LCOV - code coverage report
Current view: top level - gcc - gimple-walk.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 441 479 92.1 %
Date: 2020-04-04 11:58:09 Functions: 8 8 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Gimple walk support.
       2                 :            : 
       3                 :            :    Copyright (C) 2007-2020 Free Software Foundation, Inc.
       4                 :            :    Contributed by Aldy Hernandez <aldyh@redhat.com>
       5                 :            : 
       6                 :            : This file is part of GCC.
       7                 :            : 
       8                 :            : GCC is free software; you can redistribute it and/or modify it under
       9                 :            : the terms of the GNU General Public License as published by the Free
      10                 :            : Software Foundation; either version 3, or (at your option) any later
      11                 :            : version.
      12                 :            : 
      13                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      14                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      15                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      16                 :            : for more details.
      17                 :            : 
      18                 :            : You should have received a copy of the GNU General Public License
      19                 :            : along with GCC; see the file COPYING3.  If not see
      20                 :            : <http://www.gnu.org/licenses/>.  */
      21                 :            : 
      22                 :            : #include "config.h"
      23                 :            : #include "system.h"
      24                 :            : #include "coretypes.h"
      25                 :            : #include "backend.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "gimple.h"
      28                 :            : #include "gimple-iterator.h"
      29                 :            : #include "gimple-walk.h"
      30                 :            : #include "stmt.h"
      31                 :            : 
      32                 :            : /* Walk all the statements in the sequence *PSEQ calling walk_gimple_stmt
      33                 :            :    on each one.  WI is as in walk_gimple_stmt.
      34                 :            : 
      35                 :            :    If walk_gimple_stmt returns non-NULL, the walk is stopped, and the
      36                 :            :    value is stored in WI->CALLBACK_RESULT.  Also, the statement that
      37                 :            :    produced the value is returned if this statement has not been
      38                 :            :    removed by a callback (wi->removed_stmt).  If the statement has
      39                 :            :    been removed, NULL is returned.
      40                 :            : 
      41                 :            :    Otherwise, all the statements are walked and NULL returned.  */
      42                 :            : 
      43                 :            : gimple *
      44                 :   25192800 : walk_gimple_seq_mod (gimple_seq *pseq, walk_stmt_fn callback_stmt,
      45                 :            :                      walk_tree_fn callback_op, struct walk_stmt_info *wi)
      46                 :            : {
      47                 :   25192800 :   gimple_stmt_iterator gsi;
      48                 :            : 
      49                 :  216566000 :   for (gsi = gsi_start (*pseq); !gsi_end_p (gsi); )
      50                 :            :     {
      51                 :  141679000 :       tree ret = walk_gimple_stmt (&gsi, callback_stmt, callback_op, wi);
      52                 :  141679000 :       if (ret)
      53                 :            :         {
      54                 :            :           /* If CALLBACK_STMT or CALLBACK_OP return a value, WI must exist
      55                 :            :              to hold it.  */
      56                 :      53685 :           gcc_assert (wi);
      57                 :      53685 :           wi->callback_result = ret;
      58                 :            : 
      59                 :      53685 :           return wi->removed_stmt ? NULL : gsi_stmt (gsi);
      60                 :            :         }
      61                 :            : 
      62                 :  141625000 :       if (!wi->removed_stmt)
      63                 :  141625000 :         gsi_next (&gsi);
      64                 :            :     }
      65                 :            : 
      66                 :   25139100 :   if (wi)
      67                 :   25139100 :     wi->callback_result = NULL_TREE;
      68                 :            : 
      69                 :            :   return NULL;
      70                 :            : }
      71                 :            : 
      72                 :            : 
      73                 :            : /* Like walk_gimple_seq_mod, but ensure that the head of SEQ isn't
      74                 :            :    changed by the callbacks.  */
      75                 :            : 
      76                 :            : gimple *
      77                 :   22286400 : walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
      78                 :            :                  walk_tree_fn callback_op, struct walk_stmt_info *wi)
      79                 :            : {
      80                 :   22286400 :   gimple_seq seq2 = seq;
      81                 :   22286400 :   gimple *ret = walk_gimple_seq_mod (&seq2, callback_stmt, callback_op, wi);
      82                 :   22286400 :   gcc_assert (seq2 == seq);
      83                 :   22286400 :   return ret;
      84                 :            : }
      85                 :            : 
      86                 :            : 
      87                 :            : /* Helper function for walk_gimple_stmt.  Walk operands of a GIMPLE_ASM.  */
      88                 :            : 
      89                 :            : static tree
      90                 :   20257100 : walk_gimple_asm (gasm *stmt, walk_tree_fn callback_op,
      91                 :            :                  struct walk_stmt_info *wi)
      92                 :            : {
      93                 :   20257100 :   tree ret, op;
      94                 :   20257100 :   unsigned noutputs;
      95                 :   20257100 :   const char **oconstraints;
      96                 :   20257100 :   unsigned i, n;
      97                 :   20257100 :   const char *constraint;
      98                 :   20257100 :   bool allows_mem, allows_reg, is_inout;
      99                 :            : 
     100                 :   20257100 :   noutputs = gimple_asm_noutputs (stmt);
     101                 :   20257100 :   oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
     102                 :            : 
     103                 :   40425200 :   for (i = 0; i < noutputs; i++)
     104                 :            :     {
     105                 :   20168000 :       op = gimple_asm_output_op (stmt, i);
     106                 :   20168000 :       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
     107                 :   20168000 :       oconstraints[i] = constraint;
     108                 :   20168000 :       if (wi)
     109                 :            :         {
     110                 :   20096900 :           if (parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
     111                 :            :                                        &allows_reg, &is_inout))
     112                 :   20301400 :             wi->val_only = (allows_reg || !allows_mem);
     113                 :            :         }
     114                 :   20168000 :       if (wi)
     115                 :   20096900 :         wi->is_lhs = true;
     116                 :   20168000 :       ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
     117                 :   20168000 :       if (ret)
     118                 :         10 :         return ret;
     119                 :            :     }
     120                 :            : 
     121                 :   20257100 :   n = gimple_asm_ninputs (stmt);
     122                 :   31748900 :   for (i = 0; i < n; i++)
     123                 :            :     {
     124                 :   11491700 :       op = gimple_asm_input_op (stmt, i);
     125                 :   11491700 :       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
     126                 :            : 
     127                 :   11491700 :       if (wi)
     128                 :            :         {
     129                 :   11447100 :           if (parse_input_constraint (&constraint, 0, 0, noutputs, 0,
     130                 :            :                                       oconstraints, &allows_mem, &allows_reg))
     131                 :            :             {
     132                 :   11447100 :               wi->val_only = (allows_reg || !allows_mem);
     133                 :            :               /* Although input "m" is not really a LHS, we need a lvalue.  */
     134                 :   11447100 :               wi->is_lhs = !wi->val_only;
     135                 :            :             }
     136                 :            :         }
     137                 :   11491700 :       ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
     138                 :   11491700 :       if (ret)
     139                 :          6 :         return ret;
     140                 :            :     }
     141                 :            : 
     142                 :   20257100 :   if (wi)
     143                 :            :     {
     144                 :   20167200 :       wi->is_lhs = false;
     145                 :   20167200 :       wi->val_only = true;
     146                 :            :     }
     147                 :            : 
     148                 :   20257100 :   n = gimple_asm_nlabels (stmt);
     149                 :   20330300 :   for (i = 0; i < n; i++)
     150                 :            :     {
     151                 :      73184 :       op = gimple_asm_label_op (stmt, i);
     152                 :      73184 :       ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
     153                 :      73184 :       if (ret)
     154                 :          0 :         return ret;
     155                 :            :     }
     156                 :            : 
     157                 :            :   return NULL_TREE;
     158                 :            : }
     159                 :            : 
     160                 :            : 
     161                 :            : /* Helper function of WALK_GIMPLE_STMT.  Walk every tree operand in
     162                 :            :    STMT.  CALLBACK_OP and WI are as in WALK_GIMPLE_STMT.
     163                 :            : 
     164                 :            :    CALLBACK_OP is called on each operand of STMT via walk_tree.
     165                 :            :    Additional parameters to walk_tree must be stored in WI.  For each operand
     166                 :            :    OP, walk_tree is called as:
     167                 :            : 
     168                 :            :         walk_tree (&OP, CALLBACK_OP, WI, WI->PSET)
     169                 :            : 
     170                 :            :    If CALLBACK_OP returns non-NULL for an operand, the remaining
     171                 :            :    operands are not scanned.
     172                 :            : 
     173                 :            :    The return value is that returned by the last call to walk_tree, or
     174                 :            :    NULL_TREE if no CALLBACK_OP is specified.  */
     175                 :            : 
     176                 :            : tree
     177                 :14147200000 : walk_gimple_op (gimple *stmt, walk_tree_fn callback_op,
     178                 :            :                 struct walk_stmt_info *wi)
     179                 :            : {
     180                 :14147200000 :   hash_set<tree> *pset = (wi) ? wi->pset : NULL;
     181                 :14147200000 :   unsigned i;
     182                 :14147200000 :   tree ret = NULL_TREE;
     183                 :            : 
     184                 :14147200000 :   if (wi)
     185                 :14117100000 :     wi->stmt = stmt;
     186                 :            : 
     187                 :14147200000 :   switch (gimple_code (stmt))
     188                 :            :     {
     189                 : 4894560000 :     case GIMPLE_ASSIGN:
     190                 :            :       /* Walk the RHS operands.  If the LHS is of a non-renamable type or
     191                 :            :          is a register variable, we may use a COMPONENT_REF on the RHS.  */
     192                 : 4894560000 :       if (wi)
     193                 :            :         {
     194                 : 4874060000 :           tree lhs = gimple_assign_lhs (stmt);
     195                 : 4874060000 :           wi->val_only
     196                 : 8447520000 :             = (is_gimple_reg_type (TREE_TYPE (lhs)) && !is_gimple_reg (lhs))
     197                 : 8447520000 :               || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
     198                 :            :         }
     199                 :            : 
     200                 :10821600000 :       for (i = 1; i < gimple_num_ops (stmt); i++)
     201                 :            :         {
     202                 : 5927120000 :           ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi,
     203                 :            :                            pset);
     204                 : 5927120000 :           if (ret)
     205                 :      47413 :             return ret;
     206                 :            :         }
     207                 :            : 
     208                 :            :       /* Walk the LHS.  If the RHS is appropriate for a memory, we
     209                 :            :          may use a COMPONENT_REF on the LHS.  */
     210                 : 4894510000 :       if (wi)
     211                 :            :         {
     212                 :            :           /* If the RHS is of a non-renamable type or is a register variable,
     213                 :            :              we may use a COMPONENT_REF on the LHS.  */
     214                 : 4874060000 :           tree rhs1 = gimple_assign_rhs1 (stmt);
     215                 : 4874060000 :           wi->val_only
     216                 : 4874060000 :             = (is_gimple_reg_type (TREE_TYPE (rhs1)) && !is_gimple_reg (rhs1))
     217                 : 7507000000 :               || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
     218                 : 4874060000 :           wi->is_lhs = true;
     219                 :            :         }
     220                 :            : 
     221                 : 4894510000 :       ret = walk_tree (gimple_op_ptr (stmt, 0), callback_op, wi, pset);
     222                 : 4894510000 :       if (ret)
     223                 :            :         return ret;
     224                 :            : 
     225                 : 4894490000 :       if (wi)
     226                 :            :         {
     227                 : 4874060000 :           wi->val_only = true;
     228                 : 4874060000 :           wi->is_lhs = false;
     229                 :            :         }
     230                 :            :       break;
     231                 :            : 
     232                 : 1124380000 :     case GIMPLE_CALL:
     233                 : 1124380000 :       if (wi)
     234                 :            :         {
     235                 : 1119770000 :           wi->is_lhs = false;
     236                 : 1119770000 :           wi->val_only = true;
     237                 :            :         }
     238                 :            : 
     239                 : 1124380000 :       ret = walk_tree (gimple_call_chain_ptr (as_a <gcall *> (stmt)),
     240                 :            :                        callback_op, wi, pset);
     241                 : 1124380000 :       if (ret)
     242                 :            :         return ret;
     243                 :            : 
     244                 : 1124380000 :       ret = walk_tree (gimple_call_fn_ptr (stmt), callback_op, wi, pset);
     245                 : 1124380000 :       if (ret)
     246                 :            :         return ret;
     247                 :            : 
     248                 : 3240850000 :       for (i = 0; i < gimple_call_num_args (stmt); i++)
     249                 :            :         {
     250                 : 2116480000 :           if (wi)
     251                 : 2107820000 :             wi->val_only
     252                 : 2107820000 :               = is_gimple_reg_type (TREE_TYPE (gimple_call_arg (stmt, i)));
     253                 : 2116480000 :           ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
     254                 :            :                            pset);
     255                 : 2116480000 :           if (ret)
     256                 :       3314 :             return ret;
     257                 :            :         }
     258                 :            : 
     259                 : 1124380000 :       if (gimple_call_lhs (stmt))
     260                 :            :         {
     261                 :  453648000 :           if (wi)
     262                 :            :             {
     263                 :  451910000 :               wi->is_lhs = true;
     264                 :  451910000 :               wi->val_only
     265                 :  451910000 :                 = is_gimple_reg_type (TREE_TYPE (gimple_call_lhs (stmt)));
     266                 :            :             }
     267                 :            : 
     268                 :  453648000 :           ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
     269                 :  453648000 :           if (ret)
     270                 :            :             return ret;
     271                 :            :         }
     272                 :            : 
     273                 : 1124380000 :       if (wi)
     274                 :            :         {
     275                 : 1119770000 :           wi->is_lhs = false;
     276                 : 1119770000 :           wi->val_only = true;
     277                 :            :         }
     278                 :            :       break;
     279                 :            : 
     280                 :      15301 :     case GIMPLE_CATCH:
     281                 :      15301 :       ret = walk_tree (gimple_catch_types_ptr (as_a <gcatch *> (stmt)),
     282                 :            :                        callback_op, wi, pset);
     283                 :      15301 :       if (ret)
     284                 :          0 :         return ret;
     285                 :            :       break;
     286                 :            : 
     287                 :         77 :     case GIMPLE_EH_FILTER:
     288                 :         77 :       ret = walk_tree (gimple_eh_filter_types_ptr (stmt), callback_op, wi,
     289                 :            :                        pset);
     290                 :         77 :       if (ret)
     291                 :          0 :         return ret;
     292                 :            :       break;
     293                 :            : 
     294                 :   20257100 :     case GIMPLE_ASM:
     295                 :   20257100 :       ret = walk_gimple_asm (as_a <gasm *> (stmt), callback_op, wi);
     296                 :   20257100 :       if (ret)
     297                 :         16 :         return ret;
     298                 :            :       break;
     299                 :            : 
     300                 :     144568 :     case GIMPLE_OMP_CONTINUE:
     301                 :     144568 :       {
     302                 :     144568 :         gomp_continue *cont_stmt = as_a <gomp_continue *> (stmt);
     303                 :     144568 :         ret = walk_tree (gimple_omp_continue_control_def_ptr (cont_stmt),
     304                 :            :                          callback_op, wi, pset);
     305                 :     144568 :         if (ret)
     306                 :            :           return ret;
     307                 :            : 
     308                 :     144568 :         ret = walk_tree (gimple_omp_continue_control_use_ptr (cont_stmt),
     309                 :            :                          callback_op, wi, pset);
     310                 :     144568 :         if (ret)
     311                 :          0 :           return ret;
     312                 :            :       }
     313                 :            :       break;
     314                 :            : 
     315                 :       1032 :     case GIMPLE_OMP_CRITICAL:
     316                 :       1032 :       {
     317                 :       1032 :         gomp_critical *omp_stmt = as_a <gomp_critical *> (stmt);
     318                 :       1032 :         ret = walk_tree (gimple_omp_critical_name_ptr (omp_stmt),
     319                 :            :                          callback_op, wi, pset);
     320                 :       1032 :         if (ret)
     321                 :            :           return ret;
     322                 :       1032 :         ret = walk_tree (gimple_omp_critical_clauses_ptr (omp_stmt),
     323                 :            :                          callback_op, wi, pset);
     324                 :       1032 :         if (ret)
     325                 :          0 :           return ret;
     326                 :            :       }
     327                 :            :       break;
     328                 :            : 
     329                 :       4537 :     case GIMPLE_OMP_ORDERED:
     330                 :       4537 :       {
     331                 :       4537 :         gomp_ordered *omp_stmt = as_a <gomp_ordered *> (stmt);
     332                 :       4537 :         ret = walk_tree (gimple_omp_ordered_clauses_ptr (omp_stmt),
     333                 :            :                          callback_op, wi, pset);
     334                 :       4537 :         if (ret)
     335                 :          0 :           return ret;
     336                 :            :       }
     337                 :            :       break;
     338                 :            : 
     339                 :        678 :     case GIMPLE_OMP_SCAN:
     340                 :        678 :       {
     341                 :        678 :         gomp_scan *scan_stmt = as_a <gomp_scan *> (stmt);
     342                 :        678 :         ret = walk_tree (gimple_omp_scan_clauses_ptr (scan_stmt),
     343                 :            :                          callback_op, wi, pset);
     344                 :        678 :         if (ret)
     345                 :          0 :           return ret;
     346                 :            :       }
     347                 :            :       break;
     348                 :            : 
     349                 :     145600 :     case GIMPLE_OMP_FOR:
     350                 :     145600 :       ret = walk_tree (gimple_omp_for_clauses_ptr (stmt), callback_op, wi,
     351                 :            :                        pset);
     352                 :     145600 :       if (ret)
     353                 :            :         return ret;
     354                 :     365016 :       for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
     355                 :            :         {
     356                 :     219416 :           ret = walk_tree (gimple_omp_for_index_ptr (stmt, i), callback_op,
     357                 :            :                            wi, pset);
     358                 :     219416 :           if (ret)
     359                 :          0 :             return ret;
     360                 :     219416 :           ret = walk_tree (gimple_omp_for_initial_ptr (stmt, i), callback_op,
     361                 :            :                            wi, pset);
     362                 :     219416 :           if (ret)
     363                 :          0 :             return ret;
     364                 :     219416 :           ret = walk_tree (gimple_omp_for_final_ptr (stmt, i), callback_op,
     365                 :            :                            wi, pset);
     366                 :     219416 :           if (ret)
     367                 :          0 :             return ret;
     368                 :     219416 :           ret = walk_tree (gimple_omp_for_incr_ptr (stmt, i), callback_op,
     369                 :            :                            wi, pset);
     370                 :     219416 :           if (ret)
     371                 :          0 :             return ret;
     372                 :            :         }
     373                 :            :       break;
     374                 :            : 
     375                 :      50409 :     case GIMPLE_OMP_PARALLEL:
     376                 :      50409 :       {
     377                 :      50409 :         gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
     378                 :      50409 :         ret = walk_tree (gimple_omp_parallel_clauses_ptr (omp_par_stmt),
     379                 :            :                          callback_op, wi, pset);
     380                 :      50409 :         if (ret)
     381                 :            :           return ret;
     382                 :      50409 :         ret = walk_tree (gimple_omp_parallel_child_fn_ptr (omp_par_stmt),
     383                 :            :                          callback_op, wi, pset);
     384                 :      50409 :         if (ret)
     385                 :            :           return ret;
     386                 :      50409 :         ret = walk_tree (gimple_omp_parallel_data_arg_ptr (omp_par_stmt),
     387                 :            :                          callback_op, wi, pset);
     388                 :      50409 :         if (ret)
     389                 :          0 :           return ret;
     390                 :            :       }
     391                 :            :       break;
     392                 :            : 
     393                 :       8561 :     case GIMPLE_OMP_TASK:
     394                 :       8561 :       ret = walk_tree (gimple_omp_task_clauses_ptr (stmt), callback_op,
     395                 :            :                        wi, pset);
     396                 :       8561 :       if (ret)
     397                 :            :         return ret;
     398                 :       8561 :       ret = walk_tree (gimple_omp_task_child_fn_ptr (stmt), callback_op,
     399                 :            :                        wi, pset);
     400                 :       8561 :       if (ret)
     401                 :            :         return ret;
     402                 :       8561 :       ret = walk_tree (gimple_omp_task_data_arg_ptr (stmt), callback_op,
     403                 :            :                        wi, pset);
     404                 :       8561 :       if (ret)
     405                 :            :         return ret;
     406                 :       8561 :       ret = walk_tree (gimple_omp_task_copy_fn_ptr (stmt), callback_op,
     407                 :            :                        wi, pset);
     408                 :       8561 :       if (ret)
     409                 :            :         return ret;
     410                 :       8561 :       ret = walk_tree (gimple_omp_task_arg_size_ptr (stmt), callback_op,
     411                 :            :                        wi, pset);
     412                 :       8561 :       if (ret)
     413                 :            :         return ret;
     414                 :       8561 :       ret = walk_tree (gimple_omp_task_arg_align_ptr (stmt), callback_op,
     415                 :            :                        wi, pset);
     416                 :       8561 :       if (ret)
     417                 :          0 :         return ret;
     418                 :            :       break;
     419                 :            : 
     420                 :       1414 :     case GIMPLE_OMP_SECTIONS:
     421                 :       1414 :       ret = walk_tree (gimple_omp_sections_clauses_ptr (stmt), callback_op,
     422                 :            :                        wi, pset);
     423                 :       1414 :       if (ret)
     424                 :            :         return ret;
     425                 :       1414 :       ret = walk_tree (gimple_omp_sections_control_ptr (stmt), callback_op,
     426                 :            :                        wi, pset);
     427                 :       1414 :       if (ret)
     428                 :          0 :         return ret;
     429                 :            : 
     430                 :            :       break;
     431                 :            : 
     432                 :       3947 :     case GIMPLE_OMP_SINGLE:
     433                 :       3947 :       ret = walk_tree (gimple_omp_single_clauses_ptr (stmt), callback_op, wi,
     434                 :            :                        pset);
     435                 :       3947 :       if (ret)
     436                 :          0 :         return ret;
     437                 :            :       break;
     438                 :            : 
     439                 :      92998 :     case GIMPLE_OMP_TARGET:
     440                 :      92998 :       {
     441                 :      92998 :         gomp_target *omp_stmt = as_a <gomp_target *> (stmt);
     442                 :      92998 :         ret = walk_tree (gimple_omp_target_clauses_ptr (omp_stmt),
     443                 :            :                          callback_op, wi, pset);
     444                 :      92998 :         if (ret)
     445                 :            :           return ret;
     446                 :      92998 :         ret = walk_tree (gimple_omp_target_child_fn_ptr (omp_stmt),
     447                 :            :                          callback_op, wi, pset);
     448                 :      92998 :         if (ret)
     449                 :            :           return ret;
     450                 :      92998 :         ret = walk_tree (gimple_omp_target_data_arg_ptr (omp_stmt),
     451                 :            :                          callback_op, wi, pset);
     452                 :      92998 :         if (ret)
     453                 :          0 :           return ret;
     454                 :            :       }
     455                 :            :       break;
     456                 :            : 
     457                 :      18035 :     case GIMPLE_OMP_TEAMS:
     458                 :      18035 :       ret = walk_tree (gimple_omp_teams_clauses_ptr (stmt), callback_op, wi,
     459                 :            :                        pset);
     460                 :      18035 :       if (ret)
     461                 :          0 :         return ret;
     462                 :            :       break;
     463                 :            : 
     464                 :      31847 :     case GIMPLE_OMP_ATOMIC_LOAD:
     465                 :      31847 :       {
     466                 :      31847 :         gomp_atomic_load *omp_stmt = as_a <gomp_atomic_load *> (stmt);
     467                 :      31847 :         ret = walk_tree (gimple_omp_atomic_load_lhs_ptr (omp_stmt),
     468                 :            :                          callback_op, wi, pset);
     469                 :      31847 :         if (ret)
     470                 :            :           return ret;
     471                 :      31847 :         ret = walk_tree (gimple_omp_atomic_load_rhs_ptr (omp_stmt),
     472                 :            :                          callback_op, wi, pset);
     473                 :      31847 :         if (ret)
     474                 :          0 :           return ret;
     475                 :            :       }
     476                 :            :       break;
     477                 :            : 
     478                 :      32590 :     case GIMPLE_OMP_ATOMIC_STORE:
     479                 :      32590 :       {
     480                 :      32590 :         gomp_atomic_store *omp_stmt = as_a <gomp_atomic_store *> (stmt);
     481                 :      32590 :         ret = walk_tree (gimple_omp_atomic_store_val_ptr (omp_stmt),
     482                 :            :                          callback_op, wi, pset);
     483                 :      32590 :         if (ret)
     484                 :          0 :           return ret;
     485                 :            :       }
     486                 :            :       break;
     487                 :            : 
     488                 :      61536 :     case GIMPLE_TRANSACTION:
     489                 :      61536 :       {
     490                 :      61536 :         gtransaction *txn = as_a <gtransaction *> (stmt);
     491                 :            : 
     492                 :      61536 :         ret = walk_tree (gimple_transaction_label_norm_ptr (txn),
     493                 :            :                          callback_op, wi, pset);
     494                 :      61536 :         if (ret)
     495                 :            :           return ret;
     496                 :      61536 :         ret = walk_tree (gimple_transaction_label_uninst_ptr (txn),
     497                 :            :                          callback_op, wi, pset);
     498                 :      61536 :         if (ret)
     499                 :            :           return ret;
     500                 :      61536 :         ret = walk_tree (gimple_transaction_label_over_ptr (txn),
     501                 :            :                          callback_op, wi, pset);
     502                 :      61536 :         if (ret)
     503                 :          0 :           return ret;
     504                 :            :       }
     505                 :            :       break;
     506                 :            : 
     507                 :     293152 :     case GIMPLE_OMP_RETURN:
     508                 :     293152 :       ret = walk_tree (gimple_omp_return_lhs_ptr (stmt), callback_op, wi,
     509                 :            :                        pset);
     510                 :     293152 :       if (ret)
     511                 :          0 :         return ret;
     512                 :            :       break;
     513                 :            : 
     514                 :            :       /* Tuples that do not have operands.  */
     515                 :            :     case GIMPLE_NOP:
     516                 :            :     case GIMPLE_RESX:
     517                 :            :     case GIMPLE_PREDICT:
     518                 :            :       break;
     519                 :            : 
     520                 : 8032000000 :     default:
     521                 : 8032000000 :       {
     522                 : 8032000000 :         enum gimple_statement_structure_enum gss;
     523                 : 8032000000 :         gss = gimple_statement_structure (stmt);
     524                 : 8032000000 :         if (gss == GSS_WITH_OPS || gss == GSS_WITH_MEM_OPS)
     525                 :21880000000 :           for (i = 0; i < gimple_num_ops (stmt); i++)
     526                 :            :             {
     527                 :13852700000 :               ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi, pset);
     528                 :13852700000 :               if (ret)
     529                 :          0 :                 return ret;
     530                 :            :             }
     531                 :            :       }
     532                 :            :       break;
     533                 :            :     }
     534                 :            : 
     535                 :            :   return NULL_TREE;
     536                 :            : }
     537                 :            : 
     538                 :            : 
     539                 :            : /* Walk the current statement in GSI (optionally using traversal state
     540                 :            :    stored in WI).  If WI is NULL, no state is kept during traversal.
     541                 :            :    The callback CALLBACK_STMT is called.  If CALLBACK_STMT indicates
     542                 :            :    that it has handled all the operands of the statement, its return
     543                 :            :    value is returned.  Otherwise, the return value from CALLBACK_STMT
     544                 :            :    is discarded and its operands are scanned.
     545                 :            : 
     546                 :            :    If CALLBACK_STMT is NULL or it didn't handle the operands,
     547                 :            :    CALLBACK_OP is called on each operand of the statement via
     548                 :            :    walk_gimple_op.  If walk_gimple_op returns non-NULL for any
     549                 :            :    operand, the remaining operands are not scanned.  In this case, the
     550                 :            :    return value from CALLBACK_OP is returned.
     551                 :            : 
     552                 :            :    In any other case, NULL_TREE is returned.  */
     553                 :            : 
     554                 :            : tree
     555                 :  143196000 : walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
     556                 :            :                   walk_tree_fn callback_op, struct walk_stmt_info *wi)
     557                 :            : {
     558                 :  143196000 :   gimple *ret;
     559                 :  143196000 :   tree tree_ret;
     560                 :  143196000 :   gimple *stmt = gsi_stmt (*gsi);
     561                 :            : 
     562                 :  143196000 :   if (wi)
     563                 :            :     {
     564                 :  143193000 :       wi->gsi = *gsi;
     565                 :  143193000 :       wi->removed_stmt = false;
     566                 :            : 
     567                 :  147520000 :       if (wi->want_locations && gimple_has_location (stmt))
     568                 :    3511660 :         input_location = gimple_location (stmt);
     569                 :            :     }
     570                 :            : 
     571                 :  143196000 :   ret = NULL;
     572                 :            : 
     573                 :            :   /* Invoke the statement callback.  Return if the callback handled
     574                 :            :      all of STMT operands by itself.  */
     575                 :  143196000 :   if (callback_stmt)
     576                 :            :     {
     577                 :  143155000 :       bool handled_ops = false;
     578                 :  143155000 :       tree_ret = callback_stmt (gsi, &handled_ops, wi);
     579                 :  143155000 :       if (handled_ops)
     580                 :    7387270 :         return tree_ret;
     581                 :            : 
     582                 :            :       /* If CALLBACK_STMT did not handle operands, it should not have
     583                 :            :          a value to return.  */
     584                 :  135768000 :       gcc_assert (tree_ret == NULL);
     585                 :            : 
     586                 :  135768000 :       if (wi && wi->removed_stmt)
     587                 :            :         return NULL;
     588                 :            : 
     589                 :            :       /* Re-read stmt in case the callback changed it.  */
     590                 :  135768000 :       stmt = gsi_stmt (*gsi);
     591                 :            :     }
     592                 :            : 
     593                 :            :   /* If CALLBACK_OP is defined, invoke it on every operand of STMT.  */
     594                 :  135809000 :   if (callback_op)
     595                 :            :     {
     596                 :   12613500 :       tree_ret = walk_gimple_op (stmt, callback_op, wi);
     597                 :   12613500 :       if (tree_ret)
     598                 :            :         return tree_ret;
     599                 :            :     }
     600                 :            : 
     601                 :            :   /* If STMT can have statements inside (e.g. GIMPLE_BIND), walk them.  */
     602                 :  135809000 :   switch (gimple_code (stmt))
     603                 :            :     {
     604                 :    1525980 :     case GIMPLE_BIND:
     605                 :    1525980 :       ret = walk_gimple_seq_mod (gimple_bind_body_ptr (as_a <gbind *> (stmt)),
     606                 :            :                                  callback_stmt, callback_op, wi);
     607                 :    1525980 :       if (ret)
     608                 :       8417 :         return wi->callback_result;
     609                 :            :       break;
     610                 :            : 
     611                 :      30658 :     case GIMPLE_CATCH:
     612                 :      30658 :       ret = walk_gimple_seq_mod (gimple_catch_handler_ptr (
     613                 :            :                                    as_a <gcatch *> (stmt)),
     614                 :            :                                  callback_stmt, callback_op, wi);
     615                 :      30658 :       if (ret)
     616                 :          0 :         return wi->callback_result;
     617                 :            :       break;
     618                 :            : 
     619                 :        175 :     case GIMPLE_EH_FILTER:
     620                 :        175 :       ret = walk_gimple_seq_mod (gimple_eh_filter_failure_ptr (stmt), callback_stmt,
     621                 :            :                              callback_op, wi);
     622                 :        175 :       if (ret)
     623                 :          0 :         return wi->callback_result;
     624                 :            :       break;
     625                 :            : 
     626                 :        990 :     case GIMPLE_EH_ELSE:
     627                 :        990 :       {
     628                 :        990 :         geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
     629                 :        990 :         ret = walk_gimple_seq_mod (gimple_eh_else_n_body_ptr (eh_else_stmt),
     630                 :            :                                    callback_stmt, callback_op, wi);
     631                 :        990 :         if (ret)
     632                 :          0 :           return wi->callback_result;
     633                 :        990 :         ret = walk_gimple_seq_mod (gimple_eh_else_e_body_ptr (eh_else_stmt),
     634                 :            :                                    callback_stmt, callback_op, wi);
     635                 :        990 :         if (ret)
     636                 :          0 :           return wi->callback_result;
     637                 :            :       }
     638                 :            :       break;
     639                 :            : 
     640                 :     390088 :     case GIMPLE_TRY:
     641                 :     390088 :       ret = walk_gimple_seq_mod (gimple_try_eval_ptr (stmt), callback_stmt, callback_op,
     642                 :            :                              wi);
     643                 :     390088 :       if (ret)
     644                 :        185 :         return wi->callback_result;
     645                 :            : 
     646                 :     389903 :       ret = walk_gimple_seq_mod (gimple_try_cleanup_ptr (stmt), callback_stmt,
     647                 :            :                              callback_op, wi);
     648                 :     389903 :       if (ret)
     649                 :          0 :         return wi->callback_result;
     650                 :            :       break;
     651                 :            : 
     652                 :       3892 :     case GIMPLE_OMP_FOR:
     653                 :       3892 :       ret = walk_gimple_seq_mod (gimple_omp_for_pre_body_ptr (stmt), callback_stmt,
     654                 :            :                              callback_op, wi);
     655                 :       3892 :       if (ret)
     656                 :          0 :         return wi->callback_result;
     657                 :            : 
     658                 :            :       /* FALL THROUGH.  */
     659                 :      12687 :     case GIMPLE_OMP_CRITICAL:
     660                 :      12687 :     case GIMPLE_OMP_MASTER:
     661                 :      12687 :     case GIMPLE_OMP_TASKGROUP:
     662                 :      12687 :     case GIMPLE_OMP_ORDERED:
     663                 :      12687 :     case GIMPLE_OMP_SCAN:
     664                 :      12687 :     case GIMPLE_OMP_SECTION:
     665                 :      12687 :     case GIMPLE_OMP_PARALLEL:
     666                 :      12687 :     case GIMPLE_OMP_TASK:
     667                 :      12687 :     case GIMPLE_OMP_SECTIONS:
     668                 :      12687 :     case GIMPLE_OMP_SINGLE:
     669                 :      12687 :     case GIMPLE_OMP_TARGET:
     670                 :      12687 :     case GIMPLE_OMP_TEAMS:
     671                 :      12687 :     case GIMPLE_OMP_GRID_BODY:
     672                 :      12687 :       ret = walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), callback_stmt,
     673                 :            :                              callback_op, wi);
     674                 :      12687 :       if (ret)
     675                 :          0 :         return wi->callback_result;
     676                 :            :       break;
     677                 :            : 
     678                 :          0 :     case GIMPLE_WITH_CLEANUP_EXPR:
     679                 :          0 :       ret = walk_gimple_seq_mod (gimple_wce_cleanup_ptr (stmt), callback_stmt,
     680                 :            :                              callback_op, wi);
     681                 :          0 :       if (ret)
     682                 :          0 :         return wi->callback_result;
     683                 :            :       break;
     684                 :            : 
     685                 :        675 :     case GIMPLE_TRANSACTION:
     686                 :        675 :       ret = walk_gimple_seq_mod (gimple_transaction_body_ptr (
     687                 :            :                                    as_a <gtransaction *> (stmt)),
     688                 :            :                              callback_stmt, callback_op, wi);
     689                 :        675 :       if (ret)
     690                 :          4 :         return wi->callback_result;
     691                 :            :       break;
     692                 :            : 
     693                 :  133847000 :     default:
     694                 :  133847000 :       gcc_assert (!gimple_has_substatements (stmt));
     695                 :            :       break;
     696                 :            :     }
     697                 :            : 
     698                 :            :   return NULL;
     699                 :            : }
     700                 :            : 
     701                 :            : /* From a tree operand OP return the base of a load or store operation
     702                 :            :    or NULL_TREE if OP is not a load or a store.  */
     703                 :            : 
     704                 :            : static tree
     705                 :  543933000 : get_base_loadstore (tree op)
     706                 :            : {
     707                 :  630058000 :   while (handled_component_p (op))
     708                 :   86124300 :     op = TREE_OPERAND (op, 0);
     709                 :  543933000 :   if (DECL_P (op)
     710                 :  424265000 :       || INDIRECT_REF_P (op)
     711                 :  424265000 :       || TREE_CODE (op) == MEM_REF
     712                 :  338655000 :       || TREE_CODE (op) == TARGET_MEM_REF)
     713                 :  208504000 :     return op;
     714                 :            :   return NULL_TREE;
     715                 :            : }
     716                 :            : 
     717                 :            : 
     718                 :            : /* For the statement STMT call the callbacks VISIT_LOAD, VISIT_STORE and
     719                 :            :    VISIT_ADDR if non-NULL on loads, store and address-taken operands
     720                 :            :    passing the STMT, the base of the operand, the operand itself containing
     721                 :            :    the base and DATA to it.  The base will be either a decl, an indirect
     722                 :            :    reference (including TARGET_MEM_REF) or the argument of an address
     723                 :            :    expression.
     724                 :            :    Returns the results of these callbacks or'ed.  */
     725                 :            : 
     726                 :            : bool
     727                 :  970127000 : walk_stmt_load_store_addr_ops (gimple *stmt, void *data,
     728                 :            :                                walk_stmt_load_store_addr_fn visit_load,
     729                 :            :                                walk_stmt_load_store_addr_fn visit_store,
     730                 :            :                                walk_stmt_load_store_addr_fn visit_addr)
     731                 :            : {
     732                 :  970127000 :   bool ret = false;
     733                 :  970127000 :   unsigned i;
     734                 :  970127000 :   if (gimple_assign_single_p (stmt))
     735                 :            :     {
     736                 :  293637000 :       tree lhs, rhs, arg;
     737                 :  293637000 :       if (visit_store)
     738                 :            :         {
     739                 :  197877000 :           arg = gimple_assign_lhs (stmt);
     740                 :  197877000 :           lhs = get_base_loadstore (arg);
     741                 :  197877000 :           if (lhs)
     742                 :  102851000 :             ret |= visit_store (stmt, lhs, arg, data);
     743                 :            :         }
     744                 :  293637000 :       arg = gimple_assign_rhs1 (stmt);
     745                 :  293637000 :       rhs = arg;
     746                 :  402255000 :       while (handled_component_p (rhs))
     747                 :  108618000 :         rhs = TREE_OPERAND (rhs, 0);
     748                 :  293637000 :       if (visit_addr)
     749                 :            :         {
     750                 :  215726000 :           if (TREE_CODE (rhs) == ADDR_EXPR)
     751                 :   19959300 :             ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), arg, data);
     752                 :  195767000 :           else if (TREE_CODE (rhs) == TARGET_MEM_REF
     753                 :  195767000 :                    && TREE_CODE (TMR_BASE (rhs)) == ADDR_EXPR)
     754                 :     263694 :             ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (rhs), 0), arg,
     755                 :            :                                data);
     756                 :  195503000 :           else if (TREE_CODE (rhs) == OBJ_TYPE_REF
     757                 :  195503000 :                    && TREE_CODE (OBJ_TYPE_REF_OBJECT (rhs)) == ADDR_EXPR)
     758                 :          0 :             ret |= visit_addr (stmt, TREE_OPERAND (OBJ_TYPE_REF_OBJECT (rhs),
     759                 :            :                                                    0), arg, data);
     760                 :  195503000 :           else if (TREE_CODE (rhs) == CONSTRUCTOR)
     761                 :            :             {
     762                 :            :               unsigned int ix;
     763                 :            :               tree val;
     764                 :            : 
     765                 :   20095100 :               FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), ix, val)
     766                 :     481932 :                 if (TREE_CODE (val) == ADDR_EXPR)
     767                 :          0 :                   ret |= visit_addr (stmt, TREE_OPERAND (val, 0), arg, data);
     768                 :     481932 :                 else if (TREE_CODE (val) == OBJ_TYPE_REF
     769                 :     481932 :                          && TREE_CODE (OBJ_TYPE_REF_OBJECT (val)) == ADDR_EXPR)
     770                 :          0 :                   ret |= visit_addr (stmt,
     771                 :          0 :                                      TREE_OPERAND (OBJ_TYPE_REF_OBJECT (val),
     772                 :            :                                                    0), arg, data);
     773                 :            :             }
     774                 :  215726000 :           lhs = gimple_assign_lhs (stmt);
     775                 :  215726000 :           if (TREE_CODE (lhs) == TARGET_MEM_REF
     776                 :  215726000 :               && TREE_CODE (TMR_BASE (lhs)) == ADDR_EXPR)
     777                 :     176526 :             ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (lhs), 0), lhs, data);
     778                 :            :         }
     779                 :  293637000 :       if (visit_load)
     780                 :            :         {
     781                 :  197875000 :           rhs = get_base_loadstore (rhs);
     782                 :  197875000 :           if (rhs)
     783                 :   85690400 :             ret |= visit_load (stmt, rhs, arg, data);
     784                 :            :         }
     785                 :            :     }
     786                 :  676490000 :   else if (visit_addr
     787                 :  676490000 :            && (is_gimple_assign (stmt)
     788                 :  408957000 :                || gimple_code (stmt) == GIMPLE_COND))
     789                 :            :     {
     790                 :  549439000 :       for (i = 0; i < gimple_num_ops (stmt); ++i)
     791                 :            :         {
     792                 :  416820000 :           tree op = gimple_op (stmt, i);
     793                 :  416820000 :           if (op == NULL_TREE)
     794                 :            :             ;
     795                 :  326341000 :           else if (TREE_CODE (op) == ADDR_EXPR)
     796                 :    3105390 :             ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
     797                 :            :           /* COND_EXPR and VCOND_EXPR rhs1 argument is a comparison
     798                 :            :              tree with two operands.  */
     799                 :  323235000 :           else if (i == 1 && COMPARISON_CLASS_P (op))
     800                 :            :             {
     801                 :     149875 :               if (TREE_CODE (TREE_OPERAND (op, 0)) == ADDR_EXPR)
     802                 :          0 :                 ret |= visit_addr (stmt, TREE_OPERAND (TREE_OPERAND (op, 0),
     803                 :            :                                                        0), op, data);
     804                 :     149875 :               if (TREE_CODE (TREE_OPERAND (op, 1)) == ADDR_EXPR)
     805                 :      15801 :                 ret |= visit_addr (stmt, TREE_OPERAND (TREE_OPERAND (op, 1),
     806                 :            :                                                        0), op, data);
     807                 :            :             }
     808                 :            :         }
     809                 :            :     }
     810                 :  543871000 :   else if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
     811                 :            :     {
     812                 :   96359100 :       if (visit_store)
     813                 :            :         {
     814                 :   67606800 :           tree arg = gimple_call_lhs (call_stmt);
     815                 :   67606800 :           if (arg)
     816                 :            :             {
     817                 :   27314300 :               tree lhs = get_base_loadstore (arg);
     818                 :   27314300 :               if (lhs)
     819                 :    6203310 :                 ret |= visit_store (stmt, lhs, arg, data);
     820                 :            :             }
     821                 :            :         }
     822                 :   96359100 :       if (visit_load || visit_addr)
     823                 :  285645000 :         for (i = 0; i < gimple_call_num_args (call_stmt); ++i)
     824                 :            :           {
     825                 :  189463000 :             tree arg = gimple_call_arg (call_stmt, i);
     826                 :  189463000 :             if (visit_addr
     827                 :  134819000 :                 && TREE_CODE (arg) == ADDR_EXPR)
     828                 :   40685300 :               ret |= visit_addr (stmt, TREE_OPERAND (arg, 0), arg, data);
     829                 :  148778000 :             else if (visit_load)
     830                 :            :               {
     831                 :  111469000 :                 tree rhs = get_base_loadstore (arg);
     832                 :  111469000 :                 if (rhs)
     833                 :   11427500 :                   ret |= visit_load (stmt, rhs, arg, data);
     834                 :            :               }
     835                 :            :           }
     836                 :   96359100 :       if (visit_addr
     837                 :   71123500 :           && gimple_call_chain (call_stmt)
     838                 :   96716800 :           && TREE_CODE (gimple_call_chain (call_stmt)) == ADDR_EXPR)
     839                 :     127812 :         ret |= visit_addr (stmt, TREE_OPERAND (gimple_call_chain (call_stmt), 0),
     840                 :            :                            gimple_call_chain (call_stmt), data);
     841                 :   96359100 :       if (visit_addr
     842                 :   71123500 :           && gimple_call_return_slot_opt_p (call_stmt)
     843                 :    2893880 :           && gimple_call_lhs (call_stmt) != NULL_TREE
     844                 :   99252300 :           && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (call_stmt))))
     845                 :     430191 :         ret |= visit_addr (stmt, gimple_call_lhs (call_stmt),
     846                 :            :                            gimple_call_lhs (call_stmt), data);
     847                 :            :     }
     848                 :  447512000 :   else if (gasm *asm_stmt = dyn_cast <gasm *> (stmt))
     849                 :            :     {
     850                 :    1180080 :       unsigned noutputs;
     851                 :    1180080 :       const char *constraint;
     852                 :    1180080 :       const char **oconstraints;
     853                 :    1180080 :       bool allows_mem, allows_reg, is_inout;
     854                 :    1180080 :       noutputs = gimple_asm_noutputs (asm_stmt);
     855                 :    1180080 :       oconstraints = XALLOCAVEC (const char *, noutputs);
     856                 :    1180080 :       if (visit_store || visit_addr)
     857                 :    2362780 :         for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i)
     858                 :            :           {
     859                 :    1182700 :             tree link = gimple_asm_output_op (asm_stmt, i);
     860                 :    1182700 :             tree op = get_base_loadstore (TREE_VALUE (link));
     861                 :    1182700 :             if (op && visit_store)
     862                 :     166230 :               ret |= visit_store (stmt, op, TREE_VALUE (link), data);
     863                 :    1182700 :             if (visit_addr)
     864                 :            :               {
     865                 :     930595 :                 constraint = TREE_STRING_POINTER
     866                 :            :                     (TREE_VALUE (TREE_PURPOSE (link)));
     867                 :     930595 :                 oconstraints[i] = constraint;
     868                 :     930595 :                 parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
     869                 :            :                                          &allows_reg, &is_inout);
     870                 :     930595 :                 if (op && !allows_reg && allows_mem)
     871                 :      11371 :                   ret |= visit_addr (stmt, op, TREE_VALUE (link), data);
     872                 :            :               }
     873                 :            :           }
     874                 :    1180080 :       if (visit_load || visit_addr)
     875                 :    1857640 :         for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
     876                 :            :           {
     877                 :     678557 :             tree link = gimple_asm_input_op (asm_stmt, i);
     878                 :     678557 :             tree op = TREE_VALUE (link);
     879                 :     678557 :             if (visit_addr
     880                 :     547008 :                 && TREE_CODE (op) == ADDR_EXPR)
     881                 :      59295 :               ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
     882                 :     619262 :             else if (visit_load || visit_addr)
     883                 :            :               {
     884                 :     619262 :                 op = get_base_loadstore (op);
     885                 :     619262 :                 if (op)
     886                 :            :                   {
     887                 :      80269 :                     if (visit_load)
     888                 :      43946 :                       ret |= visit_load (stmt, op, TREE_VALUE (link), data);
     889                 :      80269 :                     if (visit_addr)
     890                 :            :                       {
     891                 :      74474 :                         constraint = TREE_STRING_POINTER
     892                 :            :                             (TREE_VALUE (TREE_PURPOSE (link)));
     893                 :      74474 :                         parse_input_constraint (&constraint, 0, 0, noutputs,
     894                 :            :                                                 0, oconstraints,
     895                 :            :                                                 &allows_mem, &allows_reg);
     896                 :      74474 :                         if (!allows_reg && allows_mem)
     897                 :      17868 :                           ret |= visit_addr (stmt, op, TREE_VALUE (link),
     898                 :            :                                              data);
     899                 :            :                       }
     900                 :            :                   }
     901                 :            :               }
     902                 :            :           }
     903                 :            :     }
     904                 :  446332000 :   else if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
     905                 :            :     {
     906                 :   21038900 :       tree op = gimple_return_retval (return_stmt);
     907                 :   21038900 :       if (op)
     908                 :            :         {
     909                 :   11225100 :           if (visit_addr
     910                 :    8761210 :               && TREE_CODE (op) == ADDR_EXPR)
     911                 :      18688 :             ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
     912                 :   11206400 :           else if (visit_load)
     913                 :            :             {
     914                 :    7596880 :               tree base = get_base_loadstore (op);
     915                 :    7596880 :               if (base)
     916                 :    1955110 :                 ret |= visit_load (stmt, base, op, data);
     917                 :            :             }
     918                 :            :         }
     919                 :            :     }
     920                 :  425293000 :   else if (visit_addr
     921                 :  425293000 :            && gimple_code (stmt) == GIMPLE_PHI)
     922                 :            :     {
     923                 :   63573100 :       for (i = 0; i < gimple_phi_num_args (stmt); ++i)
     924                 :            :         {
     925                 :   45353400 :           tree op = gimple_phi_arg_def (stmt, i);
     926                 :   45353400 :           if (TREE_CODE (op) == ADDR_EXPR)
     927                 :     296270 :             ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
     928                 :            :         }
     929                 :            :     }
     930                 :  407074000 :   else if (visit_addr
     931                 :  407074000 :            && gimple_code (stmt) == GIMPLE_GOTO)
     932                 :            :     {
     933                 :       4464 :       tree op = gimple_goto_dest (stmt);
     934                 :       4464 :       if (TREE_CODE (op) == ADDR_EXPR)
     935                 :         77 :         ret |= visit_addr (stmt, TREE_OPERAND (op, 0), op, data);
     936                 :            :     }
     937                 :            : 
     938                 :  970127000 :   return ret;
     939                 :            : }
     940                 :            : 
     941                 :            : /* Like walk_stmt_load_store_addr_ops but with NULL visit_addr.  IPA-CP
     942                 :            :    should make a faster clone for this case.  */
     943                 :            : 
     944                 :            : bool
     945                 :  258064000 : walk_stmt_load_store_ops (gimple *stmt, void *data,
     946                 :            :                           walk_stmt_load_store_addr_fn visit_load,
     947                 :            :                           walk_stmt_load_store_addr_fn visit_store)
     948                 :            : {
     949                 :  258064000 :   return walk_stmt_load_store_addr_ops (stmt, data,
     950                 :  258064000 :                                         visit_load, visit_store, NULL);
     951                 :            : }

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.