LCOV - code coverage report
Current view: top level - gcc - tree-ssa-live.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 634 715 88.7 %
Date: 2020-04-04 11:58:09 Functions: 32 39 82.1 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Liveness for SSA trees.
       2                 :            :    Copyright (C) 2003-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Andrew MacLeod <amacleod@redhat.com>
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify
       8                 :            : it under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful,
      13                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            : GNU General Public License for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "backend.h"
      25                 :            : #include "rtl.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "gimple.h"
      28                 :            : #include "timevar.h"
      29                 :            : #include "ssa.h"
      30                 :            : #include "cgraph.h"
      31                 :            : #include "gimple-pretty-print.h"
      32                 :            : #include "diagnostic-core.h"
      33                 :            : #include "gimple-iterator.h"
      34                 :            : #include "tree-dfa.h"
      35                 :            : #include "dumpfile.h"
      36                 :            : #include "tree-ssa-live.h"
      37                 :            : #include "debug.h"
      38                 :            : #include "tree-ssa.h"
      39                 :            : #include "ipa-utils.h"
      40                 :            : #include "cfgloop.h"
      41                 :            : #include "stringpool.h"
      42                 :            : #include "attribs.h"
      43                 :            : #include "optinfo.h"
      44                 :            : #include "gimple-walk.h"
      45                 :            : #include "cfganal.h"
      46                 :            : 
      47                 :            : static void verify_live_on_entry (tree_live_info_p);
      48                 :            : 
      49                 :            : 
      50                 :            : /* VARMAP maintains a mapping from SSA version number to real variables.
      51                 :            : 
      52                 :            :    All SSA_NAMES are divided into partitions.  Initially each ssa_name is the
      53                 :            :    only member of it's own partition.  Coalescing will attempt to group any
      54                 :            :    ssa_names which occur in a copy or in a PHI node into the same partition.
      55                 :            : 
      56                 :            :    At the end of out-of-ssa, each partition becomes a "real" variable and is
      57                 :            :    rewritten as a compiler variable.
      58                 :            : 
      59                 :            :    The var_map data structure is used to manage these partitions.  It allows
      60                 :            :    partitions to be combined, and determines which partition belongs to what
      61                 :            :    ssa_name or variable, and vice versa.  */
      62                 :            : 
      63                 :            : 
      64                 :            : /* Remove the base table in MAP.  */
      65                 :            : 
      66                 :            : static void
      67                 :    2833540 : var_map_base_fini (var_map map)
      68                 :            : {
      69                 :            :   /* Free the basevar info if it is present.  */
      70                 :          0 :   if (map->partition_to_base_index != NULL)
      71                 :            :     {
      72                 :     944512 :       free (map->partition_to_base_index);
      73                 :     944512 :       map->partition_to_base_index = NULL;
      74                 :     944512 :       map->num_basevars = 0;
      75                 :            :     }
      76                 :          0 : }
      77                 :            : /* Create a variable partition map of SIZE for region, initialize and return
      78                 :            :    it.  Region is a loop if LOOP is non-NULL, otherwise is the current
      79                 :            :    function.  */
      80                 :            : 
      81                 :            : var_map
      82                 :     944512 : init_var_map (int size, class loop *loop)
      83                 :            : {
      84                 :     944512 :   var_map map;
      85                 :            : 
      86                 :     944512 :   map = (var_map) xmalloc (sizeof (struct _var_map));
      87                 :     944512 :   map->var_partition = partition_new (size);
      88                 :            : 
      89                 :     944512 :   map->partition_to_view = NULL;
      90                 :     944512 :   map->view_to_partition = NULL;
      91                 :     944512 :   map->num_partitions = size;
      92                 :     944512 :   map->partition_size = size;
      93                 :     944512 :   map->num_basevars = 0;
      94                 :     944512 :   map->partition_to_base_index = NULL;
      95                 :     944512 :   map->vec_bbs = vNULL;
      96                 :     944512 :   if (loop)
      97                 :            :     {
      98                 :          0 :       map->bmp_bbs = BITMAP_ALLOC (NULL);
      99                 :          0 :       map->outofssa_p = false;
     100                 :          0 :       basic_block *bbs = get_loop_body_in_dom_order (loop);
     101                 :          0 :       for (unsigned i = 0; i < loop->num_nodes; ++i)
     102                 :            :         {
     103                 :          0 :           bitmap_set_bit (map->bmp_bbs, bbs[i]->index);
     104                 :          0 :           map->vec_bbs.safe_push (bbs[i]);
     105                 :            :         }
     106                 :          0 :       free (bbs);
     107                 :            :     }
     108                 :            :   else
     109                 :            :     {
     110                 :     944512 :       map->bmp_bbs = NULL;
     111                 :     944512 :       map->outofssa_p = true;
     112                 :     944512 :       basic_block bb;
     113                 :    8912700 :       FOR_EACH_BB_FN (bb, cfun)
     114                 :    7968190 :         map->vec_bbs.safe_push (bb);
     115                 :            :     }
     116                 :     944512 :   return map;
     117                 :            : }
     118                 :            : 
     119                 :            : 
     120                 :            : /* Free memory associated with MAP.  */
     121                 :            : 
     122                 :            : void
     123                 :     944512 : delete_var_map (var_map map)
     124                 :            : {
     125                 :     944512 :   var_map_base_fini (map);
     126                 :     944512 :   partition_delete (map->var_partition);
     127                 :     944512 :   free (map->partition_to_view);
     128                 :     944512 :   free (map->view_to_partition);
     129                 :     944512 :   if (map->bmp_bbs)
     130                 :          0 :     BITMAP_FREE (map->bmp_bbs);
     131                 :     944512 :   map->vec_bbs.release ();
     132                 :     944512 :   free (map);
     133                 :     944512 : }
     134                 :            : 
     135                 :            : 
     136                 :            : /* This function will combine the partitions in MAP for VAR1 and VAR2.  It
     137                 :            :    Returns the partition which represents the new partition.  If the two
     138                 :            :    partitions cannot be combined, NO_PARTITION is returned.  */
     139                 :            : 
     140                 :            : int
     141                 :    2938150 : var_union (var_map map, tree var1, tree var2)
     142                 :            : {
     143                 :    2938150 :   int p1, p2, p3;
     144                 :            : 
     145                 :    2938150 :   gcc_assert (TREE_CODE (var1) == SSA_NAME);
     146                 :    2938150 :   gcc_assert (TREE_CODE (var2) == SSA_NAME);
     147                 :            : 
     148                 :            :   /* This is independent of partition_to_view. If partition_to_view is
     149                 :            :      on, then whichever one of these partitions is absorbed will never have a
     150                 :            :      dereference into the partition_to_view array any more.  */
     151                 :            : 
     152                 :    2938150 :   p1 = partition_find (map->var_partition, SSA_NAME_VERSION (var1));
     153                 :    2938150 :   p2 = partition_find (map->var_partition, SSA_NAME_VERSION (var2));
     154                 :            : 
     155                 :    2938150 :   gcc_assert (p1 != NO_PARTITION);
     156                 :    2938150 :   gcc_assert (p2 != NO_PARTITION);
     157                 :            : 
     158                 :    2938150 :   if (p1 == p2)
     159                 :            :     p3 = p1;
     160                 :            :   else
     161                 :    2938150 :     p3 = partition_union (map->var_partition, p1, p2);
     162                 :            : 
     163                 :    2938150 :   if (map->partition_to_view)
     164                 :    2938150 :     p3 = map->partition_to_view[p3];
     165                 :            : 
     166                 :    2938150 :   return p3;
     167                 :            : }
     168                 :            : 
     169                 :            : 
     170                 :            : /* Compress the partition numbers in MAP such that they fall in the range
     171                 :            :    0..(num_partitions-1) instead of wherever they turned out during
     172                 :            :    the partitioning exercise.  This removes any references to unused
     173                 :            :    partitions, thereby allowing bitmaps and other vectors to be much
     174                 :            :    denser.
     175                 :            : 
     176                 :            :    This is implemented such that compaction doesn't affect partitioning.
     177                 :            :    Ie., once partitions are created and possibly merged, running one
     178                 :            :    or more different kind of compaction will not affect the partitions
     179                 :            :    themselves.  Their index might change, but all the same variables will
     180                 :            :    still be members of the same partition group.  This allows work on reduced
     181                 :            :    sets, and no loss of information when a larger set is later desired.
     182                 :            : 
     183                 :            :    In particular, coalescing can work on partitions which have 2 or more
     184                 :            :    definitions, and then 'recompact' later to include all the single
     185                 :            :    definitions for assignment to program variables.  */
     186                 :            : 
     187                 :            : 
     188                 :            : /* Set MAP back to the initial state of having no partition view.  Return a
     189                 :            :    bitmap which has a bit set for each partition number which is in use in the
     190                 :            :    varmap.  */
     191                 :            : 
     192                 :            : static bitmap
     193                 :    1889020 : partition_view_init (var_map map)
     194                 :            : {
     195                 :    1889020 :   bitmap used;
     196                 :    1889020 :   int tmp;
     197                 :    1889020 :   unsigned int x;
     198                 :            : 
     199                 :    1889020 :   used = BITMAP_ALLOC (NULL);
     200                 :            : 
     201                 :            :   /* Already in a view? Abandon the old one.  */
     202                 :    1889020 :   if (map->partition_to_view)
     203                 :            :     {
     204                 :     944512 :       free (map->partition_to_view);
     205                 :     944512 :       map->partition_to_view = NULL;
     206                 :            :     }
     207                 :    1889020 :   if (map->view_to_partition)
     208                 :            :     {
     209                 :     944512 :       free (map->view_to_partition);
     210                 :     944512 :       map->view_to_partition = NULL;
     211                 :            :     }
     212                 :            : 
     213                 :            :   /* Find out which partitions are actually referenced.  */
     214                 :   91043300 :   for (x = 0; x < map->partition_size; x++)
     215                 :            :     {
     216                 :   89154300 :       tmp = partition_find (map->var_partition, x);
     217                 :  212262000 :       if (ssa_name (tmp) != NULL_TREE && !virtual_operand_p (ssa_name (tmp))
     218                 :  126682000 :           && (!has_zero_uses (ssa_name (tmp))
     219                 :    2918860 :               || !SSA_NAME_IS_DEFAULT_DEF (ssa_name (tmp))
     220                 :    2541130 :               || (SSA_NAME_VAR (ssa_name (tmp))
     221                 :    2541130 :                   && !VAR_P (SSA_NAME_VAR (ssa_name (tmp))))))
     222                 :   37196700 :         bitmap_set_bit (used, tmp);
     223                 :            :     }
     224                 :            : 
     225                 :    1889020 :   map->num_partitions = map->partition_size;
     226                 :    1889020 :   return used;
     227                 :            : }
     228                 :            : 
     229                 :            : 
     230                 :            : /* This routine will finalize the view data for MAP based on the partitions
     231                 :            :    set in SELECTED.  This is either the same bitmap returned from
     232                 :            :    partition_view_init, or a trimmed down version if some of those partitions
     233                 :            :    were not desired in this view.  SELECTED is freed before returning.  */
     234                 :            : 
     235                 :            : static void
     236                 :    1889020 : partition_view_fini (var_map map, bitmap selected)
     237                 :            : {
     238                 :    1889020 :   bitmap_iterator bi;
     239                 :    1889020 :   unsigned count, i, x, limit;
     240                 :            : 
     241                 :    1889020 :   gcc_assert (selected);
     242                 :            : 
     243                 :    1889020 :   count = bitmap_count_bits (selected);
     244                 :    1889020 :   limit = map->partition_size;
     245                 :            : 
     246                 :            :   /* If its a one-to-one ratio, we don't need any view compaction.  */
     247                 :    1889020 :   if (count < limit)
     248                 :            :     {
     249                 :    1889020 :       map->partition_to_view = (int *)xmalloc (limit * sizeof (int));
     250                 :    1889020 :       memset (map->partition_to_view, 0xff, (limit * sizeof (int)));
     251                 :    1889020 :       map->view_to_partition = (int *)xmalloc (count * sizeof (int));
     252                 :            : 
     253                 :    1889020 :       i = 0;
     254                 :            :       /* Give each selected partition an index.  */
     255                 :   24054400 :       EXECUTE_IF_SET_IN_BITMAP (selected, 0, x, bi)
     256                 :            :         {
     257                 :   22165400 :           map->partition_to_view[x] = i;
     258                 :   22165400 :           map->view_to_partition[i] = x;
     259                 :   22165400 :           i++;
     260                 :            :         }
     261                 :    1889020 :       gcc_assert (i == count);
     262                 :    1889020 :       map->num_partitions = i;
     263                 :            :     }
     264                 :            : 
     265                 :    1889020 :   BITMAP_FREE (selected);
     266                 :    1889020 : }
     267                 :            : 
     268                 :            : 
     269                 :            : /* Create a partition view which includes all the used partitions in MAP.  */
     270                 :            : 
     271                 :            : void
     272                 :     944512 : partition_view_normal (var_map map)
     273                 :            : {
     274                 :     944512 :   bitmap used;
     275                 :            : 
     276                 :     944512 :   used = partition_view_init (map);
     277                 :     944512 :   partition_view_fini (map, used);
     278                 :            : 
     279                 :     944512 :   var_map_base_fini (map);
     280                 :     944512 : }
     281                 :            : 
     282                 :            : 
     283                 :            : /* Create a partition view in MAP which includes just partitions which occur in
     284                 :            :    the bitmap ONLY. If WANT_BASES is true, create the base variable map
     285                 :            :    as well.  */
     286                 :            : 
     287                 :            : void
     288                 :     944512 : partition_view_bitmap (var_map map, bitmap only)
     289                 :            : {
     290                 :     944512 :   bitmap used;
     291                 :     944512 :   bitmap new_partitions = BITMAP_ALLOC (NULL);
     292                 :     944512 :   unsigned x, p;
     293                 :     944512 :   bitmap_iterator bi;
     294                 :            : 
     295                 :     944512 :   used = partition_view_init (map);
     296                 :    7449690 :   EXECUTE_IF_SET_IN_BITMAP (only, 0, x, bi)
     297                 :            :     {
     298                 :    6505180 :       p = partition_find (map->var_partition, x);
     299                 :    6505180 :       gcc_assert (bitmap_bit_p (used, p));
     300                 :    6505180 :       bitmap_set_bit (new_partitions, p);
     301                 :            :     }
     302                 :     944512 :   partition_view_fini (map, new_partitions);
     303                 :            : 
     304                 :     944512 :   var_map_base_fini (map);
     305                 :     944512 : }
     306                 :            : 
     307                 :            : 
     308                 :            : static bitmap usedvars;
     309                 :            : 
     310                 :            : /* Mark VAR as used, so that it'll be preserved during rtl expansion.
     311                 :            :    Returns true if VAR wasn't marked before.  */
     312                 :            : 
     313                 :            : static inline bool
     314                 :   67308600 : set_is_used (tree var)
     315                 :            : {
     316                 :   67308600 :   return bitmap_set_bit (usedvars, DECL_UID (var));
     317                 :            : }
     318                 :            : 
     319                 :            : /* Return true if VAR is marked as used.  */
     320                 :            : 
     321                 :            : static inline bool
     322                 :   69053300 : is_used_p (tree var)
     323                 :            : {
     324                 :   69053300 :   return bitmap_bit_p (usedvars, DECL_UID (var));
     325                 :            : }
     326                 :            : 
     327                 :            : static inline void mark_all_vars_used (tree *);
     328                 :            : 
     329                 :            : /* Helper function for mark_all_vars_used, called via walk_tree.  */
     330                 :            : 
     331                 :            : static tree
     332                 :  402401000 : mark_all_vars_used_1 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
     333                 :            : {
     334                 :  402401000 :   tree t = *tp;
     335                 :  402401000 :   enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
     336                 :  402401000 :   tree b;
     337                 :            : 
     338                 :  402401000 :   if (TREE_CODE (t) == SSA_NAME)
     339                 :            :     {
     340                 :  153664000 :       *walk_subtrees = 0;
     341                 :  153664000 :       t = SSA_NAME_VAR (t);
     342                 :            :       if (!t)
     343                 :            :         return NULL;
     344                 :            :     }
     345                 :            : 
     346                 :  295444000 :   if (IS_EXPR_CODE_CLASS (c)
     347                 :  295444000 :       && (b = TREE_BLOCK (t)) != NULL)
     348                 :   26003800 :     TREE_USED (b) = true;
     349                 :            : 
     350                 :            :   /* Ignore TMR_OFFSET and TMR_STEP for TARGET_MEM_REFS, as those
     351                 :            :      fields do not contain vars.  */
     352                 :  295444000 :   if (TREE_CODE (t) == TARGET_MEM_REF)
     353                 :            :     {
     354                 :     499687 :       mark_all_vars_used (&TMR_BASE (t));
     355                 :     499687 :       mark_all_vars_used (&TMR_INDEX (t));
     356                 :     499687 :       mark_all_vars_used (&TMR_INDEX2 (t));
     357                 :     499687 :       *walk_subtrees = 0;
     358                 :     499687 :       return NULL;
     359                 :            :     }
     360                 :            : 
     361                 :            :   /* Only need to mark VAR_DECLS; parameters and return results are not
     362                 :            :      eliminated as unused.  */
     363                 :  294944000 :   if (VAR_P (t))
     364                 :            :     {
     365                 :            :       /* When a global var becomes used for the first time also walk its
     366                 :            :          initializer (non global ones don't have any).  */
     367                 :   83906500 :       if (set_is_used (t) && is_global_var (t)
     368                 :   70173900 :           && DECL_CONTEXT (t) == current_function_decl)
     369                 :     424383 :         mark_all_vars_used (&DECL_INITIAL (t));
     370                 :            :     }
     371                 :            :   /* remove_unused_scope_block_p requires information about labels
     372                 :            :      which are not DECL_IGNORED_P to tell if they might be used in the IL.  */
     373                 :  227636000 :   else if (TREE_CODE (t) == LABEL_DECL)
     374                 :            :     /* Although the TREE_USED values that the frontend uses would be
     375                 :            :        acceptable (albeit slightly over-conservative) for our purposes,
     376                 :            :        init_vars_expansion clears TREE_USED for LABEL_DECLs too, so we
     377                 :            :        must re-compute it here.  */
     378                 :    1856950 :     TREE_USED (t) = 1;
     379                 :            : 
     380                 :  294944000 :   if (IS_TYPE_OR_DECL_P (t))
     381                 :  136073000 :     *walk_subtrees = 0;
     382                 :            : 
     383                 :            :   return NULL;
     384                 :            : }
     385                 :            : 
     386                 :            : /* Mark the scope block SCOPE and its subblocks unused when they can be
     387                 :            :    possibly eliminated if dead.  */
     388                 :            : 
     389                 :            : static void
     390                 :   40032700 : mark_scope_block_unused (tree scope)
     391                 :            : {
     392                 :   40032700 :   tree t;
     393                 :   40032700 :   TREE_USED (scope) = false;
     394                 :   40032700 :   if (!(*debug_hooks->ignore_block) (scope))
     395                 :      52344 :     TREE_USED (scope) = true;
     396                 :   75405600 :   for (t = BLOCK_SUBBLOCKS (scope); t ; t = BLOCK_CHAIN (t))
     397                 :   35372900 :     mark_scope_block_unused (t);
     398                 :   40032700 : }
     399                 :            : 
     400                 :            : /* Look if the block is dead (by possibly eliminating its dead subblocks)
     401                 :            :    and return true if so.
     402                 :            :    Block is declared dead if:
     403                 :            :      1) No statements are associated with it.
     404                 :            :      2) Declares no live variables
     405                 :            :      3) All subblocks are dead
     406                 :            :         or there is precisely one subblocks and the block
     407                 :            :         has same abstract origin as outer block and declares
     408                 :            :         no variables, so it is pure wrapper.
     409                 :            :    When we are not outputting full debug info, we also eliminate dead variables
     410                 :            :    out of scope blocks to let them to be recycled by GGC and to save copying work
     411                 :            :    done by the inliner.  */
     412                 :            : 
     413                 :            : static bool
     414                 :   40032700 : remove_unused_scope_block_p (tree scope, bool in_ctor_dtor_block)
     415                 :            : {
     416                 :   40032700 :   tree *t, *next;
     417                 :   40032700 :   bool unused = !TREE_USED (scope);
     418                 :   40032700 :   int nsubblocks = 0;
     419                 :            : 
     420                 :            :   /* For ipa-polymorphic-call.c purposes, preserve blocks:
     421                 :            :      1) with BLOCK_ABSTRACT_ORIGIN of a ctor/dtor or their clones  */
     422                 :   40032700 :   if (inlined_polymorphic_ctor_dtor_block_p (scope, true))
     423                 :            :     {
     424                 :            :       in_ctor_dtor_block = true;
     425                 :            :       unused = false;
     426                 :            :     }
     427                 :            :   /* 2) inside such blocks, the outermost block with block_ultimate_origin
     428                 :            :      being a FUNCTION_DECL.  */
     429                 :   34108200 :   else if (in_ctor_dtor_block)
     430                 :            :     {
     431                 :    6127630 :       tree fn = block_ultimate_origin (scope);
     432                 :    6127630 :       if (fn && TREE_CODE (fn) == FUNCTION_DECL)
     433                 :            :         {
     434                 :    1714420 :           in_ctor_dtor_block = false;
     435                 :    1714420 :           unused = false;
     436                 :            :         }
     437                 :            :     }
     438                 :            : 
     439                 :   75864600 :   for (t = &BLOCK_VARS (scope); *t; t = next)
     440                 :            :     {
     441                 :   35831900 :       next = &DECL_CHAIN (*t);
     442                 :            : 
     443                 :            :       /* Debug info of nested function refers to the block of the
     444                 :            :          function.  We might stil call it even if all statements
     445                 :            :          of function it was nested into was elliminated.
     446                 :            : 
     447                 :            :          TODO: We can actually look into cgraph to see if function
     448                 :            :          will be output to file.  */
     449                 :   35831900 :       if (TREE_CODE (*t) == FUNCTION_DECL)
     450                 :            :         unused = false;
     451                 :            : 
     452                 :            :       /* If a decl has a value expr, we need to instantiate it
     453                 :            :          regardless of debug info generation, to avoid codegen
     454                 :            :          differences in memory overlap tests.  update_equiv_regs() may
     455                 :            :          indirectly call validate_equiv_mem() to test whether a
     456                 :            :          SET_DEST overlaps with others, and if the value expr changes
     457                 :            :          by virtual register instantiation, we may get end up with
     458                 :            :          different results.  */
     459                 :   35673600 :       else if (VAR_P (*t) && DECL_HAS_VALUE_EXPR_P (*t))
     460                 :            :         unused = false;
     461                 :            : 
     462                 :            :       /* Remove everything we don't generate debug info for.  */
     463                 :   35425300 :       else if (DECL_IGNORED_P (*t))
     464                 :            :         {
     465                 :    2303850 :           *t = DECL_CHAIN (*t);
     466                 :    2303850 :           next = t;
     467                 :            :         }
     468                 :            : 
     469                 :            :       /* When we are outputting debug info, we usually want to output
     470                 :            :          info about optimized-out variables in the scope blocks.
     471                 :            :          Exception are the scope blocks not containing any instructions
     472                 :            :          at all so user can't get into the scopes at first place.  */
     473                 :   33121400 :       else if (is_used_p (*t))
     474                 :            :         unused = false;
     475                 :   28072400 :       else if (TREE_CODE (*t) == LABEL_DECL && TREE_USED (*t))
     476                 :            :         /* For labels that are still used in the IL, the decision to
     477                 :            :            preserve them must not depend DEBUG_INFO_LEVEL, otherwise we
     478                 :            :            risk having different ordering in debug vs.  non-debug builds
     479                 :            :            during inlining or versioning.
     480                 :            :            A label appearing here (we have already checked DECL_IGNORED_P)
     481                 :            :            should not be used in the IL unless it has been explicitly used
     482                 :            :            before, so we use TREE_USED as an approximation.  */
     483                 :            :         /* In principle, we should do the same here as for the debug case
     484                 :            :            below, however, when debugging, there might be additional nested
     485                 :            :            levels that keep an upper level with a label live, so we have to
     486                 :            :            force this block to be considered used, too.  */
     487                 :            :         unused = false;
     488                 :            : 
     489                 :            :       /* When we are not doing full debug info, we however can keep around
     490                 :            :          only the used variables for cfgexpand's memory packing saving quite
     491                 :            :          a lot of memory.
     492                 :            : 
     493                 :            :          For sake of -g3, we keep around those vars but we don't count this as
     494                 :            :          use of block, so innermost block with no used vars and no instructions
     495                 :            :          can be considered dead.  We only want to keep around blocks user can
     496                 :            :          breakpoint into and ask about value of optimized out variables.
     497                 :            : 
     498                 :            :          Similarly we need to keep around types at least until all
     499                 :            :          variables of all nested blocks are gone.  We track no
     500                 :            :          information on whether given type is used or not, so we have
     501                 :            :          to keep them even when not emitting debug information,
     502                 :            :          otherwise we may end up remapping variables and their (local)
     503                 :            :          types in different orders depending on whether debug
     504                 :            :          information is being generated.  */
     505                 :            : 
     506                 :   28018800 :       else if (TREE_CODE (*t) == TYPE_DECL
     507                 :   27194900 :                || debug_info_level == DINFO_LEVEL_NORMAL
     508                 :    1269120 :                || debug_info_level == DINFO_LEVEL_VERBOSE)
     509                 :            :         ;
     510                 :            :       else
     511                 :            :         {
     512                 :    1261810 :           *t = DECL_CHAIN (*t);
     513                 :    1261810 :           next = t;
     514                 :            :         }
     515                 :            :     }
     516                 :            : 
     517                 :   75405600 :   for (t = &BLOCK_SUBBLOCKS (scope); *t ;)
     518                 :   35372900 :     if (remove_unused_scope_block_p (*t, in_ctor_dtor_block))
     519                 :            :       {
     520                 :    4206000 :         if (BLOCK_SUBBLOCKS (*t))
     521                 :            :           {
     522                 :    1562800 :             tree next = BLOCK_CHAIN (*t);
     523                 :    1562800 :             tree supercontext = BLOCK_SUPERCONTEXT (*t);
     524                 :            : 
     525                 :    1562800 :             *t = BLOCK_SUBBLOCKS (*t);
     526                 :    1927700 :             while (BLOCK_CHAIN (*t))
     527                 :            :               {
     528                 :     364899 :                 BLOCK_SUPERCONTEXT (*t) = supercontext;
     529                 :     364899 :                 t = &BLOCK_CHAIN (*t);
     530                 :            :               }
     531                 :    1562800 :             BLOCK_CHAIN (*t) = next;
     532                 :    1562800 :             BLOCK_SUPERCONTEXT (*t) = supercontext;
     533                 :    1562800 :             t = &BLOCK_CHAIN (*t);
     534                 :    1562800 :             nsubblocks ++;
     535                 :            :           }
     536                 :            :         else
     537                 :    2643200 :           *t = BLOCK_CHAIN (*t);
     538                 :            :       }
     539                 :            :     else
     540                 :            :       {
     541                 :   31166900 :         t = &BLOCK_CHAIN (*t);
     542                 :   31166900 :         nsubblocks ++;
     543                 :            :       }
     544                 :            : 
     545                 :            : 
     546                 :   40032700 :    if (!unused)
     547                 :            :      ;
     548                 :            :    /* Outer scope is always used.  */
     549                 :    8258330 :    else if (!BLOCK_SUPERCONTEXT (scope)
     550                 :    8258330 :             || TREE_CODE (BLOCK_SUPERCONTEXT (scope)) == FUNCTION_DECL)
     551                 :            :      unused = false;
     552                 :            :    /* Innermost blocks with no live variables nor statements can be always
     553                 :            :       eliminated.  */
     554                 :    7982160 :    else if (!nsubblocks)
     555                 :            :      ;
     556                 :            :    /* When not generating debug info we can eliminate info on unused
     557                 :            :       variables.  */
     558                 :    5338960 :    else if (!flag_auto_profile && debug_info_level == DINFO_LEVEL_NONE
     559                 :    5533430 :             && !optinfo_wants_inlining_info_p ())
     560                 :            :      {
     561                 :            :        /* Even for -g0 don't prune outer scopes from artificial
     562                 :            :           functions, otherwise diagnostics using tree_nonartificial_location
     563                 :            :           will not be emitted properly.  */
     564                 :     194471 :        if (inlined_function_outer_scope_p (scope))
     565                 :            :          {
     566                 :      84154 :            tree ao = BLOCK_ORIGIN (scope);
     567                 :      84154 :            if (ao
     568                 :      84154 :                && TREE_CODE (ao) == FUNCTION_DECL
     569                 :      84154 :                && DECL_DECLARED_INLINE_P (ao)
     570                 :     129641 :                && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
     571                 :            :              unused = false;
     572                 :            :          }
     573                 :            :      }
     574                 :    5144490 :    else if (BLOCK_VARS (scope) || BLOCK_NUM_NONLOCALIZED_VARS (scope))
     575                 :            :      unused = false;
     576                 :            :    /* See if this block is important for representation of inlined
     577                 :            :       function.  Inlined functions are always represented by block
     578                 :            :       with block_ultimate_origin being set to FUNCTION_DECL and
     579                 :            :       DECL_SOURCE_LOCATION set, unless they expand to nothing...  */
     580                 :    1418090 :    else if (inlined_function_outer_scope_p (scope))
     581                 :            :      unused = false;
     582                 :            :    else
     583                 :            :    /* Verfify that only blocks with source location set
     584                 :            :       are entry points to the inlined functions.  */
     585                 :    1384780 :      gcc_assert (LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (scope))
     586                 :            :                  == UNKNOWN_LOCATION);
     587                 :            : 
     588                 :   40032700 :    TREE_USED (scope) = !unused;
     589                 :   40032700 :    return unused;
     590                 :            : }
     591                 :            : 
     592                 :            : /* Mark all VAR_DECLS under *EXPR_P as used, so that they won't be
     593                 :            :    eliminated during the tree->rtl conversion process.  */
     594                 :            : 
     595                 :            : static inline void
     596                 :  300306000 : mark_all_vars_used (tree *expr_p)
     597                 :            : {
     598                 :    1923440 :   walk_tree (expr_p, mark_all_vars_used_1, NULL, NULL);
     599                 :     424383 : }
     600                 :            : 
     601                 :            : /* Helper function for clear_unused_block_pointer, called via walk_tree.  */
     602                 :            : 
     603                 :            : static tree
     604                 :  162090000 : clear_unused_block_pointer_1 (tree *tp, int *, void *)
     605                 :            : {
     606                 :   23323600 :   if (EXPR_P (*tp) && TREE_BLOCK (*tp)
     607                 :  178452000 :       && !TREE_USED (TREE_BLOCK (*tp)))
     608                 :     691922 :     TREE_SET_BLOCK (*tp, NULL);
     609                 :  162090000 :   return NULL_TREE;
     610                 :            : }
     611                 :            : 
     612                 :            : /* Set all block pointer in debug or clobber stmt to NULL if the block
     613                 :            :    is unused, so that they will not be streamed out.  */
     614                 :            : 
     615                 :            : static void
     616                 :    4659800 : clear_unused_block_pointer (void)
     617                 :            : {
     618                 :    4659800 :   basic_block bb;
     619                 :    4659800 :   gimple_stmt_iterator gsi;
     620                 :            : 
     621                 :   34398000 :   FOR_EACH_BB_FN (bb, cfun)
     622                 :  270629000 :     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     623                 :            :       {
     624                 :  211153000 :         unsigned i;
     625                 :  211153000 :         tree b;
     626                 :  211153000 :         gimple *stmt = gsi_stmt (gsi);
     627                 :            : 
     628                 :  211153000 :         if (!is_gimple_debug (stmt) && !gimple_clobber_p (stmt))
     629                 :  102644000 :           continue;
     630                 :  108508000 :         b = gimple_block (stmt);
     631                 :   82450700 :         if (b && !TREE_USED (b))
     632                 :    4363020 :           gimple_set_block (stmt, NULL);
     633                 :  269310000 :         for (i = 0; i < gimple_num_ops (stmt); i++)
     634                 :  160801000 :           walk_tree (gimple_op_ptr (stmt, i), clear_unused_block_pointer_1,
     635                 :            :                      NULL, NULL);
     636                 :            :       }
     637                 :    4659800 : }
     638                 :            : 
     639                 :            : /* Dump scope blocks starting at SCOPE to FILE.  INDENT is the
     640                 :            :    indentation level and FLAGS is as in print_generic_expr.  */
     641                 :            : 
     642                 :            : static void
     643                 :        454 : dump_scope_block (FILE *file, int indent, tree scope, dump_flags_t flags)
     644                 :            : {
     645                 :        454 :   tree var, t;
     646                 :        454 :   unsigned int i;
     647                 :            : 
     648                 :        454 :   fprintf (file, "\n%*s{ Scope block #%i%s",indent, "" , BLOCK_NUMBER (scope),
     649                 :        454 :            TREE_USED (scope) ? "" : " (unused)");
     650                 :        454 :   if (LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (scope)) != UNKNOWN_LOCATION)
     651                 :            :     {
     652                 :        166 :       expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (scope));
     653                 :        166 :       fprintf (file, " %s:%i", s.file, s.line);
     654                 :            :     }
     655                 :        454 :   if (BLOCK_ABSTRACT_ORIGIN (scope))
     656                 :            :     {
     657                 :        363 :       tree origin = block_ultimate_origin (scope);
     658                 :        363 :       if (origin)
     659                 :            :         {
     660                 :        363 :           fprintf (file, " Originating from :");
     661                 :        363 :           if (DECL_P (origin))
     662                 :        166 :             print_generic_decl (file, origin, flags);
     663                 :            :           else
     664                 :        197 :             fprintf (file, "#%i", BLOCK_NUMBER (origin));
     665                 :            :         }
     666                 :            :     }
     667                 :        454 :   if (BLOCK_FRAGMENT_ORIGIN (scope))
     668                 :          0 :     fprintf (file, " Fragment of : #%i",
     669                 :          0 :              BLOCK_NUMBER (BLOCK_FRAGMENT_ORIGIN (scope)));
     670                 :        454 :   else if (BLOCK_FRAGMENT_CHAIN (scope))
     671                 :            :     {
     672                 :          0 :       fprintf (file, " Fragment chain :");
     673                 :          0 :       for (t = BLOCK_FRAGMENT_CHAIN (scope); t ;
     674                 :          0 :            t = BLOCK_FRAGMENT_CHAIN (t))
     675                 :          0 :         fprintf (file, " #%i", BLOCK_NUMBER (t));
     676                 :            :     }
     677                 :        454 :   fprintf (file, " \n");
     678                 :        546 :   for (var = BLOCK_VARS (scope); var; var = DECL_CHAIN (var))
     679                 :            :     {
     680                 :         92 :       fprintf (file, "%*s", indent, "");
     681                 :         92 :       print_generic_decl (file, var, flags);
     682                 :         92 :       fprintf (file, "\n");
     683                 :            :     }
     684                 :        454 :   for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (scope); i++)
     685                 :            :     {
     686                 :          0 :       fprintf (file, "%*s",indent, "");
     687                 :          0 :       print_generic_decl (file, BLOCK_NONLOCALIZED_VAR (scope, i),
     688                 :            :                           flags);
     689                 :          0 :       fprintf (file, " (nonlocalized)\n");
     690                 :            :     }
     691                 :        823 :   for (t = BLOCK_SUBBLOCKS (scope); t ; t = BLOCK_CHAIN (t))
     692                 :        369 :     dump_scope_block (file, indent + 2, t, flags);
     693                 :        454 :   fprintf (file, "\n%*s}\n",indent, "");
     694                 :        454 : }
     695                 :            : 
     696                 :            : /* Dump the tree of lexical scopes starting at SCOPE to stderr.  FLAGS
     697                 :            :    is as in print_generic_expr.  */
     698                 :            : 
     699                 :            : DEBUG_FUNCTION void
     700                 :          0 : debug_scope_block (tree scope, dump_flags_t flags)
     701                 :            : {
     702                 :          0 :   dump_scope_block (stderr, 0, scope, flags);
     703                 :          0 : }
     704                 :            : 
     705                 :            : 
     706                 :            : /* Dump the tree of lexical scopes of current_function_decl to FILE.
     707                 :            :    FLAGS is as in print_generic_expr.  */
     708                 :            : 
     709                 :            : void
     710                 :         85 : dump_scope_blocks (FILE *file, dump_flags_t flags)
     711                 :            : {
     712                 :         85 :   dump_scope_block (file, 0, DECL_INITIAL (current_function_decl), flags);
     713                 :         85 : }
     714                 :            : 
     715                 :            : 
     716                 :            : /* Dump the tree of lexical scopes of current_function_decl to stderr.
     717                 :            :    FLAGS is as in print_generic_expr.  */
     718                 :            : 
     719                 :            : DEBUG_FUNCTION void
     720                 :          0 : debug_scope_blocks (dump_flags_t flags)
     721                 :            : {
     722                 :          0 :   dump_scope_blocks (stderr, flags);
     723                 :          0 : }
     724                 :            : 
     725                 :            : /* Remove local variables that are not referenced in the IL.  */
     726                 :            : 
     727                 :            : void
     728                 :    5435210 : remove_unused_locals (void)
     729                 :            : {
     730                 :    5435210 :   basic_block bb;
     731                 :    5435210 :   tree var;
     732                 :    5435210 :   unsigned srcidx, dstidx, num;
     733                 :    5435210 :   bool have_local_clobbers = false;
     734                 :            : 
     735                 :            :   /* Removing declarations from lexical blocks when not optimizing is
     736                 :            :      not only a waste of time, it actually causes differences in stack
     737                 :            :      layout.  */
     738                 :    5435210 :   if (!optimize)
     739                 :            :     return;
     740                 :            : 
     741                 :    4659800 :   timevar_push (TV_REMOVE_UNUSED);
     742                 :            : 
     743                 :    4659800 :   mark_scope_block_unused (DECL_INITIAL (current_function_decl));
     744                 :            : 
     745                 :    4659800 :   usedvars = BITMAP_ALLOC (NULL);
     746                 :            : 
     747                 :            :   /* Walk the CFG marking all referenced symbols.  */
     748                 :   34398000 :   FOR_EACH_BB_FN (bb, cfun)
     749                 :            :     {
     750                 :   29738200 :       gimple_stmt_iterator gsi;
     751                 :   29738200 :       size_t i;
     752                 :   29738200 :       edge_iterator ei;
     753                 :   29738200 :       edge e;
     754                 :            : 
     755                 :            :       /* Walk the statements.  */
     756                 :  271029000 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     757                 :            :         {
     758                 :  211553000 :           gimple *stmt = gsi_stmt (gsi);
     759                 :  211553000 :           tree b = gimple_block (stmt);
     760                 :            : 
     761                 :            :           /* If we wanted to mark the block referenced by the inline
     762                 :            :              entry point marker as used, this would be a good spot to
     763                 :            :              do it.  If the block is not otherwise used, the stmt will
     764                 :            :              be cleaned up in clean_unused_block_pointer.  */
     765                 :  211553000 :           if (is_gimple_debug (stmt))
     766                 :  103338000 :             continue;
     767                 :            : 
     768                 :  108215000 :           if (gimple_clobber_p (stmt))
     769                 :            :             {
     770                 :    5570180 :               have_local_clobbers = true;
     771                 :    5570180 :               continue;
     772                 :            :             }
     773                 :            : 
     774                 :  102644000 :           if (b)
     775                 :   94528800 :             TREE_USED (b) = true;
     776                 :            : 
     777                 :  385240000 :           for (i = 0; i < gimple_num_ops (stmt); i++)
     778                 :  282596000 :             mark_all_vars_used (gimple_op_ptr (gsi_stmt (gsi), i));
     779                 :            :         }
     780                 :            : 
     781                 :   29738200 :       for (gphi_iterator gpi = gsi_start_phis (bb);
     782                 :   39710200 :            !gsi_end_p (gpi);
     783                 :    9971950 :            gsi_next (&gpi))
     784                 :            :         {
     785                 :    9971950 :           use_operand_p arg_p;
     786                 :    9971950 :           ssa_op_iter i;
     787                 :    9971950 :           tree def;
     788                 :    9971950 :           gphi *phi = gpi.phi ();
     789                 :            : 
     790                 :   19943900 :           if (virtual_operand_p (gimple_phi_result (phi)))
     791                 :    5096210 :             continue;
     792                 :            : 
     793                 :    4875740 :           def = gimple_phi_result (phi);
     794                 :    4875740 :           mark_all_vars_used (&def);
     795                 :            : 
     796                 :   15786500 :           FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_ALL_USES)
     797                 :            :             {
     798                 :   10910700 :               tree arg = USE_FROM_PTR (arg_p);
     799                 :   10910700 :               int index = PHI_ARG_INDEX_FROM_USE (arg_p);
     800                 :   10910700 :               tree block =
     801                 :   10910700 :                 LOCATION_BLOCK (gimple_phi_arg_location (phi, index));
     802                 :    6962290 :               if (block != NULL)
     803                 :    6961200 :                 TREE_USED (block) = true;
     804                 :   10910700 :               mark_all_vars_used (&arg);
     805                 :            :             }
     806                 :            :         }
     807                 :            : 
     808                 :   71154600 :       FOR_EACH_EDGE (e, ei, bb->succs)
     809                 :   41416300 :         if (LOCATION_BLOCK (e->goto_locus) != NULL)
     810                 :   27531900 :           TREE_USED (LOCATION_BLOCK (e->goto_locus)) = true;
     811                 :            :     }
     812                 :            : 
     813                 :            :   /* We do a two-pass approach about the out-of-scope clobbers.  We want
     814                 :            :      to remove them if they are the only references to a local variable,
     815                 :            :      but we want to retain them when there's any other.  So the first pass
     816                 :            :      ignores them, and the second pass (if there were any) tries to remove
     817                 :            :      them.  */
     818                 :    4659800 :   if (have_local_clobbers)
     819                 :   18725300 :     FOR_EACH_BB_FN (bb, cfun)
     820                 :            :       {
     821                 :   17366400 :         gimple_stmt_iterator gsi;
     822                 :            : 
     823                 :  180462000 :         for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
     824                 :            :           {
     825                 :  145730000 :             gimple *stmt = gsi_stmt (gsi);
     826                 :  145730000 :             tree b = gimple_block (stmt);
     827                 :            : 
     828                 :  145730000 :             if (gimple_clobber_p (stmt))
     829                 :            :               {
     830                 :    5570180 :                 tree lhs = gimple_assign_lhs (stmt);
     831                 :    5570180 :                 tree base = get_base_address (lhs);
     832                 :            :                 /* Remove clobbers referencing unused vars, or clobbers
     833                 :            :                    with MEM_REF lhs referencing uninitialized pointers.  */
     834                 :    4684150 :                 if ((VAR_P (base) && !is_used_p (base))
     835                 :    9871180 :                     || (TREE_CODE (lhs) == MEM_REF
     836                 :    1399790 :                         && TREE_CODE (TREE_OPERAND (lhs, 0)) == SSA_NAME
     837                 :     879132 :                         && SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (lhs, 0))
     838                 :     586330 :                         && (TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (lhs, 0)))
     839                 :            :                             != PARM_DECL)))
     840                 :            :                   {
     841                 :     400324 :                     unlink_stmt_vdef (stmt);
     842                 :     400324 :                     gsi_remove (&gsi, true);
     843                 :     400324 :                     release_defs (stmt);
     844                 :     400324 :                     continue;
     845                 :            :                   }
     846                 :    5169850 :                 if (b)
     847                 :    5065980 :                   TREE_USED (b) = true;
     848                 :            :               }
     849                 :  145329000 :             gsi_next (&gsi);
     850                 :            :           }
     851                 :            :       }
     852                 :            : 
     853                 :    4659800 :   if (cfun->has_simduid_loops)
     854                 :            :     {
     855                 :      11395 :       class loop *loop;
     856                 :      36181 :       FOR_EACH_LOOP (loop, 0)
     857                 :      13391 :         if (loop->simduid && !is_used_p (loop->simduid))
     858                 :        186 :           loop->simduid = NULL_TREE;
     859                 :            :     }
     860                 :            : 
     861                 :    4659800 :   cfun->has_local_explicit_reg_vars = false;
     862                 :            : 
     863                 :            :   /* Remove unmarked local and global vars from local_decls.  */
     864                 :    4659800 :   num = vec_safe_length (cfun->local_decls);
     865                 :   35902900 :   for (srcidx = 0, dstidx = 0; srcidx < num; srcidx++)
     866                 :            :     {
     867                 :   31243100 :       var = (*cfun->local_decls)[srcidx];
     868                 :   31243100 :       if (VAR_P (var))
     869                 :            :         {
     870                 :   31243100 :           if (!is_used_p (var))
     871                 :            :             {
     872                 :   17059800 :               tree def;
     873                 :   17059800 :               if (cfun->nonlocal_goto_save_area
     874                 :   17059800 :                   && TREE_OPERAND (cfun->nonlocal_goto_save_area, 0) == var)
     875                 :         10 :                 cfun->nonlocal_goto_save_area = NULL;
     876                 :            :               /* Release any default def associated with var.  */
     877                 :   17059800 :               if ((def = ssa_default_def (cfun, var)) != NULL_TREE)
     878                 :            :                 {
     879                 :     638572 :                   set_ssa_default_def (cfun, var, NULL_TREE);
     880                 :     638572 :                   release_ssa_name (def);
     881                 :            :                 }
     882                 :   17059800 :               continue;
     883                 :            :             }
     884                 :            :         }
     885                 :   14183300 :       if (VAR_P (var) && DECL_HARD_REGISTER (var) && !is_global_var (var))
     886                 :       2013 :         cfun->has_local_explicit_reg_vars = true;
     887                 :            : 
     888                 :   14183300 :       if (srcidx != dstidx)
     889                 :    8495000 :         (*cfun->local_decls)[dstidx] = var;
     890                 :   14183300 :       dstidx++;
     891                 :            :     }
     892                 :    4659800 :   if (dstidx != num)
     893                 :            :     {
     894                 :    2684670 :       statistics_counter_event (cfun, "unused VAR_DECLs removed", num - dstidx);
     895                 :    2684670 :       cfun->local_decls->truncate (dstidx);
     896                 :            :     }
     897                 :            : 
     898                 :    4659800 :   remove_unused_scope_block_p (DECL_INITIAL (current_function_decl),
     899                 :    4659800 :                                polymorphic_ctor_dtor_p (current_function_decl,
     900                 :            :                                                         true) != NULL_TREE);
     901                 :    4659800 :   clear_unused_block_pointer ();
     902                 :            : 
     903                 :    4659800 :   BITMAP_FREE (usedvars);
     904                 :            : 
     905                 :    4659800 :   if (dump_file && (dump_flags & TDF_DETAILS))
     906                 :            :     {
     907                 :         83 :       fprintf (dump_file, "Scope blocks after cleanups:\n");
     908                 :         83 :       dump_scope_blocks (dump_file, dump_flags);
     909                 :            :     }
     910                 :            : 
     911                 :    4659800 :   timevar_pop (TV_REMOVE_UNUSED);
     912                 :            : }
     913                 :            : 
     914                 :            : /* Allocate and return a new live range information object base on MAP.  */
     915                 :            : 
     916                 :            : static tree_live_info_p
     917                 :     832684 : new_tree_live_info (var_map map)
     918                 :            : {
     919                 :     832684 :   tree_live_info_p live;
     920                 :     832684 :   basic_block bb;
     921                 :            : 
     922                 :     832684 :   live = XNEW (struct tree_live_info_d);
     923                 :     832684 :   live->map = map;
     924                 :     832684 :   live->num_blocks = last_basic_block_for_fn (cfun);
     925                 :            : 
     926                 :     832684 :   bitmap_obstack_initialize (&live->livein_obstack);
     927                 :     832684 :   bitmap_obstack_initialize (&live->liveout_obstack);
     928                 :            : 
     929                 :     832684 :   live->livein = XCNEWVEC (bitmap_head, last_basic_block_for_fn (cfun));
     930                 :     832684 :   live->liveout = XCNEWVEC (bitmap_head, last_basic_block_for_fn (cfun));
     931                 :    8206310 :   for (unsigned i = 0; map->vec_bbs.iterate (i, &bb); ++i)
     932                 :            :     {
     933                 :    7373620 :       bitmap_initialize (&live->livein[bb->index], &live->livein_obstack);
     934                 :    7373620 :       bitmap_initialize (&live->liveout[bb->index], &live->liveout_obstack);
     935                 :            :     }
     936                 :            : 
     937                 :     832684 :   live->work_stack = XNEWVEC (int, last_basic_block_for_fn (cfun));
     938                 :     832684 :   live->stack_top = live->work_stack;
     939                 :            : 
     940                 :     832684 :   live->global = BITMAP_ALLOC (NULL);
     941                 :     832684 :   return live;
     942                 :            : }
     943                 :            : 
     944                 :            : 
     945                 :            : /* Free storage for live range info object LIVE.  */
     946                 :            : 
     947                 :            : void
     948                 :     832684 : delete_tree_live_info (tree_live_info_p live)
     949                 :            : {
     950                 :     832684 :   if (live->livein)
     951                 :            :     {
     952                 :          0 :       bitmap_obstack_release (&live->livein_obstack);
     953                 :          0 :       free (live->livein);
     954                 :            :     }
     955                 :     832684 :   if (live->liveout)
     956                 :            :     {
     957                 :     832684 :       bitmap_obstack_release (&live->liveout_obstack);
     958                 :     832684 :       free (live->liveout);
     959                 :            :     }
     960                 :     832684 :   BITMAP_FREE (live->global);
     961                 :     832684 :   free (live->work_stack);
     962                 :     832684 :   free (live);
     963                 :     832684 : }
     964                 :            : 
     965                 :            : 
     966                 :            : /* Visit basic block BB and propagate any required live on entry bits from
     967                 :            :    LIVE into the predecessors.  VISITED is the bitmap of visited blocks.
     968                 :            :    TMP is a temporary work bitmap which is passed in to avoid reallocating
     969                 :            :    it each time.  */
     970                 :            : 
     971                 :            : static void
     972                 :    8464590 : loe_visit_block (tree_live_info_p live, basic_block bb, sbitmap visited)
     973                 :            : {
     974                 :    8464590 :   edge e;
     975                 :    8464590 :   bool change;
     976                 :    8464590 :   edge_iterator ei;
     977                 :    8464590 :   basic_block pred_bb;
     978                 :    8464590 :   bitmap loe;
     979                 :            : 
     980                 :    8464590 :   gcc_checking_assert (!bitmap_bit_p (visited, bb->index));
     981                 :    8464590 :   bitmap_set_bit (visited, bb->index);
     982                 :            : 
     983                 :    8464590 :   loe = live_on_entry (live, bb);
     984                 :            : 
     985                 :   20697400 :   FOR_EACH_EDGE (e, ei, bb->preds)
     986                 :            :     {
     987                 :   12232800 :       pred_bb = e->src;
     988                 :   24465600 :       if (!region_contains_p (live->map, pred_bb))
     989                 :     841123 :         continue;
     990                 :            :       /* Variables live-on-entry from BB that aren't defined in the
     991                 :            :          predecessor block.  This should be the live on entry vars to pred.
     992                 :            :          Note that liveout is the DEFs in a block while live on entry is
     993                 :            :          being calculated.
     994                 :            :          Add these bits to live-on-entry for the pred. if there are any
     995                 :            :          changes, and pred_bb has been visited already, add it to the
     996                 :            :          revisit stack.  */
     997                 :   11391700 :       change = bitmap_ior_and_compl_into (live_on_entry (live, pred_bb),
     998                 :   11391700 :                                           loe, &live->liveout[pred_bb->index]);
     999                 :   11391700 :       if (change
    1000                 :   11391700 :           && bitmap_bit_p (visited, pred_bb->index))
    1001                 :            :         {
    1002                 :    1090960 :           bitmap_clear_bit (visited, pred_bb->index);
    1003                 :    1090960 :           *(live->stack_top)++ = pred_bb->index;
    1004                 :            :         }
    1005                 :            :     }
    1006                 :    8464590 : }
    1007                 :            : 
    1008                 :            : 
    1009                 :            : /* Using LIVE, fill in all the live-on-entry blocks between the defs and uses
    1010                 :            :    of all the variables.  */
    1011                 :            : 
    1012                 :            : static void
    1013                 :     832684 : live_worklist (tree_live_info_p live)
    1014                 :            : {
    1015                 :     832684 :   unsigned b;
    1016                 :     832684 :   basic_block bb;
    1017                 :     832684 :   auto_sbitmap visited (last_basic_block_for_fn (cfun) + 1);
    1018                 :            : 
    1019                 :     832684 :   bitmap_clear (visited);
    1020                 :            : 
    1021                 :            :   /* Visit region's blocks in reverse order and propagate live on entry values
    1022                 :            :      into the predecessors blocks.  */
    1023                 :    9038990 :   for (unsigned i = live->map->vec_bbs.length () - 1;
    1024                 :    8206310 :        live->map->vec_bbs.iterate (i, &bb); --i)
    1025                 :    7373620 :     loe_visit_block (live, bb, visited);
    1026                 :            : 
    1027                 :            :   /* Process any blocks which require further iteration.  */
    1028                 :    1923650 :   while (live->stack_top != live->work_stack)
    1029                 :            :     {
    1030                 :    1090960 :       b = *--(live->stack_top);
    1031                 :    1090960 :       loe_visit_block (live, BASIC_BLOCK_FOR_FN (cfun, b), visited);
    1032                 :            :     }
    1033                 :     832684 : }
    1034                 :            : 
    1035                 :            : 
    1036                 :            : /* Calculate the initial live on entry vector for SSA_NAME using immediate_use
    1037                 :            :    links.  Set the live on entry fields in LIVE.  Def's are marked temporarily
    1038                 :            :    in the liveout vector.  */
    1039                 :            : 
    1040                 :            : static void
    1041                 :    6505180 : set_var_live_on_entry (tree ssa_name, tree_live_info_p live)
    1042                 :            : {
    1043                 :    6505180 :   int p;
    1044                 :    6505180 :   gimple *stmt;
    1045                 :    6505180 :   use_operand_p use;
    1046                 :    6505180 :   basic_block def_bb = NULL;
    1047                 :    6505180 :   imm_use_iterator imm_iter;
    1048                 :    6505180 :   bool global = false;
    1049                 :            : 
    1050                 :    6505180 :   p = var_to_partition (live->map, ssa_name);
    1051                 :    6505180 :   if (p == NO_PARTITION)
    1052                 :     451686 :     return;
    1053                 :            : 
    1054                 :    6505180 :   stmt = SSA_NAME_DEF_STMT (ssa_name);
    1055                 :    6505180 :   if (stmt)
    1056                 :            :     {
    1057                 :    6505180 :       def_bb = gimple_bb (stmt);
    1058                 :            :       /* Mark defs in liveout bitmap temporarily.  */
    1059                 :   10696200 :       if (def_bb && region_contains_p (live->map, def_bb))
    1060                 :    4191030 :         bitmap_set_bit (&live->liveout[def_bb->index], p);
    1061                 :            :     }
    1062                 :            :   else
    1063                 :          0 :     def_bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
    1064                 :            : 
    1065                 :            :   /* An undefined local variable does not need to be very alive.  */
    1066                 :    6505180 :   if (ssa_undefined_value_p (ssa_name, false))
    1067                 :            :     return;
    1068                 :            : 
    1069                 :            :   /* Visit each use of SSA_NAME and if it isn't in the same block as the def,
    1070                 :            :      add it to the list of live on entry blocks.  */
    1071                 :   19576900 :   FOR_EACH_IMM_USE_FAST (use, imm_iter, ssa_name)
    1072                 :            :     {
    1073                 :   13523400 :       gimple *use_stmt = USE_STMT (use);
    1074                 :   13523400 :       basic_block add_block = NULL;
    1075                 :            : 
    1076                 :   13523400 :       if (gimple_code (use_stmt) == GIMPLE_PHI)
    1077                 :            :         {
    1078                 :            :           /* Uses in PHI's are considered to be live at exit of the SRC block
    1079                 :            :              as this is where a copy would be inserted.  Check to see if it is
    1080                 :            :              defined in that block, or whether its live on entry.  */
    1081                 :    3179480 :           int index = PHI_ARG_INDEX_FROM_USE (use);
    1082                 :    3179480 :           edge e = gimple_phi_arg_edge (as_a <gphi *> (use_stmt), index);
    1083                 :    4180540 :           if (e->src != def_bb && region_contains_p (live->map, e->src))
    1084                 :    1000790 :             add_block = e->src;
    1085                 :            :         }
    1086                 :   10343900 :       else if (is_gimple_debug (use_stmt))
    1087                 :    2679380 :         continue;
    1088                 :            :       else
    1089                 :            :         {
    1090                 :            :           /* If its not defined in this block, its live on entry.  */
    1091                 :    7664520 :           basic_block use_bb = gimple_bb (use_stmt);
    1092                 :   12749100 :           if (use_bb != def_bb && region_contains_p (live->map, use_bb))
    1093                 :            :             add_block = use_bb;
    1094                 :            :         }
    1095                 :            : 
    1096                 :            :       /* If there was a live on entry use, set the bit.  */
    1097                 :    6085410 :       if (add_block)
    1098                 :            :         {
    1099                 :    6085410 :           global = true;
    1100                 :    6085410 :           bitmap_set_bit (&live->livein[add_block->index], p);
    1101                 :            :         }
    1102                 :            :     }
    1103                 :            : 
    1104                 :            :   /* If SSA_NAME is live on entry to at least one block, fill in all the live
    1105                 :            :      on entry blocks between the def and all the uses.  */
    1106                 :    6053490 :   if (global)
    1107                 :    2370060 :     bitmap_set_bit (live->global, p);
    1108                 :            : }
    1109                 :            : 
    1110                 :            : 
    1111                 :            : /* Calculate the live on exit vectors based on the entry info in LIVEINFO.  */
    1112                 :            : 
    1113                 :            : static void
    1114                 :     832684 : calculate_live_on_exit (tree_live_info_p liveinfo)
    1115                 :            : {
    1116                 :     832684 :   basic_block bb;
    1117                 :     832684 :   edge e;
    1118                 :     832684 :   edge_iterator ei;
    1119                 :            : 
    1120                 :            :   /* live on entry calculations used liveout vectors for defs, clear them.  */
    1121                 :    8206310 :   for (unsigned i = 0; liveinfo->map->vec_bbs.iterate (i, &bb); ++i)
    1122                 :    7373620 :     bitmap_clear (&liveinfo->liveout[bb->index]);
    1123                 :            : 
    1124                 :            :   /* Set all the live-on-exit bits for uses in PHIs.  */
    1125                 :    8206310 :   FOR_EACH_BB_FN (bb, cfun)
    1126                 :            :     {
    1127                 :    7373620 :       gphi_iterator gsi;
    1128                 :    7373620 :       size_t i;
    1129                 :            : 
    1130                 :            :       /* Mark the PHI arguments which are live on exit to the pred block.  */
    1131                 :    8960040 :       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    1132                 :            :         {
    1133                 :    1586420 :           gphi *phi = gsi.phi ();
    1134                 :    3172840 :           if (virtual_operand_p (gimple_phi_result (phi)))
    1135                 :          0 :             continue;
    1136                 :    5425290 :           for (i = 0; i < gimple_phi_num_args (phi); i++)
    1137                 :            :             {
    1138                 :    3838870 :               tree t = PHI_ARG_DEF (phi, i);
    1139                 :    3838870 :               int p;
    1140                 :            : 
    1141                 :    3838870 :               if (TREE_CODE (t) != SSA_NAME)
    1142                 :     642875 :                 continue;
    1143                 :            : 
    1144                 :    3196000 :               p = var_to_partition (liveinfo->map, t);
    1145                 :    3196000 :               if (p == NO_PARTITION)
    1146                 :        188 :                 continue;
    1147                 :    3195810 :               e = gimple_phi_arg_edge (phi, i);
    1148                 :    6391620 :               if (region_contains_p (liveinfo->map, e->src))
    1149                 :    3195460 :                 bitmap_set_bit (&liveinfo->liveout[e->src->index], p);
    1150                 :            :             }
    1151                 :            :         }
    1152                 :            : 
    1153                 :   14747200 :       if (!region_contains_p (liveinfo->map, bb))
    1154                 :          0 :         continue;
    1155                 :            : 
    1156                 :            :       /* Add each successors live on entry to this bock live on exit.  */
    1157                 :   18011800 :       FOR_EACH_EDGE (e, ei, bb->succs)
    1158                 :   21276400 :         if (region_contains_p (liveinfo->map, e->dest))
    1159                 :    9821790 :           bitmap_ior_into (&liveinfo->liveout[bb->index],
    1160                 :    9821790 :                            live_on_entry (liveinfo, e->dest));
    1161                 :            :     }
    1162                 :     832684 : }
    1163                 :            : 
    1164                 :            : 
    1165                 :            : /* Given partition map MAP, calculate all the live on entry bitmaps for
    1166                 :            :    each partition.  Return a new live info object.  */
    1167                 :            : 
    1168                 :            : tree_live_info_p
    1169                 :     832684 : calculate_live_ranges (var_map map, bool want_livein)
    1170                 :            : {
    1171                 :     832684 :   tree var;
    1172                 :     832684 :   unsigned i;
    1173                 :     832684 :   tree_live_info_p live;
    1174                 :            : 
    1175                 :     832684 :   live = new_tree_live_info (map);
    1176                 :    7337860 :   for (i = 0; i < num_var_partitions (map); i++)
    1177                 :            :     {
    1178                 :    6505180 :       var = partition_to_var (map, i);
    1179                 :    6505180 :       if (var != NULL_TREE)
    1180                 :    6505180 :         set_var_live_on_entry (var, live);
    1181                 :            :     }
    1182                 :            : 
    1183                 :     832684 :   live_worklist (live);
    1184                 :            : 
    1185                 :     832684 :   if (flag_checking)
    1186                 :     832672 :     verify_live_on_entry (live);
    1187                 :            : 
    1188                 :     832684 :   calculate_live_on_exit (live);
    1189                 :            : 
    1190                 :     832684 :   if (!want_livein)
    1191                 :            :     {
    1192                 :     832684 :       bitmap_obstack_release (&live->livein_obstack);
    1193                 :     832684 :       free (live->livein);
    1194                 :     832684 :       live->livein = NULL;
    1195                 :            :     }
    1196                 :            : 
    1197                 :     832684 :   return live;
    1198                 :            : }
    1199                 :            : 
    1200                 :            : /* Data structure for compute_live_vars* functions.  */
    1201                 :            : 
    1202                 :            : struct compute_live_vars_data {
    1203                 :            :   /* Vector of bitmaps for live vars indices at the end of basic blocks,
    1204                 :            :      indexed by bb->index.  ACTIVE[ENTRY_BLOCK] must be empty bitmap,
    1205                 :            :      ACTIVE[EXIT_BLOCK] is used for STOP_AFTER.  */
    1206                 :            :   vec<bitmap_head> active;
    1207                 :            :   /* Work bitmap of currently live variables.  */
    1208                 :            :   bitmap work;
    1209                 :            :   /* Set of interesting variables.  Variables with uids not in this
    1210                 :            :      hash_map are not tracked.  */
    1211                 :            :   live_vars_map *vars;
    1212                 :            : };
    1213                 :            : 
    1214                 :            : /* Callback for walk_stmt_load_store_addr_ops.  If OP is a VAR_DECL with
    1215                 :            :    uid set in DATA->vars, enter its corresponding index into bitmap
    1216                 :            :    DATA->work.  */
    1217                 :            : 
    1218                 :            : static bool
    1219                 :   15015200 : compute_live_vars_visit (gimple *, tree op, tree, void *pdata)
    1220                 :            : {
    1221                 :   15015200 :   compute_live_vars_data *data = (compute_live_vars_data *) pdata;
    1222                 :   15015200 :   op = get_base_address (op);
    1223                 :   15015200 :   if (op && VAR_P (op))
    1224                 :    9764440 :     if (unsigned int *v = data->vars->get (DECL_UID (op)))
    1225                 :    8008990 :       bitmap_set_bit (data->work, *v);
    1226                 :   15015200 :   return false;
    1227                 :            : }
    1228                 :            : 
    1229                 :            : /* Helper routine for compute_live_vars, calculating the sets of live
    1230                 :            :    variables at the end of BB, leaving the result in DATA->work.
    1231                 :            :    If STOP_AFTER is non-NULL, stop processing after that stmt.  */
    1232                 :            : 
    1233                 :            : static void
    1234                 :    7009550 : compute_live_vars_1 (basic_block bb, compute_live_vars_data *data,
    1235                 :            :                      gimple *stop_after)
    1236                 :            : {
    1237                 :    7009550 :   edge e;
    1238                 :    7009550 :   edge_iterator ei;
    1239                 :    7009550 :   gimple_stmt_iterator gsi;
    1240                 :    7009550 :   walk_stmt_load_store_addr_fn visit = compute_live_vars_visit;
    1241                 :            : 
    1242                 :    7009550 :   bitmap_clear (data->work);
    1243                 :   17044200 :   FOR_EACH_EDGE (e, ei, bb->preds)
    1244                 :   10034700 :     bitmap_ior_into (data->work, &data->active[e->src->index]);
    1245                 :            : 
    1246                 :   10004700 :   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    1247                 :    2995170 :     walk_stmt_load_store_addr_ops (gsi_stmt (gsi), data, NULL, NULL, visit);
    1248                 :  107790000 :   for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    1249                 :            :     {
    1250                 :   93945400 :       gimple *stmt = gsi_stmt (gsi);
    1251                 :            : 
    1252                 :   93945400 :       if (gimple_clobber_p (stmt))
    1253                 :            :         {
    1254                 :    2893180 :           tree lhs = gimple_assign_lhs (stmt);
    1255                 :    2893180 :           if (VAR_P (lhs))
    1256                 :    2111340 :             if (unsigned int *v = data->vars->get (DECL_UID (lhs)))
    1257                 :    1696560 :               bitmap_clear_bit (data->work, *v);
    1258                 :            :         }
    1259                 :   91052300 :       else if (!is_gimple_debug (stmt))
    1260                 :   23275700 :         walk_stmt_load_store_addr_ops (stmt, data, visit, visit, visit);
    1261                 :   93945400 :       if (stmt == stop_after)
    1262                 :            :         break;
    1263                 :            :     }
    1264                 :    7009550 : }
    1265                 :            : 
    1266                 :            : /* For function FN and live_vars_map (hash map from DECL_UIDs to a dense set of
    1267                 :            :    indexes of automatic variables VARS, compute which of those variables are
    1268                 :            :    (might be) live at the end of each basic block.  */
    1269                 :            : 
    1270                 :            : vec<bitmap_head>
    1271                 :     212161 : compute_live_vars (struct function *fn, live_vars_map *vars)
    1272                 :            : {
    1273                 :     212161 :   vec<bitmap_head> active;
    1274                 :            : 
    1275                 :            :   /* We approximate the live range of a stack variable by taking the first
    1276                 :            :      mention of its name as starting point(s), and by the end-of-scope
    1277                 :            :      death clobber added by gimplify as ending point(s) of the range.
    1278                 :            :      This overapproximates in the case we for instance moved an address-taken
    1279                 :            :      operation upward, without also moving a dereference to it upwards.
    1280                 :            :      But it's conservatively correct as a variable never can hold values
    1281                 :            :      before its name is mentioned at least once.
    1282                 :            : 
    1283                 :            :      We then do a mostly classical bitmap liveness algorithm.  */
    1284                 :            : 
    1285                 :     212161 :   active.create (last_basic_block_for_fn (fn));
    1286                 :     212161 :   active.quick_grow (last_basic_block_for_fn (fn));
    1287                 :    4069490 :   for (int i = 0; i < last_basic_block_for_fn (fn); i++)
    1288                 :    3857330 :     bitmap_initialize (&active[i], &bitmap_default_obstack);
    1289                 :            : 
    1290                 :     212161 :   bitmap work = BITMAP_ALLOC (NULL);
    1291                 :            : 
    1292                 :     212161 :   int *rpo = XNEWVEC (int, last_basic_block_for_fn (fn));
    1293                 :     212161 :   int n_bbs = pre_and_rev_post_order_compute_fn (fn, NULL, rpo, false);
    1294                 :            : 
    1295                 :     212161 :   bool changed = true;
    1296                 :     212161 :   compute_live_vars_data data = { active, work, vars };
    1297                 :     581652 :   while (changed)
    1298                 :            :     {
    1299                 :            :       int i;
    1300                 :            :       changed = false;
    1301                 :    7204910 :       for (i = 0; i < n_bbs; i++)
    1302                 :            :         {
    1303                 :    6835420 :           basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
    1304                 :    6835420 :           compute_live_vars_1 (bb, &data, NULL);
    1305                 :    6835420 :           if (bitmap_ior_into (&active[bb->index], work))
    1306                 :    2588910 :             changed = true;
    1307                 :            :         }
    1308                 :            :     }
    1309                 :            : 
    1310                 :     212161 :   free (rpo);
    1311                 :     212161 :   BITMAP_FREE (work);
    1312                 :            : 
    1313                 :     212161 :   return active;
    1314                 :            : }
    1315                 :            : 
    1316                 :            : /* For ACTIVE computed by compute_live_vars, compute a bitmap of variables
    1317                 :            :    live after the STOP_AFTER statement and return that bitmap.  */
    1318                 :            : 
    1319                 :            : bitmap
    1320                 :     174129 : live_vars_at_stmt (vec<bitmap_head> &active, live_vars_map *vars,
    1321                 :            :                    gimple *stop_after)
    1322                 :            : {
    1323                 :     174129 :   bitmap work = BITMAP_ALLOC (NULL);
    1324                 :     174129 :   compute_live_vars_data data = { active, work, vars };
    1325                 :     174129 :   basic_block bb = gimple_bb (stop_after);
    1326                 :     174129 :   compute_live_vars_1 (bb, &data, stop_after);
    1327                 :     174129 :   return work;
    1328                 :            : }
    1329                 :            : 
    1330                 :            : /* Destroy what compute_live_vars has returned when it is no longer needed.  */
    1331                 :            : 
    1332                 :            : void
    1333                 :     212161 : destroy_live_vars (vec<bitmap_head> &active)
    1334                 :            : {
    1335                 :     212161 :   unsigned len = active.length ();
    1336                 :    4069490 :   for (unsigned i = 0; i < len; i++)
    1337                 :    3857330 :     bitmap_clear (&active[i]);
    1338                 :            : 
    1339                 :     212161 :   active.release ();
    1340                 :     212161 : }
    1341                 :            : 
    1342                 :            : /* Output partition map MAP to file F.  */
    1343                 :            : 
    1344                 :            : void
    1345                 :        146 : dump_var_map (FILE *f, var_map map)
    1346                 :            : {
    1347                 :        146 :   int t;
    1348                 :        146 :   unsigned x, y;
    1349                 :        146 :   int p;
    1350                 :            : 
    1351                 :        146 :   fprintf (f, "\nPartition map \n\n");
    1352                 :            : 
    1353                 :        753 :   for (x = 0; x < map->num_partitions; x++)
    1354                 :            :     {
    1355                 :        607 :       if (map->view_to_partition != NULL)
    1356                 :        277 :         p = map->view_to_partition[x];
    1357                 :            :       else
    1358                 :        330 :         p = x;
    1359                 :            : 
    1360                 :        607 :       if (ssa_name (p) == NULL_TREE
    1361                 :       1125 :           || virtual_operand_p (ssa_name (p)))
    1362                 :        183 :         continue;
    1363                 :            : 
    1364                 :            :       t = 0;
    1365                 :      15772 :       for (y = 1; y < num_ssa_names; y++)
    1366                 :            :         {
    1367                 :       7462 :           p = partition_find (map->var_partition, y);
    1368                 :       7462 :           if (map->partition_to_view)
    1369                 :       4707 :             p = map->partition_to_view[p];
    1370                 :       7462 :           if (p == (int)x)
    1371                 :            :             {
    1372                 :        446 :               if (t++ == 0)
    1373                 :            :                 {
    1374                 :        424 :                   fprintf (f, "Partition %d (", x);
    1375                 :        424 :                   print_generic_expr (f, partition_to_var (map, p), TDF_SLIM);
    1376                 :        424 :                   fprintf (f, " - ");
    1377                 :            :                 }
    1378                 :        446 :               fprintf (f, "%d ", y);
    1379                 :            :             }
    1380                 :            :         }
    1381                 :        424 :       if (t != 0)
    1382                 :        424 :         fprintf (f, ")\n");
    1383                 :            :     }
    1384                 :        146 :   fprintf (f, "\n");
    1385                 :        146 : }
    1386                 :            : 
    1387                 :            : 
    1388                 :            : /* Generic dump for the above.  */
    1389                 :            : 
    1390                 :            : DEBUG_FUNCTION void
    1391                 :          0 : debug (_var_map &ref)
    1392                 :            : {
    1393                 :          0 :   dump_var_map (stderr, &ref);
    1394                 :          0 : }
    1395                 :            : 
    1396                 :            : DEBUG_FUNCTION void
    1397                 :          0 : debug (_var_map *ptr)
    1398                 :            : {
    1399                 :          0 :   if (ptr)
    1400                 :          0 :     debug (*ptr);
    1401                 :            :   else
    1402                 :          0 :     fprintf (stderr, "<nil>\n");
    1403                 :          0 : }
    1404                 :            : 
    1405                 :            : 
    1406                 :            : /* Output live range info LIVE to file F, controlled by FLAG.  */
    1407                 :            : 
    1408                 :            : void
    1409                 :         34 : dump_live_info (FILE *f, tree_live_info_p live, int flag)
    1410                 :            : {
    1411                 :         34 :   basic_block bb;
    1412                 :         34 :   unsigned i;
    1413                 :         34 :   var_map map = live->map;
    1414                 :         34 :   bitmap_iterator bi;
    1415                 :            : 
    1416                 :         34 :   if ((flag & LIVEDUMP_ENTRY) && live->livein)
    1417                 :            :     {
    1418                 :          0 :       FOR_EACH_BB_FN (bb, cfun)
    1419                 :            :         {
    1420                 :          0 :           fprintf (f, "\nLive on entry to BB%d : ", bb->index);
    1421                 :          0 :           EXECUTE_IF_SET_IN_BITMAP (&live->livein[bb->index], 0, i, bi)
    1422                 :            :             {
    1423                 :          0 :               print_generic_expr (f, partition_to_var (map, i), TDF_SLIM);
    1424                 :          0 :               fprintf (f, "  ");
    1425                 :            :             }
    1426                 :          0 :           fprintf (f, "\n");
    1427                 :            :         }
    1428                 :            :     }
    1429                 :            : 
    1430                 :         34 :   if ((flag & LIVEDUMP_EXIT) && live->liveout)
    1431                 :            :     {
    1432                 :          0 :       FOR_EACH_BB_FN (bb, cfun)
    1433                 :            :         {
    1434                 :          0 :           fprintf (f, "\nLive on exit from BB%d : ", bb->index);
    1435                 :          0 :           EXECUTE_IF_SET_IN_BITMAP (&live->liveout[bb->index], 0, i, bi)
    1436                 :            :             {
    1437                 :          0 :               print_generic_expr (f, partition_to_var (map, i), TDF_SLIM);
    1438                 :          0 :               fprintf (f, "  ");
    1439                 :            :             }
    1440                 :          0 :           fprintf (f, "\n");
    1441                 :            :         }
    1442                 :            :     }
    1443                 :         34 : }
    1444                 :            : 
    1445                 :            : 
    1446                 :            : /* Generic dump for the above.  */
    1447                 :            : 
    1448                 :            : DEBUG_FUNCTION void
    1449                 :          0 : debug (tree_live_info_d &ref)
    1450                 :            : {
    1451                 :          0 :   dump_live_info (stderr, &ref, 0);
    1452                 :          0 : }
    1453                 :            : 
    1454                 :            : DEBUG_FUNCTION void
    1455                 :          0 : debug (tree_live_info_d *ptr)
    1456                 :            : {
    1457                 :          0 :   if (ptr)
    1458                 :          0 :     debug (*ptr);
    1459                 :            :   else
    1460                 :          0 :     fprintf (stderr, "<nil>\n");
    1461                 :          0 : }
    1462                 :            : 
    1463                 :            : 
    1464                 :            : /* Verify that the info in LIVE matches the current cfg.  */
    1465                 :            : 
    1466                 :            : static void
    1467                 :     832672 : verify_live_on_entry (tree_live_info_p live)
    1468                 :            : {
    1469                 :     832672 :   unsigned i;
    1470                 :     832672 :   tree var;
    1471                 :     832672 :   gimple *stmt;
    1472                 :     832672 :   basic_block bb;
    1473                 :     832672 :   edge e;
    1474                 :     832672 :   int num;
    1475                 :     832672 :   edge_iterator ei;
    1476                 :     832672 :   var_map map = live->map;
    1477                 :            : 
    1478                 :            :    /* Check for live on entry partitions and report those with a DEF in
    1479                 :            :       the program. This will typically mean an optimization has done
    1480                 :            :       something wrong.  */
    1481                 :     832672 :   bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
    1482                 :     832672 :   num = 0;
    1483                 :    1665340 :   FOR_EACH_EDGE (e, ei, bb->succs)
    1484                 :            :     {
    1485                 :     832672 :       int entry_block = e->dest->index;
    1486                 :    1665340 :       if (!region_contains_p (live->map, e->dest))
    1487                 :          0 :         continue;
    1488                 :    7337770 :       for (i = 0; i < (unsigned)num_var_partitions (map); i++)
    1489                 :            :         {
    1490                 :    6505100 :           basic_block tmp;
    1491                 :    6505100 :           tree d = NULL_TREE;
    1492                 :    6505100 :           bitmap loe;
    1493                 :    6505100 :           var = partition_to_var (map, i);
    1494                 :    6505100 :           stmt = SSA_NAME_DEF_STMT (var);
    1495                 :    6505100 :           tmp = gimple_bb (stmt);
    1496                 :    6505100 :           if (SSA_NAME_VAR (var))
    1497                 :    4584020 :             d = ssa_default_def (cfun, SSA_NAME_VAR (var));
    1498                 :            : 
    1499                 :    6505100 :           loe = live_on_entry (live, e->dest);
    1500                 :    6505100 :           if (loe && bitmap_bit_p (loe, i))
    1501                 :            :             {
    1502                 :    1092160 :               if (!gimple_nop_p (stmt))
    1503                 :            :                 {
    1504                 :          0 :                   num++;
    1505                 :          0 :                   print_generic_expr (stderr, var, TDF_SLIM);
    1506                 :          0 :                   fprintf (stderr, " is defined ");
    1507                 :          0 :                   if (tmp)
    1508                 :          0 :                     fprintf (stderr, " in BB%d, ", tmp->index);
    1509                 :          0 :                   fprintf (stderr, "by:\n");
    1510                 :          0 :                   print_gimple_stmt (stderr, stmt, 0, TDF_SLIM);
    1511                 :          0 :                   fprintf (stderr, "\nIt is also live-on-entry to entry BB %d",
    1512                 :            :                            entry_block);
    1513                 :          0 :                   fprintf (stderr, " So it appears to have multiple defs.\n");
    1514                 :            :                 }
    1515                 :            :               else
    1516                 :            :                 {
    1517                 :    1092160 :                   if (d != var)
    1518                 :            :                     {
    1519                 :          0 :                       num++;
    1520                 :          0 :                       print_generic_expr (stderr, var, TDF_SLIM);
    1521                 :          0 :                       fprintf (stderr, " is live-on-entry to BB%d ",
    1522                 :            :                                entry_block);
    1523                 :          0 :                       if (d)
    1524                 :            :                         {
    1525                 :          0 :                           fprintf (stderr, " but is not the default def of ");
    1526                 :          0 :                           print_generic_expr (stderr, d, TDF_SLIM);
    1527                 :          0 :                           fprintf (stderr, "\n");
    1528                 :            :                         }
    1529                 :            :                       else
    1530                 :          0 :                         fprintf (stderr, " and there is no default def.\n");
    1531                 :            :                     }
    1532                 :            :                 }
    1533                 :            :             }
    1534                 :            :           else
    1535                 :    5412940 :             if (d == var)
    1536                 :            :               {
    1537                 :            :                 /* An undefined local variable does not need to be very
    1538                 :            :                    alive.  */
    1539                 :    1221970 :                 if (ssa_undefined_value_p (var, false))
    1540                 :    1221970 :                   continue;
    1541                 :            : 
    1542                 :            :                 /* The only way this var shouldn't be marked live on entry is
    1543                 :            :                    if it occurs in a PHI argument of the block.  */
    1544                 :     770289 :                 size_t z;
    1545                 :     770289 :                 bool ok = false;
    1546                 :     770289 :                 gphi_iterator gsi;
    1547                 :     770289 :                 for (gsi = gsi_start_phis (e->dest);
    1548                 :     770641 :                      !gsi_end_p (gsi) && !ok;
    1549                 :        352 :                      gsi_next (&gsi))
    1550                 :            :                   {
    1551                 :        352 :                     gphi *phi = gsi.phi ();
    1552                 :        704 :                     if (virtual_operand_p (gimple_phi_result (phi)))
    1553                 :          0 :                       continue;
    1554                 :        521 :                     for (z = 0; z < gimple_phi_num_args (phi); z++)
    1555                 :        438 :                       if (var == gimple_phi_arg_def (phi, z))
    1556                 :            :                         {
    1557                 :            :                           ok = true;
    1558                 :            :                           break;
    1559                 :            :                         }
    1560                 :            :                   }
    1561                 :     770289 :                 if (ok)
    1562                 :        269 :                   continue;
    1563                 :            :                 /* Expand adds unused default defs for PARM_DECLs and
    1564                 :            :                    RESULT_DECLs.  They're ok.  */
    1565                 :     770020 :                 if (has_zero_uses (var)
    1566                 :     770020 :                     && SSA_NAME_VAR (var)
    1567                 :    1540040 :                     && !VAR_P (SSA_NAME_VAR (var)))
    1568                 :     770020 :                   continue;
    1569                 :          0 :                 num++;
    1570                 :          0 :                 print_generic_expr (stderr, var, TDF_SLIM);
    1571                 :          0 :                 fprintf (stderr, " is not marked live-on-entry to entry BB%d ",
    1572                 :            :                          entry_block);
    1573                 :          0 :                 fprintf (stderr, "but it is a default def so it should be.\n");
    1574                 :            :               }
    1575                 :            :         }
    1576                 :            :     }
    1577                 :     832672 :   gcc_assert (num <= 0);
    1578                 :     832672 : }

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.