LCOV - code coverage report
Current view: top level - gcc - tree-ssa.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 863 1006 85.8 %
Date: 2020-04-04 11:58:09 Functions: 33 34 97.1 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Miscellaneous SSA utility functions.
       2                 :            :    Copyright (C) 2001-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 "cfghooks.h"
      27                 :            : #include "tree-pass.h"
      28                 :            : #include "ssa.h"
      29                 :            : #include "gimple-pretty-print.h"
      30                 :            : #include "diagnostic-core.h"
      31                 :            : #include "fold-const.h"
      32                 :            : #include "stor-layout.h"
      33                 :            : #include "gimple-fold.h"
      34                 :            : #include "gimplify.h"
      35                 :            : #include "gimple-iterator.h"
      36                 :            : #include "gimple-walk.h"
      37                 :            : #include "tree-ssa-loop-manip.h"
      38                 :            : #include "tree-into-ssa.h"
      39                 :            : #include "tree-ssa.h"
      40                 :            : #include "cfgloop.h"
      41                 :            : #include "cfgexpand.h"
      42                 :            : #include "tree-cfg.h"
      43                 :            : #include "tree-dfa.h"
      44                 :            : #include "stringpool.h"
      45                 :            : #include "attribs.h"
      46                 :            : #include "asan.h"
      47                 :            : 
      48                 :            : /* Pointer map of variable mappings, keyed by edge.  */
      49                 :            : static hash_map<edge, auto_vec<edge_var_map> > *edge_var_maps;
      50                 :            : 
      51                 :            : 
      52                 :            : /* Add a mapping with PHI RESULT and PHI DEF associated with edge E.  */
      53                 :            : 
      54                 :            : void
      55                 :   23786700 : redirect_edge_var_map_add (edge e, tree result, tree def, location_t locus)
      56                 :            : {
      57                 :   23786700 :   edge_var_map new_node;
      58                 :            : 
      59                 :   23786700 :   if (edge_var_maps == NULL)
      60                 :      61613 :     edge_var_maps = new hash_map<edge, auto_vec<edge_var_map> >;
      61                 :            : 
      62                 :   23786700 :   auto_vec<edge_var_map> &slot = edge_var_maps->get_or_insert (e);
      63                 :   23786700 :   new_node.def = def;
      64                 :   23786700 :   new_node.result = result;
      65                 :   23786700 :   new_node.locus = locus;
      66                 :            : 
      67                 :   23786700 :   slot.safe_push (new_node);
      68                 :   23786700 : }
      69                 :            : 
      70                 :            : 
      71                 :            : /* Clear the var mappings in edge E.  */
      72                 :            : 
      73                 :            : void
      74                 :   81571900 : redirect_edge_var_map_clear (edge e)
      75                 :            : {
      76                 :   81571900 :   if (!edge_var_maps)
      77                 :            :     return;
      78                 :            : 
      79                 :   73824400 :   auto_vec<edge_var_map> *head = edge_var_maps->get (e);
      80                 :            : 
      81                 :   19154300 :   if (head)
      82                 :   19154300 :     head->release ();
      83                 :            : }
      84                 :            : 
      85                 :            : 
      86                 :            : /* Duplicate the redirected var mappings in OLDE in NEWE.
      87                 :            : 
      88                 :            :    This assumes a hash_map can have multiple edges mapping to the same
      89                 :            :    var_map (many to one mapping), since we don't remove the previous mappings.
      90                 :            :    */
      91                 :            : 
      92                 :            : void
      93                 :     215946 : redirect_edge_var_map_dup (edge newe, edge olde)
      94                 :            : {
      95                 :     215946 :   if (!edge_var_maps)
      96                 :            :     return;
      97                 :            : 
      98                 :     199807 :   auto_vec<edge_var_map> *new_head = &edge_var_maps->get_or_insert (newe);
      99                 :     199807 :   auto_vec<edge_var_map> *old_head = edge_var_maps->get (olde);
     100                 :      45012 :   if (!old_head)
     101                 :            :     return;
     102                 :            : 
     103                 :      45012 :   new_head->safe_splice (*old_head);
     104                 :            : }
     105                 :            : 
     106                 :            : 
     107                 :            : /* Return the variable mappings for a given edge.  If there is none, return
     108                 :            :    NULL.  */
     109                 :            : 
     110                 :            : vec<edge_var_map> *
     111                 :   15957400 : redirect_edge_var_map_vector (edge e)
     112                 :            : {
     113                 :            :   /* Hey, what kind of idiot would... you'd be surprised.  */
     114                 :   15957400 :   if (!edge_var_maps)
     115                 :            :     return NULL;
     116                 :            : 
     117                 :   15730800 :   auto_vec<edge_var_map> *slot = edge_var_maps->get (e);
     118                 :   13851700 :   if (!slot)
     119                 :            :     return NULL;
     120                 :            : 
     121                 :            :   return slot;
     122                 :            : }
     123                 :            : 
     124                 :            : /* Clear the edge variable mappings.  */
     125                 :            : 
     126                 :            : void
     127                 :  375938000 : redirect_edge_var_map_empty (void)
     128                 :            : {
     129                 :  375938000 :   if (edge_var_maps)
     130                 :  158288000 :     edge_var_maps->empty ();
     131                 :  375938000 : }
     132                 :            : 
     133                 :            : 
     134                 :            : /* Remove the corresponding arguments from the PHI nodes in E's
     135                 :            :    destination block and redirect it to DEST.  Return redirected edge.
     136                 :            :    The list of removed arguments is stored in a vector accessed
     137                 :            :    through edge_var_maps.  */
     138                 :            : 
     139                 :            : edge
     140                 :   31709100 : ssa_redirect_edge (edge e, basic_block dest)
     141                 :            : {
     142                 :   31709100 :   gphi_iterator gsi;
     143                 :   31709100 :   gphi *phi;
     144                 :            : 
     145                 :   31709100 :   redirect_edge_var_map_clear (e);
     146                 :            : 
     147                 :            :   /* Remove the appropriate PHI arguments in E's destination block.
     148                 :            :      If we are redirecting a copied edge the destination has not
     149                 :            :      got PHI argument space reserved nor an interesting argument.  */
     150                 :   31709100 :   if (! (e->dest->flags & BB_DUPLICATED))
     151                 :   55124300 :     for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     152                 :            :       {
     153                 :   24127200 :         tree def;
     154                 :   24127200 :         location_t locus;
     155                 :            : 
     156                 :   24127200 :         phi = gsi.phi ();
     157                 :   24127200 :         def = gimple_phi_arg_def (phi, e->dest_idx);
     158                 :   24127200 :         locus = gimple_phi_arg_location (phi, e->dest_idx);
     159                 :            : 
     160                 :   24127200 :         if (def == NULL_TREE)
     161                 :     855060 :           continue;
     162                 :            : 
     163                 :   23272100 :         redirect_edge_var_map_add (e, gimple_phi_result (phi), def, locus);
     164                 :            :       }
     165                 :            : 
     166                 :   31709100 :   e = redirect_edge_succ_nodup (e, dest);
     167                 :            : 
     168                 :   31709100 :   return e;
     169                 :            : }
     170                 :            : 
     171                 :            : 
     172                 :            : /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
     173                 :            :    E->dest.  */
     174                 :            : 
     175                 :            : void
     176                 :    1945970 : flush_pending_stmts (edge e)
     177                 :            : {
     178                 :    1945970 :   gphi *phi;
     179                 :    1945970 :   edge_var_map *vm;
     180                 :    1945970 :   int i;
     181                 :    1945970 :   gphi_iterator gsi;
     182                 :            : 
     183                 :    1945970 :   vec<edge_var_map> *v = redirect_edge_var_map_vector (e);
     184                 :    1945970 :   if (!v)
     185                 :     201907 :     return;
     186                 :            : 
     187                 :    1744060 :   for (gsi = gsi_start_phis (e->dest), i = 0;
     188                 :    4659820 :        !gsi_end_p (gsi) && v->iterate (i, &vm);
     189                 :    2915750 :        gsi_next (&gsi), i++)
     190                 :            :     {
     191                 :    2915750 :       tree def;
     192                 :            : 
     193                 :    2915750 :       phi = gsi.phi ();
     194                 :    2915750 :       def = redirect_edge_var_map_def (vm);
     195                 :    2915750 :       add_phi_arg (phi, def, e, redirect_edge_var_map_location (vm));
     196                 :            :     }
     197                 :            : 
     198                 :    1744060 :   redirect_edge_var_map_clear (e);
     199                 :            : }
     200                 :            : 
     201                 :            : /* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
     202                 :            :    GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
     203                 :            :    expression with a different value.
     204                 :            : 
     205                 :            :    This will update any annotations (say debug bind stmts) referring
     206                 :            :    to the original LHS, so that they use the RHS instead.  This is
     207                 :            :    done even if NLHS and LHS are the same, for it is understood that
     208                 :            :    the RHS will be modified afterwards, and NLHS will not be assigned
     209                 :            :    an equivalent value.
     210                 :            : 
     211                 :            :    Adjusting any non-annotation uses of the LHS, if needed, is a
     212                 :            :    responsibility of the caller.
     213                 :            : 
     214                 :            :    The effect of this call should be pretty much the same as that of
     215                 :            :    inserting a copy of STMT before STMT, and then removing the
     216                 :            :    original stmt, at which time gsi_remove() would have update
     217                 :            :    annotations, but using this function saves all the inserting,
     218                 :            :    copying and removing.  */
     219                 :            : 
     220                 :            : void
     221                 :         34 : gimple_replace_ssa_lhs (gimple *stmt, tree nlhs)
     222                 :            : {
     223                 :         34 :   if (MAY_HAVE_DEBUG_BIND_STMTS)
     224                 :            :     {
     225                 :          1 :       tree lhs = gimple_get_lhs (stmt);
     226                 :            : 
     227                 :          1 :       gcc_assert (SSA_NAME_DEF_STMT (lhs) == stmt);
     228                 :            : 
     229                 :          1 :       insert_debug_temp_for_var_def (NULL, lhs);
     230                 :            :     }
     231                 :            : 
     232                 :         34 :   gimple_set_lhs (stmt, nlhs);
     233                 :         34 : }
     234                 :            : 
     235                 :            : 
     236                 :            : /* Given a tree for an expression for which we might want to emit
     237                 :            :    locations or values in debug information (generally a variable, but
     238                 :            :    we might deal with other kinds of trees in the future), return the
     239                 :            :    tree that should be used as the variable of a DEBUG_BIND STMT or
     240                 :            :    VAR_LOCATION INSN or NOTE.  Return NULL if VAR is not to be tracked.  */
     241                 :            : 
     242                 :            : tree
     243                 :  204393000 : target_for_debug_bind (tree var)
     244                 :            : {
     245                 :  204395000 :   if (!MAY_HAVE_DEBUG_BIND_STMTS)
     246                 :            :     return NULL_TREE;
     247                 :            : 
     248                 :  191261000 :   if (TREE_CODE (var) == SSA_NAME)
     249                 :            :     {
     250                 :    7823410 :       var = SSA_NAME_VAR (var);
     251                 :            :       if (var == NULL_TREE)
     252                 :            :         return NULL_TREE;
     253                 :            :     }
     254                 :            : 
     255                 :  158514000 :   if ((!VAR_P (var) || VAR_DECL_IS_VIRTUAL_OPERAND (var))
     256                 :  200237000 :       && TREE_CODE (var) != PARM_DECL)
     257                 :            :     return NULL_TREE;
     258                 :            : 
     259                 :  172726000 :   if (DECL_HAS_VALUE_EXPR_P (var))
     260                 :       1576 :     return target_for_debug_bind (DECL_VALUE_EXPR (var));
     261                 :            : 
     262                 :  157258000 :   if (DECL_IGNORED_P (var))
     263                 :            :     return NULL_TREE;
     264                 :            : 
     265                 :            :   /* var-tracking only tracks registers.  */
     266                 :  141616000 :   if (!is_gimple_reg_type (TREE_TYPE (var)))
     267                 :    6123650 :     return NULL_TREE;
     268                 :            : 
     269                 :            :   return var;
     270                 :            : }
     271                 :            : 
     272                 :            : /* Called via walk_tree, look for SSA_NAMEs that have already been
     273                 :            :    released.  */
     274                 :            : 
     275                 :            : static tree
     276                 :     279982 : find_released_ssa_name (tree *tp, int *walk_subtrees, void *data_)
     277                 :            : {
     278                 :     279982 :   struct walk_stmt_info *wi = (struct walk_stmt_info *) data_;
     279                 :            : 
     280                 :     279982 :   if (wi && wi->is_lhs)
     281                 :            :     return NULL_TREE;
     282                 :            : 
     283                 :     248537 :   if (TREE_CODE (*tp) == SSA_NAME)
     284                 :            :     {
     285                 :      44920 :       if (SSA_NAME_IN_FREE_LIST (*tp))
     286                 :            :         return *tp;
     287                 :            : 
     288                 :      42282 :       *walk_subtrees = 0;
     289                 :            :     }
     290                 :     203617 :   else if (IS_TYPE_OR_DECL_P (*tp))
     291                 :      48122 :     *walk_subtrees = 0;
     292                 :            : 
     293                 :            :   return NULL_TREE;
     294                 :            : }
     295                 :            : 
     296                 :            : /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
     297                 :            :    by other DEBUG stmts, and replace uses of the DEF with the
     298                 :            :    newly-created debug temp.  */
     299                 :            : 
     300                 :            : void
     301                 :   61183600 : insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var)
     302                 :            : {
     303                 :   61183600 :   imm_use_iterator imm_iter;
     304                 :   61183600 :   use_operand_p use_p;
     305                 :   61183600 :   gimple *stmt;
     306                 :   61183600 :   gimple *def_stmt = NULL;
     307                 :   61183600 :   int usecount = 0;
     308                 :   61183600 :   tree value = NULL;
     309                 :            : 
     310                 :   61183600 :   if (!MAY_HAVE_DEBUG_BIND_STMTS)
     311                 :   59246700 :     return;
     312                 :            : 
     313                 :            :   /* If this name has already been registered for replacement, do nothing
     314                 :            :      as anything that uses this name isn't in SSA form.  */
     315                 :   61183600 :   if (name_registered_for_update_p (var))
     316                 :            :     return;
     317                 :            : 
     318                 :            :   /* Check whether there are debug stmts that reference this variable and,
     319                 :            :      if there are, decide whether we should use a debug temp.  */
     320                 :   66032500 :   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, var)
     321                 :            :     {
     322                 :    5666810 :       stmt = USE_STMT (use_p);
     323                 :            : 
     324                 :    5666810 :       if (!gimple_debug_bind_p (stmt))
     325                 :    3490410 :         continue;
     326                 :            : 
     327                 :    2176400 :       if (usecount++)
     328                 :            :         break;
     329                 :            : 
     330                 :    1936920 :       if (gimple_debug_bind_get_value (stmt) != var)
     331                 :            :         {
     332                 :            :           /* Count this as an additional use, so as to make sure we
     333                 :            :              use a temp unless VAR's definition has a SINGLE_RHS that
     334                 :            :              can be shared.  */
     335                 :            :           usecount++;
     336                 :            :           break;
     337                 :            :         }
     338                 :            :     }
     339                 :            : 
     340                 :   60986700 :   if (!usecount)
     341                 :            :     return;
     342                 :            : 
     343                 :    1936920 :   if (gsi)
     344                 :    1712670 :     def_stmt = gsi_stmt (*gsi);
     345                 :            :   else
     346                 :     224251 :     def_stmt = SSA_NAME_DEF_STMT (var);
     347                 :            : 
     348                 :            :   /* If we didn't get an insertion point, and the stmt has already
     349                 :            :      been removed, we won't be able to insert the debug bind stmt, so
     350                 :            :      we'll have to drop debug information.  */
     351                 :    1936920 :   if (gimple_code (def_stmt) == GIMPLE_PHI)
     352                 :            :     {
     353                 :      88824 :       value = degenerate_phi_result (as_a <gphi *> (def_stmt));
     354                 :      88824 :       if (value && walk_tree (&value, find_released_ssa_name, NULL, NULL))
     355                 :          7 :         value = NULL;
     356                 :            :       /* error_mark_node is what fixup_noreturn_call changes PHI arguments
     357                 :            :          to.  */
     358                 :      88817 :       else if (value == error_mark_node)
     359                 :          0 :         value = NULL;
     360                 :            :     }
     361                 :    1848090 :   else if (gimple_clobber_p (def_stmt))
     362                 :            :     /* We can end up here when rewriting a decl into SSA and coming
     363                 :            :        along a clobber for the original decl.  Turn that into
     364                 :            :        # DEBUG decl => NULL  */
     365                 :     894942 :     value = NULL;
     366                 :     953151 :   else if (is_gimple_assign (def_stmt))
     367                 :            :     {
     368                 :     925747 :       bool no_value = false;
     369                 :            : 
     370                 :     925747 :       if (!dom_info_available_p (CDI_DOMINATORS))
     371                 :            :         {
     372                 :      34076 :           struct walk_stmt_info wi;
     373                 :            : 
     374                 :      34076 :           memset (&wi, 0, sizeof (wi));
     375                 :            : 
     376                 :            :           /* When removing blocks without following reverse dominance
     377                 :            :              order, we may sometimes encounter SSA_NAMEs that have
     378                 :            :              already been released, referenced in other SSA_DEFs that
     379                 :            :              we're about to release.  Consider:
     380                 :            : 
     381                 :            :              <bb X>:
     382                 :            :              v_1 = foo;
     383                 :            : 
     384                 :            :              <bb Y>:
     385                 :            :              w_2 = v_1 + bar;
     386                 :            :              # DEBUG w => w_2
     387                 :            : 
     388                 :            :              If we deleted BB X first, propagating the value of w_2
     389                 :            :              won't do us any good.  It's too late to recover their
     390                 :            :              original definition of v_1: when it was deleted, it was
     391                 :            :              only referenced in other DEFs, it couldn't possibly know
     392                 :            :              it should have been retained, and propagating every
     393                 :            :              single DEF just in case it might have to be propagated
     394                 :            :              into a DEBUG STMT would probably be too wasteful.
     395                 :            : 
     396                 :            :              When dominator information is not readily available, we
     397                 :            :              check for and accept some loss of debug information.  But
     398                 :            :              if it is available, there's no excuse for us to remove
     399                 :            :              blocks in the wrong order, so we don't even check for
     400                 :            :              dead SSA NAMEs.  SSA verification shall catch any
     401                 :            :              errors.  */
     402                 :      32905 :           if ((!gsi && !gimple_bb (def_stmt))
     403                 :      66981 :               || walk_gimple_op (def_stmt, find_released_ssa_name, &wi))
     404                 :       2631 :             no_value = true;
     405                 :            :         }
     406                 :            : 
     407                 :      34076 :       if (!no_value)
     408                 :     923116 :         value = gimple_assign_rhs_to_tree (def_stmt);
     409                 :            :     }
     410                 :            : 
     411                 :    1936920 :   if (value)
     412                 :            :     {
     413                 :            :       /* If there's a single use of VAR, and VAR is the entire debug
     414                 :            :          expression (usecount would have been incremented again
     415                 :            :          otherwise), and the definition involves only constants and
     416                 :            :          SSA names, then we can propagate VALUE into this single use,
     417                 :            :          avoiding the temp.
     418                 :            : 
     419                 :            :          We can also avoid using a temp if VALUE can be shared and
     420                 :            :          propagated into all uses, without generating expressions that
     421                 :            :          wouldn't be valid gimple RHSs.
     422                 :            : 
     423                 :            :          Other cases that would require unsharing or non-gimple RHSs
     424                 :            :          are deferred to a debug temp, although we could avoid temps
     425                 :            :          at the expense of duplication of expressions.  */
     426                 :            : 
     427                 :     949768 :       if (CONSTANT_CLASS_P (value)
     428                 :     933987 :           || gimple_code (def_stmt) == GIMPLE_PHI
     429                 :     921066 :           || (usecount == 1
     430                 :    2191280 :               && (!gimple_assign_single_p (def_stmt)
     431                 :     254368 :                   || is_gimple_min_invariant (value)))
     432                 :    1757840 :           || is_gimple_reg (value))
     433                 :            :         ;
     434                 :            :       else
     435                 :            :         {
     436                 :     806707 :           gdebug *def_temp;
     437                 :     806707 :           tree vexpr = make_node (DEBUG_EXPR_DECL);
     438                 :            : 
     439                 :     806707 :           def_temp = gimple_build_debug_bind (vexpr,
     440                 :            :                                               unshare_expr (value),
     441                 :            :                                               def_stmt);
     442                 :            : 
     443                 :     806707 :           DECL_ARTIFICIAL (vexpr) = 1;
     444                 :     806707 :           TREE_TYPE (vexpr) = TREE_TYPE (value);
     445                 :     806707 :           if (DECL_P (value))
     446                 :       6034 :             SET_DECL_MODE (vexpr, DECL_MODE (value));
     447                 :            :           else
     448                 :    1601350 :             SET_DECL_MODE (vexpr, TYPE_MODE (TREE_TYPE (value)));
     449                 :            : 
     450                 :     806707 :           if (gsi)
     451                 :     614141 :             gsi_insert_before (gsi, def_temp, GSI_SAME_STMT);
     452                 :            :           else
     453                 :            :             {
     454                 :     192566 :               gimple_stmt_iterator ngsi = gsi_for_stmt (def_stmt);
     455                 :     192566 :               gsi_insert_before (&ngsi, def_temp, GSI_SAME_STMT);
     456                 :            :             }
     457                 :            : 
     458                 :     806707 :           value = vexpr;
     459                 :            :         }
     460                 :            :     }
     461                 :            : 
     462                 :    5237520 :   FOR_EACH_IMM_USE_STMT (stmt, imm_iter, var)
     463                 :            :     {
     464                 :    3300610 :       if (!gimple_debug_bind_p (stmt))
     465                 :     329489 :         continue;
     466                 :            : 
     467                 :    2971120 :       if (value)
     468                 :            :         {
     469                 :    5668800 :           FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
     470                 :            :             /* unshare_expr is not needed here.  vexpr is either a
     471                 :            :                SINGLE_RHS, that can be safely shared, some other RHS
     472                 :            :                that was unshared when we found it had a single debug
     473                 :            :                use, or a DEBUG_EXPR_DECL, that can be safely
     474                 :            :                shared.  */
     475                 :    1889640 :             SET_USE (use_p, unshare_expr (value));
     476                 :            :           /* If we didn't replace uses with a debug decl fold the
     477                 :            :              resulting expression.  Otherwise we end up with invalid IL.  */
     478                 :    1889520 :           if (TREE_CODE (value) != DEBUG_EXPR_DECL)
     479                 :            :             {
     480                 :     150192 :               gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
     481                 :     150192 :               fold_stmt_inplace (&gsi);
     482                 :            :             }
     483                 :            :         }
     484                 :            :       else
     485                 :    1081600 :         gimple_debug_bind_reset_value (stmt);
     486                 :            : 
     487                 :    6271730 :       update_stmt (stmt);
     488                 :            :     }
     489                 :            : }
     490                 :            : 
     491                 :            : 
     492                 :            : /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
     493                 :            :    other DEBUG stmts, and replace uses of the DEF with the
     494                 :            :    newly-created debug temp.  */
     495                 :            : 
     496                 :            : void
     497                 :   91244300 : insert_debug_temps_for_defs (gimple_stmt_iterator *gsi)
     498                 :            : {
     499                 :   91244300 :   gimple *stmt;
     500                 :   91244300 :   ssa_op_iter op_iter;
     501                 :   91244300 :   def_operand_p def_p;
     502                 :            : 
     503                 :   91244300 :   if (!MAY_HAVE_DEBUG_BIND_STMTS)
     504                 :   25115300 :     return;
     505                 :            : 
     506                 :   66129100 :   stmt = gsi_stmt (*gsi);
     507                 :            : 
     508                 :  158085000 :   FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
     509                 :            :     {
     510                 :   25826700 :       tree var = DEF_FROM_PTR (def_p);
     511                 :            : 
     512                 :   25826700 :       if (TREE_CODE (var) != SSA_NAME)
     513                 :      64432 :         continue;
     514                 :            : 
     515                 :   25762300 :       insert_debug_temp_for_var_def (gsi, var);
     516                 :            :     }
     517                 :            : }
     518                 :            : 
     519                 :            : /* Reset all debug stmts that use SSA_NAME(s) defined in STMT.  */
     520                 :            : 
     521                 :            : void
     522                 :       3439 : reset_debug_uses (gimple *stmt)
     523                 :            : {
     524                 :       3439 :   ssa_op_iter op_iter;
     525                 :       3439 :   def_operand_p def_p;
     526                 :       3439 :   imm_use_iterator imm_iter;
     527                 :       3439 :   gimple *use_stmt;
     528                 :            : 
     529                 :       3439 :   if (!MAY_HAVE_DEBUG_BIND_STMTS)
     530                 :        220 :     return;
     531                 :            : 
     532                 :       8204 :   FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
     533                 :            :     {
     534                 :       1766 :       tree var = DEF_FROM_PTR (def_p);
     535                 :            : 
     536                 :       1766 :       if (TREE_CODE (var) != SSA_NAME)
     537                 :          0 :         continue;
     538                 :            : 
     539                 :       3681 :       FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, var)
     540                 :            :         {
     541                 :       1915 :           if (!gimple_debug_bind_p (use_stmt))
     542                 :       1797 :             continue;
     543                 :            : 
     544                 :        118 :           gimple_debug_bind_reset_value (use_stmt);
     545                 :       2033 :           update_stmt (use_stmt);
     546                 :            :         }
     547                 :            :     }
     548                 :            : }
     549                 :            : 
     550                 :            : /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
     551                 :            :    dominated stmts before their dominators, so that release_ssa_defs
     552                 :            :    stands a chance of propagating DEFs into debug bind stmts.  */
     553                 :            : 
     554                 :            : void
     555                 :     157655 : release_defs_bitset (bitmap toremove)
     556                 :            : {
     557                 :     157655 :   unsigned j;
     558                 :     157655 :   bitmap_iterator bi;
     559                 :            : 
     560                 :            :   /* Performing a topological sort is probably overkill, this will
     561                 :            :      most likely run in slightly superlinear time, rather than the
     562                 :            :      pathological quadratic worst case.
     563                 :            :      But iterate from max SSA name version to min one because
     564                 :            :      that mimics allocation order during code generation behavior best.
     565                 :            :      Use an array for this which we compact on-the-fly with a NULL
     566                 :            :      marker moving towards the end of the vector.  */
     567                 :     157655 :   auto_vec<tree, 16> names;
     568                 :     157655 :   names.reserve (bitmap_count_bits (toremove) + 1);
     569                 :     157655 :   names.quick_push (NULL_TREE);
     570                 :    1522760 :   EXECUTE_IF_SET_IN_BITMAP (toremove, 0, j, bi)
     571                 :    1365100 :     names.quick_push (ssa_name (j));
     572                 :            : 
     573                 :     157655 :   bitmap_tree_view (toremove);
     574                 :     329458 :   while (!bitmap_empty_p (toremove))
     575                 :            :     {
     576                 :     171803 :       j = names.length () - 1;
     577                 :    2082700 :       for (unsigned i = names.length () - 1; names[i];)
     578                 :            :         {
     579                 :    1910900 :           bool remove_now = true;
     580                 :    1910900 :           tree var = names[i];
     581                 :    1910900 :           gimple *stmt;
     582                 :    1910900 :           imm_use_iterator uit;
     583                 :            : 
     584                 :    2230270 :           FOR_EACH_IMM_USE_STMT (stmt, uit, var)
     585                 :            :             {
     586                 :     865165 :               ssa_op_iter dit;
     587                 :     865165 :               def_operand_p def_p;
     588                 :            : 
     589                 :            :               /* We can't propagate PHI nodes into debug stmts.  */
     590                 :     865165 :               if (gimple_code (stmt) == GIMPLE_PHI
     591                 :     865165 :                   || is_gimple_debug (stmt))
     592                 :     319373 :                 continue;
     593                 :            : 
     594                 :            :               /* If we find another definition to remove that uses
     595                 :            :                  the one we're looking at, defer the removal of this
     596                 :            :                  one, so that it can be propagated into debug stmts
     597                 :            :                  after the other is.  */
     598                 :     545792 :               FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, dit, SSA_OP_DEF)
     599                 :            :                 {
     600                 :     545792 :                   tree odef = DEF_FROM_PTR (def_p);
     601                 :            : 
     602                 :     545792 :                   if (bitmap_bit_p (toremove, SSA_NAME_VERSION (odef)))
     603                 :            :                     {
     604                 :            :                       remove_now = false;
     605                 :            :                       break;
     606                 :            :                     }
     607                 :            :                 }
     608                 :            : 
     609                 :     545792 :               if (!remove_now)
     610                 :    1091580 :                 BREAK_FROM_IMM_USE_STMT (uit);
     611                 :            :             }
     612                 :            : 
     613                 :    1910900 :           if (remove_now)
     614                 :            :             {
     615                 :    1365100 :               gimple *def = SSA_NAME_DEF_STMT (var);
     616                 :    1365100 :               gimple_stmt_iterator gsi = gsi_for_stmt (def);
     617                 :            : 
     618                 :    1365100 :               if (gimple_code (def) == GIMPLE_PHI)
     619                 :     281507 :                 remove_phi_node (&gsi, true);
     620                 :            :               else
     621                 :            :                 {
     622                 :    1083600 :                   gsi_remove (&gsi, true);
     623                 :    1083600 :                   release_defs (def);
     624                 :            :                 }
     625                 :    1365100 :               bitmap_clear_bit (toremove, SSA_NAME_VERSION (var));
     626                 :            :             }
     627                 :            :           else
     628                 :     545792 :             --i;
     629                 :    1910900 :           if (--j != i)
     630                 :    1809650 :             names[i] = names[j];
     631                 :            :         }
     632                 :            :     }
     633                 :     157655 :   bitmap_list_view (toremove);
     634                 :     157655 : }
     635                 :            : 
     636                 :            : /* Disable warnings about missing quoting in GCC diagnostics for
     637                 :            :    the verification errors.  Their format strings don't follow GCC
     638                 :            :    diagnostic conventions and the calls are ultimately followed by
     639                 :            :    one to internal_error.  */
     640                 :            : #if __GNUC__ >= 10
     641                 :            : #  pragma GCC diagnostic push
     642                 :            : #  pragma GCC diagnostic ignored "-Wformat-diag"
     643                 :            : #endif
     644                 :            : 
     645                 :            : /* Verify virtual SSA form.  */
     646                 :            : 
     647                 :            : bool
     648                 : 1611060000 : verify_vssa (basic_block bb, tree current_vdef, sbitmap visited)
     649                 :            : {
     650                 : 1611060000 :   bool err = false;
     651                 :            : 
     652                 : 1611060000 :   if (bitmap_bit_p (visited, bb->index))
     653                 :            :     return false;
     654                 :            : 
     655                 : 1224740000 :   bitmap_set_bit (visited, bb->index);
     656                 :            : 
     657                 :            :   /* Pick up the single virtual PHI def.  */
     658                 : 1224740000 :   gphi *phi = NULL;
     659                 : 1580980000 :   for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si);
     660                 :  356242000 :        gsi_next (&si))
     661                 :            :     {
     662                 :  356242000 :       tree res = gimple_phi_result (si.phi ());
     663                 :  890865000 :       if (virtual_operand_p (res))
     664                 :            :         {
     665                 :  178381000 :           if (phi)
     666                 :            :             {
     667                 :          0 :               error ("multiple virtual PHI nodes in BB %d", bb->index);
     668                 :          0 :               print_gimple_stmt (stderr, phi, 0);
     669                 :          0 :               print_gimple_stmt (stderr, si.phi (), 0);
     670                 :          0 :               err = true;
     671                 :            :             }
     672                 :            :           else
     673                 :            :             phi = si.phi ();
     674                 :            :         }
     675                 :            :     }
     676                 : 1224740000 :   if (phi)
     677                 :            :     {
     678                 :  178381000 :       current_vdef = gimple_phi_result (phi);
     679                 :  178381000 :       if (TREE_CODE (current_vdef) != SSA_NAME)
     680                 :            :         {
     681                 :          0 :           error ("virtual definition is not an SSA name");
     682                 :          0 :           print_gimple_stmt (stderr, phi, 0);
     683                 :          0 :           err = true;
     684                 :            :         }
     685                 :            :     }
     686                 :            : 
     687                 :            :   /* Verify stmts.  */
     688                 : 9155800000 :   for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
     689                 : 6706320000 :        gsi_next (&gsi))
     690                 :            :     {
     691                 : 6706320000 :       gimple *stmt = gsi_stmt (gsi);
     692                 : 9586770000 :       tree vuse = gimple_vuse (stmt);
     693                 : 2847820000 :       if (vuse)
     694                 :            :         {
     695                 : 1967290000 :           if (vuse != current_vdef)
     696                 :            :             {
     697                 :          0 :               error ("stmt with wrong VUSE");
     698                 :          0 :               print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
     699                 :          0 :               fprintf (stderr, "expected ");
     700                 :          0 :               print_generic_expr (stderr, current_vdef);
     701                 :          0 :               fprintf (stderr, "\n");
     702                 :          0 :               err = true;
     703                 :            :             }
     704                 : 8673610000 :           tree vdef = gimple_vdef (stmt);
     705                 : 1967290000 :           if (vdef)
     706                 :            :             {
     707                 : 1278710000 :               current_vdef = vdef;
     708                 : 1278710000 :               if (TREE_CODE (current_vdef) != SSA_NAME)
     709                 :            :                 {
     710                 :          0 :                   error ("virtual definition is not an SSA name");
     711                 :          0 :                   print_gimple_stmt (stderr, phi, 0);
     712                 :          0 :                   err = true;
     713                 :            :                 }
     714                 :            :             }
     715                 :            :         }
     716                 :            :     }
     717                 :            : 
     718                 :            :   /* Verify destination PHI uses and recurse.  */
     719                 : 1224740000 :   edge_iterator ei;
     720                 : 1224740000 :   edge e;
     721                 : 2712890000 :   FOR_EACH_EDGE (e, ei, bb->succs)
     722                 :            :     {
     723                 : 1488150000 :       gphi *phi = get_virtual_phi (e->dest);
     724                 : 1488150000 :       if (phi
     725                 : 1488150000 :           && PHI_ARG_DEF_FROM_EDGE (phi, e) != current_vdef)
     726                 :            :         {
     727                 :          0 :           error ("PHI node with wrong VUSE on edge from BB %d",
     728                 :          0 :                  e->src->index);
     729                 :          0 :           print_gimple_stmt (stderr, phi, 0, TDF_VOPS);
     730                 :          0 :           fprintf (stderr, "expected ");
     731                 :          0 :           print_generic_expr (stderr, current_vdef);
     732                 :          0 :           fprintf (stderr, "\n");
     733                 :          0 :           err = true;
     734                 :            :         }
     735                 :            : 
     736                 :            :       /* Recurse.  */
     737                 : 1488150000 :       err |= verify_vssa (e->dest, current_vdef, visited);
     738                 :            :     }
     739                 :            : 
     740                 :            :   return err;
     741                 :            : }
     742                 :            : 
     743                 :            : /* Return true if SSA_NAME is malformed and mark it visited.
     744                 :            : 
     745                 :            :    IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
     746                 :            :       operand.  */
     747                 :            : 
     748                 :            : static bool
     749                 : 7522280000 : verify_ssa_name (tree ssa_name, bool is_virtual)
     750                 :            : {
     751                 : 7522280000 :   if (TREE_CODE (ssa_name) != SSA_NAME)
     752                 :            :     {
     753                 :          0 :       error ("expected an SSA_NAME object");
     754                 :          0 :       return true;
     755                 :            :     }
     756                 :            : 
     757                 : 7522280000 :   if (SSA_NAME_IN_FREE_LIST (ssa_name))
     758                 :            :     {
     759                 :          0 :       error ("found an SSA_NAME that had been released into the free pool");
     760                 :          0 :       return true;
     761                 :            :     }
     762                 :            : 
     763                 : 7522280000 :   if (SSA_NAME_VAR (ssa_name) != NULL_TREE
     764                 : 4622620000 :       && TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
     765                 :            :     {
     766                 :          0 :       error ("type mismatch between an SSA_NAME and its symbol");
     767                 :          0 :       return true;
     768                 :            :     }
     769                 :            : 
     770                 : 7522280000 :   if (is_virtual && !virtual_operand_p (ssa_name))
     771                 :            :     {
     772                 :          0 :       error ("found a virtual definition for a GIMPLE register");
     773                 :          0 :       return true;
     774                 :            :     }
     775                 :            : 
     776                 :14570400000 :   if (is_virtual && SSA_NAME_VAR (ssa_name) != gimple_vop (cfun))
     777                 :            :     {
     778                 :          0 :       error ("virtual SSA name for non-VOP decl");
     779                 :          0 :       return true;
     780                 :            :     }
     781                 :            : 
     782                 : 7522280000 :   if (!is_virtual && virtual_operand_p (ssa_name))
     783                 :            :     {
     784                 :          0 :       error ("found a real definition for a non-register");
     785                 :          0 :       return true;
     786                 :            :     }
     787                 :            : 
     788                 : 7522280000 :   if (SSA_NAME_IS_DEFAULT_DEF (ssa_name)
     789                 : 7522280000 :       && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name)))
     790                 :            :     {
     791                 :          0 :       error ("found a default name with a non-empty defining statement");
     792                 :          0 :       return true;
     793                 :            :     }
     794                 :            : 
     795                 :            :   return false;
     796                 :            : }
     797                 :            : 
     798                 :            : 
     799                 :            : /* Return true if the definition of SSA_NAME at block BB is malformed.
     800                 :            : 
     801                 :            :    STMT is the statement where SSA_NAME is created.
     802                 :            : 
     803                 :            :    DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
     804                 :            :       version numbers.  If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
     805                 :            :       it means that the block in that array slot contains the
     806                 :            :       definition of SSA_NAME.
     807                 :            : 
     808                 :            :    IS_VIRTUAL is true if SSA_NAME is created by a VDEF.  */
     809                 :            : 
     810                 :            : static bool
     811                 : 3209430000 : verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
     812                 :            :             gimple *stmt, bool is_virtual)
     813                 :            : {
     814                 : 3209430000 :   if (verify_ssa_name (ssa_name, is_virtual))
     815                 :          0 :     goto err;
     816                 :            : 
     817                 : 3209430000 :   if (SSA_NAME_VAR (ssa_name)
     818                 : 1821570000 :       && TREE_CODE (SSA_NAME_VAR (ssa_name)) == RESULT_DECL
     819                 :          0 :       && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name)))
     820                 :            :     {
     821                 :          0 :       error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
     822                 :          0 :       goto err;
     823                 :            :     }
     824                 :            : 
     825                 : 3209430000 :   if (definition_block[SSA_NAME_VERSION (ssa_name)])
     826                 :            :     {
     827                 :          0 :       error ("SSA_NAME created in two different blocks %i and %i",
     828                 :          0 :              definition_block[SSA_NAME_VERSION (ssa_name)]->index, bb->index);
     829                 :          0 :       goto err;
     830                 :            :     }
     831                 :            : 
     832                 : 3209430000 :   definition_block[SSA_NAME_VERSION (ssa_name)] = bb;
     833                 :            : 
     834                 : 3209430000 :   if (SSA_NAME_DEF_STMT (ssa_name) != stmt)
     835                 :            :     {
     836                 :          0 :       error ("SSA_NAME_DEF_STMT is wrong");
     837                 :          0 :       fprintf (stderr, "Expected definition statement:\n");
     838                 :          0 :       print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (ssa_name), 4, TDF_VOPS);
     839                 :          0 :       fprintf (stderr, "\nActual definition statement:\n");
     840                 :          0 :       print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
     841                 :          0 :       goto err;
     842                 :            :     }
     843                 :            : 
     844                 :            :   return false;
     845                 :            : 
     846                 :          0 : err:
     847                 :          0 :   fprintf (stderr, "while verifying SSA_NAME ");
     848                 :          0 :   print_generic_expr (stderr, ssa_name);
     849                 :          0 :   fprintf (stderr, " in statement\n");
     850                 :          0 :   print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
     851                 :            : 
     852                 :          0 :   return true;
     853                 :            : }
     854                 :            : 
     855                 :            : 
     856                 :            : /* Return true if the use of SSA_NAME at statement STMT in block BB is
     857                 :            :    malformed.
     858                 :            : 
     859                 :            :    DEF_BB is the block where SSA_NAME was found to be created.
     860                 :            : 
     861                 :            :    IDOM contains immediate dominator information for the flowgraph.
     862                 :            : 
     863                 :            :    CHECK_ABNORMAL is true if the caller wants to check whether this use
     864                 :            :       is flowing through an abnormal edge (only used when checking PHI
     865                 :            :       arguments).
     866                 :            : 
     867                 :            :    If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
     868                 :            :      that are defined before STMT in basic block BB.  */
     869                 :            : 
     870                 :            : static bool
     871                 : 5985600000 : verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
     872                 :            :             gimple *stmt, bool check_abnormal, bitmap names_defined_in_bb)
     873                 :            : {
     874                 : 5985600000 :   bool err = false;
     875                 : 5985600000 :   tree ssa_name = USE_FROM_PTR (use_p);
     876                 :            : 
     877                 : 5985600000 :   if (!TREE_VISITED (ssa_name))
     878                 : 3399280000 :     if (verify_imm_links (stderr, ssa_name))
     879                 :          0 :       err = true;
     880                 :            : 
     881                 : 5985600000 :   TREE_VISITED (ssa_name) = 1;
     882                 :            : 
     883                 : 5985600000 :   if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name))
     884                 : 5985600000 :       && SSA_NAME_IS_DEFAULT_DEF (ssa_name))
     885                 :            :     ; /* Default definitions have empty statements.  Nothing to do.  */
     886                 : 5185350000 :   else if (!def_bb)
     887                 :            :     {
     888                 :          0 :       error ("missing definition");
     889                 :          0 :       err = true;
     890                 :            :     }
     891                 : 5185350000 :   else if (bb != def_bb
     892                 : 5185350000 :            && !dominated_by_p (CDI_DOMINATORS, bb, def_bb))
     893                 :            :     {
     894                 :          0 :       error ("definition in block %i does not dominate use in block %i",
     895                 :            :              def_bb->index, bb->index);
     896                 :          0 :       err = true;
     897                 :            :     }
     898                 : 5185350000 :   else if (bb == def_bb
     899                 : 5185350000 :            && names_defined_in_bb != NULL
     900                 : 8310360000 :            && !bitmap_bit_p (names_defined_in_bb, SSA_NAME_VERSION (ssa_name)))
     901                 :            :     {
     902                 :          0 :       error ("definition in block %i follows the use", def_bb->index);
     903                 :          0 :       err = true;
     904                 :            :     }
     905                 :            : 
     906                 : 5985600000 :   if (check_abnormal
     907                 : 5991400000 :       && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
     908                 :            :     {
     909                 :          0 :       error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
     910                 :          0 :       err = true;
     911                 :            :     }
     912                 :            : 
     913                 :            :   /* Make sure the use is in an appropriate list by checking the previous
     914                 :            :      element to make sure it's the same.  */
     915                 : 5985600000 :   if (use_p->prev == NULL)
     916                 :            :     {
     917                 :          0 :       error ("no immediate_use list");
     918                 :          0 :       err = true;
     919                 :            :     }
     920                 :            :   else
     921                 :            :     {
     922                 : 5985600000 :       tree listvar;
     923                 : 5985600000 :       if (use_p->prev->use == NULL)
     924                 : 3399280000 :         listvar = use_p->prev->loc.ssa_name;
     925                 :            :       else
     926                 : 2586320000 :         listvar = USE_FROM_PTR (use_p->prev);
     927                 : 5985600000 :       if (listvar != ssa_name)
     928                 :            :         {
     929                 :          0 :           error ("wrong immediate use list");
     930                 :          0 :           err = true;
     931                 :            :         }
     932                 :            :     }
     933                 :            : 
     934                 : 5985600000 :   if (err)
     935                 :            :     {
     936                 :          0 :       fprintf (stderr, "for SSA_NAME: ");
     937                 :          0 :       print_generic_expr (stderr, ssa_name, TDF_VOPS);
     938                 :          0 :       fprintf (stderr, " in statement:\n");
     939                 :          0 :       print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
     940                 :            :     }
     941                 :            : 
     942                 : 5985600000 :   return err;
     943                 :            : }
     944                 :            : 
     945                 :            : 
     946                 :            : /* Return true if any of the arguments for PHI node PHI at block BB is
     947                 :            :    malformed.
     948                 :            : 
     949                 :            :    DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
     950                 :            :       version numbers.  If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
     951                 :            :       it means that the block in that array slot contains the
     952                 :            :       definition of SSA_NAME.  */
     953                 :            : 
     954                 :            : static bool
     955                 :  356250000 : verify_phi_args (gphi *phi, basic_block bb, basic_block *definition_block)
     956                 :            : {
     957                 :  356250000 :   edge e;
     958                 :  356250000 :   bool err = false;
     959                 :  356250000 :   size_t i, phi_num_args = gimple_phi_num_args (phi);
     960                 :            : 
     961                 :  712500000 :   if (EDGE_COUNT (bb->preds) != phi_num_args)
     962                 :            :     {
     963                 :          0 :       error ("incoming edge count does not match number of PHI arguments");
     964                 :          0 :       err = true;
     965                 :          0 :       goto error;
     966                 :            :     }
     967                 :            : 
     968                 : 1235050000 :   for (i = 0; i < phi_num_args; i++)
     969                 :            :     {
     970                 :  878797000 :       use_operand_p op_p = gimple_phi_arg_imm_use_ptr (phi, i);
     971                 :  878797000 :       tree op = USE_FROM_PTR (op_p);
     972                 :            : 
     973                 :  878797000 :       e = EDGE_PRED (bb, i);
     974                 :            : 
     975                 :  878797000 :       if (op == NULL_TREE)
     976                 :            :         {
     977                 :          0 :           error ("PHI argument is missing for edge %d->%d",
     978                 :          0 :                  e->src->index,
     979                 :          0 :                  e->dest->index);
     980                 :          0 :           err = true;
     981                 :          0 :           goto error;
     982                 :            :         }
     983                 :            : 
     984                 :  878797000 :       if (TREE_CODE (op) != SSA_NAME && !is_gimple_min_invariant (op))
     985                 :            :         {
     986                 :          0 :           error ("PHI argument is not SSA_NAME, or invariant");
     987                 :          0 :           err = true;
     988                 :            :         }
     989                 :            : 
     990                 :  878797000 :       if (TREE_CODE (op) == SSA_NAME)
     991                 :            :         {
     992                 : 1554570000 :           err = verify_ssa_name (op, virtual_operand_p (gimple_phi_result (phi)));
     993                 :  777286000 :           err |= verify_use (e->src, definition_block[SSA_NAME_VERSION (op)],
     994                 :  777286000 :                              op_p, phi, e->flags & EDGE_ABNORMAL, NULL);
     995                 :            :         }
     996                 :            : 
     997                 :  878797000 :       if (TREE_CODE (op) == ADDR_EXPR)
     998                 :            :         {
     999                 :    5504680 :           tree base = TREE_OPERAND (op, 0);
    1000                 :    7488640 :           while (handled_component_p (base))
    1001                 :    1983960 :             base = TREE_OPERAND (base, 0);
    1002                 :    5504680 :           if ((VAR_P (base)
    1003                 :    5504680 :                || TREE_CODE (base) == PARM_DECL
    1004                 :    2411170 :                || TREE_CODE (base) == RESULT_DECL)
    1005                 :    3094730 :               && !TREE_ADDRESSABLE (base))
    1006                 :            :             {
    1007                 :          0 :               error ("address taken, but ADDRESSABLE bit not set");
    1008                 :          0 :               err = true;
    1009                 :            :             }
    1010                 :            :         }
    1011                 :            : 
    1012                 :  878797000 :       if (e->dest != bb)
    1013                 :            :         {
    1014                 :          0 :           error ("wrong edge %d->%d for PHI argument",
    1015                 :          0 :                  e->src->index, e->dest->index);
    1016                 :          0 :           err = true;
    1017                 :            :         }
    1018                 :            : 
    1019                 :  878797000 :       if (err)
    1020                 :            :         {
    1021                 :          0 :           fprintf (stderr, "PHI argument\n");
    1022                 :          0 :           print_generic_stmt (stderr, op, TDF_VOPS);
    1023                 :          0 :           goto error;
    1024                 :            :         }
    1025                 :            :     }
    1026                 :            : 
    1027                 :  356250000 : error:
    1028                 :  356250000 :   if (err)
    1029                 :            :     {
    1030                 :          0 :       fprintf (stderr, "for PHI node\n");
    1031                 :          0 :       print_gimple_stmt (stderr, phi, 0, TDF_VOPS|TDF_MEMSYMS);
    1032                 :            :     }
    1033                 :            : 
    1034                 :            : 
    1035                 :  356250000 :   return err;
    1036                 :            : }
    1037                 :            : 
    1038                 :            : 
    1039                 :            : /* Verify common invariants in the SSA web.
    1040                 :            :    TODO: verify the variable annotations.  */
    1041                 :            : 
    1042                 :            : DEBUG_FUNCTION void
    1043                 :  122977000 : verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
    1044                 :            : {
    1045                 :  122977000 :   basic_block bb;
    1046                 :  245954000 :   basic_block *definition_block = XCNEWVEC (basic_block, num_ssa_names);
    1047                 :  122977000 :   ssa_op_iter iter;
    1048                 :  122977000 :   tree op;
    1049                 :  122977000 :   enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS);
    1050                 :  122977000 :   auto_bitmap names_defined_in_bb;
    1051                 :            : 
    1052                 :  122977000 :   gcc_assert (!need_ssa_update_p (cfun));
    1053                 :            : 
    1054                 :  122977000 :   timevar_push (TV_TREE_SSA_VERIFY);
    1055                 :            : 
    1056                 :  122977000 :     {
    1057                 :            :       /* Keep track of SSA names present in the IL.  */
    1058                 :  122977000 :       size_t i;
    1059                 :  122977000 :       tree name;
    1060                 :  122977000 :       hash_map <void *, tree> ssa_info;
    1061                 :            : 
    1062                 : 4526460000 :       FOR_EACH_SSA_NAME (i, name, cfun)
    1063                 :            :         {
    1064                 : 3535560000 :           gimple *stmt;
    1065                 : 3535560000 :           TREE_VISITED (name) = 0;
    1066                 :            : 
    1067                 : 7071120000 :           verify_ssa_name (name, virtual_operand_p (name));
    1068                 :            : 
    1069                 : 3535560000 :           stmt = SSA_NAME_DEF_STMT (name);
    1070                 : 3535560000 :           if (!gimple_nop_p (stmt))
    1071                 :            :             {
    1072                 : 3209430000 :               basic_block bb = gimple_bb (stmt);
    1073                 : 3209430000 :               if (verify_def (bb, definition_block,
    1074                 : 3209430000 :                               name, stmt, virtual_operand_p (name)))
    1075                 :          0 :                 goto err;
    1076                 :            :             }
    1077                 :            : 
    1078                 : 3535560000 :           void *info = NULL;
    1079                 : 3535560000 :           if (POINTER_TYPE_P (TREE_TYPE (name)))
    1080                 :  610441000 :             info = SSA_NAME_PTR_INFO (name);
    1081                 : 2925120000 :           else if (INTEGRAL_TYPE_P (TREE_TYPE (name)))
    1082                 : 1175520000 :             info = SSA_NAME_RANGE_INFO (name);
    1083                 : 3535560000 :           if (info)
    1084                 :            :             {
    1085                 :  685275000 :               bool existed;
    1086                 :  685275000 :               tree &val = ssa_info.get_or_insert (info, &existed);
    1087                 :  685275000 :               if (existed)
    1088                 :            :                 {
    1089                 :          0 :                   error ("shared SSA name info");
    1090                 :          0 :                   print_generic_expr (stderr, val);
    1091                 :          0 :                   fprintf (stderr, " and ");
    1092                 :          0 :                   print_generic_expr (stderr, name);
    1093                 :          0 :                   fprintf (stderr, "\n");
    1094                 :          0 :                   goto err;
    1095                 :            :                 }
    1096                 :            :               else
    1097                 :  685275000 :                 val = name;
    1098                 :            :             }
    1099                 :            :         }
    1100                 :            :     }
    1101                 :            : 
    1102                 :  122977000 :   calculate_dominance_info (CDI_DOMINATORS);
    1103                 :            : 
    1104                 :            :   /* Now verify all the uses and make sure they agree with the definitions
    1105                 :            :      found in the previous pass.  */
    1106                 : 1104480000 :   FOR_EACH_BB_FN (bb, cfun)
    1107                 :            :     {
    1108                 :  981503000 :       edge e;
    1109                 :  981503000 :       edge_iterator ei;
    1110                 :            : 
    1111                 :            :       /* Make sure that all edges have a clear 'aux' field.  */
    1112                 : 2349220000 :       FOR_EACH_EDGE (e, ei, bb->preds)
    1113                 :            :         {
    1114                 : 1367720000 :           if (e->aux)
    1115                 :            :             {
    1116                 :          0 :               error ("AUX pointer initialized for edge %d->%d", e->src->index,
    1117                 :          0 :                       e->dest->index);
    1118                 :          0 :               goto err;
    1119                 :            :             }
    1120                 :            :         }
    1121                 :            : 
    1122                 :            :       /* Verify the arguments for every PHI node in the block.  */
    1123                 : 1337750000 :       for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    1124                 :            :         {
    1125                 :  356250000 :           gphi *phi = gsi.phi ();
    1126                 :  356250000 :           if (verify_phi_args (phi, bb, definition_block))
    1127                 :          0 :             goto err;
    1128                 :            : 
    1129                 :  712500000 :           bitmap_set_bit (names_defined_in_bb,
    1130                 :  356250000 :                           SSA_NAME_VERSION (gimple_phi_result (phi)));
    1131                 :            :         }
    1132                 :            : 
    1133                 :            :       /* Now verify all the uses and vuses in every statement of the block.  */
    1134                 : 8669430000 :       for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
    1135                 : 6706430000 :            gsi_next (&gsi))
    1136                 :            :         {
    1137                 : 6706430000 :           gimple *stmt = gsi_stmt (gsi);
    1138                 : 6706430000 :           use_operand_p use_p;
    1139                 :            : 
    1140                 :13375900000 :           if (check_modified_stmt && gimple_modified_p (stmt))
    1141                 :            :             {
    1142                 :          0 :               error ("stmt (%p) marked modified after optimization pass: ",
    1143                 :            :                      (void *)stmt);
    1144                 :          0 :               print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
    1145                 :          0 :               goto err;
    1146                 :            :             }
    1147                 :            : 
    1148                 : 6706430000 :           if (check_ssa_operands && verify_ssa_operands (cfun, stmt))
    1149                 :            :             {
    1150                 :          0 :               print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
    1151                 :          0 :               goto err;
    1152                 :            :             }
    1153                 :            : 
    1154                 : 6706430000 :           if (gimple_debug_bind_p (stmt)
    1155                 : 3399510000 :               && !gimple_debug_bind_has_value_p (stmt))
    1156                 : 1138650000 :             continue;
    1157                 :            : 
    1158                 :10776100000 :           FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
    1159                 :            :             {
    1160                 : 5208310000 :               op = USE_FROM_PTR (use_p);
    1161                 : 5208310000 :               if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
    1162                 :            :                               use_p, stmt, false, names_defined_in_bb))
    1163                 :          0 :                 goto err;
    1164                 :            :             }
    1165                 :            : 
    1166                 : 8413030000 :           FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS)
    1167                 :            :             {
    1168                 : 2845250000 :               if (SSA_NAME_DEF_STMT (op) != stmt)
    1169                 :            :                 {
    1170                 :          0 :                   error ("SSA_NAME_DEF_STMT is wrong");
    1171                 :          0 :                   fprintf (stderr, "Expected definition statement:\n");
    1172                 :          0 :                   print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
    1173                 :          0 :                   fprintf (stderr, "\nActual definition statement:\n");
    1174                 :          0 :                   print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (op),
    1175                 :            :                                      4, TDF_VOPS);
    1176                 :          0 :                   goto err;
    1177                 :            :                 }
    1178                 : 2845250000 :               bitmap_set_bit (names_defined_in_bb, SSA_NAME_VERSION (op));
    1179                 :            :             }
    1180                 :            :         }
    1181                 :            : 
    1182                 :  981503000 :       bitmap_clear (names_defined_in_bb);
    1183                 :            :     }
    1184                 :            : 
    1185                 :  122977000 :   free (definition_block);
    1186                 :            : 
    1187                 :  122977000 :   if (gimple_vop (cfun)
    1188                 :  122977000 :       && ssa_default_def (cfun, gimple_vop (cfun)))
    1189                 :            :     {
    1190                 :  245810000 :       auto_sbitmap visited (last_basic_block_for_fn (cfun) + 1);
    1191                 :  122905000 :       bitmap_clear (visited);
    1192                 :  245810000 :       if (verify_vssa (ENTRY_BLOCK_PTR_FOR_FN (cfun),
    1193                 :            :                        ssa_default_def (cfun, gimple_vop (cfun)), visited))
    1194                 :          0 :         goto err;
    1195                 :            :     }
    1196                 :            : 
    1197                 :            :   /* Restore the dominance information to its prior known state, so
    1198                 :            :      that we do not perturb the compiler's subsequent behavior.  */
    1199                 :  122977000 :   if (orig_dom_state == DOM_NONE)
    1200                 :   34043100 :     free_dominance_info (CDI_DOMINATORS);
    1201                 :            :   else
    1202                 :   88933800 :     set_dom_info_availability (CDI_DOMINATORS, orig_dom_state);
    1203                 :            : 
    1204                 :  122977000 :   timevar_pop (TV_TREE_SSA_VERIFY);
    1205                 :  122977000 :   return;
    1206                 :            : 
    1207                 :          0 : err:
    1208                 :          0 :   internal_error ("verify_ssa failed");
    1209                 :            : }
    1210                 :            : 
    1211                 :            : #if __GNUC__ >= 10
    1212                 :            : #  pragma GCC diagnostic pop
    1213                 :            : #endif
    1214                 :            : 
    1215                 :            : /* Initialize global DFA and SSA structures.  */
    1216                 :            : 
    1217                 :            : void
    1218                 :    2120620 : init_tree_ssa (struct function *fn)
    1219                 :            : {
    1220                 :    2120620 :   fn->gimple_df = ggc_cleared_alloc<gimple_df> ();
    1221                 :    2120620 :   fn->gimple_df->default_defs = hash_table<ssa_name_hasher>::create_ggc (20);
    1222                 :    2120620 :   pt_solution_reset (&fn->gimple_df->escaped);
    1223                 :    2120620 :   init_ssanames (fn, 0);
    1224                 :    2120620 : }
    1225                 :            : 
    1226                 :            : /* Deallocate memory associated with SSA data structures for FNDECL.  */
    1227                 :            : 
    1228                 :            : void
    1229                 :    2030360 : delete_tree_ssa (struct function *fn)
    1230                 :            : {
    1231                 :    2030360 :   fini_ssanames (fn);
    1232                 :            : 
    1233                 :            :   /* We no longer maintain the SSA operand cache at this point.  */
    1234                 :    2030360 :   if (ssa_operands_active (fn))
    1235                 :    2018890 :     fini_ssa_operands (fn);
    1236                 :            : 
    1237                 :    2030360 :   fn->gimple_df->default_defs->empty ();
    1238                 :    2030360 :   fn->gimple_df->default_defs = NULL;
    1239                 :    2030360 :   pt_solution_reset (&fn->gimple_df->escaped);
    1240                 :    2030360 :   if (fn->gimple_df->decls_to_pointers != NULL)
    1241                 :      28981 :     delete fn->gimple_df->decls_to_pointers;
    1242                 :    2030360 :   fn->gimple_df->decls_to_pointers = NULL;
    1243                 :    2030360 :   fn->gimple_df = NULL;
    1244                 :            : 
    1245                 :            :   /* We no longer need the edge variable maps.  */
    1246                 :    2030360 :   redirect_edge_var_map_empty ();
    1247                 :    2030360 : }
    1248                 :            : 
    1249                 :            : /* Return true if EXPR is a useless type conversion, otherwise return
    1250                 :            :    false.  */
    1251                 :            : 
    1252                 :            : bool
    1253                 :  457379000 : tree_ssa_useless_type_conversion (tree expr)
    1254                 :            : {
    1255                 :            :   /* If we have an assignment that merely uses a NOP_EXPR to change
    1256                 :            :      the top of the RHS to the type of the LHS and the type conversion
    1257                 :            :      is "safe", then strip away the type conversion so that we can
    1258                 :            :      enter LHS = RHS into the const_and_copies table.  */
    1259                 :  457379000 :   if (CONVERT_EXPR_P (expr)
    1260                 :  416972000 :       || TREE_CODE (expr) == VIEW_CONVERT_EXPR
    1261                 :  416107000 :       || TREE_CODE (expr) == NON_LVALUE_EXPR)
    1262                 :   41629600 :     return useless_type_conversion_p
    1263                 :   41629600 :       (TREE_TYPE (expr),
    1264                 :   83259300 :        TREE_TYPE (TREE_OPERAND (expr, 0)));
    1265                 :            : 
    1266                 :            :   return false;
    1267                 :            : }
    1268                 :            : 
    1269                 :            : /* Strip conversions from EXP according to
    1270                 :            :    tree_ssa_useless_type_conversion and return the resulting
    1271                 :            :    expression.  */
    1272                 :            : 
    1273                 :            : tree
    1274                 :  436387000 : tree_ssa_strip_useless_type_conversions (tree exp)
    1275                 :            : {
    1276                 :  449138000 :   while (tree_ssa_useless_type_conversion (exp))
    1277                 :   12751600 :     exp = TREE_OPERAND (exp, 0);
    1278                 :  436387000 :   return exp;
    1279                 :            : }
    1280                 :            : 
    1281                 :            : /* Return true if T, as SSA_NAME, has an implicit default defined value.  */
    1282                 :            : 
    1283                 :            : bool
    1284                 :   68519400 : ssa_defined_default_def_p (tree t)
    1285                 :            : {
    1286                 :   68519400 :   tree var = SSA_NAME_VAR (t);
    1287                 :            : 
    1288                 :   31237700 :   if (!var)
    1289                 :            :     ;
    1290                 :            :   /* Parameters get their initial value from the function entry.  */
    1291                 :   31237700 :   else if (TREE_CODE (var) == PARM_DECL)
    1292                 :            :     return true;
    1293                 :            :   /* When returning by reference the return address is actually a hidden
    1294                 :            :      parameter.  */
    1295                 :   23721800 :   else if (TREE_CODE (var) == RESULT_DECL && DECL_BY_REFERENCE (var))
    1296                 :            :     return true;
    1297                 :            :   /* Hard register variables get their initial value from the ether.  */
    1298                 :   23675500 :   else if (VAR_P (var) && DECL_HARD_REGISTER (var))
    1299                 :          0 :     return true;
    1300                 :            : 
    1301                 :            :   return false;
    1302                 :            : }
    1303                 :            : 
    1304                 :            : 
    1305                 :            : /* Return true if T, an SSA_NAME, has an undefined value.  PARTIAL is what
    1306                 :            :    should be returned if the value is only partially undefined.  */
    1307                 :            : 
    1308                 :            : bool
    1309                 :   68336000 : ssa_undefined_value_p (tree t, bool partial)
    1310                 :            : {
    1311                 :   68336000 :   gimple *def_stmt;
    1312                 :            : 
    1313                 :   68336000 :   if (ssa_defined_default_def_p (t))
    1314                 :            :     return false;
    1315                 :            : 
    1316                 :            :   /* The value is undefined iff its definition statement is empty.  */
    1317                 :   60775100 :   def_stmt = SSA_NAME_DEF_STMT (t);
    1318                 :   60775100 :   if (gimple_nop_p (def_stmt))
    1319                 :            :     return true;
    1320                 :            : 
    1321                 :            :   /* Check if the complex was not only partially defined.  */
    1322                 :   33308200 :   if (partial && is_gimple_assign (def_stmt)
    1323                 :   84913600 :       && gimple_assign_rhs_code (def_stmt) == COMPLEX_EXPR)
    1324                 :            :     {
    1325                 :      20202 :       tree rhs1, rhs2;
    1326                 :            : 
    1327                 :      20202 :       rhs1 = gimple_assign_rhs1 (def_stmt);
    1328                 :      20202 :       rhs2 = gimple_assign_rhs2 (def_stmt);
    1329                 :      19759 :       return (TREE_CODE (rhs1) == SSA_NAME && ssa_undefined_value_p (rhs1))
    1330                 :      39925 :              || (TREE_CODE (rhs2) == SSA_NAME && ssa_undefined_value_p (rhs2));
    1331                 :            :     }
    1332                 :            :   return false;
    1333                 :            : }
    1334                 :            : 
    1335                 :            : 
    1336                 :            : /* Return TRUE iff STMT, a gimple statement, references an undefined
    1337                 :            :    SSA name.  */
    1338                 :            : 
    1339                 :            : bool
    1340                 :    1985940 : gimple_uses_undefined_value_p (gimple *stmt)
    1341                 :            : {
    1342                 :    1985940 :   ssa_op_iter iter;
    1343                 :    1985940 :   tree op;
    1344                 :            : 
    1345                 :    3894560 :   FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
    1346                 :    1910220 :     if (ssa_undefined_value_p (op))
    1347                 :            :       return true;
    1348                 :            : 
    1349                 :            :   return false;
    1350                 :            : }
    1351                 :            : 
    1352                 :            : 
    1353                 :            : 
    1354                 :            : /* If necessary, rewrite the base of the reference tree *TP from
    1355                 :            :    a MEM_REF to a plain or converted symbol.  */
    1356                 :            : 
    1357                 :            : static void
    1358                 :   14402500 : maybe_rewrite_mem_ref_base (tree *tp, bitmap suitable_for_renaming)
    1359                 :            : {
    1360                 :   16261400 :   tree sym;
    1361                 :            : 
    1362                 :   16261400 :   while (handled_component_p (*tp))
    1363                 :    1858900 :     tp = &TREE_OPERAND (*tp, 0);
    1364                 :   14402500 :   if (TREE_CODE (*tp) == MEM_REF
    1365                 :     969012 :       && TREE_CODE (TREE_OPERAND (*tp, 0)) == ADDR_EXPR
    1366                 :     116721 :       && (sym = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0))
    1367                 :     116721 :       && DECL_P (sym)
    1368                 :     116421 :       && !TREE_ADDRESSABLE (sym)
    1369                 :      58602 :       && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym))
    1370                 :      23953 :       && is_gimple_reg_type (TREE_TYPE (*tp))
    1371                 :   14426400 :       && ! VOID_TYPE_P (TREE_TYPE (*tp)))
    1372                 :            :     {
    1373                 :      23953 :       if (TREE_CODE (TREE_TYPE (sym)) == VECTOR_TYPE
    1374                 :        121 :           && useless_type_conversion_p (TREE_TYPE (*tp),
    1375                 :        121 :                                         TREE_TYPE (TREE_TYPE (sym)))
    1376                 :      23962 :           && multiple_of_p (sizetype, TREE_OPERAND (*tp, 1),
    1377                 :          9 :                             TYPE_SIZE_UNIT (TREE_TYPE (*tp))))
    1378                 :            :         {
    1379                 :          9 :           *tp = build3 (BIT_FIELD_REF, TREE_TYPE (*tp), sym, 
    1380                 :          9 :                         TYPE_SIZE (TREE_TYPE (*tp)),
    1381                 :            :                         int_const_binop (MULT_EXPR,
    1382                 :         18 :                                          bitsize_int (BITS_PER_UNIT),
    1383                 :          9 :                                          TREE_OPERAND (*tp, 1)));
    1384                 :            :         }
    1385                 :      23944 :       else if (TREE_CODE (TREE_TYPE (sym)) == COMPLEX_TYPE
    1386                 :      24121 :                && useless_type_conversion_p (TREE_TYPE (*tp),
    1387                 :        177 :                                              TREE_TYPE (TREE_TYPE (sym))))
    1388                 :            :         {
    1389                 :          6 :           *tp = build1 (integer_zerop (TREE_OPERAND (*tp, 1))
    1390                 :            :                         ? REALPART_EXPR : IMAGPART_EXPR,
    1391                 :          4 :                         TREE_TYPE (*tp), sym);
    1392                 :            :         }
    1393                 :      23940 :       else if (integer_zerop (TREE_OPERAND (*tp, 1))
    1394                 :      47781 :                && DECL_SIZE (sym) == TYPE_SIZE (TREE_TYPE (*tp)))
    1395                 :            :         {
    1396                 :      47502 :           if (!useless_type_conversion_p (TREE_TYPE (*tp),
    1397                 :      23751 :                                           TREE_TYPE (sym)))
    1398                 :       3839 :             *tp = build1 (VIEW_CONVERT_EXPR,
    1399                 :       3839 :                           TREE_TYPE (*tp), sym);
    1400                 :            :           else
    1401                 :      19912 :             *tp = sym;
    1402                 :            :         }
    1403                 :        189 :       else if (DECL_SIZE (sym)
    1404                 :        189 :                && TREE_CODE (DECL_SIZE (sym)) == INTEGER_CST
    1405                 :        189 :                && (known_subrange_p
    1406                 :        189 :                    (mem_ref_offset (*tp),
    1407                 :        189 :                     wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (*tp))),
    1408                 :        189 :                     0, wi::to_offset (DECL_SIZE_UNIT (sym))))
    1409                 :        189 :                && (! INTEGRAL_TYPE_P (TREE_TYPE (*tp)) 
    1410                 :        188 :                    || (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp)))
    1411                 :        376 :                        == TYPE_PRECISION (TREE_TYPE (*tp))))
    1412                 :        378 :                && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp))),
    1413                 :        378 :                                   BITS_PER_UNIT) == 0)
    1414                 :            :         {
    1415                 :        189 :           *tp = build3 (BIT_FIELD_REF, TREE_TYPE (*tp), sym,
    1416                 :        189 :                         TYPE_SIZE (TREE_TYPE (*tp)),
    1417                 :            :                         wide_int_to_tree (bitsizetype,
    1418                 :        189 :                                           mem_ref_offset (*tp)
    1419                 :        378 :                                           << LOG2_BITS_PER_UNIT));
    1420                 :            :         }
    1421                 :            :     }
    1422                 :   14402500 : }
    1423                 :            : 
    1424                 :            : /* For a tree REF return its base if it is the base of a MEM_REF
    1425                 :            :    that cannot be rewritten into SSA form.  Otherwise return NULL_TREE.  */
    1426                 :            : 
    1427                 :            : static tree
    1428                 :  152924000 : non_rewritable_mem_ref_base (tree ref)
    1429                 :            : {
    1430                 :  152924000 :   tree base;
    1431                 :            : 
    1432                 :            :   /* A plain decl does not need it set.  */
    1433                 :  152924000 :   if (DECL_P (ref))
    1434                 :            :     return NULL_TREE;
    1435                 :            : 
    1436                 :  134784000 :   if (! (base = CONST_CAST_TREE (strip_invariant_refs (ref))))
    1437                 :            :     {
    1438                 :    1789940 :       base = get_base_address (ref);
    1439                 :    1789940 :       if (DECL_P (base))
    1440                 :            :         return base;
    1441                 :     636521 :       return NULL_TREE;
    1442                 :            :     }
    1443                 :            : 
    1444                 :            :   /* But watch out for MEM_REFs we cannot lower to a
    1445                 :            :      VIEW_CONVERT_EXPR or a BIT_FIELD_REF.  */
    1446                 :  132994000 :   if (TREE_CODE (base) == MEM_REF
    1447                 :  132994000 :       && TREE_CODE (TREE_OPERAND (base, 0)) == ADDR_EXPR)
    1448                 :            :     {
    1449                 :    3584980 :       tree decl = TREE_OPERAND (TREE_OPERAND (base, 0), 0);
    1450                 :    3584980 :       if (! DECL_P (decl))
    1451                 :            :         return NULL_TREE;
    1452                 :    3560660 :       if (! is_gimple_reg_type (TREE_TYPE (base))
    1453                 :    2253790 :           || VOID_TYPE_P (TREE_TYPE (base))
    1454                 :    5814440 :           || TREE_THIS_VOLATILE (decl) != TREE_THIS_VOLATILE (base))
    1455                 :            :         return decl;
    1456                 :    2253290 :       if ((TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE
    1457                 :    2253000 :            || TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE)
    1458                 :        561 :           && useless_type_conversion_p (TREE_TYPE (base),
    1459                 :        561 :                                         TREE_TYPE (TREE_TYPE (decl)))
    1460                 :        153 :           && known_ge (mem_ref_offset (base), 0)
    1461                 :        116 :           && known_gt (wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl))),
    1462                 :            :                        mem_ref_offset (base))
    1463                 :    2253400 :           && multiple_of_p (sizetype, TREE_OPERAND (base, 1),
    1464                 :        112 :                             TYPE_SIZE_UNIT (TREE_TYPE (base))))
    1465                 :        112 :         return NULL_TREE;
    1466                 :            :       /* For same sizes and zero offset we can use a VIEW_CONVERT_EXPR.  */
    1467                 :    2253180 :       if (integer_zerop (TREE_OPERAND (base, 1))
    1468                 :    3794310 :           && DECL_SIZE (decl) == TYPE_SIZE (TREE_TYPE (base)))
    1469                 :            :         return NULL_TREE;
    1470                 :            :       /* For integral typed extracts we can use a BIT_FIELD_REF.  */
    1471                 :    2030860 :       if (DECL_SIZE (decl)
    1472                 :    2030430 :           && TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST
    1473                 :    2030430 :           && (known_subrange_p
    1474                 :    2030430 :               (mem_ref_offset (base),
    1475                 :    2030430 :                wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (base))),
    1476                 :    2030430 :                0, wi::to_poly_offset (DECL_SIZE_UNIT (decl))))
    1477                 :            :           /* ???  We can't handle bitfield precision extracts without
    1478                 :            :              either using an alternate type for the BIT_FIELD_REF and
    1479                 :            :              then doing a conversion or possibly adjusting the offset
    1480                 :            :              according to endianness.  */
    1481                 :    2029740 :           && (! INTEGRAL_TYPE_P (TREE_TYPE (base))
    1482                 :    1316930 :               || (wi::to_offset (TYPE_SIZE (TREE_TYPE (base)))
    1483                 :    2633850 :                   == TYPE_PRECISION (TREE_TYPE (base))))
    1484                 :    4057070 :           && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (base))),
    1485                 :    4052410 :                              BITS_PER_UNIT) == 0)
    1486                 :    2026200 :         return NULL_TREE;
    1487                 :       4660 :       return decl;
    1488                 :            :     }
    1489                 :            : 
    1490                 :            :   return NULL_TREE;
    1491                 :            : }
    1492                 :            : 
    1493                 :            : /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
    1494                 :            :    Otherwise return true.  */
    1495                 :            : 
    1496                 :            : static bool 
    1497                 :   59477300 : non_rewritable_lvalue_p (tree lhs)
    1498                 :            : {
    1499                 :            :   /* A plain decl is always rewritable.  */
    1500                 :   59477300 :   if (DECL_P (lhs))
    1501                 :            :     return false;
    1502                 :            : 
    1503                 :            :   /* We can re-write REALPART_EXPR and IMAGPART_EXPR sets in
    1504                 :            :      a reasonably efficient manner... */
    1505                 :   35128600 :   if ((TREE_CODE (lhs) == REALPART_EXPR
    1506                 :   35128600 :        || TREE_CODE (lhs) == IMAGPART_EXPR)
    1507                 :   35128600 :       && DECL_P (TREE_OPERAND (lhs, 0)))
    1508                 :            :     return false;
    1509                 :            : 
    1510                 :            :   /* ???  The following could be relaxed allowing component
    1511                 :            :      references that do not change the access size.  */
    1512                 :   35115100 :   if (TREE_CODE (lhs) == MEM_REF
    1513                 :   35115100 :       && TREE_CODE (TREE_OPERAND (lhs, 0)) == ADDR_EXPR)
    1514                 :            :     {
    1515                 :    3673800 :       tree decl = TREE_OPERAND (TREE_OPERAND (lhs, 0), 0);
    1516                 :            : 
    1517                 :            :       /* A decl that is wrapped inside a MEM-REF that covers
    1518                 :            :          it full is also rewritable.  */
    1519                 :    3673800 :       if (integer_zerop (TREE_OPERAND (lhs, 1))
    1520                 :    1417790 :           && DECL_P (decl)
    1521                 :    1417790 :           && DECL_SIZE (decl) == TYPE_SIZE (TREE_TYPE (lhs))
    1522                 :            :           /* If the dynamic type of the decl has larger precision than
    1523                 :            :              the decl itself we can't use the decls type for SSA rewriting.  */
    1524                 :     715819 :           && ((! INTEGRAL_TYPE_P (TREE_TYPE (decl))
    1525                 :       5650 :                || compare_tree_int (DECL_SIZE (decl),
    1526                 :       5650 :                                     TYPE_PRECISION (TREE_TYPE (decl))) == 0)
    1527                 :        782 :               || (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
    1528                 :        782 :                   && (TYPE_PRECISION (TREE_TYPE (decl))
    1529                 :        782 :                       >= TYPE_PRECISION (TREE_TYPE (lhs)))))
    1530                 :            :           /* Make sure we are not re-writing non-float copying into float
    1531                 :            :              copying as that can incur normalization.  */
    1532                 :     715706 :           && (! FLOAT_TYPE_P (TREE_TYPE (decl))
    1533                 :       1120 :               || types_compatible_p (TREE_TYPE (lhs), TREE_TYPE (decl)))
    1534                 :    4389000 :           && (TREE_THIS_VOLATILE (decl) == TREE_THIS_VOLATILE (lhs)))
    1535                 :            :         return false;
    1536                 :            : 
    1537                 :            :       /* A vector-insert using a MEM_REF or ARRAY_REF is rewritable
    1538                 :            :          using a BIT_INSERT_EXPR.  */
    1539                 :    2959210 :       if (DECL_P (decl)
    1540                 :    2959210 :           && VECTOR_TYPE_P (TREE_TYPE (decl))
    1541                 :        156 :           && TYPE_MODE (TREE_TYPE (decl)) != BLKmode
    1542                 :        150 :           && known_ge (mem_ref_offset (lhs), 0)
    1543                 :    2959210 :           && known_gt (wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl))),
    1544                 :            :                        mem_ref_offset (lhs))
    1545                 :    2959340 :           && multiple_of_p (sizetype, TREE_OPERAND (lhs, 1),
    1546                 :        125 :                             TYPE_SIZE_UNIT (TREE_TYPE (lhs))))
    1547                 :            :         {
    1548                 :        125 :           poly_uint64 lhs_bits, nelts;
    1549                 :        125 :           if (poly_int_tree_p (TYPE_SIZE (TREE_TYPE (lhs)), &lhs_bits)
    1550                 :        127 :               && multiple_p (lhs_bits,
    1551                 :            :                              tree_to_uhwi
    1552                 :        125 :                                (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl)))),
    1553                 :            :                              &nelts)
    1554                 :        143 :               && valid_vector_subparts_p (nelts))
    1555                 :            :             {
    1556                 :        107 :               if (known_eq (nelts, 1u))
    1557                 :        107 :                 return false;
    1558                 :            :               /* For sub-vector inserts the insert vector mode has to be
    1559                 :            :                  supported.  */
    1560                 :         53 :               tree vtype = build_vector_type (TREE_TYPE (TREE_TYPE (decl)),
    1561                 :            :                                               nelts);
    1562                 :         53 :               if (TYPE_MODE (vtype) != BLKmode)
    1563                 :            :                 return false;
    1564                 :            :             }
    1565                 :            :         }
    1566                 :            :     }
    1567                 :            : 
    1568                 :            :   /* A vector-insert using a BIT_FIELD_REF is rewritable using
    1569                 :            :      BIT_INSERT_EXPR.  */
    1570                 :   34400400 :   if (TREE_CODE (lhs) == BIT_FIELD_REF
    1571                 :      13969 :       && DECL_P (TREE_OPERAND (lhs, 0))
    1572                 :      13796 :       && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs, 0)))
    1573                 :      13796 :       && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs, 0))) != BLKmode
    1574                 :        663 :       && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs)),
    1575                 :        663 :                           TYPE_SIZE_UNIT
    1576                 :            :                             (TREE_TYPE (TREE_TYPE (TREE_OPERAND (lhs, 0)))), 0)
    1577                 :   34401000 :       && (tree_to_uhwi (TREE_OPERAND (lhs, 2))
    1578                 :        663 :           % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs)))) == 0)
    1579                 :        663 :     return false;
    1580                 :            : 
    1581                 :            :   return true;
    1582                 :            : }
    1583                 :            : 
    1584                 :            : /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
    1585                 :            :    mark the variable VAR for conversion into SSA.  Return true when updating
    1586                 :            :    stmts is required.  */
    1587                 :            : 
    1588                 :            : static void
    1589                 :   56108800 : maybe_optimize_var (tree var, bitmap addresses_taken, bitmap not_reg_needs,
    1590                 :            :                     bitmap suitable_for_renaming)
    1591                 :            : {
    1592                 :            :   /* Global Variables, result decls cannot be changed.  */
    1593                 :   56108800 :   if (is_global_var (var)
    1594                 :   55146300 :       || TREE_CODE (var) == RESULT_DECL
    1595                 :  111255000 :       || bitmap_bit_p (addresses_taken, DECL_UID (var)))
    1596                 :    5769180 :     return;
    1597                 :            : 
    1598                 :   50339600 :   if (TREE_ADDRESSABLE (var)
    1599                 :            :       /* Do not change TREE_ADDRESSABLE if we need to preserve var as
    1600                 :            :          a non-register.  Otherwise we are confused and forget to
    1601                 :            :          add virtual operands for it.  */
    1602                 :     913113 :       && (!is_gimple_reg_type (TREE_TYPE (var))
    1603                 :     394364 :           || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE
    1604                 :     389980 :           || TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
    1605                 :   50725700 :           || !bitmap_bit_p (not_reg_needs, DECL_UID (var))))
    1606                 :            :     {
    1607                 :     911317 :       TREE_ADDRESSABLE (var) = 0;
    1608                 :            :       /* If we cleared TREE_ADDRESSABLE make sure DECL_GIMPLE_REG_P
    1609                 :            :          is unset if we cannot rewrite the var into SSA.  */
    1610                 :     911317 :       if ((TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE
    1611                 :     906933 :            || TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE)
    1612                 :     919627 :           && bitmap_bit_p (not_reg_needs, DECL_UID (var)))
    1613                 :       2311 :         DECL_GIMPLE_REG_P (var) = 0;
    1614                 :     911317 :       if (is_gimple_reg (var))
    1615                 :     384212 :         bitmap_set_bit (suitable_for_renaming, DECL_UID (var));
    1616                 :     911317 :       if (dump_file)
    1617                 :            :         {
    1618                 :         43 :           fprintf (dump_file, "No longer having address taken: ");
    1619                 :         43 :           print_generic_expr (dump_file, var);
    1620                 :         43 :           fprintf (dump_file, "\n");
    1621                 :            :         }
    1622                 :            :     }
    1623                 :            : 
    1624                 :   50339600 :   if (!DECL_GIMPLE_REG_P (var)
    1625                 :   49198400 :       && !bitmap_bit_p (not_reg_needs, DECL_UID (var))
    1626                 :   45412900 :       && (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
    1627                 :   45331200 :           || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE)
    1628                 :      89705 :       && !TREE_THIS_VOLATILE (var)
    1629                 :   50349000 :       && (!VAR_P (var) || !DECL_HARD_REGISTER (var)))
    1630                 :            :     {
    1631                 :       7298 :       DECL_GIMPLE_REG_P (var) = 1;
    1632                 :       7298 :       bitmap_set_bit (suitable_for_renaming, DECL_UID (var));
    1633                 :       7298 :       if (dump_file)
    1634                 :            :         {
    1635                 :          5 :           fprintf (dump_file, "Now a gimple register: ");
    1636                 :          5 :           print_generic_expr (dump_file, var);
    1637                 :          5 :           fprintf (dump_file, "\n");
    1638                 :            :         }
    1639                 :            :     }
    1640                 :            : }
    1641                 :            : 
    1642                 :            : /* Return true when STMT is ASAN mark where second argument is an address
    1643                 :            :    of a local variable.  */
    1644                 :            : 
    1645                 :            : static bool
    1646                 :   30389100 : is_asan_mark_p (gimple *stmt)
    1647                 :            : {
    1648                 :   30389100 :   if (!gimple_call_internal_p (stmt, IFN_ASAN_MARK))
    1649                 :            :     return false;
    1650                 :            : 
    1651                 :      28784 :   tree addr = get_base_address (gimple_call_arg (stmt, 1));
    1652                 :      28784 :   if (TREE_CODE (addr) == ADDR_EXPR
    1653                 :      28784 :       && VAR_P (TREE_OPERAND (addr, 0)))
    1654                 :            :     {
    1655                 :      28722 :       tree var = TREE_OPERAND (addr, 0);
    1656                 :      57444 :       if (lookup_attribute (ASAN_USE_AFTER_SCOPE_ATTRIBUTE,
    1657                 :      28722 :                             DECL_ATTRIBUTES (var)))
    1658                 :            :         return false;
    1659                 :            : 
    1660                 :      26949 :       unsigned addressable = TREE_ADDRESSABLE (var);
    1661                 :      26949 :       TREE_ADDRESSABLE (var) = 0;
    1662                 :      26949 :       bool r = is_gimple_reg (var);
    1663                 :      26949 :       TREE_ADDRESSABLE (var) = addressable;
    1664                 :      26949 :       return r;
    1665                 :            :     }
    1666                 :            : 
    1667                 :            :   return false;
    1668                 :            : }
    1669                 :            : 
    1670                 :            : /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables.  */
    1671                 :            : 
    1672                 :            : void
    1673                 :    6839490 : execute_update_addresses_taken (void)
    1674                 :            : {
    1675                 :    6839490 :   basic_block bb;
    1676                 :    6839490 :   auto_bitmap addresses_taken;
    1677                 :    6839490 :   auto_bitmap not_reg_needs;
    1678                 :    6839490 :   auto_bitmap suitable_for_renaming;
    1679                 :    6839490 :   tree var;
    1680                 :    6839490 :   unsigned i;
    1681                 :            : 
    1682                 :    6839490 :   timevar_push (TV_ADDRESS_TAKEN);
    1683                 :            : 
    1684                 :            :   /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
    1685                 :            :      the function body.  */
    1686                 :   62338300 :   FOR_EACH_BB_FN (bb, cfun)
    1687                 :            :     {
    1688                 :  516860000 :       for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
    1689                 :  405862000 :            gsi_next (&gsi))
    1690                 :            :         {
    1691                 :  405862000 :           gimple *stmt = gsi_stmt (gsi);
    1692                 :  405862000 :           enum gimple_code code = gimple_code (stmt);
    1693                 :  405862000 :           tree decl;
    1694                 :            : 
    1695                 :  405862000 :           if (code == GIMPLE_CALL)
    1696                 :            :             {
    1697                 :   28760300 :               if (optimize_atomic_compare_exchange_p (stmt))
    1698                 :            :                 {
    1699                 :            :                   /* For __atomic_compare_exchange_N if the second argument
    1700                 :            :                      is &var, don't mark var addressable;
    1701                 :            :                      if it becomes non-addressable, we'll rewrite it into
    1702                 :            :                      ATOMIC_COMPARE_EXCHANGE call.  */
    1703                 :       5129 :                   tree arg = gimple_call_arg (stmt, 1);
    1704                 :       5129 :                   gimple_call_set_arg (stmt, 1, null_pointer_node);
    1705                 :       5129 :                   gimple_ior_addresses_taken (addresses_taken, stmt);
    1706                 :       5129 :                   gimple_call_set_arg (stmt, 1, arg);
    1707                 :            :                 }
    1708                 :   28755200 :               else if (is_asan_mark_p (stmt)
    1709                 :   28755200 :                        || gimple_call_internal_p (stmt, IFN_GOMP_SIMT_ENTER))
    1710                 :            :                 ;
    1711                 :            :               else
    1712                 :   28747200 :                 gimple_ior_addresses_taken (addresses_taken, stmt);
    1713                 :            :             }
    1714                 :            :           else
    1715                 :            :             /* Note all addresses taken by the stmt.  */
    1716                 :  377102000 :             gimple_ior_addresses_taken (addresses_taken, stmt);
    1717                 :            : 
    1718                 :            :           /* If we have a call or an assignment, see if the lhs contains
    1719                 :            :              a local decl that requires not to be a gimple register.  */
    1720                 :  405862000 :           if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
    1721                 :            :             {
    1722                 :  162882000 :               tree lhs = gimple_get_lhs (stmt);
    1723                 :  162882000 :               if (lhs
    1724                 :  145792000 :                   && TREE_CODE (lhs) != SSA_NAME
    1725                 :  222328000 :                   && ((code == GIMPLE_CALL && ! DECL_P (lhs))
    1726                 :   59404000 :                       || non_rewritable_lvalue_p (lhs)))
    1727                 :            :                 {
    1728                 :   34435900 :                   decl = get_base_address (lhs);
    1729                 :   34435900 :                   if (DECL_P (decl))
    1730                 :   24415400 :                     bitmap_set_bit (not_reg_needs, DECL_UID (decl));
    1731                 :            :                 }
    1732                 :            :             }
    1733                 :            : 
    1734                 :  405862000 :           if (gimple_assign_single_p (stmt))
    1735                 :            :             {
    1736                 :   95760100 :               tree rhs = gimple_assign_rhs1 (stmt);
    1737                 :   95760100 :               if ((decl = non_rewritable_mem_ref_base (rhs)))
    1738                 :    2460500 :                 bitmap_set_bit (not_reg_needs, DECL_UID (decl));
    1739                 :            :             }
    1740                 :            : 
    1741                 :  310102000 :           else if (code == GIMPLE_CALL)
    1742                 :            :             {
    1743                 :   82373400 :               for (i = 0; i < gimple_call_num_args (stmt); ++i)
    1744                 :            :                 {
    1745                 :   53613100 :                   tree arg = gimple_call_arg (stmt, i);
    1746                 :   53613100 :                   if ((decl = non_rewritable_mem_ref_base (arg)))
    1747                 :       1984 :                     bitmap_set_bit (not_reg_needs, DECL_UID (decl));
    1748                 :            :                 }
    1749                 :            :             }
    1750                 :            : 
    1751                 :  281342000 :           else if (code == GIMPLE_ASM)
    1752                 :            :             {
    1753                 :     466558 :               gasm *asm_stmt = as_a <gasm *> (stmt);
    1754                 :    1001090 :               for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i)
    1755                 :            :                 {
    1756                 :     534532 :                   tree link = gimple_asm_output_op (asm_stmt, i);
    1757                 :     534532 :                   tree lhs = TREE_VALUE (link);
    1758                 :     534532 :                   if (TREE_CODE (lhs) != SSA_NAME)
    1759                 :            :                     {
    1760                 :     128048 :                       decl = get_base_address (lhs);
    1761                 :     128048 :                       if (DECL_P (decl)
    1762                 :     128048 :                           && (non_rewritable_lvalue_p (lhs)
    1763                 :            :                               /* We cannot move required conversions from
    1764                 :            :                                  the lhs to the rhs in asm statements, so
    1765                 :            :                                  require we do not need any.  */
    1766                 :      67300 :                               || !useless_type_conversion_p
    1767                 :      67300 :                                     (TREE_TYPE (lhs), TREE_TYPE (decl))))
    1768                 :       6232 :                         bitmap_set_bit (not_reg_needs, DECL_UID (decl));
    1769                 :            :                     }
    1770                 :            :                 }
    1771                 :     755595 :               for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
    1772                 :            :                 {
    1773                 :     289037 :                   tree link = gimple_asm_input_op (asm_stmt, i);
    1774                 :     289037 :                   if ((decl = non_rewritable_mem_ref_base (TREE_VALUE (link))))
    1775                 :         19 :                     bitmap_set_bit (not_reg_needs, DECL_UID (decl));
    1776                 :            :                 }
    1777                 :            :             }
    1778                 :            :         }
    1779                 :            : 
    1780                 :   72533300 :       for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
    1781                 :   17034500 :            gsi_next (&gsi))
    1782                 :            :         {
    1783                 :   17034500 :           size_t i;
    1784                 :   17034500 :           gphi *phi = gsi.phi ();
    1785                 :            : 
    1786                 :   59858800 :           for (i = 0; i < gimple_phi_num_args (phi); i++)
    1787                 :            :             {
    1788                 :   42824300 :               tree op = PHI_ARG_DEF (phi, i), var;
    1789                 :   42824300 :               if (TREE_CODE (op) == ADDR_EXPR
    1790                 :     300508 :                   && (var = get_base_address (TREE_OPERAND (op, 0))) != NULL
    1791                 :   43124800 :                   && DECL_P (var))
    1792                 :     228347 :                 bitmap_set_bit (addresses_taken, DECL_UID (var));
    1793                 :            :             }
    1794                 :            :         }
    1795                 :            :     }
    1796                 :            : 
    1797                 :            :   /* We cannot iterate over all referenced vars because that can contain
    1798                 :            :      unused vars from BLOCK trees, which causes code generation differences
    1799                 :            :      for -g vs. -g0.  */
    1800                 :   21094600 :   for (var = DECL_ARGUMENTS (cfun->decl); var; var = DECL_CHAIN (var))
    1801                 :   14255100 :     maybe_optimize_var (var, addresses_taken, not_reg_needs,
    1802                 :            :                         suitable_for_renaming);
    1803                 :            : 
    1804                 :   48693200 :   FOR_EACH_VEC_SAFE_ELT (cfun->local_decls, i, var)
    1805                 :   41853700 :     maybe_optimize_var (var, addresses_taken, not_reg_needs,
    1806                 :            :                         suitable_for_renaming);
    1807                 :            : 
    1808                 :            :   /* Operand caches need to be recomputed for operands referencing the updated
    1809                 :            :      variables and operands need to be rewritten to expose bare symbols.  */
    1810                 :    6839490 :   if (!bitmap_empty_p (suitable_for_renaming))
    1811                 :            :     {
    1812                 :    3625240 :       FOR_EACH_BB_FN (bb, cfun)
    1813                 :   28657900 :         for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
    1814                 :            :           {
    1815                 :   21686100 :             gimple *stmt = gsi_stmt (gsi);
    1816                 :            : 
    1817                 :            :             /* Re-write TARGET_MEM_REFs of symbols we want to
    1818                 :            :                rewrite into SSA form.  */
    1819                 :   21686100 :             if (gimple_assign_single_p (stmt))
    1820                 :            :               {
    1821                 :    8153570 :                 tree lhs = gimple_assign_lhs (stmt);
    1822                 :    8153570 :                 tree rhs, *rhsp = gimple_assign_rhs1_ptr (stmt);
    1823                 :    8153570 :                 tree sym;
    1824                 :            : 
    1825                 :            :                 /* Rewrite LHS IMAG/REALPART_EXPR similar to
    1826                 :            :                    gimplify_modify_expr_complex_part.  */
    1827                 :    8153570 :                 if ((TREE_CODE (lhs) == IMAGPART_EXPR
    1828                 :    8153570 :                      || TREE_CODE (lhs) == REALPART_EXPR)
    1829                 :       1431 :                     && DECL_P (TREE_OPERAND (lhs, 0))
    1830                 :    8154420 :                     && bitmap_bit_p (suitable_for_renaming,
    1831                 :        850 :                                      DECL_UID (TREE_OPERAND (lhs, 0))))
    1832                 :            :                   {
    1833                 :        784 :                     tree other = make_ssa_name (TREE_TYPE (lhs));
    1834                 :       1568 :                     tree lrhs = build1 (TREE_CODE (lhs) == IMAGPART_EXPR
    1835                 :            :                                         ? REALPART_EXPR : IMAGPART_EXPR,
    1836                 :        784 :                                         TREE_TYPE (other),
    1837                 :        784 :                                         TREE_OPERAND (lhs, 0));
    1838                 :        784 :                     gimple *load = gimple_build_assign (other, lrhs);
    1839                 :        784 :                     location_t loc = gimple_location (stmt);
    1840                 :        784 :                     gimple_set_location (load, loc);
    1841                 :       1568 :                     gimple_set_vuse (load, gimple_vuse (stmt));
    1842                 :        784 :                     gsi_insert_before (&gsi, load, GSI_SAME_STMT);
    1843                 :        784 :                     gimple_assign_set_lhs (stmt, TREE_OPERAND (lhs, 0));
    1844                 :        784 :                     gimple_assign_set_rhs_with_ops
    1845                 :       1175 :                       (&gsi, COMPLEX_EXPR,
    1846                 :            :                        TREE_CODE (lhs) == IMAGPART_EXPR
    1847                 :        391 :                        ? other : gimple_assign_rhs1 (stmt),
    1848                 :        784 :                        TREE_CODE (lhs) == IMAGPART_EXPR
    1849                 :        393 :                        ? gimple_assign_rhs1 (stmt) : other, NULL_TREE);
    1850                 :        784 :                     stmt = gsi_stmt (gsi);
    1851                 :        784 :                     unlink_stmt_vdef (stmt);
    1852                 :        784 :                     update_stmt (stmt);
    1853                 :        784 :                     continue;
    1854                 :            :                   }
    1855                 :            : 
    1856                 :            :                 /* Rewrite a vector insert via a BIT_FIELD_REF on the LHS
    1857                 :            :                    into a BIT_INSERT_EXPR.  */
    1858                 :    8152780 :                 if (TREE_CODE (lhs) == BIT_FIELD_REF
    1859                 :        278 :                     && DECL_P (TREE_OPERAND (lhs, 0))
    1860                 :        278 :                     && bitmap_bit_p (suitable_for_renaming,
    1861                 :        278 :                                      DECL_UID (TREE_OPERAND (lhs, 0)))
    1862                 :        185 :                     && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs, 0)))
    1863                 :        185 :                     && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs, 0))) != BLKmode
    1864                 :        185 :                     && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs)),
    1865                 :        185 :                                         TYPE_SIZE_UNIT (TREE_TYPE
    1866                 :            :                                           (TREE_TYPE (TREE_OPERAND (lhs, 0)))),
    1867                 :            :                                         0)
    1868                 :    8152970 :                     && (tree_to_uhwi (TREE_OPERAND (lhs, 2))
    1869                 :        185 :                         % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs))) == 0))
    1870                 :            :                   {
    1871                 :        185 :                     tree var = TREE_OPERAND (lhs, 0);
    1872                 :        185 :                     tree val = gimple_assign_rhs1 (stmt);
    1873                 :        370 :                     if (! types_compatible_p (TREE_TYPE (TREE_TYPE (var)),
    1874                 :        185 :                                               TREE_TYPE (val)))
    1875                 :            :                       {
    1876                 :          0 :                         tree tem = make_ssa_name (TREE_TYPE (TREE_TYPE (var)));
    1877                 :          0 :                         gimple *pun
    1878                 :          0 :                           = gimple_build_assign (tem,
    1879                 :            :                                                  build1 (VIEW_CONVERT_EXPR,
    1880                 :          0 :                                                          TREE_TYPE (tem), val));
    1881                 :          0 :                         gsi_insert_before (&gsi, pun, GSI_SAME_STMT);
    1882                 :          0 :                         val = tem;
    1883                 :            :                       }
    1884                 :        185 :                     tree bitpos = TREE_OPERAND (lhs, 2);
    1885                 :        185 :                     gimple_assign_set_lhs (stmt, var);
    1886                 :        185 :                     gimple_assign_set_rhs_with_ops
    1887                 :        185 :                       (&gsi, BIT_INSERT_EXPR, var, val, bitpos);
    1888                 :        185 :                     stmt = gsi_stmt (gsi);
    1889                 :        185 :                     unlink_stmt_vdef (stmt);
    1890                 :        185 :                     update_stmt (stmt);
    1891                 :        185 :                     continue;
    1892                 :            :                   }
    1893                 :            : 
    1894                 :            :                 /* Rewrite a vector insert using a MEM_REF on the LHS
    1895                 :            :                    into a BIT_INSERT_EXPR.  */
    1896                 :    8152600 :                 if (TREE_CODE (lhs) == MEM_REF
    1897                 :     330423 :                     && TREE_CODE (TREE_OPERAND (lhs, 0)) == ADDR_EXPR
    1898                 :      80822 :                     && (sym = TREE_OPERAND (TREE_OPERAND (lhs, 0), 0))
    1899                 :      80822 :                     && DECL_P (sym)
    1900                 :      80822 :                     && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym))
    1901                 :       4026 :                     && VECTOR_TYPE_P (TREE_TYPE (sym))
    1902                 :         99 :                     && TYPE_MODE (TREE_TYPE (sym)) != BLKmode
    1903                 :            :                     /* If it is a full replacement we can do better below.  */
    1904                 :         99 :                     && maybe_ne (wi::to_poly_offset
    1905                 :         99 :                                    (TYPE_SIZE_UNIT (TREE_TYPE (lhs))),
    1906                 :            :                                  wi::to_poly_offset
    1907                 :         99 :                                    (TYPE_SIZE_UNIT (TREE_TYPE (sym))))
    1908                 :         76 :                     && known_ge (mem_ref_offset (lhs), 0)
    1909                 :    8152600 :                     && known_gt (wi::to_poly_offset
    1910                 :            :                                    (TYPE_SIZE_UNIT (TREE_TYPE (sym))),
    1911                 :            :                                  mem_ref_offset (lhs))
    1912                 :    8152670 :                     && multiple_of_p (sizetype,
    1913                 :         76 :                                       TREE_OPERAND (lhs, 1),
    1914                 :         76 :                                       TYPE_SIZE_UNIT (TREE_TYPE (lhs))))
    1915                 :            :                   {
    1916                 :         76 :                     tree val = gimple_assign_rhs1 (stmt);
    1917                 :        152 :                     if (! types_compatible_p (TREE_TYPE (val),
    1918                 :         76 :                                               TREE_TYPE (TREE_TYPE (sym))))
    1919                 :            :                       {
    1920                 :         56 :                         poly_uint64 lhs_bits, nelts;
    1921                 :         56 :                         tree temtype = TREE_TYPE (TREE_TYPE (sym));
    1922                 :         56 :                         if (poly_int_tree_p (TYPE_SIZE (TREE_TYPE (lhs)),
    1923                 :            :                                              &lhs_bits)
    1924                 :        168 :                             && multiple_p (lhs_bits,
    1925                 :            :                                            tree_to_uhwi
    1926                 :         56 :                                              (TYPE_SIZE (TREE_TYPE
    1927                 :            :                                                            (TREE_TYPE (sym)))),
    1928                 :            :                                            &nelts)
    1929                 :         56 :                             && maybe_ne (nelts, 1u)
    1930                 :        112 :                             && valid_vector_subparts_p (nelts))
    1931                 :         30 :                           temtype = build_vector_type (temtype, nelts);
    1932                 :         56 :                         tree tem = make_ssa_name (temtype);
    1933                 :         56 :                         gimple *pun
    1934                 :         56 :                           = gimple_build_assign (tem,
    1935                 :            :                                                  build1 (VIEW_CONVERT_EXPR,
    1936                 :         56 :                                                          TREE_TYPE (tem), val));
    1937                 :         56 :                         gsi_insert_before (&gsi, pun, GSI_SAME_STMT);
    1938                 :         56 :                         val = tem;
    1939                 :            :                       }
    1940                 :         76 :                     tree bitpos
    1941                 :         76 :                       = wide_int_to_tree (bitsizetype,
    1942                 :         76 :                                           mem_ref_offset (lhs) * BITS_PER_UNIT);
    1943                 :         76 :                     gimple_assign_set_lhs (stmt, sym);
    1944                 :         76 :                     gimple_assign_set_rhs_with_ops
    1945                 :         76 :                       (&gsi, BIT_INSERT_EXPR, sym, val, bitpos);
    1946                 :         76 :                     stmt = gsi_stmt (gsi);
    1947                 :         76 :                     unlink_stmt_vdef (stmt);
    1948                 :         76 :                     update_stmt (stmt);
    1949                 :         76 :                     continue;
    1950                 :            :                   }
    1951                 :            : 
    1952                 :            :                 /* We shouldn't have any fancy wrapping of
    1953                 :            :                    component-refs on the LHS, but look through
    1954                 :            :                    VIEW_CONVERT_EXPRs as that is easy.  */
    1955                 :    8152520 :                 while (TREE_CODE (lhs) == VIEW_CONVERT_EXPR)
    1956                 :          0 :                   lhs = TREE_OPERAND (lhs, 0);
    1957                 :    8152520 :                 if (TREE_CODE (lhs) == MEM_REF
    1958                 :     330347 :                     && TREE_CODE (TREE_OPERAND (lhs, 0)) == ADDR_EXPR
    1959                 :      80746 :                     && integer_zerop (TREE_OPERAND (lhs, 1))
    1960                 :      58454 :                     && (sym = TREE_OPERAND (TREE_OPERAND (lhs, 0), 0))
    1961                 :      58454 :                     && DECL_P (sym)
    1962                 :      58454 :                     && !TREE_ADDRESSABLE (sym)
    1963                 :    8179010 :                     && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym)))
    1964                 :            :                   lhs = sym;
    1965                 :            :                 else
    1966                 :    8148570 :                   lhs = gimple_assign_lhs (stmt);
    1967                 :            : 
    1968                 :            :                 /* Rewrite the RHS and make sure the resulting assignment
    1969                 :            :                    is validly typed.  */
    1970                 :    8152520 :                 maybe_rewrite_mem_ref_base (rhsp, suitable_for_renaming);
    1971                 :    8152520 :                 rhs = gimple_assign_rhs1 (stmt);
    1972                 :    8152520 :                 if (gimple_assign_lhs (stmt) != lhs
    1973                 :    8156470 :                     && !useless_type_conversion_p (TREE_TYPE (lhs),
    1974                 :       3950 :                                                    TREE_TYPE (rhs)))
    1975                 :            :                   {
    1976                 :       1874 :                     if (gimple_clobber_p (stmt))
    1977                 :            :                       {
    1978                 :          5 :                         rhs = build_constructor (TREE_TYPE (lhs), NULL);
    1979                 :          5 :                         TREE_THIS_VOLATILE (rhs) = 1;
    1980                 :            :                       }
    1981                 :            :                     else
    1982                 :       1869 :                       rhs = fold_build1 (VIEW_CONVERT_EXPR,
    1983                 :            :                                          TREE_TYPE (lhs), rhs);
    1984                 :            :                   }
    1985                 :    8152520 :                 if (gimple_assign_lhs (stmt) != lhs)
    1986                 :       3950 :                   gimple_assign_set_lhs (stmt, lhs);
    1987                 :            : 
    1988                 :    8152520 :                 if (gimple_assign_rhs1 (stmt) != rhs)
    1989                 :            :                   {
    1990                 :       1874 :                     gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    1991                 :       1874 :                     gimple_assign_set_rhs_from_tree (&gsi, rhs);
    1992                 :            :                   }
    1993                 :            :               }
    1994                 :            : 
    1995                 :   13532500 :             else if (gimple_code (stmt) == GIMPLE_CALL)
    1996                 :            :               {
    1997                 :    1639000 :                 unsigned i;
    1998                 :    1639000 :                 if (optimize_atomic_compare_exchange_p (stmt))
    1999                 :            :                   {
    2000                 :       5089 :                     tree expected = gimple_call_arg (stmt, 1);
    2001                 :       5089 :                     if (bitmap_bit_p (suitable_for_renaming,
    2002                 :       5089 :                                       DECL_UID (TREE_OPERAND (expected, 0))))
    2003                 :            :                       {
    2004                 :       5089 :                         fold_builtin_atomic_compare_exchange (&gsi);
    2005                 :       5089 :                         continue;
    2006                 :            :                       }
    2007                 :            :                   }
    2008                 :    1633910 :                 else if (is_asan_mark_p (stmt))
    2009                 :            :                   {
    2010                 :        400 :                     tree var = TREE_OPERAND (gimple_call_arg (stmt, 1), 0);
    2011                 :        400 :                     if (bitmap_bit_p (suitable_for_renaming, DECL_UID (var)))
    2012                 :            :                       {
    2013                 :        267 :                         unlink_stmt_vdef (stmt);
    2014                 :        267 :                         if (asan_mark_p (stmt, ASAN_MARK_POISON))
    2015                 :            :                           {
    2016                 :        144 :                             gcall *call
    2017                 :        144 :                               = gimple_build_call_internal (IFN_ASAN_POISON, 0);
    2018                 :        144 :                             gimple_call_set_lhs (call, var);
    2019                 :        144 :                             gsi_replace (&gsi, call, GSI_SAME_STMT);
    2020                 :            :                           }
    2021                 :            :                         else
    2022                 :            :                           {
    2023                 :            :                             /* In ASAN_MARK (UNPOISON, &b, ...) the variable
    2024                 :            :                                is uninitialized.  Avoid dependencies on
    2025                 :            :                                previous out of scope value.  */
    2026                 :        123 :                             tree clobber = build_clobber (TREE_TYPE (var));
    2027                 :        123 :                             gimple *g = gimple_build_assign (var, clobber);
    2028                 :        123 :                             gsi_replace (&gsi, g, GSI_SAME_STMT);
    2029                 :            :                           }
    2030                 :        267 :                         continue;
    2031                 :            :                       }
    2032                 :            :                   }
    2033                 :    1633510 :                 else if (gimple_call_internal_p (stmt, IFN_GOMP_SIMT_ENTER))
    2034                 :          0 :                   for (i = 1; i < gimple_call_num_args (stmt); i++)
    2035                 :            :                     {
    2036                 :          0 :                       tree *argp = gimple_call_arg_ptr (stmt, i);
    2037                 :          0 :                       if (*argp == null_pointer_node)
    2038                 :          0 :                         continue;
    2039                 :          0 :                       gcc_assert (TREE_CODE (*argp) == ADDR_EXPR
    2040                 :            :                                   && VAR_P (TREE_OPERAND (*argp, 0)));
    2041                 :          0 :                       tree var = TREE_OPERAND (*argp, 0);
    2042                 :          0 :                       if (bitmap_bit_p (suitable_for_renaming, DECL_UID (var)))
    2043                 :          0 :                         *argp = null_pointer_node;
    2044                 :            :                     }
    2045                 :    4563270 :                 for (i = 0; i < gimple_call_num_args (stmt); ++i)
    2046                 :            :                   {
    2047                 :    2929620 :                     tree *argp = gimple_call_arg_ptr (stmt, i);
    2048                 :    2929620 :                     maybe_rewrite_mem_ref_base (argp, suitable_for_renaming);
    2049                 :            :                   }
    2050                 :            :               }
    2051                 :            : 
    2052                 :   11893500 :             else if (gimple_code (stmt) == GIMPLE_ASM)
    2053                 :            :               {
    2054                 :      59276 :                 gasm *asm_stmt = as_a <gasm *> (stmt);
    2055                 :            :                 unsigned i;
    2056                 :      59276 :                 for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i)
    2057                 :            :                   {
    2058                 :      44323 :                     tree link = gimple_asm_output_op (asm_stmt, i);
    2059                 :      44323 :                     maybe_rewrite_mem_ref_base (&TREE_VALUE (link),
    2060                 :            :                                                 suitable_for_renaming);
    2061                 :            :                   }
    2062                 :      29354 :                 for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
    2063                 :            :                   {
    2064                 :      14401 :                     tree link = gimple_asm_input_op (asm_stmt, i);
    2065                 :      14401 :                     maybe_rewrite_mem_ref_base (&TREE_VALUE (link),
    2066                 :            :                                                 suitable_for_renaming);
    2067                 :            :                   }
    2068                 :            :               }
    2069                 :            : 
    2070                 :   11878600 :             else if (gimple_debug_bind_p (stmt)
    2071                 :    8676810 :                      && gimple_debug_bind_has_value_p (stmt))
    2072                 :            :               {
    2073                 :    3261600 :                 tree *valuep = gimple_debug_bind_get_value_ptr (stmt);
    2074                 :    3261600 :                 tree decl;
    2075                 :    3261600 :                 maybe_rewrite_mem_ref_base (valuep, suitable_for_renaming);
    2076                 :    3261600 :                 decl = non_rewritable_mem_ref_base (*valuep);
    2077                 :    3261600 :                 if (decl
    2078                 :    3264540 :                     && bitmap_bit_p (suitable_for_renaming, DECL_UID (decl)))
    2079                 :          0 :                   gimple_debug_bind_reset_value (stmt);
    2080                 :            :               }
    2081                 :            : 
    2082                 :   31185400 :             if (gimple_references_memory_p (stmt)
    2083                 :   19426000 :                 || is_gimple_debug (stmt))
    2084                 :   10930500 :               update_stmt (stmt);
    2085                 :            : 
    2086                 :   21679700 :             gsi_next (&gsi);
    2087                 :            :           }
    2088                 :            : 
    2089                 :            :       /* Update SSA form here, we are called as non-pass as well.  */
    2090                 :     139351 :       if (number_of_loops (cfun) > 1
    2091                 :     139351 :           && loops_state_satisfies_p (LOOP_CLOSED_SSA))
    2092                 :          0 :         rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa);
    2093                 :            :       else
    2094                 :     139351 :         update_ssa (TODO_update_ssa);
    2095                 :            :     }
    2096                 :            : 
    2097                 :    6841490 :   timevar_pop (TV_ADDRESS_TAKEN);
    2098                 :    6839490 : }
    2099                 :            : 
    2100                 :            : namespace {
    2101                 :            : 
    2102                 :            : const pass_data pass_data_update_address_taken =
    2103                 :            : {
    2104                 :            :   GIMPLE_PASS, /* type */
    2105                 :            :   "addressables", /* name */
    2106                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    2107                 :            :   TV_ADDRESS_TAKEN, /* tv_id */
    2108                 :            :   PROP_ssa, /* properties_required */
    2109                 :            :   0, /* properties_provided */
    2110                 :            :   0, /* properties_destroyed */
    2111                 :            :   0, /* todo_flags_start */
    2112                 :            :   TODO_update_address_taken, /* todo_flags_finish */
    2113                 :            : };
    2114                 :            : 
    2115                 :            : class pass_update_address_taken : public gimple_opt_pass
    2116                 :            : {
    2117                 :            : public:
    2118                 :          0 :   pass_update_address_taken (gcc::context *ctxt)
    2119                 :          0 :     : gimple_opt_pass (pass_data_update_address_taken, ctxt)
    2120                 :            :   {}
    2121                 :            : 
    2122                 :            :   /* opt_pass methods: */
    2123                 :            : 
    2124                 :            : }; // class pass_update_address_taken
    2125                 :            : 
    2126                 :            : } // anon namespace
    2127                 :            : 
    2128                 :            : gimple_opt_pass *
    2129                 :          0 : make_pass_update_address_taken (gcc::context *ctxt)
    2130                 :            : {
    2131                 :          0 :   return new pass_update_address_taken (ctxt);
    2132                 :            : }

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.