LCOV - code coverage report
Current view: top level - gcc - gimple-ssa-evrp-analyze.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 212 212 100.0 %
Date: 2020-04-04 11:58:09 Functions: 13 13 100.0 %
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                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify
       7                 :            : it under the terms of the GNU General Public License as published by
       8                 :            : the Free Software Foundation; either version 3, or (at your option)
       9                 :            : any later version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful,
      12                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            : GNU General Public License for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "backend.h"
      24                 :            : #include "tree.h"
      25                 :            : #include "gimple.h"
      26                 :            : #include "tree-pass.h"
      27                 :            : #include "ssa.h"
      28                 :            : #include "gimple-pretty-print.h"
      29                 :            : #include "cfganal.h"
      30                 :            : #include "gimple-fold.h"
      31                 :            : #include "tree-eh.h"
      32                 :            : #include "gimple-iterator.h"
      33                 :            : #include "tree-cfg.h"
      34                 :            : #include "tree-ssa-loop-manip.h"
      35                 :            : #include "tree-ssa-loop.h"
      36                 :            : #include "cfgloop.h"
      37                 :            : #include "tree-scalar-evolution.h"
      38                 :            : #include "tree-ssa-propagate.h"
      39                 :            : #include "alloc-pool.h"
      40                 :            : #include "domwalk.h"
      41                 :            : #include "tree-cfgcleanup.h"
      42                 :            : #include "vr-values.h"
      43                 :            : #include "gimple-ssa-evrp-analyze.h"
      44                 :            : 
      45                 :    3609080 : evrp_range_analyzer::evrp_range_analyzer (bool update_global_ranges)
      46                 :    3609080 :   : stack (10), m_update_global_ranges (update_global_ranges)
      47                 :            : {
      48                 :    3609080 :   edge e;
      49                 :    3609080 :   edge_iterator ei;
      50                 :    3609080 :   basic_block bb;
      51                 :   32439000 :   FOR_EACH_BB_FN (bb, cfun)
      52                 :            :     {
      53                 :   28829900 :       bb->flags &= ~BB_VISITED;
      54                 :   69383500 :       FOR_EACH_EDGE (e, ei, bb->preds)
      55                 :   40553600 :         e->flags |= EDGE_EXECUTABLE;
      56                 :            :     }
      57                 :    3609080 :   vr_values = new class vr_values;
      58                 :    3609080 : }
      59                 :            : 
      60                 :            : /* Push an unwinding marker onto the unwinding stack.  */
      61                 :            : 
      62                 :            : void
      63                 :   43316200 : evrp_range_analyzer::push_marker ()
      64                 :            : {
      65                 :   43316200 :   stack.safe_push (std::make_pair (NULL_TREE, (value_range_equiv *)NULL));
      66                 :   43316200 : }
      67                 :            : 
      68                 :            : /* Analyze ranges as we enter basic block BB.  */
      69                 :            : 
      70                 :            : void
      71                 :   32419800 : evrp_range_analyzer::enter (basic_block bb)
      72                 :            : {
      73                 :   32419800 :   if (!optimize)
      74                 :            :     return;
      75                 :   32355000 :   push_marker ();
      76                 :   32355000 :   record_ranges_from_incoming_edge (bb);
      77                 :   32355000 :   record_ranges_from_phis (bb);
      78                 :   32355000 :   bb->flags |= BB_VISITED;
      79                 :            : }
      80                 :            : 
      81                 :            : /* Find new range for NAME such that (OP CODE LIMIT) is true.  */
      82                 :            : value_range_equiv *
      83                 :   38164900 : evrp_range_analyzer::try_find_new_range (tree name,
      84                 :            :                                          tree op, tree_code code, tree limit)
      85                 :            : {
      86                 :   38164900 :   value_range_equiv vr;
      87                 :   38164900 :   const value_range_equiv *old_vr = get_value_range (name);
      88                 :            : 
      89                 :            :   /* Discover VR when condition is true.  */
      90                 :   38164900 :   vr_values->extract_range_for_var_from_comparison_expr (name, code, op,
      91                 :            :                                                          limit, &vr);
      92                 :            :   /* If we found any usable VR, set the VR to ssa_name and create a
      93                 :            :      PUSH old value in the stack with the old VR.  */
      94                 :   38164900 :   if (!vr.undefined_p () && !vr.varying_p ())
      95                 :            :     {
      96                 :   37850200 :       if (old_vr->equal_p (vr, /*ignore_equivs=*/true))
      97                 :            :         return NULL;
      98                 :   24308400 :       value_range_equiv *new_vr = vr_values->allocate_value_range_equiv ();
      99                 :   24308400 :       new_vr->move (&vr);
     100                 :   24308400 :       return new_vr;
     101                 :            :     }
     102                 :            :   return NULL;
     103                 :            : }
     104                 :            : 
     105                 :            : /* For LHS record VR in the SSA info.  */
     106                 :            : void
     107                 :   22387900 : evrp_range_analyzer::set_ssa_range_info (tree lhs, value_range_equiv *vr)
     108                 :            : {
     109                 :   22387900 :   gcc_assert (m_update_global_ranges);
     110                 :            : 
     111                 :            :   /* Set the SSA with the value range.  */
     112                 :   22387900 :   if (INTEGRAL_TYPE_P (TREE_TYPE (lhs)))
     113                 :            :     {
     114                 :   17055200 :       if (vr->constant_p ())
     115                 :    6732120 :         set_range_info (lhs, vr->kind (),
     116                 :    6732120 :                         wi::to_wide (vr->min ()),
     117                 :   13464200 :                         wi::to_wide (vr->max ()));
     118                 :            :     }
     119                 :    5332650 :   else if (POINTER_TYPE_P (TREE_TYPE (lhs))
     120                 :    5575750 :            && range_includes_zero_p (vr) == 0)
     121                 :    1812440 :     set_ptr_nonnull (lhs);
     122                 :   22387900 : }
     123                 :            : 
     124                 :            : /* Return true if all uses of NAME are dominated by STMT or feed STMT
     125                 :            :    via a chain of single immediate uses.  */
     126                 :            : 
     127                 :            : static bool
     128                 :       2549 : all_uses_feed_or_dominated_by_stmt (tree name, gimple *stmt)
     129                 :            : {
     130                 :       2549 :   use_operand_p use_p, use2_p;
     131                 :       2549 :   imm_use_iterator iter;
     132                 :       2549 :   basic_block stmt_bb = gimple_bb (stmt);
     133                 :            : 
     134                 :       6704 :   FOR_EACH_IMM_USE_FAST (use_p, iter, name)
     135                 :            :     {
     136                 :       5006 :       gimple *use_stmt = USE_STMT (use_p), *use_stmt2;
     137                 :       8974 :       if (use_stmt == stmt
     138                 :       2909 :           || is_gimple_debug (use_stmt)
     139                 :       7552 :           || (gimple_bb (use_stmt) != stmt_bb
     140                 :       2102 :               && dominated_by_p (CDI_DOMINATORS,
     141                 :       2102 :                                  gimple_bb (use_stmt), stmt_bb)))
     142                 :       3968 :         continue;
     143                 :       1324 :       while (use_stmt != stmt
     144                 :       1137 :              && is_gimple_assign (use_stmt)
     145                 :        550 :              && TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME
     146                 :       1854 :              && single_imm_use (gimple_assign_lhs (use_stmt),
     147                 :            :                                 &use2_p, &use_stmt2))
     148                 :        286 :         use_stmt = use_stmt2;
     149                 :       1038 :       if (use_stmt != stmt)
     150                 :        851 :         return false;
     151                 :            :     }
     152                 :            :   return true;
     153                 :            : }
     154                 :            : 
     155                 :            : void
     156                 :   32355000 : evrp_range_analyzer::record_ranges_from_incoming_edge (basic_block bb)
     157                 :            : {
     158                 :   32355000 :   edge pred_e = single_pred_edge_ignoring_loop_edges (bb, false);
     159                 :   32355000 :   if (pred_e)
     160                 :            :     {
     161                 :   23298200 :       gimple *stmt = last_stmt (pred_e->src);
     162                 :   23298200 :       tree op0 = NULL_TREE;
     163                 :            : 
     164                 :   23298200 :       if (stmt
     165                 :   19001200 :           && gimple_code (stmt) == GIMPLE_COND
     166                 :   14496600 :           && (op0 = gimple_cond_lhs (stmt))
     167                 :   14496600 :           && TREE_CODE (op0) == SSA_NAME
     168                 :   37475000 :           && (INTEGRAL_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt)))
     169                 :    3095300 :               || POINTER_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt)))))
     170                 :            :         {
     171                 :   13508300 :           if (dump_file && (dump_flags & TDF_DETAILS))
     172                 :            :             {
     173                 :        644 :               fprintf (dump_file, "Visiting controlling predicate ");
     174                 :        644 :               print_gimple_stmt (dump_file, stmt, 0);
     175                 :            :             }
     176                 :            :           /* Entering a new scope.  Try to see if we can find a VR
     177                 :            :              here.  */
     178                 :   13508300 :           tree op1 = gimple_cond_rhs (stmt);
     179                 :   13508300 :           if (TREE_OVERFLOW_P (op1))
     180                 :       6175 :             op1 = drop_tree_overflow (op1);
     181                 :   13508300 :           tree_code code = gimple_cond_code (stmt);
     182                 :            : 
     183                 :   27016700 :           auto_vec<assert_info, 8> asserts;
     184                 :   13508300 :           register_edge_assert_for (op0, pred_e, code, op0, op1, asserts);
     185                 :   13508300 :           if (TREE_CODE (op1) == SSA_NAME)
     186                 :    3059210 :             register_edge_assert_for (op1, pred_e, code, op0, op1, asserts);
     187                 :            : 
     188                 :   27016700 :           auto_vec<std::pair<tree, value_range_equiv *>, 8> vrs;
     189                 :   66048800 :           for (unsigned i = 0; i < asserts.length (); ++i)
     190                 :            :             {
     191                 :   19516100 :               value_range_equiv *vr
     192                 :   19516100 :                 = try_find_new_range (asserts[i].name,
     193                 :   19516100 :                                       asserts[i].expr,
     194                 :   19516100 :                                       asserts[i].comp_code,
     195                 :   19516100 :                                       asserts[i].val);
     196                 :   19516100 :               if (vr)
     197                 :   18540100 :                 vrs.safe_push (std::make_pair (asserts[i].name, vr));
     198                 :            :             }
     199                 :            : 
     200                 :            :           /* If pred_e is really a fallthru we can record value ranges
     201                 :            :              in SSA names as well.  */
     202                 :   13508300 :           bool is_fallthru = assert_unreachable_fallthru_edge_p (pred_e);
     203                 :            : 
     204                 :            :           /* Push updated ranges only after finding all of them to avoid
     205                 :            :              ordering issues that can lead to worse ranges.  */
     206                 :   64096900 :           for (unsigned i = 0; i < vrs.length (); ++i)
     207                 :            :             {
     208                 :            :               /* But make sure we do not weaken ranges like when
     209                 :            :                  getting first [64, +INF] and then ~[0, 0] from
     210                 :            :                  conditions like (s & 0x3cc0) == 0).  */
     211                 :   18540100 :               const value_range_equiv *old_vr
     212                 :   18540100 :                 = get_value_range (vrs[i].first);
     213                 :   18540100 :               value_range tem (*old_vr);
     214                 :   18540100 :               tem.intersect (vrs[i].second);
     215                 :   18540100 :               if (tem.equal_p (*old_vr))
     216                 :            :                 {
     217                 :    2428500 :                   vr_values->free_value_range (vrs[i].second);
     218                 :    2428500 :                   continue;
     219                 :            :                 }
     220                 :   16111600 :               push_value_range (vrs[i].first, vrs[i].second);
     221                 :   16111600 :               if (is_fallthru
     222                 :       3240 :                   && m_update_global_ranges
     223                 :   16114200 :                   && all_uses_feed_or_dominated_by_stmt (vrs[i].first, stmt))
     224                 :            :                 {
     225                 :       1698 :                   set_ssa_range_info (vrs[i].first, vrs[i].second);
     226                 :       1698 :                   maybe_set_nonzero_bits (pred_e, vrs[i].first);
     227                 :            :                 }
     228                 :            :             }
     229                 :            :         }
     230                 :            :     }
     231                 :   32355000 : }
     232                 :            : 
     233                 :            : void
     234                 :   32355000 : evrp_range_analyzer::record_ranges_from_phis (basic_block bb)
     235                 :            : {
     236                 :            :   /* Visit PHI stmts and discover any new VRs possible.  */
     237                 :   32355000 :   bool has_unvisited_preds = false;
     238                 :   32355000 :   edge_iterator ei;
     239                 :   32355000 :   edge e;
     240                 :   71180100 :   FOR_EACH_EDGE (e, ei, bb->preds)
     241                 :   40287600 :     if (e->flags & EDGE_EXECUTABLE
     242                 :   40191100 :         && !(e->src->flags & BB_VISITED))
     243                 :            :       {
     244                 :            :         has_unvisited_preds = true;
     245                 :            :         break;
     246                 :            :       }
     247                 :            : 
     248                 :   32355000 :   for (gphi_iterator gpi = gsi_start_phis (bb);
     249                 :   43336900 :        !gsi_end_p (gpi); gsi_next (&gpi))
     250                 :            :     {
     251                 :   10981900 :       gphi *phi = gpi.phi ();
     252                 :   10981900 :       tree lhs = PHI_RESULT (phi);
     253                 :   21963800 :       if (virtual_operand_p (lhs))
     254                 :    5749070 :         continue;
     255                 :            : 
     256                 :            :       /* Skips floats and other things we can't represent in a
     257                 :            :          range.  */
     258                 :    5530810 :       if (!value_range::supports_type_p (TREE_TYPE (lhs)))
     259                 :     297957 :         continue;
     260                 :            : 
     261                 :    5232850 :       value_range_equiv vr_result;
     262                 :    5232850 :       bool interesting = stmt_interesting_for_vrp (phi);
     263                 :    5232850 :       if (!has_unvisited_preds && interesting)
     264                 :    3058660 :         vr_values->extract_range_from_phi_node (phi, &vr_result);
     265                 :            :       else
     266                 :            :         {
     267                 :    2174190 :           vr_result.set_varying (TREE_TYPE (lhs));
     268                 :            :           /* When we have an unvisited executable predecessor we can't
     269                 :            :              use PHI arg ranges which may be still UNDEFINED but have
     270                 :            :              to use VARYING for them.  But we can still resort to
     271                 :            :              SCEV for loop header PHIs.  */
     272                 :    2174190 :           class loop *l;
     273                 :    2174190 :           if (scev_initialized_p ()
     274                 :    1077850 :               && interesting
     275                 :    1077850 :               && (l = loop_containing_stmt (phi))
     276                 :    3252040 :               && l->header == gimple_bb (phi))
     277                 :    1073150 :           vr_values->adjust_range_with_scev (&vr_result, l, phi, lhs);
     278                 :            :         }
     279                 :    5232850 :       vr_values->update_value_range (lhs, &vr_result);
     280                 :            : 
     281                 :            :       /* Set the SSA with the value range.  */
     282                 :    5232850 :       if (m_update_global_ranges)
     283                 :    3798410 :         set_ssa_range_info (lhs, &vr_result);
     284                 :            :     }
     285                 :   32355000 : }
     286                 :            : 
     287                 :            : /* Record ranges from STMT into our VR_VALUES class.  If TEMPORARY is
     288                 :            :    true, then this is a temporary equivalence and should be recorded
     289                 :            :    into the unwind table.  Othewise record the equivalence into the
     290                 :            :    global table.  */
     291                 :            : 
     292                 :            : void
     293                 :  245112000 : evrp_range_analyzer::record_ranges_from_stmt (gimple *stmt, bool temporary)
     294                 :            : {
     295                 :  245112000 :   tree output = NULL_TREE;
     296                 :            : 
     297                 :  245112000 :   if (!optimize)
     298                 :     264465 :     return;
     299                 :            : 
     300                 :  244848000 :   if (dyn_cast <gcond *> (stmt))
     301                 :            :     ;
     302                 :  228522000 :   else if (stmt_interesting_for_vrp (stmt))
     303                 :            :     {
     304                 :   35441800 :       edge taken_edge;
     305                 :   35441800 :       value_range_equiv vr;
     306                 :   35441800 :       vr_values->extract_range_from_stmt (stmt, &taken_edge, &output, &vr);
     307                 :   35441800 :       if (output)
     308                 :            :         {
     309                 :            :           /* Set the SSA with the value range.  There are two cases to
     310                 :            :              consider.  First (the the most common) is we are processing
     311                 :            :              STMT in a context where its resulting range globally holds
     312                 :            :              and thus it can be reflected into the global ranges and need
     313                 :            :              not be unwound as we leave scope.
     314                 :            : 
     315                 :            :              The second case occurs if we are processing a statement in
     316                 :            :              a context where the resulting range must not be reflected
     317                 :            :              into the global tables and must be unwound as we leave
     318                 :            :              the current context.  This happens in jump threading for
     319                 :            :              example.  */
     320                 :   35174200 :           if (!temporary)
     321                 :            :             {
     322                 :            :               /* Case one.  We can just update the underlying range
     323                 :            :                  information as well as the global information.  */
     324                 :   24885300 :               vr_values->update_value_range (output, &vr);
     325                 :   24885300 :               if (m_update_global_ranges)
     326                 :   18587800 :                 set_ssa_range_info (output, &vr);
     327                 :            :             }
     328                 :            :           else
     329                 :            :             {
     330                 :            :               /* We're going to need to unwind this range.  We cannot
     331                 :            :                  use VR as that's a stack object.  We have to allocate
     332                 :            :                  a new range and push the old range onto the stack.  We
     333                 :            :                  also have to be very careful about sharing the underlying
     334                 :            :                  bitmaps.  Ugh.  */
     335                 :   10289000 :               value_range_equiv *new_vr
     336                 :   10289000 :                 = vr_values->allocate_value_range_equiv ();
     337                 :   10289000 :               new_vr->set (vr.min (), vr.max (), NULL, vr.kind ());
     338                 :   10289000 :               vr.equiv_clear ();
     339                 :   10289000 :               push_value_range (output, new_vr);
     340                 :            :             }
     341                 :            :         }
     342                 :            :       else
     343                 :     267556 :         vr_values->set_defs_to_varying (stmt);
     344                 :            :     }
     345                 :            :   else
     346                 :  193080000 :     vr_values->set_defs_to_varying (stmt);
     347                 :            : 
     348                 :            :   /* See if we can derive a range for any of STMT's operands.  */
     349                 :  244848000 :   tree op;
     350                 :  244848000 :   ssa_op_iter i;
     351                 :  372808000 :   FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE)
     352                 :            :     {
     353                 :  127960000 :       tree value;
     354                 :  127960000 :       enum tree_code comp_code;
     355                 :            : 
     356                 :            :       /* If OP is used in such a way that we can infer a value
     357                 :            :          range for it, and we don't find a previous assertion for
     358                 :            :          it, create a new assertion location node for OP.  */
     359                 :  127960000 :       if (infer_value_range (stmt, op, &comp_code, &value))
     360                 :            :         {
     361                 :            :           /* If we are able to infer a nonzero value range for OP,
     362                 :            :              then walk backwards through the use-def chain to see if OP
     363                 :            :              was set via a typecast.
     364                 :            :              If so, then we can also infer a nonzero value range
     365                 :            :              for the operand of the NOP_EXPR.  */
     366                 :   18648800 :           if (comp_code == NE_EXPR && integer_zerop (value))
     367                 :            :             {
     368                 :   18648800 :               tree t = op;
     369                 :   18648800 :               gimple *def_stmt = SSA_NAME_DEF_STMT (t);
     370                 :   18648800 :               while (is_gimple_assign (def_stmt)
     371                 :    6298180 :                      && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))
     372                 :     698553 :                      && TREE_CODE
     373                 :            :                           (gimple_assign_rhs1 (def_stmt)) == SSA_NAME
     374                 :   19347300 :                      && POINTER_TYPE_P
     375                 :            :                           (TREE_TYPE (gimple_assign_rhs1 (def_stmt))))
     376                 :            :                 {
     377                 :         26 :                   t = gimple_assign_rhs1 (def_stmt);
     378                 :         26 :                   def_stmt = SSA_NAME_DEF_STMT (t);
     379                 :            : 
     380                 :            :                   /* Add VR when (T COMP_CODE value) condition is
     381                 :            :                      true.  */
     382                 :         26 :                   value_range_equiv *op_range
     383                 :         26 :                     = try_find_new_range (t, t, comp_code, value);
     384                 :         26 :                   if (op_range)
     385                 :         26 :                     push_value_range (t, op_range);
     386                 :            :                 }
     387                 :            :             }
     388                 :            :           /* Add VR when (OP COMP_CODE value) condition is true.  */
     389                 :   18648800 :           value_range_equiv *op_range = try_find_new_range (op, op,
     390                 :            :                                                             comp_code, value);
     391                 :   18648800 :           if (op_range)
     392                 :    5768250 :             push_value_range (op, op_range);
     393                 :            :         }
     394                 :            :     }
     395                 :            : }
     396                 :            : 
     397                 :            : /* Unwind recorded ranges to their most recent state.  */
     398                 :            : 
     399                 :            : void
     400                 :   43316200 : evrp_range_analyzer::pop_to_marker (void)
     401                 :            : {
     402                 :   43316200 :   gcc_checking_assert (!stack.is_empty ());
     403                 :   85709400 :   while (stack.last ().first != NULL_TREE)
     404                 :   42393200 :     pop_value_range ();
     405                 :   43316200 :   stack.pop ();
     406                 :   43316200 : }
     407                 :            : 
     408                 :            : /* Restore/pop VRs valid only for BB when we leave BB.  */
     409                 :            : 
     410                 :            : void
     411                 :   32419800 : evrp_range_analyzer::leave (basic_block bb ATTRIBUTE_UNUSED)
     412                 :            : {
     413                 :   32419800 :   if (!optimize)
     414                 :            :     return;
     415                 :   32355000 :   pop_to_marker ();
     416                 :            : }
     417                 :            : 
     418                 :            : 
     419                 :            : /* Push the Value Range of VAR to the stack and update it with new VR.  */
     420                 :            : 
     421                 :            : void
     422                 :   42393200 : evrp_range_analyzer::push_value_range (tree var, value_range_equiv *vr)
     423                 :            : {
     424                 :   42393200 :   if (dump_file && (dump_flags & TDF_DETAILS))
     425                 :            :     {
     426                 :       1809 :       fprintf (dump_file, "pushing new range for ");
     427                 :       1809 :       print_generic_expr (dump_file, var);
     428                 :       1809 :       fprintf (dump_file, ": ");
     429                 :       1809 :       dump_value_range (dump_file, vr);
     430                 :       1809 :       fprintf (dump_file, "\n");
     431                 :            :     }
     432                 :   42393200 :   value_range_equiv *old_vr = vr_values->swap_vr_value (var, vr);
     433                 :   42393200 :   stack.safe_push (std::make_pair (var, old_vr));
     434                 :   42393200 : }
     435                 :            : 
     436                 :            : /* Pop a Value Range from the vrp_stack.  */
     437                 :            : 
     438                 :            : void
     439                 :   42393200 : evrp_range_analyzer::pop_value_range ()
     440                 :            : {
     441                 :   42393200 :   std::pair<tree, value_range_equiv *> e = stack.pop ();
     442                 :   42393200 :   tree var = e.first;
     443                 :   42393200 :   value_range_equiv *vr = e.second;
     444                 :   42393200 :   if (dump_file && (dump_flags & TDF_DETAILS))
     445                 :            :     {
     446                 :       1809 :       fprintf (dump_file, "popping range for ");
     447                 :       1809 :       print_generic_expr (dump_file, var);
     448                 :       1809 :       fprintf (dump_file, ", restoring ");
     449                 :       1809 :       dump_value_range (dump_file, vr);
     450                 :       1809 :       fprintf (dump_file, "\n");
     451                 :            :     }
     452                 :            :   /* We saved off a lattice entry, now give it back and release
     453                 :            :      the one we popped.  */
     454                 :   42393200 :   value_range_equiv *popped_vr = vr_values->swap_vr_value (var, vr);
     455                 :   42393200 :   if (popped_vr)
     456                 :   42393200 :     vr_values->free_value_range (popped_vr);
     457                 :   42393200 : }

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.