LCOV - code coverage report
Current view: top level - gcc - tree-ssa-phiprop.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 198 207 95.7 %
Date: 2020-04-04 11:58:09 Functions: 7 7 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Backward propagation of indirect loads through PHIs.
       2                 :            :    Copyright (C) 2007-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Richard Guenther <rguenther@suse.de>
       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 "tree.h"
      26                 :            : #include "gimple.h"
      27                 :            : #include "tree-pass.h"
      28                 :            : #include "ssa.h"
      29                 :            : #include "gimple-pretty-print.h"
      30                 :            : #include "fold-const.h"
      31                 :            : #include "tree-eh.h"
      32                 :            : #include "gimplify.h"
      33                 :            : #include "gimple-iterator.h"
      34                 :            : #include "stor-layout.h"
      35                 :            : #include "tree-ssa-loop.h"
      36                 :            : 
      37                 :            : /* This pass propagates indirect loads through the PHI node for its
      38                 :            :    address to make the load source possibly non-addressable and to
      39                 :            :    allow for PHI optimization to trigger.
      40                 :            : 
      41                 :            :    For example the pass changes
      42                 :            : 
      43                 :            :      # addr_1 = PHI <&a, &b>
      44                 :            :      tmp_1 = *addr_1;
      45                 :            : 
      46                 :            :    to
      47                 :            : 
      48                 :            :      # tmp_1 = PHI <a, b>
      49                 :            : 
      50                 :            :    but also handles more complex scenarios like
      51                 :            : 
      52                 :            :      D.2077_2 = &this_1(D)->a1;
      53                 :            :      ...
      54                 :            : 
      55                 :            :      # b_12 = PHI <&c(2), D.2077_2(3)>
      56                 :            :      D.2114_13 = *b_12;
      57                 :            :      ...
      58                 :            : 
      59                 :            :      # b_15 = PHI <b_12(4), &b(5)>
      60                 :            :      D.2080_5 = &this_1(D)->a0;
      61                 :            :      ...
      62                 :            : 
      63                 :            :      # b_18 = PHI <D.2080_5(6), &c(7)>
      64                 :            :      ...
      65                 :            : 
      66                 :            :      # b_21 = PHI <b_15(8), b_18(9)>
      67                 :            :      D.2076_8 = *b_21;
      68                 :            : 
      69                 :            :    where the addresses loaded are defined by PHIs itself.
      70                 :            :    The above happens for
      71                 :            : 
      72                 :            :      std::max(std::min(a0, c), std::min(std::max(a1, c), b))
      73                 :            : 
      74                 :            :    where this pass transforms it to a form later PHI optimization
      75                 :            :    recognizes and transforms it to the simple
      76                 :            : 
      77                 :            :      D.2109_10 = this_1(D)->a1;
      78                 :            :      D.2110_11 = c;
      79                 :            :      D.2114_31 = MAX_EXPR <D.2109_10, D.2110_11>;
      80                 :            :      D.2115_14 = b;
      81                 :            :      D.2125_17 = MIN_EXPR <D.2115_14, D.2114_31>;
      82                 :            :      D.2119_16 = this_1(D)->a0;
      83                 :            :      D.2124_32 = MIN_EXPR <D.2110_11, D.2119_16>;
      84                 :            :      D.2076_33 = MAX_EXPR <D.2125_17, D.2124_32>;
      85                 :            : 
      86                 :            :    The pass does a dominator walk processing loads using a basic-block
      87                 :            :    local analysis and stores the result for use by transformations on
      88                 :            :    dominated basic-blocks.  */
      89                 :            : 
      90                 :            : 
      91                 :            : /* Structure to keep track of the value of a dereferenced PHI result
      92                 :            :    and the virtual operand used for that dereference.  */
      93                 :            : 
      94                 :            : struct phiprop_d
      95                 :            : {
      96                 :            :   tree value;
      97                 :            :   tree vuse;
      98                 :            : };
      99                 :            : 
     100                 :            : /* Verify if the value recorded for NAME in PHIVN is still valid at
     101                 :            :    the start of basic block BB.  */
     102                 :            : 
     103                 :            : static bool
     104                 :        211 : phivn_valid_p (struct phiprop_d *phivn, tree name, basic_block bb)
     105                 :            : {
     106                 :        211 :   tree vuse = phivn[SSA_NAME_VERSION (name)].vuse;
     107                 :        211 :   gimple *use_stmt;
     108                 :        211 :   imm_use_iterator ui2;
     109                 :        211 :   bool ok = true;
     110                 :            : 
     111                 :            :   /* The def stmts of the virtual uses need to be dominated by bb.  */
     112                 :        211 :   gcc_assert (vuse != NULL_TREE);
     113                 :            : 
     114                 :        714 :   FOR_EACH_IMM_USE_STMT (use_stmt, ui2, vuse)
     115                 :            :     {
     116                 :            :       /* If BB does not dominate a VDEF, the value is invalid.  */
     117                 :       1055 :       if ((gimple_vdef (use_stmt) != NULL_TREE
     118                 :        438 :            || gimple_code (use_stmt) == GIMPLE_PHI)
     119                 :        617 :           && !dominated_by_p (CDI_DOMINATORS, gimple_bb (use_stmt), bb))
     120                 :            :         {
     121                 :        114 :           ok = false;
     122                 :        617 :           BREAK_FROM_IMM_USE_STMT (ui2);
     123                 :            :         }
     124                 :            :     }
     125                 :            : 
     126                 :        211 :   return ok;
     127                 :            : }
     128                 :            : 
     129                 :            : /* Insert a new phi node for the dereference of PHI at basic_block
     130                 :            :    BB with the virtual operands from USE_STMT.  */
     131                 :            : 
     132                 :            : static tree
     133                 :       6815 : phiprop_insert_phi (basic_block bb, gphi *phi, gimple *use_stmt,
     134                 :            :                     struct phiprop_d *phivn, size_t n)
     135                 :            : {
     136                 :       6815 :   tree res;
     137                 :       6815 :   gphi *new_phi = NULL;
     138                 :       6815 :   edge_iterator ei;
     139                 :       6815 :   edge e;
     140                 :            : 
     141                 :       6815 :   gcc_assert (is_gimple_assign (use_stmt)
     142                 :            :               && gimple_assign_rhs_code (use_stmt) == MEM_REF);
     143                 :            : 
     144                 :            :   /* Build a new PHI node to replace the definition of
     145                 :            :      the indirect reference lhs.  */
     146                 :       6815 :   res = gimple_assign_lhs (use_stmt);
     147                 :       6815 :   if (TREE_CODE (res) == SSA_NAME)
     148                 :       6801 :     new_phi = create_phi_node (res, bb);
     149                 :            : 
     150                 :       6815 :   if (dump_file && (dump_flags & TDF_DETAILS))
     151                 :            :     {
     152                 :          1 :       fprintf (dump_file, "Inserting PHI for result of load ");
     153                 :          1 :       print_gimple_stmt (dump_file, use_stmt, 0);
     154                 :            :     }
     155                 :            : 
     156                 :            :   /* Add PHI arguments for each edge inserting loads of the
     157                 :            :      addressable operands.  */
     158                 :      20458 :   FOR_EACH_EDGE (e, ei, bb->preds)
     159                 :            :     {
     160                 :      13643 :       tree old_arg, new_var;
     161                 :      13643 :       gassign *tmp;
     162                 :      13643 :       location_t locus;
     163                 :            : 
     164                 :      13643 :       old_arg = PHI_ARG_DEF_FROM_EDGE (phi, e);
     165                 :      13643 :       locus = gimple_phi_arg_location_from_edge (phi, e);
     166                 :      14403 :       while (TREE_CODE (old_arg) == SSA_NAME
     167                 :      14403 :              && (SSA_NAME_VERSION (old_arg) >= n
     168                 :        832 :                  || phivn[SSA_NAME_VERSION (old_arg)].value == NULL_TREE))
     169                 :            :         {
     170                 :        760 :           gimple *def_stmt = SSA_NAME_DEF_STMT (old_arg);
     171                 :        760 :           old_arg = gimple_assign_rhs1 (def_stmt);
     172                 :        760 :           locus = gimple_location (def_stmt);
     173                 :            :         }
     174                 :            : 
     175                 :      13643 :       if (TREE_CODE (old_arg) == SSA_NAME)
     176                 :            :         {
     177                 :         72 :           if (dump_file && (dump_flags & TDF_DETAILS))
     178                 :            :             {
     179                 :          0 :               fprintf (dump_file, "  for edge defining ");
     180                 :          0 :               print_generic_expr (dump_file, PHI_ARG_DEF_FROM_EDGE (phi, e));
     181                 :          0 :               fprintf (dump_file, " reusing PHI result ");
     182                 :          0 :               print_generic_expr (dump_file,
     183                 :          0 :                                   phivn[SSA_NAME_VERSION (old_arg)].value);
     184                 :          0 :               fprintf (dump_file, "\n");
     185                 :            :             }
     186                 :            :           /* Reuse a formerly created dereference.  */
     187                 :         72 :           new_var = phivn[SSA_NAME_VERSION (old_arg)].value;
     188                 :            :         }
     189                 :            :       else
     190                 :            :         {
     191                 :      13571 :           tree rhs = gimple_assign_rhs1 (use_stmt);
     192                 :      13571 :           gcc_assert (TREE_CODE (old_arg) == ADDR_EXPR);
     193                 :      13571 :           if (TREE_CODE (res) == SSA_NAME)
     194                 :      13539 :             new_var = make_ssa_name (TREE_TYPE (rhs));
     195                 :            :           else
     196                 :         32 :             new_var = unshare_expr (res);
     197                 :      13571 :           if (!is_gimple_min_invariant (old_arg))
     198                 :        744 :             old_arg = PHI_ARG_DEF_FROM_EDGE (phi, e);
     199                 :            :           else
     200                 :      12827 :             old_arg = unshare_expr (old_arg);
     201                 :      27142 :           tmp = gimple_build_assign (new_var,
     202                 :      27142 :                                      fold_build2 (MEM_REF, TREE_TYPE (rhs),
     203                 :            :                                                   old_arg,
     204                 :            :                                                   TREE_OPERAND (rhs, 1)));
     205                 :      13571 :           gimple_set_location (tmp, locus);
     206                 :            : 
     207                 :      13571 :           gsi_insert_on_edge (e, tmp);
     208                 :      13571 :           update_stmt (tmp);
     209                 :            : 
     210                 :      13571 :           if (dump_file && (dump_flags & TDF_DETAILS))
     211                 :            :             {
     212                 :          2 :               fprintf (dump_file, "  for edge defining ");
     213                 :          2 :               print_generic_expr (dump_file, PHI_ARG_DEF_FROM_EDGE (phi, e));
     214                 :          2 :               fprintf (dump_file, " inserting load ");
     215                 :          2 :               print_gimple_stmt (dump_file, tmp, 0);
     216                 :            :             }
     217                 :            :         }
     218                 :            : 
     219                 :      13643 :       if (new_phi)
     220                 :      13611 :         add_phi_arg (new_phi, new_var, e, locus);
     221                 :            :     }
     222                 :            : 
     223                 :       6815 :   if (new_phi)
     224                 :            :     {
     225                 :       6801 :       update_stmt (new_phi);
     226                 :            : 
     227                 :       6801 :       if (dump_file && (dump_flags & TDF_DETAILS))
     228                 :          1 :         print_gimple_stmt (dump_file, new_phi, 0);
     229                 :            :     }
     230                 :            : 
     231                 :       6815 :   return res;
     232                 :            : }
     233                 :            : 
     234                 :            : /* Verify if *idx is available at *DATA.  */
     235                 :            : 
     236                 :            : static bool
     237                 :         16 : chk_uses (tree, tree *idx, void *data)
     238                 :            : {
     239                 :         16 :   basic_block dom = (basic_block) data;
     240                 :         16 :   if (TREE_CODE (*idx) == SSA_NAME)
     241                 :          8 :     return (SSA_NAME_IS_DEFAULT_DEF (*idx)
     242                 :          8 :             || ! dominated_by_p (CDI_DOMINATORS,
     243                 :          8 :                                  gimple_bb (SSA_NAME_DEF_STMT (*idx)), dom));
     244                 :            :   return true;
     245                 :            : }
     246                 :            : 
     247                 :            : /* Propagate between the phi node arguments of PHI in BB and phi result
     248                 :            :    users.  For now this matches
     249                 :            :         # p_2 = PHI <&x, &y>
     250                 :            :       <Lx>:;
     251                 :            :         p_3 = p_2;
     252                 :            :         z_2 = *p_3;
     253                 :            :    and converts it to
     254                 :            :         # z_2 = PHI <x, y>
     255                 :            :       <Lx>:;
     256                 :            :    Returns true if a transformation was done and edge insertions
     257                 :            :    need to be committed.  Global data PHIVN and N is used to track
     258                 :            :    past transformation results.  We need to be especially careful here
     259                 :            :    with aliasing issues as we are moving memory reads.  */
     260                 :            : 
     261                 :            : static bool
     262                 :    2504920 : propagate_with_phi (basic_block bb, gphi *phi, struct phiprop_d *phivn,
     263                 :            :                     size_t n)
     264                 :            : {
     265                 :    2504920 :   tree ptr = PHI_RESULT (phi);
     266                 :    2504920 :   gimple *use_stmt;
     267                 :    2504920 :   tree res = NULL_TREE;
     268                 :    2504920 :   gimple_stmt_iterator gsi;
     269                 :    2504920 :   imm_use_iterator ui;
     270                 :    2504920 :   use_operand_p arg_p, use;
     271                 :    2504920 :   ssa_op_iter i;
     272                 :    2504920 :   bool phi_inserted;
     273                 :    2504920 :   bool changed;
     274                 :    2504920 :   tree type = NULL_TREE;
     275                 :            : 
     276                 :    4757060 :   if (!POINTER_TYPE_P (TREE_TYPE (ptr))
     277                 :    2513270 :       || (!is_gimple_reg_type (TREE_TYPE (TREE_TYPE (ptr)))
     278                 :     127862 :           && TYPE_MODE (TREE_TYPE (TREE_TYPE (ptr))) == BLKmode))
     279                 :            :     return false;
     280                 :            : 
     281                 :            :   /* Check if we can "cheaply" dereference all phi arguments.  */
     282                 :     205811 :   FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_USE)
     283                 :            :     {
     284                 :     194305 :       tree arg = USE_FROM_PTR (arg_p);
     285                 :            :       /* Walk the ssa chain until we reach a ssa name we already
     286                 :            :          created a value for or we reach a definition of the form
     287                 :            :          ssa_name_n = &var;  */
     288                 :     238559 :       while (TREE_CODE (arg) == SSA_NAME
     289                 :     141137 :              && !SSA_NAME_IS_DEFAULT_DEF (arg)
     290                 :     371101 :              && (SSA_NAME_VERSION (arg) >= n
     291                 :     132497 :                  || phivn[SSA_NAME_VERSION (arg)].value == NULL_TREE))
     292                 :            :         {
     293                 :     132331 :           gimple *def_stmt = SSA_NAME_DEF_STMT (arg);
     294                 :     132331 :           if (!gimple_assign_single_p (def_stmt))
     295                 :            :             return false;
     296                 :      44254 :           arg = gimple_assign_rhs1 (def_stmt);
     297                 :            :         }
     298                 :     106228 :       if (TREE_CODE (arg) != ADDR_EXPR
     299                 :     106439 :           && !(TREE_CODE (arg) == SSA_NAME
     300                 :       8806 :                && SSA_NAME_VERSION (arg) < n
     301                 :       8806 :                && phivn[SSA_NAME_VERSION (arg)].value != NULL_TREE
     302                 :        211 :                && (!type
     303                 :         10 :                    || types_compatible_p
     304                 :         10 :                        (type, TREE_TYPE (phivn[SSA_NAME_VERSION (arg)].value)))
     305                 :        211 :                && phivn_valid_p (phivn, arg, bb)))
     306                 :      70427 :         return false;
     307                 :      35801 :       if (!type
     308                 :      35787 :           && TREE_CODE (arg) == SSA_NAME)
     309                 :         87 :         type = TREE_TYPE (phivn[SSA_NAME_VERSION (arg)].value);
     310                 :            :     }
     311                 :            : 
     312                 :            :   /* Find a dereferencing use.  First follow (single use) ssa
     313                 :            :      copy chains for ptr.  */
     314                 :      11544 :   while (single_imm_use (ptr, &use, &use_stmt)
     315                 :      11544 :          && gimple_assign_ssa_name_copy_p (use_stmt))
     316                 :         38 :     ptr = gimple_assign_lhs (use_stmt);
     317                 :            : 
     318                 :            :   /* Replace the first dereference of *ptr if there is one and if we
     319                 :            :      can move the loads to the place of the ptr phi node.  */
     320                 :      11506 :   phi_inserted = false;
     321                 :      11506 :   changed = false;
     322                 :      27561 :   FOR_EACH_IMM_USE_STMT (use_stmt, ui, ptr)
     323                 :            :     {
     324                 :      16055 :       gimple *def_stmt;
     325                 :      16055 :       tree vuse;
     326                 :            : 
     327                 :            :       /* Only replace loads in blocks that post-dominate the PHI node.  That
     328                 :            :          makes sure we don't end up speculating loads.  */
     329                 :      16055 :       if (!dominated_by_p (CDI_POST_DOMINATORS,
     330                 :      16055 :                            bb, gimple_bb (use_stmt)))
     331                 :       2097 :         continue;
     332                 :            : 
     333                 :            :       /* Check whether this is a load of *ptr.  */
     334                 :      13958 :       if (!(is_gimple_assign (use_stmt)
     335                 :       7879 :             && gimple_assign_rhs_code (use_stmt) == MEM_REF
     336                 :       7018 :             && TREE_OPERAND (gimple_assign_rhs1 (use_stmt), 0) == ptr
     337                 :       7018 :             && integer_zerop (TREE_OPERAND (gimple_assign_rhs1 (use_stmt), 1))
     338                 :       7017 :             && (!type
     339                 :         68 :                 || types_compatible_p
     340                 :         68 :                      (TREE_TYPE (gimple_assign_lhs (use_stmt)), type))
     341                 :            :             /* We cannot replace a load that may throw or is volatile.
     342                 :            :                For volatiles the transform can change the number of
     343                 :            :                executions if the load is inside a loop but the address
     344                 :            :                computations outside (PR91812).  We could relax this
     345                 :            :                if we guard against that appropriately.  For loads that can
     346                 :            :                throw we could relax things if the moved loads all are
     347                 :            :                known to not throw.  */
     348                 :       7017 :             && !stmt_can_throw_internal (cfun, use_stmt)
     349                 :      14018 :             && !gimple_has_volatile_ops (use_stmt)))
     350                 :       6957 :         continue;
     351                 :            : 
     352                 :            :       /* Check if we can move the loads.  The def stmt of the virtual use
     353                 :            :          needs to be in a different basic block dominating bb.  When the
     354                 :            :          def is an edge-inserted one we know it dominates us.  */
     355                 :       7001 :       vuse = gimple_vuse (use_stmt);
     356                 :       7001 :       def_stmt = SSA_NAME_DEF_STMT (vuse);
     357                 :       7001 :       if (!SSA_NAME_IS_DEFAULT_DEF (vuse)
     358                 :       7001 :           && (gimple_bb (def_stmt) == bb
     359                 :       6524 :               || (gimple_bb (def_stmt)
     360                 :       6524 :                   && !dominated_by_p (CDI_DOMINATORS,
     361                 :       6524 :                                       bb, gimple_bb (def_stmt)))))
     362                 :        170 :         goto next;
     363                 :            : 
     364                 :            :       /* Found a proper dereference with an aggregate copy.  Just
     365                 :            :          insert aggregate copies on the edges instead.  */
     366                 :       6831 :       if (!is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (use_stmt))))
     367                 :            :         {
     368                 :         30 :           if (!gimple_vdef (use_stmt))
     369                 :         16 :             goto next;
     370                 :            : 
     371                 :            :           /* As we replicate the lhs on each incoming edge all
     372                 :            :              used SSA names have to be available there.  */
     373                 :         30 :           if (! for_each_index (gimple_assign_lhs_ptr (use_stmt),
     374                 :            :                                 chk_uses,
     375                 :         30 :                                 get_immediate_dominator (CDI_DOMINATORS,
     376                 :            :                                                          gimple_bb (phi))))
     377                 :          8 :             goto next;
     378                 :            : 
     379                 :         22 :           gimple *vuse_stmt;
     380                 :         22 :           imm_use_iterator vui;
     381                 :         22 :           use_operand_p vuse_p;
     382                 :            :           /* In order to move the aggregate copies earlier, make sure
     383                 :            :              there are no statements that could read from memory
     384                 :            :              aliasing the lhs in between the start of bb and use_stmt.
     385                 :            :              As we require use_stmt to have a VDEF above, loads after
     386                 :            :              use_stmt will use a different virtual SSA_NAME.  */
     387                 :         49 :           FOR_EACH_IMM_USE_FAST (vuse_p, vui, vuse)
     388                 :            :             {
     389                 :         35 :               vuse_stmt = USE_STMT (vuse_p);
     390                 :         35 :               if (vuse_stmt == use_stmt)
     391                 :         22 :                 continue;
     392                 :         13 :               if (!dominated_by_p (CDI_DOMINATORS,
     393                 :         13 :                                    gimple_bb (vuse_stmt), bb))
     394                 :          5 :                 continue;
     395                 :          8 :               if (ref_maybe_used_by_stmt_p (vuse_stmt,
     396                 :            :                                             gimple_assign_lhs (use_stmt)))
     397                 :          8 :                 goto next;
     398                 :            :             }
     399                 :            : 
     400                 :         14 :           phiprop_insert_phi (bb, phi, use_stmt, phivn, n);
     401                 :            : 
     402                 :            :           /* Remove old stmt.  The phi is taken care of by DCE.  */
     403                 :         14 :           gsi = gsi_for_stmt (use_stmt);
     404                 :            :           /* Unlinking the VDEF here is fine as we are sure that we process
     405                 :            :              stmts in execution order due to aggregate copies having VDEFs
     406                 :            :              and we emit loads on the edges in the very same order.
     407                 :            :              We get multiple copies (or intermediate register loads) handled
     408                 :            :              only by walking PHIs or immediate uses in a lucky order though,
     409                 :            :              so we could signal the caller to re-start iterating over PHIs
     410                 :            :              when we come here which would make it quadratic in the number
     411                 :            :              of PHIs.  */
     412                 :         14 :           unlink_stmt_vdef (use_stmt);
     413                 :         14 :           gsi_remove (&gsi, true);
     414                 :            : 
     415                 :         14 :           changed = true;
     416                 :            :         }
     417                 :            : 
     418                 :            :       /* Found a proper dereference.  Insert a phi node if this
     419                 :            :          is the first load transformation.  */
     420                 :       6801 :       else if (!phi_inserted)
     421                 :            :         {
     422                 :       6801 :           res = phiprop_insert_phi (bb, phi, use_stmt, phivn, n);
     423                 :       6801 :           type = TREE_TYPE (res);
     424                 :            : 
     425                 :            :           /* Remember the value we created for *ptr.  */
     426                 :       6801 :           phivn[SSA_NAME_VERSION (ptr)].value = res;
     427                 :       6801 :           phivn[SSA_NAME_VERSION (ptr)].vuse = vuse;
     428                 :            : 
     429                 :            :           /* Remove old stmt.  The phi is taken care of by DCE, if we
     430                 :            :              want to delete it here we also have to delete all intermediate
     431                 :            :              copies.  */
     432                 :       6801 :           gsi = gsi_for_stmt (use_stmt);
     433                 :       6801 :           gsi_remove (&gsi, true);
     434                 :            : 
     435                 :       6801 :           phi_inserted = true;
     436                 :       6801 :           changed = true;
     437                 :            :         }
     438                 :            :       else
     439                 :            :         {
     440                 :            :           /* Further replacements are easy, just make a copy out of the
     441                 :            :              load.  */
     442                 :          0 :           gimple_assign_set_rhs1 (use_stmt, res);
     443                 :          0 :           update_stmt (use_stmt);
     444                 :          0 :           changed = true;
     445                 :            :         }
     446                 :            : 
     447                 :      16055 : next:;
     448                 :            :       /* Continue searching for a proper dereference.  */
     449                 :            :     }
     450                 :            : 
     451                 :            :   return changed;
     452                 :            : }
     453                 :            : 
     454                 :            : /* Main entry for phiprop pass.  */
     455                 :            : 
     456                 :            : namespace {
     457                 :            : 
     458                 :            : const pass_data pass_data_phiprop =
     459                 :            : {
     460                 :            :   GIMPLE_PASS, /* type */
     461                 :            :   "phiprop", /* name */
     462                 :            :   OPTGROUP_NONE, /* optinfo_flags */
     463                 :            :   TV_TREE_PHIPROP, /* tv_id */
     464                 :            :   ( PROP_cfg | PROP_ssa ), /* properties_required */
     465                 :            :   0, /* properties_provided */
     466                 :            :   0, /* properties_destroyed */
     467                 :            :   0, /* todo_flags_start */
     468                 :            :   TODO_update_ssa, /* todo_flags_finish */
     469                 :            : };
     470                 :            : 
     471                 :            : class pass_phiprop : public gimple_opt_pass
     472                 :            : {
     473                 :            : public:
     474                 :     200773 :   pass_phiprop (gcc::context *ctxt)
     475                 :     401546 :     : gimple_opt_pass (pass_data_phiprop, ctxt)
     476                 :            :   {}
     477                 :            : 
     478                 :            :   /* opt_pass methods: */
     479                 :     686787 :   virtual bool gate (function *) { return flag_tree_phiprop; }
     480                 :            :   virtual unsigned int execute (function *);
     481                 :            : 
     482                 :            : }; // class pass_phiprop
     483                 :            : 
     484                 :            : unsigned int
     485                 :     686746 : pass_phiprop::execute (function *fun)
     486                 :            : {
     487                 :     686746 :   vec<basic_block> bbs;
     488                 :     686746 :   struct phiprop_d *phivn;
     489                 :     686746 :   bool did_something = false;
     490                 :     686746 :   basic_block bb;
     491                 :     686746 :   gphi_iterator gsi;
     492                 :     686746 :   unsigned i;
     493                 :     686746 :   size_t n;
     494                 :            : 
     495                 :     686746 :   calculate_dominance_info (CDI_DOMINATORS);
     496                 :     686746 :   calculate_dominance_info (CDI_POST_DOMINATORS);
     497                 :            : 
     498                 :     686746 :   n = num_ssa_names;
     499                 :     686746 :   phivn = XCNEWVEC (struct phiprop_d, n);
     500                 :            : 
     501                 :            :   /* Walk the dominator tree in preorder.  */
     502                 :     686746 :   bbs = get_all_dominated_blocks (CDI_DOMINATORS,
     503                 :     686746 :                                   single_succ (ENTRY_BLOCK_PTR_FOR_FN (fun)));
     504                 :    7579450 :   FOR_EACH_VEC_ELT (bbs, i, bb)
     505                 :            :     {
     506                 :            :       /* Since we're going to move dereferences across predecessor
     507                 :            :          edges avoid blocks with abnormal predecessors.  */
     508                 :    6892700 :       if (bb_has_abnormal_pred (bb))
     509                 :       3410 :         continue;
     510                 :    9394220 :       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     511                 :    2504920 :         did_something |= propagate_with_phi (bb, gsi.phi (), phivn, n);
     512                 :            :     }
     513                 :            : 
     514                 :     686746 :   if (did_something)
     515                 :       4568 :     gsi_commit_edge_inserts ();
     516                 :            : 
     517                 :     686746 :   bbs.release ();
     518                 :     686746 :   free (phivn);
     519                 :            : 
     520                 :     686746 :   free_dominance_info (CDI_POST_DOMINATORS);
     521                 :            : 
     522                 :     686746 :   return 0;
     523                 :            : }
     524                 :            : 
     525                 :            : } // anon namespace
     526                 :            : 
     527                 :            : gimple_opt_pass *
     528                 :     200773 : make_pass_phiprop (gcc::context *ctxt)
     529                 :            : {
     530                 :     200773 :   return new pass_phiprop (ctxt);
     531                 :            : }

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.