LCOV - code coverage report
Current view: top level - gcc - tree-phinodes.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 184 190 96.8 %
Date: 2020-04-04 11:58:09 Functions: 14 16 87.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Generic routines for manipulating PHIs
       2                 :            :    Copyright (C) 2003-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify
       7                 :            : it under the terms of the GNU General Public License as published by
       8                 :            : the Free Software Foundation; either version 3, or (at your option)
       9                 :            : any later version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful,
      12                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            : GNU General Public License for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "backend.h"
      24                 :            : #include "tree.h"
      25                 :            : #include "gimple.h"
      26                 :            : #include "ssa.h"
      27                 :            : #include "fold-const.h"
      28                 :            : #include "gimple-iterator.h"
      29                 :            : #include "tree-ssa.h"
      30                 :            : 
      31                 :            : /* Rewriting a function into SSA form can create a huge number of PHIs
      32                 :            :    many of which may be thrown away shortly after their creation if jumps
      33                 :            :    were threaded through PHI nodes.
      34                 :            : 
      35                 :            :    While our garbage collection mechanisms will handle this situation, it
      36                 :            :    is extremely wasteful to create nodes and throw them away, especially
      37                 :            :    when the nodes can be reused.
      38                 :            : 
      39                 :            :    For PR 8361, we can significantly reduce the number of nodes allocated
      40                 :            :    and thus the total amount of memory allocated by managing PHIs a
      41                 :            :    little.  This additionally helps reduce the amount of work done by the
      42                 :            :    garbage collector.  Similar results have been seen on a wider variety
      43                 :            :    of tests (such as the compiler itself).
      44                 :            : 
      45                 :            :    PHI nodes have different sizes, so we can't have a single list of all
      46                 :            :    the PHI nodes as it would be too expensive to walk down that list to
      47                 :            :    find a PHI of a suitable size.
      48                 :            : 
      49                 :            :    Instead we have an array of lists of free PHI nodes.  The array is
      50                 :            :    indexed by the number of PHI alternatives that PHI node can hold.
      51                 :            :    Except for the last array member, which holds all remaining PHI
      52                 :            :    nodes.
      53                 :            : 
      54                 :            :    So to find a free PHI node, we compute its index into the free PHI
      55                 :            :    node array and see if there are any elements with an exact match.
      56                 :            :    If so, then we are done.  Otherwise, we test the next larger size
      57                 :            :    up and continue until we are in the last array element.
      58                 :            : 
      59                 :            :    We do not actually walk members of the last array element.  While it
      60                 :            :    might allow us to pick up a few reusable PHI nodes, it could potentially
      61                 :            :    be very expensive if the program has released a bunch of large PHI nodes,
      62                 :            :    but keeps asking for even larger PHI nodes.  Experiments have shown that
      63                 :            :    walking the elements of the last array entry would result in finding less
      64                 :            :    than .1% additional reusable PHI nodes.
      65                 :            : 
      66                 :            :    Note that we can never have less than two PHI argument slots.  Thus,
      67                 :            :    the -2 on all the calculations below.  */
      68                 :            : 
      69                 :            : #define NUM_BUCKETS 10
      70                 :            : static GTY ((deletable (""))) vec<gimple *, va_gc> *free_phinodes[NUM_BUCKETS - 2];
      71                 :            : static unsigned long free_phinode_count;
      72                 :            : 
      73                 :            : static int ideal_phi_node_len (int);
      74                 :            : 
      75                 :            : unsigned int phi_nodes_reused;
      76                 :            : unsigned int phi_nodes_created;
      77                 :            : 
      78                 :            : /* Dump some simple statistics regarding the re-use of PHI nodes.  */
      79                 :            : 
      80                 :            : void
      81                 :          0 : phinodes_print_statistics (void)
      82                 :            : {
      83                 :          0 :   fprintf (stderr, "%-32s" PRsa (11) "\n", "PHI nodes allocated:",
      84                 :          0 :            SIZE_AMOUNT (phi_nodes_created));
      85                 :          0 :   fprintf (stderr, "%-32s" PRsa (11) "\n", "PHI nodes reused:",
      86                 :          0 :            SIZE_AMOUNT (phi_nodes_reused));
      87                 :          0 : }
      88                 :            : 
      89                 :            : /* Allocate a PHI node with at least LEN arguments.  If the free list
      90                 :            :    happens to contain a PHI node with LEN arguments or more, return
      91                 :            :    that one.  */
      92                 :            : 
      93                 :            : static inline gphi *
      94                 :   11408900 : allocate_phi_node (size_t len)
      95                 :            : {
      96                 :   11408900 :   gphi *phi;
      97                 :   11408900 :   size_t bucket = NUM_BUCKETS - 2;
      98                 :   11408900 :   size_t size = sizeof (struct gphi)
      99                 :   11408900 :                 + (len - 1) * sizeof (struct phi_arg_d);
     100                 :            : 
     101                 :   11408900 :   if (free_phinode_count)
     102                 :   12389000 :     for (bucket = len - 2; bucket < NUM_BUCKETS - 2; bucket++)
     103                 :   11352700 :       if (free_phinodes[bucket])
     104                 :            :         break;
     105                 :            : 
     106                 :            :   /* If our free list has an element, then use it.  */
     107                 :    6955130 :   if (bucket < NUM_BUCKETS - 2
     108                 :    6955130 :       && gimple_phi_capacity ((*free_phinodes[bucket])[0]) >= len)
     109                 :            :     {
     110                 :    5918820 :       free_phinode_count--;
     111                 :    5918820 :       phi = as_a <gphi *> (free_phinodes[bucket]->pop ());
     112                 :    5918820 :       if (free_phinodes[bucket]->is_empty ())
     113                 :     281231 :         vec_free (free_phinodes[bucket]);
     114                 :            :       if (GATHER_STATISTICS)
     115                 :            :         phi_nodes_reused++;
     116                 :            :     }
     117                 :            :   else
     118                 :            :     {
     119                 :    5490120 :       phi = static_cast <gphi *> (ggc_internal_alloc (size));
     120                 :    5490120 :       if (GATHER_STATISTICS)
     121                 :            :         {
     122                 :            :           enum gimple_alloc_kind kind = gimple_alloc_kind (GIMPLE_PHI);
     123                 :            :           phi_nodes_created++;
     124                 :            :           gimple_alloc_counts[(int) kind]++;
     125                 :            :           gimple_alloc_sizes[(int) kind] += size;
     126                 :            :         }
     127                 :            :     }
     128                 :            : 
     129                 :   11408900 :   return phi;
     130                 :            : }
     131                 :            : 
     132                 :            : /* Given LEN, the original number of requested PHI arguments, return
     133                 :            :    a new, "ideal" length for the PHI node.  The "ideal" length rounds
     134                 :            :    the total size of the PHI node up to the next power of two bytes.
     135                 :            : 
     136                 :            :    Rounding up will not result in wasting any memory since the size request
     137                 :            :    will be rounded up by the GC system anyway.  [ Note this is not entirely
     138                 :            :    true since the original length might have fit on one of the special
     139                 :            :    GC pages. ]  By rounding up, we may avoid the need to reallocate the
     140                 :            :    PHI node later if we increase the number of arguments for the PHI.  */
     141                 :            : 
     142                 :            : static int
     143                 :   37049500 : ideal_phi_node_len (int len)
     144                 :            : {
     145                 :   37049500 :   size_t size, new_size;
     146                 :   37049500 :   int log2, new_len;
     147                 :            : 
     148                 :            :   /* We do not support allocations of less than two PHI argument slots.  */
     149                 :   37049500 :   if (len < 2)
     150                 :            :     len = 2;
     151                 :            : 
     152                 :            :   /* Compute the number of bytes of the original request.  */
     153                 :   37049500 :   size = sizeof (struct gphi)
     154                 :   37049500 :          + (len - 1) * sizeof (struct phi_arg_d);
     155                 :            : 
     156                 :            :   /* Round it up to the next power of two.  */
     157                 :   37049500 :   log2 = ceil_log2 (size);
     158                 :   37049500 :   new_size = 1 << log2;
     159                 :            : 
     160                 :            :   /* Now compute and return the number of PHI argument slots given an
     161                 :            :      ideal size allocation.  */
     162                 :   37049500 :   new_len = len + (new_size - size) / sizeof (struct phi_arg_d);
     163                 :   37049500 :   return new_len;
     164                 :            : }
     165                 :            : 
     166                 :            : /* Return a PHI node with LEN argument slots for variable VAR.  */
     167                 :            : 
     168                 :            : static gphi *
     169                 :   11035300 : make_phi_node (tree var, int len)
     170                 :            : {
     171                 :   11035300 :   gphi *phi;
     172                 :   11035300 :   int capacity, i;
     173                 :            : 
     174                 :   11035300 :   capacity = ideal_phi_node_len (len);
     175                 :            : 
     176                 :   11035300 :   phi = allocate_phi_node (capacity);
     177                 :            : 
     178                 :            :   /* We need to clear the entire PHI node, including the argument
     179                 :            :      portion, because we represent a "missing PHI argument" by placing
     180                 :            :      NULL_TREE in PHI_ARG_DEF.  */
     181                 :   11035300 :   memset (phi, 0, (sizeof (struct gphi)
     182                 :            :                    - sizeof (struct phi_arg_d)
     183                 :   11035300 :                    + sizeof (struct phi_arg_d) * len));
     184                 :   11035300 :   phi->code = GIMPLE_PHI;
     185                 :   11035300 :   gimple_init_singleton (phi);
     186                 :   11035300 :   phi->nargs = len;
     187                 :   11035300 :   phi->capacity = capacity;
     188                 :   11035300 :   if (!var)
     189                 :            :     ;
     190                 :    7579660 :   else if (TREE_CODE (var) == SSA_NAME)
     191                 :    3341300 :     gimple_phi_set_result (phi, var);
     192                 :            :   else
     193                 :    4238360 :     gimple_phi_set_result (phi, make_ssa_name (var, phi));
     194                 :            : 
     195                 :   30221500 :   for (i = 0; i < len; i++)
     196                 :            :     {
     197                 :   19186200 :       use_operand_p  imm;
     198                 :            : 
     199                 :   19186200 :       gimple_phi_arg_set_location (phi, i, UNKNOWN_LOCATION);
     200                 :   19186200 :       imm = gimple_phi_arg_imm_use_ptr (phi, i);
     201                 :   19186200 :       imm->use = gimple_phi_arg_def_ptr (phi, i);
     202                 :   19186200 :       imm->prev = NULL;
     203                 :   19186200 :       imm->next = NULL;
     204                 :   19186200 :       imm->loc.stmt = phi;
     205                 :            :     }
     206                 :            : 
     207                 :   11035300 :   return phi;
     208                 :            : }
     209                 :            : 
     210                 :            : /* We no longer need PHI, release it so that it may be reused.  */
     211                 :            : 
     212                 :            : static void
     213                 :    9048410 : release_phi_node (gimple *phi)
     214                 :            : {
     215                 :    9048410 :   size_t bucket;
     216                 :    9048410 :   size_t len = gimple_phi_capacity (phi);
     217                 :    9048410 :   size_t x;
     218                 :            : 
     219                 :   23253400 :   for (x = 0; x < gimple_phi_num_args (phi); x++)
     220                 :            :     {
     221                 :   14205000 :       use_operand_p  imm;
     222                 :   14205000 :       imm = gimple_phi_arg_imm_use_ptr (phi, x);
     223                 :   14205000 :       delink_imm_use (imm);
     224                 :            :     }
     225                 :            : 
     226                 :    9048410 :   bucket = len > NUM_BUCKETS - 1 ? NUM_BUCKETS - 1 : len;
     227                 :    9048410 :   bucket -= 2;
     228                 :    9048410 :   vec_safe_push (free_phinodes[bucket], phi);
     229                 :    9048410 :   free_phinode_count++;
     230                 :    9048410 : }
     231                 :            : 
     232                 :            : 
     233                 :            : /* Resize an existing PHI node.  The only way is up.  Return the
     234                 :            :    possibly relocated phi.  */
     235                 :            : 
     236                 :            : static gphi *
     237                 :     373635 : resize_phi_node (gphi *phi, size_t len)
     238                 :            : {
     239                 :     373635 :   size_t old_size, i;
     240                 :     373635 :   gphi *new_phi;
     241                 :            : 
     242                 :     373635 :   gcc_assert (len > gimple_phi_capacity (phi));
     243                 :            : 
     244                 :            :   /* The garbage collector will not look at the PHI node beyond the
     245                 :            :      first PHI_NUM_ARGS elements.  Therefore, all we have to copy is a
     246                 :            :      portion of the PHI node currently in use.  */
     247                 :     373635 :   old_size = sizeof (struct gphi)
     248                 :     373635 :              + (gimple_phi_num_args (phi) - 1) * sizeof (struct phi_arg_d);
     249                 :            : 
     250                 :     373635 :   new_phi = allocate_phi_node (len);
     251                 :            : 
     252                 :     373635 :   memcpy (new_phi, phi, old_size);
     253                 :     373635 :   memset ((char *)new_phi + old_size, 0,
     254                 :            :           (sizeof (struct gphi)
     255                 :            :            - sizeof (struct phi_arg_d)
     256                 :     373635 :            + sizeof (struct phi_arg_d) * len) - old_size);
     257                 :            : 
     258                 :    2678430 :   for (i = 0; i < gimple_phi_num_args (new_phi); i++)
     259                 :            :     {
     260                 :    2304790 :       use_operand_p imm, old_imm;
     261                 :    2304790 :       imm = gimple_phi_arg_imm_use_ptr (new_phi, i);
     262                 :    2304790 :       old_imm = gimple_phi_arg_imm_use_ptr (phi, i);
     263                 :    2304790 :       imm->use = gimple_phi_arg_def_ptr (new_phi, i);
     264                 :    2304790 :       relink_imm_use_stmt (imm, old_imm, new_phi);
     265                 :            :     }
     266                 :            : 
     267                 :     373635 :   new_phi->capacity = len;
     268                 :            : 
     269                 :     373635 :   return new_phi;
     270                 :            : }
     271                 :            : 
     272                 :            : /* Reserve PHI arguments for a new edge to basic block BB.  */
     273                 :            : 
     274                 :            : void
     275                 :   26014200 : reserve_phi_args_for_new_edge (basic_block bb)
     276                 :            : {
     277                 :   26014200 :   size_t len = EDGE_COUNT (bb->preds);
     278                 :   26014200 :   size_t cap = ideal_phi_node_len (len + 4);
     279                 :   26014200 :   gphi_iterator gsi;
     280                 :            : 
     281                 :   73537800 :   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     282                 :            :     {
     283                 :   47523600 :       gphi *stmt = gsi.phi ();
     284                 :            : 
     285                 :   47523600 :       if (len > gimple_phi_capacity (stmt))
     286                 :            :         {
     287                 :     373635 :           gphi *new_phi = resize_phi_node (stmt, cap);
     288                 :            : 
     289                 :            :           /* The result of the PHI is defined by this PHI node.  */
     290                 :     373635 :           SSA_NAME_DEF_STMT (gimple_phi_result (new_phi)) = new_phi;
     291                 :     373635 :           gsi_set_stmt (&gsi, new_phi);
     292                 :            : 
     293                 :     373635 :           release_phi_node (stmt);
     294                 :     373635 :           stmt = new_phi;
     295                 :            :         }
     296                 :            : 
     297                 :   47523600 :       stmt->nargs++;
     298                 :            : 
     299                 :            :       /* We represent a "missing PHI argument" by placing NULL_TREE in
     300                 :            :          the corresponding slot.  If PHI arguments were added
     301                 :            :          immediately after an edge is created, this zeroing would not
     302                 :            :          be necessary, but unfortunately this is not the case.  For
     303                 :            :          example, the loop optimizer duplicates several basic blocks,
     304                 :            :          redirects edges, and then fixes up PHI arguments later in
     305                 :            :          batch.  */
     306                 :   47523600 :       use_operand_p imm = gimple_phi_arg_imm_use_ptr (stmt, len - 1);
     307                 :   47523600 :       imm->use = gimple_phi_arg_def_ptr (stmt, len - 1);
     308                 :   47523600 :       imm->prev = NULL;
     309                 :   47523600 :       imm->next = NULL;
     310                 :   47523600 :       imm->loc.stmt = stmt;
     311                 :   47523600 :       SET_PHI_ARG_DEF (stmt, len - 1, NULL_TREE);
     312                 :   47523600 :       gimple_phi_arg_set_location (stmt, len - 1, UNKNOWN_LOCATION);
     313                 :            :     }
     314                 :   26014200 : }
     315                 :            : 
     316                 :            : /* Adds PHI to BB.  */
     317                 :            : 
     318                 :            : void
     319                 :   11035300 : add_phi_node_to_bb (gphi *phi, basic_block bb)
     320                 :            : {
     321                 :   11035300 :   gimple_seq seq = phi_nodes (bb);
     322                 :            :   /* Add the new PHI node to the list of PHI nodes for block BB.  */
     323                 :   11035300 :   if (seq == NULL)
     324                 :    6244140 :     set_phi_nodes (bb, gimple_seq_alloc_with_stmt (phi));
     325                 :            :   else
     326                 :            :     {
     327                 :    4791170 :       gimple_seq_add_stmt (&seq, phi);
     328                 :    4791170 :       gcc_assert (seq == phi_nodes (bb));
     329                 :            :     }
     330                 :            : 
     331                 :            :   /* Associate BB to the PHI node.  */
     332                 :   11035300 :   gimple_set_bb (phi, bb);
     333                 :            : 
     334                 :   11035300 : }
     335                 :            : 
     336                 :            : /* Create a new PHI node for variable VAR at basic block BB.  */
     337                 :            : 
     338                 :            : gphi *
     339                 :   11035300 : create_phi_node (tree var, basic_block bb)
     340                 :            : {
     341                 :   19648100 :   gphi *phi = make_phi_node (var, EDGE_COUNT (bb->preds));
     342                 :            : 
     343                 :   11035300 :   add_phi_node_to_bb (phi, bb);
     344                 :   11035300 :   return phi;
     345                 :            : }
     346                 :            : 
     347                 :            : 
     348                 :            : /* Add a new argument to PHI node PHI.  DEF is the incoming reaching
     349                 :            :    definition and E is the edge through which DEF reaches PHI.  The new
     350                 :            :    argument is added at the end of the argument list.
     351                 :            :    If PHI has reached its maximum capacity, add a few slots.  In this case,
     352                 :            :    PHI points to the reallocated phi node when we return.  */
     353                 :            : 
     354                 :            : void
     355                 :   62251000 : add_phi_arg (gphi *phi, tree def, edge e, location_t locus)
     356                 :            : {
     357                 :   62251000 :   basic_block bb = e->dest;
     358                 :            : 
     359                 :   62251000 :   gcc_assert (bb == gimple_bb (phi));
     360                 :            : 
     361                 :            :   /* We resize PHI nodes upon edge creation.  We should always have
     362                 :            :      enough room at this point.  */
     363                 :   62251000 :   gcc_assert (gimple_phi_num_args (phi) <= gimple_phi_capacity (phi));
     364                 :            : 
     365                 :            :   /* We resize PHI nodes upon edge creation.  We should always have
     366                 :            :      enough room at this point.  */
     367                 :   62251000 :   gcc_assert (e->dest_idx < gimple_phi_num_args (phi));
     368                 :            : 
     369                 :            :   /* Copy propagation needs to know what object occur in abnormal
     370                 :            :      PHI nodes.  This is a convenient place to record such information.  */
     371                 :   62251000 :   if (e->flags & EDGE_ABNORMAL)
     372                 :            :     {
     373                 :     200566 :       SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def) = 1;
     374                 :     200566 :       SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)) = 1;
     375                 :            :     }
     376                 :            : 
     377                 :   62251000 :   SET_PHI_ARG_DEF (phi, e->dest_idx, def);
     378                 :   62251000 :   gimple_phi_arg_set_location (phi, e->dest_idx, locus);
     379                 :   62251000 : }
     380                 :            : 
     381                 :            : 
     382                 :            : /* Remove the Ith argument from PHI's argument list.  This routine
     383                 :            :    implements removal by swapping the last alternative with the
     384                 :            :    alternative we want to delete and then shrinking the vector, which
     385                 :            :    is consistent with how we remove an edge from the edge vector.  */
     386                 :            : 
     387                 :            : static void
     388                 :   49272200 : remove_phi_arg_num (gphi *phi, int i)
     389                 :            : {
     390                 :   49272200 :   int num_elem = gimple_phi_num_args (phi);
     391                 :            : 
     392                 :   49272200 :   gcc_assert (i < num_elem);
     393                 :            : 
     394                 :            :   /* Delink the item which is being removed.  */
     395                 :   49272200 :   delink_imm_use (gimple_phi_arg_imm_use_ptr (phi, i));
     396                 :            : 
     397                 :            :   /* If it is not the last element, move the last element
     398                 :            :      to the element we want to delete, resetting all the links. */
     399                 :   49272200 :   if (i != num_elem - 1)
     400                 :            :     {
     401                 :   38720700 :       use_operand_p old_p, new_p;
     402                 :   38720700 :       old_p = gimple_phi_arg_imm_use_ptr (phi, num_elem - 1);
     403                 :   38720700 :       new_p = gimple_phi_arg_imm_use_ptr (phi, i);
     404                 :            :       /* Set use on new node, and link into last element's place.  */
     405                 :   38720700 :       *(new_p->use) = *(old_p->use);
     406                 :   38720700 :       relink_imm_use (new_p, old_p);
     407                 :            :       /* Move the location as well.  */
     408                 :   38720700 :       gimple_phi_arg_set_location (phi, i,
     409                 :            :                                    gimple_phi_arg_location (phi, num_elem - 1));
     410                 :            :     }
     411                 :            : 
     412                 :            :   /* Shrink the vector and return.  Note that we do not have to clear
     413                 :            :      PHI_ARG_DEF because the garbage collector will not look at those
     414                 :            :      elements beyond the first PHI_NUM_ARGS elements of the array.  */
     415                 :   49272200 :   phi->nargs--;
     416                 :   49272200 : }
     417                 :            : 
     418                 :            : 
     419                 :            : /* Remove all PHI arguments associated with edge E.  */
     420                 :            : 
     421                 :            : void
     422                 :   27944000 : remove_phi_args (edge e)
     423                 :            : {
     424                 :   27944000 :   gphi_iterator gsi;
     425                 :            : 
     426                 :   77216200 :   for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     427                 :   49272200 :     remove_phi_arg_num (gsi.phi (),
     428                 :   49272200 :                         e->dest_idx);
     429                 :   27944000 : }
     430                 :            : 
     431                 :            : 
     432                 :            : /* Remove the PHI node pointed-to by iterator GSI from basic block BB.  After
     433                 :            :    removal, iterator GSI is updated to point to the next PHI node in the
     434                 :            :    sequence. If RELEASE_LHS_P is true, the LHS of this PHI node is released
     435                 :            :    into the free pool of SSA names.  */
     436                 :            : 
     437                 :            : void
     438                 :    8674770 : remove_phi_node (gimple_stmt_iterator *gsi, bool release_lhs_p)
     439                 :            : {
     440                 :    8674770 :   gimple *phi = gsi_stmt (*gsi);
     441                 :            : 
     442                 :    8674770 :   if (release_lhs_p)
     443                 :    8606010 :     insert_debug_temps_for_defs (gsi);
     444                 :            : 
     445                 :    8674770 :   gsi_remove (gsi, false);
     446                 :            : 
     447                 :            :   /* If we are deleting the PHI node, then we should release the
     448                 :            :      SSA_NAME node so that it can be reused.  */
     449                 :    8674770 :   release_phi_node (phi);
     450                 :    8674770 :   if (release_lhs_p)
     451                 :    8606010 :     release_ssa_name (gimple_phi_result (phi));
     452                 :    8674770 : }
     453                 :            : 
     454                 :            : /* Remove all the phi nodes from BB.  */
     455                 :            : 
     456                 :            : void
     457                 :   18375100 : remove_phi_nodes (basic_block bb)
     458                 :            : {
     459                 :   18375100 :   gphi_iterator gsi;
     460                 :            : 
     461                 :   19329700 :   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); )
     462                 :     954600 :     remove_phi_node (&gsi, true);
     463                 :            : 
     464                 :   18375100 :   set_phi_nodes (bb, NULL);
     465                 :   18375100 : }
     466                 :            : 
     467                 :            : /* Given PHI, return its RHS if the PHI is a degenerate, otherwise return
     468                 :            :    NULL.  */
     469                 :            : 
     470                 :            : tree
     471                 :    2697930 : degenerate_phi_result (gphi *phi)
     472                 :            : {
     473                 :    2697930 :   tree lhs = gimple_phi_result (phi);
     474                 :    2697930 :   tree val = NULL;
     475                 :    2697930 :   size_t i;
     476                 :            : 
     477                 :            :   /* Ignoring arguments which are the same as LHS, if all the remaining
     478                 :            :      arguments are the same, then the PHI is a degenerate and has the
     479                 :            :      value of that common argument.  */
     480                 :    5519980 :   for (i = 0; i < gimple_phi_num_args (phi); i++)
     481                 :            :     {
     482                 :    5316110 :       tree arg = gimple_phi_arg_def (phi, i);
     483                 :            : 
     484                 :    5316110 :       if (arg == lhs)
     485                 :        672 :         continue;
     486                 :    5315440 :       else if (!arg)
     487                 :            :         break;
     488                 :    5315440 :       else if (!val)
     489                 :            :         val = arg;
     490                 :    2617860 :       else if (arg == val)
     491                 :     122904 :         continue;
     492                 :            :       /* We bring in some of operand_equal_p not only to speed things
     493                 :            :          up, but also to avoid crashing when dereferencing the type of
     494                 :            :          a released SSA name.  */
     495                 :    2494960 :       else if (TREE_CODE (val) != TREE_CODE (arg)
     496                 :     861150 :                || TREE_CODE (val) == SSA_NAME
     497                 :    2528760 :                || !operand_equal_p (arg, val, 0))
     498                 :            :         break;
     499                 :            :     }
     500                 :    2697930 :   return (i == gimple_phi_num_args (phi) ? val : NULL);
     501                 :            : }
     502                 :            : 
     503                 :            : /* Set PHI nodes of a basic block BB to SEQ.  */
     504                 :            : 
     505                 :            : void
     506                 :   25497200 : set_phi_nodes (basic_block bb, gimple_seq seq)
     507                 :            : {
     508                 :   25497200 :   gimple_stmt_iterator i;
     509                 :            : 
     510                 :   25497200 :   gcc_checking_assert (!(bb->flags & BB_RTL));
     511                 :   25497200 :   bb->il.gimple.phi_nodes = seq;
     512                 :   25497200 :   if (seq)
     513                 :   12488300 :     for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
     514                 :    6244140 :       gimple_set_bb (gsi_stmt (i), bb);
     515                 :   25497200 : }
     516                 :            : 
     517                 :            : #include "gt-tree-phinodes.h"

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.