LCOV - code coverage report
Current view: top level - gcc - tree-vrp.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2204 2295 96.0 %
Date: 2020-04-04 11:58:09 Functions: 93 107 86.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Support routines for Value Range Propagation (VRP).
       2                 :            :    Copyright (C) 2005-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Diego Novillo <dnovillo@redhat.com>.
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify
       8                 :            : it under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful,
      13                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            : GNU General Public License for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "backend.h"
      25                 :            : #include "insn-codes.h"
      26                 :            : #include "rtl.h"
      27                 :            : #include "tree.h"
      28                 :            : #include "gimple.h"
      29                 :            : #include "cfghooks.h"
      30                 :            : #include "tree-pass.h"
      31                 :            : #include "ssa.h"
      32                 :            : #include "optabs-tree.h"
      33                 :            : #include "gimple-pretty-print.h"
      34                 :            : #include "diagnostic-core.h"
      35                 :            : #include "flags.h"
      36                 :            : #include "fold-const.h"
      37                 :            : #include "stor-layout.h"
      38                 :            : #include "calls.h"
      39                 :            : #include "cfganal.h"
      40                 :            : #include "gimple-fold.h"
      41                 :            : #include "tree-eh.h"
      42                 :            : #include "gimple-iterator.h"
      43                 :            : #include "gimple-walk.h"
      44                 :            : #include "tree-cfg.h"
      45                 :            : #include "tree-dfa.h"
      46                 :            : #include "tree-ssa-loop-manip.h"
      47                 :            : #include "tree-ssa-loop-niter.h"
      48                 :            : #include "tree-ssa-loop.h"
      49                 :            : #include "tree-into-ssa.h"
      50                 :            : #include "tree-ssa.h"
      51                 :            : #include "intl.h"
      52                 :            : #include "cfgloop.h"
      53                 :            : #include "tree-scalar-evolution.h"
      54                 :            : #include "tree-ssa-propagate.h"
      55                 :            : #include "tree-chrec.h"
      56                 :            : #include "tree-ssa-threadupdate.h"
      57                 :            : #include "tree-ssa-scopedtables.h"
      58                 :            : #include "tree-ssa-threadedge.h"
      59                 :            : #include "omp-general.h"
      60                 :            : #include "target.h"
      61                 :            : #include "case-cfn-macros.h"
      62                 :            : #include "alloc-pool.h"
      63                 :            : #include "domwalk.h"
      64                 :            : #include "tree-cfgcleanup.h"
      65                 :            : #include "stringpool.h"
      66                 :            : #include "attribs.h"
      67                 :            : #include "vr-values.h"
      68                 :            : #include "builtins.h"
      69                 :            : #include "range-op.h"
      70                 :            : 
      71                 :            : /* Set of SSA names found live during the RPO traversal of the function
      72                 :            :    for still active basic-blocks.  */
      73                 :            : static sbitmap *live;
      74                 :            : 
      75                 :            : void
      76                 :  403291000 : value_range_equiv::set_equiv (bitmap equiv)
      77                 :            : {
      78                 :  403291000 :   if (undefined_p () || varying_p ())
      79                 :            :     equiv = NULL;
      80                 :            :   /* Since updating the equivalence set involves deep copying the
      81                 :            :      bitmaps, only do it if absolutely necessary.
      82                 :            : 
      83                 :            :      All equivalence bitmaps are allocated from the same obstack.  So
      84                 :            :      we can use the obstack associated with EQUIV to allocate vr->equiv.  */
      85                 :  403291000 :   if (m_equiv == NULL
      86                 :  305982000 :       && equiv != NULL)
      87                 :    8282800 :     m_equiv = BITMAP_ALLOC (equiv->obstack);
      88                 :            : 
      89                 :  403291000 :   if (equiv != m_equiv)
      90                 :            :     {
      91                 :   10499900 :       if (equiv && !bitmap_empty_p (equiv))
      92                 :    9249150 :         bitmap_copy (m_equiv, equiv);
      93                 :            :       else
      94                 :    1250780 :         bitmap_clear (m_equiv);
      95                 :            :     }
      96                 :  403291000 : }
      97                 :            : 
      98                 :            : /* Initialize value_range.  */
      99                 :            : 
     100                 :            : void
     101                 :  403291000 : value_range_equiv::set (tree min, tree max, bitmap equiv,
     102                 :            :                         value_range_kind kind)
     103                 :            : {
     104                 :  403291000 :   value_range::set (min, max, kind);
     105                 :  403291000 :   set_equiv (equiv);
     106                 :  403291000 :   if (flag_checking)
     107                 :  403287000 :     check ();
     108                 :  403291000 : }
     109                 :            : 
     110                 :          0 : value_range_equiv::value_range_equiv (tree min, tree max, bitmap equiv,
     111                 :          0 :                                       value_range_kind kind)
     112                 :            : {
     113                 :          0 :   m_equiv = NULL;
     114                 :          0 :   set (min, max, equiv, kind);
     115                 :          0 : }
     116                 :            : 
     117                 :          0 : value_range_equiv::value_range_equiv (const value_range &other)
     118                 :            : {
     119                 :          0 :   m_equiv = NULL;
     120                 :          0 :   set (other.min(), other.max (), NULL, other.kind ());
     121                 :          0 : }
     122                 :            : 
     123                 :            : /* Like set, but keep the equivalences in place.  */
     124                 :            : 
     125                 :            : void
     126                 :  108155000 : value_range_equiv::update (tree min, tree max, value_range_kind kind)
     127                 :            : {
     128                 :  108155000 :   set (min, max,
     129                 :            :        (kind != VR_UNDEFINED && kind != VR_VARYING) ? m_equiv : NULL, kind);
     130                 :  108155000 : }
     131                 :            : 
     132                 :            : /* Copy value_range in FROM into THIS while avoiding bitmap sharing.
     133                 :            : 
     134                 :            :    Note: The code that avoids the bitmap sharing looks at the existing
     135                 :            :    this->m_equiv, so this function cannot be used to initalize an
     136                 :            :    object.  Use the constructors for initialization.  */
     137                 :            : 
     138                 :            : void
     139                 :   37423700 : value_range_equiv::deep_copy (const value_range_equiv *from)
     140                 :            : {
     141                 :   37423700 :   set (from->min (), from->max (), from->m_equiv, from->m_kind);
     142                 :   37423700 : }
     143                 :            : 
     144                 :            : void
     145                 :   24308400 : value_range_equiv::move (value_range_equiv *from)
     146                 :            : {
     147                 :   24308400 :   set (from->min (), from->max (), NULL, from->m_kind);
     148                 :   24308400 :   m_equiv = from->m_equiv;
     149                 :   24308400 :   from->m_equiv = NULL;
     150                 :   24308400 : }
     151                 :            : 
     152                 :            : void
     153                 :  403287000 : value_range_equiv::check ()
     154                 :            : {
     155                 :  403287000 :   value_range::check ();
     156                 :  403287000 :   switch (m_kind)
     157                 :            :     {
     158                 :  166224000 :     case VR_UNDEFINED:
     159                 :  166224000 :     case VR_VARYING:
     160                 :  166224000 :       gcc_assert (!m_equiv || bitmap_empty_p (m_equiv));
     161                 :  403287000 :     default:;
     162                 :            :     }
     163                 :  403287000 : }
     164                 :            : 
     165                 :            : /* Return true if the bitmaps B1 and B2 are equal.  */
     166                 :            : 
     167                 :            : static bool
     168                 :    1506660 : vrp_bitmap_equal_p (const_bitmap b1, const_bitmap b2)
     169                 :            : {
     170                 :    1506660 :   return (b1 == b2
     171                 :     705193 :           || ((!b1 || bitmap_empty_p (b1))
     172                 :      39731 :               && (!b2 || bitmap_empty_p (b2)))
     173                 :    2172130 :           || (b1 && b2
     174                 :     646101 :               && bitmap_equal_p (b1, b2)));
     175                 :            : }
     176                 :            : 
     177                 :            : /* Returns TRUE if THIS == OTHER.  Ignores the equivalence bitmap if
     178                 :            :    IGNORE_EQUIVS is TRUE.  */
     179                 :            : 
     180                 :            : bool
     181                 :   94740600 : value_range_equiv::equal_p (const value_range_equiv &other,
     182                 :            :                             bool ignore_equivs) const
     183                 :            : {
     184                 :   94740600 :   return (value_range::equal_p (other)
     185                 :   94740600 :           && (ignore_equivs
     186                 :    1506660 :               || vrp_bitmap_equal_p (m_equiv, other.m_equiv)));
     187                 :            : }
     188                 :            : 
     189                 :            : void
     190                 :   87817000 : value_range_equiv::set_undefined ()
     191                 :            : {
     192                 :   87817000 :   set (NULL, NULL, NULL, VR_UNDEFINED);
     193                 :   87817000 : }
     194                 :            : 
     195                 :            : void
     196                 :   91739100 : value_range_equiv::set_varying (tree type)
     197                 :            : {
     198                 :   91739100 :   value_range::set_varying (type);
     199                 :   91739100 :   equiv_clear ();
     200                 :   91739100 : }
     201                 :            : 
     202                 :            : void
     203                 :  163121000 : value_range_equiv::equiv_clear ()
     204                 :            : {
     205                 :  163121000 :   if (m_equiv)
     206                 :    9688030 :     bitmap_clear (m_equiv);
     207                 :  163121000 : }
     208                 :            : 
     209                 :            : /* Add VAR and VAR's equivalence set (VAR_VR) to the equivalence
     210                 :            :    bitmap.  If no equivalence table has been created, OBSTACK is the
     211                 :            :    obstack to use (NULL for the default obstack).
     212                 :            : 
     213                 :            :    This is the central point where equivalence processing can be
     214                 :            :    turned on/off.  */
     215                 :            : 
     216                 :            : void
     217                 :   48483900 : value_range_equiv::equiv_add (const_tree var,
     218                 :            :                               const value_range_equiv *var_vr,
     219                 :            :                               bitmap_obstack *obstack)
     220                 :            : {
     221                 :   48483900 :   if (!m_equiv)
     222                 :   46449400 :     m_equiv = BITMAP_ALLOC (obstack);
     223                 :   48483900 :   unsigned ver = SSA_NAME_VERSION (var);
     224                 :   48483900 :   bitmap_set_bit (m_equiv, ver);
     225                 :   48483900 :   if (var_vr && var_vr->m_equiv)
     226                 :   11107500 :     bitmap_ior_into (m_equiv, var_vr->m_equiv);
     227                 :   48483900 : }
     228                 :            : 
     229                 :            : void
     230                 :      23729 : value_range_equiv::dump (FILE *file) const
     231                 :            : {
     232                 :      23729 :   value_range::dump (file);
     233                 :      23729 :   if ((m_kind == VR_RANGE || m_kind == VR_ANTI_RANGE)
     234                 :      14520 :       && m_equiv)
     235                 :            :     {
     236                 :       6417 :       bitmap_iterator bi;
     237                 :       6417 :       unsigned i, c = 0;
     238                 :            : 
     239                 :       6417 :       fprintf (file, "  EQUIVALENCES: { ");
     240                 :            : 
     241                 :      13061 :       EXECUTE_IF_SET_IN_BITMAP (m_equiv, 0, i, bi)
     242                 :            :         {
     243                 :       6644 :           print_generic_expr (file, ssa_name (i));
     244                 :       6644 :           fprintf (file, " ");
     245                 :       6644 :           c++;
     246                 :            :         }
     247                 :            : 
     248                 :       6417 :       fprintf (file, "} (%u elements)", c);
     249                 :            :     }
     250                 :      23729 : }
     251                 :            : 
     252                 :            : void
     253                 :          0 : value_range_equiv::dump () const
     254                 :            : {
     255                 :          0 :   dump (stderr);
     256                 :          0 : }
     257                 :            : 
     258                 :            : void
     259                 :      24272 : dump_value_range (FILE *file, const value_range_equiv *vr)
     260                 :            : {
     261                 :      24272 :   if (!vr)
     262                 :        543 :     fprintf (file, "[]");
     263                 :            :   else
     264                 :      23729 :     vr->dump (file);
     265                 :      24272 : }
     266                 :            : 
     267                 :            : DEBUG_FUNCTION void
     268                 :          0 : debug (const value_range_equiv *vr)
     269                 :            : {
     270                 :          0 :   dump_value_range (stderr, vr);
     271                 :          0 : }
     272                 :            : 
     273                 :            : DEBUG_FUNCTION void
     274                 :          0 : debug (const value_range_equiv &vr)
     275                 :            : {
     276                 :          0 :   dump_value_range (stderr, &vr);
     277                 :          0 : }
     278                 :            : 
     279                 :            : /* Return true if the SSA name NAME is live on the edge E.  */
     280                 :            : 
     281                 :            : static bool
     282                 :   13935800 : live_on_edge (edge e, tree name)
     283                 :            : {
     284                 :   13935800 :   return (live[e->dest->index]
     285                 :   25055300 :           && bitmap_bit_p (live[e->dest->index], SSA_NAME_VERSION (name)));
     286                 :            : }
     287                 :            : 
     288                 :            : /* Location information for ASSERT_EXPRs.  Each instance of this
     289                 :            :    structure describes an ASSERT_EXPR for an SSA name.  Since a single
     290                 :            :    SSA name may have more than one assertion associated with it, these
     291                 :            :    locations are kept in a linked list attached to the corresponding
     292                 :            :    SSA name.  */
     293                 :            : struct assert_locus
     294                 :            : {
     295                 :            :   /* Basic block where the assertion would be inserted.  */
     296                 :            :   basic_block bb;
     297                 :            : 
     298                 :            :   /* Some assertions need to be inserted on an edge (e.g., assertions
     299                 :            :      generated by COND_EXPRs).  In those cases, BB will be NULL.  */
     300                 :            :   edge e;
     301                 :            : 
     302                 :            :   /* Pointer to the statement that generated this assertion.  */
     303                 :            :   gimple_stmt_iterator si;
     304                 :            : 
     305                 :            :   /* Predicate code for the ASSERT_EXPR.  Must be COMPARISON_CLASS_P.  */
     306                 :            :   enum tree_code comp_code;
     307                 :            : 
     308                 :            :   /* Value being compared against.  */
     309                 :            :   tree val;
     310                 :            : 
     311                 :            :   /* Expression to compare.  */
     312                 :            :   tree expr;
     313                 :            : 
     314                 :            :   /* Next node in the linked list.  */
     315                 :            :   assert_locus *next;
     316                 :            : };
     317                 :            : 
     318                 :            : /* If bit I is present, it means that SSA name N_i has a list of
     319                 :            :    assertions that should be inserted in the IL.  */
     320                 :            : static bitmap need_assert_for;
     321                 :            : 
     322                 :            : /* Array of locations lists where to insert assertions.  ASSERTS_FOR[I]
     323                 :            :    holds a list of ASSERT_LOCUS_T nodes that describe where
     324                 :            :    ASSERT_EXPRs for SSA name N_I should be inserted.  */
     325                 :            : static assert_locus **asserts_for;
     326                 :            : 
     327                 :            : /* VR_TYPE describes a range with mininum value *MIN and maximum
     328                 :            :    value *MAX.  Restrict the range to the set of values that have
     329                 :            :    no bits set outside NONZERO_BITS.  Update *MIN and *MAX and
     330                 :            :    return the new range type.
     331                 :            : 
     332                 :            :    SGN gives the sign of the values described by the range.  */
     333                 :            : 
     334                 :            : enum value_range_kind
     335                 :     647067 : intersect_range_with_nonzero_bits (enum value_range_kind vr_type,
     336                 :            :                                    wide_int *min, wide_int *max,
     337                 :            :                                    const wide_int &nonzero_bits,
     338                 :            :                                    signop sgn)
     339                 :            : {
     340                 :     647067 :   if (vr_type == VR_ANTI_RANGE)
     341                 :            :     {
     342                 :            :       /* The VR_ANTI_RANGE is equivalent to the union of the ranges
     343                 :            :          A: [-INF, *MIN) and B: (*MAX, +INF].  First use NONZERO_BITS
     344                 :            :          to create an inclusive upper bound for A and an inclusive lower
     345                 :            :          bound for B.  */
     346                 :      29922 :       wide_int a_max = wi::round_down_for_mask (*min - 1, nonzero_bits);
     347                 :      29922 :       wide_int b_min = wi::round_up_for_mask (*max + 1, nonzero_bits);
     348                 :            : 
     349                 :            :       /* If the calculation of A_MAX wrapped, A is effectively empty
     350                 :            :          and A_MAX is the highest value that satisfies NONZERO_BITS.
     351                 :            :          Likewise if the calculation of B_MIN wrapped, B is effectively
     352                 :            :          empty and B_MIN is the lowest value that satisfies NONZERO_BITS.  */
     353                 :      29922 :       bool a_empty = wi::ge_p (a_max, *min, sgn);
     354                 :      29922 :       bool b_empty = wi::le_p (b_min, *max, sgn);
     355                 :            : 
     356                 :            :       /* If both A and B are empty, there are no valid values.  */
     357                 :      29922 :       if (a_empty && b_empty)
     358                 :        135 :         return VR_UNDEFINED;
     359                 :            : 
     360                 :            :       /* If exactly one of A or B is empty, return a VR_RANGE for the
     361                 :            :          other one.  */
     362                 :      29922 :       if (a_empty || b_empty)
     363                 :            :         {
     364                 :        135 :           *min = b_min;
     365                 :        135 :           *max = a_max;
     366                 :        135 :           gcc_checking_assert (wi::le_p (*min, *max, sgn));
     367                 :            :           return VR_RANGE;
     368                 :            :         }
     369                 :            : 
     370                 :            :       /* Update the VR_ANTI_RANGE bounds.  */
     371                 :      29787 :       *min = a_max + 1;
     372                 :      29787 :       *max = b_min - 1;
     373                 :      29787 :       gcc_checking_assert (wi::le_p (*min, *max, sgn));
     374                 :            : 
     375                 :            :       /* Now check whether the excluded range includes any values that
     376                 :            :          satisfy NONZERO_BITS.  If not, switch to a full VR_RANGE.  */
     377                 :      29787 :       if (wi::round_up_for_mask (*min, nonzero_bits) == b_min)
     378                 :            :         {
     379                 :       2047 :           unsigned int precision = min->get_precision ();
     380                 :       2047 :           *min = wi::min_value (precision, sgn);
     381                 :       2047 :           *max = wi::max_value (precision, sgn);
     382                 :       2047 :           vr_type = VR_RANGE;
     383                 :            :         }
     384                 :            :     }
     385                 :     646932 :   if (vr_type == VR_RANGE)
     386                 :            :     {
     387                 :     283687 :       *max = wi::round_down_for_mask (*max, nonzero_bits);
     388                 :            : 
     389                 :            :       /* Check that the range contains at least one valid value.  */
     390                 :     283687 :       if (wi::gt_p (*min, *max, sgn))
     391                 :            :         return VR_UNDEFINED;
     392                 :            : 
     393                 :     283687 :       *min = wi::round_up_for_mask (*min, nonzero_bits);
     394                 :     283687 :       gcc_checking_assert (wi::le_p (*min, *max, sgn));
     395                 :            :     }
     396                 :            :   return vr_type;
     397                 :            : }
     398                 :            : 
     399                 :            : void
     400                 :   46253000 : value_range_equiv::set (tree val)
     401                 :            : {
     402                 :   46253000 :   gcc_assert (TREE_CODE (val) == SSA_NAME || is_gimple_min_invariant (val));
     403                 :   46253000 :   if (TREE_OVERFLOW_P (val))
     404                 :          8 :     val = drop_tree_overflow (val);
     405                 :   46253000 :   set (val, val);
     406                 :   46253000 : }
     407                 :            : 
     408                 :            : /* Return true if max and min of VR are INTEGER_CST.  It's not necessary
     409                 :            :    a singleton.  */
     410                 :            : 
     411                 :            : bool
     412                 :    2600380 : range_int_cst_p (const value_range *vr)
     413                 :            : {
     414                 :    2600380 :   return (vr->kind () == VR_RANGE && range_has_numeric_bounds_p (vr));
     415                 :            : }
     416                 :            : 
     417                 :            : /* Return the single symbol (an SSA_NAME) contained in T if any, or NULL_TREE
     418                 :            :    otherwise.  We only handle additive operations and set NEG to true if the
     419                 :            :    symbol is negated and INV to the invariant part, if any.  */
     420                 :            : 
     421                 :            : tree
     422                 : 2109980000 : get_single_symbol (tree t, bool *neg, tree *inv)
     423                 :            : {
     424                 : 2109980000 :   bool neg_;
     425                 : 2109980000 :   tree inv_;
     426                 :            : 
     427                 : 2109980000 :   *inv = NULL_TREE;
     428                 : 2109980000 :   *neg = false;
     429                 :            : 
     430                 : 2109980000 :   if (TREE_CODE (t) == PLUS_EXPR
     431                 : 2109980000 :       || TREE_CODE (t) == POINTER_PLUS_EXPR
     432                 : 2097060000 :       || TREE_CODE (t) == MINUS_EXPR)
     433                 :            :     {
     434                 :   12913600 :       if (is_gimple_min_invariant (TREE_OPERAND (t, 0)))
     435                 :            :         {
     436                 :         18 :           neg_ = (TREE_CODE (t) == MINUS_EXPR);
     437                 :         18 :           inv_ = TREE_OPERAND (t, 0);
     438                 :         18 :           t = TREE_OPERAND (t, 1);
     439                 :            :         }
     440                 :   12913600 :       else if (is_gimple_min_invariant (TREE_OPERAND (t, 1)))
     441                 :            :         {
     442                 :   12913600 :           neg_ = false;
     443                 :   12913600 :           inv_ = TREE_OPERAND (t, 1);
     444                 :   12913600 :           t = TREE_OPERAND (t, 0);
     445                 :            :         }
     446                 :            :       else
     447                 :            :         return NULL_TREE;
     448                 :            :     }
     449                 :            :   else
     450                 :            :     {
     451                 :            :       neg_ = false;
     452                 :            :       inv_ = NULL_TREE;
     453                 :            :     }
     454                 :            : 
     455                 : 2109980000 :   if (TREE_CODE (t) == NEGATE_EXPR)
     456                 :            :     {
     457                 :      49803 :       t = TREE_OPERAND (t, 0);
     458                 :      49803 :       neg_ = !neg_;
     459                 :            :     }
     460                 :            : 
     461                 : 2109980000 :   if (TREE_CODE (t) != SSA_NAME)
     462                 :            :     return NULL_TREE;
     463                 :            : 
     464                 :  716780000 :   if (inv_ && TREE_OVERFLOW_P (inv_))
     465                 :          0 :     inv_ = drop_tree_overflow (inv_);
     466                 :            : 
     467                 :  716780000 :   *neg = neg_;
     468                 :  716780000 :   *inv = inv_;
     469                 :  716780000 :   return t;
     470                 :            : }
     471                 :            : 
     472                 :            : /* The reverse operation: build a symbolic expression with TYPE
     473                 :            :    from symbol SYM, negated according to NEG, and invariant INV.  */
     474                 :            : 
     475                 :            : static tree
     476                 :     567292 : build_symbolic_expr (tree type, tree sym, bool neg, tree inv)
     477                 :            : {
     478                 :     567292 :   const bool pointer_p = POINTER_TYPE_P (type);
     479                 :     567292 :   tree t = sym;
     480                 :            : 
     481                 :     567292 :   if (neg)
     482                 :      26400 :     t = build1 (NEGATE_EXPR, type, t);
     483                 :            : 
     484                 :     567292 :   if (integer_zerop (inv))
     485                 :            :     return t;
     486                 :            : 
     487                 :     875546 :   return build2 (pointer_p ? POINTER_PLUS_EXPR : PLUS_EXPR, type, t, inv);
     488                 :            : }
     489                 :            : 
     490                 :            : /* Return
     491                 :            :    1 if VAL < VAL2
     492                 :            :    0 if !(VAL < VAL2)
     493                 :            :    -2 if those are incomparable.  */
     494                 :            : int
     495                 :  124412000 : operand_less_p (tree val, tree val2)
     496                 :            : {
     497                 :            :   /* LT is folded faster than GE and others.  Inline the common case.  */
     498                 :  124412000 :   if (TREE_CODE (val) == INTEGER_CST && TREE_CODE (val2) == INTEGER_CST)
     499                 :   78946100 :     return tree_int_cst_lt (val, val2);
     500                 :   45465500 :   else if (TREE_CODE (val) == SSA_NAME && TREE_CODE (val2) == SSA_NAME)
     501                 :   13587300 :     return val == val2 ? 0 : -2;
     502                 :            :   else
     503                 :            :     {
     504                 :   38577400 :       int cmp = compare_values (val, val2);
     505                 :   38577400 :       if (cmp == -1)
     506                 :            :         return 1;
     507                 :   37443700 :       else if (cmp == 0 || cmp == 1)
     508                 :            :         return 0;
     509                 :            :       else
     510                 :   37095600 :         return -2;
     511                 :            :     }
     512                 :            : 
     513                 :            :   return 0;
     514                 :            : }
     515                 :            : 
     516                 :            : /* Compare two values VAL1 and VAL2.  Return
     517                 :            : 
     518                 :            :         -2 if VAL1 and VAL2 cannot be compared at compile-time,
     519                 :            :         -1 if VAL1 < VAL2,
     520                 :            :          0 if VAL1 == VAL2,
     521                 :            :         +1 if VAL1 > VAL2, and
     522                 :            :         +2 if VAL1 != VAL2
     523                 :            : 
     524                 :            :    This is similar to tree_int_cst_compare but supports pointer values
     525                 :            :    and values that cannot be compared at compile time.
     526                 :            : 
     527                 :            :    If STRICT_OVERFLOW_P is not NULL, then set *STRICT_OVERFLOW_P to
     528                 :            :    true if the return value is only valid if we assume that signed
     529                 :            :    overflow is undefined.  */
     530                 :            : 
     531                 :            : int
     532                 : 1266600000 : compare_values_warnv (tree val1, tree val2, bool *strict_overflow_p)
     533                 :            : {
     534                 : 1266600000 :   if (val1 == val2)
     535                 :            :     return 0;
     536                 :            : 
     537                 :            :   /* Below we rely on the fact that VAL1 and VAL2 are both pointers or
     538                 :            :      both integers.  */
     539                 : 1080740000 :   gcc_assert (POINTER_TYPE_P (TREE_TYPE (val1))
     540                 :            :               == POINTER_TYPE_P (TREE_TYPE (val2)));
     541                 :            : 
     542                 :            :   /* Convert the two values into the same type.  This is needed because
     543                 :            :      sizetype causes sign extension even for unsigned types.  */
     544                 : 1054130000 :   if (!useless_type_conversion_p (TREE_TYPE (val1), TREE_TYPE (val2)))
     545                 :      15948 :     val2 = fold_convert (TREE_TYPE (val1), val2);
     546                 :            : 
     547                 : 1054130000 :   const bool overflow_undefined
     548                 : 1050720000 :     = INTEGRAL_TYPE_P (TREE_TYPE (val1))
     549                 : 1929670000 :       && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (val1));
     550                 : 1054130000 :   tree inv1, inv2;
     551                 : 1054130000 :   bool neg1, neg2;
     552                 : 1054130000 :   tree sym1 = get_single_symbol (val1, &neg1, &inv1);
     553                 : 1054130000 :   tree sym2 = get_single_symbol (val2, &neg2, &inv2);
     554                 :            : 
     555                 :            :   /* If VAL1 and VAL2 are of the form '[-]NAME [+ CST]', return -1 or +1
     556                 :            :      accordingly.  If VAL1 and VAL2 don't use the same name, return -2.  */
     557                 : 1054130000 :   if (sym1 && sym2)
     558                 :            :     {
     559                 :            :       /* Both values must use the same name with the same sign.  */
     560                 :  162218000 :       if (sym1 != sym2 || neg1 != neg2)
     561                 :            :         return -2;
     562                 :            : 
     563                 :            :       /* [-]NAME + CST == [-]NAME + CST.  */
     564                 :     728038 :       if (inv1 == inv2)
     565                 :            :         return 0;
     566                 :            : 
     567                 :            :       /* If overflow is defined we cannot simplify more.  */
     568                 :     287430 :       if (!overflow_undefined)
     569                 :            :         return -2;
     570                 :            : 
     571                 :     165768 :       if (strict_overflow_p != NULL
     572                 :            :           /* Symbolic range building sets TREE_NO_WARNING to declare
     573                 :            :              that overflow doesn't happen.  */
     574                 :     165768 :           && (!inv1 || !TREE_NO_WARNING (val1))
     575                 :     158263 :           && (!inv2 || !TREE_NO_WARNING (val2)))
     576                 :     149733 :         *strict_overflow_p = true;
     577                 :            : 
     578                 :     165768 :       if (!inv1)
     579                 :      30670 :         inv1 = build_int_cst (TREE_TYPE (val1), 0);
     580                 :     165768 :       if (!inv2)
     581                 :      43103 :         inv2 = build_int_cst (TREE_TYPE (val2), 0);
     582                 :            : 
     583                 :     331536 :       return wi::cmp (wi::to_wide (inv1), wi::to_wide (inv2),
     584                 :     165768 :                       TYPE_SIGN (TREE_TYPE (val1)));
     585                 :            :     }
     586                 :            : 
     587                 :  891912000 :   const bool cst1 = is_gimple_min_invariant (val1);
     588                 :  891912000 :   const bool cst2 = is_gimple_min_invariant (val2);
     589                 :            : 
     590                 :            :   /* If one is of the form '[-]NAME + CST' and the other is constant, then
     591                 :            :      it might be possible to say something depending on the constants.  */
     592                 :  891912000 :   if ((sym1 && inv1 && cst2) || (sym2 && inv2 && cst1))
     593                 :            :     {
     594                 :    9508900 :       if (!overflow_undefined)
     595                 :            :         return -2;
     596                 :            : 
     597                 :    3380440 :       if (strict_overflow_p != NULL
     598                 :            :           /* Symbolic range building sets TREE_NO_WARNING to declare
     599                 :            :              that overflow doesn't happen.  */
     600                 :    3380440 :           && (!sym1 || !TREE_NO_WARNING (val1))
     601                 :    1749260 :           && (!sym2 || !TREE_NO_WARNING (val2)))
     602                 :     216503 :         *strict_overflow_p = true;
     603                 :            : 
     604                 :    3380440 :       const signop sgn = TYPE_SIGN (TREE_TYPE (val1));
     605                 :    3380440 :       tree cst = cst1 ? val1 : val2;
     606                 :    3380440 :       tree inv = cst1 ? inv2 : inv1;
     607                 :            : 
     608                 :            :       /* Compute the difference between the constants.  If it overflows or
     609                 :            :          underflows, this means that we can trivially compare the NAME with
     610                 :            :          it and, consequently, the two values with each other.  */
     611                 :    3380440 :       wide_int diff = wi::to_wide (cst) - wi::to_wide (inv);
     612                 :    3380440 :       if (wi::cmp (0, wi::to_wide (inv), sgn)
     613                 :    3380440 :           != wi::cmp (diff, wi::to_wide (cst), sgn))
     614                 :            :         {
     615                 :     411832 :           const int res = wi::cmp (wi::to_wide (cst), wi::to_wide (inv), sgn);
     616                 :     411832 :           return cst1 ? res : -res;
     617                 :            :         }
     618                 :            : 
     619                 :            :       return -2;
     620                 :            :     }
     621                 :            : 
     622                 :            :   /* We cannot say anything more for non-constants.  */
     623                 :  882404000 :   if (!cst1 || !cst2)
     624                 :            :     return -2;
     625                 :            : 
     626                 :  501285000 :   if (!POINTER_TYPE_P (TREE_TYPE (val1)))
     627                 :            :     {
     628                 :            :       /* We cannot compare overflowed values.  */
     629                 :  704886000 :       if (TREE_OVERFLOW (val1) || TREE_OVERFLOW (val2))
     630                 :            :         return -2;
     631                 :            : 
     632                 :  352428000 :       if (TREE_CODE (val1) == INTEGER_CST
     633                 :  352428000 :           && TREE_CODE (val2) == INTEGER_CST)
     634                 :  352428000 :         return tree_int_cst_compare (val1, val2);
     635                 :            : 
     636                 :          0 :       if (poly_int_tree_p (val1) && poly_int_tree_p (val2))
     637                 :            :         {
     638                 :          0 :           if (known_eq (wi::to_poly_widest (val1),
     639                 :            :                         wi::to_poly_widest (val2)))
     640                 :            :             return 0;
     641                 :          0 :           if (known_lt (wi::to_poly_widest (val1),
     642                 :            :                         wi::to_poly_widest (val2)))
     643                 :            :             return -1;
     644                 :          0 :           if (known_gt (wi::to_poly_widest (val1),
     645                 :            :                         wi::to_poly_widest (val2)))
     646                 :            :             return 1;
     647                 :            :         }
     648                 :            : 
     649                 :          0 :       return -2;
     650                 :            :     }
     651                 :            :   else
     652                 :            :     {
     653                 :  148842000 :       if (TREE_CODE (val1) == INTEGER_CST && TREE_CODE (val2) == INTEGER_CST)
     654                 :            :         {
     655                 :            :           /* We cannot compare overflowed values.  */
     656                 :  289171000 :           if (TREE_OVERFLOW (val1) || TREE_OVERFLOW (val2))
     657                 :            :             return -2;
     658                 :            : 
     659                 :  144586000 :           return tree_int_cst_compare (val1, val2);
     660                 :            :         }
     661                 :            : 
     662                 :            :       /* First see if VAL1 and VAL2 are not the same.  */
     663                 :    4256020 :       if (operand_equal_p (val1, val2, 0))
     664                 :            :         return 0;
     665                 :            : 
     666                 :    4227470 :       fold_defer_overflow_warnings ();
     667                 :            : 
     668                 :            :       /* If VAL1 is a lower address than VAL2, return -1.  */
     669                 :    4227470 :       tree t = fold_binary_to_constant (LT_EXPR, boolean_type_node, val1, val2);
     670                 :    4227470 :       if (t && integer_onep (t))
     671                 :            :         {
     672                 :    1156940 :           fold_undefer_and_ignore_overflow_warnings ();
     673                 :    1156940 :           return -1;
     674                 :            :         }
     675                 :            : 
     676                 :            :       /* If VAL1 is a higher address than VAL2, return +1.  */
     677                 :    3070530 :       t = fold_binary_to_constant (LT_EXPR, boolean_type_node, val2, val1);
     678                 :    3070530 :       if (t && integer_onep (t))
     679                 :            :         {
     680                 :     143664 :           fold_undefer_and_ignore_overflow_warnings ();
     681                 :     143664 :           return 1;
     682                 :            :         }
     683                 :            : 
     684                 :            :       /* If VAL1 is different than VAL2, return +2.  */
     685                 :    2926870 :       t = fold_binary_to_constant (NE_EXPR, boolean_type_node, val1, val2);
     686                 :    2926870 :       fold_undefer_and_ignore_overflow_warnings ();
     687                 :    2926870 :       if (t && integer_onep (t))
     688                 :            :         return 2;
     689                 :            : 
     690                 :    2632220 :       return -2;
     691                 :            :     }
     692                 :            : }
     693                 :            : 
     694                 :            : /* Compare values like compare_values_warnv.  */
     695                 :            : 
     696                 :            : int
     697                 :  586820000 : compare_values (tree val1, tree val2)
     698                 :            : {
     699                 :  586820000 :   bool sop;
     700                 :  586820000 :   return compare_values_warnv (val1, val2, &sop);
     701                 :            : }
     702                 :            : 
     703                 :            : /* If BOUND will include a symbolic bound, adjust it accordingly,
     704                 :            :    otherwise leave it as is.
     705                 :            : 
     706                 :            :    CODE is the original operation that combined the bounds (PLUS_EXPR
     707                 :            :    or MINUS_EXPR).
     708                 :            : 
     709                 :            :    TYPE is the type of the original operation.
     710                 :            : 
     711                 :            :    SYM_OPn is the symbolic for OPn if it has a symbolic.
     712                 :            : 
     713                 :            :    NEG_OPn is TRUE if the OPn was negated.  */
     714                 :            : 
     715                 :            : static void
     716                 :     795572 : adjust_symbolic_bound (tree &bound, enum tree_code code, tree type,
     717                 :            :                        tree sym_op0, tree sym_op1,
     718                 :            :                        bool neg_op0, bool neg_op1)
     719                 :            : {
     720                 :     795572 :   bool minus_p = (code == MINUS_EXPR);
     721                 :            :   /* If the result bound is constant, we're done; otherwise, build the
     722                 :            :      symbolic lower bound.  */
     723                 :     795572 :   if (sym_op0 == sym_op1)
     724                 :            :     ;
     725                 :     573099 :   else if (sym_op0)
     726                 :     458967 :     bound = build_symbolic_expr (type, sym_op0,
     727                 :            :                                  neg_op0, bound);
     728                 :     114132 :   else if (sym_op1)
     729                 :            :     {
     730                 :            :       /* We may not negate if that might introduce
     731                 :            :          undefined overflow.  */
     732                 :     114132 :       if (!minus_p
     733                 :     114132 :           || neg_op1
     734                 :     119939 :           || TYPE_OVERFLOW_WRAPS (type))
     735                 :     108325 :         bound = build_symbolic_expr (type, sym_op1,
     736                 :            :                                      neg_op1 ^ minus_p, bound);
     737                 :            :       else
     738                 :       5807 :         bound = NULL_TREE;
     739                 :            :     }
     740                 :     795572 : }
     741                 :            : 
     742                 :            : /* Combine OP1 and OP1, which are two parts of a bound, into one wide
     743                 :            :    int bound according to CODE.  CODE is the operation combining the
     744                 :            :    bound (either a PLUS_EXPR or a MINUS_EXPR).
     745                 :            : 
     746                 :            :    TYPE is the type of the combine operation.
     747                 :            : 
     748                 :            :    WI is the wide int to store the result.
     749                 :            : 
     750                 :            :    OVF is -1 if an underflow occurred, +1 if an overflow occurred or 0
     751                 :            :    if over/underflow occurred.  */
     752                 :            : 
     753                 :            : static void
     754                 :    1650420 : combine_bound (enum tree_code code, wide_int &wi, wi::overflow_type &ovf,
     755                 :            :                tree type, tree op0, tree op1)
     756                 :            : {
     757                 :    1650420 :   bool minus_p = (code == MINUS_EXPR);
     758                 :    1650420 :   const signop sgn = TYPE_SIGN (type);
     759                 :    1650420 :   const unsigned int prec = TYPE_PRECISION (type);
     760                 :            : 
     761                 :            :   /* Combine the bounds, if any.  */
     762                 :    1650420 :   if (op0 && op1)
     763                 :            :     {
     764                 :     838277 :       if (minus_p)
     765                 :     272047 :         wi = wi::sub (wi::to_wide (op0), wi::to_wide (op1), sgn, &ovf);
     766                 :            :       else
     767                 :     566230 :         wi = wi::add (wi::to_wide (op0), wi::to_wide (op1), sgn, &ovf);
     768                 :            :     }
     769                 :     812145 :   else if (op0)
     770                 :     199678 :     wi = wi::to_wide (op0);
     771                 :     612467 :   else if (op1)
     772                 :            :     {
     773                 :     550641 :       if (minus_p)
     774                 :      98640 :         wi = wi::neg (wi::to_wide (op1), &ovf);
     775                 :            :       else
     776                 :     452001 :         wi = wi::to_wide (op1);
     777                 :            :     }
     778                 :            :   else
     779                 :      61826 :     wi = wi::shwi (0, prec);
     780                 :    1650420 : }
     781                 :            : 
     782                 :            : /* Given a range in [WMIN, WMAX], adjust it for possible overflow and
     783                 :            :    put the result in VR.
     784                 :            : 
     785                 :            :    TYPE is the type of the range.
     786                 :            : 
     787                 :            :    MIN_OVF and MAX_OVF indicate what type of overflow, if any,
     788                 :            :    occurred while originally calculating WMIN or WMAX.  -1 indicates
     789                 :            :    underflow.  +1 indicates overflow.  0 indicates neither.  */
     790                 :            : 
     791                 :            : static void
     792                 :     443087 : set_value_range_with_overflow (value_range_kind &kind, tree &min, tree &max,
     793                 :            :                                tree type,
     794                 :            :                                const wide_int &wmin, const wide_int &wmax,
     795                 :            :                                wi::overflow_type min_ovf,
     796                 :            :                                wi::overflow_type max_ovf)
     797                 :            : {
     798                 :     443087 :   const signop sgn = TYPE_SIGN (type);
     799                 :     443087 :   const unsigned int prec = TYPE_PRECISION (type);
     800                 :            : 
     801                 :            :   /* For one bit precision if max < min, then the swapped
     802                 :            :      range covers all values.  */
     803                 :     443087 :   if (prec == 1 && wi::lt_p (wmax, wmin, sgn))
     804                 :            :     {
     805                 :          0 :       kind = VR_VARYING;
     806                 :          0 :       return;
     807                 :            :     }
     808                 :            : 
     809                 :     594771 :   if (TYPE_OVERFLOW_WRAPS (type))
     810                 :            :     {
     811                 :            :       /* If overflow wraps, truncate the values and adjust the
     812                 :            :          range kind and bounds appropriately.  */
     813                 :     291403 :       wide_int tmin = wide_int::from (wmin, prec, sgn);
     814                 :     291403 :       wide_int tmax = wide_int::from (wmax, prec, sgn);
     815                 :     291403 :       if ((min_ovf != wi::OVF_NONE) == (max_ovf != wi::OVF_NONE))
     816                 :            :         {
     817                 :            :           /* If the limits are swapped, we wrapped around and cover
     818                 :            :              the entire range.  */
     819                 :     243923 :           if (wi::gt_p (tmin, tmax, sgn))
     820                 :       1781 :             kind = VR_VARYING;
     821                 :            :           else
     822                 :            :             {
     823                 :     242142 :               kind = VR_RANGE;
     824                 :            :               /* No overflow or both overflow or underflow.  The
     825                 :            :                  range kind stays VR_RANGE.  */
     826                 :     242142 :               min = wide_int_to_tree (type, tmin);
     827                 :     242142 :               max = wide_int_to_tree (type, tmax);
     828                 :            :             }
     829                 :     243923 :           return;
     830                 :            :         }
     831                 :      47480 :       else if ((min_ovf == wi::OVF_UNDERFLOW && max_ovf == wi::OVF_NONE)
     832                 :      45297 :                || (max_ovf == wi::OVF_OVERFLOW && min_ovf == wi::OVF_NONE))
     833                 :            :         {
     834                 :            :           /* Min underflow or max overflow.  The range kind
     835                 :            :              changes to VR_ANTI_RANGE.  */
     836                 :      47480 :           bool covers = false;
     837                 :      47480 :           wide_int tem = tmin;
     838                 :      47480 :           tmin = tmax + 1;
     839                 :      47480 :           if (wi::cmp (tmin, tmax, sgn) < 0)
     840                 :        387 :             covers = true;
     841                 :      47480 :           tmax = tem - 1;
     842                 :      47480 :           if (wi::cmp (tmax, tem, sgn) > 0)
     843                 :            :             covers = true;
     844                 :            :           /* If the anti-range would cover nothing, drop to varying.
     845                 :            :              Likewise if the anti-range bounds are outside of the
     846                 :            :              types values.  */
     847                 :      47480 :           if (covers || wi::cmp (tmin, tmax, sgn) > 0)
     848                 :            :             {
     849                 :      43520 :               kind = VR_VARYING;
     850                 :      43520 :               return;
     851                 :            :             }
     852                 :       3960 :           kind = VR_ANTI_RANGE;
     853                 :       3960 :           min = wide_int_to_tree (type, tmin);
     854                 :       3960 :           max = wide_int_to_tree (type, tmax);
     855                 :       3960 :           return;
     856                 :            :         }
     857                 :            :       else
     858                 :            :         {
     859                 :            :           /* Other underflow and/or overflow, drop to VR_VARYING.  */
     860                 :          0 :           kind = VR_VARYING;
     861                 :          0 :           return;
     862                 :            :         }
     863                 :            :     }
     864                 :            :   else
     865                 :            :     {
     866                 :            :       /* If overflow does not wrap, saturate to the types min/max
     867                 :            :          value.  */
     868                 :     151684 :       wide_int type_min = wi::min_value (prec, sgn);
     869                 :     151684 :       wide_int type_max = wi::max_value (prec, sgn);
     870                 :     151684 :       kind = VR_RANGE;
     871                 :     151684 :       if (min_ovf == wi::OVF_UNDERFLOW)
     872                 :        412 :         min = wide_int_to_tree (type, type_min);
     873                 :     151272 :       else if (min_ovf == wi::OVF_OVERFLOW)
     874                 :          0 :         min = wide_int_to_tree (type, type_max);
     875                 :            :       else
     876                 :     151272 :         min = wide_int_to_tree (type, wmin);
     877                 :            : 
     878                 :     151684 :       if (max_ovf == wi::OVF_UNDERFLOW)
     879                 :          0 :         max = wide_int_to_tree (type, type_min);
     880                 :     151684 :       else if (max_ovf == wi::OVF_OVERFLOW)
     881                 :      14025 :         max = wide_int_to_tree (type, type_max);
     882                 :            :       else
     883                 :     137659 :         max = wide_int_to_tree (type, wmax);
     884                 :            :     }
     885                 :            : }
     886                 :            : 
     887                 :            : /* Fold two value range's of a POINTER_PLUS_EXPR into VR.  */
     888                 :            : 
     889                 :            : static void
     890                 :     187228 : extract_range_from_pointer_plus_expr (value_range *vr,
     891                 :            :                                       enum tree_code code,
     892                 :            :                                       tree expr_type,
     893                 :            :                                       const value_range *vr0,
     894                 :            :                                       const value_range *vr1)
     895                 :            : {
     896                 :     187228 :   gcc_checking_assert (POINTER_TYPE_P (expr_type)
     897                 :            :                        && code == POINTER_PLUS_EXPR);
     898                 :            :   /* For pointer types, we are really only interested in asserting
     899                 :            :      whether the expression evaluates to non-NULL.
     900                 :            :      With -fno-delete-null-pointer-checks we need to be more
     901                 :            :      conservative.  As some object might reside at address 0,
     902                 :            :      then some offset could be added to it and the same offset
     903                 :            :      subtracted again and the result would be NULL.
     904                 :            :      E.g.
     905                 :            :      static int a[12]; where &a[0] is NULL and
     906                 :            :      ptr = &a[6];
     907                 :            :      ptr -= 6;
     908                 :            :      ptr will be NULL here, even when there is POINTER_PLUS_EXPR
     909                 :            :      where the first range doesn't include zero and the second one
     910                 :            :      doesn't either.  As the second operand is sizetype (unsigned),
     911                 :            :      consider all ranges where the MSB could be set as possible
     912                 :            :      subtractions where the result might be NULL.  */
     913                 :     187228 :   if ((!range_includes_zero_p (vr0)
     914                 :     182685 :        || !range_includes_zero_p (vr1))
     915                 :     100056 :       && !TYPE_OVERFLOW_WRAPS (expr_type)
     916                 :     287266 :       && (flag_delete_null_pointer_checks
     917                 :         82 :           || (range_int_cst_p (vr1)
     918                 :         82 :               && !tree_int_cst_sign_bit (vr1->max ()))))
     919                 :     100038 :     vr->set_nonzero (expr_type);
     920                 :      87190 :   else if (vr0->zero_p () && vr1->zero_p ())
     921                 :          0 :     vr->set_zero (expr_type);
     922                 :            :   else
     923                 :      87190 :     vr->set_varying (expr_type);
     924                 :     187228 : }
     925                 :            : 
     926                 :            : /* Extract range information from a PLUS/MINUS_EXPR and store the
     927                 :            :    result in *VR.  */
     928                 :            : 
     929                 :            : static void
     930                 :     940989 : extract_range_from_plus_minus_expr (value_range *vr,
     931                 :            :                                     enum tree_code code,
     932                 :            :                                     tree expr_type,
     933                 :            :                                     const value_range *vr0_,
     934                 :            :                                     const value_range *vr1_)
     935                 :            : {
     936                 :     940989 :   gcc_checking_assert (code == PLUS_EXPR || code == MINUS_EXPR);
     937                 :            : 
     938                 :     940989 :   value_range vr0 = *vr0_, vr1 = *vr1_;
     939                 :     940989 :   value_range vrtem0, vrtem1;
     940                 :            : 
     941                 :            :   /* Now canonicalize anti-ranges to ranges when they are not symbolic
     942                 :            :      and express ~[] op X as ([]' op X) U ([]'' op X).  */
     943                 :     940989 :   if (vr0.kind () == VR_ANTI_RANGE
     944                 :     940989 :       && ranges_from_anti_range (&vr0, &vrtem0, &vrtem1))
     945                 :            :     {
     946                 :       2071 :       extract_range_from_plus_minus_expr (vr, code, expr_type, &vrtem0, vr1_);
     947                 :       2071 :       if (!vrtem1.undefined_p ())
     948                 :            :         {
     949                 :       2071 :           value_range vrres;
     950                 :       2071 :           extract_range_from_plus_minus_expr (&vrres, code, expr_type,
     951                 :            :                                               &vrtem1, vr1_);
     952                 :       2071 :           vr->union_ (&vrres);
     953                 :            :         }
     954                 :     546380 :       return;
     955                 :            :     }
     956                 :            :   /* Likewise for X op ~[].  */
     957                 :     938918 :   if (vr1.kind () == VR_ANTI_RANGE
     958                 :     938918 :       && ranges_from_anti_range (&vr1, &vrtem0, &vrtem1))
     959                 :            :     {
     960                 :       8384 :       extract_range_from_plus_minus_expr (vr, code, expr_type, vr0_, &vrtem0);
     961                 :       8384 :       if (!vrtem1.undefined_p ())
     962                 :            :         {
     963                 :       8384 :           value_range vrres;
     964                 :       8384 :           extract_range_from_plus_minus_expr (&vrres, code, expr_type,
     965                 :            :                                               vr0_, &vrtem1);
     966                 :       8384 :           vr->union_ (&vrres);
     967                 :            :         }
     968                 :       8384 :       return;
     969                 :            :     }
     970                 :            : 
     971                 :     930534 :   value_range_kind kind;
     972                 :     930534 :   value_range_kind vr0_kind = vr0.kind (), vr1_kind = vr1.kind ();
     973                 :     930534 :   tree vr0_min = vr0.min (), vr0_max = vr0.max ();
     974                 :     930534 :   tree vr1_min = vr1.min (), vr1_max = vr1.max ();
     975                 :     930534 :   tree min = NULL_TREE, max = NULL_TREE;
     976                 :            : 
     977                 :            :   /* This will normalize things such that calculating
     978                 :            :      [0,0] - VR_VARYING is not dropped to varying, but is
     979                 :            :      calculated as [MIN+1, MAX].  */
     980                 :     930534 :   if (vr0.varying_p ())
     981                 :            :     {
     982                 :     125050 :       vr0_kind = VR_RANGE;
     983                 :     125050 :       vr0_min = vrp_val_min (expr_type);
     984                 :     125050 :       vr0_max = vrp_val_max (expr_type);
     985                 :            :     }
     986                 :     930534 :   if (vr1.varying_p ())
     987                 :            :     {
     988                 :     103913 :       vr1_kind = VR_RANGE;
     989                 :     103913 :       vr1_min = vrp_val_min (expr_type);
     990                 :     103913 :       vr1_max = vrp_val_max (expr_type);
     991                 :            :     }
     992                 :            : 
     993                 :     930534 :   const bool minus_p = (code == MINUS_EXPR);
     994                 :     930534 :   tree min_op0 = vr0_min;
     995                 :     930534 :   tree min_op1 = minus_p ? vr1_max : vr1_min;
     996                 :     930534 :   tree max_op0 = vr0_max;
     997                 :     930534 :   tree max_op1 = minus_p ? vr1_min : vr1_max;
     998                 :     930534 :   tree sym_min_op0 = NULL_TREE;
     999                 :     930534 :   tree sym_min_op1 = NULL_TREE;
    1000                 :     930534 :   tree sym_max_op0 = NULL_TREE;
    1001                 :     930534 :   tree sym_max_op1 = NULL_TREE;
    1002                 :     930534 :   bool neg_min_op0, neg_min_op1, neg_max_op0, neg_max_op1;
    1003                 :            : 
    1004                 :     930534 :   neg_min_op0 = neg_min_op1 = neg_max_op0 = neg_max_op1 = false;
    1005                 :            : 
    1006                 :            :   /* If we have a PLUS or MINUS with two VR_RANGEs, either constant or
    1007                 :            :      single-symbolic ranges, try to compute the precise resulting range,
    1008                 :            :      but only if we know that this resulting range will also be constant
    1009                 :            :      or single-symbolic.  */
    1010                 :     930534 :   if (vr0_kind == VR_RANGE && vr1_kind == VR_RANGE
    1011                 :     888689 :       && (TREE_CODE (min_op0) == INTEGER_CST
    1012                 :     480855 :           || (sym_min_op0
    1013                 :     480855 :               = get_single_symbol (min_op0, &neg_min_op0, &min_op0)))
    1014                 :     888689 :       && (TREE_CODE (min_op1) == INTEGER_CST
    1015                 :     274562 :           || (sym_min_op1
    1016                 :     274562 :               = get_single_symbol (min_op1, &neg_min_op1, &min_op1)))
    1017                 :     888689 :       && (!(sym_min_op0 && sym_min_op1)
    1018                 :     141477 :           || (sym_min_op0 == sym_min_op1
    1019                 :     166141 :               && neg_min_op0 == (minus_p ? neg_min_op1 : !neg_min_op1)))
    1020                 :     828560 :       && (TREE_CODE (max_op0) == INTEGER_CST
    1021                 :     402227 :           || (sym_max_op0
    1022                 :     402227 :               = get_single_symbol (max_op0, &neg_max_op0, &max_op0)))
    1023                 :     828560 :       && (TREE_CODE (max_op1) == INTEGER_CST
    1024                 :     120523 :           || (sym_max_op1
    1025                 :     120523 :               = get_single_symbol (max_op1, &neg_max_op1, &max_op1)))
    1026                 :    1759090 :       && (!(sym_max_op0 && sym_max_op1)
    1027                 :       6392 :           || (sym_max_op0 == sym_max_op1
    1028                 :       7205 :               && neg_max_op0 == (minus_p ? neg_max_op1 : !neg_max_op1))))
    1029                 :            :     {
    1030                 :     825211 :       wide_int wmin, wmax;
    1031                 :     825211 :       wi::overflow_type min_ovf = wi::OVF_NONE;
    1032                 :     825211 :       wi::overflow_type max_ovf = wi::OVF_NONE;
    1033                 :            : 
    1034                 :            :       /* Build the bounds.  */
    1035                 :     825211 :       combine_bound (code, wmin, min_ovf, expr_type, min_op0, min_op1);
    1036                 :     825211 :       combine_bound (code, wmax, max_ovf, expr_type, max_op0, max_op1);
    1037                 :            : 
    1038                 :            :       /* If the resulting range will be symbolic, we need to eliminate any
    1039                 :            :          explicit or implicit overflow introduced in the above computation
    1040                 :            :          because compare_values could make an incorrect use of it.  That's
    1041                 :            :          why we require one of the ranges to be a singleton.  */
    1042                 :     825211 :       if ((sym_min_op0 != sym_min_op1 || sym_max_op0 != sym_max_op1)
    1043                 :     742656 :           && ((bool)min_ovf || (bool)max_ovf
    1044                 :     412258 :               || (min_op0 != max_op0 && min_op1 != max_op1)))
    1045                 :            :         {
    1046                 :     382124 :           vr->set_varying (expr_type);
    1047                 :     809549 :           return;
    1048                 :            :         }
    1049                 :            : 
    1050                 :            :       /* Adjust the range for possible overflow.  */
    1051                 :     443087 :       set_value_range_with_overflow (kind, min, max, expr_type,
    1052                 :            :                                      wmin, wmax, min_ovf, max_ovf);
    1053                 :     443087 :       if (kind == VR_VARYING)
    1054                 :            :         {
    1055                 :      45301 :           vr->set_varying (expr_type);
    1056                 :      45301 :           return;
    1057                 :            :         }
    1058                 :            : 
    1059                 :            :       /* Build the symbolic bounds if needed.  */
    1060                 :     397786 :       adjust_symbolic_bound (min, code, expr_type,
    1061                 :            :                              sym_min_op0, sym_min_op1,
    1062                 :            :                              neg_min_op0, neg_min_op1);
    1063                 :     397786 :       adjust_symbolic_bound (max, code, expr_type,
    1064                 :            :                              sym_max_op0, sym_max_op1,
    1065                 :            :                              neg_max_op0, neg_max_op1);
    1066                 :            :     }
    1067                 :            :   else
    1068                 :            :     {
    1069                 :            :       /* For other cases, for example if we have a PLUS_EXPR with two
    1070                 :            :          VR_ANTI_RANGEs, drop to VR_VARYING.  It would take more effort
    1071                 :            :          to compute a precise range for such a case.
    1072                 :            :          ???  General even mixed range kind operations can be expressed
    1073                 :            :          by for example transforming ~[3, 5] + [1, 2] to range-only
    1074                 :            :          operations and a union primitive:
    1075                 :            :          [-INF, 2] + [1, 2]  U  [5, +INF] + [1, 2]
    1076                 :            :          [-INF+1, 4]     U    [6, +INF(OVF)]
    1077                 :            :          though usually the union is not exactly representable with
    1078                 :            :          a single range or anti-range as the above is
    1079                 :            :          [-INF+1, +INF(OVF)] intersected with ~[5, 5]
    1080                 :            :          but one could use a scheme similar to equivalences for this. */
    1081                 :     105323 :       vr->set_varying (expr_type);
    1082                 :     105323 :       return;
    1083                 :            :     }
    1084                 :            : 
    1085                 :            :   /* If either MIN or MAX overflowed, then set the resulting range to
    1086                 :            :      VARYING.  */
    1087                 :     397786 :   if (min == NULL_TREE
    1088                 :     395104 :       || TREE_OVERFLOW_P (min)
    1089                 :     395104 :       || max == NULL_TREE
    1090                 :     792395 :       || TREE_OVERFLOW_P (max))
    1091                 :            :     {
    1092                 :       3177 :       vr->set_varying (expr_type);
    1093                 :       3177 :       return;
    1094                 :            :     }
    1095                 :            : 
    1096                 :     394609 :   int cmp = compare_values (min, max);
    1097                 :     394609 :   if (cmp == -2 || cmp == 1)
    1098                 :            :     {
    1099                 :            :       /* If the new range has its limits swapped around (MIN > MAX),
    1100                 :            :          then the operation caused one of them to wrap around, mark
    1101                 :            :          the new range VARYING.  */
    1102                 :     212871 :       vr->set_varying (expr_type);
    1103                 :            :     }
    1104                 :            :   else
    1105                 :     181738 :     vr->set (min, max, kind);
    1106                 :      84385 : }
    1107                 :            : 
    1108                 :            : /* Return the range-ops handler for CODE and EXPR_TYPE.  If no
    1109                 :            :    suitable operator is found, return NULL and set VR to VARYING.  */
    1110                 :            : 
    1111                 :            : static const range_operator *
    1112                 :   45085500 : get_range_op_handler (value_range *vr,
    1113                 :            :                       enum tree_code code,
    1114                 :            :                       tree expr_type)
    1115                 :            : {
    1116                 :          0 :   const range_operator *op = range_op_handler (code, expr_type);
    1117                 :   45085500 :   if (!op)
    1118                 :     843928 :     vr->set_varying (expr_type);
    1119                 :   45085500 :   return op;
    1120                 :            : }
    1121                 :            : 
    1122                 :            : /* If the types passed are supported, return TRUE, otherwise set VR to
    1123                 :            :    VARYING and return FALSE.  */
    1124                 :            : 
    1125                 :            : static bool
    1126                 :   44904000 : supported_types_p (value_range *vr,
    1127                 :            :                    tree type0,
    1128                 :            :                    tree type1 = NULL)
    1129                 :            : {
    1130                 :   44904000 :   if (!value_range::supports_type_p (type0)
    1131                 :   44904000 :       || (type1 && !value_range::supports_type_p (type1)))
    1132                 :            :     {
    1133                 :     438347 :       vr->set_varying (type0);
    1134                 :     438347 :       return false;
    1135                 :            :     }
    1136                 :            :   return true;
    1137                 :            : }
    1138                 :            : 
    1139                 :            : /* If any of the ranges passed are defined, return TRUE, otherwise set
    1140                 :            :    VR to UNDEFINED and return FALSE.  */
    1141                 :            : 
    1142                 :            : static bool
    1143                 :   44465600 : defined_ranges_p (value_range *vr,
    1144                 :            :                   const value_range *vr0, const value_range *vr1 = NULL)
    1145                 :            : {
    1146                 :   44465600 :   if (vr0->undefined_p () && (!vr1 || vr1->undefined_p ()))
    1147                 :            :     {
    1148                 :      46464 :       vr->set_undefined ();
    1149                 :          0 :       return false;
    1150                 :            :     }
    1151                 :            :   return true;
    1152                 :            : }
    1153                 :            : 
    1154                 :            : static value_range
    1155                 :   58630900 : drop_undefines_to_varying (const value_range *vr, tree expr_type)
    1156                 :            : {
    1157                 :          0 :   if (vr->undefined_p ())
    1158                 :      32911 :     return value_range (expr_type);
    1159                 :            :   else
    1160                 :   58598000 :     return *vr;
    1161                 :            : }
    1162                 :            : 
    1163                 :            : /* If any operand is symbolic, perform a binary operation on them and
    1164                 :            :    return TRUE, otherwise return FALSE.  */
    1165                 :            : 
    1166                 :            : static bool
    1167                 :   29315500 : range_fold_binary_symbolics_p (value_range *vr,
    1168                 :            :                                tree_code code,
    1169                 :            :                                tree expr_type,
    1170                 :            :                                const value_range *vr0, const value_range *vr1)
    1171                 :            : {
    1172                 :   29315500 :   if (vr0->symbolic_p () || vr1->symbolic_p ())
    1173                 :            :     {
    1174                 :    1321110 :       if ((code == PLUS_EXPR || code == MINUS_EXPR))
    1175                 :            :         {
    1176                 :     920079 :           extract_range_from_plus_minus_expr (vr, code, expr_type, vr0, vr1);
    1177                 :     920079 :           return true;
    1178                 :            :         }
    1179                 :     401031 :       if (POINTER_TYPE_P (expr_type) && code == POINTER_PLUS_EXPR)
    1180                 :            :         {
    1181                 :     187228 :           extract_range_from_pointer_plus_expr (vr, code, expr_type, vr0, vr1);
    1182                 :     187228 :           return true;
    1183                 :            :         }
    1184                 :     213803 :       const range_operator *op = get_range_op_handler (vr, code, expr_type);
    1185                 :     213803 :       value_range vr0_cst (*vr0), vr1_cst (*vr1);
    1186                 :     213803 :       vr0_cst.normalize_symbolics ();
    1187                 :     213803 :       vr1_cst.normalize_symbolics ();
    1188                 :     213803 :       return op->fold_range (*vr, expr_type, vr0_cst, vr1_cst);
    1189                 :            :     }
    1190                 :            :   return false;
    1191                 :            : }
    1192                 :            : 
    1193                 :            : /* If operand is symbolic, perform a unary operation on it and return
    1194                 :            :    TRUE, otherwise return FALSE.  */
    1195                 :            : 
    1196                 :            : static bool
    1197                 :   14259800 : range_fold_unary_symbolics_p (value_range *vr,
    1198                 :            :                               tree_code code,
    1199                 :            :                               tree expr_type,
    1200                 :            :                               const value_range *vr0)
    1201                 :            : {
    1202                 :   14259800 :   if (vr0->symbolic_p ())
    1203                 :            :     {
    1204                 :     467054 :       if (code == NEGATE_EXPR)
    1205                 :            :         {
    1206                 :            :           /* -X is simply 0 - X.  */
    1207                 :      12234 :           value_range zero;
    1208                 :      12234 :           zero.set_zero (vr0->type ());
    1209                 :      12234 :           range_fold_binary_expr (vr, MINUS_EXPR, expr_type, &zero, vr0);
    1210                 :      12234 :           return true;
    1211                 :            :         }
    1212                 :     454820 :       if (code == BIT_NOT_EXPR)
    1213                 :            :         {
    1214                 :            :           /* ~X is simply -1 - X.  */
    1215                 :       2351 :           value_range minusone;
    1216                 :       2351 :           minusone.set (build_int_cst (vr0->type (), -1));
    1217                 :       2351 :           range_fold_binary_expr (vr, MINUS_EXPR, expr_type, &minusone, vr0);
    1218                 :       2351 :           return true;
    1219                 :            :         }
    1220                 :     452469 :       const range_operator *op = get_range_op_handler (vr, code, expr_type);
    1221                 :     452469 :       value_range vr0_cst (*vr0);
    1222                 :     452469 :       vr0_cst.normalize_symbolics ();
    1223                 :     452469 :       return op->fold_range (*vr, expr_type, vr0_cst, value_range (expr_type));
    1224                 :            :     }
    1225                 :            :   return false;
    1226                 :            : }
    1227                 :            : 
    1228                 :            : /* Perform a binary operation on a pair of ranges.  */
    1229                 :            : 
    1230                 :            : void
    1231                 :   30163900 : range_fold_binary_expr (value_range *vr,
    1232                 :            :                         enum tree_code code,
    1233                 :            :                         tree expr_type,
    1234                 :            :                         const value_range *vr0_,
    1235                 :            :                         const value_range *vr1_)
    1236                 :            : {
    1237                 :   30163900 :   if (!supported_types_p (vr, expr_type)
    1238                 :   30168400 :       || !defined_ranges_p (vr, vr0_, vr1_))
    1239                 :    2169530 :     return;
    1240                 :   30159400 :   const range_operator *op = get_range_op_handler (vr, code, expr_type);
    1241                 :   30159400 :   if (!op)
    1242                 :            :     return;
    1243                 :            : 
    1244                 :   29315500 :   value_range vr0 = drop_undefines_to_varying (vr0_, expr_type);
    1245                 :   29315500 :   value_range vr1 = drop_undefines_to_varying (vr1_, expr_type);
    1246                 :   29315500 :   if (range_fold_binary_symbolics_p (vr, code, expr_type, &vr0, &vr1))
    1247                 :            :     return;
    1248                 :            : 
    1249                 :   27994400 :   vr0.normalize_addresses ();
    1250                 :   27994400 :   vr1.normalize_addresses ();
    1251                 :   27994400 :   op->fold_range (*vr, expr_type, vr0, vr1);
    1252                 :            : }
    1253                 :            : 
    1254                 :            : /* Perform a unary operation on a range.  */
    1255                 :            : 
    1256                 :            : void
    1257                 :   14740100 : range_fold_unary_expr (value_range *vr,
    1258                 :            :                        enum tree_code code, tree expr_type,
    1259                 :            :                        const value_range *vr0,
    1260                 :            :                        tree vr0_type)
    1261                 :            : {
    1262                 :   14740100 :   if (!supported_types_p (vr, expr_type, vr0_type)
    1263                 :   14782100 :       || !defined_ranges_p (vr, vr0))
    1264                 :     947370 :     return;
    1265                 :   14259800 :   const range_operator *op = get_range_op_handler (vr, code, expr_type);
    1266                 :   14259800 :   if (!op)
    1267                 :            :     return;
    1268                 :            : 
    1269                 :   14259800 :   if (range_fold_unary_symbolics_p (vr, code, expr_type, vr0))
    1270                 :            :     return;
    1271                 :            : 
    1272                 :   13792700 :   value_range vr0_cst (*vr0);
    1273                 :   13792700 :   vr0_cst.normalize_addresses ();
    1274                 :   13792700 :   op->fold_range (*vr, expr_type, vr0_cst, value_range (expr_type));
    1275                 :            : }
    1276                 :            : 
    1277                 :            : /* Given a COND_EXPR COND of the form 'V OP W', and an SSA name V,
    1278                 :            :    create a new SSA name N and return the assertion assignment
    1279                 :            :    'N = ASSERT_EXPR <V, V OP W>'.  */
    1280                 :            : 
    1281                 :            : static gimple *
    1282                 :    5660610 : build_assert_expr_for (tree cond, tree v)
    1283                 :            : {
    1284                 :    5660610 :   tree a;
    1285                 :    5660610 :   gassign *assertion;
    1286                 :            : 
    1287                 :    5660610 :   gcc_assert (TREE_CODE (v) == SSA_NAME
    1288                 :            :               && COMPARISON_CLASS_P (cond));
    1289                 :            : 
    1290                 :    5660610 :   a = build2 (ASSERT_EXPR, TREE_TYPE (v), v, cond);
    1291                 :    5660610 :   assertion = gimple_build_assign (NULL_TREE, a);
    1292                 :            : 
    1293                 :            :   /* The new ASSERT_EXPR, creates a new SSA name that replaces the
    1294                 :            :      operand of the ASSERT_EXPR.  Create it so the new name and the old one
    1295                 :            :      are registered in the replacement table so that we can fix the SSA web
    1296                 :            :      after adding all the ASSERT_EXPRs.  */
    1297                 :    5660610 :   tree new_def = create_new_def_for (v, assertion, NULL);
    1298                 :            :   /* Make sure we preserve abnormalness throughout an ASSERT_EXPR chain
    1299                 :            :      given we have to be able to fully propagate those out to re-create
    1300                 :            :      valid SSA when removing the asserts.  */
    1301                 :    5660610 :   if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (v))
    1302                 :         48 :     SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_def) = 1;
    1303                 :            : 
    1304                 :    5660610 :   return assertion;
    1305                 :            : }
    1306                 :            : 
    1307                 :            : 
    1308                 :            : /* Return false if EXPR is a predicate expression involving floating
    1309                 :            :    point values.  */
    1310                 :            : 
    1311                 :            : static inline bool
    1312                 :    5144440 : fp_predicate (gimple *stmt)
    1313                 :            : {
    1314                 :    5144440 :   GIMPLE_CHECK (stmt, GIMPLE_COND);
    1315                 :            : 
    1316                 :    5144440 :   return FLOAT_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt)));
    1317                 :            : }
    1318                 :            : 
    1319                 :            : /* If the range of values taken by OP can be inferred after STMT executes,
    1320                 :            :    return the comparison code (COMP_CODE_P) and value (VAL_P) that
    1321                 :            :    describes the inferred range.  Return true if a range could be
    1322                 :            :    inferred.  */
    1323                 :            : 
    1324                 :            : bool
    1325                 :  141526000 : infer_value_range (gimple *stmt, tree op, tree_code *comp_code_p, tree *val_p)
    1326                 :            : {
    1327                 :  141526000 :   *val_p = NULL_TREE;
    1328                 :  141526000 :   *comp_code_p = ERROR_MARK;
    1329                 :            : 
    1330                 :            :   /* Do not attempt to infer anything in names that flow through
    1331                 :            :      abnormal edges.  */
    1332                 :  141526000 :   if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op))
    1333                 :            :     return false;
    1334                 :            : 
    1335                 :            :   /* If STMT is the last statement of a basic block with no normal
    1336                 :            :      successors, there is no point inferring anything about any of its
    1337                 :            :      operands.  We would not be able to find a proper insertion point
    1338                 :            :      for the assertion, anyway.  */
    1339                 :  141517000 :   if (stmt_ends_bb_p (stmt))
    1340                 :            :     {
    1341                 :   28406200 :       edge_iterator ei;
    1342                 :   28406200 :       edge e;
    1343                 :            : 
    1344                 :   30804000 :       FOR_EACH_EDGE (e, ei, gimple_bb (stmt)->succs)
    1345                 :   30069000 :         if (!(e->flags & (EDGE_ABNORMAL|EDGE_EH)))
    1346                 :            :           break;
    1347                 :   28406200 :       if (e == NULL)
    1348                 :     734955 :         return false;
    1349                 :            :     }
    1350                 :            : 
    1351                 :  140782000 :   if (infer_nonnull_range (stmt, op))
    1352                 :            :     {
    1353                 :   22814800 :       *val_p = build_int_cst (TREE_TYPE (op), 0);
    1354                 :   22814800 :       *comp_code_p = NE_EXPR;
    1355                 :   22814800 :       return true;
    1356                 :            :     }
    1357                 :            : 
    1358                 :            :   return false;
    1359                 :            : }
    1360                 :            : 
    1361                 :            : 
    1362                 :            : void dump_asserts_for (FILE *, tree);
    1363                 :            : void debug_asserts_for (tree);
    1364                 :            : void dump_all_asserts (FILE *);
    1365                 :            : void debug_all_asserts (void);
    1366                 :            : 
    1367                 :            : /* Dump all the registered assertions for NAME to FILE.  */
    1368                 :            : 
    1369                 :            : void
    1370                 :         97 : dump_asserts_for (FILE *file, tree name)
    1371                 :            : {
    1372                 :         97 :   assert_locus *loc;
    1373                 :            : 
    1374                 :         97 :   fprintf (file, "Assertions to be inserted for ");
    1375                 :         97 :   print_generic_expr (file, name);
    1376                 :         97 :   fprintf (file, "\n");
    1377                 :            : 
    1378                 :         97 :   loc = asserts_for[SSA_NAME_VERSION (name)];
    1379                 :        240 :   while (loc)
    1380                 :            :     {
    1381                 :        143 :       fprintf (file, "\t");
    1382                 :        143 :       print_gimple_stmt (file, gsi_stmt (loc->si), 0);
    1383                 :        143 :       fprintf (file, "\n\tBB #%d", loc->bb->index);
    1384                 :        143 :       if (loc->e)
    1385                 :            :         {
    1386                 :        132 :           fprintf (file, "\n\tEDGE %d->%d", loc->e->src->index,
    1387                 :        132 :                    loc->e->dest->index);
    1388                 :        132 :           dump_edge_info (file, loc->e, dump_flags, 0);
    1389                 :            :         }
    1390                 :        143 :       fprintf (file, "\n\tPREDICATE: ");
    1391                 :        143 :       print_generic_expr (file, loc->expr);
    1392                 :        143 :       fprintf (file, " %s ", get_tree_code_name (loc->comp_code));
    1393                 :        143 :       print_generic_expr (file, loc->val);
    1394                 :        143 :       fprintf (file, "\n\n");
    1395                 :        143 :       loc = loc->next;
    1396                 :            :     }
    1397                 :            : 
    1398                 :         97 :   fprintf (file, "\n");
    1399                 :         97 : }
    1400                 :            : 
    1401                 :            : 
    1402                 :            : /* Dump all the registered assertions for NAME to stderr.  */
    1403                 :            : 
    1404                 :            : DEBUG_FUNCTION void
    1405                 :          0 : debug_asserts_for (tree name)
    1406                 :            : {
    1407                 :          0 :   dump_asserts_for (stderr, name);
    1408                 :          0 : }
    1409                 :            : 
    1410                 :            : 
    1411                 :            : /* Dump all the registered assertions for all the names to FILE.  */
    1412                 :            : 
    1413                 :            : void
    1414                 :         33 : dump_all_asserts (FILE *file)
    1415                 :            : {
    1416                 :         33 :   unsigned i;
    1417                 :         33 :   bitmap_iterator bi;
    1418                 :            : 
    1419                 :         33 :   fprintf (file, "\nASSERT_EXPRs to be inserted\n\n");
    1420                 :        130 :   EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi)
    1421                 :         97 :     dump_asserts_for (file, ssa_name (i));
    1422                 :         33 :   fprintf (file, "\n");
    1423                 :         33 : }
    1424                 :            : 
    1425                 :            : 
    1426                 :            : /* Dump all the registered assertions for all the names to stderr.  */
    1427                 :            : 
    1428                 :            : DEBUG_FUNCTION void
    1429                 :          0 : debug_all_asserts (void)
    1430                 :            : {
    1431                 :          0 :   dump_all_asserts (stderr);
    1432                 :          0 : }
    1433                 :            : 
    1434                 :            : /* Dump assert_info structure.  */
    1435                 :            : 
    1436                 :            : void
    1437                 :          0 : dump_assert_info (FILE *file, const assert_info &assert)
    1438                 :            : {
    1439                 :          0 :   fprintf (file, "Assert for: ");
    1440                 :          0 :   print_generic_expr (file, assert.name);
    1441                 :          0 :   fprintf (file, "\n\tPREDICATE: expr=[");
    1442                 :          0 :   print_generic_expr (file, assert.expr);
    1443                 :          0 :   fprintf (file, "] %s ", get_tree_code_name (assert.comp_code));
    1444                 :          0 :   fprintf (file, "val=[");
    1445                 :          0 :   print_generic_expr (file, assert.val);
    1446                 :          0 :   fprintf (file, "]\n\n");
    1447                 :          0 : }
    1448                 :            : 
    1449                 :            : DEBUG_FUNCTION void
    1450                 :          0 : debug (const assert_info &assert)
    1451                 :            : {
    1452                 :          0 :   dump_assert_info (stderr, assert);
    1453                 :          0 : }
    1454                 :            : 
    1455                 :            : /* Dump a vector of assert_info's.  */
    1456                 :            : 
    1457                 :            : void
    1458                 :          0 : dump_asserts_info (FILE *file, const vec<assert_info> &asserts)
    1459                 :            : {
    1460                 :          0 :   for (unsigned i = 0; i < asserts.length (); ++i)
    1461                 :            :     {
    1462                 :          0 :       dump_assert_info (file, asserts[i]);
    1463                 :          0 :       fprintf (file, "\n");
    1464                 :            :     }
    1465                 :          0 : }
    1466                 :            : 
    1467                 :            : DEBUG_FUNCTION void
    1468                 :          0 : debug (const vec<assert_info> &asserts)
    1469                 :            : {
    1470                 :          0 :   dump_asserts_info (stderr, asserts);
    1471                 :          0 : }
    1472                 :            : 
    1473                 :            : /* Push the assert info for NAME, EXPR, COMP_CODE and VAL to ASSERTS.  */
    1474                 :            : 
    1475                 :            : static void
    1476                 :   33430700 : add_assert_info (vec<assert_info> &asserts,
    1477                 :            :                  tree name, tree expr, enum tree_code comp_code, tree val)
    1478                 :            : {
    1479                 :   33430700 :   assert_info info;
    1480                 :   33430700 :   info.comp_code = comp_code;
    1481                 :   33430700 :   info.name = name;
    1482                 :   33430700 :   if (TREE_OVERFLOW_P (val))
    1483                 :       4154 :     val = drop_tree_overflow (val);
    1484                 :   33430700 :   info.val = val;
    1485                 :   33430700 :   info.expr = expr;
    1486                 :   33430700 :   asserts.safe_push (info);
    1487                 :   33430700 :   if (dump_enabled_p ())
    1488                 :      15515 :     dump_printf (MSG_NOTE | MSG_PRIORITY_INTERNALS,
    1489                 :            :                  "Adding assert for %T from %T %s %T\n",
    1490                 :            :                  name, expr, op_symbol_code (comp_code), val);
    1491                 :   33430700 : }
    1492                 :            : 
    1493                 :            : /* If NAME doesn't have an ASSERT_EXPR registered for asserting
    1494                 :            :    'EXPR COMP_CODE VAL' at a location that dominates block BB or
    1495                 :            :    E->DEST, then register this location as a possible insertion point
    1496                 :            :    for ASSERT_EXPR <NAME, EXPR COMP_CODE VAL>.
    1497                 :            : 
    1498                 :            :    BB, E and SI provide the exact insertion point for the new
    1499                 :            :    ASSERT_EXPR.  If BB is NULL, then the ASSERT_EXPR is to be inserted
    1500                 :            :    on edge E.  Otherwise, if E is NULL, the ASSERT_EXPR is inserted on
    1501                 :            :    BB.  If SI points to a COND_EXPR or a SWITCH_EXPR statement, then E
    1502                 :            :    must not be NULL.  */
    1503                 :            : 
    1504                 :            : static void
    1505                 :    8098680 : register_new_assert_for (tree name, tree expr,
    1506                 :            :                          enum tree_code comp_code,
    1507                 :            :                          tree val,
    1508                 :            :                          basic_block bb,
    1509                 :            :                          edge e,
    1510                 :            :                          gimple_stmt_iterator si)
    1511                 :            : {
    1512                 :    8098680 :   assert_locus *n, *loc, *last_loc;
    1513                 :    8098680 :   basic_block dest_bb;
    1514                 :            : 
    1515                 :    8098680 :   gcc_checking_assert (bb == NULL || e == NULL);
    1516                 :            : 
    1517                 :    8098680 :   if (e == NULL)
    1518                 :    4166050 :     gcc_checking_assert (gimple_code (gsi_stmt (si)) != GIMPLE_COND
    1519                 :            :                          && gimple_code (gsi_stmt (si)) != GIMPLE_SWITCH);
    1520                 :            : 
    1521                 :            :   /* Never build an assert comparing against an integer constant with
    1522                 :            :      TREE_OVERFLOW set.  This confuses our undefined overflow warning
    1523                 :            :      machinery.  */
    1524                 :    8098680 :   if (TREE_OVERFLOW_P (val))
    1525                 :          0 :     val = drop_tree_overflow (val);
    1526                 :            : 
    1527                 :            :   /* The new assertion A will be inserted at BB or E.  We need to
    1528                 :            :      determine if the new location is dominated by a previously
    1529                 :            :      registered location for A.  If we are doing an edge insertion,
    1530                 :            :      assume that A will be inserted at E->DEST.  Note that this is not
    1531                 :            :      necessarily true.
    1532                 :            : 
    1533                 :            :      If E is a critical edge, it will be split.  But even if E is
    1534                 :            :      split, the new block will dominate the same set of blocks that
    1535                 :            :      E->DEST dominates.
    1536                 :            : 
    1537                 :            :      The reverse, however, is not true, blocks dominated by E->DEST
    1538                 :            :      will not be dominated by the new block created to split E.  So,
    1539                 :            :      if the insertion location is on a critical edge, we will not use
    1540                 :            :      the new location to move another assertion previously registered
    1541                 :            :      at a block dominated by E->DEST.  */
    1542                 :    8098680 :   dest_bb = (bb) ? bb : e->dest;
    1543                 :            : 
    1544                 :            :   /* If NAME already has an ASSERT_EXPR registered for COMP_CODE and
    1545                 :            :      VAL at a block dominating DEST_BB, then we don't need to insert a new
    1546                 :            :      one.  Similarly, if the same assertion already exists at a block
    1547                 :            :      dominated by DEST_BB and the new location is not on a critical
    1548                 :            :      edge, then update the existing location for the assertion (i.e.,
    1549                 :            :      move the assertion up in the dominance tree).
    1550                 :            : 
    1551                 :            :      Note, this is implemented as a simple linked list because there
    1552                 :            :      should not be more than a handful of assertions registered per
    1553                 :            :      name.  If this becomes a performance problem, a table hashed by
    1554                 :            :      COMP_CODE and VAL could be implemented.  */
    1555                 :    8098680 :   loc = asserts_for[SSA_NAME_VERSION (name)];
    1556                 :    8098680 :   last_loc = loc;
    1557                 :   27604900 :   while (loc)
    1558                 :            :     {
    1559                 :   21939400 :       if (loc->comp_code == comp_code
    1560                 :   13642000 :           && (loc->val == val
    1561                 :    6497330 :               || operand_equal_p (loc->val, val, 0))
    1562                 :   29286700 :           && (loc->expr == expr
    1563                 :      38317 :               || operand_equal_p (loc->expr, expr, 0)))
    1564                 :            :         {
    1565                 :            :           /* If E is not a critical edge and DEST_BB
    1566                 :            :              dominates the existing location for the assertion, move
    1567                 :            :              the assertion up in the dominance tree by updating its
    1568                 :            :              location information.  */
    1569                 :     629212 :           if ((e == NULL || !EDGE_CRITICAL_P (e))
    1570                 :    7799690 :               && dominated_by_p (CDI_DOMINATORS, loc->bb, dest_bb))
    1571                 :            :             {
    1572                 :    2433200 :               loc->bb = dest_bb;
    1573                 :    2433200 :               loc->e = e;
    1574                 :    2433200 :               loc->si = si;
    1575                 :    2433200 :               return;
    1576                 :            :             }
    1577                 :            :         }
    1578                 :            : 
    1579                 :            :       /* Update the last node of the list and move to the next one.  */
    1580                 :   19506200 :       last_loc = loc;
    1581                 :   19506200 :       loc = loc->next;
    1582                 :            :     }
    1583                 :            : 
    1584                 :            :   /* If we didn't find an assertion already registered for
    1585                 :            :      NAME COMP_CODE VAL, add a new one at the end of the list of
    1586                 :            :      assertions associated with NAME.  */
    1587                 :    5665480 :   n = XNEW (struct assert_locus);
    1588                 :    5665480 :   n->bb = dest_bb;
    1589                 :    5665480 :   n->e = e;
    1590                 :    5665480 :   n->si = si;
    1591                 :    5665480 :   n->comp_code = comp_code;
    1592                 :    5665480 :   n->val = val;
    1593                 :    5665480 :   n->expr = expr;
    1594                 :    5665480 :   n->next = NULL;
    1595                 :            : 
    1596                 :    5665480 :   if (last_loc)
    1597                 :    2101310 :     last_loc->next = n;
    1598                 :            :   else
    1599                 :    3564170 :     asserts_for[SSA_NAME_VERSION (name)] = n;
    1600                 :            : 
    1601                 :    5665480 :   bitmap_set_bit (need_assert_for, SSA_NAME_VERSION (name));
    1602                 :            : }
    1603                 :            : 
    1604                 :            : /* (COND_OP0 COND_CODE COND_OP1) is a predicate which uses NAME.
    1605                 :            :    Extract a suitable test code and value and store them into *CODE_P and
    1606                 :            :    *VAL_P so the predicate is normalized to NAME *CODE_P *VAL_P.
    1607                 :            : 
    1608                 :            :    If no extraction was possible, return FALSE, otherwise return TRUE.
    1609                 :            : 
    1610                 :            :    If INVERT is true, then we invert the result stored into *CODE_P.  */
    1611                 :            : 
    1612                 :            : static bool
    1613                 :   58407400 : extract_code_and_val_from_cond_with_ops (tree name, enum tree_code cond_code,
    1614                 :            :                                          tree cond_op0, tree cond_op1,
    1615                 :            :                                          bool invert, enum tree_code *code_p,
    1616                 :            :                                          tree *val_p)
    1617                 :            : {
    1618                 :   58407400 :   enum tree_code comp_code;
    1619                 :   58407400 :   tree val;
    1620                 :            : 
    1621                 :            :   /* Otherwise, we have a comparison of the form NAME COMP VAL
    1622                 :            :      or VAL COMP NAME.  */
    1623                 :   58407400 :   if (name == cond_op1)
    1624                 :            :     {
    1625                 :            :       /* If the predicate is of the form VAL COMP NAME, flip
    1626                 :            :          COMP around because we need to register NAME as the
    1627                 :            :          first operand in the predicate.  */
    1628                 :   11197300 :       comp_code = swap_tree_comparison (cond_code);
    1629                 :   11197300 :       val = cond_op0;
    1630                 :            :     }
    1631                 :   47210100 :   else if (name == cond_op0)
    1632                 :            :     {
    1633                 :            :       /* The comparison is of the form NAME COMP VAL, so the
    1634                 :            :          comparison code remains unchanged.  */
    1635                 :            :       comp_code = cond_code;
    1636                 :            :       val = cond_op1;
    1637                 :            :     }
    1638                 :            :   else
    1639                 :          0 :     gcc_unreachable ();
    1640                 :            : 
    1641                 :            :   /* Invert the comparison code as necessary.  */
    1642                 :   58407400 :   if (invert)
    1643                 :   28155900 :     comp_code = invert_tree_comparison (comp_code, 0);
    1644                 :            : 
    1645                 :            :   /* VRP only handles integral and pointer types.  */
    1646                 :  115871000 :   if (! INTEGRAL_TYPE_P (TREE_TYPE (val))
    1647                 :   69864200 :       && ! POINTER_TYPE_P (TREE_TYPE (val)))
    1648                 :            :     return false;
    1649                 :            : 
    1650                 :            :   /* Do not register always-false predicates.
    1651                 :            :      FIXME:  this works around a limitation in fold() when dealing with
    1652                 :            :      enumerations.  Given 'enum { N1, N2 } x;', fold will not
    1653                 :            :      fold 'if (x > N2)' to 'if (0)'.  */
    1654                 :   58191000 :   if ((comp_code == GT_EXPR || comp_code == LT_EXPR)
    1655                 :   58191000 :       && INTEGRAL_TYPE_P (TREE_TYPE (val)))
    1656                 :            :     {
    1657                 :    7315180 :       tree min = TYPE_MIN_VALUE (TREE_TYPE (val));
    1658                 :    7315180 :       tree max = TYPE_MAX_VALUE (TREE_TYPE (val));
    1659                 :            : 
    1660                 :    7315180 :       if (comp_code == GT_EXPR
    1661                 :    7315180 :           && (!max
    1662                 :    4521430 :               || compare_values (val, max) == 0))
    1663                 :          0 :         return false;
    1664                 :            : 
    1665                 :    7315180 :       if (comp_code == LT_EXPR
    1666                 :    7315180 :           && (!min
    1667                 :    2793750 :               || compare_values (val, min) == 0))
    1668                 :          0 :         return false;
    1669                 :            :     }
    1670                 :   58191000 :   *code_p = comp_code;
    1671                 :   58191000 :   *val_p = val;
    1672                 :   58191000 :   return true;
    1673                 :            : }
    1674                 :            : 
    1675                 :            : /* Find out smallest RES where RES > VAL && (RES & MASK) == RES, if any
    1676                 :            :    (otherwise return VAL).  VAL and MASK must be zero-extended for
    1677                 :            :    precision PREC.  If SGNBIT is non-zero, first xor VAL with SGNBIT
    1678                 :            :    (to transform signed values into unsigned) and at the end xor
    1679                 :            :    SGNBIT back.  */
    1680                 :            : 
    1681                 :            : static wide_int
    1682                 :     371127 : masked_increment (const wide_int &val_in, const wide_int &mask,
    1683                 :            :                   const wide_int &sgnbit, unsigned int prec)
    1684                 :            : {
    1685                 :     614166 :   wide_int bit = wi::one (prec), res;
    1686                 :     371127 :   unsigned int i;
    1687                 :            : 
    1688                 :     371127 :   wide_int val = val_in ^ sgnbit;
    1689                 :    1919450 :   for (i = 0; i < prec; i++, bit += bit)
    1690                 :            :     {
    1691                 :    1919450 :       res = mask;
    1692                 :    2290950 :       if ((res & bit) == 0)
    1693                 :    1547940 :         continue;
    1694                 :     371505 :       res = bit - 1;
    1695                 :     371505 :       res = wi::bit_and_not (val + bit, res);
    1696                 :     371505 :       res &= mask;
    1697                 :     371505 :       if (wi::gtu_p (res, val))
    1698                 :     371124 :         return res ^ sgnbit;
    1699                 :            :     }
    1700                 :          3 :   return val ^ sgnbit;
    1701                 :            : }
    1702                 :            : 
    1703                 :            : /* Helper for overflow_comparison_p
    1704                 :            : 
    1705                 :            :    OP0 CODE OP1 is a comparison.  Examine the comparison and potentially
    1706                 :            :    OP1's defining statement to see if it ultimately has the form
    1707                 :            :    OP0 CODE (OP0 PLUS INTEGER_CST)
    1708                 :            : 
    1709                 :            :    If so, return TRUE indicating this is an overflow test and store into
    1710                 :            :    *NEW_CST an updated constant that can be used in a narrowed range test.
    1711                 :            : 
    1712                 :            :    REVERSED indicates if the comparison was originally:
    1713                 :            : 
    1714                 :            :    OP1 CODE' OP0.
    1715                 :            : 
    1716                 :            :    This affects how we build the updated constant.  */
    1717                 :            : 
    1718                 :            : static bool
    1719                 :  123148000 : overflow_comparison_p_1 (enum tree_code code, tree op0, tree op1,
    1720                 :            :                          bool follow_assert_exprs, bool reversed, tree *new_cst)
    1721                 :            : {
    1722                 :            :   /* See if this is a relational operation between two SSA_NAMES with
    1723                 :            :      unsigned, overflow wrapping values.  If so, check it more deeply.  */
    1724                 :  123148000 :   if ((code == LT_EXPR || code == LE_EXPR
    1725                 :  100747000 :        || code == GE_EXPR || code == GT_EXPR)
    1726                 :   31286400 :       && TREE_CODE (op0) == SSA_NAME
    1727                 :   24573700 :       && TREE_CODE (op1) == SSA_NAME
    1728                 :   17861300 :       && INTEGRAL_TYPE_P (TREE_TYPE (op0))
    1729                 :   16505800 :       && TYPE_UNSIGNED (TREE_TYPE (op0))
    1730                 :  127747000 :       && TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0)))
    1731                 :            :     {
    1732                 :    4598560 :       gimple *op1_def = SSA_NAME_DEF_STMT (op1);
    1733                 :            : 
    1734                 :            :       /* If requested, follow any ASSERT_EXPRs backwards for OP1.  */
    1735                 :    4598560 :       if (follow_assert_exprs)
    1736                 :            :         {
    1737                 :     245025 :           while (gimple_assign_single_p (op1_def)
    1738                 :    1252900 :                  && TREE_CODE (gimple_assign_rhs1 (op1_def)) == ASSERT_EXPR)
    1739                 :            :             {
    1740                 :      87790 :               op1 = TREE_OPERAND (gimple_assign_rhs1 (op1_def), 0);
    1741                 :      87790 :               if (TREE_CODE (op1) != SSA_NAME)
    1742                 :            :                 break;
    1743                 :      87790 :               op1_def = SSA_NAME_DEF_STMT (op1);
    1744                 :            :             }
    1745                 :            :         }
    1746                 :            : 
    1747                 :            :       /* Now look at the defining statement of OP1 to see if it adds
    1748                 :            :          or subtracts a nonzero constant from another operand.  */
    1749                 :    4598560 :       if (op1_def
    1750                 :    4598560 :           && is_gimple_assign (op1_def)
    1751                 :    3618780 :           && gimple_assign_rhs_code (op1_def) == PLUS_EXPR
    1752                 :     969006 :           && TREE_CODE (gimple_assign_rhs2 (op1_def)) == INTEGER_CST
    1753                 :    4947930 :           && !integer_zerop (gimple_assign_rhs2 (op1_def)))
    1754                 :            :         {
    1755                 :     349373 :           tree target = gimple_assign_rhs1 (op1_def);
    1756                 :            : 
    1757                 :            :           /* If requested, follow ASSERT_EXPRs backwards for op0 looking
    1758                 :            :              for one where TARGET appears on the RHS.  */
    1759                 :     349373 :           if (follow_assert_exprs)
    1760                 :            :             {
    1761                 :            :               /* Now see if that "other operand" is op0, following the chain
    1762                 :            :                  of ASSERT_EXPRs if necessary.  */
    1763                 :      81770 :               gimple *op0_def = SSA_NAME_DEF_STMT (op0);
    1764                 :      99082 :               while (op0 != target
    1765                 :      42279 :                      && gimple_assign_single_p (op0_def)
    1766                 :     141361 :                      && TREE_CODE (gimple_assign_rhs1 (op0_def)) == ASSERT_EXPR)
    1767                 :            :                 {
    1768                 :      17312 :                   op0 = TREE_OPERAND (gimple_assign_rhs1 (op0_def), 0);
    1769                 :      17312 :                   if (TREE_CODE (op0) != SSA_NAME)
    1770                 :            :                     break;
    1771                 :      17312 :                   op0_def = SSA_NAME_DEF_STMT (op0);
    1772                 :            :                 }
    1773                 :            :             }
    1774                 :            : 
    1775                 :            :           /* If we did not find our target SSA_NAME, then this is not
    1776                 :            :              an overflow test.  */
    1777                 :     349373 :           if (op0 != target)
    1778                 :            :             return false;
    1779                 :            : 
    1780                 :       4939 :           tree type = TREE_TYPE (op0);
    1781                 :       4939 :           wide_int max = wi::max_value (TYPE_PRECISION (type), UNSIGNED);
    1782                 :       4939 :           tree inc = gimple_assign_rhs2 (op1_def);
    1783                 :       4939 :           if (reversed)
    1784                 :       2021 :             *new_cst = wide_int_to_tree (type, max + wi::to_wide (inc));
    1785                 :            :           else
    1786                 :       2918 :             *new_cst = wide_int_to_tree (type, max - wi::to_wide (inc));
    1787                 :       4939 :           return true;
    1788                 :            :         }
    1789                 :            :     }
    1790                 :            :   return false;
    1791                 :            : }
    1792                 :            : 
    1793                 :            : /* OP0 CODE OP1 is a comparison.  Examine the comparison and potentially
    1794                 :            :    OP1's defining statement to see if it ultimately has the form
    1795                 :            :    OP0 CODE (OP0 PLUS INTEGER_CST)
    1796                 :            : 
    1797                 :            :    If so, return TRUE indicating this is an overflow test and store into
    1798                 :            :    *NEW_CST an updated constant that can be used in a narrowed range test.
    1799                 :            : 
    1800                 :            :    These statements are left as-is in the IL to facilitate discovery of
    1801                 :            :    {ADD,SUB}_OVERFLOW sequences later in the optimizer pipeline.  But
    1802                 :            :    the alternate range representation is often useful within VRP.  */
    1803                 :            : 
    1804                 :            : bool
    1805                 :   61575500 : overflow_comparison_p (tree_code code, tree name, tree val,
    1806                 :            :                        bool use_equiv_p, tree *new_cst)
    1807                 :            : {
    1808                 :   61575500 :   if (overflow_comparison_p_1 (code, name, val, use_equiv_p, false, new_cst))
    1809                 :            :     return true;
    1810                 :   61572600 :   return overflow_comparison_p_1 (swap_tree_comparison (code), val, name,
    1811                 :   61572600 :                                   use_equiv_p, true, new_cst);
    1812                 :            : }
    1813                 :            : 
    1814                 :            : 
    1815                 :            : /* Try to register an edge assertion for SSA name NAME on edge E for
    1816                 :            :    the condition COND contributing to the conditional jump pointed to by BSI.
    1817                 :            :    Invert the condition COND if INVERT is true.  */
    1818                 :            : 
    1819                 :            : static void
    1820                 :   29734100 : register_edge_assert_for_2 (tree name, edge e,
    1821                 :            :                             enum tree_code cond_code,
    1822                 :            :                             tree cond_op0, tree cond_op1, bool invert,
    1823                 :            :                             vec<assert_info> &asserts)
    1824                 :            : {
    1825                 :   29734100 :   tree val;
    1826                 :   29734100 :   enum tree_code comp_code;
    1827                 :            : 
    1828                 :   29734100 :   if (!extract_code_and_val_from_cond_with_ops (name, cond_code,
    1829                 :            :                                                 cond_op0,
    1830                 :            :                                                 cond_op1,
    1831                 :            :                                                 invert, &comp_code, &val))
    1832                 :     215285 :     return;
    1833                 :            : 
    1834                 :            :   /* Queue the assert.  */
    1835                 :   29518800 :   tree x;
    1836                 :   29518800 :   if (overflow_comparison_p (comp_code, name, val, false, &x))
    1837                 :            :     {
    1838                 :       6288 :       enum tree_code new_code = ((comp_code == GT_EXPR || comp_code == GE_EXPR)
    1839                 :       3144 :                                  ? GT_EXPR : LE_EXPR);
    1840                 :       3144 :       add_assert_info (asserts, name, name, new_code, x);
    1841                 :            :     }
    1842                 :   29518800 :   add_assert_info (asserts, name, name, comp_code, val);
    1843                 :            : 
    1844                 :            :   /* In the case of NAME <= CST and NAME being defined as
    1845                 :            :      NAME = (unsigned) NAME2 + CST2 we can assert NAME2 >= -CST2
    1846                 :            :      and NAME2 <= CST - CST2.  We can do the same for NAME > CST.
    1847                 :            :      This catches range and anti-range tests.  */
    1848                 :   29518800 :   if ((comp_code == LE_EXPR
    1849                 :   29518800 :        || comp_code == GT_EXPR)
    1850                 :    4547540 :       && TREE_CODE (val) == INTEGER_CST
    1851                 :   31428600 :       && TYPE_UNSIGNED (TREE_TYPE (val)))
    1852                 :            :     {
    1853                 :     670077 :       gimple *def_stmt = SSA_NAME_DEF_STMT (name);
    1854                 :     670077 :       tree cst2 = NULL_TREE, name2 = NULL_TREE, name3 = NULL_TREE;
    1855                 :            : 
    1856                 :            :       /* Extract CST2 from the (optional) addition.  */
    1857                 :     670077 :       if (is_gimple_assign (def_stmt)
    1858                 :     670077 :           && gimple_assign_rhs_code (def_stmt) == PLUS_EXPR)
    1859                 :            :         {
    1860                 :     149023 :           name2 = gimple_assign_rhs1 (def_stmt);
    1861                 :     149023 :           cst2 = gimple_assign_rhs2 (def_stmt);
    1862                 :     149023 :           if (TREE_CODE (name2) == SSA_NAME
    1863                 :     149023 :               && TREE_CODE (cst2) == INTEGER_CST)
    1864                 :     131932 :             def_stmt = SSA_NAME_DEF_STMT (name2);
    1865                 :            :         }
    1866                 :            : 
    1867                 :            :       /* Extract NAME2 from the (optional) sign-changing cast.  */
    1868                 :     670077 :       if (gimple_assign_cast_p (def_stmt))
    1869                 :            :         {
    1870                 :     228392 :           if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))
    1871                 :     227740 :               && ! TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (def_stmt)))
    1872                 :     429199 :               && (TYPE_PRECISION (gimple_expr_type (def_stmt))
    1873                 :     201133 :                   == TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt)))))
    1874                 :     195075 :             name3 = gimple_assign_rhs1 (def_stmt);
    1875                 :            :         }
    1876                 :            : 
    1877                 :            :       /* If name3 is used later, create an ASSERT_EXPR for it.  */
    1878                 :     195075 :       if (name3 != NULL_TREE
    1879                 :     195075 :           && TREE_CODE (name3) == SSA_NAME
    1880                 :     195075 :           && (cst2 == NULL_TREE
    1881                 :      57727 :               || TREE_CODE (cst2) == INTEGER_CST)
    1882                 :     195075 :           && INTEGRAL_TYPE_P (TREE_TYPE (name3)))
    1883                 :            :         {
    1884                 :     195075 :           tree tmp;
    1885                 :            : 
    1886                 :            :           /* Build an expression for the range test.  */
    1887                 :     195075 :           tmp = build1 (NOP_EXPR, TREE_TYPE (name), name3);
    1888                 :     195075 :           if (cst2 != NULL_TREE)
    1889                 :      57727 :             tmp = build2 (PLUS_EXPR, TREE_TYPE (name), tmp, cst2);
    1890                 :     195075 :           add_assert_info (asserts, name3, tmp, comp_code, val);
    1891                 :            :         }
    1892                 :            : 
    1893                 :            :       /* If name2 is used later, create an ASSERT_EXPR for it.  */
    1894                 :     670077 :       if (name2 != NULL_TREE
    1895                 :     149023 :           && TREE_CODE (name2) == SSA_NAME
    1896                 :     149023 :           && TREE_CODE (cst2) == INTEGER_CST
    1897                 :     802009 :           && INTEGRAL_TYPE_P (TREE_TYPE (name2)))
    1898                 :            :         {
    1899                 :     131932 :           tree tmp;
    1900                 :            : 
    1901                 :            :           /* Build an expression for the range test.  */
    1902                 :     131932 :           tmp = name2;
    1903                 :     131932 :           if (TREE_TYPE (name) != TREE_TYPE (name2))
    1904                 :      19186 :             tmp = build1 (NOP_EXPR, TREE_TYPE (name), tmp);
    1905                 :     131932 :           if (cst2 != NULL_TREE)
    1906                 :     131932 :             tmp = build2 (PLUS_EXPR, TREE_TYPE (name), tmp, cst2);
    1907                 :     131932 :           add_assert_info (asserts, name2, tmp, comp_code, val);
    1908                 :            :         }
    1909                 :            :     }
    1910                 :            : 
    1911                 :            :   /* In the case of post-in/decrement tests like if (i++) ... and uses
    1912                 :            :      of the in/decremented value on the edge the extra name we want to
    1913                 :            :      assert for is not on the def chain of the name compared.  Instead
    1914                 :            :      it is in the set of use stmts.
    1915                 :            :      Similar cases happen for conversions that were simplified through
    1916                 :            :      fold_{sign_changed,widened}_comparison.  */
    1917                 :   29518800 :   if ((comp_code == NE_EXPR
    1918                 :   29518800 :        || comp_code == EQ_EXPR)
    1919                 :   21766500 :       && TREE_CODE (val) == INTEGER_CST)
    1920                 :            :     {
    1921                 :   15319500 :       imm_use_iterator ui;
    1922                 :   15319500 :       gimple *use_stmt;
    1923                 :   57358800 :       FOR_EACH_IMM_USE_STMT (use_stmt, ui, name)
    1924                 :            :         {
    1925                 :   42039300 :           if (!is_gimple_assign (use_stmt))
    1926                 :   32043900 :             continue;
    1927                 :            : 
    1928                 :            :           /* Cut off to use-stmts that are dominating the predecessor.  */
    1929                 :    9995360 :           if (!dominated_by_p (CDI_DOMINATORS, e->src, gimple_bb (use_stmt)))
    1930                 :    8289140 :             continue;
    1931                 :            : 
    1932                 :    1706220 :           tree name2 = gimple_assign_lhs (use_stmt);
    1933                 :    1706220 :           if (TREE_CODE (name2) != SSA_NAME)
    1934                 :     369368 :             continue;
    1935                 :            : 
    1936                 :    1336850 :           enum tree_code code = gimple_assign_rhs_code (use_stmt);
    1937                 :    1336850 :           tree cst;
    1938                 :    1336850 :           if (code == PLUS_EXPR
    1939                 :    1336850 :               || code == MINUS_EXPR)
    1940                 :            :             {
    1941                 :     112874 :               cst = gimple_assign_rhs2 (use_stmt);
    1942                 :     112874 :               if (TREE_CODE (cst) != INTEGER_CST)
    1943                 :      44632 :                 continue;
    1944                 :      68242 :               cst = int_const_binop (code, val, cst);
    1945                 :            :             }
    1946                 :    1223980 :           else if (CONVERT_EXPR_CODE_P (code))
    1947                 :            :             {
    1948                 :            :               /* For truncating conversions we cannot record
    1949                 :            :                  an inequality.  */
    1950                 :     192111 :               if (comp_code == NE_EXPR
    1951                 :     288417 :                   && (TYPE_PRECISION (TREE_TYPE (name2))
    1952                 :     101789 :                       < TYPE_PRECISION (TREE_TYPE (name))))
    1953                 :       5483 :                 continue;
    1954                 :     181145 :               cst = fold_convert (TREE_TYPE (name2), val);
    1955                 :            :             }
    1956                 :            :           else
    1957                 :    1037350 :             continue;
    1958                 :            : 
    1959                 :     249387 :           if (TREE_OVERFLOW_P (cst))
    1960                 :       4055 :             cst = drop_tree_overflow (cst);
    1961                 :     249387 :           add_assert_info (asserts, name2, name2, comp_code, cst);
    1962                 :            :         }
    1963                 :            :     }
    1964                 :            :  
    1965                 :   29518800 :   if (TREE_CODE_CLASS (comp_code) == tcc_comparison
    1966                 :   29518800 :       && TREE_CODE (val) == INTEGER_CST)
    1967                 :            :     {
    1968                 :   17794300 :       gimple *def_stmt = SSA_NAME_DEF_STMT (name);
    1969                 :   17794300 :       tree name2 = NULL_TREE, names[2], cst2 = NULL_TREE;
    1970                 :   17794300 :       tree val2 = NULL_TREE;
    1971                 :   17794300 :       unsigned int prec = TYPE_PRECISION (TREE_TYPE (val));
    1972                 :   17794300 :       wide_int mask = wi::zero (prec);
    1973                 :   17794300 :       unsigned int nprec = prec;
    1974                 :   17794300 :       enum tree_code rhs_code = ERROR_MARK;
    1975                 :            : 
    1976                 :   17794300 :       if (is_gimple_assign (def_stmt))
    1977                 :   12035300 :         rhs_code = gimple_assign_rhs_code (def_stmt);
    1978                 :            : 
    1979                 :            :       /* In the case of NAME != CST1 where NAME = A +- CST2 we can
    1980                 :            :          assert that A != CST1 -+ CST2.  */
    1981                 :   17794300 :       if ((comp_code == EQ_EXPR || comp_code == NE_EXPR)
    1982                 :   15319500 :           && (rhs_code == PLUS_EXPR || rhs_code == MINUS_EXPR))
    1983                 :            :         {
    1984                 :     924021 :           tree op0 = gimple_assign_rhs1 (def_stmt);
    1985                 :     924021 :           tree op1 = gimple_assign_rhs2 (def_stmt);
    1986                 :     924021 :           if (TREE_CODE (op0) == SSA_NAME
    1987                 :     918841 :               && TREE_CODE (op1) == INTEGER_CST)
    1988                 :            :             {
    1989                 :    1597570 :               enum tree_code reverse_op = (rhs_code == PLUS_EXPR
    1990                 :     798784 :                                            ? MINUS_EXPR : PLUS_EXPR);
    1991                 :     798784 :               op1 = int_const_binop (reverse_op, val, op1);
    1992                 :     798784 :               if (TREE_OVERFLOW (op1))
    1993                 :       5674 :                 op1 = drop_tree_overflow (op1);
    1994                 :     798784 :               add_assert_info (asserts, op0, op0, comp_code, op1);
    1995                 :            :             }
    1996                 :            :         }
    1997                 :            : 
    1998                 :            :       /* Add asserts for NAME cmp CST and NAME being defined
    1999                 :            :          as NAME = (int) NAME2.  */
    2000                 :   17794300 :       if (!TYPE_UNSIGNED (TREE_TYPE (val))
    2001                 :    6495500 :           && (comp_code == LE_EXPR || comp_code == LT_EXPR
    2002                 :    6495500 :               || comp_code == GT_EXPR || comp_code == GE_EXPR)
    2003                 :   19589300 :           && gimple_assign_cast_p (def_stmt))
    2004                 :            :         {
    2005                 :     254618 :           name2 = gimple_assign_rhs1 (def_stmt);
    2006                 :     254618 :           if (CONVERT_EXPR_CODE_P (rhs_code)
    2007                 :     252376 :               && TREE_CODE (name2) == SSA_NAME
    2008                 :     252376 :               && INTEGRAL_TYPE_P (TREE_TYPE (name2))
    2009                 :     251405 :               && TYPE_UNSIGNED (TREE_TYPE (name2))
    2010                 :     163780 :               && prec == TYPE_PRECISION (TREE_TYPE (name2))
    2011                 :     390560 :               && (comp_code == LE_EXPR || comp_code == GT_EXPR
    2012                 :      97590 :                   || !tree_int_cst_equal (val,
    2013                 :      97590 :                                           TYPE_MIN_VALUE (TREE_TYPE (val)))))
    2014                 :            :             {
    2015                 :     135942 :               tree tmp, cst;
    2016                 :     135942 :               enum tree_code new_comp_code = comp_code;
    2017                 :            : 
    2018                 :     135942 :               cst = fold_convert (TREE_TYPE (name2),
    2019                 :            :                                   TYPE_MIN_VALUE (TREE_TYPE (val)));
    2020                 :            :               /* Build an expression for the range test.  */
    2021                 :     135942 :               tmp = build2 (PLUS_EXPR, TREE_TYPE (name2), name2, cst);
    2022                 :     135942 :               cst = fold_build2 (PLUS_EXPR, TREE_TYPE (name2), cst,
    2023                 :            :                                  fold_convert (TREE_TYPE (name2), val));
    2024                 :     135942 :               if (comp_code == LT_EXPR || comp_code == GE_EXPR)
    2025                 :            :                 {
    2026                 :      97590 :                   new_comp_code = comp_code == LT_EXPR ? LE_EXPR : GT_EXPR;
    2027                 :      97590 :                   cst = fold_build2 (MINUS_EXPR, TREE_TYPE (name2), cst,
    2028                 :            :                                      build_int_cst (TREE_TYPE (name2), 1));
    2029                 :            :                 }
    2030                 :     135942 :               add_assert_info (asserts, name2, tmp, new_comp_code, cst);
    2031                 :            :             }
    2032                 :            :         }
    2033                 :            : 
    2034                 :            :       /* Add asserts for NAME cmp CST and NAME being defined as
    2035                 :            :          NAME = NAME2 >> CST2.
    2036                 :            : 
    2037                 :            :          Extract CST2 from the right shift.  */
    2038                 :   17794300 :       if (rhs_code == RSHIFT_EXPR)
    2039                 :            :         {
    2040                 :      30522 :           name2 = gimple_assign_rhs1 (def_stmt);
    2041                 :      30522 :           cst2 = gimple_assign_rhs2 (def_stmt);
    2042                 :      30522 :           if (TREE_CODE (name2) == SSA_NAME
    2043                 :      29474 :               && tree_fits_uhwi_p (cst2)
    2044                 :      27685 :               && INTEGRAL_TYPE_P (TREE_TYPE (name2))
    2045                 :      27685 :               && IN_RANGE (tree_to_uhwi (cst2), 1, prec - 1)
    2046                 :      58207 :               && type_has_mode_precision_p (TREE_TYPE (val)))
    2047                 :            :             {
    2048                 :      27685 :               mask = wi::mask (tree_to_uhwi (cst2), false, prec);
    2049                 :      27685 :               val2 = fold_binary (LSHIFT_EXPR, TREE_TYPE (val), val, cst2);
    2050                 :            :             }
    2051                 :            :         }
    2052                 :   17794300 :       if (val2 != NULL_TREE
    2053                 :      27685 :           && TREE_CODE (val2) == INTEGER_CST
    2054                 :   17822000 :           && simple_cst_equal (fold_build2 (RSHIFT_EXPR,
    2055                 :            :                                             TREE_TYPE (val),
    2056                 :            :                                             val2, cst2), val))
    2057                 :            :         {
    2058                 :      27685 :           enum tree_code new_comp_code = comp_code;
    2059                 :      27685 :           tree tmp, new_val;
    2060                 :            : 
    2061                 :      27685 :           tmp = name2;
    2062                 :      27685 :           if (comp_code == EQ_EXPR || comp_code == NE_EXPR)
    2063                 :            :             {
    2064                 :      17249 :               if (!TYPE_UNSIGNED (TREE_TYPE (val)))
    2065                 :            :                 {
    2066                 :       3162 :                   tree type = build_nonstandard_integer_type (prec, 1);
    2067                 :       3162 :                   tmp = build1 (NOP_EXPR, type, name2);
    2068                 :       3162 :                   val2 = fold_convert (type, val2);
    2069                 :            :                 }
    2070                 :      17249 :               tmp = fold_build2 (MINUS_EXPR, TREE_TYPE (tmp), tmp, val2);
    2071                 :      17249 :               new_val = wide_int_to_tree (TREE_TYPE (tmp), mask);
    2072                 :      17249 :               new_comp_code = comp_code == EQ_EXPR ? LE_EXPR : GT_EXPR;
    2073                 :            :             }
    2074                 :      10436 :           else if (comp_code == LT_EXPR || comp_code == GE_EXPR)
    2075                 :            :             {
    2076                 :        403 :               wide_int minval
    2077                 :        403 :                 = wi::min_value (prec, TYPE_SIGN (TREE_TYPE (val)));
    2078                 :        403 :               new_val = val2;
    2079                 :        403 :               if (minval == wi::to_wide (new_val))
    2080                 :        403 :                 new_val = NULL_TREE;
    2081                 :            :             }
    2082                 :            :           else
    2083                 :            :             {
    2084                 :      10033 :               wide_int maxval
    2085                 :      10033 :                 = wi::max_value (prec, TYPE_SIGN (TREE_TYPE (val)));
    2086                 :      10033 :               mask |= wi::to_wide (val2);
    2087                 :      10033 :               if (wi::eq_p (mask, maxval))
    2088                 :            :                 new_val = NULL_TREE;
    2089                 :            :               else
    2090                 :       9967 :                 new_val = wide_int_to_tree (TREE_TYPE (val2), mask);
    2091                 :            :             }
    2092                 :            : 
    2093                 :      27685 :           if (new_val)
    2094                 :      27607 :             add_assert_info (asserts, name2, tmp, new_comp_code, new_val);
    2095                 :            :         }
    2096                 :            : 
    2097                 :            :       /* If we have a conversion that doesn't change the value of the source
    2098                 :            :          simply register the same assert for it.  */
    2099                 :   17794300 :       if (CONVERT_EXPR_CODE_P (rhs_code))
    2100                 :            :         {
    2101                 :     931804 :           wide_int rmin, rmax;
    2102                 :     931804 :           tree rhs1 = gimple_assign_rhs1 (def_stmt);
    2103                 :    1856860 :           if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
    2104                 :     919446 :               && TREE_CODE (rhs1) == SSA_NAME
    2105                 :            :               /* Make sure the relation preserves the upper/lower boundary of
    2106                 :            :                  the range conservatively.  */
    2107                 :     919446 :               && (comp_code == NE_EXPR
    2108                 :     919446 :                   || comp_code == EQ_EXPR
    2109                 :     399633 :                   || (TYPE_SIGN (TREE_TYPE (name))
    2110                 :     399633 :                       == TYPE_SIGN (TREE_TYPE (rhs1)))
    2111                 :     305511 :                   || ((comp_code == LE_EXPR
    2112                 :     305511 :                        || comp_code == LT_EXPR)
    2113                 :     145173 :                       && !TYPE_UNSIGNED (TREE_TYPE (rhs1)))
    2114                 :     238478 :                   || ((comp_code == GE_EXPR
    2115                 :     238478 :                        || comp_code == GT_EXPR)
    2116                 :     160338 :                       && TYPE_UNSIGNED (TREE_TYPE (rhs1))))
    2117                 :            :               /* And the conversion does not alter the value we compare
    2118                 :            :                  against and all values in rhs1 can be represented in
    2119                 :            :                  the converted to type.  */
    2120                 :     766608 :               && int_fits_type_p (val, TREE_TYPE (rhs1))
    2121                 :    1683480 :               && ((TYPE_PRECISION (TREE_TYPE (name))
    2122                 :     751679 :                    > TYPE_PRECISION (TREE_TYPE (rhs1)))
    2123                 :     622792 :                   || (get_range_info (rhs1, &rmin, &rmax) == VR_RANGE
    2124                 :     266227 :                       && wi::fits_to_tree_p (rmin, TREE_TYPE (name))
    2125                 :     261897 :                       && wi::fits_to_tree_p (rmax, TREE_TYPE (name)))))
    2126                 :     714954 :             add_assert_info (asserts, rhs1, rhs1,
    2127                 :     357477 :                              comp_code, fold_convert (TREE_TYPE (rhs1), val));
    2128                 :            :         }
    2129                 :            : 
    2130                 :            :       /* Add asserts for NAME cmp CST and NAME being defined as
    2131                 :            :          NAME = NAME2 & CST2.
    2132                 :            : 
    2133                 :            :          Extract CST2 from the and.
    2134                 :            : 
    2135                 :            :          Also handle
    2136                 :            :          NAME = (unsigned) NAME2;
    2137                 :            :          casts where NAME's type is unsigned and has smaller precision
    2138                 :            :          than NAME2's type as if it was NAME = NAME2 & MASK.  */
    2139                 :   17794300 :       names[0] = NULL_TREE;
    2140                 :   17794300 :       names[1] = NULL_TREE;
    2141                 :   17794300 :       cst2 = NULL_TREE;
    2142                 :   17794300 :       if (rhs_code == BIT_AND_EXPR
    2143                 :   17794300 :           || (CONVERT_EXPR_CODE_P (rhs_code)
    2144                 :     931804 :               && INTEGRAL_TYPE_P (TREE_TYPE (val))
    2145                 :     930633 :               && TYPE_UNSIGNED (TREE_TYPE (val))
    2146                 :     523982 :               && TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt)))
    2147                 :            :                  > prec))
    2148                 :            :         {
    2149                 :    1273210 :           name2 = gimple_assign_rhs1 (def_stmt);
    2150                 :    1273210 :           if (rhs_code == BIT_AND_EXPR)
    2151                 :    1031950 :             cst2 = gimple_assign_rhs2 (def_stmt);
    2152                 :            :           else
    2153                 :            :             {
    2154                 :     241255 :               cst2 = TYPE_MAX_VALUE (TREE_TYPE (val));
    2155                 :     241255 :               nprec = TYPE_PRECISION (TREE_TYPE (name2));
    2156                 :            :             }
    2157                 :    1273210 :           if (TREE_CODE (name2) == SSA_NAME
    2158                 :    1273210 :               && INTEGRAL_TYPE_P (TREE_TYPE (name2))
    2159                 :    1273200 :               && TREE_CODE (cst2) == INTEGER_CST
    2160                 :     774783 :               && !integer_zerop (cst2)
    2161                 :    2047990 :               && (nprec > 1
    2162                 :          0 :                   || TYPE_UNSIGNED (TREE_TYPE (val))))
    2163                 :            :             {
    2164                 :     774783 :               gimple *def_stmt2 = SSA_NAME_DEF_STMT (name2);
    2165                 :     774783 :               if (gimple_assign_cast_p (def_stmt2))
    2166                 :            :                 {
    2167                 :      68027 :                   names[1] = gimple_assign_rhs1 (def_stmt2);
    2168                 :      69950 :                   if (!CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt2))
    2169                 :      66112 :                       || TREE_CODE (names[1]) != SSA_NAME
    2170                 :      65999 :                       || !INTEGRAL_TYPE_P (TREE_TYPE (names[1]))
    2171                 :     121609 :                       || (TYPE_PRECISION (TREE_TYPE (name2))
    2172                 :      53582 :                           != TYPE_PRECISION (TREE_TYPE (names[1]))))
    2173                 :      38783 :                     names[1] = NULL_TREE;
    2174                 :            :                 }
    2175                 :     774783 :               names[0] = name2;
    2176                 :            :             }
    2177                 :            :         }
    2178                 :   17794300 :       if (names[0] || names[1])
    2179                 :            :         {
    2180                 :     774783 :           wide_int minv, maxv, valv, cst2v;
    2181                 :     774783 :           wide_int tem, sgnbit;
    2182                 :     774783 :           bool valid_p = false, valn, cst2n;
    2183                 :     774783 :           enum tree_code ccode = comp_code;
    2184                 :            : 
    2185                 :     774783 :           valv = wide_int::from (wi::to_wide (val), nprec, UNSIGNED);
    2186                 :     774783 :           cst2v = wide_int::from (wi::to_wide (cst2), nprec, UNSIGNED);
    2187                 :     774783 :           valn = wi::neg_p (valv, TYPE_SIGN (TREE_TYPE (val)));
    2188                 :     774783 :           cst2n = wi::neg_p (cst2v, TYPE_SIGN (TREE_TYPE (val)));
    2189                 :            :           /* If CST2 doesn't have most significant bit set,
    2190                 :            :              but VAL is negative, we have comparison like
    2191                 :            :              if ((x & 0x123) > -4) (always true).  Just give up.  */
    2192                 :     774783 :           if (!cst2n && valn)
    2193                 :          0 :             ccode = ERROR_MARK;
    2194                 :     774783 :           if (cst2n)
    2195                 :       5392 :             sgnbit = wi::set_bit_in_zero (nprec - 1, nprec);
    2196                 :            :           else
    2197                 :     769391 :             sgnbit = wi::zero (nprec);
    2198                 :     774783 :           minv = valv & cst2v;
    2199                 :     774783 :           switch (ccode)
    2200                 :            :             {
    2201                 :     333641 :             case EQ_EXPR:
    2202                 :            :               /* Minimum unsigned value for equality is VAL & CST2
    2203                 :            :                  (should be equal to VAL, otherwise we probably should
    2204                 :            :                  have folded the comparison into false) and
    2205                 :            :                  maximum unsigned value is VAL | ~CST2.  */
    2206                 :     333641 :               maxv = valv | ~cst2v;
    2207                 :     333641 :               valid_p = true;
    2208                 :     333641 :               break;
    2209                 :            : 
    2210                 :     420166 :             case NE_EXPR:
    2211                 :     420166 :               tem = valv | ~cst2v;
    2212                 :            :               /* If VAL is 0, handle (X & CST2) != 0 as (X & CST2) > 0U.  */
    2213                 :     420166 :               if (valv == 0)
    2214                 :            :                 {
    2215                 :     361274 :                   cst2n = false;
    2216                 :     361274 :                   sgnbit = wi::zero (nprec);
    2217                 :     361274 :                   goto gt_expr;
    2218                 :            :                 }
    2219                 :            :               /* If (VAL | ~CST2) is all ones, handle it as
    2220                 :            :                  (X & CST2) < VAL.  */
    2221                 :      58892 :               if (tem == -1)
    2222                 :            :                 {
    2223                 :      19420 :                   cst2n = false;
    2224                 :      19420 :                   valn = false;
    2225                 :      19420 :                   sgnbit = wi::zero (nprec);
    2226                 :      19420 :                   goto lt_expr;
    2227                 :            :                 }
    2228                 :      77255 :               if (!cst2n && wi::neg_p (cst2v))
    2229                 :       2124 :                 sgnbit = wi::set_bit_in_zero (nprec - 1, nprec);
    2230                 :      39472 :               if (sgnbit != 0)
    2231                 :            :                 {
    2232                 :       3813 :                   if (valv == sgnbit)
    2233                 :            :                     {
    2234                 :        398 :                       cst2n = true;
    2235                 :        398 :                       valn = true;
    2236                 :        398 :                       goto gt_expr;
    2237                 :            :                     }
    2238                 :       3415 :                   if (tem == wi::mask (nprec - 1, false, nprec))
    2239                 :            :                     {
    2240                 :        151 :                       cst2n = true;
    2241                 :        151 :                       goto lt_expr;
    2242                 :            :                     }
    2243                 :       3264 :                   if (!cst2n)
    2244                 :       1738 :                     sgnbit = wi::zero (nprec);
    2245                 :            :                 }
    2246                 :            :               break;
    2247                 :            : 
    2248                 :       1153 :             case GE_EXPR:
    2249                 :            :               /* Minimum unsigned value for >= if (VAL & CST2) == VAL
    2250                 :            :                  is VAL and maximum unsigned value is ~0.  For signed
    2251                 :            :                  comparison, if CST2 doesn't have most significant bit
    2252                 :            :                  set, handle it similarly.  If CST2 has MSB set,
    2253                 :            :                  the minimum is the same, and maximum is ~0U/2.  */
    2254                 :       1153 :               if (minv != valv)
    2255                 :            :                 {
    2256                 :            :                   /* If (VAL & CST2) != VAL, X & CST2 can't be equal to
    2257                 :            :                      VAL.  */
    2258                 :         26 :                   minv = masked_increment (valv, cst2v, sgnbit, nprec);
    2259                 :         26 :                   if (minv == valv)
    2260                 :            :                     break;
    2261                 :            :                 }
    2262                 :       1153 :               maxv = wi::mask (nprec - (cst2n ? 1 : 0), false, nprec);
    2263                 :       1153 :               valid_p = true;
    2264                 :       1153 :               break;
    2265                 :            : 
    2266                 :     370760 :             case GT_EXPR:
    2267                 :     370760 :             gt_expr:
    2268                 :            :               /* Find out smallest MINV where MINV > VAL
    2269                 :            :                  && (MINV & CST2) == MINV, if any.  If VAL is signed and
    2270                 :            :                  CST2 has MSB set, compute it biased by 1 << (nprec - 1).  */
    2271                 :     370760 :               minv = masked_increment (valv, cst2v, sgnbit, nprec);
    2272                 :     370760 :               if (minv == valv)
    2273                 :            :                 break;
    2274                 :     370758 :               maxv = wi::mask (nprec - (cst2n ? 1 : 0), false, nprec);
    2275                 :     370758 :               valid_p = true;
    2276                 :     370758 :               break;
    2277                 :            : 
    2278                 :      10517 :             case LE_EXPR:
    2279                 :            :               /* Minimum unsigned value for <= is 0 and maximum
    2280                 :            :                  unsigned value is VAL | ~CST2 if (VAL & CST2) == VAL.
    2281                 :            :                  Otherwise, find smallest VAL2 where VAL2 > VAL
    2282                 :            :                  && (VAL2 & CST2) == VAL2 and use (VAL2 - 1) | ~CST2
    2283                 :            :                  as maximum.
    2284                 :            :                  For signed comparison, if CST2 doesn't have most
    2285                 :            :                  significant bit set, handle it similarly.  If CST2 has
    2286                 :            :                  MSB set, the maximum is the same and minimum is INT_MIN.  */
    2287                 :      10517 :               if (minv == valv)
    2288                 :      10202 :                 maxv = valv;
    2289                 :            :               else
    2290                 :            :                 {
    2291                 :        315 :                   maxv = masked_increment (valv, cst2v, sgnbit, nprec);
    2292                 :        315 :                   if (maxv == valv)
    2293                 :            :                     break;
    2294                 :        314 :                   maxv -= 1;
    2295                 :            :                 }
    2296                 :      10516 :               maxv |= ~cst2v;
    2297                 :      10516 :               minv = sgnbit;
    2298                 :      10516 :               valid_p = true;
    2299                 :      10516 :               break;
    2300                 :            : 
    2301                 :      19789 :             case LT_EXPR:
    2302                 :      19789 :             lt_expr:
    2303                 :            :               /* Minimum unsigned value for < is 0 and maximum
    2304                 :            :                  unsigned value is (VAL-1) | ~CST2 if (VAL & CST2) == VAL.
    2305                 :            :                  Otherwise, find smallest VAL2 where VAL2 > VAL
    2306                 :            :                  && (VAL2 & CST2) == VAL2 and use (VAL2 - 1) | ~CST2
    2307                 :            :                  as maximum.
    2308                 :            :                  For signed comparison, if CST2 doesn't have most
    2309                 :            :                  significant bit set, handle it similarly.  If CST2 has
    2310                 :            :                  MSB set, the maximum is the same and minimum is INT_MIN.  */
    2311                 :      19789 :               if (minv == valv)
    2312                 :            :                 {
    2313                 :      19763 :                   if (valv == sgnbit)
    2314                 :            :                     break;
    2315                 :      19763 :                   maxv = valv;
    2316                 :            :                 }
    2317                 :            :               else
    2318                 :            :                 {
    2319                 :         26 :                   maxv = masked_increment (valv, cst2v, sgnbit, nprec);
    2320                 :         26 :                   if (maxv == valv)
    2321                 :            :                     break;
    2322                 :            :                 }
    2323                 :      19789 :               maxv -= 1;
    2324                 :      19789 :               maxv |= ~cst2v;
    2325                 :      19789 :               minv = sgnbit;
    2326                 :      19789 :               valid_p = true;
    2327                 :      19789 :               break;
    2328                 :            : 
    2329                 :            :             default:
    2330                 :            :               break;
    2331                 :            :             }
    2332                 :     737595 :           if (valid_p
    2333                 :    1510340 :               && (maxv - minv) != -1)
    2334                 :            :             {
    2335                 :            :               tree tmp, new_val, type;
    2336                 :            :               int i;
    2337                 :            : 
    2338                 :    2207180 :               for (i = 0; i < 2; i++)
    2339                 :    1471460 :                 if (names[i])
    2340                 :            :                   {
    2341                 :     764405 :                     wide_int maxv2 = maxv;
    2342                 :     764405 :                     tmp = names[i];
    2343                 :     764405 :                     type = TREE_TYPE (names[i]);
    2344                 :     764405 :                     if (!TYPE_UNSIGNED (type))
    2345                 :            :                       {
    2346                 :     239139 :                         type = build_nonstandard_integer_type (nprec, 1);
    2347                 :     239139 :                         tmp = build1 (NOP_EXPR, type, names[i]);
    2348                 :            :                       }
    2349                 :     764405 :                     if (minv != 0)
    2350                 :            :                       {
    2351                 :     454044 :                         tmp = build2 (PLUS_EXPR, type, tmp,
    2352                 :     454044 :                                       wide_int_to_tree (type, -minv));
    2353                 :     454044 :                         maxv2 = maxv - minv;
    2354                 :            :                       }
    2355                 :     764405 :                     new_val = wide_int_to_tree (type, maxv2);
    2356                 :     764405 :                     add_assert_info (asserts, names[i], tmp, LE_EXPR, new_val);
    2357                 :            :                   }
    2358                 :            :             }
    2359                 :            :         }
    2360                 :            :     }
    2361                 :            : }
    2362                 :            : 
    2363                 :            : /* OP is an operand of a truth value expression which is known to have
    2364                 :            :    a particular value.  Register any asserts for OP and for any
    2365                 :            :    operands in OP's defining statement.
    2366                 :            : 
    2367                 :            :    If CODE is EQ_EXPR, then we want to register OP is zero (false),
    2368                 :            :    if CODE is NE_EXPR, then we want to register OP is nonzero (true).   */
    2369                 :            : 
    2370                 :            : static void
    2371                 :    1400560 : register_edge_assert_for_1 (tree op, enum tree_code code,
    2372                 :            :                             edge e, vec<assert_info> &asserts)
    2373                 :            : {
    2374                 :    1467420 :   gimple *op_def;
    2375                 :    1467420 :   tree val;
    2376                 :    1467420 :   enum tree_code rhs_code;
    2377                 :            : 
    2378                 :            :   /* We only care about SSA_NAMEs.  */
    2379                 :    1467420 :   if (TREE_CODE (op) != SSA_NAME)
    2380                 :            :     return;
    2381                 :            : 
    2382                 :            :   /* We know that OP will have a zero or nonzero value.  */
    2383                 :    1248070 :   val = build_int_cst (TREE_TYPE (op), 0);
    2384                 :    1248070 :   add_assert_info (asserts, op, op, code, val);
    2385                 :            : 
    2386                 :            :   /* Now look at how OP is set.  If it's set from a comparison,
    2387                 :            :      a truth operation or some bit operations, then we may be able
    2388                 :            :      to register information about the operands of that assignment.  */
    2389                 :    1248070 :   op_def = SSA_NAME_DEF_STMT (op);
    2390                 :    1248070 :   if (gimple_code (op_def) != GIMPLE_ASSIGN)
    2391                 :            :     return;
    2392                 :            : 
    2393                 :    1137220 :   rhs_code = gimple_assign_rhs_code (op_def);
    2394                 :            : 
    2395                 :    1137220 :   if (TREE_CODE_CLASS (rhs_code) == tcc_comparison)
    2396                 :            :     {
    2397                 :     841575 :       bool invert = (code == EQ_EXPR ? true : false);
    2398                 :     841575 :       tree op0 = gimple_assign_rhs1 (op_def);
    2399                 :     841575 :       tree op1 = gimple_assign_rhs2 (op_def);
    2400                 :            : 
    2401                 :     841575 :       if (TREE_CODE (op0) == SSA_NAME)
    2402                 :     839696 :         register_edge_assert_for_2 (op0, e, rhs_code, op0, op1, invert, asserts);
    2403                 :     841575 :       if (TREE_CODE (op1) == SSA_NAME)
    2404                 :     210664 :         register_edge_assert_for_2 (op1, e, rhs_code, op0, op1, invert, asserts);
    2405                 :            :     }
    2406                 :     295640 :   else if ((code == NE_EXPR
    2407                 :     239618 :             && gimple_assign_rhs_code (op_def) == BIT_AND_EXPR)
    2408                 :     525821 :            || (code == EQ_EXPR
    2409                 :      56022 :                && gimple_assign_rhs_code (op_def) == BIT_IOR_EXPR))
    2410                 :            :     {
    2411                 :            :       /* Recurse on each operand.  */
    2412                 :      35560 :       tree op0 = gimple_assign_rhs1 (op_def);
    2413                 :      35560 :       tree op1 = gimple_assign_rhs2 (op_def);
    2414                 :      35560 :       if (TREE_CODE (op0) == SSA_NAME
    2415                 :      35560 :           && has_single_use (op0))
    2416                 :      32444 :         register_edge_assert_for_1 (op0, code, e, asserts);
    2417                 :      35560 :       if (TREE_CODE (op1) == SSA_NAME
    2418                 :      35560 :           && has_single_use (op1))
    2419                 :            :         register_edge_assert_for_1 (op1, code, e, asserts);
    2420                 :            :     }
    2421                 :     260080 :   else if (gimple_assign_rhs_code (op_def) == BIT_NOT_EXPR
    2422                 :     260080 :            && TYPE_PRECISION (TREE_TYPE (gimple_assign_lhs (op_def))) == 1)
    2423                 :            :     {
    2424                 :            :       /* Recurse, flipping CODE.  */
    2425                 :       5210 :       code = invert_tree_comparison (code, false);
    2426                 :       5210 :       register_edge_assert_for_1 (gimple_assign_rhs1 (op_def), code, e, asserts);
    2427                 :            :     }
    2428                 :     254870 :   else if (gimple_assign_rhs_code (op_def) == SSA_NAME)
    2429                 :            :     {
    2430                 :            :       /* Recurse through the copy.  */
    2431                 :          5 :       register_edge_assert_for_1 (gimple_assign_rhs1 (op_def), code, e, asserts);
    2432                 :            :     }
    2433                 :     254865 :   else if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (op_def)))
    2434                 :            :     {
    2435                 :            :       /* Recurse through the type conversion, unless it is a narrowing
    2436                 :            :          conversion or conversion from non-integral type.  */
    2437                 :      54485 :       tree rhs = gimple_assign_rhs1 (op_def);
    2438                 :     108222 :       if (INTEGRAL_TYPE_P (TREE_TYPE (rhs))
    2439                 :      94878 :           && (TYPE_PRECISION (TREE_TYPE (rhs))
    2440                 :      41141 :               <= TYPE_PRECISION (TREE_TYPE (op))))
    2441                 :            :         register_edge_assert_for_1 (rhs, code, e, asserts);
    2442                 :            :     }
    2443                 :            : }
    2444                 :            : 
    2445                 :            : /* Check if comparison
    2446                 :            :      NAME COND_OP INTEGER_CST
    2447                 :            :    has a form of
    2448                 :            :      (X & 11...100..0) COND_OP XX...X00...0
    2449                 :            :    Such comparison can yield assertions like
    2450                 :            :      X >= XX...X00...0
    2451                 :            :      X <= XX...X11...1
    2452                 :            :    in case of COND_OP being EQ_EXPR or
    2453                 :            :      X < XX...X00...0
    2454                 :            :      X > XX...X11...1
    2455                 :            :    in case of NE_EXPR.  */
    2456                 :            : 
    2457                 :            : static bool
    2458                 :   15118300 : is_masked_range_test (tree name, tree valt, enum tree_code cond_code,
    2459                 :            :                       tree *new_name, tree *low, enum tree_code *low_code,
    2460                 :            :                       tree *high, enum tree_code *high_code)
    2461                 :            : {
    2462                 :   15118300 :   gimple *def_stmt = SSA_NAME_DEF_STMT (name);
    2463                 :            : 
    2464                 :   15118300 :   if (!is_gimple_assign (def_stmt)
    2465                 :   15118300 :       || gimple_assign_rhs_code (def_stmt) != BIT_AND_EXPR)
    2466                 :            :     return false;
    2467                 :            : 
    2468                 :    1000600 :   tree t = gimple_assign_rhs1 (def_stmt);
    2469                 :    1000600 :   tree maskt = gimple_assign_rhs2 (def_stmt);
    2470                 :    1000600 :   if (TREE_CODE (t) != SSA_NAME || TREE_CODE (maskt) != INTEGER_CST)
    2471                 :            :     return false;
    2472                 :            : 
    2473                 :     504748 :   wi::tree_to_wide_ref mask = wi::to_wide (maskt);
    2474                 :     504748 :   wide_int inv_mask = ~mask;
    2475                 :            :   /* Must have been removed by now so don't bother optimizing.  */
    2476                 :     504748 :   if (mask == 0 || inv_mask == 0)
    2477                 :          0 :     return false;
    2478                 :            : 
    2479                 :            :   /* Assume VALT is INTEGER_CST.  */
    2480                 :     504748 :   wi::tree_to_wide_ref val = wi::to_wide (valt);
    2481                 :            : 
    2482                 :     515892 :   if ((inv_mask & (inv_mask + 1)) != 0
    2483                 :      11144 :       || (val & mask) != val)
    2484                 :     493604 :     return false;
    2485                 :            : 
    2486                 :      11144 :   bool is_range = cond_code == EQ_EXPR;
    2487                 :            : 
    2488                 :      11144 :   tree type = TREE_TYPE (t);
    2489                 :      11144 :   wide_int min = wi::min_value (type),
    2490                 :      11144 :     max = wi::max_value (type);
    2491                 :            : 
    2492                 :      11144 :   if (is_range)
    2493                 :            :     {
    2494                 :       6408 :       *low_code = val == min ? ERROR_MARK : GE_EXPR;
    2495                 :      12816 :       *high_code = val == max ? ERROR_MARK : LE_EXPR;
    2496                 :            :     }
    2497                 :            :   else
    2498                 :            :     {
    2499                 :            :       /* We can still generate assertion if one of alternatives
    2500                 :            :          is known to always be false.  */
    2501                 :       4736 :       if (val == min)
    2502                 :            :         {
    2503                 :       3591 :           *low_code = (enum tree_code) 0;
    2504                 :       3591 :           *high_code = GT_EXPR;
    2505                 :            :         }
    2506                 :       1145 :       else if ((val | inv_mask) == max)
    2507                 :            :         {
    2508                 :        138 :           *low_code = LT_EXPR;
    2509                 :        138 :           *high_code = (enum tree_code) 0;
    2510                 :            :         }
    2511                 :            :       else
    2512                 :            :         return false;
    2513                 :            :     }
    2514                 :            : 
    2515                 :      10137 :   *new_name = t;
    2516                 :      10137 :   *low = wide_int_to_tree (type, val);
    2517                 :      10137 :   *high = wide_int_to_tree (type, val | inv_mask);
    2518                 :            : 
    2519                 :      10137 :   return true;
    2520                 :            : }
    2521                 :            : 
    2522                 :            : /* Try to register an edge assertion for SSA name NAME on edge E for
    2523                 :            :    the condition COND contributing to the conditional jump pointed to by
    2524                 :            :    SI.  */
    2525                 :            : 
    2526                 :            : void
    2527                 :   28673700 : register_edge_assert_for (tree name, edge e,
    2528                 :            :                           enum tree_code cond_code, tree cond_op0,
    2529                 :            :                           tree cond_op1, vec<assert_info> &asserts)
    2530                 :            : {
    2531                 :   28673700 :   tree val;
    2532                 :   28673700 :   enum tree_code comp_code;
    2533                 :   28673700 :   bool is_else_edge = (e->flags & EDGE_FALSE_VALUE) != 0;
    2534                 :            : 
    2535                 :            :   /* Do not attempt to infer anything in names that flow through
    2536                 :            :      abnormal edges.  */
    2537                 :   28673700 :   if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
    2538                 :       1524 :     return;
    2539                 :            : 
    2540                 :   28673300 :   if (!extract_code_and_val_from_cond_with_ops (name, cond_code,
    2541                 :            :                                                 cond_op0, cond_op1,
    2542                 :            :                                                 is_else_edge,
    2543                 :            :                                                 &comp_code, &val))
    2544                 :            :     return;
    2545                 :            : 
    2546                 :            :   /* Register ASSERT_EXPRs for name.  */
    2547                 :   28672200 :   register_edge_assert_for_2 (name, e, cond_code, cond_op0,
    2548                 :            :                               cond_op1, is_else_edge, asserts);
    2549                 :            : 
    2550                 :            : 
    2551                 :            :   /* If COND is effectively an equality test of an SSA_NAME against
    2552                 :            :      the value zero or one, then we may be able to assert values
    2553                 :            :      for SSA_NAMEs which flow into COND.  */
    2554                 :            : 
    2555                 :            :   /* In the case of NAME == 1 or NAME != 0, for BIT_AND_EXPR defining
    2556                 :            :      statement of NAME we can assert both operands of the BIT_AND_EXPR
    2557                 :            :      have nonzero value.  */
    2558                 :   10366200 :   if (((comp_code == EQ_EXPR && integer_onep (val))
    2559                 :   38686600 :        || (comp_code == NE_EXPR && integer_zerop (val))))
    2560                 :            :     {
    2561                 :    6366310 :       gimple *def_stmt = SSA_NAME_DEF_STMT (name);
    2562                 :            : 
    2563                 :    6366310 :       if (is_gimple_assign (def_stmt)
    2564                 :    6366310 :           && gimple_assign_rhs_code (def_stmt) == BIT_AND_EXPR)
    2565                 :            :         {
    2566                 :     482569 :           tree op0 = gimple_assign_rhs1 (def_stmt);
    2567                 :     482569 :           tree op1 = gimple_assign_rhs2 (def_stmt);
    2568                 :     482569 :           register_edge_assert_for_1 (op0, NE_EXPR, e, asserts);
    2569                 :     482569 :           register_edge_assert_for_1 (op1, NE_EXPR, e, asserts);
    2570                 :            :         }
    2571                 :            :     }
    2572                 :            : 
    2573                 :            :   /* In the case of NAME == 0 or NAME != 1, for BIT_IOR_EXPR defining
    2574                 :            :      statement of NAME we can assert both operands of the BIT_IOR_EXPR
    2575                 :            :      have zero value.  */
    2576                 :   10366200 :   if (((comp_code == EQ_EXPR && integer_zerop (val))
    2577                 :   33959900 :        || (comp_code == NE_EXPR && integer_onep (val))))
    2578                 :            :     {
    2579                 :    5373050 :       gimple *def_stmt = SSA_NAME_DEF_STMT (name);
    2580                 :            : 
    2581                 :            :       /* For BIT_IOR_EXPR only if NAME == 0 both operands have
    2582                 :            :          necessarily zero value, or if type-precision is one.  */
    2583                 :    5373050 :       if (is_gimple_assign (def_stmt)
    2584                 :    5373050 :           && (gimple_assign_rhs_code (def_stmt) == BIT_IOR_EXPR
    2585                 :     201620 :               && (TYPE_PRECISION (TREE_TYPE (name)) == 1
    2586                 :      10265 :                   || comp_code == EQ_EXPR)))
    2587                 :            :         {
    2588                 :     201490 :           tree op0 = gimple_assign_rhs1 (def_stmt);
    2589                 :     201490 :           tree op1 = gimple_assign_rhs2 (def_stmt);
    2590                 :     201490 :           register_edge_assert_for_1 (op0, EQ_EXPR, e, asserts);
    2591                 :     201490 :           register_edge_assert_for_1 (op1, EQ_EXPR, e, asserts);
    2592                 :            :         }
    2593                 :            :     }
    2594                 :            : 
    2595                 :            :   /* Sometimes we can infer ranges from (NAME & MASK) == VALUE.  */
    2596                 :   28672200 :   if ((comp_code == EQ_EXPR || comp_code == NE_EXPR)
    2597                 :   21519800 :       && TREE_CODE (val) == INTEGER_CST)
    2598                 :            :     {
    2599                 :   15118300 :       enum tree_code low_code, high_code;
    2600                 :   15118300 :       tree low, high;
    2601                 :   15118300 :       if (is_masked_range_test (name, val, comp_code, &name, &low,
    2602                 :            :                                 &low_code, &high, &high_code))
    2603                 :            :         {
    2604                 :      10137 :           if (low_code != ERROR_MARK)
    2605                 :       1607 :             register_edge_assert_for_2 (name, e, low_code, name,
    2606                 :            :                                         low, /*invert*/false, asserts);
    2607                 :      10137 :           if (high_code != ERROR_MARK)
    2608                 :       9999 :             register_edge_assert_for_2 (name, e, high_code, name,
    2609                 :            :                                         high, /*invert*/false, asserts);
    2610                 :            :         }
    2611                 :            :     }
    2612                 :            : }
    2613                 :            : 
    2614                 :            : /* Finish found ASSERTS for E and register them at GSI.  */
    2615                 :            : 
    2616                 :            : static void
    2617                 :    9799280 : finish_register_edge_assert_for (edge e, gimple_stmt_iterator gsi,
    2618                 :            :                                  vec<assert_info> &asserts)
    2619                 :            : {
    2620                 :   47427700 :   for (unsigned i = 0; i < asserts.length (); ++i)
    2621                 :            :     /* Only register an ASSERT_EXPR if NAME was found in the sub-graph
    2622                 :            :        reachable from E.  */
    2623                 :   13914600 :     if (live_on_edge (e, asserts[i].name))
    2624                 :    3927330 :       register_new_assert_for (asserts[i].name, asserts[i].expr,
    2625                 :    3927330 :                                asserts[i].comp_code, asserts[i].val,
    2626                 :            :                                NULL, e, gsi);
    2627                 :    9799280 : }
    2628                 :            : 
    2629                 :            : 
    2630                 :            : 
    2631                 :            : /* Determine whether the outgoing edges of BB should receive an
    2632                 :            :    ASSERT_EXPR for each of the operands of BB's LAST statement.
    2633                 :            :    The last statement of BB must be a COND_EXPR.
    2634                 :            : 
    2635                 :            :    If any of the sub-graphs rooted at BB have an interesting use of
    2636                 :            :    the predicate operands, an assert location node is added to the
    2637                 :            :    list of assertions for the corresponding operands.  */
    2638                 :            : 
    2639                 :            : static void
    2640                 :    4851950 : find_conditional_asserts (basic_block bb, gcond *last)
    2641                 :            : {
    2642                 :    4851950 :   gimple_stmt_iterator bsi;
    2643                 :    4851950 :   tree op;
    2644                 :    4851950 :   edge_iterator ei;
    2645                 :    4851950 :   edge e;
    2646                 :    4851950 :   ssa_op_iter iter;
    2647                 :            : 
    2648                 :    4851950 :   bsi = gsi_for_stmt (last);
    2649                 :            : 
    2650                 :            :   /* Look for uses of the operands in each of the sub-graphs
    2651                 :            :      rooted at BB.  We need to check each of the outgoing edges
    2652                 :            :      separately, so that we know what kind of ASSERT_EXPR to
    2653                 :            :      insert.  */
    2654                 :   14555800 :   FOR_EACH_EDGE (e, ei, bb->succs)
    2655                 :            :     {
    2656                 :    9703900 :       if (e->dest == bb)
    2657                 :          0 :         continue;
    2658                 :            : 
    2659                 :            :       /* Register the necessary assertions for each operand in the
    2660                 :            :          conditional predicate.  */
    2661                 :   19407800 :       auto_vec<assert_info, 8> asserts;
    2662                 :   21704500 :       FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE)
    2663                 :   12000600 :         register_edge_assert_for (op, e,
    2664                 :            :                                   gimple_cond_code (last),
    2665                 :            :                                   gimple_cond_lhs (last),
    2666                 :            :                                   gimple_cond_rhs (last), asserts);
    2667                 :    9703900 :       finish_register_edge_assert_for (e, bsi, asserts);
    2668                 :            :     }
    2669                 :    4851950 : }
    2670                 :            : 
    2671                 :            : struct case_info
    2672                 :            : {
    2673                 :            :   tree expr;
    2674                 :            :   basic_block bb;
    2675                 :            : };
    2676                 :            : 
    2677                 :            : /* Compare two case labels sorting first by the destination bb index
    2678                 :            :    and then by the case value.  */
    2679                 :            : 
    2680                 :            : static int
    2681                 :    1402170 : compare_case_labels (const void *p1, const void *p2)
    2682                 :            : {
    2683                 :    1402170 :   const struct case_info *ci1 = (const struct case_info *) p1;
    2684                 :    1402170 :   const struct case_info *ci2 = (const struct case_info *) p2;
    2685                 :    1402170 :   int idx1 = ci1->bb->index;
    2686                 :    1402170 :   int idx2 = ci2->bb->index;
    2687                 :            : 
    2688                 :    1402170 :   if (idx1 < idx2)
    2689                 :            :     return -1;
    2690                 :     699941 :   else if (idx1 == idx2)
    2691                 :            :     {
    2692                 :            :       /* Make sure the default label is first in a group.  */
    2693                 :      91189 :       if (!CASE_LOW (ci1->expr))
    2694                 :            :         return -1;
    2695                 :      91189 :       else if (!CASE_LOW (ci2->expr))
    2696                 :            :         return 1;
    2697                 :            :       else
    2698                 :      91189 :         return tree_int_cst_compare (CASE_LOW (ci1->expr),
    2699                 :     182378 :                                      CASE_LOW (ci2->expr));
    2700                 :            :     }
    2701                 :            :   else
    2702                 :            :     return 1;
    2703                 :            : }
    2704                 :            : 
    2705                 :            : /* Determine whether the outgoing edges of BB should receive an
    2706                 :            :    ASSERT_EXPR for each of the operands of BB's LAST statement.
    2707                 :            :    The last statement of BB must be a SWITCH_EXPR.
    2708                 :            : 
    2709                 :            :    If any of the sub-graphs rooted at BB have an interesting use of
    2710                 :            :    the predicate operands, an assert location node is added to the
    2711                 :            :    list of assertions for the corresponding operands.  */
    2712                 :            : 
    2713                 :            : static void
    2714                 :      21246 : find_switch_asserts (basic_block bb, gswitch *last)
    2715                 :            : {
    2716                 :      21246 :   gimple_stmt_iterator bsi;
    2717                 :      21246 :   tree op;
    2718                 :      21246 :   edge e;
    2719                 :      21246 :   struct case_info *ci;
    2720                 :      21246 :   size_t n = gimple_switch_num_labels (last);
    2721                 :            : #if GCC_VERSION >= 4000
    2722                 :      21246 :   unsigned int idx;
    2723                 :            : #else
    2724                 :            :   /* Work around GCC 3.4 bug (PR 37086).  */
    2725                 :            :   volatile unsigned int idx;
    2726                 :            : #endif
    2727                 :            : 
    2728                 :      21246 :   bsi = gsi_for_stmt (last);
    2729                 :      21246 :   op = gimple_switch_index (last);
    2730                 :      21246 :   if (TREE_CODE (op) != SSA_NAME)
    2731                 :      16309 :     return;
    2732                 :            : 
    2733                 :            :   /* Build a vector of case labels sorted by destination label.  */
    2734                 :      21246 :   ci = XNEWVEC (struct case_info, n);
    2735                 :     145410 :   for (idx = 0; idx < n; ++idx)
    2736                 :            :     {
    2737                 :     124164 :       ci[idx].expr = gimple_switch_label (last, idx);
    2738                 :     124164 :       ci[idx].bb = label_to_block (cfun, CASE_LABEL (ci[idx].expr));
    2739                 :            :     }
    2740                 :      21246 :   edge default_edge = find_edge (bb, ci[0].bb);
    2741                 :      21246 :   qsort (ci, n, sizeof (struct case_info), compare_case_labels);
    2742                 :            : 
    2743                 :     132387 :   for (idx = 0; idx < n; ++idx)
    2744                 :            :     {
    2745                 :     111141 :       tree min, max;
    2746                 :     111141 :       tree cl = ci[idx].expr;
    2747                 :     111141 :       basic_block cbb = ci[idx].bb;
    2748                 :            : 
    2749                 :     111141 :       min = CASE_LOW (cl);
    2750                 :     111141 :       max = CASE_HIGH (cl);
    2751                 :            : 
    2752                 :            :       /* If there are multiple case labels with the same destination
    2753                 :            :          we need to combine them to a single value range for the edge.  */
    2754                 :     111141 :       if (idx + 1 < n && cbb == ci[idx + 1].bb)
    2755                 :            :         {
    2756                 :            :           /* Skip labels until the last of the group.  */
    2757                 :      19840 :           do {
    2758                 :      19840 :             ++idx;
    2759                 :      19840 :           } while (idx < n && cbb == ci[idx].bb);
    2760                 :       6817 :           --idx;
    2761                 :            : 
    2762                 :            :           /* Pick up the maximum of the case label range.  */
    2763                 :       6817 :           if (CASE_HIGH (ci[idx].expr))
    2764                 :        945 :             max = CASE_HIGH (ci[idx].expr);
    2765                 :            :           else
    2766                 :       5872 :             max = CASE_LOW (ci[idx].expr);
    2767                 :            :         }
    2768                 :            : 
    2769                 :            :       /* Can't extract a useful assertion out of a range that includes the
    2770                 :            :          default label.  */
    2771                 :     111141 :       if (min == NULL_TREE)
    2772                 :      21246 :         continue;
    2773                 :            : 
    2774                 :            :       /* Find the edge to register the assert expr on.  */
    2775                 :      89895 :       e = find_edge (bb, cbb);
    2776                 :            : 
    2777                 :            :       /* Register the necessary assertions for the operand in the
    2778                 :            :          SWITCH_EXPR.  */
    2779                 :     179790 :       auto_vec<assert_info, 8> asserts;
    2780                 :     259498 :       register_edge_assert_for (op, e,
    2781                 :            :                                 max ? GE_EXPR : EQ_EXPR,
    2782                 :      89895 :                                 op, fold_convert (TREE_TYPE (op), min),
    2783                 :            :                                 asserts);
    2784                 :      89895 :       if (max)
    2785                 :      20374 :         register_edge_assert_for (op, e, LE_EXPR, op,
    2786                 :      10187 :                                   fold_convert (TREE_TYPE (op), max),
    2787                 :            :                                   asserts);
    2788                 :      89895 :       finish_register_edge_assert_for (e, bsi, asserts);
    2789                 :            :     }
    2790                 :            : 
    2791                 :      21246 :   XDELETEVEC (ci);
    2792                 :            : 
    2793                 :      21246 :   if (!live_on_edge (default_edge, op))
    2794                 :            :     return;
    2795                 :            : 
    2796                 :            :   /* Now register along the default label assertions that correspond to the
    2797                 :            :      anti-range of each label.  */
    2798                 :       4937 :   int insertion_limit = param_max_vrp_switch_assertions;
    2799                 :       4937 :   if (insertion_limit == 0)
    2800                 :            :     return;
    2801                 :            : 
    2802                 :            :   /* We can't do this if the default case shares a label with another case.  */
    2803                 :       4937 :   tree default_cl = gimple_switch_default_label (last);
    2804                 :      15662 :   for (idx = 1; idx < n; idx++)
    2805                 :            :     {
    2806                 :      10779 :       tree min, max;
    2807                 :      10779 :       tree cl = gimple_switch_label (last, idx);
    2808                 :      10779 :       if (CASE_LABEL (cl) == CASE_LABEL (default_cl))
    2809                 :          0 :         continue;
    2810                 :            : 
    2811                 :      10779 :       min = CASE_LOW (cl);
    2812                 :      10779 :       max = CASE_HIGH (cl);
    2813                 :            : 
    2814                 :            :       /* Combine contiguous case ranges to reduce the number of assertions
    2815                 :            :          to insert.  */
    2816                 :      18718 :       for (idx = idx + 1; idx < n; idx++)
    2817                 :            :         {
    2818                 :      13792 :           tree next_min, next_max;
    2819                 :      13792 :           tree next_cl = gimple_switch_label (last, idx);
    2820                 :      13792 :           if (CASE_LABEL (next_cl) == CASE_LABEL (default_cl))
    2821                 :            :             break;
    2822                 :            : 
    2823                 :      13792 :           next_min = CASE_LOW (next_cl);
    2824                 :      13792 :           next_max = CASE_HIGH (next_cl);
    2825                 :            : 
    2826                 :      13792 :           wide_int difference = (wi::to_wide (next_min)
    2827                 :      19090 :                                  - wi::to_wide (max ? max : min));
    2828                 :      19645 :           if (wi::eq_p (difference, 1))
    2829                 :      15468 :             max = next_max ? next_max : next_min;
    2830                 :            :           else
    2831                 :            :             break;
    2832                 :            :         }
    2833                 :      10779 :       idx--;
    2834                 :            : 
    2835                 :      10779 :       if (max == NULL_TREE)
    2836                 :            :         {
    2837                 :            :           /* Register the assertion OP != MIN.  */
    2838                 :      10964 :           auto_vec<assert_info, 8> asserts;
    2839                 :       5482 :           min = fold_convert (TREE_TYPE (op), min);
    2840                 :       5482 :           register_edge_assert_for (op, default_edge, NE_EXPR, op, min,
    2841                 :            :                                     asserts);
    2842                 :       5482 :           finish_register_edge_assert_for (default_edge, bsi, asserts);
    2843                 :            :         }
    2844                 :            :       else
    2845                 :            :         {
    2846                 :            :           /* Register the assertion (unsigned)OP - MIN > (MAX - MIN),
    2847                 :            :              which will give OP the anti-range ~[MIN,MAX].  */
    2848                 :       5297 :           tree uop = fold_convert (unsigned_type_for (TREE_TYPE (op)), op);
    2849                 :       5297 :           min = fold_convert (TREE_TYPE (uop), min);
    2850                 :       5297 :           max = fold_convert (TREE_TYPE (uop), max);
    2851                 :            : 
    2852                 :       5297 :           tree lhs = fold_build2 (MINUS_EXPR, TREE_TYPE (uop), uop, min);
    2853                 :       5297 :           tree rhs = int_const_binop (MINUS_EXPR, max, min);
    2854                 :       5297 :           register_new_assert_for (op, lhs, GT_EXPR, rhs,
    2855                 :            :                                    NULL, default_edge, bsi);
    2856                 :            :         }
    2857                 :            : 
    2858                 :      10779 :       if (--insertion_limit == 0)
    2859                 :            :         break;
    2860                 :            :     }
    2861                 :            : }
    2862                 :            : 
    2863                 :            : 
    2864                 :            : /* Traverse all the statements in block BB looking for statements that
    2865                 :            :    may generate useful assertions for the SSA names in their operand.
    2866                 :            :    If a statement produces a useful assertion A for name N_i, then the
    2867                 :            :    list of assertions already generated for N_i is scanned to
    2868                 :            :    determine if A is actually needed.
    2869                 :            : 
    2870                 :            :    If N_i already had the assertion A at a location dominating the
    2871                 :            :    current location, then nothing needs to be done.  Otherwise, the
    2872                 :            :    new location for A is recorded instead.
    2873                 :            : 
    2874                 :            :    1- For every statement S in BB, all the variables used by S are
    2875                 :            :       added to bitmap FOUND_IN_SUBGRAPH.
    2876                 :            : 
    2877                 :            :    2- If statement S uses an operand N in a way that exposes a known
    2878                 :            :       value range for N, then if N was not already generated by an
    2879                 :            :       ASSERT_EXPR, create a new assert location for N.  For instance,
    2880                 :            :       if N is a pointer and the statement dereferences it, we can
    2881                 :            :       assume that N is not NULL.
    2882                 :            : 
    2883                 :            :    3- COND_EXPRs are a special case of #2.  We can derive range
    2884                 :            :       information from the predicate but need to insert different
    2885                 :            :       ASSERT_EXPRs for each of the sub-graphs rooted at the
    2886                 :            :       conditional block.  If the last statement of BB is a conditional
    2887                 :            :       expression of the form 'X op Y', then
    2888                 :            : 
    2889                 :            :       a) Remove X and Y from the set FOUND_IN_SUBGRAPH.
    2890                 :            : 
    2891                 :            :       b) If the conditional is the only entry point to the sub-graph
    2892                 :            :          corresponding to the THEN_CLAUSE, recurse into it.  On
    2893                 :            :          return, if X and/or Y are marked in FOUND_IN_SUBGRAPH, then
    2894                 :            :          an ASSERT_EXPR is added for the corresponding variable.
    2895                 :            : 
    2896                 :            :       c) Repeat step (b) on the ELSE_CLAUSE.
    2897                 :            : 
    2898                 :            :       d) Mark X and Y in FOUND_IN_SUBGRAPH.
    2899                 :            : 
    2900                 :            :       For instance,
    2901                 :            : 
    2902                 :            :             if (a == 9)
    2903                 :            :               b = a;
    2904                 :            :             else
    2905                 :            :               b = c + 1;
    2906                 :            : 
    2907                 :            :       In this case, an assertion on the THEN clause is useful to
    2908                 :            :       determine that 'a' is always 9 on that edge.  However, an assertion
    2909                 :            :       on the ELSE clause would be unnecessary.
    2910                 :            : 
    2911                 :            :    4- If BB does not end in a conditional expression, then we recurse
    2912                 :            :       into BB's dominator children.
    2913                 :            : 
    2914                 :            :    At the end of the recursive traversal, every SSA name will have a
    2915                 :            :    list of locations where ASSERT_EXPRs should be added.  When a new
    2916                 :            :    location for name N is found, it is registered by calling
    2917                 :            :    register_new_assert_for.  That function keeps track of all the
    2918                 :            :    registered assertions to prevent adding unnecessary assertions.
    2919                 :            :    For instance, if a pointer P_4 is dereferenced more than once in a
    2920                 :            :    dominator tree, only the location dominating all the dereference of
    2921                 :            :    P_4 will receive an ASSERT_EXPR.  */
    2922                 :            : 
    2923                 :            : static void
    2924                 :   12999200 : find_assert_locations_1 (basic_block bb, sbitmap live)
    2925                 :            : {
    2926                 :   12999200 :   gimple *last;
    2927                 :            : 
    2928                 :   12999200 :   last = last_stmt (bb);
    2929                 :            : 
    2930                 :            :   /* If BB's last statement is a conditional statement involving integer
    2931                 :            :      operands, determine if we need to add ASSERT_EXPRs.  */
    2932                 :   12999200 :   if (last
    2933                 :   12110100 :       && gimple_code (last) == GIMPLE_COND
    2934                 :    5144440 :       && !fp_predicate (last)
    2935                 :   17869800 :       && !ZERO_SSA_OPERANDS (last, SSA_OP_USE))
    2936                 :    4851950 :     find_conditional_asserts (bb, as_a <gcond *> (last));
    2937                 :            : 
    2938                 :            :   /* If BB's last statement is a switch statement involving integer
    2939                 :            :      operands, determine if we need to add ASSERT_EXPRs.  */
    2940                 :   12999200 :   if (last
    2941                 :   12110100 :       && gimple_code (last) == GIMPLE_SWITCH
    2942                 :   13020400 :       && !ZERO_SSA_OPERANDS (last, SSA_OP_USE))
    2943                 :      21246 :     find_switch_asserts (bb, as_a <gswitch *> (last));
    2944                 :            : 
    2945                 :            :   /* Traverse all the statements in BB marking used names and looking
    2946                 :            :      for statements that may infer assertions for their used operands.  */
    2947                 :   12999200 :   for (gimple_stmt_iterator si = gsi_last_bb (bb); !gsi_end_p (si);
    2948                 :  221990000 :        gsi_prev (&si))
    2949                 :            :     {
    2950                 :  104495000 :       gimple *stmt;
    2951                 :  104495000 :       tree op;
    2952                 :  104495000 :       ssa_op_iter i;
    2953                 :            : 
    2954                 :  104495000 :       stmt = gsi_stmt (si);
    2955                 :            : 
    2956                 :  104495000 :       if (is_gimple_debug (stmt))
    2957                 :   61236200 :         continue;
    2958                 :            : 
    2959                 :            :       /* See if we can derive an assertion for any of STMT's operands.  */
    2960                 :   78377800 :       FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE)
    2961                 :            :         {
    2962                 :   35118800 :           tree value;
    2963                 :   35118800 :           enum tree_code comp_code;
    2964                 :            : 
    2965                 :            :           /* If op is not live beyond this stmt, do not bother to insert
    2966                 :            :              asserts for it.  */
    2967                 :   35118800 :           if (!bitmap_bit_p (live, SSA_NAME_VERSION (op)))
    2968                 :   21553600 :             continue;
    2969                 :            : 
    2970                 :            :           /* If OP is used in such a way that we can infer a value
    2971                 :            :              range for it, and we don't find a previous assertion for
    2972                 :            :              it, create a new assertion location node for OP.  */
    2973                 :   13565200 :           if (infer_value_range (stmt, op, &comp_code, &value))
    2974                 :            :             {
    2975                 :            :               /* If we are able to infer a nonzero value range for OP,
    2976                 :            :                  then walk backwards through the use-def chain to see if OP
    2977                 :            :                  was set via a typecast.
    2978                 :            : 
    2979                 :            :                  If so, then we can also infer a nonzero value range
    2980                 :            :                  for the operand of the NOP_EXPR.  */
    2981                 :    4166050 :               if (comp_code == NE_EXPR && integer_zerop (value))
    2982                 :            :                 {
    2983                 :    4166050 :                   tree t = op;
    2984                 :    4166050 :                   gimple *def_stmt = SSA_NAME_DEF_STMT (t);
    2985                 :            : 
    2986                 :    4166050 :                   while (is_gimple_assign (def_stmt)
    2987                 :    1008330 :                          && CONVERT_EXPR_CODE_P
    2988                 :            :                              (gimple_assign_rhs_code (def_stmt))
    2989                 :     122731 :                          && TREE_CODE
    2990                 :            :                              (gimple_assign_rhs1 (def_stmt)) == SSA_NAME
    2991                 :    4288780 :                          && POINTER_TYPE_P
    2992                 :            :                              (TREE_TYPE (gimple_assign_rhs1 (def_stmt))))
    2993                 :            :                     {
    2994                 :          0 :                       t = gimple_assign_rhs1 (def_stmt);
    2995                 :          0 :                       def_stmt = SSA_NAME_DEF_STMT (t);
    2996                 :            : 
    2997                 :            :                       /* Note we want to register the assert for the
    2998                 :            :                          operand of the NOP_EXPR after SI, not after the
    2999                 :            :                          conversion.  */
    3000                 :          0 :                       if (bitmap_bit_p (live, SSA_NAME_VERSION (t)))
    3001                 :          0 :                         register_new_assert_for (t, t, comp_code, value,
    3002                 :            :                                                  bb, NULL, si);
    3003                 :            :                     }
    3004                 :            :                 }
    3005                 :            : 
    3006                 :    4166050 :               register_new_assert_for (op, op, comp_code, value, bb, NULL, si);
    3007                 :            :             }
    3008                 :            :         }
    3009                 :            : 
    3010                 :            :       /* Update live.  */
    3011                 :   78377800 :       FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE)
    3012                 :   35118800 :         bitmap_set_bit (live, SSA_NAME_VERSION (op));
    3013                 :   62998800 :       FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_DEF)
    3014                 :   19739800 :         bitmap_clear_bit (live, SSA_NAME_VERSION (op));
    3015                 :            :     }
    3016                 :            : 
    3017                 :            :   /* Traverse all PHI nodes in BB, updating live.  */
    3018                 :   18535900 :   for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si);
    3019                 :    5536760 :        gsi_next (&si))
    3020                 :            :     {
    3021                 :    5536760 :       use_operand_p arg_p;
    3022                 :    5536760 :       ssa_op_iter i;
    3023                 :    5536760 :       gphi *phi = si.phi ();
    3024                 :    5536760 :       tree res = gimple_phi_result (phi);
    3025                 :            : 
    3026                 :   11073500 :       if (virtual_operand_p (res))
    3027                 :    2524550 :         continue;
    3028                 :            : 
    3029                 :    9351020 :       FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_USE)
    3030                 :            :         {
    3031                 :    6338820 :           tree arg = USE_FROM_PTR (arg_p);
    3032                 :    6338820 :           if (TREE_CODE (arg) == SSA_NAME)
    3033                 :   11037100 :             bitmap_set_bit (live, SSA_NAME_VERSION (arg));
    3034                 :            :         }
    3035                 :            : 
    3036                 :    3012210 :       bitmap_clear_bit (live, SSA_NAME_VERSION (res));
    3037                 :            :     }
    3038                 :   12999200 : }
    3039                 :            : 
    3040                 :            : /* Do an RPO walk over the function computing SSA name liveness
    3041                 :            :    on-the-fly and deciding on assert expressions to insert.  */
    3042                 :            : 
    3043                 :            : static void
    3044                 :    1290530 : find_assert_locations (void)
    3045                 :            : {
    3046                 :    1290530 :   int *rpo = XNEWVEC (int, last_basic_block_for_fn (cfun));
    3047                 :    1290530 :   int *bb_rpo = XNEWVEC (int, last_basic_block_for_fn (cfun));
    3048                 :    1290530 :   int *last_rpo = XCNEWVEC (int, last_basic_block_for_fn (cfun));
    3049                 :    1290530 :   int rpo_cnt, i;
    3050                 :            : 
    3051                 :    1290530 :   live = XCNEWVEC (sbitmap, last_basic_block_for_fn (cfun));
    3052                 :    1290530 :   rpo_cnt = pre_and_rev_post_order_compute (NULL, rpo, false);
    3053                 :   14289700 :   for (i = 0; i < rpo_cnt; ++i)
    3054                 :   12999200 :     bb_rpo[rpo[i]] = i;
    3055                 :            : 
    3056                 :            :   /* Pre-seed loop latch liveness from loop header PHI nodes.  Due to
    3057                 :            :      the order we compute liveness and insert asserts we otherwise
    3058                 :            :      fail to insert asserts into the loop latch.  */
    3059                 :    1290530 :   loop_p loop;
    3060                 :    1966550 :   FOR_EACH_LOOP (loop, 0)
    3061                 :            :     {
    3062                 :     676016 :       i = loop->latch->index;
    3063                 :     676016 :       unsigned int j = single_succ_edge (loop->latch)->dest_idx;
    3064                 :     676016 :       for (gphi_iterator gsi = gsi_start_phis (loop->header);
    3065                 :    2221530 :            !gsi_end_p (gsi); gsi_next (&gsi))
    3066                 :            :         {
    3067                 :    1545520 :           gphi *phi = gsi.phi ();
    3068                 :    3091030 :           if (virtual_operand_p (gimple_phi_result (phi)))
    3069                 :     500544 :             continue;
    3070                 :    1044970 :           tree arg = gimple_phi_arg_def (phi, j);
    3071                 :    1044970 :           if (TREE_CODE (arg) == SSA_NAME)
    3072                 :            :             {
    3073                 :    1036780 :               if (live[i] == NULL)
    3074                 :            :                 {
    3075                 :    1190350 :                   live[i] = sbitmap_alloc (num_ssa_names);
    3076                 :     595175 :                   bitmap_clear (live[i]);
    3077                 :            :                 }
    3078                 :    2582300 :               bitmap_set_bit (live[i], SSA_NAME_VERSION (arg));
    3079                 :            :             }
    3080                 :            :         }
    3081                 :            :     }
    3082                 :            : 
    3083                 :   14289700 :   for (i = rpo_cnt - 1; i >= 0; --i)
    3084                 :            :     {
    3085                 :   12999200 :       basic_block bb = BASIC_BLOCK_FOR_FN (cfun, rpo[i]);
    3086                 :   12999200 :       edge e;
    3087                 :   12999200 :       edge_iterator ei;
    3088                 :            : 
    3089                 :   12999200 :       if (!live[rpo[i]])
    3090                 :            :         {
    3091                 :    8333370 :           live[rpo[i]] = sbitmap_alloc (num_ssa_names);
    3092                 :    4166680 :           bitmap_clear (live[rpo[i]]);
    3093                 :            :         }
    3094                 :            : 
    3095                 :            :       /* Process BB and update the live information with uses in
    3096                 :            :          this block.  */
    3097                 :   12999200 :       find_assert_locations_1 (bb, live[rpo[i]]);
    3098                 :            : 
    3099                 :            :       /* Merge liveness into the predecessor blocks and free it.  */
    3100                 :   12999200 :       if (!bitmap_empty_p (live[rpo[i]]))
    3101                 :            :         {
    3102                 :   10134800 :           int pred_rpo = i;
    3103                 :   23609200 :           FOR_EACH_EDGE (e, ei, bb->preds)
    3104                 :            :             {
    3105                 :   13474400 :               int pred = e->src->index;
    3106                 :   13474400 :               if ((e->flags & EDGE_DFS_BACK) || pred == ENTRY_BLOCK)
    3107                 :    1326650 :                 continue;
    3108                 :            : 
    3109                 :   12147700 :               if (!live[pred])
    3110                 :            :                 {
    3111                 :   16888300 :                   live[pred] = sbitmap_alloc (num_ssa_names);
    3112                 :    8444140 :                   bitmap_clear (live[pred]);
    3113                 :            :                 }
    3114                 :   12147700 :               bitmap_ior (live[pred], live[pred], live[rpo[i]]);
    3115                 :            : 
    3116                 :   12147700 :               if (bb_rpo[pred] < pred_rpo)
    3117                 :            :                 pred_rpo = bb_rpo[pred];
    3118                 :            :             }
    3119                 :            : 
    3120                 :            :           /* Record the RPO number of the last visited block that needs
    3121                 :            :              live information from this block.  */
    3122                 :   10134800 :           last_rpo[rpo[i]] = pred_rpo;
    3123                 :            :         }
    3124                 :            :       else
    3125                 :            :         {
    3126                 :    2864360 :           sbitmap_free (live[rpo[i]]);
    3127                 :    2864360 :           live[rpo[i]] = NULL;
    3128                 :            :         }
    3129                 :            : 
    3130                 :            :       /* We can free all successors live bitmaps if all their
    3131                 :            :          predecessors have been visited already.  */
    3132                 :   31308500 :       FOR_EACH_EDGE (e, ei, bb->succs)
    3133                 :   18309400 :         if (last_rpo[e->dest->index] == i
    3134                 :   10140100 :             && live[e->dest->index])
    3135                 :            :           {
    3136                 :    9148340 :             sbitmap_free (live[e->dest->index]);
    3137                 :    9148340 :             live[e->dest->index] = NULL;
    3138                 :            :           }
    3139                 :            :     }
    3140                 :            : 
    3141                 :    1290530 :   XDELETEVEC (rpo);
    3142                 :    1290530 :   XDELETEVEC (bb_rpo);
    3143                 :    1290530 :   XDELETEVEC (last_rpo);
    3144                 :   16959200 :   for (i = 0; i < last_basic_block_for_fn (cfun); ++i)
    3145                 :   15668700 :     if (live[i])
    3146                 :   15668700 :       sbitmap_free (live[i]);
    3147                 :    1290530 :   XDELETEVEC (live);
    3148                 :    1290530 : }
    3149                 :            : 
    3150                 :            : /* Create an ASSERT_EXPR for NAME and insert it in the location
    3151                 :            :    indicated by LOC.  Return true if we made any edge insertions.  */
    3152                 :            : 
    3153                 :            : static bool
    3154                 :    5660610 : process_assert_insertions_for (tree name, assert_locus *loc)
    3155                 :            : {
    3156                 :            :   /* Build the comparison expression NAME_i COMP_CODE VAL.  */
    3157                 :    5660610 :   gimple *stmt;
    3158                 :    5660610 :   tree cond;
    3159                 :    5660610 :   gimple *assert_stmt;
    3160                 :    5660610 :   edge_iterator ei;
    3161                 :    5660610 :   edge e;
    3162                 :            : 
    3163                 :            :   /* If we have X <=> X do not insert an assert expr for that.  */
    3164                 :    5660610 :   if (loc->expr == loc->val)
    3165                 :            :     return false;
    3166                 :            : 
    3167                 :    5660610 :   cond = build2 (loc->comp_code, boolean_type_node, loc->expr, loc->val);
    3168                 :    5660610 :   assert_stmt = build_assert_expr_for (cond, name);
    3169                 :    5660610 :   if (loc->e)
    3170                 :            :     {
    3171                 :            :       /* We have been asked to insert the assertion on an edge.  This
    3172                 :            :          is used only by COND_EXPR and SWITCH_EXPR assertions.  */
    3173                 :    3912220 :       gcc_checking_assert (gimple_code (gsi_stmt (loc->si)) == GIMPLE_COND
    3174                 :            :                            || (gimple_code (gsi_stmt (loc->si))
    3175                 :            :                                == GIMPLE_SWITCH));
    3176                 :            : 
    3177                 :    3912220 :       gsi_insert_on_edge (loc->e, assert_stmt);
    3178                 :    3912220 :       return true;
    3179                 :            :     }
    3180                 :            : 
    3181                 :            :   /* If the stmt iterator points at the end then this is an insertion
    3182                 :            :      at the beginning of a block.  */
    3183                 :    1748400 :   if (gsi_end_p (loc->si))
    3184                 :            :     {
    3185                 :       4068 :       gimple_stmt_iterator si = gsi_after_labels (loc->bb);
    3186                 :       4068 :       gsi_insert_before (&si, assert_stmt, GSI_SAME_STMT);
    3187                 :       4068 :       return false;
    3188                 :            : 
    3189                 :            :     }
    3190                 :            :   /* Otherwise, we can insert right after LOC->SI iff the
    3191                 :            :      statement must not be the last statement in the block.  */
    3192                 :    1744330 :   stmt = gsi_stmt (loc->si);
    3193                 :    1744330 :   if (!stmt_ends_bb_p (stmt))
    3194                 :            :     {
    3195                 :    1704440 :       gsi_insert_after (&loc->si, assert_stmt, GSI_SAME_STMT);
    3196                 :    1704440 :       return false;
    3197                 :            :     }
    3198                 :            : 
    3199                 :            :   /* If STMT must be the last statement in BB, we can only insert new
    3200                 :            :      assertions on the non-abnormal edge out of BB.  Note that since
    3201                 :            :      STMT is not control flow, there may only be one non-abnormal/eh edge
    3202                 :            :      out of BB.  */
    3203                 :      74821 :   FOR_EACH_EDGE (e, ei, loc->bb->succs)
    3204                 :      74821 :     if (!(e->flags & (EDGE_ABNORMAL|EDGE_EH)))
    3205                 :            :       {
    3206                 :      39889 :         gsi_insert_on_edge (e, assert_stmt);
    3207                 :      39889 :         return true;
    3208                 :            :       }
    3209                 :            : 
    3210                 :          0 :   gcc_unreachable ();
    3211                 :            : }
    3212                 :            : 
    3213                 :            : /* Qsort helper for sorting assert locations.  If stable is true, don't
    3214                 :            :    use iterative_hash_expr because it can be unstable for -fcompare-debug,
    3215                 :            :    on the other side some pointers might be NULL.  */
    3216                 :            : 
    3217                 :            : template <bool stable>
    3218                 :            : static int
    3219                 :   44959700 : compare_assert_loc (const void *pa, const void *pb)
    3220                 :            : {
    3221                 :   44959700 :   assert_locus * const a = *(assert_locus * const *)pa;
    3222                 :   44959700 :   assert_locus * const b = *(assert_locus * const *)pb;
    3223                 :            : 
    3224                 :            :   /* If stable, some asserts might be optimized away already, sort
    3225                 :            :      them last.  */
    3226                 :            :   if (stable)
    3227                 :            :     {
    3228                 :   21921200 :       if (a == NULL)
    3229                 :      35786 :         return b != NULL;
    3230                 :   21885400 :       else if (b == NULL)
    3231                 :            :         return -1;
    3232                 :            :     }
    3233                 :            : 
    3234                 :   44885400 :   if (a->e == NULL && b->e != NULL)
    3235                 :            :     return 1;
    3236                 :   44215300 :   else if (a->e != NULL && b->e == NULL)
    3237                 :            :     return -1;
    3238                 :            : 
    3239                 :            :   /* After the above checks, we know that (a->e == NULL) == (b->e == NULL),
    3240                 :            :      no need to test both a->e and b->e.  */
    3241                 :            : 
    3242                 :            :   /* Sort after destination index.  */
    3243                 :   43400200 :   if (a->e == NULL)
    3244                 :            :     ;
    3245                 :   35381000 :   else if (a->e->dest->index > b->e->dest->index)
    3246                 :            :     return 1;
    3247                 :   19495500 :   else if (a->e->dest->index < b->e->dest->index)
    3248                 :            :     return -1;
    3249                 :            : 
    3250                 :            :   /* Sort after comp_code.  */
    3251                 :    9735460 :   if (a->comp_code > b->comp_code)
    3252                 :            :     return 1;
    3253                 :    9339770 :   else if (a->comp_code < b->comp_code)
    3254                 :            :     return -1;
    3255                 :            : 
    3256                 :            :   hashval_t ha, hb;
    3257                 :            : 
    3258                 :            :   /* E.g. if a->val is ADDR_EXPR of a VAR_DECL, iterative_hash_expr
    3259                 :            :      uses DECL_UID of the VAR_DECL, so sorting might differ between
    3260                 :            :      -g and -g0.  When doing the removal of redundant assert exprs
    3261                 :            :      and commonization to successors, this does not matter, but for
    3262                 :            :      the final sort needs to be stable.  */
    3263                 :            :   if (stable)
    3264                 :            :     {
    3265                 :    4328330 :       ha = 0;
    3266                 :    4328330 :       hb = 0;
    3267                 :            :     }
    3268                 :            :   else
    3269                 :            :     {
    3270                 :    4537780 :       ha = iterative_hash_expr (a->expr, iterative_hash_expr (a->val, 0));
    3271                 :    4537780 :       hb = iterative_hash_expr (b->expr, iterative_hash_expr (b->val, 0));
    3272                 :            :     }
    3273                 :            : 
    3274                 :            :   /* Break the tie using hashing and source/bb index.  */
    3275                 :    4537780 :   if (ha == hb)
    3276                 :    4157100 :     return (a->e != NULL
    3277                 :     468096 :             ? a->e->src->index - b->e->src->index
    3278                 :    8485430 :             : a->bb->index - b->bb->index);
    3279                 :     380679 :   return ha > hb ? 1 : -1;
    3280                 :            : }
    3281                 :            : 
    3282                 :            : /* Process all the insertions registered for every name N_i registered
    3283                 :            :    in NEED_ASSERT_FOR.  The list of assertions to be inserted are
    3284                 :            :    found in ASSERTS_FOR[i].  */
    3285                 :            : 
    3286                 :            : static void
    3287                 :     585699 : process_assert_insertions (void)
    3288                 :            : {
    3289                 :     585699 :   unsigned i;
    3290                 :     585699 :   bitmap_iterator bi;
    3291                 :     585699 :   bool update_edges_p = false;
    3292                 :     585699 :   int num_asserts = 0;
    3293                 :            : 
    3294                 :     585699 :   if (dump_file && (dump_flags & TDF_DETAILS))
    3295                 :         33 :     dump_all_asserts (dump_file);
    3296                 :            : 
    3297                 :    4149870 :   EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi)
    3298                 :            :     {
    3299                 :    3564170 :       assert_locus *loc = asserts_for[i];
    3300                 :    3564170 :       gcc_assert (loc);
    3301                 :            : 
    3302                 :    7128340 :       auto_vec<assert_locus *, 16> asserts;
    3303                 :    9229650 :       for (; loc; loc = loc->next)
    3304                 :    5665480 :         asserts.safe_push (loc);
    3305                 :    3564170 :       asserts.qsort (compare_assert_loc<false>);
    3306                 :            : 
    3307                 :            :       /* Push down common asserts to successors and remove redundant ones.  */
    3308                 :            :       unsigned ecnt = 0;
    3309                 :            :       assert_locus *common = NULL;
    3310                 :            :       unsigned commonj = 0;
    3311                 :   18459300 :       for (unsigned j = 0; j < asserts.length (); ++j)
    3312                 :            :         {
    3313                 :    5665480 :           loc = asserts[j];
    3314                 :    5665480 :           if (! loc->e)
    3315                 :            :             common = NULL;
    3316                 :    3921150 :           else if (! common
    3317                 :    1586180 :                    || loc->e->dest != common->e->dest
    3318                 :     147370 :                    || loc->comp_code != common->comp_code
    3319                 :      52871 :                    || ! operand_equal_p (loc->val, common->val, 0)
    3320                 :    3934240 :                    || ! operand_equal_p (loc->expr, common->expr, 0))
    3321                 :            :             {
    3322                 :    3910360 :               commonj = j;
    3323                 :    3910360 :               common = loc;
    3324                 :    3910360 :               ecnt = 1;
    3325                 :            :             }
    3326                 :      10788 :           else if (loc->e == asserts[j-1]->e)
    3327                 :            :             {
    3328                 :            :               /* Remove duplicate asserts.  */
    3329                 :         17 :               if (commonj == j - 1)
    3330                 :            :                 {
    3331                 :         17 :                   commonj = j;
    3332                 :         17 :                   common = loc;
    3333                 :            :                 }
    3334                 :         17 :               free (asserts[j-1]);
    3335                 :         17 :               asserts[j-1] = NULL;
    3336                 :            :             }
    3337                 :            :           else
    3338                 :            :             {
    3339                 :      10771 :               ecnt++;
    3340                 :      21542 :               if (EDGE_COUNT (common->e->dest->preds) == ecnt)
    3341                 :            :                 {
    3342                 :            :                   /* We have the same assertion on all incoming edges of a BB.
    3343                 :            :                      Insert it at the beginning of that block.  */
    3344                 :       4068 :                   loc->bb = loc->e->dest;
    3345                 :       4068 :                   loc->e = NULL;
    3346                 :       4068 :                   loc->si = gsi_none ();
    3347                 :       4068 :                   common = NULL;
    3348                 :            :                   /* Clear asserts commoned.  */
    3349                 :       8914 :                   for (; commonj != j; ++commonj)
    3350                 :       4846 :                     if (asserts[commonj])
    3351                 :            :                       {
    3352                 :       4846 :                         free (asserts[commonj]);
    3353                 :       4846 :                         asserts[commonj] = NULL;
    3354                 :            :                       }
    3355                 :            :                 }
    3356                 :            :             }
    3357                 :            :         }
    3358                 :            : 
    3359                 :            :       /* The asserts vector sorting above might be unstable for
    3360                 :            :          -fcompare-debug, sort again to ensure a stable sort.  */
    3361                 :    3564170 :       asserts.qsort (compare_assert_loc<true>);
    3362                 :   18449600 :       for (unsigned j = 0; j < asserts.length (); ++j)
    3363                 :            :         {
    3364                 :    5664310 :           loc = asserts[j];
    3365                 :    5664310 :           if (! loc)
    3366                 :            :             break;
    3367                 :    5660610 :           update_edges_p |= process_assert_insertions_for (ssa_name (i), loc);
    3368                 :    5660610 :           num_asserts++;
    3369                 :    5660610 :           free (loc);
    3370                 :            :         }
    3371                 :            :     }
    3372                 :            : 
    3373                 :     585699 :   if (update_edges_p)
    3374                 :     458352 :     gsi_commit_edge_inserts ();
    3375                 :            : 
    3376                 :     585699 :   statistics_counter_event (cfun, "Number of ASSERT_EXPR expressions inserted",
    3377                 :            :                             num_asserts);
    3378                 :     585699 : }
    3379                 :            : 
    3380                 :            : 
    3381                 :            : /* Traverse the flowgraph looking for conditional jumps to insert range
    3382                 :            :    expressions.  These range expressions are meant to provide information
    3383                 :            :    to optimizations that need to reason in terms of value ranges.  They
    3384                 :            :    will not be expanded into RTL.  For instance, given:
    3385                 :            : 
    3386                 :            :    x = ...
    3387                 :            :    y = ...
    3388                 :            :    if (x < y)
    3389                 :            :      y = x - 2;
    3390                 :            :    else
    3391                 :            :      x = y + 3;
    3392                 :            : 
    3393                 :            :    this pass will transform the code into:
    3394                 :            : 
    3395                 :            :    x = ...
    3396                 :            :    y = ...
    3397                 :            :    if (x < y)
    3398                 :            :     {
    3399                 :            :       x = ASSERT_EXPR <x, x < y>
    3400                 :            :       y = x - 2
    3401                 :            :     }
    3402                 :            :    else
    3403                 :            :     {
    3404                 :            :       y = ASSERT_EXPR <y, x >= y>
    3405                 :            :       x = y + 3
    3406                 :            :     }
    3407                 :            : 
    3408                 :            :    The idea is that once copy and constant propagation have run, other
    3409                 :            :    optimizations will be able to determine what ranges of values can 'x'
    3410                 :            :    take in different paths of the code, simply by checking the reaching
    3411                 :            :    definition of 'x'.  */
    3412                 :            : 
    3413                 :            : static void
    3414                 :    1290530 : insert_range_assertions (void)
    3415                 :            : {
    3416                 :    1290530 :   need_assert_for = BITMAP_ALLOC (NULL);
    3417                 :    2581070 :   asserts_for = XCNEWVEC (assert_locus *, num_ssa_names);
    3418                 :            : 
    3419                 :    1290530 :   calculate_dominance_info (CDI_DOMINATORS);
    3420                 :            : 
    3421                 :    1290530 :   find_assert_locations ();
    3422                 :    1290530 :   if (!bitmap_empty_p (need_assert_for))
    3423                 :            :     {
    3424                 :     585699 :       process_assert_insertions ();
    3425                 :     585699 :       update_ssa (TODO_update_ssa_no_phi);
    3426                 :            :     }
    3427                 :            : 
    3428                 :    1290530 :   if (dump_file && (dump_flags & TDF_DETAILS))
    3429                 :            :     {
    3430                 :         40 :       fprintf (dump_file, "\nSSA form after inserting ASSERT_EXPRs\n");
    3431                 :         40 :       dump_function_to_file (current_function_decl, dump_file, dump_flags);
    3432                 :            :     }
    3433                 :            : 
    3434                 :    1290530 :   free (asserts_for);
    3435                 :    1290530 :   BITMAP_FREE (need_assert_for);
    3436                 :    1290530 : }
    3437                 :            : 
    3438                 :    3871600 : class vrp_prop : public ssa_propagation_engine
    3439                 :            : {
    3440                 :            :  public:
    3441                 :            :   enum ssa_prop_result visit_stmt (gimple *, edge *, tree *) FINAL OVERRIDE;
    3442                 :            :   enum ssa_prop_result visit_phi (gphi *) FINAL OVERRIDE;
    3443                 :            : 
    3444                 :            :   void vrp_initialize (void);
    3445                 :            :   void vrp_finalize (bool);
    3446                 :            :   void check_all_array_refs (void);
    3447                 :            :   bool check_array_ref (location_t, tree, bool);
    3448                 :            :   bool check_mem_ref (location_t, tree, bool);
    3449                 :            :   void search_for_addr_array (tree, location_t);
    3450                 :            : 
    3451                 :            :   class vr_values vr_values;
    3452                 :            :   /* Temporary delegator to minimize code churn.  */
    3453                 :   52323500 :   const value_range_equiv *get_value_range (const_tree op)
    3454                 :   52323500 :     { return vr_values.get_value_range (op); }
    3455                 :    2785790 :   void set_def_to_varying (const_tree def)
    3456                 :    2785790 :     { vr_values.set_def_to_varying (def); }
    3457                 :   93869200 :   void set_defs_to_varying (gimple *stmt)
    3458                 :   93869200 :     { vr_values.set_defs_to_varying (stmt); }
    3459                 :   29922100 :   void extract_range_from_stmt (gimple *stmt, edge *taken_edge_p,
    3460                 :            :                                 tree *output_p, value_range_equiv *vr)
    3461                 :   29922100 :     { vr_values.extract_range_from_stmt (stmt, taken_edge_p, output_p, vr); }
    3462                 :   26661500 :   bool update_value_range (const_tree op, value_range_equiv *vr)
    3463                 :   26661500 :     { return vr_values.update_value_range (op, vr); }
    3464                 :     110831 :   void extract_range_basic (value_range_equiv *vr, gimple *stmt)
    3465                 :     110831 :     { vr_values.extract_range_basic (vr, stmt); }
    3466                 :    5244430 :   void extract_range_from_phi_node (gphi *phi, value_range_equiv *vr)
    3467                 :    5244430 :     { vr_values.extract_range_from_phi_node (phi, vr); }
    3468                 :            : };
    3469                 :            : /* Checks one ARRAY_REF in REF, located at LOCUS. Ignores flexible arrays
    3470                 :            :    and "struct" hacks. If VRP can determine that the
    3471                 :            :    array subscript is a constant, check if it is outside valid
    3472                 :            :    range. If the array subscript is a RANGE, warn if it is
    3473                 :            :    non-overlapping with valid range.
    3474                 :            :    IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside a ADDR_EXPR.
    3475                 :            :    Returns true if a warning has been issued.  */
    3476                 :            : 
    3477                 :            : bool
    3478                 :     191882 : vrp_prop::check_array_ref (location_t location, tree ref,
    3479                 :            :                            bool ignore_off_by_one)
    3480                 :            : {
    3481                 :     191882 :   if (TREE_NO_WARNING (ref))
    3482                 :            :     return false;
    3483                 :            : 
    3484                 :     191823 :   tree low_sub = TREE_OPERAND (ref, 1);
    3485                 :     191823 :   tree up_sub = low_sub;
    3486                 :     191823 :   tree up_bound = array_ref_up_bound (ref);
    3487                 :            : 
    3488                 :            :   /* Referenced decl if one can be determined.  */
    3489                 :     191823 :   tree decl = NULL_TREE;
    3490                 :            : 
    3491                 :            :   /* Set for accesses to interior zero-length arrays.  */
    3492                 :     191823 :   bool interior_zero_len = false;
    3493                 :            : 
    3494                 :     191823 :   tree up_bound_p1;
    3495                 :            : 
    3496                 :     191823 :   if (!up_bound
    3497                 :     124493 :       || TREE_CODE (up_bound) != INTEGER_CST
    3498                 :     314880 :       || (warn_array_bounds < 2
    3499                 :     122968 :           && array_at_struct_end_p (ref)))
    3500                 :            :     {
    3501                 :            :       /* Accesses to trailing arrays via pointers may access storage
    3502                 :            :          beyond the types array bounds.  For such arrays, or for flexible
    3503                 :            :          array members, as well as for other arrays of an unknown size,
    3504                 :            :          replace the upper bound with a more permissive one that assumes
    3505                 :            :          the size of the largest object is PTRDIFF_MAX.  */
    3506                 :      73569 :       tree eltsize = array_ref_element_size (ref);
    3507                 :            : 
    3508                 :      73569 :       if (TREE_CODE (eltsize) != INTEGER_CST
    3509                 :      73569 :           || integer_zerop (eltsize))
    3510                 :            :         {
    3511                 :            :           up_bound = NULL_TREE;
    3512                 :            :           up_bound_p1 = NULL_TREE;
    3513                 :            :         }
    3514                 :            :       else
    3515                 :            :         {
    3516                 :      72873 :           tree ptrdiff_max = TYPE_MAX_VALUE (ptrdiff_type_node);
    3517                 :      72873 :           tree maxbound = ptrdiff_max;
    3518                 :      72873 :           tree arg = TREE_OPERAND (ref, 0);
    3519                 :            : 
    3520                 :      72873 :           const bool compref = TREE_CODE (arg) == COMPONENT_REF;
    3521                 :      72873 :           if (compref)
    3522                 :            :             {
    3523                 :            :               /* Try to determine the size of the trailing array from
    3524                 :            :                  its initializer (if it has one).  */
    3525                 :      66769 :               if (tree refsize = component_ref_size (arg, &interior_zero_len))
    3526                 :       4156 :                 if (TREE_CODE (refsize) == INTEGER_CST)
    3527                 :       4153 :                   maxbound = refsize;
    3528                 :            :             }
    3529                 :            : 
    3530                 :      72873 :           if (maxbound == ptrdiff_max)
    3531                 :            :             {
    3532                 :            :               /* Try to determine the size of the base object.  Avoid
    3533                 :            :                  COMPONENT_REF already tried above.  Using its DECL_SIZE
    3534                 :            :                  size wouldn't necessarily be correct if the reference is
    3535                 :            :                  to its flexible array member initialized in a different
    3536                 :            :                  translation unit.  */
    3537                 :      68720 :               poly_int64 off;
    3538                 :      68720 :               if (tree base = get_addr_base_and_unit_offset (arg, &off))
    3539                 :            :                 {
    3540                 :      68363 :                   if (!compref && DECL_P (base))
    3541                 :       5368 :                     if (tree basesize = DECL_SIZE_UNIT (base))
    3542                 :        117 :                       if (TREE_CODE (basesize) == INTEGER_CST)
    3543                 :            :                         {
    3544                 :        117 :                           maxbound = basesize;
    3545                 :        117 :                           decl = base;
    3546                 :            :                         }
    3547                 :            : 
    3548                 :      68363 :                   if (known_gt (off, 0))
    3549                 :      62559 :                     maxbound = wide_int_to_tree (sizetype,
    3550                 :     125118 :                                                  wi::sub (wi::to_wide (maxbound),
    3551                 :      62559 :                                                           off));
    3552                 :            :                 }
    3553                 :            :             }
    3554                 :            :           else
    3555                 :       4153 :             maxbound = fold_convert (sizetype, maxbound);
    3556                 :            : 
    3557                 :      72873 :           up_bound_p1 = int_const_binop (TRUNC_DIV_EXPR, maxbound, eltsize);
    3558                 :            : 
    3559                 :      72873 :           if (up_bound_p1 != NULL_TREE)
    3560                 :      72873 :             up_bound = int_const_binop (MINUS_EXPR, up_bound_p1,
    3561                 :     145746 :                                         build_int_cst (ptrdiff_type_node, 1));
    3562                 :            :           else
    3563                 :            :             up_bound = NULL_TREE;
    3564                 :            :         }
    3565                 :            :     }
    3566                 :            :   else
    3567                 :     118254 :     up_bound_p1 = int_const_binop (PLUS_EXPR, up_bound,
    3568                 :     236508 :                                    build_int_cst (TREE_TYPE (up_bound), 1));
    3569                 :            : 
    3570                 :     191823 :   tree low_bound = array_ref_low_bound (ref);
    3571                 :            : 
    3572                 :     191823 :   tree artype = TREE_TYPE (TREE_OPERAND (ref, 0));
    3573                 :            : 
    3574                 :     191823 :   bool warned = false;
    3575                 :            : 
    3576                 :            :   /* Empty array.  */
    3577                 :     191823 :   if (up_bound && tree_int_cst_equal (low_bound, up_bound_p1))
    3578                 :        123 :     warned = warning_at (location, OPT_Warray_bounds,
    3579                 :            :                          "array subscript %E is outside array bounds of %qT",
    3580                 :            :                          low_sub, artype);
    3581                 :            : 
    3582                 :     191823 :   const value_range_equiv *vr = NULL;
    3583                 :     191823 :   if (TREE_CODE (low_sub) == SSA_NAME)
    3584                 :            :     {
    3585                 :     112498 :       vr = get_value_range (low_sub);
    3586                 :     112498 :       if (!vr->undefined_p () && !vr->varying_p ())
    3587                 :            :         {
    3588                 :     109513 :           low_sub = vr->kind () == VR_RANGE ? vr->max () : vr->min ();
    3589                 :     109513 :           up_sub = vr->kind () == VR_RANGE ? vr->min () : vr->max ();
    3590                 :            :         }
    3591                 :            :     }
    3592                 :            : 
    3593                 :     191823 :   if (warned)
    3594                 :            :     ; /* Do nothing.  */
    3595                 :     191700 :   else if (vr && vr->kind () == VR_ANTI_RANGE)
    3596                 :            :     {
    3597                 :       2399 :       if (up_bound
    3598                 :       2399 :           && TREE_CODE (up_sub) == INTEGER_CST
    3599                 :          7 :           && (ignore_off_by_one
    3600                 :        716 :               ? tree_int_cst_lt (up_bound, up_sub)
    3601                 :        709 :               : tree_int_cst_le (up_bound, up_sub))
    3602                 :        419 :           && TREE_CODE (low_sub) == INTEGER_CST
    3603                 :       3534 :           && tree_int_cst_le (low_sub, low_bound))
    3604                 :          2 :         warned = warning_at (location, OPT_Warray_bounds,
    3605                 :            :                              "array subscript [%E, %E] is outside "
    3606                 :            :                              "array bounds of %qT",
    3607                 :            :                              low_sub, up_sub, artype);
    3608                 :            :     }
    3609                 :     189301 :   else if (up_bound
    3610                 :     188605 :            && TREE_CODE (up_sub) == INTEGER_CST
    3611                 :     378248 :            && (ignore_off_by_one
    3612                 :     185289 :                ? !tree_int_cst_le (up_sub, up_bound_p1)
    3613                 :     181631 :                : !tree_int_cst_le (up_sub, up_bound)))
    3614                 :        542 :     warned = warning_at (location, OPT_Warray_bounds,
    3615                 :            :                          "array subscript %E is above array bounds of %qT",
    3616                 :            :                          up_sub, artype);
    3617                 :     188759 :   else if (TREE_CODE (low_sub) == INTEGER_CST
    3618                 :     188759 :            && tree_int_cst_lt (low_sub, low_bound))
    3619                 :        290 :     warned = warning_at (location, OPT_Warray_bounds,
    3620                 :            :                          "array subscript %E is below array bounds of %qT",
    3621                 :            :                          low_sub, artype);
    3622                 :            : 
    3623                 :     191823 :   if (!warned && interior_zero_len)
    3624                 :         36 :     warned = warning_at (location, OPT_Wzero_length_bounds,
    3625                 :         36 :                          (TREE_CODE (low_sub) == INTEGER_CST
    3626                 :            :                           ? G_("array subscript %E is outside the bounds "
    3627                 :            :                                "of an interior zero-length array %qT")
    3628                 :            :                           : G_("array subscript %qE is outside the bounds "
    3629                 :            :                                "of an interior zero-length array %qT")),
    3630                 :            :                          low_sub, artype);
    3631                 :            : 
    3632                 :     191823 :   if (warned)
    3633                 :            :     {
    3634                 :        993 :       if (dump_file && (dump_flags & TDF_DETAILS))
    3635                 :            :         {
    3636                 :          0 :           fprintf (dump_file, "Array bound warning for ");
    3637                 :          0 :           dump_generic_expr (MSG_NOTE, TDF_SLIM, ref);
    3638                 :          0 :           fprintf (dump_file, "\n");
    3639                 :            :         }
    3640                 :            : 
    3641                 :        993 :       ref = decl ? decl : TREE_OPERAND (ref, 0);
    3642                 :            : 
    3643                 :        993 :       tree rec = NULL_TREE;
    3644                 :        993 :       if (TREE_CODE (ref) == COMPONENT_REF)
    3645                 :            :         {
    3646                 :            :           /* For a reference to a member of a struct object also mention
    3647                 :            :              the object if it's known.  It may be defined in a different
    3648                 :            :              function than the out-of-bounds access.  */
    3649                 :        596 :           rec = TREE_OPERAND (ref, 0);
    3650                 :        596 :           if (!VAR_P (rec))
    3651                 :        359 :             rec = NULL_TREE;
    3652                 :        596 :           ref = TREE_OPERAND (ref, 1);
    3653                 :            :         }
    3654                 :            : 
    3655                 :        993 :       if (DECL_P (ref))
    3656                 :        828 :         inform (DECL_SOURCE_LOCATION (ref), "while referencing %qD", ref);
    3657                 :        993 :       if (rec && DECL_P (rec))
    3658                 :        237 :         inform (DECL_SOURCE_LOCATION (rec), "defined here %qD", rec);
    3659                 :            : 
    3660                 :        993 :       TREE_NO_WARNING (ref) = 1;
    3661                 :            :     }
    3662                 :            : 
    3663                 :            :   return warned;
    3664                 :            : }
    3665                 :            : 
    3666                 :            : /* Checks one MEM_REF in REF, located at LOCATION, for out-of-bounds
    3667                 :            :    references to string constants.  If VRP can determine that the array
    3668                 :            :    subscript is a constant, check if it is outside valid range.
    3669                 :            :    If the array subscript is a RANGE, warn if it is non-overlapping
    3670                 :            :    with valid range.
    3671                 :            :    IGNORE_OFF_BY_ONE is true if the MEM_REF is inside an ADDR_EXPR
    3672                 :            :    (used to allow one-past-the-end indices for code that takes
    3673                 :            :    the address of the just-past-the-end element of an array).
    3674                 :            :    Returns true if a warning has been issued.  */
    3675                 :            : 
    3676                 :            : bool
    3677                 :     513622 : vrp_prop::check_mem_ref (location_t location, tree ref,
    3678                 :            :                          bool ignore_off_by_one)
    3679                 :            : {
    3680                 :     513622 :   if (TREE_NO_WARNING (ref))
    3681                 :            :     return false;
    3682                 :            : 
    3683                 :     513593 :   tree arg = TREE_OPERAND (ref, 0);
    3684                 :            :   /* The constant and variable offset of the reference.  */
    3685                 :     513593 :   tree cstoff = TREE_OPERAND (ref, 1);
    3686                 :     513593 :   tree varoff = NULL_TREE;
    3687                 :            : 
    3688                 :     513593 :   const offset_int maxobjsize = tree_to_shwi (max_object_size ());
    3689                 :            : 
    3690                 :            :   /* The array or string constant bounds in bytes.  Initially set
    3691                 :            :      to [-MAXOBJSIZE - 1, MAXOBJSIZE]  until a tighter bound is
    3692                 :            :      determined.  */
    3693                 :     513593 :   offset_int arrbounds[2] = { -maxobjsize - 1, maxobjsize };
    3694                 :            : 
    3695                 :            :   /* The minimum and maximum intermediate offset.  For a reference
    3696                 :            :      to be valid, not only does the final offset/subscript must be
    3697                 :            :      in bounds but all intermediate offsets should be as well.
    3698                 :            :      GCC may be able to deal gracefully with such out-of-bounds
    3699                 :            :      offsets so the checking is only enbaled at -Warray-bounds=2
    3700                 :            :      where it may help detect bugs in uses of the intermediate
    3701                 :            :      offsets that could otherwise not be detectable.  */
    3702                 :     513593 :   offset_int ioff = wi::to_offset (fold_convert (ptrdiff_type_node, cstoff));
    3703                 :     513593 :   offset_int extrema[2] = { 0, wi::abs (ioff) };
    3704                 :            : 
    3705                 :            :   /* The range of the byte offset into the reference.  */
    3706                 :     513593 :   offset_int offrange[2] = { 0, 0 };
    3707                 :            : 
    3708                 :     513593 :   const value_range_equiv *vr = NULL;
    3709                 :            : 
    3710                 :            :   /* Determine the offsets and increment OFFRANGE for the bounds of each.
    3711                 :            :      The loop computes the range of the final offset for expressions such
    3712                 :            :      as (A + i0 + ... + iN)[CSTOFF] where i0 through iN are SSA_NAMEs in
    3713                 :            :      some range.  */
    3714                 :     513593 :   const unsigned limit = param_ssa_name_def_chain_limit;
    3715                 :     868846 :   for (unsigned n = 0; TREE_CODE (arg) == SSA_NAME && n < limit; ++n)
    3716                 :            :     {
    3717                 :     761672 :       gimple *def = SSA_NAME_DEF_STMT (arg);
    3718                 :     761672 :       if (!is_gimple_assign (def))
    3719                 :            :         break;
    3720                 :            : 
    3721                 :     483149 :       tree_code code = gimple_assign_rhs_code (def);
    3722                 :     483149 :       if (code == POINTER_PLUS_EXPR)
    3723                 :            :         {
    3724                 :      58586 :           arg = gimple_assign_rhs1 (def);
    3725                 :      58586 :           varoff = gimple_assign_rhs2 (def);
    3726                 :            :         }
    3727                 :     424563 :       else if (code == ASSERT_EXPR)
    3728                 :            :         {
    3729                 :     342979 :           arg = TREE_OPERAND (gimple_assign_rhs1 (def), 0);
    3730                 :     342979 :           continue;
    3731                 :            :         }
    3732                 :            :       else
    3733                 :            :         return false;
    3734                 :            : 
    3735                 :            :       /* VAROFF should always be a SSA_NAME here (and not even
    3736                 :            :          INTEGER_CST) but there's no point in taking chances.  */
    3737                 :      58586 :       if (TREE_CODE (varoff) != SSA_NAME)
    3738                 :            :         break;
    3739                 :            : 
    3740                 :      57849 :       vr = get_value_range (varoff);
    3741                 :      57849 :       if (!vr || vr->undefined_p () || vr->varying_p ())
    3742                 :            :         break;
    3743                 :            : 
    3744                 :      13156 :       if (!vr->constant_p ())
    3745                 :            :         break;
    3746                 :            : 
    3747                 :      12274 :       if (vr->kind () == VR_RANGE)
    3748                 :            :         {
    3749                 :       7862 :           offset_int min
    3750                 :       7862 :             = wi::to_offset (fold_convert (ptrdiff_type_node, vr->min ()));
    3751                 :       7862 :           offset_int max
    3752                 :       7862 :             = wi::to_offset (fold_convert (ptrdiff_type_node, vr->max ()));
    3753                 :       7862 :           if (min < max)
    3754                 :            :             {
    3755                 :       4606 :               offrange[0] += min;
    3756                 :       4606 :               offrange[1] += max;
    3757                 :            :             }
    3758                 :            :           else
    3759                 :            :             {
    3760                 :            :               /* When MIN >= MAX, the offset is effectively in a union
    3761                 :            :                  of two ranges: [-MAXOBJSIZE -1, MAX] and [MIN, MAXOBJSIZE].
    3762                 :            :                  Since there is no way to represent such a range across
    3763                 :            :                  additions, conservatively add [-MAXOBJSIZE -1, MAXOBJSIZE]
    3764                 :            :                  to OFFRANGE.  */
    3765                 :       3256 :               offrange[0] += arrbounds[0];
    3766                 :      11118 :               offrange[1] += arrbounds[1];
    3767                 :            :             }
    3768                 :            :         }
    3769                 :            :       else
    3770                 :            :         {
    3771                 :            :           /* For an anti-range, analogously to the above, conservatively
    3772                 :            :              add [-MAXOBJSIZE -1, MAXOBJSIZE] to OFFRANGE.  */
    3773                 :       4412 :           offrange[0] += arrbounds[0];
    3774                 :       4412 :           offrange[1] += arrbounds[1];
    3775                 :            :         }
    3776                 :            : 
    3777                 :            :       /* Keep track of the minimum and maximum offset.  */
    3778                 :      12334 :       if (offrange[1] < 0 && offrange[1] < extrema[0])
    3779                 :         60 :         extrema[0] = offrange[1];
    3780                 :      13172 :       if (offrange[0] > 0 && offrange[0] > extrema[1])
    3781                 :        767 :         extrema[1] = offrange[0];
    3782                 :            : 
    3783                 :      12274 :       if (offrange[0] < arrbounds[0])
    3784                 :       2117 :         offrange[0] = arrbounds[0];
    3785                 :            : 
    3786                 :      12274 :       if (offrange[1] > arrbounds[1])
    3787                 :       2131 :         offrange[1] = arrbounds[1];
    3788                 :            :     }
    3789                 :            : 
    3790                 :     432009 :   if (TREE_CODE (arg) == ADDR_EXPR)
    3791                 :            :     {
    3792                 :     107398 :       arg = TREE_OPERAND (arg, 0);
    3793                 :     107398 :       if (TREE_CODE (arg) != STRING_CST
    3794                 :     107398 :           && TREE_CODE (arg) != PARM_DECL
    3795                 :     106434 :           && TREE_CODE (arg) != VAR_DECL)
    3796                 :            :         return false;
    3797                 :            :     }
    3798                 :            :   else
    3799                 :            :     return false;
    3800                 :            : 
    3801                 :            :   /* The type of the object being referred to.  It can be an array,
    3802                 :            :      string literal, or a non-array type when the MEM_REF represents
    3803                 :            :      a reference/subscript via a pointer to an object that is not
    3804                 :            :      an element of an array.  Incomplete types are excluded as well
    3805                 :            :      because their size is not known.  */
    3806                 :     106767 :   tree reftype = TREE_TYPE (arg);
    3807                 :     106767 :   if (POINTER_TYPE_P (reftype)
    3808                 :     106738 :       || !COMPLETE_TYPE_P (reftype)
    3809                 :     208646 :       || TREE_CODE (TYPE_SIZE_UNIT (reftype)) != INTEGER_CST)
    3810                 :            :     return false;
    3811                 :            : 
    3812                 :            :   /* Except in declared objects, references to trailing array members
    3813                 :            :      of structs and union objects are excluded because MEM_REF doesn't
    3814                 :            :      make it possible to identify the member where the reference
    3815                 :            :      originated.  */
    3816                 :     101879 :   if (RECORD_OR_UNION_TYPE_P (reftype)
    3817                 :     101879 :       && (!VAR_P (arg)
    3818                 :      87654 :           || (DECL_EXTERNAL (arg) && array_at_struct_end_p (ref))))
    3819                 :        408 :     return false;
    3820                 :            : 
    3821                 :     101471 :   arrbounds[0] = 0;
    3822                 :            : 
    3823                 :     101471 :   offset_int eltsize;
    3824                 :     101471 :   if (TREE_CODE (reftype) == ARRAY_TYPE)
    3825                 :            :     {
    3826                 :      13594 :       eltsize = wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (reftype)));
    3827                 :      13594 :       if (tree dom = TYPE_DOMAIN (reftype))
    3828                 :            :         {
    3829                 :      13594 :           tree bnds[] = { TYPE_MIN_VALUE (dom), TYPE_MAX_VALUE (dom) };
    3830                 :      13594 :           if (TREE_CODE (arg) == COMPONENT_REF)
    3831                 :            :             {
    3832                 :          0 :               offset_int size = maxobjsize;
    3833                 :          0 :               if (tree fldsize = component_ref_size (arg))
    3834                 :          0 :                 size = wi::to_offset (fldsize);
    3835                 :          0 :               arrbounds[1] = wi::lrshift (size, wi::floor_log2 (eltsize));
    3836                 :            :             }
    3837                 :      13594 :           else if (array_at_struct_end_p (arg) || !bnds[0] || !bnds[1])
    3838                 :          0 :             arrbounds[1] = wi::lrshift (maxobjsize, wi::floor_log2 (eltsize));
    3839                 :            :           else
    3840                 :      13594 :             arrbounds[1] = (wi::to_offset (bnds[1]) - wi::to_offset (bnds[0])
    3841                 :      27188 :                             + 1) * eltsize;
    3842                 :            :         }
    3843                 :            :       else
    3844                 :          0 :         arrbounds[1] = wi::lrshift (maxobjsize, wi::floor_log2 (eltsize));
    3845                 :            : 
    3846                 :      13594 :       if (TREE_CODE (ref) == MEM_REF)
    3847                 :            :         {
    3848                 :            :           /* For MEM_REF determine a tighter bound of the non-array
    3849                 :            :              element type.  */
    3850                 :      13594 :           tree eltype = TREE_TYPE (reftype);
    3851                 :      13661 :           while (TREE_CODE (eltype) == ARRAY_TYPE)
    3852                 :         67 :             eltype = TREE_TYPE (eltype);
    3853                 :      13594 :           eltsize = wi::to_offset (TYPE_SIZE_UNIT (eltype));
    3854                 :            :         }
    3855                 :            :     }
    3856                 :            :   else
    3857                 :            :     {
    3858                 :      87877 :       eltsize = 1;
    3859                 :      87877 :       tree size = TYPE_SIZE_UNIT (reftype);
    3860                 :      87877 :       if (VAR_P (arg))
    3861                 :      87876 :         if (tree initsize = DECL_SIZE_UNIT (arg))
    3862                 :      87876 :           if (tree_int_cst_lt (size, initsize))
    3863                 :         22 :             size = initsize;
    3864                 :            : 
    3865                 :      87877 :       arrbounds[1] = wi::to_offset (size);
    3866                 :            :     }
    3867                 :            : 
    3868                 :     101471 :   offrange[0] += ioff;
    3869                 :     101471 :   offrange[1] += ioff;
    3870                 :            : 
    3871                 :            :   /* Compute the more permissive upper bound when IGNORE_OFF_BY_ONE
    3872                 :            :      is set (when taking the address of the one-past-last element
    3873                 :            :      of an array) but always use the stricter bound in diagnostics. */
    3874                 :     101471 :   offset_int ubound = arrbounds[1];
    3875                 :     101471 :   if (ignore_off_by_one)
    3876                 :      13060 :     ubound += 1;
    3877                 :            : 
    3878                 :     202930 :   if (arrbounds[0] == arrbounds[1]
    3879                 :     101459 :       || offrange[0] >= ubound
    3880                 :     202826 :       || offrange[1] < arrbounds[0])
    3881                 :            :     {
    3882                 :            :       /* Treat a reference to a non-array object as one to an array
    3883                 :            :          of a single element.  */
    3884                 :        187 :       if (TREE_CODE (reftype) != ARRAY_TYPE)
    3885                 :         17 :         reftype = build_array_type_nelts (reftype, 1);
    3886                 :            : 
    3887                 :        187 :       if (TREE_CODE (ref) == MEM_REF)
    3888                 :            :         {
    3889                 :            :           /* Extract the element type out of MEM_REF and use its size
    3890                 :            :              to compute the index to print in the diagnostic; arrays
    3891                 :            :              in MEM_REF don't mean anything.  A type with no size like
    3892                 :            :              void is as good as having a size of 1.  */
    3893                 :        187 :           tree type = TREE_TYPE (ref);
    3894                 :        245 :           while (TREE_CODE (type) == ARRAY_TYPE)
    3895                 :         58 :             type = TREE_TYPE (type);
    3896                 :        187 :           if (tree size = TYPE_SIZE_UNIT (type))
    3897                 :            :             {
    3898                 :        186 :               offrange[0] = offrange[0] / wi::to_offset (size);
    3899                 :        186 :               offrange[1] = offrange[1] / wi::to_offset (size);
    3900                 :            :             }
    3901                 :            :         }
    3902                 :            :       else
    3903                 :            :         {
    3904                 :            :           /* For anything other than MEM_REF, compute the index to
    3905                 :            :              print in the diagnostic as the offset over element size.  */
    3906                 :          0 :           offrange[0] = offrange[0] / eltsize;
    3907                 :          0 :           offrange[1] = offrange[1] / eltsize;
    3908                 :            :         }
    3909                 :            : 
    3910                 :        187 :       bool warned;
    3911                 :        374 :       if (offrange[0] == offrange[1])
    3912                 :        133 :         warned = warning_at (location, OPT_Warray_bounds,
    3913                 :            :                              "array subscript %wi is outside array bounds "
    3914                 :            :                              "of %qT",
    3915                 :            :                              offrange[0].to_shwi (), reftype);
    3916                 :            :       else
    3917                 :         54 :         warned = warning_at (location, OPT_Warray_bounds,
    3918                 :            :                              "array subscript [%wi, %wi] is outside "
    3919                 :            :                              "array bounds of %qT",
    3920                 :            :                              offrange[0].to_shwi (),
    3921                 :            :                              offrange[1].to_shwi (), reftype);
    3922                 :        187 :       if (warned && DECL_P (arg))
    3923                 :        116 :         inform (DECL_SOURCE_LOCATION (arg), "while referencing %qD", arg);
    3924                 :            : 
    3925                 :        187 :       if (warned)
    3926                 :        187 :         TREE_NO_WARNING (ref) = 1;
    3927                 :        187 :       return warned;
    3928                 :            :     }
    3929                 :            : 
    3930                 :     101284 :   if (warn_array_bounds < 2)
    3931                 :            :     return false;
    3932                 :            : 
    3933                 :            :   /* At level 2 check also intermediate offsets.  */
    3934                 :         85 :   int i = 0;
    3935                 :         85 :   if (extrema[i] < -arrbounds[1] || extrema[i = 1] > ubound)
    3936                 :            :     {
    3937                 :          7 :       HOST_WIDE_INT tmpidx = extrema[i].to_shwi () / eltsize.to_shwi ();
    3938                 :            : 
    3939                 :          7 :       if (warning_at (location, OPT_Warray_bounds,
    3940                 :            :                       "intermediate array offset %wi is outside array bounds "
    3941                 :            :                       "of %qT", tmpidx, reftype))
    3942                 :            :         {
    3943                 :          7 :           TREE_NO_WARNING (ref) = 1;
    3944                 :          7 :           return true;
    3945                 :            :         }
    3946                 :            :     }
    3947                 :            : 
    3948                 :            :   return false;
    3949                 :            : }
    3950                 :            : 
    3951                 :            : /* Searches if the expr T, located at LOCATION computes
    3952                 :            :    address of an ARRAY_REF, and call check_array_ref on it.  */
    3953                 :            : 
    3954                 :            : void
    3955                 :     635426 : vrp_prop::search_for_addr_array (tree t, location_t location)
    3956                 :            : {
    3957                 :            :   /* Check each ARRAY_REF and MEM_REF in the reference chain. */
    3958                 :     729840 :   do
    3959                 :            :     {
    3960                 :     729840 :       bool warned = false;
    3961                 :     729840 :       if (TREE_CODE (t) == ARRAY_REF)
    3962                 :       3968 :         warned = check_array_ref (location, t, true /*ignore_off_by_one*/);
    3963                 :     725872 :       else if (TREE_CODE (t) == MEM_REF)
    3964                 :      39815 :         warned = check_mem_ref (location, t, true /*ignore_off_by_one*/);
    3965                 :            : 
    3966                 :      43783 :       if (warned)
    3967                 :        136 :         TREE_NO_WARNING (t) = true;
    3968                 :            : 
    3969                 :     729840 :       t = TREE_OPERAND (t, 0);
    3970                 :            :     }
    3971                 :    1459680 :   while (handled_component_p (t) || TREE_CODE (t) == MEM_REF);
    3972                 :            : 
    3973                 :     635426 :   if (TREE_CODE (t) != MEM_REF
    3974                 :            :       || TREE_CODE (TREE_OPERAND (t, 0)) != ADDR_EXPR
    3975                 :            :       || TREE_NO_WARNING (t))
    3976                 :     635426 :     return;
    3977                 :            : 
    3978                 :            :   tree tem = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
    3979                 :            :   tree low_bound, up_bound, el_sz;
    3980                 :            :   if (TREE_CODE (TREE_TYPE (tem)) != ARRAY_TYPE
    3981                 :            :       || TREE_CODE (TREE_TYPE (TREE_TYPE (tem))) == ARRAY_TYPE
    3982                 :            :       || !TYPE_DOMAIN (TREE_TYPE (tem)))
    3983                 :            :     return;
    3984                 :            : 
    3985                 :            :   low_bound = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (tem)));
    3986                 :            :   up_bound = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (tem)));
    3987                 :            :   el_sz = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (tem)));
    3988                 :            :   if (!low_bound
    3989                 :            :       || TREE_CODE (low_bound) != INTEGER_CST
    3990                 :            :       || !up_bound
    3991                 :            :       || TREE_CODE (up_bound) != INTEGER_CST
    3992                 :            :       || !el_sz
    3993                 :            :       || TREE_CODE (el_sz) != INTEGER_CST)
    3994                 :            :     return;
    3995                 :            : 
    3996                 :            :   offset_int idx;
    3997                 :            :   if (!mem_ref_offset (t).is_constant (&idx))
    3998                 :            :     return;
    3999                 :            : 
    4000                 :            :   bool warned = false;
    4001                 :            :   idx = wi::sdiv_trunc (idx, wi::to_offset (el_sz));
    4002                 :            :   if (idx < 0)
    4003                 :            :     {
    4004                 :            :       if (dump_file && (dump_flags & TDF_DETAILS))
    4005                 :            :         {
    4006                 :            :           fprintf (dump_file, "Array bound warning for ");
    4007                 :            :           dump_generic_expr (MSG_NOTE, TDF_SLIM, t);
    4008                 :            :           fprintf (dump_file, "\n");
    4009                 :            :         }
    4010                 :            :       warned = warning_at (location, OPT_Warray_bounds,
    4011                 :            :                            "array subscript %wi is below "
    4012                 :            :                            "array bounds of %qT",
    4013                 :            :                            idx.to_shwi (), TREE_TYPE (tem));
    4014                 :            :     }
    4015                 :            :   else if (idx > (wi::to_offset (up_bound)
    4016                 :            :                   - wi::to_offset (low_bound) + 1))
    4017                 :            :     {
    4018                 :            :       if (dump_file && (dump_flags & TDF_DETAILS))
    4019                 :            :         {
    4020                 :            :           fprintf (dump_file, "Array bound warning for ");
    4021                 :            :           dump_generic_expr (MSG_NOTE, TDF_SLIM, t);
    4022                 :            :           fprintf (dump_file, "\n");
    4023                 :            :         }
    4024                 :            :       warned = warning_at (location, OPT_Warray_bounds,
    4025                 :            :                            "array subscript %wu is above "
    4026                 :            :                            "array bounds of %qT",
    4027                 :            :                            idx.to_uhwi (), TREE_TYPE (tem));
    4028                 :            :     }
    4029                 :            : 
    4030                 :            :   if (warned)
    4031                 :            :     {
    4032                 :            :       if (DECL_P (t))
    4033                 :            :         inform (DECL_SOURCE_LOCATION (t), "while referencing %qD", t);
    4034                 :            : 
    4035                 :            :       TREE_NO_WARNING (t) = 1;
    4036                 :            :     }
    4037                 :            : }
    4038                 :            : 
    4039                 :            : /* walk_tree() callback that checks if *TP is
    4040                 :            :    an ARRAY_REF inside an ADDR_EXPR (in which an array
    4041                 :            :    subscript one outside the valid range is allowed). Call
    4042                 :            :    check_array_ref for each ARRAY_REF found. The location is
    4043                 :            :    passed in DATA.  */
    4044                 :            : 
    4045                 :            : static tree
    4046                 :    8232880 : check_array_bounds (tree *tp, int *walk_subtree, void *data)
    4047                 :            : {
    4048                 :    8232880 :   tree t = *tp;
    4049                 :    8232880 :   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
    4050                 :    8232880 :   location_t location;
    4051                 :            : 
    4052                 :    8232880 :   if (EXPR_HAS_LOCATION (t))
    4053                 :    1250710 :     location = EXPR_LOCATION (t);
    4054                 :            :   else
    4055                 :    6982170 :     location = gimple_location (wi->stmt);
    4056                 :            : 
    4057                 :    8232880 :   *walk_subtree = TRUE;
    4058                 :            : 
    4059                 :    8232880 :   bool warned = false;
    4060                 :    8232880 :   vrp_prop *vrp_prop = (class vrp_prop *)wi->info;
    4061                 :    8232880 :   if (TREE_CODE (t) == ARRAY_REF)
    4062                 :     187914 :     warned = vrp_prop->check_array_ref (location, t, false/*ignore_off_by_one*/);
    4063                 :    8044970 :   else if (TREE_CODE (t) == MEM_REF)
    4064                 :     473807 :     warned = vrp_prop->check_mem_ref (location, t, false /*ignore_off_by_one*/);
    4065                 :    7571160 :   else if (TREE_CODE (t) == ADDR_EXPR)
    4066                 :            :     {
    4067                 :     635426 :       vrp_prop->search_for_addr_array (t, location);
    4068                 :     635426 :       *walk_subtree = FALSE;
    4069                 :            :     }
    4070                 :            :   /* Propagate the no-warning bit to the outer expression.  */
    4071                 :    1297150 :   if (warned)
    4072                 :       1051 :     TREE_NO_WARNING (t) = true;
    4073                 :            : 
    4074                 :    8232880 :   return NULL_TREE;
    4075                 :            : }
    4076                 :            : 
    4077                 :            : /* A dom_walker subclass for use by vrp_prop::check_all_array_refs,
    4078                 :            :    to walk over all statements of all reachable BBs and call
    4079                 :            :    check_array_bounds on them.  */
    4080                 :            : 
    4081                 :            : class check_array_bounds_dom_walker : public dom_walker
    4082                 :            : {
    4083                 :            :  public:
    4084                 :      56688 :   check_array_bounds_dom_walker (vrp_prop *prop)
    4085                 :      56688 :     : dom_walker (CDI_DOMINATORS,
    4086                 :            :                   /* Discover non-executable edges, preserving EDGE_EXECUTABLE
    4087                 :            :                      flags, so that we can merge in information on
    4088                 :            :                      non-executable edges from vrp_folder .  */
    4089                 :            :                   REACHABLE_BLOCKS_PRESERVING_FLAGS),
    4090                 :     113376 :       m_prop (prop) {}
    4091                 :      56688 :   ~check_array_bounds_dom_walker () {}
    4092                 :            : 
    4093                 :            :   edge before_dom_children (basic_block) FINAL OVERRIDE;
    4094                 :            : 
    4095                 :            :  private:
    4096                 :            :   vrp_prop *m_prop;
    4097                 :            : };
    4098                 :            : 
    4099                 :            : /* Implementation of dom_walker::before_dom_children.
    4100                 :            : 
    4101                 :            :    Walk over all statements of BB and call check_array_bounds on them,
    4102                 :            :    and determine if there's a unique successor edge.  */
    4103                 :            : 
    4104                 :            : edge
    4105                 :     811796 : check_array_bounds_dom_walker::before_dom_children (basic_block bb)
    4106                 :            : {
    4107                 :     811796 :   gimple_stmt_iterator si;
    4108                 :    8358890 :   for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
    4109                 :            :     {
    4110                 :    6735290 :       gimple *stmt = gsi_stmt (si);
    4111                 :    6735290 :       struct walk_stmt_info wi;
    4112                 :    6735290 :       if (!gimple_has_location (stmt)
    4113                 :    6735290 :           || is_gimple_debug (stmt))
    4114                 :    4395970 :         continue;
    4115                 :            : 
    4116                 :    2339320 :       memset (&wi, 0, sizeof (wi));
    4117                 :            : 
    4118                 :    2339320 :       wi.info = m_prop;
    4119                 :            : 
    4120                 :    2339320 :       walk_gimple_op (stmt, check_array_bounds, &wi);
    4121                 :            :     }
    4122                 :            : 
    4123                 :            :   /* Determine if there's a unique successor edge, and if so, return
    4124                 :            :      that back to dom_walker, ensuring that we don't visit blocks that
    4125                 :            :      became unreachable during the VRP propagation
    4126                 :            :      (PR tree-optimization/83312).  */
    4127                 :     811796 :   return find_taken_edge (bb, NULL_TREE);
    4128                 :            : }
    4129                 :            : 
    4130                 :            : /* Walk over all statements of all reachable BBs and call check_array_bounds
    4131                 :            :    on them.  */
    4132                 :            : 
    4133                 :            : void
    4134                 :      56688 : vrp_prop::check_all_array_refs ()
    4135                 :            : {
    4136                 :      56688 :   check_array_bounds_dom_walker w (this);
    4137                 :      56688 :   w.walk (ENTRY_BLOCK_PTR_FOR_FN (cfun));
    4138                 :      56688 : }
    4139                 :            : 
    4140                 :            : /* Return true if all imm uses of VAR are either in STMT, or
    4141                 :            :    feed (optionally through a chain of single imm uses) GIMPLE_COND
    4142                 :            :    in basic block COND_BB.  */
    4143                 :            : 
    4144                 :            : static bool
    4145                 :        447 : all_imm_uses_in_stmt_or_feed_cond (tree var, gimple *stmt, basic_block cond_bb)
    4146                 :            : {
    4147                 :        447 :   use_operand_p use_p, use2_p;
    4148                 :        447 :   imm_use_iterator iter;
    4149                 :            : 
    4150                 :       1681 :   FOR_EACH_IMM_USE_FAST (use_p, iter, var)
    4151                 :       1406 :     if (USE_STMT (use_p) != stmt)
    4152                 :            :       {
    4153                 :        566 :         gimple *use_stmt = USE_STMT (use_p), *use_stmt2;
    4154                 :        566 :         if (is_gimple_debug (use_stmt))
    4155                 :         59 :           continue;
    4156                 :        632 :         while (is_gimple_assign (use_stmt)
    4157                 :        278 :                && TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME
    4158                 :        900 :                && single_imm_use (gimple_assign_lhs (use_stmt),
    4159                 :            :                                   &use2_p, &use_stmt2))
    4160                 :        125 :           use_stmt = use_stmt2;
    4161                 :        507 :         if (gimple_code (use_stmt) != GIMPLE_COND
    4162                 :        507 :             || gimple_bb (use_stmt) != cond_bb)
    4163                 :        172 :           return false;
    4164                 :            :       }
    4165                 :            :   return true;
    4166                 :            : }
    4167                 :            : 
    4168                 :            : /* Handle
    4169                 :            :    _4 = x_3 & 31;
    4170                 :            :    if (_4 != 0)
    4171                 :            :      goto <bb 6>;
    4172                 :            :    else
    4173                 :            :      goto <bb 7>;
    4174                 :            :    <bb 6>:
    4175                 :            :    __builtin_unreachable ();
    4176                 :            :    <bb 7>:
    4177                 :            :    x_5 = ASSERT_EXPR <x_3, ...>;
    4178                 :            :    If x_3 has no other immediate uses (checked by caller),
    4179                 :            :    var is the x_3 var from ASSERT_EXPR, we can clear low 5 bits
    4180                 :            :    from the non-zero bitmask.  */
    4181                 :            : 
    4182                 :            : void
    4183                 :       1973 : maybe_set_nonzero_bits (edge e, tree var)
    4184                 :            : {
    4185                 :       1973 :   basic_block cond_bb = e->src;
    4186                 :       1973 :   gimple *stmt = last_stmt (cond_bb);
    4187                 :       1973 :   tree cst;
    4188                 :            : 
    4189                 :       1973 :   if (stmt == NULL
    4190                 :       1973 :       || gimple_code (stmt) != GIMPLE_COND
    4191                 :       1973 :       || gimple_cond_code (stmt) != ((e->flags & EDGE_TRUE_VALUE)
    4192                 :       1973 :                                      ? EQ_EXPR : NE_EXPR)
    4193                 :        648 :       || TREE_CODE (gimple_cond_lhs (stmt)) != SSA_NAME
    4194                 :       2557 :       || !integer_zerop (gimple_cond_rhs (stmt)))
    4195                 :       1620 :     return;
    4196                 :            : 
    4197                 :        353 :   stmt = SSA_NAME_DEF_STMT (gimple_cond_lhs (stmt));
    4198                 :        353 :   if (!is_gimple_assign (stmt)
    4199                 :        121 :       || gimple_assign_rhs_code (stmt) != BIT_AND_EXPR
    4200                 :        391 :       || TREE_CODE (gimple_assign_rhs2 (stmt)) != INTEGER_CST)
    4201                 :            :     return;
    4202                 :         38 :   if (gimple_assign_rhs1 (stmt) != var)
    4203                 :            :     {
    4204                 :         24 :       gimple *stmt2;
    4205                 :            : 
    4206                 :         24 :       if (TREE_CODE (gimple_assign_rhs1 (stmt)) != SSA_NAME)
    4207                 :            :         return;
    4208                 :         24 :       stmt2 = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt));
    4209                 :         24 :       if (!gimple_assign_cast_p (stmt2)
    4210                 :         20 :           || gimple_assign_rhs1 (stmt2) != var
    4211                 :         10 :           || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt2))
    4212                 :         34 :           || (TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (stmt)))
    4213                 :         10 :                               != TYPE_PRECISION (TREE_TYPE (var))))
    4214                 :            :         return;
    4215                 :            :     }
    4216                 :         24 :   cst = gimple_assign_rhs2 (stmt);
    4217                 :         48 :   set_nonzero_bits (var, wi::bit_and_not (get_nonzero_bits (var),
    4218                 :         48 :                                           wi::to_wide (cst)));
    4219                 :            : }
    4220                 :            : 
    4221                 :            : /* Convert range assertion expressions into the implied copies and
    4222                 :            :    copy propagate away the copies.  Doing the trivial copy propagation
    4223                 :            :    here avoids the need to run the full copy propagation pass after
    4224                 :            :    VRP.
    4225                 :            : 
    4226                 :            :    FIXME, this will eventually lead to copy propagation removing the
    4227                 :            :    names that had useful range information attached to them.  For
    4228                 :            :    instance, if we had the assertion N_i = ASSERT_EXPR <N_j, N_j > 3>,
    4229                 :            :    then N_i will have the range [3, +INF].
    4230                 :            : 
    4231                 :            :    However, by converting the assertion into the implied copy
    4232                 :            :    operation N_i = N_j, we will then copy-propagate N_j into the uses
    4233                 :            :    of N_i and lose the range information.  We may want to hold on to
    4234                 :            :    ASSERT_EXPRs a little while longer as the ranges could be used in
    4235                 :            :    things like jump threading.
    4236                 :            : 
    4237                 :            :    The problem with keeping ASSERT_EXPRs around is that passes after
    4238                 :            :    VRP need to handle them appropriately.
    4239                 :            : 
    4240                 :            :    Another approach would be to make the range information a first
    4241                 :            :    class property of the SSA_NAME so that it can be queried from
    4242                 :            :    any pass.  This is made somewhat more complex by the need for
    4243                 :            :    multiple ranges to be associated with one SSA_NAME.  */
    4244                 :            : 
    4245                 :            : static void
    4246                 :    1290530 : remove_range_assertions (void)
    4247                 :            : {
    4248                 :    1290530 :   basic_block bb;
    4249                 :    1290530 :   gimple_stmt_iterator si;
    4250                 :            :   /* 1 if looking at ASSERT_EXPRs immediately at the beginning of
    4251                 :            :      a basic block preceeded by GIMPLE_COND branching to it and
    4252                 :            :      __builtin_trap, -1 if not yet checked, 0 otherwise.  */
    4253                 :    1290530 :   int is_unreachable;
    4254                 :            : 
    4255                 :            :   /* Note that the BSI iterator bump happens at the bottom of the
    4256                 :            :      loop and no bump is necessary if we're removing the statement
    4257                 :            :      referenced by the current BSI.  */
    4258                 :   14992500 :   FOR_EACH_BB_FN (bb, cfun)
    4259                 :  137038000 :     for (si = gsi_after_labels (bb), is_unreachable = -1; !gsi_end_p (si);)
    4260                 :            :       {
    4261                 :  109634000 :         gimple *stmt = gsi_stmt (si);
    4262                 :            : 
    4263                 :  109634000 :         if (is_gimple_assign (stmt)
    4264                 :  109634000 :             && gimple_assign_rhs_code (stmt) == ASSERT_EXPR)
    4265                 :            :           {
    4266                 :    5660610 :             tree lhs = gimple_assign_lhs (stmt);
    4267                 :    5660610 :             tree rhs = gimple_assign_rhs1 (stmt);
    4268                 :    5660610 :             tree var;
    4269                 :            : 
    4270                 :    5660610 :             var = ASSERT_EXPR_VAR (rhs);
    4271                 :            : 
    4272                 :    5660610 :             if (TREE_CODE (var) == SSA_NAME
    4273                 :    5648990 :                 && !POINTER_TYPE_P (TREE_TYPE (lhs))
    4274                 :    8480220 :                 && SSA_NAME_RANGE_INFO (lhs))
    4275                 :            :               {
    4276                 :    2002180 :                 if (is_unreachable == -1)
    4277                 :            :                   {
    4278                 :    1755310 :                     is_unreachable = 0;
    4279                 :    1755310 :                     if (single_pred_p (bb)
    4280                 :    3508260 :                         && assert_unreachable_fallthru_edge_p
    4281                 :    1752940 :                                                     (single_pred_edge (bb)))
    4282                 :            :                       is_unreachable = 1;
    4283                 :            :                   }
    4284                 :            :                 /* Handle
    4285                 :            :                    if (x_7 >= 10 && x_7 < 20)
    4286                 :            :                      __builtin_unreachable ();
    4287                 :            :                    x_8 = ASSERT_EXPR <x_7, ...>;
    4288                 :            :                    if the only uses of x_7 are in the ASSERT_EXPR and
    4289                 :            :                    in the condition.  In that case, we can copy the
    4290                 :            :                    range info from x_8 computed in this pass also
    4291                 :            :                    for x_7.  */
    4292                 :     246866 :                 if (is_unreachable
    4293                 :     247313 :                     && all_imm_uses_in_stmt_or_feed_cond (var, stmt,
    4294                 :            :                                                           single_pred (bb)))
    4295                 :            :                   {
    4296                 :       1093 :                     set_range_info (var, SSA_NAME_RANGE_TYPE (lhs),
    4297                 :        275 :                                     SSA_NAME_RANGE_INFO (lhs)->get_min (),
    4298                 :        275 :                                     SSA_NAME_RANGE_INFO (lhs)->get_max ());
    4299                 :        275 :                     maybe_set_nonzero_bits (single_pred_edge (bb), var);
    4300                 :            :                   }
    4301                 :            :               }
    4302                 :            : 
    4303                 :            :             /* Propagate the RHS into every use of the LHS.  For SSA names
    4304                 :            :                also propagate abnormals as it merely restores the original
    4305                 :            :                IL in this case (an replace_uses_by would assert).  */
    4306                 :    5660610 :             if (TREE_CODE (var) == SSA_NAME)
    4307                 :            :               {
    4308                 :    5648990 :                 imm_use_iterator iter;
    4309                 :    5648990 :                 use_operand_p use_p;
    4310                 :    5648990 :                 gimple *use_stmt;
    4311                 :   18300600 :                 FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
    4312                 :   40587600 :                   FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
    4313                 :   13968000 :                     SET_USE (use_p, var);
    4314                 :            :               }
    4315                 :            :             else
    4316                 :      11623 :               replace_uses_by (lhs, var);
    4317                 :            : 
    4318                 :            :             /* And finally, remove the copy, it is not needed.  */
    4319                 :    5660610 :             gsi_remove (&si, true);
    4320                 :    5660610 :             release_defs (stmt);
    4321                 :            :           }
    4322                 :            :         else
    4323                 :            :           {
    4324                 :  103974000 :             if (!is_gimple_debug (gsi_stmt (si)))
    4325                 :   42252800 :               is_unreachable = 0;
    4326                 :  103974000 :             gsi_next (&si);
    4327                 :            :           }
    4328                 :            :       }
    4329                 :    1290530 : }
    4330                 :            : 
    4331                 :            : /* Return true if STMT is interesting for VRP.  */
    4332                 :            : 
    4333                 :            : bool
    4334                 :  487440000 : stmt_interesting_for_vrp (gimple *stmt)
    4335                 :            : {
    4336                 :  487440000 :   if (gimple_code (stmt) == GIMPLE_PHI)
    4337                 :            :     {
    4338                 :   10769600 :       tree res = gimple_phi_result (stmt);
    4339                 :   19014700 :       return (!virtual_operand_p (res)
    4340                 :   19014700 :               && (INTEGRAL_TYPE_P (TREE_TYPE (res))
    4341                 :    2389630 :                   || POINTER_TYPE_P (TREE_TYPE (res))));
    4342                 :            :     }
    4343                 :  476671000 :   else if (is_gimple_assign (stmt) || is_gimple_call (stmt))
    4344                 :            :     {
    4345                 :  254283000 :       tree lhs = gimple_get_lhs (stmt);
    4346                 :            : 
    4347                 :            :       /* In general, assignments with virtual operands are not useful
    4348                 :            :          for deriving ranges, with the obvious exception of calls to
    4349                 :            :          builtin functions.  */
    4350                 :  237724000 :       if (lhs && TREE_CODE (lhs) == SSA_NAME
    4351                 :  186910000 :           && (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
    4352                 :   58520700 :               || POINTER_TYPE_P (TREE_TYPE (lhs)))
    4353                 :  432709000 :           && (is_gimple_call (stmt)
    4354                 :  163216000 :               || !gimple_vuse (stmt)))
    4355                 :            :         return true;
    4356                 :  114585000 :       else if (is_gimple_call (stmt) && gimple_call_internal_p (stmt))
    4357                 :     847241 :         switch (gimple_call_internal_fn (stmt))
    4358                 :            :           {
    4359                 :     677927 :           case IFN_ADD_OVERFLOW:
    4360                 :     677927 :           case IFN_SUB_OVERFLOW:
    4361                 :     677927 :           case IFN_MUL_OVERFLOW:
    4362                 :     677927 :           case IFN_ATOMIC_COMPARE_EXCHANGE:
    4363                 :            :             /* These internal calls return _Complex integer type,
    4364                 :            :                but are interesting to VRP nevertheless.  */
    4365                 :     677927 :             if (lhs && TREE_CODE (lhs) == SSA_NAME)
    4366                 :     675409 :               return true;
    4367                 :            :             break;
    4368                 :            :           default:
    4369                 :            :             break;
    4370                 :            :           }
    4371                 :            :     }
    4372                 :  222388000 :   else if (gimple_code (stmt) == GIMPLE_COND
    4373                 :  222388000 :            || gimple_code (stmt) == GIMPLE_SWITCH)
    4374                 :    5847560 :     return true;
    4375                 :            : 
    4376                 :            :   return false;
    4377                 :            : }
    4378                 :            : 
    4379                 :            : /* Initialization required by ssa_propagate engine.  */
    4380                 :            : 
    4381                 :            : void
    4382                 :    1290530 : vrp_prop::vrp_initialize ()
    4383                 :            : {
    4384                 :    1290530 :   basic_block bb;
    4385                 :            : 
    4386                 :   14992500 :   FOR_EACH_BB_FN (bb, cfun)
    4387                 :            :     {
    4388                 :   19238700 :       for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si);
    4389                 :    5536760 :            gsi_next (&si))
    4390                 :            :         {
    4391                 :    5536760 :           gphi *phi = si.phi ();
    4392                 :    5536760 :           if (!stmt_interesting_for_vrp (phi))
    4393                 :            :             {
    4394                 :    2681680 :               tree lhs = PHI_RESULT (phi);
    4395                 :    2681680 :               set_def_to_varying (lhs);
    4396                 :    2681680 :               prop_set_simulate_again (phi, false);
    4397                 :            :             }
    4398                 :            :           else
    4399                 :    5536760 :             prop_set_simulate_again (phi, true);
    4400                 :            :         }
    4401                 :            : 
    4402                 :  137562000 :       for (gimple_stmt_iterator si = gsi_start_bb (bb); !gsi_end_p (si);
    4403                 :  110158000 :            gsi_next (&si))
    4404                 :            :         {
    4405                 :  110158000 :           gimple *stmt = gsi_stmt (si);
    4406                 :            : 
    4407                 :            :           /* If the statement is a control insn, then we do not
    4408                 :            :              want to avoid simulating the statement once.  Failure
    4409                 :            :              to do so means that those edges will never get added.  */
    4410                 :  110158000 :           if (stmt_ends_bb_p (stmt))
    4411                 :    8084470 :             prop_set_simulate_again (stmt, true);
    4412                 :  102073000 :           else if (!stmt_interesting_for_vrp (stmt))
    4413                 :            :             {
    4414                 :   85468300 :               set_defs_to_varying (stmt);
    4415                 :   85468300 :               prop_set_simulate_again (stmt, false);
    4416                 :            :             }
    4417                 :            :           else
    4418                 :  110158000 :             prop_set_simulate_again (stmt, true);
    4419                 :            :         }
    4420                 :            :     }
    4421                 :    1290530 : }
    4422                 :            : 
    4423                 :            : /* Searches the case label vector VEC for the index *IDX of the CASE_LABEL
    4424                 :            :    that includes the value VAL.  The search is restricted to the range
    4425                 :            :    [START_IDX, n - 1] where n is the size of VEC.
    4426                 :            : 
    4427                 :            :    If there is a CASE_LABEL for VAL, its index is placed in IDX and true is
    4428                 :            :    returned.
    4429                 :            : 
    4430                 :            :    If there is no CASE_LABEL for VAL and there is one that is larger than VAL,
    4431                 :            :    it is placed in IDX and false is returned.
    4432                 :            : 
    4433                 :            :    If VAL is larger than any CASE_LABEL, n is placed on IDX and false is
    4434                 :            :    returned. */
    4435                 :            : 
    4436                 :            : bool
    4437                 :      91045 : find_case_label_index (gswitch *stmt, size_t start_idx, tree val, size_t *idx)
    4438                 :            : {
    4439                 :      91045 :   size_t n = gimple_switch_num_labels (stmt);
    4440                 :      91045 :   size_t low, high;
    4441                 :            : 
    4442                 :            :   /* Find case label for minimum of the value range or the next one.
    4443                 :            :      At each iteration we are searching in [low, high - 1]. */
    4444                 :            : 
    4445                 :     349106 :   for (low = start_idx, high = n; high != low; )
    4446                 :            :     {
    4447                 :     195785 :       tree t;
    4448                 :     195785 :       int cmp;
    4449                 :            :       /* Note that i != high, so we never ask for n. */
    4450                 :     195785 :       size_t i = (high + low) / 2;
    4451                 :     195785 :       t = gimple_switch_label (stmt, i);
    4452                 :            : 
    4453                 :            :       /* Cache the result of comparing CASE_LOW and val.  */
    4454                 :     195785 :       cmp = tree_int_cst_compare (CASE_LOW (t), val);
    4455                 :            : 
    4456                 :     195785 :       if (cmp == 0)
    4457                 :            :         {
    4458                 :            :           /* Ranges cannot be empty. */
    4459                 :      28194 :           *idx = i;
    4460                 :      28194 :           return true;
    4461                 :            :         }
    4462                 :     167591 :       else if (cmp > 0)
    4463                 :            :         high = i;
    4464                 :            :       else
    4465                 :            :         {
    4466                 :      72175 :           low = i + 1;
    4467                 :      72175 :           if (CASE_HIGH (t) != NULL
    4468                 :      72175 :               && tree_int_cst_compare (CASE_HIGH (t), val) >= 0)
    4469                 :            :             {
    4470                 :        575 :               *idx = i;
    4471                 :        575 :               return true;
    4472                 :            :             }
    4473                 :            :         }
    4474                 :            :     }
    4475                 :            : 
    4476                 :      62276 :   *idx = high;
    4477                 :      62276 :   return false;
    4478                 :            : }
    4479                 :            : 
    4480                 :            : /* Searches the case label vector VEC for the range of CASE_LABELs that is used
    4481                 :            :    for values between MIN and MAX. The first index is placed in MIN_IDX. The
    4482                 :            :    last index is placed in MAX_IDX. If the range of CASE_LABELs is empty
    4483                 :            :    then MAX_IDX < MIN_IDX.
    4484                 :            :    Returns true if the default label is not needed. */
    4485                 :            : 
    4486                 :            : bool
    4487                 :      45514 : find_case_label_range (gswitch *stmt, tree min, tree max, size_t *min_idx,
    4488                 :            :                        size_t *max_idx)
    4489                 :            : {
    4490                 :      45514 :   size_t i, j;
    4491                 :      45514 :   bool min_take_default = !find_case_label_index (stmt, 1, min, &i);
    4492                 :      45514 :   bool max_take_default = !find_case_label_index (stmt, i, max, &j);
    4493                 :            : 
    4494                 :      45514 :   if (i == j
    4495                 :            :       && min_take_default
    4496                 :       4698 :       && max_take_default)
    4497                 :            :     {
    4498                 :            :       /* Only the default case label reached.
    4499                 :            :          Return an empty range. */
    4500                 :       3431 :       *min_idx = 1;
    4501                 :       3431 :       *max_idx = 0;
    4502                 :       3431 :       return false;
    4503                 :            :     }
    4504                 :            :   else
    4505                 :            :     {
    4506                 :      42083 :       bool take_default = min_take_default || max_take_default;
    4507                 :      42083 :       tree low, high;
    4508                 :      42083 :       size_t k;
    4509                 :            : 
    4510                 :      42083 :       if (max_take_default)
    4511                 :      34114 :         j--;
    4512                 :            : 
    4513                 :            :       /* If the case label range is continuous, we do not need
    4514                 :            :          the default case label.  Verify that.  */
    4515                 :      42083 :       high = CASE_LOW (gimple_switch_label (stmt, i));
    4516                 :      42083 :       if (CASE_HIGH (gimple_switch_label (stmt, i)))
    4517                 :       1862 :         high = CASE_HIGH (gimple_switch_label (stmt, i));
    4518                 :     117363 :       for (k = i + 1; k <= j; ++k)
    4519                 :            :         {
    4520                 :      96487 :           low = CASE_LOW (gimple_switch_label (stmt, k));
    4521                 :      96487 :           if (!integer_onep (int_const_binop (MINUS_EXPR, low, high)))
    4522                 :            :             {
    4523                 :            :               take_default = true;
    4524                 :            :               break;
    4525                 :            :             }
    4526                 :      75280 :           high = low;
    4527                 :      75280 :           if (CASE_HIGH (gimple_switch_label (stmt, k)))
    4528                 :       3411 :             high = CASE_HIGH (gimple_switch_label (stmt, k));
    4529                 :            :         }
    4530                 :            : 
    4531                 :      42083 :       *min_idx = i;
    4532                 :      42083 :       *max_idx = j;
    4533                 :      42083 :       return !take_default;
    4534                 :            :     }
    4535                 :            : }
    4536                 :            : 
    4537                 :            : /* Evaluate statement STMT.  If the statement produces a useful range,
    4538                 :            :    return SSA_PROP_INTERESTING and record the SSA name with the
    4539                 :            :    interesting range into *OUTPUT_P.
    4540                 :            : 
    4541                 :            :    If STMT is a conditional branch and we can determine its truth
    4542                 :            :    value, the taken edge is recorded in *TAKEN_EDGE_P.
    4543                 :            : 
    4544                 :            :    If STMT produces a varying value, return SSA_PROP_VARYING.  */
    4545                 :            : 
    4546                 :            : enum ssa_prop_result
    4547                 :   29922100 : vrp_prop::visit_stmt (gimple *stmt, edge *taken_edge_p, tree *output_p)
    4548                 :            : {
    4549                 :   29922100 :   tree lhs = gimple_get_lhs (stmt);
    4550                 :   29922100 :   value_range_equiv vr;
    4551                 :   29922100 :   extract_range_from_stmt (stmt, taken_edge_p, output_p, &vr);
    4552                 :            : 
    4553                 :   29922100 :   if (*output_p)
    4554                 :            :     {
    4555                 :   21417100 :       if (update_value_range (*output_p, &vr))
    4556                 :            :         {
    4557                 :   20600300 :           if (dump_file && (dump_flags & TDF_DETAILS))
    4558                 :            :             {
    4559                 :        682 :               fprintf (dump_file, "Found new range for ");
    4560                 :        682 :               print_generic_expr (dump_file, *output_p);
    4561                 :        682 :               fprintf (dump_file, ": ");
    4562                 :        682 :               dump_value_range (dump_file, &vr);
    4563                 :        682 :               fprintf (dump_file, "\n");
    4564                 :            :             }
    4565                 :            : 
    4566                 :   20600300 :           if (vr.varying_p ())
    4567                 :            :             return SSA_PROP_VARYING;
    4568                 :            : 
    4569                 :   14169100 :           return SSA_PROP_INTERESTING;
    4570                 :            :         }
    4571                 :            :       return SSA_PROP_NOT_INTERESTING;
    4572                 :            :     }
    4573                 :            : 
    4574                 :    8505050 :   if (is_gimple_call (stmt) && gimple_call_internal_p (stmt))
    4575                 :     104112 :     switch (gimple_call_internal_fn (stmt))
    4576                 :            :       {
    4577                 :     104112 :       case IFN_ADD_OVERFLOW:
    4578                 :     104112 :       case IFN_SUB_OVERFLOW:
    4579                 :     104112 :       case IFN_MUL_OVERFLOW:
    4580                 :     104112 :       case IFN_ATOMIC_COMPARE_EXCHANGE:
    4581                 :            :         /* These internal calls return _Complex integer type,
    4582                 :            :            which VRP does not track, but the immediate uses
    4583                 :            :            thereof might be interesting.  */
    4584                 :     104112 :         if (lhs && TREE_CODE (lhs) == SSA_NAME)
    4585                 :            :           {
    4586                 :     104112 :             imm_use_iterator iter;
    4587                 :     104112 :             use_operand_p use_p;
    4588                 :     104112 :             enum ssa_prop_result res = SSA_PROP_VARYING;
    4589                 :            : 
    4590                 :     104112 :             set_def_to_varying (lhs);
    4591                 :            : 
    4592                 :     118998 :             FOR_EACH_IMM_USE_FAST (use_p, iter, lhs)
    4593                 :            :               {
    4594                 :     111884 :                 gimple *use_stmt = USE_STMT (use_p);
    4595                 :     111884 :                 if (!is_gimple_assign (use_stmt))
    4596                 :       1053 :                   continue;
    4597                 :     110831 :                 enum tree_code rhs_code = gimple_assign_rhs_code (use_stmt);
    4598                 :     110831 :                 if (rhs_code != REALPART_EXPR && rhs_code != IMAGPART_EXPR)
    4599                 :          0 :                   continue;
    4600                 :     110831 :                 tree rhs1 = gimple_assign_rhs1 (use_stmt);
    4601                 :     110831 :                 tree use_lhs = gimple_assign_lhs (use_stmt);
    4602                 :     110831 :                 if (TREE_CODE (rhs1) != rhs_code
    4603                 :     110831 :                     || TREE_OPERAND (rhs1, 0) != lhs
    4604                 :     110831 :                     || TREE_CODE (use_lhs) != SSA_NAME
    4605                 :     110831 :                     || !stmt_interesting_for_vrp (use_stmt)
    4606                 :     221662 :                     || (!INTEGRAL_TYPE_P (TREE_TYPE (use_lhs))
    4607                 :     110831 :                         || !TYPE_MIN_VALUE (TREE_TYPE (use_lhs))
    4608                 :     110831 :                         || !TYPE_MAX_VALUE (TREE_TYPE (use_lhs))))
    4609                 :          0 :                   continue;
    4610                 :            : 
    4611                 :            :                 /* If there is a change in the value range for any of the
    4612                 :            :                    REALPART_EXPR/IMAGPART_EXPR immediate uses, return
    4613                 :            :                    SSA_PROP_INTERESTING.  If there are any REALPART_EXPR
    4614                 :            :                    or IMAGPART_EXPR immediate uses, but none of them have
    4615                 :            :                    a change in their value ranges, return
    4616                 :            :                    SSA_PROP_NOT_INTERESTING.  If there are no
    4617                 :            :                    {REAL,IMAG}PART_EXPR uses at all,
    4618                 :            :                    return SSA_PROP_VARYING.  */
    4619                 :     110831 :                 value_range_equiv new_vr;
    4620                 :     110831 :                 extract_range_basic (&new_vr, use_stmt);
    4621                 :     110831 :                 const value_range_equiv *old_vr = get_value_range (use_lhs);
    4622                 :     110831 :                 if (!old_vr->equal_p (new_vr, /*ignore_equivs=*/false))
    4623                 :            :                   res = SSA_PROP_INTERESTING;
    4624                 :            :                 else
    4625                 :      13833 :                   res = SSA_PROP_NOT_INTERESTING;
    4626                 :     110831 :                 new_vr.equiv_clear ();
    4627                 :     110831 :                 if (res == SSA_PROP_INTERESTING)
    4628                 :            :                   {
    4629                 :      96998 :                     *output_p = lhs;
    4630                 :      96998 :                     return res;
    4631                 :            :                   }
    4632                 :            :               }
    4633                 :            : 
    4634                 :       7114 :             return res;
    4635                 :            :           }
    4636                 :            :         break;
    4637                 :            :       default:
    4638                 :            :         break;
    4639                 :            :       }
    4640                 :            : 
    4641                 :            :   /* All other statements produce nothing of interest for VRP, so mark
    4642                 :            :      their outputs varying and prevent further simulation.  */
    4643                 :    8400940 :   set_defs_to_varying (stmt);
    4644                 :            : 
    4645                 :    8400940 :   return (*taken_edge_p) ? SSA_PROP_INTERESTING : SSA_PROP_VARYING;
    4646                 :            : }
    4647                 :            : 
    4648                 :            : void
    4649                 :   88059100 : value_range_equiv::intersect (const value_range_equiv *other)
    4650                 :            : {
    4651                 :   88059100 :   if (dump_file && (dump_flags & TDF_DETAILS))
    4652                 :            :     {
    4653                 :       3814 :       fprintf (dump_file, "Intersecting\n  ");
    4654                 :       3814 :       dump_value_range (dump_file, this);
    4655                 :       3814 :       fprintf (dump_file, "\nand\n  ");
    4656                 :       3814 :       dump_value_range (dump_file, other);
    4657                 :       3814 :       fprintf (dump_file, "\n");
    4658                 :            :     }
    4659                 :            : 
    4660                 :            :   /* If THIS is varying we want to pick up equivalences from OTHER.
    4661                 :            :      Just special-case this here rather than trying to fixup after the
    4662                 :            :      fact.  */
    4663                 :   88059100 :   if (this->varying_p ())
    4664                 :   19994200 :     this->deep_copy (other);
    4665                 :            :   else
    4666                 :            :     {
    4667                 :   68064800 :       value_range tem = intersect_helper (this, other);
    4668                 :   68064800 :       this->update (tem.min (), tem.max (), tem.kind ());
    4669                 :            : 
    4670                 :            :       /* If the result is VR_UNDEFINED there is no need to mess with
    4671                 :            :          equivalencies.  */
    4672                 :   68064800 :       if (!undefined_p ())
    4673                 :            :         {
    4674                 :            :           /* The resulting set of equivalences for range intersection
    4675                 :            :              is the union of the two sets.  */
    4676                 :   67946000 :           if (m_equiv && other->m_equiv && m_equiv != other->m_equiv)
    4677                 :   10695100 :             bitmap_ior_into (m_equiv, other->m_equiv);
    4678                 :   57250800 :           else if (other->m_equiv && !m_equiv)
    4679                 :            :             {
    4680                 :            :               /* All equivalence bitmaps are allocated from the same
    4681                 :            :                  obstack.  So we can use the obstack associated with
    4682                 :            :                  VR to allocate this->m_equiv.  */
    4683                 :          0 :               m_equiv = BITMAP_ALLOC (other->m_equiv->obstack);
    4684                 :          0 :               bitmap_copy (m_equiv, other->m_equiv);
    4685                 :            :             }
    4686                 :            :         }
    4687                 :            :     }
    4688                 :            : 
    4689                 :   88059100 :   if (dump_file && (dump_flags & TDF_DETAILS))
    4690                 :            :     {
    4691                 :       3814 :       fprintf (dump_file, "to\n  ");
    4692                 :       3814 :       dump_value_range (dump_file, this);
    4693                 :       3814 :       fprintf (dump_file, "\n");
    4694                 :            :     }
    4695                 :   88059100 : }
    4696                 :            : 
    4697                 :            : void
    4698                 :    7344440 : value_range_equiv::union_ (const value_range_equiv *other)
    4699                 :            : {
    4700                 :    7344440 :   if (dump_file && (dump_flags & TDF_DETAILS))
    4701                 :            :     {
    4702                 :        286 :       fprintf (dump_file, "Meeting\n  ");
    4703                 :        286 :       dump_value_range (dump_file, this);
    4704                 :        286 :       fprintf (dump_file, "\nand\n  ");
    4705                 :        286 :       dump_value_range (dump_file, other);
    4706                 :        286 :       fprintf (dump_file, "\n");
    4707                 :            :     }
    4708                 :            : 
    4709                 :            :   /* If THIS is undefined we want to pick up equivalences from OTHER.
    4710                 :            :      Just special-case this here rather than trying to fixup after the fact.  */
    4711                 :    7344440 :   if (this->undefined_p ())
    4712                 :      50093 :     this->deep_copy (other);
    4713                 :            :   else
    4714                 :            :     {
    4715                 :    7294340 :       value_range tem = union_helper (this, other);
    4716                 :    7294340 :       this->update (tem.min (), tem.max (), tem.kind ());
    4717                 :            : 
    4718                 :            :       /* The resulting set of equivalences is always the intersection of
    4719                 :            :          the two sets.  */
    4720                 :    7294340 :       if (this->m_equiv && other->m_equiv && this->m_equiv != other->m_equiv)
    4721                 :     159550 :         bitmap_and_into (this->m_equiv, other->m_equiv);
    4722                 :    7134790 :       else if (this->m_equiv && !other->m_equiv)
    4723                 :     246920 :         bitmap_clear (this->m_equiv);
    4724                 :            :     }
    4725                 :            : 
    4726                 :    7344440 :   if (dump_file && (dump_flags & TDF_DETAILS))
    4727                 :            :     {
    4728                 :        286 :       fprintf (dump_file, "to\n  ");
    4729                 :        286 :       dump_value_range (dump_file, this);
    4730                 :        286 :       fprintf (dump_file, "\n");
    4731                 :            :     }
    4732                 :    7344440 : }
    4733                 :            : 
    4734                 :            : /* Visit all arguments for PHI node PHI that flow through executable
    4735                 :            :    edges.  If a valid value range can be derived from all the incoming
    4736                 :            :    value ranges, set a new range for the LHS of PHI.  */
    4737                 :            : 
    4738                 :            : enum ssa_prop_result
    4739                 :    5244430 : vrp_prop::visit_phi (gphi *phi)
    4740                 :            : {
    4741                 :    5244430 :   tree lhs = PHI_RESULT (phi);
    4742                 :    5244430 :   value_range_equiv vr_result;
    4743                 :    5244430 :   extract_range_from_phi_node (phi, &vr_result);
    4744                 :    5244430 :   if (update_value_range (lhs, &vr_result))
    4745                 :            :     {
    4746                 :    4834660 :       if (dump_file && (dump_flags & TDF_DETAILS))
    4747                 :            :         {
    4748                 :        179 :           fprintf (dump_file, "Found new range for ");
    4749                 :        179 :           print_generic_expr (dump_file, lhs);
    4750                 :        179 :           fprintf (dump_file, ": ");
    4751                 :        179 :           dump_value_range (dump_file, &vr_result);
    4752                 :        179 :           fprintf (dump_file, "\n");
    4753                 :            :         }
    4754                 :            : 
    4755                 :    4834660 :       if (vr_result.varying_p ())
    4756                 :            :         return SSA_PROP_VARYING;
    4757                 :            : 
    4758                 :    3543400 :       return SSA_PROP_INTERESTING;
    4759                 :            :     }
    4760                 :            : 
    4761                 :            :   /* Nothing changed, don't add outgoing edges.  */
    4762                 :            :   return SSA_PROP_NOT_INTERESTING;
    4763                 :            : }
    4764                 :            : 
    4765                 :    1290530 : class vrp_folder : public substitute_and_fold_engine
    4766                 :            : {
    4767                 :            :  public:
    4768                 :    1290530 :   vrp_folder () : substitute_and_fold_engine (/* Fold all stmts.  */ true) {  }
    4769                 :            :   tree get_value (tree) FINAL OVERRIDE;
    4770                 :            :   bool fold_stmt (gimple_stmt_iterator *) FINAL OVERRIDE;
    4771                 :            :   bool fold_predicate_in (gimple_stmt_iterator *);
    4772                 :            : 
    4773                 :            :   class vr_values *vr_values;
    4774                 :            : 
    4775                 :            :   /* Delegators.  */
    4776                 :    5704730 :   tree vrp_evaluate_conditional (tree_code code, tree op0,
    4777                 :            :                                  tree op1, gimple *stmt)
    4778                 :    5704730 :     { return vr_values->vrp_evaluate_conditional (code, op0, op1, stmt); }
    4779                 :  110100000 :   bool simplify_stmt_using_ranges (gimple_stmt_iterator *gsi)
    4780                 :  110100000 :     { return vr_values->simplify_stmt_using_ranges (gsi); }
    4781                 :   90785600 :  tree op_with_constant_singleton_value_range (tree op)
    4782                 :   90785600 :     { return vr_values->op_with_constant_singleton_value_range (op); }
    4783                 :            : };
    4784                 :            : 
    4785                 :            : /* If the statement pointed by SI has a predicate whose value can be
    4786                 :            :    computed using the value range information computed by VRP, compute
    4787                 :            :    its value and return true.  Otherwise, return false.  */
    4788                 :            : 
    4789                 :            : bool
    4790                 :  110124000 : vrp_folder::fold_predicate_in (gimple_stmt_iterator *si)
    4791                 :            : {
    4792                 :  110124000 :   bool assignment_p = false;
    4793                 :  110124000 :   tree val;
    4794                 :  110124000 :   gimple *stmt = gsi_stmt (*si);
    4795                 :            : 
    4796                 :  110124000 :   if (is_gimple_assign (stmt)
    4797                 :  110124000 :       && TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison)
    4798                 :            :     {
    4799                 :     560294 :       assignment_p = true;
    4800                 :     560294 :       val = vrp_evaluate_conditional (gimple_assign_rhs_code (stmt),
    4801                 :            :                                       gimple_assign_rhs1 (stmt),
    4802                 :            :                                       gimple_assign_rhs2 (stmt),
    4803                 :            :                                       stmt);
    4804                 :            :     }
    4805                 :  109564000 :   else if (gcond *cond_stmt = dyn_cast <gcond *> (stmt))
    4806                 :    5144440 :     val = vrp_evaluate_conditional (gimple_cond_code (cond_stmt),
    4807                 :            :                                     gimple_cond_lhs (cond_stmt),
    4808                 :            :                                     gimple_cond_rhs (cond_stmt),
    4809                 :            :                                     stmt);
    4810                 :            :   else
    4811                 :            :     return false;
    4812                 :            : 
    4813                 :    5704730 :   if (val)
    4814                 :            :     {
    4815                 :      24172 :       if (assignment_p)
    4816                 :        277 :         val = fold_convert (gimple_expr_type (stmt), val);
    4817                 :            : 
    4818                 :      24172 :       if (dump_file)
    4819                 :            :         {
    4820                 :         45 :           fprintf (dump_file, "Folding predicate ");
    4821                 :         45 :           print_gimple_expr (dump_file, stmt, 0);
    4822                 :         45 :           fprintf (dump_file, " to ");
    4823                 :         45 :           print_generic_expr (dump_file, val);
    4824                 :         45 :           fprintf (dump_file, "\n");
    4825                 :            :         }
    4826                 :            : 
    4827                 :      24172 :       if (is_gimple_assign (stmt))
    4828                 :        277 :         gimple_assign_set_rhs_from_tree (si, val);
    4829                 :            :       else
    4830                 :            :         {
    4831                 :      23895 :           gcc_assert (gimple_code (stmt) == GIMPLE_COND);
    4832                 :      23895 :           gcond *cond_stmt = as_a <gcond *> (stmt);
    4833                 :      23895 :           if (integer_zerop (val))
    4834                 :      10507 :             gimple_cond_make_false (cond_stmt);
    4835                 :      13388 :           else if (integer_onep (val))
    4836                 :      13388 :             gimple_cond_make_true (cond_stmt);
    4837                 :            :           else
    4838                 :          0 :             gcc_unreachable ();
    4839                 :            :         }
    4840                 :            : 
    4841                 :      24172 :       return true;
    4842                 :            :     }
    4843                 :            : 
    4844                 :            :   return false;
    4845                 :            : }
    4846                 :            : 
    4847                 :            : /* Callback for substitute_and_fold folding the stmt at *SI.  */
    4848                 :            : 
    4849                 :            : bool
    4850                 :  110124000 : vrp_folder::fold_stmt (gimple_stmt_iterator *si)
    4851                 :            : {
    4852                 :  110124000 :   if (fold_predicate_in (si))
    4853                 :            :     return true;
    4854                 :            : 
    4855                 :  110100000 :   return simplify_stmt_using_ranges (si);
    4856                 :            : }
    4857                 :            : 
    4858                 :            : /* If OP has a value range with a single constant value return that,
    4859                 :            :    otherwise return NULL_TREE.  This returns OP itself if OP is a
    4860                 :            :    constant.
    4861                 :            : 
    4862                 :            :    Implemented as a pure wrapper right now, but this will change.  */
    4863                 :            : 
    4864                 :            : tree
    4865                 :   90785600 : vrp_folder::get_value (tree op)
    4866                 :            : {
    4867                 :   90785600 :   return op_with_constant_singleton_value_range (op);
    4868                 :            : }
    4869                 :            : 
    4870                 :            : /* Return the LHS of any ASSERT_EXPR where OP appears as the first
    4871                 :            :    argument to the ASSERT_EXPR and in which the ASSERT_EXPR dominates
    4872                 :            :    BB.  If no such ASSERT_EXPR is found, return OP.  */
    4873                 :            : 
    4874                 :            : static tree
    4875                 :   10359000 : lhs_of_dominating_assert (tree op, basic_block bb, gimple *stmt)
    4876                 :            : {
    4877                 :   10359000 :   imm_use_iterator imm_iter;
    4878                 :   10359000 :   gimple *use_stmt;
    4879                 :   10359000 :   use_operand_p use_p;
    4880                 :            : 
    4881                 :   10359000 :   if (TREE_CODE (op) == SSA_NAME)
    4882                 :            :     {
    4883                 :   33282500 :       FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
    4884                 :            :         {
    4885                 :   27523100 :           use_stmt = USE_STMT (use_p);
    4886                 :   27523100 :           if (use_stmt != stmt
    4887                 :   40980700 :               && gimple_assign_single_p (use_stmt)
    4888                 :   14543300 :               && TREE_CODE (gimple_assign_rhs1 (use_stmt)) == ASSERT_EXPR
    4889                 :   13880000 :               && TREE_OPERAND (gimple_assign_rhs1 (use_stmt), 0) == op
    4890                 :   40144000 :               && dominated_by_p (CDI_DOMINATORS, bb, gimple_bb (use_stmt)))
    4891                 :     422353 :             return gimple_assign_lhs (use_stmt);
    4892                 :            :         }
    4893                 :            :     }
    4894                 :            :   return op;
    4895                 :            : }
    4896                 :            : 
    4897                 :            : /* A hack.  */
    4898                 :            : static class vr_values *x_vr_values;
    4899                 :            : 
    4900                 :            : /* A trivial wrapper so that we can present the generic jump threading
    4901                 :            :    code with a simple API for simplifying statements.  STMT is the
    4902                 :            :    statement we want to simplify, WITHIN_STMT provides the location
    4903                 :            :    for any overflow warnings.  */
    4904                 :            : 
    4905                 :            : static tree
    4906                 :   16784100 : simplify_stmt_for_jump_threading (gimple *stmt, gimple *within_stmt,
    4907                 :            :     class avail_exprs_stack *avail_exprs_stack ATTRIBUTE_UNUSED,
    4908                 :            :     basic_block bb)
    4909                 :            : {
    4910                 :            :   /* First see if the conditional is in the hash table.  */
    4911                 :   16784100 :   tree cached_lhs = avail_exprs_stack->lookup_avail_expr (stmt, false, true);
    4912                 :   16784100 :   if (cached_lhs && is_gimple_min_invariant (cached_lhs))
    4913                 :            :     return cached_lhs;
    4914                 :            : 
    4915                 :   16680700 :   vr_values *vr_values = x_vr_values;
    4916                 :   16680700 :   if (gcond *cond_stmt = dyn_cast <gcond *> (stmt))
    4917                 :            :     {
    4918                 :    5173820 :       tree op0 = gimple_cond_lhs (cond_stmt);
    4919                 :    5173820 :       op0 = lhs_of_dominating_assert (op0, bb, stmt);
    4920                 :            : 
    4921                 :    5173820 :       tree op1 = gimple_cond_rhs (cond_stmt);
    4922                 :    5173820 :       op1 = lhs_of_dominating_assert (op1, bb, stmt);
    4923                 :            : 
    4924                 :    5173820 :       return vr_values->vrp_evaluate_conditional (gimple_cond_code (cond_stmt),
    4925                 :    5173820 :                                                   op0, op1, within_stmt);
    4926                 :            :     }
    4927                 :            : 
    4928                 :            :   /* We simplify a switch statement by trying to determine which case label
    4929                 :            :      will be taken.  If we are successful then we return the corresponding
    4930                 :            :      CASE_LABEL_EXPR.  */
    4931                 :   11506900 :   if (gswitch *switch_stmt = dyn_cast <gswitch *> (stmt))
    4932                 :            :     {
    4933                 :      11328 :       tree op = gimple_switch_index (switch_stmt);
    4934                 :      11328 :       if (TREE_CODE (op) != SSA_NAME)
    4935                 :            :         return NULL_TREE;
    4936                 :            : 
    4937                 :      11328 :       op = lhs_of_dominating_assert (op, bb, stmt);
    4938                 :            : 
    4939                 :      11328 :       const value_range_equiv *vr = vr_values->get_value_range (op);
    4940                 :      11328 :       if (vr->undefined_p ()
    4941                 :      11303 :           || vr->varying_p ()
    4942                 :      14459 :           || vr->symbolic_p ())
    4943                 :       8296 :         return NULL_TREE;
    4944                 :            : 
    4945                 :       3032 :       if (vr->kind () == VR_RANGE)
    4946                 :            :         {
    4947                 :       2494 :           size_t i, j;
    4948                 :            :           /* Get the range of labels that contain a part of the operand's
    4949                 :            :              value range.  */
    4950                 :       2494 :           find_case_label_range (switch_stmt, vr->min (), vr->max (), &i, &j);
    4951                 :            : 
    4952                 :            :           /* Is there only one such label?  */
    4953                 :       2494 :           if (i == j)
    4954                 :            :             {
    4955                 :        210 :               tree label = gimple_switch_label (switch_stmt, i);
    4956                 :            : 
    4957                 :            :               /* The i'th label will be taken only if the value range of the
    4958                 :            :                  operand is entirely within the bounds of this label.  */
    4959                 :        210 :               if (CASE_HIGH (label) != NULL_TREE
    4960                 :        210 :                   ? (tree_int_cst_compare (CASE_LOW (label), vr->min ()) <= 0
    4961                 :         10 :                      && tree_int_cst_compare (CASE_HIGH (label),
    4962                 :          5 :                                               vr->max ()) >= 0)
    4963                 :        205 :                   : (tree_int_cst_equal (CASE_LOW (label), vr->min ())
    4964                 :        205 :                      && tree_int_cst_equal (vr->min (), vr->max ())))
    4965                 :        237 :                 return label;
    4966                 :            :             }
    4967                 :            : 
    4968                 :            :           /* If there are no such labels then the default label will be
    4969                 :            :              taken.  */
    4970                 :       2316 :           if (i > j)
    4971                 :         59 :             return gimple_switch_label (switch_stmt, 0);
    4972                 :            :         }
    4973                 :            : 
    4974                 :       2795 :       if (vr->kind () == VR_ANTI_RANGE)
    4975                 :            :         {
    4976                 :        538 :           unsigned n = gimple_switch_num_labels (switch_stmt);
    4977                 :        538 :           tree min_label = gimple_switch_label (switch_stmt, 1);
    4978                 :        538 :           tree max_label = gimple_switch_label (switch_stmt, n - 1);
    4979                 :            : 
    4980                 :            :           /* The default label will be taken only if the anti-range of the
    4981                 :            :              operand is entirely outside the bounds of all the (non-default)
    4982                 :            :              case labels.  */
    4983                 :        538 :           if (tree_int_cst_compare (vr->min (), CASE_LOW (min_label)) <= 0
    4984                 :        744 :               && (CASE_HIGH (max_label) != NULL_TREE
    4985                 :        202 :                   ? tree_int_cst_compare (vr->max (),
    4986                 :          4 :                                           CASE_HIGH (max_label)) >= 0
    4987                 :        198 :                   : tree_int_cst_compare (vr->max (),
    4988                 :        198 :                                           CASE_LOW (max_label)) >= 0))
    4989                 :          9 :           return gimple_switch_label (switch_stmt, 0);
    4990                 :            :         }
    4991                 :            : 
    4992                 :       2786 :       return NULL_TREE;
    4993                 :            :     }
    4994                 :            : 
    4995                 :   11495600 :   if (gassign *assign_stmt = dyn_cast <gassign *> (stmt))
    4996                 :            :     {
    4997                 :   10417000 :       tree lhs = gimple_assign_lhs (assign_stmt);
    4998                 :   10417000 :       if (TREE_CODE (lhs) == SSA_NAME
    4999                 :   10417000 :           && (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
    5000                 :    3549950 :               || POINTER_TYPE_P (TREE_TYPE (lhs)))
    5001                 :   20181800 :           && stmt_interesting_for_vrp (stmt))
    5002                 :            :         {
    5003                 :    5480340 :           edge dummy_e;
    5004                 :    5480340 :           tree dummy_tree;
    5005                 :    5480340 :           value_range_equiv new_vr;
    5006                 :    5480340 :           vr_values->extract_range_from_stmt (stmt, &dummy_e,
    5007                 :            :                                               &dummy_tree, &new_vr);
    5008                 :    5480340 :           tree singleton;
    5009                 :    5480340 :           if (new_vr.singleton_p (&singleton))
    5010                 :      20727 :             return singleton;
    5011                 :            :         }
    5012                 :            :     }
    5013                 :            : 
    5014                 :            :   return NULL_TREE;
    5015                 :            : }
    5016                 :            : 
    5017                 :    1290530 : class vrp_dom_walker : public dom_walker
    5018                 :            : {
    5019                 :            : public:
    5020                 :    1290530 :   vrp_dom_walker (cdi_direction direction,
    5021                 :            :                   class const_and_copies *const_and_copies,
    5022                 :            :                   class avail_exprs_stack *avail_exprs_stack)
    5023                 :    1290530 :     : dom_walker (direction, REACHABLE_BLOCKS),
    5024                 :            :       m_const_and_copies (const_and_copies),
    5025                 :            :       m_avail_exprs_stack (avail_exprs_stack),
    5026                 :    2581070 :       m_dummy_cond (NULL) {}
    5027                 :            : 
    5028                 :            :   virtual edge before_dom_children (basic_block);
    5029                 :            :   virtual void after_dom_children (basic_block);
    5030                 :            : 
    5031                 :            :   class vr_values *vr_values;
    5032                 :            : 
    5033                 :            : private:
    5034                 :            :   class const_and_copies *m_const_and_copies;
    5035                 :            :   class avail_exprs_stack *m_avail_exprs_stack;
    5036                 :            : 
    5037                 :            :   gcond *m_dummy_cond;
    5038                 :            : 
    5039                 :            : };
    5040                 :            : 
    5041                 :            : /* Called before processing dominator children of BB.  We want to look
    5042                 :            :    at ASSERT_EXPRs and record information from them in the appropriate
    5043                 :            :    tables.
    5044                 :            : 
    5045                 :            :    We could look at other statements here.  It's not seen as likely
    5046                 :            :    to significantly increase the jump threads we discover.  */
    5047                 :            : 
    5048                 :            : edge
    5049                 :   14992500 : vrp_dom_walker::before_dom_children (basic_block bb)
    5050                 :            : {
    5051                 :   14992500 :   gimple_stmt_iterator gsi;
    5052                 :            : 
    5053                 :   14992500 :   m_avail_exprs_stack->push_marker ();
    5054                 :   14992500 :   m_const_and_copies->push_marker ();
    5055                 :   18918000 :   for (gsi = gsi_start_nondebug_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    5056                 :            :     {
    5057                 :   16037900 :       gimple *stmt = gsi_stmt (gsi);
    5058                 :   24385100 :       if (gimple_assign_single_p (stmt)
    5059                 :    8347220 :          && TREE_CODE (gimple_assign_rhs1 (stmt)) == ASSERT_EXPR)
    5060                 :            :         {
    5061                 :    3925570 :           tree rhs1 = gimple_assign_rhs1 (stmt);
    5062                 :    3925570 :           tree cond = TREE_OPERAND (rhs1, 1);
    5063                 :    3925570 :           tree inverted = invert_truthvalue (cond);
    5064                 :    3925570 :           vec<cond_equivalence> p;
    5065                 :    3925570 :           p.create (3);
    5066                 :    3925570 :           record_conditions (&p, cond, inverted);
    5067                 :   29885700 :           for (unsigned int i = 0; i < p.length (); i++)
    5068                 :   11017300 :             m_avail_exprs_stack->record_cond (&p[i]);
    5069                 :            : 
    5070                 :    3925570 :           tree lhs = gimple_assign_lhs (stmt);
    5071                 :    3925570 :           m_const_and_copies->record_const_or_copy (lhs,
    5072                 :    3925570 :                                                     TREE_OPERAND (rhs1, 0));
    5073                 :    3925570 :           p.release ();
    5074                 :    3925570 :           continue;
    5075                 :            :         }
    5076                 :            :       break;
    5077                 :            :     }
    5078                 :   14992500 :   return NULL;
    5079                 :            : }
    5080                 :            : 
    5081                 :            : /* Called after processing dominator children of BB.  This is where we
    5082                 :            :    actually call into the threader.  */
    5083                 :            : void
    5084                 :   14992500 : vrp_dom_walker::after_dom_children (basic_block bb)
    5085                 :            : {
    5086                 :   14992500 :   if (!m_dummy_cond)
    5087                 :    1290530 :     m_dummy_cond = gimple_build_cond (NE_EXPR,
    5088                 :            :                                       integer_zero_node, integer_zero_node,
    5089                 :            :                                       NULL, NULL);
    5090                 :            : 
    5091                 :   14992500 :   x_vr_values = vr_values;
    5092                 :   14992500 :   thread_outgoing_edges (bb, m_dummy_cond, m_const_and_copies,
    5093                 :            :                          m_avail_exprs_stack, NULL,
    5094                 :            :                          simplify_stmt_for_jump_threading);
    5095                 :   14992500 :   x_vr_values = NULL;
    5096                 :            : 
    5097                 :   14992500 :   m_avail_exprs_stack->pop_to_marker ();
    5098                 :   14992500 :   m_const_and_copies->pop_to_marker ();
    5099                 :   14992500 : }
    5100                 :            : 
    5101                 :            : /* Blocks which have more than one predecessor and more than
    5102                 :            :    one successor present jump threading opportunities, i.e.,
    5103                 :            :    when the block is reached from a specific predecessor, we
    5104                 :            :    may be able to determine which of the outgoing edges will
    5105                 :            :    be traversed.  When this optimization applies, we are able
    5106                 :            :    to avoid conditionals at runtime and we may expose secondary
    5107                 :            :    optimization opportunities.
    5108                 :            : 
    5109                 :            :    This routine is effectively a driver for the generic jump
    5110                 :            :    threading code.  It basically just presents the generic code
    5111                 :            :    with edges that may be suitable for jump threading.
    5112                 :            : 
    5113                 :            :    Unlike DOM, we do not iterate VRP if jump threading was successful.
    5114                 :            :    While iterating may expose new opportunities for VRP, it is expected
    5115                 :            :    those opportunities would be very limited and the compile time cost
    5116                 :            :    to expose those opportunities would be significant.
    5117                 :            : 
    5118                 :            :    As jump threading opportunities are discovered, they are registered
    5119                 :            :    for later realization.  */
    5120                 :            : 
    5121                 :            : static void
    5122                 :    1290530 : identify_jump_threads (class vr_values *vr_values)
    5123                 :            : {
    5124                 :            :   /* Ugh.  When substituting values earlier in this pass we can
    5125                 :            :      wipe the dominance information.  So rebuild the dominator
    5126                 :            :      information as we need it within the jump threading code.  */
    5127                 :    1290530 :   calculate_dominance_info (CDI_DOMINATORS);
    5128                 :            : 
    5129                 :            :   /* We do not allow VRP information to be used for jump threading
    5130                 :            :      across a back edge in the CFG.  Otherwise it becomes too
    5131                 :            :      difficult to avoid eliminating loop exit tests.  Of course
    5132                 :            :      EDGE_DFS_BACK is not accurate at this time so we have to
    5133                 :            :      recompute it.  */
    5134                 :    1290530 :   mark_dfs_back_edges ();
    5135                 :            : 
    5136                 :            :   /* Allocate our unwinder stack to unwind any temporary equivalences
    5137                 :            :      that might be recorded.  */
    5138                 :    1290530 :   const_and_copies *equiv_stack = new const_and_copies ();
    5139                 :            : 
    5140                 :    1290530 :   hash_table<expr_elt_hasher> *avail_exprs
    5141                 :    1290530 :     = new hash_table<expr_elt_hasher> (1024);
    5142                 :    1290530 :   avail_exprs_stack *avail_exprs_stack
    5143                 :    1290530 :     = new class avail_exprs_stack (avail_exprs);
    5144                 :            : 
    5145                 :    1290530 :   vrp_dom_walker walker (CDI_DOMINATORS, equiv_stack, avail_exprs_stack);
    5146                 :    1290530 :   walker.vr_values = vr_values;
    5147                 :    1290530 :   walker.walk (cfun->cfg->x_entry_block_ptr);
    5148                 :            : 
    5149                 :            :   /* We do not actually update the CFG or SSA graphs at this point as
    5150                 :            :      ASSERT_EXPRs are still in the IL and cfg cleanup code does not yet
    5151                 :            :      handle ASSERT_EXPRs gracefully.  */
    5152                 :    2581070 :   delete equiv_stack;
    5153                 :    1290530 :   delete avail_exprs;
    5154                 :    2581070 :   delete avail_exprs_stack;
    5155                 :    1290530 : }
    5156                 :            : 
    5157                 :            : /* Traverse all the blocks folding conditionals with known ranges.  */
    5158                 :            : 
    5159                 :            : void
    5160                 :    1290530 : vrp_prop::vrp_finalize (bool warn_array_bounds_p)
    5161                 :            : {
    5162                 :    1290530 :   size_t i;
    5163                 :            : 
    5164                 :            :   /* We have completed propagating through the lattice.  */
    5165                 :    1290530 :   vr_values.set_lattice_propagation_complete ();
    5166                 :            : 
    5167                 :    1290530 :   if (dump_file)
    5168                 :            :     {
    5169                 :        883 :       fprintf (dump_file, "\nValue ranges after VRP:\n\n");
    5170                 :        883 :       vr_values.dump_all_value_ranges (dump_file);
    5171                 :        883 :       fprintf (dump_file, "\n");
    5172                 :            :     }
    5173                 :            : 
    5174                 :            :   /* Set value range to non pointer SSA_NAMEs.  */
    5175                 :  126772000 :   for (i = 0; i < num_ssa_names; i++)
    5176                 :            :     {
    5177                 :   62095500 :       tree name = ssa_name (i);
    5178                 :   62095500 :       if (!name)
    5179                 :   10053200 :         continue;
    5180                 :            : 
    5181                 :   52042300 :       const value_range_equiv *vr = get_value_range (name);
    5182                 :   52042300 :       if (!name || !vr->constant_p ())
    5183                 :   41790400 :         continue;
    5184                 :            : 
    5185                 :   17089800 :       if (POINTER_TYPE_P (TREE_TYPE (name))
    5186                 :   10521800 :           && range_includes_zero_p (vr) == 0)
    5187                 :    3591540 :         set_ptr_nonnull (name);
    5188                 :    6660330 :       else if (!POINTER_TYPE_P (TREE_TYPE (name)))
    5189                 :    6568000 :         set_range_info (name, *vr);
    5190                 :            :     }
    5191                 :            : 
    5192                 :            :   /* If we're checking array refs, we want to merge information on
    5193                 :            :      the executability of each edge between vrp_folder and the
    5194                 :            :      check_array_bounds_dom_walker: each can clear the
    5195                 :            :      EDGE_EXECUTABLE flag on edges, in different ways.
    5196                 :            : 
    5197                 :            :      Hence, if we're going to call check_all_array_refs, set
    5198                 :            :      the flag on every edge now, rather than in
    5199                 :            :      check_array_bounds_dom_walker's ctor; vrp_folder may clear
    5200                 :            :      it from some edges.  */
    5201                 :    1290530 :   if (warn_array_bounds && warn_array_bounds_p)
    5202                 :      56688 :     set_all_edges_as_executable (cfun);
    5203                 :            : 
    5204                 :    1290530 :   class vrp_folder vrp_folder;
    5205                 :    1290530 :   vrp_folder.vr_values = &vr_values;
    5206                 :    1290530 :   vrp_folder.substitute_and_fold ();
    5207                 :            : 
    5208                 :    1290530 :   if (warn_array_bounds && warn_array_bounds_p)
    5209                 :      56688 :     check_all_array_refs ();
    5210                 :    1290530 : }
    5211                 :            : 
    5212                 :            : /* Main entry point to VRP (Value Range Propagation).  This pass is
    5213                 :            :    loosely based on J. R. C. Patterson, ``Accurate Static Branch
    5214                 :            :    Prediction by Value Range Propagation,'' in SIGPLAN Conference on
    5215                 :            :    Programming Language Design and Implementation, pp. 67-78, 1995.
    5216                 :            :    Also available at http://citeseer.ist.psu.edu/patterson95accurate.html
    5217                 :            : 
    5218                 :            :    This is essentially an SSA-CCP pass modified to deal with ranges
    5219                 :            :    instead of constants.
    5220                 :            : 
    5221                 :            :    While propagating ranges, we may find that two or more SSA name
    5222                 :            :    have equivalent, though distinct ranges.  For instance,
    5223                 :            : 
    5224                 :            :      1  x_9 = p_3->a;
    5225                 :            :      2  p_4 = ASSERT_EXPR <p_3, p_3 != 0>
    5226                 :            :      3  if (p_4 == q_2)
    5227                 :            :      4    p_5 = ASSERT_EXPR <p_4, p_4 == q_2>;
    5228                 :            :      5  endif
    5229                 :            :      6  if (q_2)
    5230                 :            : 
    5231                 :            :    In the code above, pointer p_5 has range [q_2, q_2], but from the
    5232                 :            :    code we can also determine that p_5 cannot be NULL and, if q_2 had
    5233                 :            :    a non-varying range, p_5's range should also be compatible with it.
    5234                 :            : 
    5235                 :            :    These equivalences are created by two expressions: ASSERT_EXPR and
    5236                 :            :    copy operations.  Since p_5 is an assertion on p_4, and p_4 was the
    5237                 :            :    result of another assertion, then we can use the fact that p_5 and
    5238                 :            :    p_4 are equivalent when evaluating p_5's range.
    5239                 :            : 
    5240                 :            :    Together with value ranges, we also propagate these equivalences
    5241                 :            :    between names so that we can take advantage of information from
    5242                 :            :    multiple ranges when doing final replacement.  Note that this
    5243                 :            :    equivalency relation is transitive but not symmetric.
    5244                 :            : 
    5245                 :            :    In the example above, p_5 is equivalent to p_4, q_2 and p_3, but we
    5246                 :            :    cannot assert that q_2 is equivalent to p_5 because q_2 may be used
    5247                 :            :    in contexts where that assertion does not hold (e.g., in line 6).
    5248                 :            : 
    5249                 :            :    TODO, the main difference between this pass and Patterson's is that
    5250                 :            :    we do not propagate edge probabilities.  We only compute whether
    5251                 :            :    edges can be taken or not.  That is, instead of having a spectrum
    5252                 :            :    of jump probabilities between 0 and 1, we only deal with 0, 1 and
    5253                 :            :    DON'T KNOW.  In the future, it may be worthwhile to propagate
    5254                 :            :    probabilities to aid branch prediction.  */
    5255                 :            : 
    5256                 :            : static unsigned int
    5257                 :    1290530 : execute_vrp (bool warn_array_bounds_p)
    5258                 :            : {
    5259                 :            : 
    5260                 :    1290530 :   loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS);
    5261                 :    1290530 :   rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa);
    5262                 :    1290530 :   scev_initialize ();
    5263                 :            : 
    5264                 :            :   /* ???  This ends up using stale EDGE_DFS_BACK for liveness computation.
    5265                 :            :      Inserting assertions may split edges which will invalidate
    5266                 :            :      EDGE_DFS_BACK.  */
    5267                 :    1290530 :   insert_range_assertions ();
    5268                 :            : 
    5269                 :    1290530 :   threadedge_initialize_values ();
    5270                 :            : 
    5271                 :            :   /* For visiting PHI nodes we need EDGE_DFS_BACK computed.  */
    5272                 :    1290530 :   mark_dfs_back_edges ();
    5273                 :            : 
    5274                 :    1290530 :   class vrp_prop vrp_prop;
    5275                 :    1290530 :   vrp_prop.vrp_initialize ();
    5276                 :    1290530 :   vrp_prop.ssa_propagate ();
    5277                 :    1290530 :   vrp_prop.vrp_finalize (warn_array_bounds_p);
    5278                 :            : 
    5279                 :            :   /* We must identify jump threading opportunities before we release
    5280                 :            :      the datastructures built by VRP.  */
    5281                 :    1290530 :   identify_jump_threads (&vrp_prop.vr_values);
    5282                 :            : 
    5283                 :            :   /* A comparison of an SSA_NAME against a constant where the SSA_NAME
    5284                 :            :      was set by a type conversion can often be rewritten to use the
    5285                 :            :      RHS of the type conversion.
    5286                 :            : 
    5287                 :            :      However, doing so inhibits jump threading through the comparison.
    5288                 :            :      So that transformation is not performed until after jump threading
    5289                 :            :      is complete.  */
    5290                 :    1290530 :   basic_block bb;
    5291                 :   14992500 :   FOR_EACH_BB_FN (bb, cfun)
    5292                 :            :     {
    5293                 :   13701900 :       gimple *last = last_stmt (bb);
    5294                 :   13701900 :       if (last && gimple_code (last) == GIMPLE_COND)
    5295                 :    5144440 :         vrp_prop.vr_values.simplify_cond_using_ranges_2 (as_a <gcond *> (last));
    5296                 :            :     }
    5297                 :            : 
    5298                 :    1290530 :   free_numbers_of_iterations_estimates (cfun);
    5299                 :            : 
    5300                 :            :   /* ASSERT_EXPRs must be removed before finalizing jump threads
    5301                 :            :      as finalizing jump threads calls the CFG cleanup code which
    5302                 :            :      does not properly handle ASSERT_EXPRs.  */
    5303                 :    1290530 :   remove_range_assertions ();
    5304                 :            : 
    5305                 :            :   /* If we exposed any new variables, go ahead and put them into
    5306                 :            :      SSA form now, before we handle jump threading.  This simplifies
    5307                 :            :      interactions between rewriting of _DECL nodes into SSA form
    5308                 :            :      and rewriting SSA_NAME nodes into SSA form after block
    5309                 :            :      duplication and CFG manipulation.  */
    5310                 :    1290530 :   update_ssa (TODO_update_ssa);
    5311                 :            : 
    5312                 :            :   /* We identified all the jump threading opportunities earlier, but could
    5313                 :            :      not transform the CFG at that time.  This routine transforms the
    5314                 :            :      CFG and arranges for the dominator tree to be rebuilt if necessary.
    5315                 :            : 
    5316                 :            :      Note the SSA graph update will occur during the normal TODO
    5317                 :            :      processing by the pass manager.  */
    5318                 :    1290530 :   thread_through_all_blocks (false);
    5319                 :            : 
    5320                 :    1290530 :   vrp_prop.vr_values.cleanup_edges_and_switches ();
    5321                 :    1290530 :   threadedge_finalize_values ();
    5322                 :            : 
    5323                 :    1290530 :   scev_finalize ();
    5324                 :    1290530 :   loop_optimizer_finalize ();
    5325                 :    1290530 :   return 0;
    5326                 :            : }
    5327                 :            : 
    5328                 :            : namespace {
    5329                 :            : 
    5330                 :            : const pass_data pass_data_vrp =
    5331                 :            : {
    5332                 :            :   GIMPLE_PASS, /* type */
    5333                 :            :   "vrp", /* name */
    5334                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    5335                 :            :   TV_TREE_VRP, /* tv_id */
    5336                 :            :   PROP_ssa, /* properties_required */
    5337                 :            :   0, /* properties_provided */
    5338                 :            :   0, /* properties_destroyed */
    5339                 :            :   0, /* todo_flags_start */
    5340                 :            :   ( TODO_cleanup_cfg | TODO_update_ssa ), /* todo_flags_finish */
    5341                 :            : };
    5342                 :            : 
    5343                 :            : class pass_vrp : public gimple_opt_pass
    5344                 :            : {
    5345                 :            : public:
    5346                 :     401546 :   pass_vrp (gcc::context *ctxt)
    5347                 :     803092 :     : gimple_opt_pass (pass_data_vrp, ctxt), warn_array_bounds_p (false)
    5348                 :            :   {}
    5349                 :            : 
    5350                 :            :   /* opt_pass methods: */
    5351                 :     200773 :   opt_pass * clone () { return new pass_vrp (m_ctxt); }
    5352                 :     401546 :   void set_pass_param (unsigned int n, bool param)
    5353                 :            :     {
    5354                 :     401546 :       gcc_assert (n == 0);
    5355                 :     401546 :       warn_array_bounds_p = param;
    5356                 :     401546 :     }
    5357                 :    1373570 :   virtual bool gate (function *) { return flag_tree_vrp != 0; }
    5358                 :    1290530 :   virtual unsigned int execute (function *)
    5359                 :    1290530 :     { return execute_vrp (warn_array_bounds_p); }
    5360                 :            : 
    5361                 :            :  private:
    5362                 :            :   bool warn_array_bounds_p;
    5363                 :            : }; // class pass_vrp
    5364                 :            : 
    5365                 :            : } // anon namespace
    5366                 :            : 
    5367                 :            : gimple_opt_pass *
    5368                 :     200773 : make_pass_vrp (gcc::context *ctxt)
    5369                 :            : {
    5370                 :     200773 :   return new pass_vrp (ctxt);
    5371                 :            : }
    5372                 :            : 
    5373                 :            : 
    5374                 :            : /* Worker for determine_value_range.  */
    5375                 :            : 
    5376                 :            : static void
    5377                 :     127753 : determine_value_range_1 (value_range *vr, tree expr)
    5378                 :            : {
    5379                 :     127753 :   if (BINARY_CLASS_P (expr))
    5380                 :            :     {
    5381                 :        700 :       value_range vr0, vr1;
    5382                 :        700 :       determine_value_range_1 (&vr0, TREE_OPERAND (expr, 0));
    5383                 :        700 :       determine_value_range_1 (&vr1, TREE_OPERAND (expr, 1));
    5384                 :        700 :       range_fold_binary_expr (vr, TREE_CODE (expr), TREE_TYPE (expr),
    5385                 :            :                               &vr0, &vr1);
    5386                 :            :     }
    5387                 :     127053 :   else if (UNARY_CLASS_P (expr))
    5388                 :            :     {
    5389                 :        114 :       value_range vr0;
    5390                 :        114 :       determine_value_range_1 (&vr0, TREE_OPERAND (expr, 0));
    5391                 :        114 :       range_fold_unary_expr (vr, TREE_CODE (expr), TREE_TYPE (expr),
    5392                 :        114 :                              &vr0, TREE_TYPE (TREE_OPERAND (expr, 0)));
    5393                 :            :     }
    5394                 :     126939 :   else if (TREE_CODE (expr) == INTEGER_CST)
    5395                 :        698 :     vr->set (expr);
    5396                 :            :   else
    5397                 :            :     {
    5398                 :     126241 :       value_range_kind kind;
    5399                 :     126241 :       wide_int min, max;
    5400                 :            :       /* For SSA names try to extract range info computed by VRP.  Otherwise
    5401                 :            :          fall back to varying.  */
    5402                 :     126241 :       if (TREE_CODE (expr) == SSA_NAME
    5403                 :     126241 :           && INTEGRAL_TYPE_P (TREE_TYPE (expr))
    5404                 :     252474 :           && (kind = get_range_info (expr, &min, &max)) != VR_VARYING)
    5405                 :     116412 :         vr->set (wide_int_to_tree (TREE_TYPE (expr), min),
    5406                 :      58206 :                  wide_int_to_tree (TREE_TYPE (expr), max),
    5407                 :            :                  kind);
    5408                 :            :       else
    5409                 :      68035 :         vr->set_varying (TREE_TYPE (expr));
    5410                 :            :     }
    5411                 :     127753 : }
    5412                 :            : 
    5413                 :            : /* Compute a value-range for EXPR and set it in *MIN and *MAX.  Return
    5414                 :            :    the determined range type.  */
    5415                 :            : 
    5416                 :            : value_range_kind
    5417                 :     126239 : determine_value_range (tree expr, wide_int *min, wide_int *max)
    5418                 :            : {
    5419                 :     126239 :   value_range vr;
    5420                 :     126239 :   determine_value_range_1 (&vr, expr);
    5421                 :     126239 :   if (vr.constant_p ())
    5422                 :            :     {
    5423                 :      46048 :       *min = wi::to_wide (vr.min ());
    5424                 :      46048 :       *max = wi::to_wide (vr.max ());
    5425                 :      46048 :       return vr.kind ();
    5426                 :            :     }
    5427                 :            : 
    5428                 :            :   return VR_VARYING;
    5429                 :            : }

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.