LCOV - code coverage report
Current view: top level - gcc - tree-ssanames.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 306 370 82.7 %
Date: 2020-04-04 11:58:09 Functions: 32 34 94.1 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Generic routines for manipulating SSA_NAME expressions
       2                 :            :    Copyright (C) 2003-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-iterator.h"
      29                 :            : #include "stor-layout.h"
      30                 :            : #include "tree-into-ssa.h"
      31                 :            : #include "tree-ssa.h"
      32                 :            : #include "cfgloop.h"
      33                 :            : #include "tree-scalar-evolution.h"
      34                 :            : 
      35                 :            : /* Rewriting a function into SSA form can create a huge number of SSA_NAMEs,
      36                 :            :    many of which may be thrown away shortly after their creation if jumps
      37                 :            :    were threaded through PHI nodes.
      38                 :            : 
      39                 :            :    While our garbage collection mechanisms will handle this situation, it
      40                 :            :    is extremely wasteful to create nodes and throw them away, especially
      41                 :            :    when the nodes can be reused.
      42                 :            : 
      43                 :            :    For PR 8361, we can significantly reduce the number of nodes allocated
      44                 :            :    and thus the total amount of memory allocated by managing SSA_NAMEs a
      45                 :            :    little.  This additionally helps reduce the amount of work done by the
      46                 :            :    garbage collector.  Similar results have been seen on a wider variety
      47                 :            :    of tests (such as the compiler itself).
      48                 :            : 
      49                 :            :    Right now we maintain our free list on a per-function basis.  It may
      50                 :            :    or may not make sense to maintain the free list for the duration of
      51                 :            :    a compilation unit.
      52                 :            : 
      53                 :            :    External code should rely solely upon HIGHEST_SSA_VERSION and the
      54                 :            :    externally defined functions.  External code should not know about
      55                 :            :    the details of the free list management.
      56                 :            : 
      57                 :            :    External code should also not assume the version number on nodes is
      58                 :            :    monotonically increasing.  We reuse the version number when we
      59                 :            :    reuse an SSA_NAME expression.  This helps keep arrays and bitmaps
      60                 :            :    more compact.  */
      61                 :            : 
      62                 :            : 
      63                 :            : /* Version numbers with special meanings.  We start allocating new version
      64                 :            :    numbers after the special ones.  */
      65                 :            : #define UNUSED_NAME_VERSION 0
      66                 :            : 
      67                 :            : unsigned int ssa_name_nodes_reused;
      68                 :            : unsigned int ssa_name_nodes_created;
      69                 :            : 
      70                 :            : #define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames
      71                 :            : #define FREE_SSANAMES_QUEUE(fun) (fun)->gimple_df->free_ssanames_queue
      72                 :            : 
      73                 :            : 
      74                 :            : /* Initialize management of SSA_NAMEs to default SIZE.  If SIZE is
      75                 :            :    zero use default.  */
      76                 :            : 
      77                 :            : void
      78                 :    2195240 : init_ssanames (struct function *fn, int size)
      79                 :            : {
      80                 :    2195240 :   if (size < 50)
      81                 :            :     size = 50;
      82                 :            : 
      83                 :    2195240 :   vec_alloc (SSANAMES (fn), size);
      84                 :            : 
      85                 :            :   /* Version 0 is special, so reserve the first slot in the table.  Though
      86                 :            :      currently unused, we may use version 0 in alias analysis as part of
      87                 :            :      the heuristics used to group aliases when the alias sets are too
      88                 :            :      large.
      89                 :            : 
      90                 :            :      We use vec::quick_push here because we know that SSA_NAMES has at
      91                 :            :      least 50 elements reserved in it.  */
      92                 :    2195240 :   SSANAMES (fn)->quick_push (NULL_TREE);
      93                 :    2195240 :   FREE_SSANAMES (fn) = NULL;
      94                 :    2195240 :   FREE_SSANAMES_QUEUE (fn) = NULL;
      95                 :            : 
      96                 :    2195240 :   fn->gimple_df->ssa_renaming_needed = 0;
      97                 :    2195240 :   fn->gimple_df->rename_vops = 0;
      98                 :    2195240 : }
      99                 :            : 
     100                 :            : /* Finalize management of SSA_NAMEs.  */
     101                 :            : 
     102                 :            : void
     103                 :    2030360 : fini_ssanames (struct function *fn)
     104                 :            : {
     105                 :    2030360 :   vec_free (SSANAMES (fn));
     106                 :    2030360 :   vec_free (FREE_SSANAMES (fn));
     107                 :    2030360 :   vec_free (FREE_SSANAMES_QUEUE (fn));
     108                 :    2030360 : }
     109                 :            : 
     110                 :            : /* Dump some simple statistics regarding the re-use of SSA_NAME nodes.  */
     111                 :            : 
     112                 :            : void
     113                 :          0 : ssanames_print_statistics (void)
     114                 :            : {
     115                 :          0 :   fprintf (stderr, "%-32s" PRsa (11) "\n", "SSA_NAME nodes allocated:",
     116                 :          0 :            SIZE_AMOUNT (ssa_name_nodes_created));
     117                 :          0 :   fprintf (stderr, "%-32s" PRsa (11) "\n", "SSA_NAME nodes reused:",
     118                 :          0 :            SIZE_AMOUNT (ssa_name_nodes_reused));
     119                 :          0 : }
     120                 :            : 
     121                 :            : /* Verify the state of the SSA_NAME lists.
     122                 :            : 
     123                 :            :    There must be no duplicates on the free list.
     124                 :            :    Every name on the free list must be marked as on the free list.
     125                 :            :    Any name on the free list must not appear in the IL.
     126                 :            :    No names can be leaked.  */
     127                 :            : 
     128                 :            : DEBUG_FUNCTION void
     129                 :          0 : verify_ssaname_freelists (struct function *fun)
     130                 :            : {
     131                 :          0 :   if (!gimple_in_ssa_p (fun))
     132                 :          0 :     return;
     133                 :            : 
     134                 :          0 :   auto_bitmap names_in_il;
     135                 :            : 
     136                 :            :   /* Walk the entire IL noting every SSA_NAME we see.  */
     137                 :          0 :   basic_block bb;
     138                 :          0 :   FOR_EACH_BB_FN (bb, fun)
     139                 :            :     {
     140                 :          0 :       tree t;
     141                 :            :       /* First note the result and arguments of PHI nodes.  */
     142                 :          0 :       for (gphi_iterator gsi = gsi_start_phis (bb);
     143                 :          0 :            !gsi_end_p (gsi);
     144                 :          0 :            gsi_next (&gsi))
     145                 :            :         {
     146                 :          0 :           gphi *phi = gsi.phi ();
     147                 :          0 :           t = gimple_phi_result (phi);
     148                 :          0 :           bitmap_set_bit (names_in_il, SSA_NAME_VERSION (t));
     149                 :            : 
     150                 :          0 :           for (unsigned int i = 0; i < gimple_phi_num_args (phi); i++)
     151                 :            :             {
     152                 :          0 :               t = gimple_phi_arg_def (phi, i);
     153                 :          0 :               if (TREE_CODE (t) == SSA_NAME)
     154                 :          0 :                 bitmap_set_bit (names_in_il, SSA_NAME_VERSION (t));
     155                 :            :             }
     156                 :            :         }
     157                 :            : 
     158                 :            :       /* Then note the operands of each statement.  */
     159                 :          0 :       for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
     160                 :          0 :            !gsi_end_p (gsi);
     161                 :          0 :            gsi_next (&gsi))
     162                 :            :         {
     163                 :          0 :           ssa_op_iter iter;
     164                 :          0 :           gimple *stmt = gsi_stmt (gsi);
     165                 :          0 :           FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, SSA_OP_ALL_OPERANDS)
     166                 :          0 :             bitmap_set_bit (names_in_il, SSA_NAME_VERSION (t));
     167                 :            :         }
     168                 :            :     }
     169                 :            : 
     170                 :            :   /* Now walk the free list noting what we find there and verifying
     171                 :            :      there are no duplicates.  */
     172                 :          0 :   auto_bitmap names_in_freelists;
     173                 :          0 :   if (FREE_SSANAMES (fun))
     174                 :            :     {
     175                 :          0 :       for (unsigned int i = 0; i < FREE_SSANAMES (fun)->length (); i++)
     176                 :            :         {
     177                 :          0 :           tree t = (*FREE_SSANAMES (fun))[i];
     178                 :            : 
     179                 :            :           /* Verify that the name is marked as being in the free list.  */
     180                 :          0 :           gcc_assert (SSA_NAME_IN_FREE_LIST (t));
     181                 :            : 
     182                 :            :           /* Verify the name has not already appeared in the free list and
     183                 :            :              note it in the list of names found in the free list.  */
     184                 :          0 :           gcc_assert (!bitmap_bit_p (names_in_freelists, SSA_NAME_VERSION (t)));
     185                 :          0 :           bitmap_set_bit (names_in_freelists, SSA_NAME_VERSION (t));
     186                 :            :         }
     187                 :            :     }
     188                 :            : 
     189                 :            :   /* Similarly for the names in the pending free list.  */
     190                 :          0 :   if (FREE_SSANAMES_QUEUE (fun))
     191                 :            :     {
     192                 :          0 :       for (unsigned int i = 0; i < FREE_SSANAMES_QUEUE (fun)->length (); i++)
     193                 :            :         {
     194                 :          0 :           tree t = (*FREE_SSANAMES_QUEUE (fun))[i];
     195                 :            : 
     196                 :            :           /* Verify that the name is marked as being in the free list.  */
     197                 :          0 :           gcc_assert (SSA_NAME_IN_FREE_LIST (t));
     198                 :            : 
     199                 :            :           /* Verify the name has not already appeared in the free list and
     200                 :            :              note it in the list of names found in the free list.  */
     201                 :          0 :           gcc_assert (!bitmap_bit_p (names_in_freelists, SSA_NAME_VERSION (t)));
     202                 :          0 :           bitmap_set_bit (names_in_freelists, SSA_NAME_VERSION (t));
     203                 :            :         }
     204                 :            :     }
     205                 :            : 
     206                 :            :   /* If any name appears in both the IL and the freelists, then
     207                 :            :      something horrible has happened.  */
     208                 :          0 :   bool intersect_p = bitmap_intersect_p (names_in_il, names_in_freelists);
     209                 :          0 :   gcc_assert (!intersect_p);
     210                 :            : 
     211                 :            :   /* Names can be queued up for release if there is an ssa update
     212                 :            :      pending.  Pretend we saw them in the IL.  */
     213                 :          0 :   if (names_to_release)
     214                 :          0 :     bitmap_ior_into (names_in_il, names_to_release);
     215                 :            : 
     216                 :            :   /* Function splitting can "lose" SSA_NAMEs in an effort to ensure that
     217                 :            :      debug/non-debug compilations have the same SSA_NAMEs.  So for each
     218                 :            :      lost SSA_NAME, see if it's likely one from that wart.  These will always
     219                 :            :      be marked as default definitions.  So we loosely assume that anything
     220                 :            :      marked as a default definition isn't leaked by pretending they are
     221                 :            :      in the IL.  */
     222                 :          0 :   for (unsigned int i = UNUSED_NAME_VERSION + 1; i < num_ssa_names; i++)
     223                 :          0 :     if (ssa_name (i) && SSA_NAME_IS_DEFAULT_DEF (ssa_name (i)))
     224                 :          0 :       bitmap_set_bit (names_in_il, i);
     225                 :            : 
     226                 :          0 :   unsigned int i;
     227                 :          0 :   bitmap_iterator bi;
     228                 :          0 :   auto_bitmap all_names;
     229                 :          0 :   bitmap_set_range (all_names, UNUSED_NAME_VERSION + 1, num_ssa_names - 1);
     230                 :          0 :   bitmap_ior_into (names_in_il, names_in_freelists);
     231                 :            : 
     232                 :            :   /* Any name not mentioned in the IL and not in the feelists
     233                 :            :      has been leaked.  */
     234                 :          0 :   EXECUTE_IF_AND_COMPL_IN_BITMAP(all_names, names_in_il,
     235                 :            :                                  UNUSED_NAME_VERSION + 1, i, bi)
     236                 :          0 :     gcc_assert (!ssa_name (i));
     237                 :            : }
     238                 :            : 
     239                 :            : /* Move all SSA_NAMEs from FREE_SSA_NAMES_QUEUE to FREE_SSA_NAMES.
     240                 :            : 
     241                 :            :    We do not, but should have a mode to verify the state of the SSA_NAMEs
     242                 :            :    lists.  In particular at this point every name must be in the IL,
     243                 :            :    on the free list or in the queue.  Anything else is an error.  */
     244                 :            : 
     245                 :            : void
     246                 :  357549000 : flush_ssaname_freelist (void)
     247                 :            : {
     248                 :            :   /* If there were any SSA names released reset the SCEV cache.  */
     249                 :  357549000 :   if (! vec_safe_is_empty (FREE_SSANAMES_QUEUE (cfun)))
     250                 :    6749760 :     scev_reset_htab ();
     251                 :  357549000 :   vec_safe_splice (FREE_SSANAMES (cfun), FREE_SSANAMES_QUEUE (cfun));
     252                 :  357549000 :   vec_safe_truncate (FREE_SSANAMES_QUEUE (cfun), 0);
     253                 :  357549000 : }
     254                 :            : 
     255                 :            : /* Initialize SSA_NAME_IMM_USE_NODE of a SSA NAME.  */
     256                 :            : 
     257                 :            : void
     258                 :   91537800 : init_ssa_name_imm_use (tree name)
     259                 :            : {
     260                 :   91537800 :   use_operand_p imm;
     261                 :   91537800 :   imm = &(SSA_NAME_IMM_USE_NODE (name));
     262                 :   91537800 :   imm->use = NULL;
     263                 :   91537800 :   imm->prev = imm;
     264                 :   91537800 :   imm->next = imm;
     265                 :   91537800 :   imm->loc.ssa_name = name;
     266                 :   91537800 : }
     267                 :            : 
     268                 :            : /* Return an SSA_NAME node for variable VAR defined in statement STMT
     269                 :            :    in function FN.  STMT may be an empty statement for artificial
     270                 :            :    references (e.g., default definitions created when a variable is
     271                 :            :    used without a preceding definition).  If VERISON is not zero then
     272                 :            :    allocate the SSA name with that version.  */
     273                 :            : 
     274                 :            : tree
     275                 :   90882600 : make_ssa_name_fn (struct function *fn, tree var, gimple *stmt,
     276                 :            :                   unsigned int version)
     277                 :            : {
     278                 :   90882600 :   tree t;
     279                 :   90882600 :   gcc_assert (VAR_P (var)
     280                 :            :               || TREE_CODE (var) == PARM_DECL
     281                 :            :               || TREE_CODE (var) == RESULT_DECL
     282                 :            :               || (TYPE_P (var) && is_gimple_reg_type (var)));
     283                 :            : 
     284                 :            :   /* Get the specified SSA name version.  */
     285                 :   90882600 :   if (version != 0)
     286                 :            :     {
     287                 :       1609 :       t = make_node (SSA_NAME);
     288                 :       1609 :       SSA_NAME_VERSION (t) = version;
     289                 :       1609 :       if (version >= SSANAMES (fn)->length ())
     290                 :        391 :         vec_safe_grow_cleared (SSANAMES (fn), version + 1);
     291                 :       1609 :       gcc_assert ((*SSANAMES (fn))[version] == NULL);
     292                 :       1609 :       (*SSANAMES (fn))[version] = t;
     293                 :       1609 :       ssa_name_nodes_created++;
     294                 :            :     }
     295                 :            :   /* If our free list has an element, then use it.  */
     296                 :   90881000 :   else if (!vec_safe_is_empty (FREE_SSANAMES (fn)))
     297                 :            :     {
     298                 :   18691700 :       t = FREE_SSANAMES (fn)->pop ();
     299                 :   18691700 :       ssa_name_nodes_reused++;
     300                 :            : 
     301                 :            :       /* The node was cleared out when we put it on the free list, so
     302                 :            :          there is no need to do so again here.  */
     303                 :   18691700 :       gcc_assert ((*SSANAMES (fn))[SSA_NAME_VERSION (t)] == NULL);
     304                 :   18691700 :       (*SSANAMES (fn))[SSA_NAME_VERSION (t)] = t;
     305                 :            :     }
     306                 :            :   else
     307                 :            :     {
     308                 :   72189300 :       t = make_node (SSA_NAME);
     309                 :   72189300 :       SSA_NAME_VERSION (t) = SSANAMES (fn)->length ();
     310                 :   72189300 :       vec_safe_push (SSANAMES (fn), t);
     311                 :   72189300 :       ssa_name_nodes_created++;
     312                 :            :     }
     313                 :            : 
     314                 :   90882600 :   if (TYPE_P (var))
     315                 :            :     {
     316                 :   33108600 :       TREE_TYPE (t) = TYPE_MAIN_VARIANT (var);
     317                 :   33108600 :       SET_SSA_NAME_VAR_OR_IDENTIFIER (t, NULL_TREE);
     318                 :            :     }
     319                 :            :   else
     320                 :            :     {
     321                 :   57774000 :       TREE_TYPE (t) = TREE_TYPE (var);
     322                 :   81758100 :       SET_SSA_NAME_VAR_OR_IDENTIFIER (t, var);
     323                 :            :     }
     324                 :   90882600 :   SSA_NAME_DEF_STMT (t) = stmt;
     325                 :   90882600 :   if (POINTER_TYPE_P (TREE_TYPE (t)))
     326                 :   21489100 :     SSA_NAME_PTR_INFO (t) = NULL;
     327                 :            :   else
     328                 :   69393500 :     SSA_NAME_RANGE_INFO (t) = NULL;
     329                 :            : 
     330                 :   90882600 :   SSA_NAME_IN_FREE_LIST (t) = 0;
     331                 :   90882600 :   SSA_NAME_IS_DEFAULT_DEF (t) = 0;
     332                 :   90882600 :   init_ssa_name_imm_use (t);
     333                 :            : 
     334                 :   90882600 :   return t;
     335                 :            : }
     336                 :            : 
     337                 :            : /* Helper function for set_range_info.
     338                 :            : 
     339                 :            :    Store range information RANGE_TYPE, MIN, and MAX to tree ssa_name
     340                 :            :    NAME.  */
     341                 :            : 
     342                 :            : void
     343                 :   14755100 : set_range_info_raw (tree name, enum value_range_kind range_type,
     344                 :            :                     const wide_int_ref &min, const wide_int_ref &max)
     345                 :            : {
     346                 :   14755100 :   gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name)));
     347                 :   14755100 :   gcc_assert (range_type == VR_RANGE || range_type == VR_ANTI_RANGE);
     348                 :   14755100 :   range_info_def *ri = SSA_NAME_RANGE_INFO (name);
     349                 :   14755100 :   unsigned int precision = TYPE_PRECISION (TREE_TYPE (name));
     350                 :            : 
     351                 :            :   /* Allocate if not available.  */
     352                 :   14755100 :   if (ri == NULL)
     353                 :            :     {
     354                 :    5638470 :       size_t size = (sizeof (range_info_def)
     355                 :    5638470 :                      + trailing_wide_ints <3>::extra_size (precision));
     356                 :    5638470 :       ri = static_cast<range_info_def *> (ggc_internal_alloc (size));
     357                 :    5638470 :       ri->ints.set_precision (precision);
     358                 :    5638470 :       SSA_NAME_RANGE_INFO (name) = ri;
     359                 :    8399300 :       ri->set_nonzero_bits (wi::shwi (-1, precision));
     360                 :            :     }
     361                 :            : 
     362                 :            :   /* Record the range type.  */
     363                 :   28742700 :   if (SSA_NAME_RANGE_TYPE (name) != range_type)
     364                 :     644654 :     SSA_NAME_ANTI_RANGE_P (name) = (range_type == VR_ANTI_RANGE);
     365                 :            : 
     366                 :            :   /* Set the values.  */
     367                 :   14755100 :   ri->set_min (min);
     368                 :   14755100 :   ri->set_max (max);
     369                 :            : 
     370                 :            :   /* If it is a range, try to improve nonzero_bits from the min/max.  */
     371                 :   14755100 :   if (range_type == VR_RANGE)
     372                 :            :     {
     373                 :   13476200 :       wide_int xorv = ri->get_min () ^ ri->get_max ();
     374                 :   13476200 :       if (xorv != 0)
     375                 :   12764500 :         xorv = wi::mask (precision - wi::clz (xorv), false, precision);
     376                 :   13476200 :       ri->set_nonzero_bits (ri->get_nonzero_bits () & (ri->get_min () | xorv));
     377                 :            :     }
     378                 :   14755100 : }
     379                 :            : 
     380                 :            : /* Store range information RANGE_TYPE, MIN, and MAX to tree ssa_name
     381                 :            :    NAME while making sure we don't store useless range info.  */
     382                 :            : 
     383                 :            : void
     384                 :   13440400 : set_range_info (tree name, enum value_range_kind range_type,
     385                 :            :                 const wide_int_ref &min, const wide_int_ref &max)
     386                 :            : {
     387                 :   13440400 :   gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name)));
     388                 :            : 
     389                 :            :   /* A range of the entire domain is really no range at all.  */
     390                 :   13440400 :   tree type = TREE_TYPE (name);
     391                 :   13440400 :   if (min == wi::min_value (TYPE_PRECISION (type), TYPE_SIGN (type))
     392                 :   16978200 :       && max == wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type)))
     393                 :            :     {
     394                 :          0 :       range_info_def *ri = SSA_NAME_RANGE_INFO (name);
     395                 :          0 :       if (ri == NULL)
     396                 :            :         return;
     397                 :          0 :       if (ri->get_nonzero_bits () == -1)
     398                 :            :         {
     399                 :          0 :           ggc_free (ri);
     400                 :          0 :           SSA_NAME_RANGE_INFO (name) = NULL;
     401                 :          0 :           return;
     402                 :            :         }
     403                 :            :     }
     404                 :            : 
     405                 :   13440400 :   set_range_info_raw (name, range_type, min, max);
     406                 :            : }
     407                 :            : 
     408                 :            : /* Store range information for NAME from a value_range.  */
     409                 :            : 
     410                 :            : void
     411                 :    6568000 : set_range_info (tree name, const value_range &vr)
     412                 :            : {
     413                 :    6568000 :   wide_int min = wi::to_wide (vr.min ());
     414                 :    6568000 :   wide_int max = wi::to_wide (vr.max ());
     415                 :    6568000 :   set_range_info (name, vr.kind (), min, max);
     416                 :    6568000 : }
     417                 :            : 
     418                 :            : /* Gets range information MIN, MAX and returns enum value_range_kind
     419                 :            :    corresponding to tree ssa_name NAME.  enum value_range_kind returned
     420                 :            :    is used to determine if MIN and MAX are valid values.  */
     421                 :            : 
     422                 :            : enum value_range_kind
     423                 :  119595000 : get_range_info (const_tree name, wide_int *min, wide_int *max)
     424                 :            : {
     425                 :  119595000 :   gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name)));
     426                 :  119595000 :   gcc_assert (min && max);
     427                 :  119595000 :   range_info_def *ri = SSA_NAME_RANGE_INFO (name);
     428                 :            : 
     429                 :            :   /* Return VR_VARYING for SSA_NAMEs with NULL RANGE_INFO or SSA_NAMEs
     430                 :            :      with integral types width > 2 * HOST_BITS_PER_WIDE_INT precision.  */
     431                 :  119595000 :   if (!ri || (GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (TREE_TYPE (name)))
     432                 :            :               > 2 * HOST_BITS_PER_WIDE_INT))
     433                 :            :     return VR_VARYING;
     434                 :            : 
     435                 :   45879900 :   *min = ri->get_min ();
     436                 :   45879900 :   *max = ri->get_max ();
     437                 :   45879900 :   return SSA_NAME_RANGE_TYPE (name);
     438                 :            : }
     439                 :            : 
     440                 :            : /* Gets range information corresponding to ssa_name NAME and stores it
     441                 :            :    in a value_range VR.  Returns the value_range_kind.  */
     442                 :            : 
     443                 :            : enum value_range_kind
     444                 :   44911200 : get_range_info (const_tree name, value_range &vr)
     445                 :            : {
     446                 :   44911200 :   tree min, max;
     447                 :   44911200 :   wide_int wmin, wmax;
     448                 :   44911200 :   enum value_range_kind kind = get_range_info (name, &wmin, &wmax);
     449                 :            : 
     450                 :   44911200 :   if (kind == VR_VARYING)
     451                 :   28800300 :     vr.set_varying (TREE_TYPE (name));
     452                 :   16110900 :   else if (kind == VR_UNDEFINED)
     453                 :          0 :     vr.set_undefined ();
     454                 :            :   else
     455                 :            :     {
     456                 :   16110900 :       min = wide_int_to_tree (TREE_TYPE (name), wmin);
     457                 :   16110900 :       max = wide_int_to_tree (TREE_TYPE (name), wmax);
     458                 :   16110900 :       vr.set (min, max, kind);
     459                 :            :     }
     460                 :   44911200 :   return kind;
     461                 :            : }
     462                 :            : 
     463                 :            : /* Set nonnull attribute to pointer NAME.  */
     464                 :            : 
     465                 :            : void
     466                 :    6297450 : set_ptr_nonnull (tree name)
     467                 :            : {
     468                 :    6297450 :   gcc_assert (POINTER_TYPE_P (TREE_TYPE (name)));
     469                 :    6297450 :   struct ptr_info_def *pi = get_ptr_info (name);
     470                 :    6297450 :   pi->pt.null = 0;
     471                 :    6297450 : }
     472                 :            : 
     473                 :            : /* Return nonnull attribute of pointer NAME.  */
     474                 :            : bool
     475                 :   18215400 : get_ptr_nonnull (const_tree name)
     476                 :            : {
     477                 :   18215400 :   gcc_assert (POINTER_TYPE_P (TREE_TYPE (name)));
     478                 :   18215400 :   struct ptr_info_def *pi = SSA_NAME_PTR_INFO (name);
     479                 :   18215400 :   if (pi == NULL)
     480                 :            :     return false;
     481                 :            :   /* TODO Now pt->null is conservatively set to true in PTA
     482                 :            :      analysis. vrp is the only pass (including ipa-vrp)
     483                 :            :      that clears pt.null via set_ptr_nonull when it knows
     484                 :            :      for sure. PTA will preserves the pt.null value set by VRP.
     485                 :            : 
     486                 :            :      When PTA analysis is improved, pt.anything, pt.nonlocal
     487                 :            :      and pt.escaped may also has to be considered before
     488                 :            :      deciding that pointer cannot point to NULL.  */
     489                 :    8309390 :   return !pi->pt.null;
     490                 :            : }
     491                 :            : 
     492                 :            : /* Change non-zero bits bitmask of NAME.  */
     493                 :            : 
     494                 :            : void
     495                 :    4882870 : set_nonzero_bits (tree name, const wide_int_ref &mask)
     496                 :            : {
     497                 :    4882870 :   gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name)));
     498                 :    4882870 :   if (SSA_NAME_RANGE_INFO (name) == NULL)
     499                 :            :     {
     500                 :    1384960 :       if (mask == -1)
     501                 :            :         return;
     502                 :    3944140 :       set_range_info_raw (name, VR_RANGE,
     503                 :    1314710 :                           wi::to_wide (TYPE_MIN_VALUE (TREE_TYPE (name))),
     504                 :    2629420 :                           wi::to_wide (TYPE_MAX_VALUE (TREE_TYPE (name))));
     505                 :            :     }
     506                 :    4812620 :   range_info_def *ri = SSA_NAME_RANGE_INFO (name);
     507                 :    4812620 :   ri->set_nonzero_bits (mask);
     508                 :            : }
     509                 :            : 
     510                 :            : /* Return a widest_int with potentially non-zero bits in SSA_NAME
     511                 :            :    NAME, the constant for INTEGER_CST, or -1 if unknown.  */
     512                 :            : 
     513                 :            : wide_int
     514                 :  231150000 : get_nonzero_bits (const_tree name)
     515                 :            : {
     516                 :  231150000 :   if (TREE_CODE (name) == INTEGER_CST)
     517                 :     382201 :     return wi::to_wide (name);
     518                 :            : 
     519                 :            :   /* Use element_precision instead of TYPE_PRECISION so complex and
     520                 :            :      vector types get a non-zero precision.  */
     521                 :  230768000 :   unsigned int precision = element_precision (TREE_TYPE (name));
     522                 :  230768000 :   if (POINTER_TYPE_P (TREE_TYPE (name)))
     523                 :            :     {
     524                 :   32845300 :       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (name);
     525                 :   32845300 :       if (pi && pi->align)
     526                 :    1666210 :         return wi::shwi (-(HOST_WIDE_INT) pi->align
     527                 :     863187 :                          | (HOST_WIDE_INT) pi->misalign, precision);
     528                 :   38849400 :       return wi::shwi (-1, precision);
     529                 :            :     }
     530                 :            : 
     531                 :  197922000 :   range_info_def *ri = SSA_NAME_RANGE_INFO (name);
     532                 :  197922000 :   if (!ri)
     533                 :  252857000 :     return wi::shwi (-1, precision);
     534                 :            : 
     535                 :   46407600 :   return ri->get_nonzero_bits ();
     536                 :            : }
     537                 :            : 
     538                 :            : /* Return TRUE is OP, an SSA_NAME has a range of values [0..1], false
     539                 :            :    otherwise.
     540                 :            : 
     541                 :            :    This can be because it is a boolean type, any unsigned integral
     542                 :            :    type with a single bit of precision, or has known range of [0..1]
     543                 :            :    via VRP analysis.  */
     544                 :            : 
     545                 :            : bool
     546                 :   16460900 : ssa_name_has_boolean_range (tree op)
     547                 :            : {
     548                 :   16460900 :   gcc_assert (TREE_CODE (op) == SSA_NAME);
     549                 :            : 
     550                 :            :   /* Boolean types always have a range [0..1].  */
     551                 :   16460900 :   if (TREE_CODE (TREE_TYPE (op)) == BOOLEAN_TYPE)
     552                 :            :     return true;
     553                 :            : 
     554                 :            :   /* An integral type with a single bit of precision.  */
     555                 :   13825600 :   if (INTEGRAL_TYPE_P (TREE_TYPE (op))
     556                 :    9819440 :       && TYPE_UNSIGNED (TREE_TYPE (op))
     557                 :   18472800 :       && TYPE_PRECISION (TREE_TYPE (op)) == 1)
     558                 :            :     return true;
     559                 :            : 
     560                 :            :   /* An integral type with more precision, but the object
     561                 :            :      only takes on values [0..1] as determined by VRP
     562                 :            :      analysis.  */
     563                 :   13823300 :   if (INTEGRAL_TYPE_P (TREE_TYPE (op))
     564                 :    9817190 :       && (TYPE_PRECISION (TREE_TYPE (op)) > 1)
     565                 :   37066000 :       && wi::eq_p (get_nonzero_bits (op), 1))
     566                 :     396787 :     return true;
     567                 :            : 
     568                 :            :   return false;
     569                 :            : }
     570                 :            : 
     571                 :            : /* We no longer need the SSA_NAME expression VAR, release it so that
     572                 :            :    it may be reused.
     573                 :            : 
     574                 :            :    Note it is assumed that no calls to make_ssa_name will be made
     575                 :            :    until all uses of the ssa name are released and that the only
     576                 :            :    use of the SSA_NAME expression is to check its SSA_NAME_VAR.  All
     577                 :            :    other fields must be assumed clobbered.  */
     578                 :            : 
     579                 :            : void
     580                 :   50316500 : release_ssa_name_fn (struct function *fn, tree var)
     581                 :            : {
     582                 :   50316500 :   if (!var)
     583                 :            :     return;
     584                 :            : 
     585                 :            :   /* Never release the default definition for a symbol.  It's a
     586                 :            :      special SSA name that should always exist once it's created.  */
     587                 :   50316500 :   if (SSA_NAME_IS_DEFAULT_DEF (var))
     588                 :            :     return;
     589                 :            : 
     590                 :            :   /* If VAR has been registered for SSA updating, don't remove it.
     591                 :            :      After update_ssa has run, the name will be released.  */
     592                 :   50316500 :   if (name_registered_for_update_p (var))
     593                 :            :     {
     594                 :     387283 :       release_ssa_name_after_update_ssa (var);
     595                 :     387283 :       return;
     596                 :            :     }
     597                 :            : 
     598                 :            :   /* release_ssa_name can be called multiple times on a single SSA_NAME.
     599                 :            :      However, it should only end up on our free list one time.   We
     600                 :            :      keep a status bit in the SSA_NAME node itself to indicate it has
     601                 :            :      been put on the free list.
     602                 :            : 
     603                 :            :      Note that once on the freelist you cannot reference the SSA_NAME's
     604                 :            :      defining statement.  */
     605                 :   49929200 :   if (! SSA_NAME_IN_FREE_LIST (var))
     606                 :            :     {
     607                 :   49929200 :       int saved_ssa_name_version = SSA_NAME_VERSION (var);
     608                 :   49929200 :       use_operand_p imm = &(SSA_NAME_IMM_USE_NODE (var));
     609                 :            : 
     610                 :   49929200 :       if (MAY_HAVE_DEBUG_BIND_STMTS)
     611                 :   35421300 :         insert_debug_temp_for_var_def (NULL, var);
     612                 :            : 
     613                 :   49929200 :       if (flag_checking)
     614                 :   49928500 :         verify_imm_links (stderr, var);
     615                 :   55413800 :       while (imm->next != imm)
     616                 :    5484580 :         delink_imm_use (imm->next);
     617                 :            : 
     618                 :   49929200 :       (*SSANAMES (fn))[SSA_NAME_VERSION (var)] = NULL_TREE;
     619                 :   49929200 :       memset (var, 0, tree_size (var));
     620                 :            : 
     621                 :   49929200 :       imm->prev = imm;
     622                 :   49929200 :       imm->next = imm;
     623                 :   49929200 :       imm->loc.ssa_name = var;
     624                 :            : 
     625                 :            :       /* First put back the right tree node so that the tree checking
     626                 :            :          macros do not complain.  */
     627                 :   49929200 :       TREE_SET_CODE (var, SSA_NAME);
     628                 :            : 
     629                 :            :       /* Restore the version number.  */
     630                 :   49929200 :       SSA_NAME_VERSION (var) = saved_ssa_name_version;
     631                 :            : 
     632                 :            :       /* Note this SSA_NAME is now in the first list.  */
     633                 :   49929200 :       SSA_NAME_IN_FREE_LIST (var) = 1;
     634                 :            : 
     635                 :            :       /* Put in a non-NULL TREE_TYPE so dumping code will not ICE
     636                 :            :          if it happens to come along a released SSA name and tries
     637                 :            :          to inspect its type.  */
     638                 :   49929200 :       TREE_TYPE (var) = error_mark_node;
     639                 :            : 
     640                 :            :       /* And finally queue it so that it will be put on the free list.  */
     641                 :   49929200 :       vec_safe_push (FREE_SSANAMES_QUEUE (fn), var);
     642                 :            :     }
     643                 :            : }
     644                 :            : 
     645                 :            : /* If the alignment of the pointer described by PI is known, return true and
     646                 :            :    store the alignment and the deviation from it into *ALIGNP and *MISALIGNP
     647                 :            :    respectively.  Otherwise return false.  */
     648                 :            : 
     649                 :            : bool
     650                 :   17522900 : get_ptr_info_alignment (struct ptr_info_def *pi, unsigned int *alignp,
     651                 :            :                         unsigned int *misalignp)
     652                 :            : {
     653                 :   17522900 :   if (pi->align)
     654                 :            :     {
     655                 :    1166550 :       *alignp = pi->align;
     656                 :    1166550 :       *misalignp = pi->misalign;
     657                 :    1166550 :       return true;
     658                 :            :     }
     659                 :            :   else
     660                 :            :     return false;
     661                 :            : }
     662                 :            : 
     663                 :            : /* State that the pointer described by PI has unknown alignment.  */
     664                 :            : 
     665                 :            : void
     666                 :   10072400 : mark_ptr_info_alignment_unknown (struct ptr_info_def *pi)
     667                 :            : {
     668                 :   10072400 :   pi->align = 0;
     669                 :   10072400 :   pi->misalign = 0;
     670                 :   10072400 : }
     671                 :            : 
     672                 :            : /* Store the power-of-two byte alignment and the deviation from that
     673                 :            :    alignment of pointer described by PI to ALIOGN and MISALIGN
     674                 :            :    respectively.  */
     675                 :            : 
     676                 :            : void
     677                 :     630023 : set_ptr_info_alignment (struct ptr_info_def *pi, unsigned int align,
     678                 :            :                             unsigned int misalign)
     679                 :            : {
     680                 :     630023 :   gcc_checking_assert (align != 0);
     681                 :     630023 :   gcc_assert ((align & (align - 1)) == 0);
     682                 :     630023 :   gcc_assert ((misalign & ~(align - 1)) == 0);
     683                 :            : 
     684                 :     630023 :   pi->align = align;
     685                 :     630023 :   pi->misalign = misalign;
     686                 :     630023 : }
     687                 :            : 
     688                 :            : /* If pointer described by PI has known alignment, increase its known
     689                 :            :    misalignment by INCREMENT modulo its current alignment.  */
     690                 :            : 
     691                 :            : void
     692                 :      18544 : adjust_ptr_info_misalignment (struct ptr_info_def *pi, poly_uint64 increment)
     693                 :            : {
     694                 :      18544 :   if (pi->align != 0)
     695                 :            :     {
     696                 :      18544 :       increment += pi->misalign;
     697                 :      18544 :       if (!known_misalignment (increment, pi->align, &pi->misalign))
     698                 :            :         {
     699                 :            :           pi->align = known_alignment (increment);
     700                 :            :           pi->misalign = 0;
     701                 :            :         }
     702                 :            :     }
     703                 :      18544 : }
     704                 :            : 
     705                 :            : /* Return the alias information associated with pointer T.  It creates a
     706                 :            :    new instance if none existed.  */
     707                 :            : 
     708                 :            : struct ptr_info_def *
     709                 :   22153100 : get_ptr_info (tree t)
     710                 :            : {
     711                 :   22153100 :   struct ptr_info_def *pi;
     712                 :            : 
     713                 :   22153100 :   gcc_assert (POINTER_TYPE_P (TREE_TYPE (t)));
     714                 :            : 
     715                 :   22153100 :   pi = SSA_NAME_PTR_INFO (t);
     716                 :   22153100 :   if (pi == NULL)
     717                 :            :     {
     718                 :    9765210 :       pi = ggc_cleared_alloc<ptr_info_def> ();
     719                 :    9765210 :       pt_solution_reset (&pi->pt);
     720                 :    9765210 :       mark_ptr_info_alignment_unknown (pi);
     721                 :    9765210 :       SSA_NAME_PTR_INFO (t) = pi;
     722                 :            :     }
     723                 :            : 
     724                 :   22153100 :   return pi;
     725                 :            : }
     726                 :            : 
     727                 :            : 
     728                 :            : /* Creates a new SSA name using the template NAME tobe defined by
     729                 :            :    statement STMT in function FN.  */
     730                 :            : 
     731                 :            : tree
     732                 :   13790000 : copy_ssa_name_fn (struct function *fn, tree name, gimple *stmt)
     733                 :            : {
     734                 :   13790000 :   tree new_name;
     735                 :            : 
     736                 :   13790000 :   if (SSA_NAME_VAR (name))
     737                 :    7753070 :     new_name = make_ssa_name_fn (fn, SSA_NAME_VAR (name), stmt);
     738                 :            :   else
     739                 :            :     {
     740                 :    6036950 :       new_name = make_ssa_name_fn (fn, TREE_TYPE (name), stmt);
     741                 :    6036950 :       SET_SSA_NAME_VAR_OR_IDENTIFIER (new_name, SSA_NAME_IDENTIFIER (name));
     742                 :            :     }
     743                 :            : 
     744                 :   13790000 :   return new_name;
     745                 :            : }
     746                 :            : 
     747                 :            : 
     748                 :            : /* Creates a duplicate of the ptr_info_def at PTR_INFO for use by
     749                 :            :    the SSA name NAME.  */
     750                 :            : 
     751                 :            : void
     752                 :    4296370 : duplicate_ssa_name_ptr_info (tree name, struct ptr_info_def *ptr_info)
     753                 :            : {
     754                 :    4296370 :   struct ptr_info_def *new_ptr_info;
     755                 :            : 
     756                 :    4296370 :   gcc_assert (POINTER_TYPE_P (TREE_TYPE (name)));
     757                 :    4296370 :   gcc_assert (!SSA_NAME_PTR_INFO (name));
     758                 :            : 
     759                 :    4296370 :   if (!ptr_info)
     760                 :            :     return;
     761                 :            : 
     762                 :    4295470 :   new_ptr_info = ggc_alloc<ptr_info_def> ();
     763                 :    4295470 :   *new_ptr_info = *ptr_info;
     764                 :            : 
     765                 :    4295470 :   SSA_NAME_PTR_INFO (name) = new_ptr_info;
     766                 :            : }
     767                 :            : 
     768                 :            : /* Creates a duplicate of the range_info_def at RANGE_INFO of type
     769                 :            :    RANGE_TYPE for use by the SSA name NAME.  */
     770                 :            : void
     771                 :    3773000 : duplicate_ssa_name_range_info (tree name, enum value_range_kind range_type,
     772                 :            :                                struct range_info_def *range_info)
     773                 :            : {
     774                 :    3773000 :   struct range_info_def *new_range_info;
     775                 :            : 
     776                 :    3773000 :   gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name)));
     777                 :    3773000 :   gcc_assert (!SSA_NAME_RANGE_INFO (name));
     778                 :            : 
     779                 :    3773000 :   if (!range_info)
     780                 :            :     return;
     781                 :            : 
     782                 :    3773000 :   unsigned int precision = TYPE_PRECISION (TREE_TYPE (name));
     783                 :    3773000 :   size_t size = (sizeof (range_info_def)
     784                 :    3773000 :                  + trailing_wide_ints <3>::extra_size (precision));
     785                 :    3773000 :   new_range_info = static_cast<range_info_def *> (ggc_internal_alloc (size));
     786                 :    3773000 :   memcpy (new_range_info, range_info, size);
     787                 :            : 
     788                 :    3773000 :   gcc_assert (range_type == VR_RANGE || range_type == VR_ANTI_RANGE);
     789                 :    3773000 :   SSA_NAME_ANTI_RANGE_P (name) = (range_type == VR_ANTI_RANGE);
     790                 :    3773000 :   SSA_NAME_RANGE_INFO (name) = new_range_info;
     791                 :            : }
     792                 :            : 
     793                 :            : 
     794                 :            : 
     795                 :            : /* Creates a duplicate of a ssa name NAME tobe defined by statement STMT
     796                 :            :    in function FN.  */
     797                 :            : 
     798                 :            : tree
     799                 :   12963400 : duplicate_ssa_name_fn (struct function *fn, tree name, gimple *stmt)
     800                 :            : {
     801                 :   12963400 :   tree new_name = copy_ssa_name_fn (fn, name, stmt);
     802                 :   12963400 :   if (POINTER_TYPE_P (TREE_TYPE (name)))
     803                 :            :     {
     804                 :    3754470 :       struct ptr_info_def *old_ptr_info = SSA_NAME_PTR_INFO (name);
     805                 :            : 
     806                 :    3754470 :       if (old_ptr_info)
     807                 :    3685150 :         duplicate_ssa_name_ptr_info (new_name, old_ptr_info);
     808                 :            :     }
     809                 :            :   else
     810                 :            :     {
     811                 :    9208920 :       struct range_info_def *old_range_info = SSA_NAME_RANGE_INFO (name);
     812                 :            : 
     813                 :    9208920 :       if (old_range_info)
     814                 :    4983360 :         duplicate_ssa_name_range_info (new_name, SSA_NAME_RANGE_TYPE (name),
     815                 :            :                                        old_range_info);
     816                 :            :     }
     817                 :            : 
     818                 :   12963400 :   return new_name;
     819                 :            : }
     820                 :            : 
     821                 :            : 
     822                 :            : /* Reset all flow sensitive data on NAME such as range-info, nonzero
     823                 :            :    bits and alignment.  */
     824                 :            : 
     825                 :            : void
     826                 :     163222 : reset_flow_sensitive_info (tree name)
     827                 :            : {
     828                 :     163222 :   if (POINTER_TYPE_P (TREE_TYPE (name)))
     829                 :            :     {
     830                 :            :       /* points-to info is not flow-sensitive.  */
     831                 :      24550 :       if (SSA_NAME_PTR_INFO (name))
     832                 :            :         {
     833                 :            :           /* [E]VRP can derive context sensitive alignment info and
     834                 :            :              non-nullness properties.  We must reset both.  */
     835                 :      24234 :           mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (name));
     836                 :      24234 :           SSA_NAME_PTR_INFO (name)->pt.null = 1;
     837                 :            :         }
     838                 :            :     }
     839                 :            :   else
     840                 :     138672 :     SSA_NAME_RANGE_INFO (name) = NULL;
     841                 :     163222 : }
     842                 :            : 
     843                 :            : /* Clear all flow sensitive data from all statements and PHI definitions
     844                 :            :    in BB.  */
     845                 :            : 
     846                 :            : void
     847                 :     838832 : reset_flow_sensitive_info_in_bb (basic_block bb)
     848                 :            : {
     849                 :    2207230 :   for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
     850                 :     529568 :        gsi_next (&gsi))
     851                 :            :     {
     852                 :     529568 :       gimple *stmt = gsi_stmt (gsi);
     853                 :     529568 :       ssa_op_iter i;
     854                 :     529568 :       tree op;
     855                 :     638403 :       FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_DEF)
     856                 :     108835 :         reset_flow_sensitive_info (op);
     857                 :            :     }
     858                 :            : 
     859                 :     858954 :   for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
     860                 :      20122 :        gsi_next (&gsi))
     861                 :            :     {
     862                 :      20122 :       tree phi_def = gimple_phi_result (gsi.phi ());
     863                 :      20122 :       reset_flow_sensitive_info (phi_def);
     864                 :            :     }
     865                 :     838832 : }
     866                 :            : 
     867                 :            : /* Release all the SSA_NAMEs created by STMT.  */
     868                 :            : 
     869                 :            : void
     870                 :   42811400 : release_defs (gimple *stmt)
     871                 :            : {
     872                 :   42811400 :   tree def;
     873                 :   42811400 :   ssa_op_iter iter;
     874                 :            : 
     875                 :   77530700 :   FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
     876                 :   34719300 :     if (TREE_CODE (def) == SSA_NAME)
     877                 :   69185900 :       release_ssa_name (def);
     878                 :   42811400 : }
     879                 :            : 
     880                 :            : 
     881                 :            : /* Replace the symbol associated with SSA_NAME with SYM.  */
     882                 :            : 
     883                 :            : void
     884                 :      10160 : replace_ssa_name_symbol (tree ssa_name, tree sym)
     885                 :            : {
     886                 :      10160 :   SET_SSA_NAME_VAR_OR_IDENTIFIER (ssa_name, sym);
     887                 :      10160 :   TREE_TYPE (ssa_name) = TREE_TYPE (sym);
     888                 :      10160 : }
     889                 :            : 
     890                 :            : /* Release the vector of free SSA_NAMEs and compact the vector of SSA_NAMEs
     891                 :            :    that are live.  */
     892                 :            : 
     893                 :            : static void
     894                 :    1847240 : release_free_names_and_compact_live_names (function *fun)
     895                 :            : {
     896                 :    1847240 :   unsigned i, j;
     897                 :    1847240 :   int n = vec_safe_length (FREE_SSANAMES (fun));
     898                 :            : 
     899                 :            :   /* Now release the freelist.  */
     900                 :    1847240 :   vec_free (FREE_SSANAMES (fun));
     901                 :            : 
     902                 :            :   /* And compact the SSA number space.  We make sure to not change the
     903                 :            :      relative order of SSA versions.  */
     904                 :   53347200 :   for (i = 1, j = 1; i < fun->gimple_df->ssa_names->length (); ++i)
     905                 :            :     {
     906                 :   51500000 :       tree name = ssa_name (i);
     907                 :   51500000 :       if (name)
     908                 :            :         {
     909                 :   33025100 :           if (i != j)
     910                 :            :             {
     911                 :   21105600 :               SSA_NAME_VERSION (name) = j;
     912                 :   21105600 :               (*fun->gimple_df->ssa_names)[j] = name;
     913                 :            :             }
     914                 :   33025100 :           j++;
     915                 :            :         }
     916                 :            :     }
     917                 :    1847240 :   fun->gimple_df->ssa_names->truncate (j);
     918                 :            : 
     919                 :    1847240 :   statistics_counter_event (fun, "SSA names released", n);
     920                 :    1847240 :   statistics_counter_event (fun, "SSA name holes removed", i - j);
     921                 :    1847240 :   if (dump_file)
     922                 :        264 :     fprintf (dump_file, "Released %i names, %.2f%%, removed %i holes\n",
     923                 :        264 :              n, n * 100.0 / num_ssa_names, i - j);
     924                 :    1847240 : }
     925                 :            : 
     926                 :            : /* Return SSA names that are unused to GGC memory and compact the SSA
     927                 :            :    version namespace.  This is used to keep footprint of compiler during
     928                 :            :    interprocedural optimization.  */
     929                 :            : 
     930                 :            : namespace {
     931                 :            : 
     932                 :            : const pass_data pass_data_release_ssa_names =
     933                 :            : {
     934                 :            :   GIMPLE_PASS, /* type */
     935                 :            :   "release_ssa", /* name */
     936                 :            :   OPTGROUP_NONE, /* optinfo_flags */
     937                 :            :   TV_TREE_SSA_OTHER, /* tv_id */
     938                 :            :   PROP_ssa, /* properties_required */
     939                 :            :   0, /* properties_provided */
     940                 :            :   0, /* properties_destroyed */
     941                 :            :   TODO_remove_unused_locals, /* todo_flags_start */
     942                 :            :   0, /* todo_flags_finish */
     943                 :            : };
     944                 :            : 
     945                 :            : class pass_release_ssa_names : public gimple_opt_pass
     946                 :            : {
     947                 :            : public:
     948                 :     200773 :   pass_release_ssa_names (gcc::context *ctxt)
     949                 :     401546 :     : gimple_opt_pass (pass_data_release_ssa_names, ctxt)
     950                 :            :   {}
     951                 :            : 
     952                 :            :   /* opt_pass methods: */
     953                 :            :   virtual unsigned int execute (function *);
     954                 :            : 
     955                 :            : }; // class pass_release_ssa_names
     956                 :            : 
     957                 :            : unsigned int
     958                 :    1847240 : pass_release_ssa_names::execute (function *fun)
     959                 :            : {
     960                 :    1847240 :   release_free_names_and_compact_live_names (fun);
     961                 :    1847240 :   return 0;
     962                 :            : }
     963                 :            : 
     964                 :            : } // anon namespace
     965                 :            : 
     966                 :            : gimple_opt_pass *
     967                 :     200773 : make_pass_release_ssa_names (gcc::context *ctxt)
     968                 :            : {
     969                 :     200773 :   return new pass_release_ssa_names (ctxt);
     970                 :            : }

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.