LCOV - code coverage report
Current view: top level - gcc/cp - cp-gimplify.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1646 1714 96.0 %
Date: 2020-03-28 11:57:23 Functions: 61 62 98.4 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* C++-specific tree lowering bits; see also c-gimplify.c and gimple.c.
       2                 :            : 
       3                 :            :    Copyright (C) 2002-2020 Free Software Foundation, Inc.
       4                 :            :    Contributed by Jason Merrill <jason@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 "target.h"
      26                 :            : #include "basic-block.h"
      27                 :            : #include "cp-tree.h"
      28                 :            : #include "gimple.h"
      29                 :            : #include "predict.h"
      30                 :            : #include "stor-layout.h"
      31                 :            : #include "tree-iterator.h"
      32                 :            : #include "gimplify.h"
      33                 :            : #include "c-family/c-ubsan.h"
      34                 :            : #include "stringpool.h"
      35                 :            : #include "attribs.h"
      36                 :            : #include "asan.h"
      37                 :            : #include "gcc-rich-location.h"
      38                 :            : #include "memmodel.h"
      39                 :            : #include "tm_p.h"
      40                 :            : #include "output.h"
      41                 :            : #include "file-prefix-map.h"
      42                 :            : #include "cgraph.h"
      43                 :            : 
      44                 :            : /* Forward declarations.  */
      45                 :            : 
      46                 :            : static tree cp_genericize_r (tree *, int *, void *);
      47                 :            : static tree cp_fold_r (tree *, int *, void *);
      48                 :            : static void cp_genericize_tree (tree*, bool);
      49                 :            : static tree cp_fold (tree);
      50                 :            : 
      51                 :            : /* Local declarations.  */
      52                 :            : 
      53                 :            : enum bc_t { bc_break = 0, bc_continue = 1 };
      54                 :            : 
      55                 :            : /* Stack of labels which are targets for "break" or "continue",
      56                 :            :    linked through TREE_CHAIN.  */
      57                 :            : static tree bc_label[2];
      58                 :            : 
      59                 :            : /* Begin a scope which can be exited by a break or continue statement.  BC
      60                 :            :    indicates which.
      61                 :            : 
      62                 :            :    Just creates a label with location LOCATION and pushes it into the current
      63                 :            :    context.  */
      64                 :            : 
      65                 :            : static tree
      66                 :     662544 : begin_bc_block (enum bc_t bc, location_t location)
      67                 :            : {
      68                 :     662544 :   tree label = create_artificial_label (location);
      69                 :     662544 :   DECL_CHAIN (label) = bc_label[bc];
      70                 :     662544 :   bc_label[bc] = label;
      71                 :     662544 :   if (bc == bc_break)
      72                 :     342854 :     LABEL_DECL_BREAK (label) = true;
      73                 :            :   else
      74                 :     319690 :     LABEL_DECL_CONTINUE (label) = true;
      75                 :     662544 :   return label;
      76                 :            : }
      77                 :            : 
      78                 :            : /* Finish a scope which can be exited by a break or continue statement.
      79                 :            :    LABEL was returned from the most recent call to begin_bc_block.  BLOCK is
      80                 :            :    an expression for the contents of the scope.
      81                 :            : 
      82                 :            :    If we saw a break (or continue) in the scope, append a LABEL_EXPR to
      83                 :            :    BLOCK.  Otherwise, just forget the label.  */
      84                 :            : 
      85                 :            : static void
      86                 :     662544 : finish_bc_block (tree *block, enum bc_t bc, tree label)
      87                 :            : {
      88                 :     662544 :   gcc_assert (label == bc_label[bc]);
      89                 :            : 
      90                 :     662544 :   if (TREE_USED (label))
      91                 :     220427 :     append_to_statement_list (build1 (LABEL_EXPR, void_type_node, label),
      92                 :            :                               block);
      93                 :            : 
      94                 :     662544 :   bc_label[bc] = DECL_CHAIN (label);
      95                 :     662544 :   DECL_CHAIN (label) = NULL_TREE;
      96                 :     662544 : }
      97                 :            : 
      98                 :            : /* Get the LABEL_EXPR to represent a break or continue statement
      99                 :            :    in the current block scope.  BC indicates which.  */
     100                 :            : 
     101                 :            : static tree
     102                 :     332614 : get_bc_label (enum bc_t bc)
     103                 :            : {
     104                 :     332614 :   tree label = bc_label[bc];
     105                 :            : 
     106                 :            :   /* Mark the label used for finish_bc_block.  */
     107                 :     332614 :   TREE_USED (label) = 1;
     108                 :     332614 :   return label;
     109                 :            : }
     110                 :            : 
     111                 :            : /* Genericize a TRY_BLOCK.  */
     112                 :            : 
     113                 :            : static void
     114                 :      21045 : genericize_try_block (tree *stmt_p)
     115                 :            : {
     116                 :      21045 :   tree body = TRY_STMTS (*stmt_p);
     117                 :      21045 :   tree cleanup = TRY_HANDLERS (*stmt_p);
     118                 :            : 
     119                 :      21045 :   *stmt_p = build2 (TRY_CATCH_EXPR, void_type_node, body, cleanup);
     120                 :      21045 : }
     121                 :            : 
     122                 :            : /* Genericize a HANDLER by converting to a CATCH_EXPR.  */
     123                 :            : 
     124                 :            : static void
     125                 :      22901 : genericize_catch_block (tree *stmt_p)
     126                 :            : {
     127                 :      22901 :   tree type = HANDLER_TYPE (*stmt_p);
     128                 :      22901 :   tree body = HANDLER_BODY (*stmt_p);
     129                 :            : 
     130                 :            :   /* FIXME should the caught type go in TREE_TYPE?  */
     131                 :      22901 :   *stmt_p = build2 (CATCH_EXPR, void_type_node, type, body);
     132                 :      22901 : }
     133                 :            : 
     134                 :            : /* A terser interface for building a representation of an exception
     135                 :            :    specification.  */
     136                 :            : 
     137                 :            : static tree
     138                 :       8272 : build_gimple_eh_filter_tree (tree body, tree allowed, tree failure)
     139                 :            : {
     140                 :       8272 :   tree t;
     141                 :            : 
     142                 :            :   /* FIXME should the allowed types go in TREE_TYPE?  */
     143                 :       8272 :   t = build2 (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE);
     144                 :       8272 :   append_to_statement_list (failure, &EH_FILTER_FAILURE (t));
     145                 :            : 
     146                 :       8272 :   t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t);
     147                 :       8272 :   append_to_statement_list (body, &TREE_OPERAND (t, 0));
     148                 :            : 
     149                 :       8272 :   return t;
     150                 :            : }
     151                 :            : 
     152                 :            : /* Genericize an EH_SPEC_BLOCK by converting it to a
     153                 :            :    TRY_CATCH_EXPR/EH_FILTER_EXPR pair.  */
     154                 :            : 
     155                 :            : static void
     156                 :       8272 : genericize_eh_spec_block (tree *stmt_p)
     157                 :            : {
     158                 :       8272 :   tree body = EH_SPEC_STMTS (*stmt_p);
     159                 :       8272 :   tree allowed = EH_SPEC_RAISES (*stmt_p);
     160                 :       8272 :   tree failure = build_call_n (call_unexpected_fn, 1, build_exc_ptr ());
     161                 :            : 
     162                 :       8272 :   *stmt_p = build_gimple_eh_filter_tree (body, allowed, failure);
     163                 :       8272 :   TREE_NO_WARNING (*stmt_p) = true;
     164                 :       8272 :   TREE_NO_WARNING (TREE_OPERAND (*stmt_p, 1)) = true;
     165                 :       8272 : }
     166                 :            : 
     167                 :            : /* Return the first non-compound statement in STMT.  */
     168                 :            : 
     169                 :            : tree
     170                 :    1346680 : first_stmt (tree stmt)
     171                 :            : {
     172                 :    1765640 :   switch (TREE_CODE (stmt))
     173                 :            :     {
     174                 :     322967 :     case STATEMENT_LIST:
     175                 :     322967 :       if (tree_statement_list_node *p = STATEMENT_LIST_HEAD (stmt))
     176                 :     244292 :         return first_stmt (p->stmt);
     177                 :      78675 :       return void_node;
     178                 :            : 
     179                 :     174661 :     case BIND_EXPR:
     180                 :     174661 :       return first_stmt (BIND_EXPR_BODY (stmt));
     181                 :            : 
     182                 :            :     default:
     183                 :            :       return stmt;
     184                 :            :     }
     185                 :            : }
     186                 :            : 
     187                 :            : /* Genericize an IF_STMT by turning it into a COND_EXPR.  */
     188                 :            : 
     189                 :            : static void
     190                 :    2264430 : genericize_if_stmt (tree *stmt_p)
     191                 :            : {
     192                 :    2264430 :   tree stmt, cond, then_, else_;
     193                 :    2264430 :   location_t locus = EXPR_LOCATION (*stmt_p);
     194                 :            : 
     195                 :    2264430 :   stmt = *stmt_p;
     196                 :    2264430 :   cond = IF_COND (stmt);
     197                 :    2264430 :   then_ = THEN_CLAUSE (stmt);
     198                 :    2264430 :   else_ = ELSE_CLAUSE (stmt);
     199                 :            : 
     200                 :    2264430 :   if (then_ && else_)
     201                 :            :     {
     202                 :     673341 :       tree ft = first_stmt (then_);
     203                 :     673341 :       tree fe = first_stmt (else_);
     204                 :     673341 :       br_predictor pr;
     205                 :     673341 :       if (TREE_CODE (ft) == PREDICT_EXPR
     206                 :         61 :           && TREE_CODE (fe) == PREDICT_EXPR
     207                 :         29 :           && (pr = PREDICT_EXPR_PREDICTOR (ft)) == PREDICT_EXPR_PREDICTOR (fe)
     208                 :     673366 :           && (pr == PRED_HOT_LABEL || pr == PRED_COLD_LABEL))
     209                 :            :         {
     210                 :          2 :           gcc_rich_location richloc (EXPR_LOC_OR_LOC (ft, locus));
     211                 :          1 :           richloc.add_range (EXPR_LOC_OR_LOC (fe, locus));
     212                 :          1 :           warning_at (&richloc, OPT_Wattributes,
     213                 :            :                       "both branches of %<if%> statement marked as %qs",
     214                 :            :                       pr == PRED_HOT_LABEL ? "likely" : "unlikely");
     215                 :            :         }
     216                 :            :     }
     217                 :            : 
     218                 :    2264430 :   if (!then_)
     219                 :         44 :     then_ = build_empty_stmt (locus);
     220                 :    2264430 :   if (!else_)
     221                 :    1591070 :     else_ = build_empty_stmt (locus);
     222                 :            : 
     223                 :    2333220 :   if (integer_nonzerop (cond) && !TREE_SIDE_EFFECTS (else_))
     224                 :            :     stmt = then_;
     225                 :    2353440 :   else if (integer_zerop (cond) && !TREE_SIDE_EFFECTS (then_))
     226                 :            :     stmt = else_;
     227                 :            :   else
     228                 :    2143480 :     stmt = build3 (COND_EXPR, void_type_node, cond, then_, else_);
     229                 :    2264430 :   if (!EXPR_HAS_LOCATION (stmt))
     230                 :    2161330 :     protected_set_expr_location (stmt, locus);
     231                 :    2264430 :   *stmt_p = stmt;
     232                 :    2264430 : }
     233                 :            : 
     234                 :            : /* Build a generic representation of one of the C loop forms.  COND is the
     235                 :            :    loop condition or NULL_TREE.  BODY is the (possibly compound) statement
     236                 :            :    controlled by the loop.  INCR is the increment expression of a for-loop,
     237                 :            :    or NULL_TREE.  COND_IS_FIRST indicates whether the condition is
     238                 :            :    evaluated before the loop body as in while and for loops, or after the
     239                 :            :    loop body as in do-while loops.  */
     240                 :            : 
     241                 :            : static void
     242                 :     299534 : genericize_cp_loop (tree *stmt_p, location_t start_locus, tree cond, tree body,
     243                 :            :                     tree incr, bool cond_is_first, int *walk_subtrees,
     244                 :            :                     void *data)
     245                 :            : {
     246                 :     299534 :   tree blab, clab;
     247                 :     299534 :   tree exit = NULL;
     248                 :     299534 :   tree stmt_list = NULL;
     249                 :     299534 :   tree debug_begin = NULL;
     250                 :            : 
     251                 :     299534 :   if (EXPR_LOCATION (incr) == UNKNOWN_LOCATION)
     252                 :     299335 :     protected_set_expr_location (incr, start_locus);
     253                 :            : 
     254                 :     299534 :   cp_walk_tree (&cond, cp_genericize_r, data, NULL);
     255                 :     299534 :   cp_walk_tree (&incr, cp_genericize_r, data, NULL);
     256                 :            : 
     257                 :     299534 :   blab = begin_bc_block (bc_break, start_locus);
     258                 :     299534 :   clab = begin_bc_block (bc_continue, start_locus);
     259                 :            : 
     260                 :     299534 :   cp_walk_tree (&body, cp_genericize_r, data, NULL);
     261                 :     299534 :   *walk_subtrees = 0;
     262                 :            : 
     263                 :     299534 :   if (MAY_HAVE_DEBUG_MARKER_STMTS
     264                 :     299534 :       && (!cond || !integer_zerop (cond)))
     265                 :            :     {
     266                 :     145158 :       debug_begin = build0 (DEBUG_BEGIN_STMT, void_type_node);
     267                 :     290316 :       SET_EXPR_LOCATION (debug_begin, cp_expr_loc_or_loc (cond, start_locus));
     268                 :            :     }
     269                 :            : 
     270                 :     299534 :   if (cond && TREE_CODE (cond) != INTEGER_CST)
     271                 :            :     {
     272                 :            :       /* If COND is constant, don't bother building an exit.  If it's false,
     273                 :            :          we won't build a loop.  If it's true, any exits are in the body.  */
     274                 :     179679 :       location_t cloc = cp_expr_loc_or_loc (cond, start_locus);
     275                 :     179679 :       exit = build1_loc (cloc, GOTO_EXPR, void_type_node,
     276                 :            :                          get_bc_label (bc_break));
     277                 :     179679 :       exit = fold_build3_loc (cloc, COND_EXPR, void_type_node, cond,
     278                 :            :                               build_empty_stmt (cloc), exit);
     279                 :            :     }
     280                 :            : 
     281                 :     299534 :   if (exit && cond_is_first)
     282                 :            :     {
     283                 :     175093 :       append_to_statement_list (debug_begin, &stmt_list);
     284                 :     175093 :       debug_begin = NULL_TREE;
     285                 :     175093 :       append_to_statement_list (exit, &stmt_list);
     286                 :            :     }
     287                 :     299534 :   append_to_statement_list (body, &stmt_list);
     288                 :     299534 :   finish_bc_block (&stmt_list, bc_continue, clab);
     289                 :     299534 :   if (incr)
     290                 :            :     {
     291                 :     111997 :       if (MAY_HAVE_DEBUG_MARKER_STMTS)
     292                 :            :         {
     293                 :      71665 :           tree d = build0 (DEBUG_BEGIN_STMT, void_type_node);
     294                 :      71665 :           SET_EXPR_LOCATION (d, cp_expr_loc_or_loc (incr, start_locus));
     295                 :      71665 :           append_to_statement_list (d, &stmt_list);
     296                 :            :         }
     297                 :     111997 :       append_to_statement_list (incr, &stmt_list);
     298                 :            :     }
     299                 :     299534 :   append_to_statement_list (debug_begin, &stmt_list);
     300                 :     299534 :   if (exit && !cond_is_first)
     301                 :       4586 :     append_to_statement_list (exit, &stmt_list);
     302                 :            : 
     303                 :     299534 :   if (!stmt_list)
     304                 :       2922 :     stmt_list = build_empty_stmt (start_locus);
     305                 :            : 
     306                 :     299534 :   tree loop;
     307                 :     299534 :   if (cond && integer_zerop (cond))
     308                 :            :     {
     309                 :     101292 :       if (cond_is_first)
     310                 :         74 :         loop = fold_build3_loc (start_locus, COND_EXPR,
     311                 :            :                                 void_type_node, cond, stmt_list,
     312                 :            :                                 build_empty_stmt (start_locus));
     313                 :            :       else
     314                 :     101218 :         loop = stmt_list;
     315                 :            :     }
     316                 :            :   else
     317                 :            :     {
     318                 :     198242 :       location_t loc = start_locus;
     319                 :     198242 :       if (!cond || integer_nonzerop (cond))
     320                 :      18563 :         loc = EXPR_LOCATION (expr_first (body));
     321                 :     197952 :       if (loc == UNKNOWN_LOCATION)
     322                 :            :         loc = start_locus;
     323                 :     198242 :       loop = build1_loc (loc, LOOP_EXPR, void_type_node, stmt_list);
     324                 :            :     }
     325                 :            : 
     326                 :     299534 :   stmt_list = NULL;
     327                 :     299534 :   append_to_statement_list (loop, &stmt_list);
     328                 :     299534 :   finish_bc_block (&stmt_list, bc_break, blab);
     329                 :     299534 :   if (!stmt_list)
     330                 :       2693 :     stmt_list = build_empty_stmt (start_locus);
     331                 :            : 
     332                 :     299534 :   *stmt_p = stmt_list;
     333                 :     299534 : }
     334                 :            : 
     335                 :            : /* Genericize a FOR_STMT node *STMT_P.  */
     336                 :            : 
     337                 :            : static void
     338                 :     126390 : genericize_for_stmt (tree *stmt_p, int *walk_subtrees, void *data)
     339                 :            : {
     340                 :     126390 :   tree stmt = *stmt_p;
     341                 :     126390 :   tree expr = NULL;
     342                 :     126390 :   tree loop;
     343                 :     126390 :   tree init = FOR_INIT_STMT (stmt);
     344                 :            : 
     345                 :     126390 :   if (init)
     346                 :            :     {
     347                 :          0 :       cp_walk_tree (&init, cp_genericize_r, data, NULL);
     348                 :          0 :       append_to_statement_list (init, &expr);
     349                 :            :     }
     350                 :            : 
     351                 :     252780 :   genericize_cp_loop (&loop, EXPR_LOCATION (stmt), FOR_COND (stmt),
     352                 :     126390 :                       FOR_BODY (stmt), FOR_EXPR (stmt), 1, walk_subtrees, data);
     353                 :     126390 :   append_to_statement_list (loop, &expr);
     354                 :     126390 :   if (expr == NULL_TREE)
     355                 :         22 :     expr = loop;
     356                 :     126390 :   *stmt_p = expr;
     357                 :     126390 : }
     358                 :            : 
     359                 :            : /* Genericize a WHILE_STMT node *STMT_P.  */
     360                 :            : 
     361                 :            : static void
     362                 :      67272 : genericize_while_stmt (tree *stmt_p, int *walk_subtrees, void *data)
     363                 :            : {
     364                 :      67272 :   tree stmt = *stmt_p;
     365                 :     134544 :   genericize_cp_loop (stmt_p, EXPR_LOCATION (stmt), WHILE_COND (stmt),
     366                 :      67272 :                       WHILE_BODY (stmt), NULL_TREE, 1, walk_subtrees, data);
     367                 :      67272 : }
     368                 :            : 
     369                 :            : /* Genericize a DO_STMT node *STMT_P.  */
     370                 :            : 
     371                 :            : static void
     372                 :     105872 : genericize_do_stmt (tree *stmt_p, int *walk_subtrees, void *data)
     373                 :            : {
     374                 :     105872 :   tree stmt = *stmt_p;
     375                 :     211744 :   genericize_cp_loop (stmt_p, EXPR_LOCATION (stmt), DO_COND (stmt),
     376                 :     105872 :                       DO_BODY (stmt), NULL_TREE, 0, walk_subtrees, data);
     377                 :     105872 : }
     378                 :            : 
     379                 :            : /* Genericize a SWITCH_STMT node *STMT_P by turning it into a SWITCH_EXPR.  */
     380                 :            : 
     381                 :            : static void
     382                 :      43320 : genericize_switch_stmt (tree *stmt_p, int *walk_subtrees, void *data)
     383                 :            : {
     384                 :      43320 :   tree stmt = *stmt_p;
     385                 :      43320 :   tree break_block, body, cond, type;
     386                 :      43320 :   location_t stmt_locus = EXPR_LOCATION (stmt);
     387                 :            : 
     388                 :      43320 :   body = SWITCH_STMT_BODY (stmt);
     389                 :      43320 :   if (!body)
     390                 :          0 :     body = build_empty_stmt (stmt_locus);
     391                 :      43320 :   cond = SWITCH_STMT_COND (stmt);
     392                 :      43320 :   type = SWITCH_STMT_TYPE (stmt);
     393                 :            : 
     394                 :      43320 :   cp_walk_tree (&cond, cp_genericize_r, data, NULL);
     395                 :            : 
     396                 :      43320 :   break_block = begin_bc_block (bc_break, stmt_locus);
     397                 :            : 
     398                 :      43320 :   cp_walk_tree (&body, cp_genericize_r, data, NULL);
     399                 :      43320 :   cp_walk_tree (&type, cp_genericize_r, data, NULL);
     400                 :      43320 :   *walk_subtrees = 0;
     401                 :            : 
     402                 :      43320 :   if (TREE_USED (break_block))
     403                 :      35746 :     SWITCH_BREAK_LABEL_P (break_block) = 1;
     404                 :      43320 :   finish_bc_block (&body, bc_break, break_block);
     405                 :      43320 :   *stmt_p = build2_loc (stmt_locus, SWITCH_EXPR, type, cond, body);
     406                 :      43320 :   SWITCH_ALL_CASES_P (*stmt_p) = SWITCH_STMT_ALL_CASES_P (stmt);
     407                 :      43320 :   gcc_checking_assert (!SWITCH_STMT_NO_BREAK_P (stmt)
     408                 :            :                        || !TREE_USED (break_block));
     409                 :      43320 : }
     410                 :            : 
     411                 :            : /* Genericize a CONTINUE_STMT node *STMT_P.  */
     412                 :            : 
     413                 :            : static void
     414                 :       1518 : genericize_continue_stmt (tree *stmt_p)
     415                 :            : {
     416                 :       1518 :   tree stmt_list = NULL;
     417                 :       1518 :   tree pred = build_predict_expr (PRED_CONTINUE, NOT_TAKEN);
     418                 :       1518 :   tree label = get_bc_label (bc_continue);
     419                 :       1518 :   location_t location = EXPR_LOCATION (*stmt_p);
     420                 :       1518 :   tree jump = build1_loc (location, GOTO_EXPR, void_type_node, label);
     421                 :       1518 :   append_to_statement_list_force (pred, &stmt_list);
     422                 :       1518 :   append_to_statement_list (jump, &stmt_list);
     423                 :       1518 :   *stmt_p = stmt_list;
     424                 :       1518 : }
     425                 :            : 
     426                 :            : /* Genericize a BREAK_STMT node *STMT_P.  */
     427                 :            : 
     428                 :            : static void
     429                 :     151417 : genericize_break_stmt (tree *stmt_p)
     430                 :            : {
     431                 :     151417 :   tree label = get_bc_label (bc_break);
     432                 :     151417 :   location_t location = EXPR_LOCATION (*stmt_p);
     433                 :     151417 :   *stmt_p = build1_loc (location, GOTO_EXPR, void_type_node, label);
     434                 :     151417 : }
     435                 :            : 
     436                 :            : /* Genericize a OMP_FOR node *STMT_P.  */
     437                 :            : 
     438                 :            : static void
     439                 :      20156 : genericize_omp_for_stmt (tree *stmt_p, int *walk_subtrees, void *data)
     440                 :            : {
     441                 :      20156 :   tree stmt = *stmt_p;
     442                 :      20156 :   location_t locus = EXPR_LOCATION (stmt);
     443                 :      20156 :   tree clab = begin_bc_block (bc_continue, locus);
     444                 :            : 
     445                 :      40312 :   cp_walk_tree (&OMP_FOR_BODY (stmt), cp_genericize_r, data, NULL);
     446                 :      20156 :   if (TREE_CODE (stmt) != OMP_TASKLOOP)
     447                 :      39130 :     cp_walk_tree (&OMP_FOR_CLAUSES (stmt), cp_genericize_r, data, NULL);
     448                 :      40312 :   cp_walk_tree (&OMP_FOR_INIT (stmt), cp_genericize_r, data, NULL);
     449                 :      40312 :   cp_walk_tree (&OMP_FOR_COND (stmt), cp_genericize_r, data, NULL);
     450                 :      40312 :   cp_walk_tree (&OMP_FOR_INCR (stmt), cp_genericize_r, data, NULL);
     451                 :      40312 :   cp_walk_tree (&OMP_FOR_PRE_BODY (stmt), cp_genericize_r, data, NULL);
     452                 :      20156 :   *walk_subtrees = 0;
     453                 :            : 
     454                 :      40312 :   finish_bc_block (&OMP_FOR_BODY (stmt), bc_continue, clab);
     455                 :      20156 : }
     456                 :            : 
     457                 :            : /* Hook into the middle of gimplifying an OMP_FOR node.  */
     458                 :            : 
     459                 :            : static enum gimplify_status
     460                 :      33272 : cp_gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
     461                 :            : {
     462                 :      33272 :   tree for_stmt = *expr_p;
     463                 :      33272 :   gimple_seq seq = NULL;
     464                 :            : 
     465                 :            :   /* Protect ourselves from recursion.  */
     466                 :      66544 :   if (OMP_FOR_GIMPLIFYING_P (for_stmt))
     467                 :            :     return GS_UNHANDLED;
     468                 :      15837 :   OMP_FOR_GIMPLIFYING_P (for_stmt) = 1;
     469                 :            : 
     470                 :      15837 :   gimplify_and_add (for_stmt, &seq);
     471                 :      15837 :   gimple_seq_add_seq (pre_p, seq);
     472                 :            : 
     473                 :      31674 :   OMP_FOR_GIMPLIFYING_P (for_stmt) = 0;
     474                 :            : 
     475                 :      15837 :   return GS_ALL_DONE;
     476                 :            : }
     477                 :            : 
     478                 :            : /*  Gimplify an EXPR_STMT node.  */
     479                 :            : 
     480                 :            : static void
     481                 :    2540550 : gimplify_expr_stmt (tree *stmt_p)
     482                 :            : {
     483                 :    2540550 :   tree stmt = EXPR_STMT_EXPR (*stmt_p);
     484                 :            : 
     485                 :    2540550 :   if (stmt == error_mark_node)
     486                 :            :     stmt = NULL;
     487                 :            : 
     488                 :            :   /* Gimplification of a statement expression will nullify the
     489                 :            :      statement if all its side effects are moved to *PRE_P and *POST_P.
     490                 :            : 
     491                 :            :      In this case we will not want to emit the gimplified statement.
     492                 :            :      However, we may still want to emit a warning, so we do that before
     493                 :            :      gimplification.  */
     494                 :    2539870 :   if (stmt && warn_unused_value)
     495                 :            :     {
     496                 :     250241 :       if (!TREE_SIDE_EFFECTS (stmt))
     497                 :            :         {
     498                 :          0 :           if (!IS_EMPTY_STMT (stmt)
     499                 :       7015 :               && !VOID_TYPE_P (TREE_TYPE (stmt))
     500                 :       7015 :               && !TREE_NO_WARNING (stmt))
     501                 :          0 :             warning (OPT_Wunused_value, "statement with no effect");
     502                 :            :         }
     503                 :            :       else
     504                 :     243226 :         warn_if_unused_value (stmt, input_location);
     505                 :            :     }
     506                 :            : 
     507                 :    2540550 :   if (stmt == NULL_TREE)
     508                 :        674 :     stmt = alloc_stmt_list ();
     509                 :            : 
     510                 :    2540550 :   *stmt_p = stmt;
     511                 :    2540550 : }
     512                 :            : 
     513                 :            : /* Gimplify initialization from an AGGR_INIT_EXPR.  */
     514                 :            : 
     515                 :            : static void
     516                 :    6910030 : cp_gimplify_init_expr (tree *expr_p)
     517                 :            : {
     518                 :    6910030 :   tree from = TREE_OPERAND (*expr_p, 1);
     519                 :    6910030 :   tree to = TREE_OPERAND (*expr_p, 0);
     520                 :    6910030 :   tree t;
     521                 :            : 
     522                 :            :   /* What about code that pulls out the temp and uses it elsewhere?  I
     523                 :            :      think that such code never uses the TARGET_EXPR as an initializer.  If
     524                 :            :      I'm wrong, we'll abort because the temp won't have any RTL.  In that
     525                 :            :      case, I guess we'll need to replace references somehow.  */
     526                 :    6910030 :   if (TREE_CODE (from) == TARGET_EXPR && TARGET_EXPR_INITIAL (from))
     527                 :      84496 :     from = TARGET_EXPR_INITIAL (from);
     528                 :            : 
     529                 :            :   /* Look through any COMPOUND_EXPRs, since build_compound_expr pushes them
     530                 :            :      inside the TARGET_EXPR.  */
     531                 :    6951890 :   for (t = from; t; )
     532                 :            :     {
     533                 :    6951890 :       tree sub = TREE_CODE (t) == COMPOUND_EXPR ? TREE_OPERAND (t, 0) : t;
     534                 :            : 
     535                 :            :       /* If we are initializing from an AGGR_INIT_EXPR, drop the INIT_EXPR and
     536                 :            :          replace the slot operand with our target.
     537                 :            : 
     538                 :            :          Should we add a target parm to gimplify_expr instead?  No, as in this
     539                 :            :          case we want to replace the INIT_EXPR.  */
     540                 :    6951890 :       if (TREE_CODE (sub) == AGGR_INIT_EXPR
     541                 :    6951890 :           || TREE_CODE (sub) == VEC_INIT_EXPR)
     542                 :            :         {
     543                 :      64267 :           if (TREE_CODE (sub) == AGGR_INIT_EXPR)
     544                 :      63797 :             AGGR_INIT_EXPR_SLOT (sub) = to;
     545                 :            :           else
     546                 :        470 :             VEC_INIT_EXPR_SLOT (sub) = to;
     547                 :      64267 :           *expr_p = from;
     548                 :            : 
     549                 :            :           /* The initialization is now a side-effect, so the container can
     550                 :            :              become void.  */
     551                 :      64267 :           if (from != sub)
     552                 :         33 :             TREE_TYPE (from) = void_type_node;
     553                 :            :         }
     554                 :            : 
     555                 :            :       /* Handle aggregate NSDMI.  */
     556                 :    6951890 :       replace_placeholders (sub, to);
     557                 :            : 
     558                 :    6951890 :       if (t == sub)
     559                 :            :         break;
     560                 :            :       else
     561                 :      41859 :         t = TREE_OPERAND (t, 1);
     562                 :            :     }
     563                 :            : 
     564                 :    6910030 : }
     565                 :            : 
     566                 :            : /* Gimplify a MUST_NOT_THROW_EXPR.  */
     567                 :            : 
     568                 :            : static enum gimplify_status
     569                 :     363219 : gimplify_must_not_throw_expr (tree *expr_p, gimple_seq *pre_p)
     570                 :            : {
     571                 :     363219 :   tree stmt = *expr_p;
     572                 :     363219 :   tree temp = voidify_wrapper_expr (stmt, NULL);
     573                 :     363219 :   tree body = TREE_OPERAND (stmt, 0);
     574                 :     363219 :   gimple_seq try_ = NULL;
     575                 :     363219 :   gimple_seq catch_ = NULL;
     576                 :     363219 :   gimple *mnt;
     577                 :            : 
     578                 :     363219 :   gimplify_and_add (body, &try_);
     579                 :     363219 :   mnt = gimple_build_eh_must_not_throw (terminate_fn);
     580                 :     363219 :   gimple_seq_add_stmt_without_update (&catch_, mnt);
     581                 :     363219 :   mnt = gimple_build_try (try_, catch_, GIMPLE_TRY_CATCH);
     582                 :            : 
     583                 :     363219 :   gimple_seq_add_stmt_without_update (pre_p, mnt);
     584                 :     363219 :   if (temp)
     585                 :            :     {
     586                 :         33 :       *expr_p = temp;
     587                 :         33 :       return GS_OK;
     588                 :            :     }
     589                 :            : 
     590                 :     363186 :   *expr_p = NULL;
     591                 :     363186 :   return GS_ALL_DONE;
     592                 :            : }
     593                 :            : 
     594                 :            : /* Return TRUE if an operand (OP) of a given TYPE being copied is
     595                 :            :    really just an empty class copy.
     596                 :            : 
     597                 :            :    Check that the operand has a simple form so that TARGET_EXPRs and
     598                 :            :    non-empty CONSTRUCTORs get reduced properly, and we leave the
     599                 :            :    return slot optimization alone because it isn't a copy.  */
     600                 :            : 
     601                 :            : bool
     602                 :   10046500 : simple_empty_class_p (tree type, tree op, tree_code code)
     603                 :            : {
     604                 :   11080000 :   if (TREE_CODE (op) == COMPOUND_EXPR)
     605                 :      92756 :     return simple_empty_class_p (type, TREE_OPERAND (op, 1), code);
     606                 :     980865 :   if (SIMPLE_TARGET_EXPR_P (op)
     607                 :   11931200 :       && TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
     608                 :            :     /* The TARGET_EXPR is itself a simple copy, look through it.  */
     609                 :     940747 :     return simple_empty_class_p (type, TARGET_EXPR_INITIAL (op), code);
     610                 :   10046500 :   return
     611                 :            :     (TREE_CODE (op) == EMPTY_CLASS_EXPR
     612                 :   10045900 :      || code == MODIFY_EXPR
     613                 :    8408520 :      || is_gimple_lvalue (op)
     614                 :    6484450 :      || INDIRECT_REF_P (op)
     615                 :    6224860 :      || (TREE_CODE (op) == CONSTRUCTOR
     616                 :     695999 :          && CONSTRUCTOR_NELTS (op) == 0)
     617                 :    5560160 :      || (TREE_CODE (op) == CALL_EXPR
     618                 :    1630280 :          && !CALL_EXPR_RETURN_SLOT_OPT (op)))
     619                 :    6069890 :     && !TREE_CLOBBER_P (op)
     620                 :   15731300 :     && is_really_empty_class (type, /*ignore_vptr*/true);
     621                 :            : }
     622                 :            : 
     623                 :            : /* Returns true if evaluating E as an lvalue has side-effects;
     624                 :            :    specifically, a volatile lvalue has TREE_SIDE_EFFECTS, but it doesn't really
     625                 :            :    have side-effects until there is a read or write through it.  */
     626                 :            : 
     627                 :            : static bool
     628                 :     184709 : lvalue_has_side_effects (tree e)
     629                 :            : {
     630                 :     184709 :   if (!TREE_SIDE_EFFECTS (e))
     631                 :            :     return false;
     632                 :       5260 :   while (handled_component_p (e))
     633                 :            :     {
     634                 :        382 :       if (TREE_CODE (e) == ARRAY_REF
     635                 :        382 :           && TREE_SIDE_EFFECTS (TREE_OPERAND (e, 1)))
     636                 :            :         return true;
     637                 :        180 :       e = TREE_OPERAND (e, 0);
     638                 :            :     }
     639                 :       4878 :   if (DECL_P (e))
     640                 :            :     /* Just naming a variable has no side-effects.  */
     641                 :            :     return false;
     642                 :       1914 :   else if (INDIRECT_REF_P (e))
     643                 :            :     /* Similarly, indirection has no side-effects.  */
     644                 :       1832 :     return TREE_SIDE_EFFECTS (TREE_OPERAND (e, 0));
     645                 :            :   else
     646                 :            :     /* For anything else, trust TREE_SIDE_EFFECTS.  */
     647                 :         82 :     return TREE_SIDE_EFFECTS (e);
     648                 :            : }
     649                 :            : 
     650                 :            : /* Gimplify *EXPR_P as rvalue into an expression that can't be modified
     651                 :            :    by expressions with side-effects in other operands.  */
     652                 :            : 
     653                 :            : static enum gimplify_status
     654                 :       3889 : gimplify_to_rvalue (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
     655                 :            :                     bool (*gimple_test_f) (tree))
     656                 :            : {
     657                 :       3889 :   enum gimplify_status t
     658                 :       3889 :     = gimplify_expr (expr_p, pre_p, post_p, gimple_test_f, fb_rvalue);
     659                 :       3889 :   if (t == GS_ERROR)
     660                 :            :     return GS_ERROR;
     661                 :       4866 :   else if (is_gimple_variable (*expr_p) && TREE_CODE (*expr_p) != SSA_NAME)
     662                 :        485 :     *expr_p = get_initialized_tmp_var (*expr_p, pre_p);
     663                 :            :   return t;
     664                 :            : }
     665                 :            : 
     666                 :            : /* Do C++-specific gimplification.  Args are as for gimplify_expr.  */
     667                 :            : 
     668                 :            : int
     669                 :  103238000 : cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
     670                 :            : {
     671                 :  103238000 :   int saved_stmts_are_full_exprs_p = 0;
     672                 :  103238000 :   location_t loc = cp_expr_loc_or_input_loc (*expr_p);
     673                 :  103238000 :   enum tree_code code = TREE_CODE (*expr_p);
     674                 :  103238000 :   enum gimplify_status ret;
     675                 :            : 
     676                 :  103238000 :   if (STATEMENT_CODE_P (code))
     677                 :            :     {
     678                 :    2592760 :       saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
     679                 :    5185530 :       current_stmt_tree ()->stmts_are_full_exprs_p
     680                 :    5185530 :         = STMT_IS_FULL_EXPR_P (*expr_p);
     681                 :            :     }
     682                 :            : 
     683                 :  103238000 :   switch (code)
     684                 :            :     {
     685                 :     197720 :     case AGGR_INIT_EXPR:
     686                 :     197720 :       simplify_aggr_init_expr (expr_p);
     687                 :     197720 :       ret = GS_OK;
     688                 :     197720 :       break;
     689                 :            : 
     690                 :        470 :     case VEC_INIT_EXPR:
     691                 :        470 :       {
     692                 :        470 :         location_t loc = input_location;
     693                 :        470 :         tree init = VEC_INIT_EXPR_INIT (*expr_p);
     694                 :        520 :         int from_array = (init && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE);
     695                 :        470 :         gcc_assert (EXPR_HAS_LOCATION (*expr_p));
     696                 :        470 :         input_location = EXPR_LOCATION (*expr_p);
     697                 :        470 :         *expr_p = build_vec_init (VEC_INIT_EXPR_SLOT (*expr_p), NULL_TREE,
     698                 :        470 :                                   init, VEC_INIT_EXPR_VALUE_INIT (*expr_p),
     699                 :            :                                   from_array,
     700                 :        470 :                                   tf_warning_or_error);
     701                 :        470 :         hash_set<tree> pset;
     702                 :        470 :         cp_walk_tree (expr_p, cp_fold_r, &pset, NULL);
     703                 :        470 :         cp_genericize_tree (expr_p, false);
     704                 :        470 :         copy_if_shared (expr_p);
     705                 :        470 :         ret = GS_OK;
     706                 :        470 :         input_location = loc;
     707                 :            :       }
     708                 :        470 :       break;
     709                 :            : 
     710                 :      22686 :     case THROW_EXPR:
     711                 :            :       /* FIXME communicate throw type to back end, probably by moving
     712                 :            :          THROW_EXPR into ../tree.def.  */
     713                 :      22686 :       *expr_p = TREE_OPERAND (*expr_p, 0);
     714                 :      22686 :       ret = GS_OK;
     715                 :      22686 :       break;
     716                 :            : 
     717                 :     363219 :     case MUST_NOT_THROW_EXPR:
     718                 :     363219 :       ret = gimplify_must_not_throw_expr (expr_p, pre_p);
     719                 :     363219 :       break;
     720                 :            : 
     721                 :            :       /* We used to do this for MODIFY_EXPR as well, but that's unsafe; the
     722                 :            :          LHS of an assignment might also be involved in the RHS, as in bug
     723                 :            :          25979.  */
     724                 :    6910030 :     case INIT_EXPR:
     725                 :    6910030 :       cp_gimplify_init_expr (expr_p);
     726                 :    6910030 :       if (TREE_CODE (*expr_p) != INIT_EXPR)
     727                 :            :         return GS_OK;
     728                 :            :       /* Fall through.  */
     729                 :    9173570 :     case MODIFY_EXPR:
     730                 :    6845770 :     modify_expr_case:
     731                 :    9173570 :       {
     732                 :            :         /* If the back end isn't clever enough to know that the lhs and rhs
     733                 :            :            types are the same, add an explicit conversion.  */
     734                 :    9173570 :         tree op0 = TREE_OPERAND (*expr_p, 0);
     735                 :    9173570 :         tree op1 = TREE_OPERAND (*expr_p, 1);
     736                 :            : 
     737                 :   18347100 :         if (!error_operand_p (op0)
     738                 :   18347100 :             && !error_operand_p (op1)
     739                 :    9173540 :             && (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (op0))
     740                 :    9170980 :                 || TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (op1)))
     741                 :    9176140 :             && !useless_type_conversion_p (TREE_TYPE (op1), TREE_TYPE (op0)))
     742                 :         24 :           TREE_OPERAND (*expr_p, 1) = build1 (VIEW_CONVERT_EXPR,
     743                 :         12 :                                               TREE_TYPE (op0), op1);
     744                 :            : 
     745                 :    9173560 :         else if (simple_empty_class_p (TREE_TYPE (op0), op1, code))
     746                 :            :           {
     747                 :      89989 :             while (TREE_CODE (op1) == TARGET_EXPR)
     748                 :            :               /* We're disconnecting the initializer from its target,
     749                 :            :                  don't create a temporary.  */
     750                 :       5288 :               op1 = TARGET_EXPR_INITIAL (op1);
     751                 :            : 
     752                 :            :             /* Remove any copies of empty classes.  Also drop volatile
     753                 :            :                variables on the RHS to avoid infinite recursion from
     754                 :            :                gimplify_expr trying to load the value.  */
     755                 :      84701 :             if (TREE_SIDE_EFFECTS (op1))
     756                 :            :               {
     757                 :       7427 :                 if (TREE_THIS_VOLATILE (op1)
     758                 :       7427 :                     && (REFERENCE_CLASS_P (op1) || DECL_P (op1)))
     759                 :         32 :                   op1 = build_fold_addr_expr (op1);
     760                 :            : 
     761                 :       7427 :                 gimplify_and_add (op1, pre_p);
     762                 :            :               }
     763                 :      84701 :             gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
     764                 :            :                            is_gimple_lvalue, fb_lvalue);
     765                 :      84701 :             *expr_p = TREE_OPERAND (*expr_p, 0);
     766                 :      84701 :             if (code == RETURN_EXPR && REFERENCE_CLASS_P (*expr_p))
     767                 :            :               /* Avoid 'return *<retval>;'  */
     768                 :          3 :               *expr_p = TREE_OPERAND (*expr_p, 0);
     769                 :            :           }
     770                 :            :         /* P0145 says that the RHS is sequenced before the LHS.
     771                 :            :            gimplify_modify_expr gimplifies the RHS before the LHS, but that
     772                 :            :            isn't quite strong enough in two cases:
     773                 :            : 
     774                 :            :            1) gimplify.c wants to leave a CALL_EXPR on the RHS, which would
     775                 :            :            mean it's evaluated after the LHS.
     776                 :            : 
     777                 :            :            2) the value calculation of the RHS is also sequenced before the
     778                 :            :            LHS, so for scalar assignment we need to preevaluate if the
     779                 :            :            RHS could be affected by LHS side-effects even if it has no
     780                 :            :            side-effects of its own.  We don't need this for classes because
     781                 :            :            class assignment takes its RHS by reference.  */
     782                 :    9088860 :        else if (flag_strong_eval_order > 1
     783                 :    1195060 :                 && TREE_CODE (*expr_p) == MODIFY_EXPR
     784                 :     184709 :                 && lvalue_has_side_effects (op0)
     785                 :    9090930 :                 && (TREE_CODE (op1) == CALL_EXPR
     786                 :       1746 :                     || (SCALAR_TYPE_P (TREE_TYPE (op1))
     787                 :       1504 :                         && !TREE_CONSTANT (op1))))
     788                 :       1307 :          TREE_OPERAND (*expr_p, 1) = get_initialized_tmp_var (op1, pre_p);
     789                 :            :       }
     790                 :            :       ret = GS_OK;
     791                 :            :       break;
     792                 :            : 
     793                 :      50011 :     case EMPTY_CLASS_EXPR:
     794                 :            :       /* We create an empty CONSTRUCTOR with RECORD_TYPE.  */
     795                 :      50011 :       *expr_p = build_constructor (TREE_TYPE (*expr_p), NULL);
     796                 :      50011 :       ret = GS_OK;
     797                 :      50011 :       break;
     798                 :            : 
     799                 :          7 :     case BASELINK:
     800                 :          7 :       *expr_p = BASELINK_FUNCTIONS (*expr_p);
     801                 :          7 :       ret = GS_OK;
     802                 :          7 :       break;
     803                 :            : 
     804                 :      21045 :     case TRY_BLOCK:
     805                 :      21045 :       genericize_try_block (expr_p);
     806                 :      21045 :       ret = GS_OK;
     807                 :      21045 :       break;
     808                 :            : 
     809                 :      22901 :     case HANDLER:
     810                 :      22901 :       genericize_catch_block (expr_p);
     811                 :      22901 :       ret = GS_OK;
     812                 :      22901 :       break;
     813                 :            : 
     814                 :       8272 :     case EH_SPEC_BLOCK:
     815                 :       8272 :       genericize_eh_spec_block (expr_p);
     816                 :       8272 :       ret = GS_OK;
     817                 :       8272 :       break;
     818                 :            : 
     819                 :          0 :     case USING_STMT:
     820                 :          0 :       gcc_unreachable ();
     821                 :            : 
     822                 :          0 :     case FOR_STMT:
     823                 :          0 :     case WHILE_STMT:
     824                 :          0 :     case DO_STMT:
     825                 :          0 :     case SWITCH_STMT:
     826                 :          0 :     case CONTINUE_STMT:
     827                 :          0 :     case BREAK_STMT:
     828                 :          0 :       gcc_unreachable ();
     829                 :            : 
     830                 :      33272 :     case OMP_FOR:
     831                 :      33272 :     case OMP_SIMD:
     832                 :      33272 :     case OMP_DISTRIBUTE:
     833                 :      33272 :     case OMP_LOOP:
     834                 :      33272 :     case OMP_TASKLOOP:
     835                 :      33272 :       ret = cp_gimplify_omp_for (expr_p, pre_p);
     836                 :      33272 :       break;
     837                 :            : 
     838                 :    2540550 :     case EXPR_STMT:
     839                 :    2540550 :       gimplify_expr_stmt (expr_p);
     840                 :    2540550 :       ret = GS_OK;
     841                 :    2540550 :       break;
     842                 :            : 
     843                 :          0 :     case UNARY_PLUS_EXPR:
     844                 :          0 :       {
     845                 :          0 :         tree arg = TREE_OPERAND (*expr_p, 0);
     846                 :          0 :         tree type = TREE_TYPE (*expr_p);
     847                 :          0 :         *expr_p = (TREE_TYPE (arg) != type) ? fold_convert (type, arg)
     848                 :            :                                             : arg;
     849                 :          0 :         ret = GS_OK;
     850                 :            :       }
     851                 :          0 :       break;
     852                 :            : 
     853                 :    5466820 :     case CALL_EXPR:
     854                 :    5466820 :       ret = GS_OK;
     855                 :    5466820 :       if (flag_strong_eval_order == 2
     856                 :     811345 :           && CALL_EXPR_FN (*expr_p)
     857                 :    6259100 :           && cp_get_callee_fndecl_nofold (*expr_p) == NULL_TREE)
     858                 :            :         {
     859                 :       3889 :           tree fnptrtype = TREE_TYPE (CALL_EXPR_FN (*expr_p));
     860                 :       3889 :           enum gimplify_status t
     861                 :       3889 :             = gimplify_to_rvalue (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
     862                 :            :                                   is_gimple_call_addr);
     863                 :       3889 :           if (t == GS_ERROR)
     864                 :            :             ret = GS_ERROR;
     865                 :            :           /* GIMPLE considers most pointer conversion useless, but for
     866                 :            :              calls we actually care about the exact function pointer type.  */
     867                 :       3889 :           else if (TREE_TYPE (CALL_EXPR_FN (*expr_p)) != fnptrtype)
     868                 :        674 :             CALL_EXPR_FN (*expr_p)
     869                 :        337 :               = build1 (NOP_EXPR, fnptrtype, CALL_EXPR_FN (*expr_p));
     870                 :            :         }
     871                 :    5466820 :       if (!CALL_EXPR_FN (*expr_p))
     872                 :            :         /* Internal function call.  */;
     873                 :    5325360 :       else if (CALL_EXPR_REVERSE_ARGS (*expr_p))
     874                 :            :         {
     875                 :            :           /* This is a call to a (compound) assignment operator that used
     876                 :            :              the operator syntax; gimplify the RHS first.  */
     877                 :       3718 :           gcc_assert (call_expr_nargs (*expr_p) == 2);
     878                 :       3718 :           gcc_assert (!CALL_EXPR_ORDERED_ARGS (*expr_p));
     879                 :       3718 :           enum gimplify_status t
     880                 :       3718 :             = gimplify_arg (&CALL_EXPR_ARG (*expr_p, 1), pre_p, loc);
     881                 :       3718 :           if (t == GS_ERROR)
     882                 :            :             ret = GS_ERROR;
     883                 :            :         }
     884                 :    5321640 :       else if (CALL_EXPR_ORDERED_ARGS (*expr_p))
     885                 :            :         {
     886                 :            :           /* Leave the last argument for gimplify_call_expr, to avoid problems
     887                 :            :              with __builtin_va_arg_pack().  */
     888                 :     128270 :           int nargs = call_expr_nargs (*expr_p) - 1;
     889                 :     263014 :           for (int i = 0; i < nargs; ++i)
     890                 :            :             {
     891                 :     134744 :               enum gimplify_status t
     892                 :     134744 :                 = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p, loc);
     893                 :     134744 :               if (t == GS_ERROR)
     894                 :          0 :                 ret = GS_ERROR;
     895                 :            :             }
     896                 :            :         }
     897                 :    5193370 :       else if (flag_strong_eval_order
     898                 :    5193370 :                && !CALL_EXPR_OPERATOR_SYNTAX (*expr_p))
     899                 :            :         {
     900                 :            :           /* If flag_strong_eval_order, evaluate the object argument first.  */
     901                 :    4864340 :           tree fntype = TREE_TYPE (CALL_EXPR_FN (*expr_p));
     902                 :    4864340 :           if (INDIRECT_TYPE_P (fntype))
     903                 :    4864340 :             fntype = TREE_TYPE (fntype);
     904                 :    4864340 :           if (TREE_CODE (fntype) == METHOD_TYPE)
     905                 :            :             {
     906                 :    2246780 :               enum gimplify_status t
     907                 :    2246780 :                 = gimplify_arg (&CALL_EXPR_ARG (*expr_p, 0), pre_p, loc);
     908                 :    2246780 :               if (t == GS_ERROR)
     909                 :            :                 ret = GS_ERROR;
     910                 :            :             }
     911                 :            :         }
     912                 :    5466820 :       if (ret != GS_ERROR)
     913                 :            :         {
     914                 :    5466820 :           tree decl = cp_get_callee_fndecl_nofold (*expr_p);
     915                 :    5466820 :           if (decl
     916                 :    5466820 :               && fndecl_built_in_p (decl, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
     917                 :            :                                     BUILT_IN_FRONTEND))
     918                 :        952 :             *expr_p = boolean_false_node;
     919                 :    5465860 :           else if (decl
     920                 :    5465860 :                    && fndecl_built_in_p (decl, CP_BUILT_IN_SOURCE_LOCATION,
     921                 :            :                                          BUILT_IN_FRONTEND))
     922                 :          0 :             *expr_p = fold_builtin_source_location (EXPR_LOCATION (*expr_p));
     923                 :            :         }
     924                 :            :       break;
     925                 :            : 
     926                 :     284967 :     case TARGET_EXPR:
     927                 :            :       /* A TARGET_EXPR that expresses direct-initialization should have been
     928                 :            :          elided by cp_gimplify_init_expr.  */
     929                 :     284967 :       gcc_checking_assert (!TARGET_EXPR_DIRECT_INIT_P (*expr_p));
     930                 :            :       ret = GS_UNHANDLED;
     931                 :            :       break;
     932                 :            : 
     933                 :     714388 :     case RETURN_EXPR:
     934                 :     714388 :       if (TREE_OPERAND (*expr_p, 0)
     935                 :     714388 :           && (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == INIT_EXPR
     936                 :       5976 :               || TREE_CODE (TREE_OPERAND (*expr_p, 0)) == MODIFY_EXPR))
     937                 :            :         {
     938                 :     690462 :           expr_p = &TREE_OPERAND (*expr_p, 0);
     939                 :            :           /* Avoid going through the INIT_EXPR case, which can
     940                 :            :              degrade INIT_EXPRs into AGGR_INIT_EXPRs.  */
     941                 :     690462 :           goto modify_expr_case;
     942                 :            :         }
     943                 :            :       /* Fall through.  */
     944                 :            : 
     945                 :   84988500 :     default:
     946                 :   84988500 :       ret = (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p);
     947                 :   84988500 :       break;
     948                 :            :     }
     949                 :            : 
     950                 :            :   /* Restore saved state.  */
     951                 :  103174000 :   if (STATEMENT_CODE_P (code))
     952                 :    2592760 :     current_stmt_tree ()->stmts_are_full_exprs_p
     953                 :    2592760 :       = saved_stmts_are_full_exprs_p;
     954                 :            : 
     955                 :            :   return ret;
     956                 :            : }
     957                 :            : 
     958                 :            : static inline bool
     959                 :  308322000 : is_invisiref_parm (const_tree t)
     960                 :            : {
     961                 :  308322000 :   return ((TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == RESULT_DECL)
     962                 :  335006000 :           && DECL_BY_REFERENCE (t));
     963                 :            : }
     964                 :            : 
     965                 :            : /* Return true if the uid in both int tree maps are equal.  */
     966                 :            : 
     967                 :            : bool
     968                 :        300 : cxx_int_tree_map_hasher::equal (cxx_int_tree_map *a, cxx_int_tree_map *b)
     969                 :            : {
     970                 :        300 :   return (a->uid == b->uid);
     971                 :            : }
     972                 :            : 
     973                 :            : /* Hash a UID in a cxx_int_tree_map.  */
     974                 :            : 
     975                 :            : unsigned int
     976                 :        141 : cxx_int_tree_map_hasher::hash (cxx_int_tree_map *item)
     977                 :            : {
     978                 :        141 :   return item->uid;
     979                 :            : }
     980                 :            : 
     981                 :            : /* A stable comparison routine for use with splay trees and DECLs.  */
     982                 :            : 
     983                 :            : static int
     984                 :      57164 : splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
     985                 :            : {
     986                 :      57164 :   tree a = (tree) xa;
     987                 :      57164 :   tree b = (tree) xb;
     988                 :            : 
     989                 :      57164 :   return DECL_UID (a) - DECL_UID (b);
     990                 :            : }
     991                 :            : 
     992                 :            : /* OpenMP context during genericization.  */
     993                 :            : 
     994                 :            : struct cp_genericize_omp_taskreg
     995                 :            : {
     996                 :            :   bool is_parallel;
     997                 :            :   bool default_shared;
     998                 :            :   struct cp_genericize_omp_taskreg *outer;
     999                 :            :   splay_tree variables;
    1000                 :            : };
    1001                 :            : 
    1002                 :            : /* Return true if genericization should try to determine if
    1003                 :            :    DECL is firstprivate or shared within task regions.  */
    1004                 :            : 
    1005                 :            : static bool
    1006                 :      93001 : omp_var_to_track (tree decl)
    1007                 :            : {
    1008                 :      93001 :   tree type = TREE_TYPE (decl);
    1009                 :      93001 :   if (is_invisiref_parm (decl))
    1010                 :        554 :     type = TREE_TYPE (type);
    1011                 :      92447 :   else if (TYPE_REF_P (type))
    1012                 :       4656 :     type = TREE_TYPE (type);
    1013                 :     112275 :   while (TREE_CODE (type) == ARRAY_TYPE)
    1014                 :      19274 :     type = TREE_TYPE (type);
    1015                 :     105521 :   if (type == error_mark_node || !CLASS_TYPE_P (type))
    1016                 :            :     return false;
    1017                 :      12520 :   if (VAR_P (decl) && CP_DECL_THREAD_LOCAL_P (decl))
    1018                 :            :     return false;
    1019                 :      12517 :   if (cxx_omp_predetermined_sharing (decl) != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
    1020                 :         72 :     return false;
    1021                 :            :   return true;
    1022                 :            : }
    1023                 :            : 
    1024                 :            : /* Note DECL use in OpenMP region OMP_CTX during genericization.  */
    1025                 :            : 
    1026                 :            : static void
    1027                 :      12750 : omp_cxx_notice_variable (struct cp_genericize_omp_taskreg *omp_ctx, tree decl)
    1028                 :            : {
    1029                 :      12750 :   splay_tree_node n = splay_tree_lookup (omp_ctx->variables,
    1030                 :            :                                          (splay_tree_key) decl);
    1031                 :      12750 :   if (n == NULL)
    1032                 :            :     {
    1033                 :       4116 :       int flags = OMP_CLAUSE_DEFAULT_SHARED;
    1034                 :       4116 :       if (omp_ctx->outer)
    1035                 :       1251 :         omp_cxx_notice_variable (omp_ctx->outer, decl);
    1036                 :       4116 :       if (!omp_ctx->default_shared)
    1037                 :            :         {
    1038                 :        938 :           struct cp_genericize_omp_taskreg *octx;
    1039                 :            : 
    1040                 :       1055 :           for (octx = omp_ctx->outer; octx; octx = octx->outer)
    1041                 :            :             {
    1042                 :        896 :               n = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
    1043                 :        896 :               if (n && n->value != OMP_CLAUSE_DEFAULT_SHARED)
    1044                 :            :                 {
    1045                 :            :                   flags = OMP_CLAUSE_DEFAULT_FIRSTPRIVATE;
    1046                 :            :                   break;
    1047                 :            :                 }
    1048                 :        853 :               if (octx->is_parallel)
    1049                 :            :                 break;
    1050                 :            :             }
    1051                 :        938 :           if (octx == NULL
    1052                 :        938 :               && (TREE_CODE (decl) == PARM_DECL
    1053                 :        160 :                   || (!(TREE_STATIC (decl) || DECL_EXTERNAL (decl))
    1054                 :         42 :                       && DECL_CONTEXT (decl) == current_function_decl)))
    1055                 :            :             flags = OMP_CLAUSE_DEFAULT_FIRSTPRIVATE;
    1056                 :        855 :           if (flags == OMP_CLAUSE_DEFAULT_FIRSTPRIVATE)
    1057                 :            :             {
    1058                 :            :               /* DECL is implicitly determined firstprivate in
    1059                 :            :                  the current task construct.  Ensure copy ctor and
    1060                 :            :                  dtor are instantiated, because during gimplification
    1061                 :            :                  it will be already too late.  */
    1062                 :        126 :               tree type = TREE_TYPE (decl);
    1063                 :        126 :               if (is_invisiref_parm (decl))
    1064                 :          2 :                 type = TREE_TYPE (type);
    1065                 :        124 :               else if (TYPE_REF_P (type))
    1066                 :         55 :                 type = TREE_TYPE (type);
    1067                 :        170 :               while (TREE_CODE (type) == ARRAY_TYPE)
    1068                 :         44 :                 type = TREE_TYPE (type);
    1069                 :        126 :               get_copy_ctor (type, tf_none);
    1070                 :        126 :               get_dtor (type, tf_none);
    1071                 :            :             }
    1072                 :            :         }
    1073                 :       4116 :       splay_tree_insert (omp_ctx->variables, (splay_tree_key) decl, flags);
    1074                 :            :     }
    1075                 :      12750 : }
    1076                 :            : 
    1077                 :            : /* Genericization context.  */
    1078                 :            : 
    1079                 :            : struct cp_genericize_data
    1080                 :            : {
    1081                 :            :   hash_set<tree> *p_set;
    1082                 :            :   vec<tree> bind_expr_stack;
    1083                 :            :   struct cp_genericize_omp_taskreg *omp_ctx;
    1084                 :            :   tree try_block;
    1085                 :            :   bool no_sanitize_p;
    1086                 :            :   bool handle_invisiref_parm_p;
    1087                 :            : };
    1088                 :            : 
    1089                 :            : /* Perform any pre-gimplification folding of C++ front end trees to
    1090                 :            :    GENERIC.
    1091                 :            :    Note:  The folding of none-omp cases is something to move into
    1092                 :            :      the middle-end.  As for now we have most foldings only on GENERIC
    1093                 :            :      in fold-const, we need to perform this before transformation to
    1094                 :            :      GIMPLE-form.  */
    1095                 :            : 
    1096                 :            : static tree
    1097                 :  369870000 : cp_fold_r (tree *stmt_p, int *walk_subtrees, void *data)
    1098                 :            : {
    1099                 :  369870000 :   tree stmt;
    1100                 :  369870000 :   enum tree_code code;
    1101                 :            : 
    1102                 :  369870000 :   *stmt_p = stmt = cp_fold (*stmt_p);
    1103                 :            : 
    1104                 :  369870000 :   if (((hash_set<tree> *) data)->add (stmt))
    1105                 :            :     {
    1106                 :            :       /* Don't walk subtrees of stmts we've already walked once, otherwise
    1107                 :            :          we can have exponential complexity with e.g. lots of nested
    1108                 :            :          SAVE_EXPRs or TARGET_EXPRs.  cp_fold uses a cache and will return
    1109                 :            :          always the same tree, which the first time cp_fold_r has been
    1110                 :            :          called on it had the subtrees walked.  */
    1111                 :   47058900 :       *walk_subtrees = 0;
    1112                 :   47058900 :       return NULL;
    1113                 :            :     }
    1114                 :            : 
    1115                 :  322811000 :   code = TREE_CODE (stmt);
    1116                 :  322811000 :   if (code == OMP_FOR || code == OMP_SIMD || code == OMP_DISTRIBUTE
    1117                 :  322811000 :       || code == OMP_LOOP || code == OMP_TASKLOOP || code == OACC_LOOP)
    1118                 :            :     {
    1119                 :      20168 :       tree x;
    1120                 :      20168 :       int i, n;
    1121                 :            : 
    1122                 :      40336 :       cp_walk_tree (&OMP_FOR_BODY (stmt), cp_fold_r, data, NULL);
    1123                 :      40336 :       cp_walk_tree (&OMP_FOR_CLAUSES (stmt), cp_fold_r, data, NULL);
    1124                 :      40336 :       cp_walk_tree (&OMP_FOR_INIT (stmt), cp_fold_r, data, NULL);
    1125                 :      40336 :       x = OMP_FOR_COND (stmt);
    1126                 :      20168 :       if (x && TREE_CODE_CLASS (TREE_CODE (x)) == tcc_comparison)
    1127                 :            :         {
    1128                 :          0 :           cp_walk_tree (&TREE_OPERAND (x, 0), cp_fold_r, data, NULL);
    1129                 :          0 :           cp_walk_tree (&TREE_OPERAND (x, 1), cp_fold_r, data, NULL);
    1130                 :            :         }
    1131                 :      20168 :       else if (x && TREE_CODE (x) == TREE_VEC)
    1132                 :            :         {
    1133                 :      14627 :           n = TREE_VEC_LENGTH (x);
    1134                 :      33882 :           for (i = 0; i < n; i++)
    1135                 :            :             {
    1136                 :      19255 :               tree o = TREE_VEC_ELT (x, i);
    1137                 :      19255 :               if (o && TREE_CODE_CLASS (TREE_CODE (o)) == tcc_comparison)
    1138                 :      19255 :                 cp_walk_tree (&TREE_OPERAND (o, 1), cp_fold_r, data, NULL);
    1139                 :            :             }
    1140                 :            :         }
    1141                 :      40336 :       x = OMP_FOR_INCR (stmt);
    1142                 :      20168 :       if (x && TREE_CODE (x) == TREE_VEC)
    1143                 :            :         {
    1144                 :      14627 :           n = TREE_VEC_LENGTH (x);
    1145                 :      33882 :           for (i = 0; i < n; i++)
    1146                 :            :             {
    1147                 :      19255 :               tree o = TREE_VEC_ELT (x, i);
    1148                 :      19255 :               if (o && TREE_CODE (o) == MODIFY_EXPR)
    1149                 :       5644 :                 o = TREE_OPERAND (o, 1);
    1150                 :      19255 :               if (o && (TREE_CODE (o) == PLUS_EXPR || TREE_CODE (o) == MINUS_EXPR
    1151                 :      14947 :                         || TREE_CODE (o) == POINTER_PLUS_EXPR))
    1152                 :            :                 {
    1153                 :       5644 :                   cp_walk_tree (&TREE_OPERAND (o, 0), cp_fold_r, data, NULL);
    1154                 :       5644 :                   cp_walk_tree (&TREE_OPERAND (o, 1), cp_fold_r, data, NULL);
    1155                 :            :                 }
    1156                 :            :             }
    1157                 :            :         }
    1158                 :      40336 :       cp_walk_tree (&OMP_FOR_PRE_BODY (stmt), cp_fold_r, data, NULL);
    1159                 :      20168 :       *walk_subtrees = 0;
    1160                 :            :     }
    1161                 :            : 
    1162                 :            :   return NULL;
    1163                 :            : }
    1164                 :            : 
    1165                 :            : /* Fold ALL the trees!  FIXME we should be able to remove this, but
    1166                 :            :    apparently that still causes optimization regressions.  */
    1167                 :            : 
    1168                 :            : void
    1169                 :   14116800 : cp_fold_function (tree fndecl)
    1170                 :            : {
    1171                 :   14116800 :   hash_set<tree> pset;
    1172                 :   14116800 :   cp_walk_tree (&DECL_SAVED_TREE (fndecl), cp_fold_r, &pset, NULL);
    1173                 :   14116800 : }
    1174                 :            : 
    1175                 :            : /* Turn SPACESHIP_EXPR EXPR into GENERIC.  */
    1176                 :            : 
    1177                 :       1909 : static tree genericize_spaceship (tree expr)
    1178                 :            : {
    1179                 :       1909 :   iloc_sentinel s (cp_expr_location (expr));
    1180                 :       1909 :   tree type = TREE_TYPE (expr);
    1181                 :       1909 :   tree op0 = TREE_OPERAND (expr, 0);
    1182                 :       1909 :   tree op1 = TREE_OPERAND (expr, 1);
    1183                 :       1909 :   return genericize_spaceship (type, op0, op1);
    1184                 :            : }
    1185                 :            : 
    1186                 :            : /* If EXPR involves an anonymous VLA type, prepend a DECL_EXPR for that type
    1187                 :            :    to trigger gimplify_type_sizes; otherwise a cast to pointer-to-VLA confuses
    1188                 :            :    the middle-end (c++/88256).  */
    1189                 :            : 
    1190                 :            : static tree
    1191                 :   18606200 : predeclare_vla (tree expr)
    1192                 :            : {
    1193                 :   18606200 :   tree type = TREE_TYPE (expr);
    1194                 :   18606200 :   if (type == error_mark_node)
    1195                 :            :     return expr;
    1196                 :            : 
    1197                 :            :   /* We need to strip pointers for gimplify_type_sizes.  */
    1198                 :            :   tree vla = type;
    1199                 :   32060600 :   while (POINTER_TYPE_P (vla))
    1200                 :            :     {
    1201                 :   14152500 :       if (TYPE_NAME (vla))
    1202                 :            :         return expr;
    1203                 :   13454400 :       vla = TREE_TYPE (vla);
    1204                 :            :     }
    1205                 :   17908100 :   if (TYPE_NAME (vla) || !variably_modified_type_p (vla, NULL_TREE))
    1206                 :   17908000 :     return expr;
    1207                 :            : 
    1208                 :        155 :   tree decl = build_decl (input_location, TYPE_DECL, NULL_TREE, vla);
    1209                 :        155 :   DECL_ARTIFICIAL (decl) = 1;
    1210                 :        155 :   TYPE_NAME (vla) = decl;
    1211                 :        155 :   tree dexp = build_stmt (input_location, DECL_EXPR, decl);
    1212                 :        155 :   expr = build2 (COMPOUND_EXPR, type, dexp, expr);
    1213                 :        155 :   return expr;
    1214                 :            : }
    1215                 :            : 
    1216                 :            : /* Perform any pre-gimplification lowering of C++ front end trees to
    1217                 :            :    GENERIC.  */
    1218                 :            : 
    1219                 :            : static tree
    1220                 :  279418000 : cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
    1221                 :            : {
    1222                 :  279418000 :   tree stmt = *stmt_p;
    1223                 :  279418000 :   struct cp_genericize_data *wtd = (struct cp_genericize_data *) data;
    1224                 :  279418000 :   hash_set<tree> *p_set = wtd->p_set;
    1225                 :            : 
    1226                 :            :   /* If in an OpenMP context, note var uses.  */
    1227                 :  279418000 :   if (__builtin_expect (wtd->omp_ctx != NULL, 0)
    1228                 :     461581 :       && (VAR_P (stmt)
    1229                 :     384438 :           || TREE_CODE (stmt) == PARM_DECL
    1230                 :     376355 :           || TREE_CODE (stmt) == RESULT_DECL)
    1231                 :  279503000 :       && omp_var_to_track (stmt))
    1232                 :      11000 :     omp_cxx_notice_variable (wtd->omp_ctx, stmt);
    1233                 :            : 
    1234                 :            :   /* Don't dereference parms in a thunk, pass the references through. */
    1235                 :   15085200 :   if ((TREE_CODE (stmt) == CALL_EXPR && CALL_FROM_THUNK_P (stmt))
    1236                 :  294489000 :       || (TREE_CODE (stmt) == AGGR_INIT_EXPR && AGGR_INIT_FROM_THUNK_P (stmt)))
    1237                 :            :     {
    1238                 :      13985 :       *walk_subtrees = 0;
    1239                 :      13985 :       return NULL;
    1240                 :            :     }
    1241                 :            : 
    1242                 :            :   /* Dereference invisible reference parms.  */
    1243                 :  279404000 :   if (wtd->handle_invisiref_parm_p && is_invisiref_parm (stmt))
    1244                 :            :     {
    1245                 :     253333 :       *stmt_p = convert_from_reference (stmt);
    1246                 :     253333 :       p_set->add (*stmt_p);
    1247                 :     253333 :       *walk_subtrees = 0;
    1248                 :     253333 :       return NULL;
    1249                 :            :     }
    1250                 :            : 
    1251                 :            :   /* Map block scope extern declarations to visible declarations with the
    1252                 :            :      same name and type in outer scopes if any.  */
    1253                 :  279151000 :   if (cp_function_chain->extern_decl_map
    1254                 :       7338 :       && VAR_OR_FUNCTION_DECL_P (stmt)
    1255                 :  279152000 :       && DECL_EXTERNAL (stmt))
    1256                 :            :     {
    1257                 :        461 :       struct cxx_int_tree_map *h, in;
    1258                 :        461 :       in.uid = DECL_UID (stmt);
    1259                 :        461 :       h = cp_function_chain->extern_decl_map->find_with_hash (&in, in.uid);
    1260                 :        461 :       if (h)
    1261                 :            :         {
    1262                 :        294 :           *stmt_p = h->to;
    1263                 :        294 :           TREE_USED (h->to) |= TREE_USED (stmt);
    1264                 :        294 :           *walk_subtrees = 0;
    1265                 :        294 :           return NULL;
    1266                 :            :         }
    1267                 :            :     }
    1268                 :            : 
    1269                 :  279150000 :   if (TREE_CODE (stmt) == INTEGER_CST
    1270                 :   31925600 :       && TYPE_REF_P (TREE_TYPE (stmt))
    1271                 :        148 :       && (flag_sanitize & (SANITIZE_NULL | SANITIZE_ALIGNMENT))
    1272                 :  279150000 :       && !wtd->no_sanitize_p)
    1273                 :            :     {
    1274                 :          7 :       ubsan_maybe_instrument_reference (stmt_p);
    1275                 :          7 :       if (*stmt_p != stmt)
    1276                 :            :         {
    1277                 :          7 :           *walk_subtrees = 0;
    1278                 :          7 :           return NULL_TREE;
    1279                 :            :         }
    1280                 :            :     }
    1281                 :            : 
    1282                 :            :   /* Other than invisiref parms, don't walk the same tree twice.  */
    1283                 :  279150000 :   if (p_set->contains (stmt))
    1284                 :            :     {
    1285                 :   41579100 :       *walk_subtrees = 0;
    1286                 :   41579100 :       return NULL_TREE;
    1287                 :            :     }
    1288                 :            : 
    1289                 :  237571000 :   switch (TREE_CODE (stmt))
    1290                 :            :     {
    1291                 :   22183100 :     case ADDR_EXPR:
    1292                 :   22183100 :       if (is_invisiref_parm (TREE_OPERAND (stmt, 0)))
    1293                 :            :         {
    1294                 :            :           /* If in an OpenMP context, note var uses.  */
    1295                 :     141220 :           if (__builtin_expect (wtd->omp_ctx != NULL, 0)
    1296                 :     141220 :               && omp_var_to_track (TREE_OPERAND (stmt, 0)))
    1297                 :        419 :             omp_cxx_notice_variable (wtd->omp_ctx, TREE_OPERAND (stmt, 0));
    1298                 :     141220 :           *stmt_p = fold_convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
    1299                 :     141220 :           *walk_subtrees = 0;
    1300                 :            :         }
    1301                 :            :       break;
    1302                 :            : 
    1303                 :    6337410 :     case RETURN_EXPR:
    1304                 :    6337410 :       if (TREE_OPERAND (stmt, 0) && is_invisiref_parm (TREE_OPERAND (stmt, 0)))
    1305                 :            :         /* Don't dereference an invisiref RESULT_DECL inside a RETURN_EXPR.  */
    1306                 :      23442 :         *walk_subtrees = 0;
    1307                 :            :       break;
    1308                 :            : 
    1309                 :      50072 :     case OMP_CLAUSE:
    1310                 :      50072 :       switch (OMP_CLAUSE_CODE (stmt))
    1311                 :            :         {
    1312                 :       1461 :         case OMP_CLAUSE_LASTPRIVATE:
    1313                 :            :           /* Don't dereference an invisiref in OpenMP clauses.  */
    1314                 :       1461 :           if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
    1315                 :            :             {
    1316                 :         54 :               *walk_subtrees = 0;
    1317                 :         54 :               if (OMP_CLAUSE_LASTPRIVATE_STMT (stmt))
    1318                 :         48 :                 cp_walk_tree (&OMP_CLAUSE_LASTPRIVATE_STMT (stmt),
    1319                 :            :                               cp_genericize_r, data, NULL);
    1320                 :            :             }
    1321                 :            :           break;
    1322                 :       1102 :         case OMP_CLAUSE_PRIVATE:
    1323                 :            :           /* Don't dereference an invisiref in OpenMP clauses.  */
    1324                 :       1102 :           if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
    1325                 :          9 :             *walk_subtrees = 0;
    1326                 :       1093 :           else if (wtd->omp_ctx != NULL)
    1327                 :            :             {
    1328                 :            :               /* Private clause doesn't cause any references to the
    1329                 :            :                  var in outer contexts, avoid calling
    1330                 :            :                  omp_cxx_notice_variable for it.  */
    1331                 :        263 :               struct cp_genericize_omp_taskreg *old = wtd->omp_ctx;
    1332                 :        263 :               wtd->omp_ctx = NULL;
    1333                 :        263 :               cp_walk_tree (&OMP_CLAUSE_DECL (stmt), cp_genericize_r,
    1334                 :            :                             data, NULL);
    1335                 :        263 :               wtd->omp_ctx = old;
    1336                 :        263 :               *walk_subtrees = 0;
    1337                 :            :             }
    1338                 :            :           break;
    1339                 :       3856 :         case OMP_CLAUSE_SHARED:
    1340                 :       3856 :         case OMP_CLAUSE_FIRSTPRIVATE:
    1341                 :       3856 :         case OMP_CLAUSE_COPYIN:
    1342                 :       3856 :         case OMP_CLAUSE_COPYPRIVATE:
    1343                 :       3856 :         case OMP_CLAUSE_INCLUSIVE:
    1344                 :       3856 :         case OMP_CLAUSE_EXCLUSIVE:
    1345                 :            :           /* Don't dereference an invisiref in OpenMP clauses.  */
    1346                 :       3856 :           if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
    1347                 :         97 :             *walk_subtrees = 0;
    1348                 :            :           break;
    1349                 :       5332 :         case OMP_CLAUSE_REDUCTION:
    1350                 :       5332 :         case OMP_CLAUSE_IN_REDUCTION:
    1351                 :       5332 :         case OMP_CLAUSE_TASK_REDUCTION:
    1352                 :            :           /* Don't dereference an invisiref in reduction clause's
    1353                 :            :              OMP_CLAUSE_DECL either.  OMP_CLAUSE_REDUCTION_{INIT,MERGE}
    1354                 :            :              still needs to be genericized.  */
    1355                 :       5332 :           if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
    1356                 :            :             {
    1357                 :         44 :               *walk_subtrees = 0;
    1358                 :         44 :               if (OMP_CLAUSE_REDUCTION_INIT (stmt))
    1359                 :         44 :                 cp_walk_tree (&OMP_CLAUSE_REDUCTION_INIT (stmt),
    1360                 :            :                               cp_genericize_r, data, NULL);
    1361                 :         44 :               if (OMP_CLAUSE_REDUCTION_MERGE (stmt))
    1362                 :         44 :                 cp_walk_tree (&OMP_CLAUSE_REDUCTION_MERGE (stmt),
    1363                 :            :                               cp_genericize_r, data, NULL);
    1364                 :            :             }
    1365                 :            :           break;
    1366                 :            :         default:
    1367                 :            :           break;
    1368                 :            :         }
    1369                 :            :       break;
    1370                 :            : 
    1371                 :            :     /* Due to the way voidify_wrapper_expr is written, we don't get a chance
    1372                 :            :        to lower this construct before scanning it, so we need to lower these
    1373                 :            :        before doing anything else.  */
    1374                 :    1797090 :     case CLEANUP_STMT:
    1375                 :    1797090 :       *stmt_p = build2_loc (EXPR_LOCATION (stmt),
    1376                 :            :                             CLEANUP_EH_ONLY (stmt) ? TRY_CATCH_EXPR
    1377                 :    1797090 :                                                    : TRY_FINALLY_EXPR,
    1378                 :            :                             void_type_node,
    1379                 :    1797090 :                             CLEANUP_BODY (stmt),
    1380                 :    1797090 :                             CLEANUP_EXPR (stmt));
    1381                 :    1797090 :       break;
    1382                 :            : 
    1383                 :    2264430 :     case IF_STMT:
    1384                 :    2264430 :       genericize_if_stmt (stmt_p);
    1385                 :            :       /* *stmt_p has changed, tail recurse to handle it again.  */
    1386                 :    2264430 :       return cp_genericize_r (stmt_p, walk_subtrees, data);
    1387                 :            : 
    1388                 :            :     /* COND_EXPR might have incompatible types in branches if one or both
    1389                 :            :        arms are bitfields.  Fix it up now.  */
    1390                 :    2507540 :     case COND_EXPR:
    1391                 :    2507540 :       {
    1392                 :    2507540 :         tree type_left
    1393                 :    2507540 :           = (TREE_OPERAND (stmt, 1)
    1394                 :    2507540 :              ? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 1))
    1395                 :    2507540 :              : NULL_TREE);
    1396                 :    2507540 :         tree type_right
    1397                 :    2507540 :           = (TREE_OPERAND (stmt, 2)
    1398                 :    2507540 :              ? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 2))
    1399                 :    2507540 :              : NULL_TREE);
    1400                 :    2507540 :         if (type_left
    1401                 :    2507570 :             && !useless_type_conversion_p (TREE_TYPE (stmt),
    1402                 :         33 :                                            TREE_TYPE (TREE_OPERAND (stmt, 1))))
    1403                 :            :           {
    1404                 :         58 :             TREE_OPERAND (stmt, 1)
    1405                 :         29 :               = fold_convert (type_left, TREE_OPERAND (stmt, 1));
    1406                 :         29 :             gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
    1407                 :            :                                                    type_left));
    1408                 :            :           }
    1409                 :    2507540 :         if (type_right
    1410                 :    2507550 :             && !useless_type_conversion_p (TREE_TYPE (stmt),
    1411                 :         18 :                                            TREE_TYPE (TREE_OPERAND (stmt, 2))))
    1412                 :            :           {
    1413                 :         36 :             TREE_OPERAND (stmt, 2)
    1414                 :         18 :               = fold_convert (type_right, TREE_OPERAND (stmt, 2));
    1415                 :         18 :             gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
    1416                 :            :                                                    type_right));
    1417                 :            :           }
    1418                 :            :       }
    1419                 :            :       break;
    1420                 :            : 
    1421                 :    4047970 :     case BIND_EXPR:
    1422                 :    4047970 :       if (__builtin_expect (wtd->omp_ctx != NULL, 0))
    1423                 :            :         {
    1424                 :      18962 :           tree decl;
    1425                 :      23554 :           for (decl = BIND_EXPR_VARS (stmt); decl; decl = DECL_CHAIN (decl))
    1426                 :       4592 :             if (VAR_P (decl)
    1427                 :       4547 :                 && !DECL_EXTERNAL (decl)
    1428                 :       9139 :                 && omp_var_to_track (decl))
    1429                 :            :               {
    1430                 :        445 :                 splay_tree_node n
    1431                 :        445 :                   = splay_tree_lookup (wtd->omp_ctx->variables,
    1432                 :            :                                        (splay_tree_key) decl);
    1433                 :        445 :                 if (n == NULL)
    1434                 :        445 :                   splay_tree_insert (wtd->omp_ctx->variables,
    1435                 :            :                                      (splay_tree_key) decl,
    1436                 :            :                                      TREE_STATIC (decl)
    1437                 :            :                                      ? OMP_CLAUSE_DEFAULT_SHARED
    1438                 :        445 :                                      : OMP_CLAUSE_DEFAULT_PRIVATE);
    1439                 :            :               }
    1440                 :            :         }
    1441                 :    4047970 :       if (sanitize_flags_p (SANITIZE_NULL | SANITIZE_ALIGNMENT | SANITIZE_VPTR))
    1442                 :            :         {
    1443                 :            :           /* The point here is to not sanitize static initializers.  */
    1444                 :       2825 :           bool no_sanitize_p = wtd->no_sanitize_p;
    1445                 :       2825 :           wtd->no_sanitize_p = true;
    1446                 :       5204 :           for (tree decl = BIND_EXPR_VARS (stmt);
    1447                 :       5204 :                decl;
    1448                 :       2379 :                decl = DECL_CHAIN (decl))
    1449                 :       2379 :             if (VAR_P (decl)
    1450                 :       2379 :                 && TREE_STATIC (decl)
    1451                 :       2511 :                 && DECL_INITIAL (decl))
    1452                 :         69 :               cp_walk_tree (&DECL_INITIAL (decl), cp_genericize_r, data, NULL);
    1453                 :       2825 :           wtd->no_sanitize_p = no_sanitize_p;
    1454                 :            :         }
    1455                 :    4047970 :       wtd->bind_expr_stack.safe_push (stmt);
    1456                 :    4047970 :       cp_walk_tree (&BIND_EXPR_BODY (stmt),
    1457                 :            :                     cp_genericize_r, data, NULL);
    1458                 :    4047970 :       wtd->bind_expr_stack.pop ();
    1459                 :            :       break;
    1460                 :            : 
    1461                 :      52326 :     case USING_STMT:
    1462                 :      52326 :       {
    1463                 :      52326 :         tree block = NULL_TREE;
    1464                 :            : 
    1465                 :            :         /* Get the innermost inclosing GIMPLE_BIND that has a non NULL
    1466                 :            :            BLOCK, and append an IMPORTED_DECL to its
    1467                 :            :            BLOCK_VARS chained list.  */
    1468                 :      52326 :         if (wtd->bind_expr_stack.exists ())
    1469                 :            :           {
    1470                 :      52326 :             int i;
    1471                 :      52326 :             for (i = wtd->bind_expr_stack.length () - 1; i >= 0; i--)
    1472                 :      52326 :               if ((block = BIND_EXPR_BLOCK (wtd->bind_expr_stack[i])))
    1473                 :            :                 break;
    1474                 :            :           }
    1475                 :      52326 :         if (block)
    1476                 :            :           {
    1477                 :      52326 :             tree decl = TREE_OPERAND (stmt, 0);
    1478                 :      52326 :             gcc_assert (decl);
    1479                 :            : 
    1480                 :      52326 :             if (undeduced_auto_decl (decl))
    1481                 :            :               /* Omit from the GENERIC, the back-end can't handle it.  */;
    1482                 :            :             else
    1483                 :            :               {
    1484                 :      52323 :                 tree using_directive = make_node (IMPORTED_DECL);
    1485                 :      52323 :                 TREE_TYPE (using_directive) = void_type_node;
    1486                 :            : 
    1487                 :      52323 :                 IMPORTED_DECL_ASSOCIATED_DECL (using_directive) = decl;
    1488                 :      52323 :                 DECL_CHAIN (using_directive) = BLOCK_VARS (block);
    1489                 :      52323 :                 BLOCK_VARS (block) = using_directive;
    1490                 :            :               }
    1491                 :            :           }
    1492                 :            :         /* The USING_STMT won't appear in GENERIC.  */
    1493                 :      52326 :         *stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
    1494                 :      52326 :         *walk_subtrees = 0;
    1495                 :            :       }
    1496                 :      52326 :       break;
    1497                 :            : 
    1498                 :    2579690 :     case DECL_EXPR:
    1499                 :    2579690 :       if (TREE_CODE (DECL_EXPR_DECL (stmt)) == USING_DECL)
    1500                 :            :         {
    1501                 :            :           /* Using decls inside DECL_EXPRs are just dropped on the floor.  */
    1502                 :      14919 :           *stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
    1503                 :      14919 :           *walk_subtrees = 0;
    1504                 :            :         }
    1505                 :            :       else
    1506                 :            :         {
    1507                 :    2564770 :           tree d = DECL_EXPR_DECL (stmt);
    1508                 :    2564770 :           if (VAR_P (d))
    1509                 :    5128510 :             gcc_assert (CP_DECL_THREAD_LOCAL_P (d) == DECL_THREAD_LOCAL_P (d));
    1510                 :            :         }
    1511                 :            :       break;
    1512                 :            : 
    1513                 :       9156 :     case OMP_PARALLEL:
    1514                 :       9156 :     case OMP_TASK:
    1515                 :       9156 :     case OMP_TASKLOOP:
    1516                 :       9156 :       {
    1517                 :       9156 :         struct cp_genericize_omp_taskreg omp_ctx;
    1518                 :       9156 :         tree c, decl;
    1519                 :       9156 :         splay_tree_node n;
    1520                 :            : 
    1521                 :       9156 :         *walk_subtrees = 0;
    1522                 :      18312 :         cp_walk_tree (&OMP_CLAUSES (stmt), cp_genericize_r, data, NULL);
    1523                 :       9156 :         omp_ctx.is_parallel = TREE_CODE (stmt) == OMP_PARALLEL;
    1524                 :       9156 :         omp_ctx.default_shared = omp_ctx.is_parallel;
    1525                 :       9156 :         omp_ctx.outer = wtd->omp_ctx;
    1526                 :       9156 :         omp_ctx.variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
    1527                 :       9156 :         wtd->omp_ctx = &omp_ctx;
    1528                 :      26110 :         for (c = OMP_CLAUSES (stmt); c; c = OMP_CLAUSE_CHAIN (c))
    1529                 :       7798 :           switch (OMP_CLAUSE_CODE (c))
    1530                 :            :             {
    1531                 :       2774 :             case OMP_CLAUSE_SHARED:
    1532                 :       2774 :             case OMP_CLAUSE_PRIVATE:
    1533                 :       2774 :             case OMP_CLAUSE_FIRSTPRIVATE:
    1534                 :       2774 :             case OMP_CLAUSE_LASTPRIVATE:
    1535                 :       2774 :               decl = OMP_CLAUSE_DECL (c);
    1536                 :       2774 :               if (decl == error_mark_node || !omp_var_to_track (decl))
    1537                 :            :                 break;
    1538                 :        581 :               n = splay_tree_lookup (omp_ctx.variables, (splay_tree_key) decl);
    1539                 :        581 :               if (n != NULL)
    1540                 :            :                 break;
    1541                 :       1140 :               splay_tree_insert (omp_ctx.variables, (splay_tree_key) decl,
    1542                 :        570 :                                  OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED
    1543                 :            :                                  ? OMP_CLAUSE_DEFAULT_SHARED
    1544                 :            :                                  : OMP_CLAUSE_DEFAULT_PRIVATE);
    1545                 :        570 :               if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_PRIVATE && omp_ctx.outer)
    1546                 :         80 :                 omp_cxx_notice_variable (omp_ctx.outer, decl);
    1547                 :            :               break;
    1548                 :        529 :             case OMP_CLAUSE_DEFAULT:
    1549                 :        529 :               if (OMP_CLAUSE_DEFAULT_KIND (c) == OMP_CLAUSE_DEFAULT_SHARED)
    1550                 :        222 :                 omp_ctx.default_shared = true;
    1551                 :            :             default:
    1552                 :            :               break;
    1553                 :            :             }
    1554                 :       9156 :         if (TREE_CODE (stmt) == OMP_TASKLOOP)
    1555                 :        591 :           genericize_omp_for_stmt (stmt_p, walk_subtrees, data);
    1556                 :            :         else
    1557                 :      17130 :           cp_walk_tree (&OMP_BODY (stmt), cp_genericize_r, data, NULL);
    1558                 :       9156 :         wtd->omp_ctx = omp_ctx.outer;
    1559                 :       9156 :         splay_tree_delete (omp_ctx.variables);
    1560                 :            :       }
    1561                 :       9156 :       break;
    1562                 :            : 
    1563                 :      81008 :     case TRY_BLOCK:
    1564                 :      81008 :       {
    1565                 :      81008 :         *walk_subtrees = 0;
    1566                 :      81008 :         tree try_block = wtd->try_block;
    1567                 :      81008 :         wtd->try_block = stmt;
    1568                 :      81008 :         cp_walk_tree (&TRY_STMTS (stmt), cp_genericize_r, data, NULL);
    1569                 :      81008 :         wtd->try_block = try_block;
    1570                 :      81008 :         cp_walk_tree (&TRY_HANDLERS (stmt), cp_genericize_r, data, NULL);
    1571                 :            :       }
    1572                 :      81008 :       break;
    1573                 :            : 
    1574                 :    3720570 :     case MUST_NOT_THROW_EXPR:
    1575                 :            :       /* MUST_NOT_THROW_COND might be something else with TM.  */
    1576                 :    3720570 :       if (MUST_NOT_THROW_COND (stmt) == NULL_TREE)
    1577                 :            :         {
    1578                 :    3720550 :           *walk_subtrees = 0;
    1579                 :    3720550 :           tree try_block = wtd->try_block;
    1580                 :    3720550 :           wtd->try_block = stmt;
    1581                 :    3720550 :           cp_walk_tree (&TREE_OPERAND (stmt, 0), cp_genericize_r, data, NULL);
    1582                 :    3720550 :           wtd->try_block = try_block;
    1583                 :            :         }
    1584                 :            :       break;
    1585                 :            : 
    1586                 :      75831 :     case THROW_EXPR:
    1587                 :      75831 :       {
    1588                 :      75831 :         location_t loc = location_of (stmt);
    1589                 :      75831 :         if (TREE_NO_WARNING (stmt))
    1590                 :            :           /* Never mind.  */;
    1591                 :      70029 :         else if (wtd->try_block)
    1592                 :            :           {
    1593                 :       1250 :             if (TREE_CODE (wtd->try_block) == MUST_NOT_THROW_EXPR)
    1594                 :            :               {
    1595                 :         42 :                 auto_diagnostic_group d;
    1596                 :         21 :                 if (warning_at (loc, OPT_Wterminate,
    1597                 :            :                                 "%<throw%> will always call %<terminate%>")
    1598                 :         12 :                     && cxx_dialect >= cxx11
    1599                 :         43 :                     && DECL_DESTRUCTOR_P (current_function_decl))
    1600                 :          6 :                   inform (loc, "in C++11 destructors default to %<noexcept%>");
    1601                 :            :               }
    1602                 :            :           }
    1603                 :            :         else
    1604                 :            :           {
    1605                 :        112 :             if (warn_cxx11_compat && cxx_dialect < cxx11
    1606                 :        224 :                 && DECL_DESTRUCTOR_P (current_function_decl)
    1607                 :          2 :                 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl))
    1608                 :            :                     == NULL_TREE)
    1609                 :      68780 :                 && (get_defaulted_eh_spec (current_function_decl)
    1610                 :          1 :                     == empty_except_spec))
    1611                 :          1 :               warning_at (loc, OPT_Wc__11_compat,
    1612                 :            :                           "in C++11 this %<throw%> will call %<terminate%> "
    1613                 :            :                           "because destructors default to %<noexcept%>");
    1614                 :            :           }
    1615                 :            :       }
    1616                 :            :       break;
    1617                 :            : 
    1618                 :    5964440 :     case CONVERT_EXPR:
    1619                 :    5964440 :       gcc_assert (!CONVERT_EXPR_VBASE_PATH (stmt));
    1620                 :            :       break;
    1621                 :            : 
    1622                 :     126390 :     case FOR_STMT:
    1623                 :     126390 :       genericize_for_stmt (stmt_p, walk_subtrees, data);
    1624                 :     126390 :       break;
    1625                 :            : 
    1626                 :      67272 :     case WHILE_STMT:
    1627                 :      67272 :       genericize_while_stmt (stmt_p, walk_subtrees, data);
    1628                 :      67272 :       break;
    1629                 :            : 
    1630                 :     105872 :     case DO_STMT:
    1631                 :     105872 :       genericize_do_stmt (stmt_p, walk_subtrees, data);
    1632                 :     105872 :       break;
    1633                 :            : 
    1634                 :      43320 :     case SWITCH_STMT:
    1635                 :      43320 :       genericize_switch_stmt (stmt_p, walk_subtrees, data);
    1636                 :      43320 :       break;
    1637                 :            : 
    1638                 :       1518 :     case CONTINUE_STMT:
    1639                 :       1518 :       genericize_continue_stmt (stmt_p);
    1640                 :       1518 :       break;
    1641                 :            : 
    1642                 :     151417 :     case BREAK_STMT:
    1643                 :     151417 :       genericize_break_stmt (stmt_p);
    1644                 :     151417 :       break;
    1645                 :            : 
    1646                 :       1909 :     case SPACESHIP_EXPR:
    1647                 :       1909 :       *stmt_p = genericize_spaceship (*stmt_p);
    1648                 :       1909 :       break;
    1649                 :            : 
    1650                 :      19565 :     case OMP_FOR:
    1651                 :      19565 :     case OMP_SIMD:
    1652                 :      19565 :     case OMP_DISTRIBUTE:
    1653                 :      19565 :     case OMP_LOOP:
    1654                 :      19565 :     case OACC_LOOP:
    1655                 :      19565 :       genericize_omp_for_stmt (stmt_p, walk_subtrees, data);
    1656                 :      19565 :       break;
    1657                 :            : 
    1658                 :       3567 :     case PTRMEM_CST:
    1659                 :            :       /* By the time we get here we're handing off to the back end, so we don't
    1660                 :            :          need or want to preserve PTRMEM_CST anymore.  */
    1661                 :       3567 :       *stmt_p = cplus_expand_constant (stmt);
    1662                 :       3567 :       *walk_subtrees = 0;
    1663                 :       3567 :       break;
    1664                 :            : 
    1665                 :       4501 :     case MEM_REF:
    1666                 :            :       /* For MEM_REF, make sure not to sanitize the second operand even
    1667                 :            :          if it has reference type.  It is just an offset with a type
    1668                 :            :          holding other information.  There is no other processing we
    1669                 :            :          need to do for INTEGER_CSTs, so just ignore the second argument
    1670                 :            :          unconditionally.  */
    1671                 :       4501 :       cp_walk_tree (&TREE_OPERAND (stmt, 0), cp_genericize_r, data, NULL);
    1672                 :       4501 :       *walk_subtrees = 0;
    1673                 :       4501 :       break;
    1674                 :            : 
    1675                 :   18606200 :     case NOP_EXPR:
    1676                 :   18606200 :       *stmt_p = predeclare_vla (*stmt_p);
    1677                 :   18606200 :       if (!wtd->no_sanitize_p
    1678                 :   18606200 :           && sanitize_flags_p (SANITIZE_NULL | SANITIZE_ALIGNMENT)
    1679                 :   18617500 :           && TYPE_REF_P (TREE_TYPE (stmt)))
    1680                 :       1204 :         ubsan_maybe_instrument_reference (stmt_p);
    1681                 :            :       break;
    1682                 :            : 
    1683                 :   15042500 :     case CALL_EXPR:
    1684                 :            :       /* Evaluate function concept checks instead of treating them as
    1685                 :            :          normal functions.  */
    1686                 :   15042500 :       if (concept_check_p (stmt))
    1687                 :            :         {
    1688                 :          0 :           *stmt_p = evaluate_concept_check (stmt, tf_warning_or_error);
    1689                 :          0 :           * walk_subtrees = 0;
    1690                 :          0 :           break;
    1691                 :            :         }
    1692                 :            : 
    1693                 :   15042500 :       if (!wtd->no_sanitize_p
    1694                 :   15042500 :           && sanitize_flags_p ((SANITIZE_NULL
    1695                 :            :                                 | SANITIZE_ALIGNMENT | SANITIZE_VPTR)))
    1696                 :            :         {
    1697                 :      14459 :           tree fn = CALL_EXPR_FN (stmt);
    1698                 :      14459 :           if (fn != NULL_TREE
    1699                 :      18962 :               && !error_operand_p (fn)
    1700                 :       9481 :               && INDIRECT_TYPE_P (TREE_TYPE (fn))
    1701                 :      23940 :               && TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) == METHOD_TYPE)
    1702                 :            :             {
    1703                 :       4871 :               bool is_ctor
    1704                 :            :                 = TREE_CODE (fn) == ADDR_EXPR
    1705                 :       4721 :                   && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
    1706                 :      14313 :                   && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0));
    1707                 :       4871 :               if (sanitize_flags_p (SANITIZE_NULL | SANITIZE_ALIGNMENT))
    1708                 :       3438 :                 ubsan_maybe_instrument_member_call (stmt, is_ctor);
    1709                 :       4871 :               if (sanitize_flags_p (SANITIZE_VPTR) && !is_ctor)
    1710                 :       3201 :                 cp_ubsan_maybe_instrument_member_call (stmt);
    1711                 :            :             }
    1712                 :       9588 :           else if (fn == NULL_TREE
    1713                 :       4978 :                    && CALL_EXPR_IFN (stmt) == IFN_UBSAN_NULL
    1714                 :       3555 :                    && TREE_CODE (CALL_EXPR_ARG (stmt, 0)) == INTEGER_CST
    1715                 :       9602 :                    && TYPE_REF_P (TREE_TYPE (CALL_EXPR_ARG (stmt, 0))))
    1716                 :         14 :             *walk_subtrees = 0;
    1717                 :            :         }
    1718                 :            :       /* Fall through.  */
    1719                 :   15746500 :     case AGGR_INIT_EXPR:
    1720                 :            :       /* For calls to a multi-versioned function, overload resolution
    1721                 :            :          returns the function with the highest target priority, that is,
    1722                 :            :          the version that will checked for dispatching first.  If this
    1723                 :            :          version is inlinable, a direct call to this version can be made
    1724                 :            :          otherwise the call should go through the dispatcher.  */
    1725                 :   15746500 :       {
    1726                 :   15746500 :         tree fn = cp_get_callee_fndecl_nofold (stmt);
    1727                 :   15427200 :         if (fn && DECL_FUNCTION_VERSIONED (fn)
    1728                 :   15746700 :             && (current_function_decl == NULL
    1729                 :        136 :                 || !targetm.target_option.can_inline_p (current_function_decl,
    1730                 :            :                                                         fn)))
    1731                 :        120 :           if (tree dis = get_function_version_dispatcher (fn))
    1732                 :            :             {
    1733                 :        120 :               mark_versions_used (dis);
    1734                 :        120 :               dis = build_address (dis);
    1735                 :        120 :               if (TREE_CODE (stmt) == CALL_EXPR)
    1736                 :        116 :                 CALL_EXPR_FN (stmt) = dis;
    1737                 :            :               else
    1738                 :          4 :                 AGGR_INIT_EXPR_FN (stmt) = dis;
    1739                 :            :             }
    1740                 :            :       }
    1741                 :            :       break;
    1742                 :            : 
    1743                 :    1800240 :     case TARGET_EXPR:
    1744                 :    1800240 :       if (TARGET_EXPR_INITIAL (stmt)
    1745                 :    1800240 :           && TREE_CODE (TARGET_EXPR_INITIAL (stmt)) == CONSTRUCTOR
    1746                 :    2283880 :           && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (TARGET_EXPR_INITIAL (stmt)))
    1747                 :         30 :         TARGET_EXPR_NO_ELIDE (stmt) = 1;
    1748                 :            :       break;
    1749                 :            : 
    1750                 :         32 :     case TEMPLATE_ID_EXPR:
    1751                 :         32 :       gcc_assert (concept_check_p (stmt));
    1752                 :            :       /* Emit the value of the concept check.  */
    1753                 :         32 :       *stmt_p = evaluate_concept_check (stmt, tf_warning_or_error);
    1754                 :         32 :       walk_subtrees = 0;
    1755                 :         32 :       break;
    1756                 :            : 
    1757                 :    9099840 :     case STATEMENT_LIST:
    1758                 :    9099840 :       if (TREE_SIDE_EFFECTS (stmt))
    1759                 :            :         {
    1760                 :    8196660 :           tree_stmt_iterator i;
    1761                 :    8196660 :           int nondebug_stmts = 0;
    1762                 :    8196660 :           bool clear_side_effects = true;
    1763                 :            :           /* Genericization can clear TREE_SIDE_EFFECTS, e.g. when
    1764                 :            :              transforming an IF_STMT into COND_EXPR.  If such stmt
    1765                 :            :              appears in a STATEMENT_LIST that contains only that
    1766                 :            :              stmt and some DEBUG_BEGIN_STMTs, without -g where the
    1767                 :            :              STATEMENT_LIST wouldn't be present at all the resulting
    1768                 :            :              expression wouldn't have TREE_SIDE_EFFECTS set, so make sure
    1769                 :            :              to clear it even on the STATEMENT_LIST in such cases.  */
    1770                 :   30720200 :           for (i = tsi_start (stmt); !tsi_end_p (i); tsi_next (&i))
    1771                 :            :             {
    1772                 :   22523500 :               tree t = tsi_stmt (i);
    1773                 :   22523500 :               if (TREE_CODE (t) != DEBUG_BEGIN_STMT && nondebug_stmts < 2)
    1774                 :   13725500 :                 nondebug_stmts++;
    1775                 :   22523500 :               cp_walk_tree (tsi_stmt_ptr (i), cp_genericize_r, data, NULL);
    1776                 :   22523500 :               if (TREE_CODE (t) != DEBUG_BEGIN_STMT
    1777                 :   22523500 :                   && (nondebug_stmts > 1 || TREE_SIDE_EFFECTS (tsi_stmt (i))))
    1778                 :            :                 clear_side_effects = false;
    1779                 :            :             }
    1780                 :    8196660 :           if (clear_side_effects)
    1781                 :      13090 :             TREE_SIDE_EFFECTS (stmt) = 0;
    1782                 :    8196660 :           *walk_subtrees = 0;
    1783                 :            :         }
    1784                 :            :       break;
    1785                 :            : 
    1786                 :  140122000 :     default:
    1787                 :  140122000 :       if (IS_TYPE_OR_DECL_P (stmt))
    1788                 :   45378400 :         *walk_subtrees = 0;
    1789                 :            :       break;
    1790                 :            :     }
    1791                 :            : 
    1792                 :  235307000 :   p_set->add (*stmt_p);
    1793                 :            : 
    1794                 :  235307000 :   return NULL;
    1795                 :            : }
    1796                 :            : 
    1797                 :            : /* Lower C++ front end trees to GENERIC in T_P.  */
    1798                 :            : 
    1799                 :            : static void
    1800                 :    9697580 : cp_genericize_tree (tree* t_p, bool handle_invisiref_parm_p)
    1801                 :            : {
    1802                 :    9697580 :   struct cp_genericize_data wtd;
    1803                 :            : 
    1804                 :    9697580 :   wtd.p_set = new hash_set<tree>;
    1805                 :    9697580 :   wtd.bind_expr_stack.create (0);
    1806                 :    9697580 :   wtd.omp_ctx = NULL;
    1807                 :    9697580 :   wtd.try_block = NULL_TREE;
    1808                 :    9697580 :   wtd.no_sanitize_p = false;
    1809                 :    9697580 :   wtd.handle_invisiref_parm_p = handle_invisiref_parm_p;
    1810                 :    9697580 :   cp_walk_tree (t_p, cp_genericize_r, &wtd, NULL);
    1811                 :   19395200 :   delete wtd.p_set;
    1812                 :    9697580 :   wtd.bind_expr_stack.release ();
    1813                 :    9697580 :   if (sanitize_flags_p (SANITIZE_VPTR))
    1814                 :       5644 :     cp_ubsan_instrument_member_accesses (t_p);
    1815                 :    9697580 : }
    1816                 :            : 
    1817                 :            : /* If a function that should end with a return in non-void
    1818                 :            :    function doesn't obviously end with return, add ubsan
    1819                 :            :    instrumentation code to verify it at runtime.  If -fsanitize=return
    1820                 :            :    is not enabled, instrument __builtin_unreachable.  */
    1821                 :            : 
    1822                 :            : static void
    1823                 :    9697110 : cp_maybe_instrument_return (tree fndecl)
    1824                 :            : {
    1825                 :    9697110 :   if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl)))
    1826                 :   11836700 :       || DECL_CONSTRUCTOR_P (fndecl)
    1827                 :    5918340 :       || DECL_DESTRUCTOR_P (fndecl)
    1828                 :   15615500 :       || !targetm.warn_func_return (fndecl))
    1829                 :    3778780 :     return;
    1830                 :            : 
    1831                 :    5918330 :   if (!sanitize_flags_p (SANITIZE_RETURN, fndecl)
    1832                 :            :       /* Don't add __builtin_unreachable () if not optimizing, it will not
    1833                 :            :          improve any optimizations in that case, just break UB code.
    1834                 :            :          Don't add it if -fsanitize=unreachable -fno-sanitize=return either,
    1835                 :            :          UBSan covers this with ubsan_instrument_return above where sufficient
    1836                 :            :          information is provided, while the __builtin_unreachable () below
    1837                 :            :          if return sanitization is disabled will just result in hard to
    1838                 :            :          understand runtime error without location.  */
    1839                 :    5918330 :       && (!optimize
    1840                 :    5399900 :           || sanitize_flags_p (SANITIZE_UNREACHABLE, fndecl)))
    1841                 :     515187 :     return;
    1842                 :            : 
    1843                 :    5403140 :   tree t = DECL_SAVED_TREE (fndecl);
    1844                 :    9227380 :   while (t)
    1845                 :            :     {
    1846                 :    9227380 :       switch (TREE_CODE (t))
    1847                 :            :         {
    1848                 :     522799 :         case BIND_EXPR:
    1849                 :     522799 :           t = BIND_EXPR_BODY (t);
    1850                 :     522799 :           continue;
    1851                 :    1617440 :         case TRY_FINALLY_EXPR:
    1852                 :    1617440 :         case CLEANUP_POINT_EXPR:
    1853                 :    1617440 :           t = TREE_OPERAND (t, 0);
    1854                 :    1617440 :           continue;
    1855                 :    1685240 :         case STATEMENT_LIST:
    1856                 :    1685240 :           {
    1857                 :    1685240 :             tree_stmt_iterator i = tsi_last (t);
    1858                 :    1685500 :             while (!tsi_end_p (i))
    1859                 :            :               {
    1860                 :    1684270 :                 tree p = tsi_stmt (i);
    1861                 :    1684270 :                 if (TREE_CODE (p) != DEBUG_BEGIN_STMT)
    1862                 :            :                   break;
    1863                 :        265 :                 tsi_prev (&i);
    1864                 :            :               }
    1865                 :    1685240 :             if (!tsi_end_p (i))
    1866                 :            :               {
    1867                 :    1684000 :                 t = tsi_stmt (i);
    1868                 :    1684000 :                 continue;
    1869                 :            :               }
    1870                 :            :           }
    1871                 :       1232 :           break;
    1872                 :            :         case RETURN_EXPR:
    1873                 :            :           return;
    1874                 :            :         default:
    1875                 :    2140240 :           break;
    1876                 :            :         }
    1877                 :            :       break;
    1878                 :            :     }
    1879                 :    2162920 :   if (t == NULL_TREE)
    1880                 :            :     return;
    1881                 :    2162920 :   tree *p = &DECL_SAVED_TREE (fndecl);
    1882                 :    2162920 :   if (TREE_CODE (*p) == BIND_EXPR)
    1883                 :      68310 :     p = &BIND_EXPR_BODY (*p);
    1884                 :            : 
    1885                 :    2162920 :   location_t loc = DECL_SOURCE_LOCATION (fndecl);
    1886                 :    2162920 :   if (sanitize_flags_p (SANITIZE_RETURN, fndecl))
    1887                 :        867 :     t = ubsan_instrument_return (loc);
    1888                 :            :   else
    1889                 :            :     {
    1890                 :    2162060 :       tree fndecl = builtin_decl_explicit (BUILT_IN_UNREACHABLE);
    1891                 :    2162060 :       t = build_call_expr_loc (BUILTINS_LOCATION, fndecl, 0);
    1892                 :            :     }
    1893                 :            : 
    1894                 :    2162920 :   append_to_statement_list (t, p);
    1895                 :            : }
    1896                 :            : 
    1897                 :            : void
    1898                 :   14116800 : cp_genericize (tree fndecl)
    1899                 :            : {
    1900                 :   14116800 :   tree t;
    1901                 :            : 
    1902                 :            :   /* Fix up the types of parms passed by invisible reference.  */
    1903                 :   38350500 :   for (t = DECL_ARGUMENTS (fndecl); t; t = DECL_CHAIN (t))
    1904                 :   24233800 :     if (TREE_ADDRESSABLE (TREE_TYPE (t)))
    1905                 :            :       {
    1906                 :            :         /* If a function's arguments are copied to create a thunk,
    1907                 :            :            then DECL_BY_REFERENCE will be set -- but the type of the
    1908                 :            :            argument will be a pointer type, so we will never get
    1909                 :            :            here.  */
    1910                 :      96122 :         gcc_assert (!DECL_BY_REFERENCE (t));
    1911                 :      48061 :         gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t));
    1912                 :      48061 :         TREE_TYPE (t) = DECL_ARG_TYPE (t);
    1913                 :      48061 :         DECL_BY_REFERENCE (t) = 1;
    1914                 :      48061 :         TREE_ADDRESSABLE (t) = 0;
    1915                 :      48061 :         relayout_decl (t);
    1916                 :            :       }
    1917                 :            : 
    1918                 :            :   /* Do the same for the return value.  */
    1919                 :   14116800 :   if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (fndecl))))
    1920                 :            :     {
    1921                 :     251058 :       t = DECL_RESULT (fndecl);
    1922                 :     251058 :       TREE_TYPE (t) = build_reference_type (TREE_TYPE (t));
    1923                 :     251058 :       DECL_BY_REFERENCE (t) = 1;
    1924                 :     251058 :       TREE_ADDRESSABLE (t) = 0;
    1925                 :     251058 :       relayout_decl (t);
    1926                 :     251058 :       if (DECL_NAME (t))
    1927                 :            :         {
    1928                 :            :           /* Adjust DECL_VALUE_EXPR of the original var.  */
    1929                 :      22563 :           tree outer = outer_curly_brace_block (current_function_decl);
    1930                 :      22563 :           tree var;
    1931                 :            : 
    1932                 :      22563 :           if (outer)
    1933                 :      40971 :             for (var = BLOCK_VARS (outer); var; var = DECL_CHAIN (var))
    1934                 :      40971 :               if (VAR_P (var)
    1935                 :      40612 :                   && DECL_NAME (t) == DECL_NAME (var)
    1936                 :      22563 :                   && DECL_HAS_VALUE_EXPR_P (var)
    1937                 :      63534 :                   && DECL_VALUE_EXPR (var) == t)
    1938                 :            :                 {
    1939                 :      22563 :                   tree val = convert_from_reference (t);
    1940                 :      22563 :                   SET_DECL_VALUE_EXPR (var, val);
    1941                 :      22563 :                   break;
    1942                 :            :                 }
    1943                 :            :         }
    1944                 :            :     }
    1945                 :            : 
    1946                 :            :   /* If we're a clone, the body is already GIMPLE.  */
    1947                 :   14116800 :   if (DECL_CLONED_FUNCTION_P (fndecl))
    1948                 :    4419640 :     return;
    1949                 :            : 
    1950                 :            :   /* Allow cp_genericize calls to be nested.  */
    1951                 :    9697110 :   tree save_bc_label[2];
    1952                 :    9697110 :   save_bc_label[bc_break] = bc_label[bc_break];
    1953                 :    9697110 :   save_bc_label[bc_continue] = bc_label[bc_continue];
    1954                 :    9697110 :   bc_label[bc_break] = NULL_TREE;
    1955                 :    9697110 :   bc_label[bc_continue] = NULL_TREE;
    1956                 :            : 
    1957                 :            :   /* We do want to see every occurrence of the parms, so we can't just use
    1958                 :            :      walk_tree's hash functionality.  */
    1959                 :    9697110 :   cp_genericize_tree (&DECL_SAVED_TREE (fndecl), true);
    1960                 :            : 
    1961                 :    9697110 :   cp_maybe_instrument_return (fndecl);
    1962                 :            : 
    1963                 :            :   /* Do everything else.  */
    1964                 :    9697110 :   c_genericize (fndecl);
    1965                 :            : 
    1966                 :    9697110 :   gcc_assert (bc_label[bc_break] == NULL);
    1967                 :    9697110 :   gcc_assert (bc_label[bc_continue] == NULL);
    1968                 :    9697110 :   bc_label[bc_break] = save_bc_label[bc_break];
    1969                 :    9697110 :   bc_label[bc_continue] = save_bc_label[bc_continue];
    1970                 :            : }
    1971                 :            : 
    1972                 :            : /* Build code to apply FN to each member of ARG1 and ARG2.  FN may be
    1973                 :            :    NULL if there is in fact nothing to do.  ARG2 may be null if FN
    1974                 :            :    actually only takes one argument.  */
    1975                 :            : 
    1976                 :            : static tree
    1977                 :       3725 : cxx_omp_clause_apply_fn (tree fn, tree arg1, tree arg2)
    1978                 :            : {
    1979                 :       3725 :   tree defparm, parm, t;
    1980                 :       3725 :   int i = 0;
    1981                 :       3725 :   int nargs;
    1982                 :       3725 :   tree *argarray;
    1983                 :            : 
    1984                 :       3725 :   if (fn == NULL)
    1985                 :            :     return NULL;
    1986                 :            : 
    1987                 :       2994 :   nargs = list_length (DECL_ARGUMENTS (fn));
    1988                 :       2994 :   argarray = XALLOCAVEC (tree, nargs);
    1989                 :            : 
    1990                 :       5988 :   defparm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
    1991                 :       2994 :   if (arg2)
    1992                 :       1009 :     defparm = TREE_CHAIN (defparm);
    1993                 :            : 
    1994                 :       2994 :   bool is_method = TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE;
    1995                 :       2994 :   if (TREE_CODE (TREE_TYPE (arg1)) == ARRAY_TYPE)
    1996                 :            :     {
    1997                 :         27 :       tree inner_type = TREE_TYPE (arg1);
    1998                 :         27 :       tree start1, end1, p1;
    1999                 :         27 :       tree start2 = NULL, p2 = NULL;
    2000                 :         27 :       tree ret = NULL, lab;
    2001                 :            : 
    2002                 :         27 :       start1 = arg1;
    2003                 :         27 :       start2 = arg2;
    2004                 :         27 :       do
    2005                 :            :         {
    2006                 :         27 :           inner_type = TREE_TYPE (inner_type);
    2007                 :         27 :           start1 = build4 (ARRAY_REF, inner_type, start1,
    2008                 :            :                            size_zero_node, NULL, NULL);
    2009                 :         27 :           if (arg2)
    2010                 :          9 :             start2 = build4 (ARRAY_REF, inner_type, start2,
    2011                 :            :                              size_zero_node, NULL, NULL);
    2012                 :            :         }
    2013                 :         27 :       while (TREE_CODE (inner_type) == ARRAY_TYPE);
    2014                 :         27 :       start1 = build_fold_addr_expr_loc (input_location, start1);
    2015                 :         27 :       if (arg2)
    2016                 :          9 :         start2 = build_fold_addr_expr_loc (input_location, start2);
    2017                 :            : 
    2018                 :         27 :       end1 = TYPE_SIZE_UNIT (TREE_TYPE (arg1));
    2019                 :         27 :       end1 = fold_build_pointer_plus (start1, end1);
    2020                 :            : 
    2021                 :         27 :       p1 = create_tmp_var (TREE_TYPE (start1));
    2022                 :         27 :       t = build2 (MODIFY_EXPR, TREE_TYPE (p1), p1, start1);
    2023                 :         27 :       append_to_statement_list (t, &ret);
    2024                 :            : 
    2025                 :         27 :       if (arg2)
    2026                 :            :         {
    2027                 :          9 :           p2 = create_tmp_var (TREE_TYPE (start2));
    2028                 :          9 :           t = build2 (MODIFY_EXPR, TREE_TYPE (p2), p2, start2);
    2029                 :          9 :           append_to_statement_list (t, &ret);
    2030                 :            :         }
    2031                 :            : 
    2032                 :         27 :       lab = create_artificial_label (input_location);
    2033                 :         27 :       t = build1 (LABEL_EXPR, void_type_node, lab);
    2034                 :         27 :       append_to_statement_list (t, &ret);
    2035                 :            : 
    2036                 :         27 :       argarray[i++] = p1;
    2037                 :         27 :       if (arg2)
    2038                 :          9 :         argarray[i++] = p2;
    2039                 :            :       /* Handle default arguments.  */
    2040                 :         27 :       for (parm = defparm; parm && parm != void_list_node;
    2041                 :          0 :            parm = TREE_CHAIN (parm), i++)
    2042                 :          0 :         argarray[i] = convert_default_arg (TREE_VALUE (parm),
    2043                 :          0 :                                            TREE_PURPOSE (parm), fn,
    2044                 :            :                                            i - is_method, tf_warning_or_error);
    2045                 :         27 :       t = build_call_a (fn, i, argarray);
    2046                 :         27 :       t = fold_convert (void_type_node, t);
    2047                 :         27 :       t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    2048                 :         27 :       append_to_statement_list (t, &ret);
    2049                 :            : 
    2050                 :         27 :       t = fold_build_pointer_plus (p1, TYPE_SIZE_UNIT (inner_type));
    2051                 :         27 :       t = build2 (MODIFY_EXPR, TREE_TYPE (p1), p1, t);
    2052                 :         27 :       append_to_statement_list (t, &ret);
    2053                 :            : 
    2054                 :         27 :       if (arg2)
    2055                 :            :         {
    2056                 :          9 :           t = fold_build_pointer_plus (p2, TYPE_SIZE_UNIT (inner_type));
    2057                 :          9 :           t = build2 (MODIFY_EXPR, TREE_TYPE (p2), p2, t);
    2058                 :          9 :           append_to_statement_list (t, &ret);
    2059                 :            :         }
    2060                 :            : 
    2061                 :         27 :       t = build2 (NE_EXPR, boolean_type_node, p1, end1);
    2062                 :         27 :       t = build3 (COND_EXPR, void_type_node, t, build_and_jump (&lab), NULL);
    2063                 :         27 :       append_to_statement_list (t, &ret);
    2064                 :            : 
    2065                 :         27 :       return ret;
    2066                 :            :     }
    2067                 :            :   else
    2068                 :            :     {
    2069                 :       2967 :       argarray[i++] = build_fold_addr_expr_loc (input_location, arg1);
    2070                 :       2967 :       if (arg2)
    2071                 :       1000 :         argarray[i++] = build_fold_addr_expr_loc (input_location, arg2);
    2072                 :            :       /* Handle default arguments.  */
    2073                 :       2973 :       for (parm = defparm; parm && parm != void_list_node;
    2074                 :          6 :            parm = TREE_CHAIN (parm), i++)
    2075                 :         12 :         argarray[i] = convert_default_arg (TREE_VALUE (parm),
    2076                 :          6 :                                            TREE_PURPOSE (parm), fn,
    2077                 :            :                                            i - is_method, tf_warning_or_error);
    2078                 :       2967 :       t = build_call_a (fn, i, argarray);
    2079                 :       2967 :       t = fold_convert (void_type_node, t);
    2080                 :       2967 :       return fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    2081                 :            :     }
    2082                 :            : }
    2083                 :            : 
    2084                 :            : /* Return code to initialize DECL with its default constructor, or
    2085                 :            :    NULL if there's nothing to do.  */
    2086                 :            : 
    2087                 :            : tree
    2088                 :      35596 : cxx_omp_clause_default_ctor (tree clause, tree decl, tree /*outer*/)
    2089                 :            : {
    2090                 :      35596 :   tree info = CP_OMP_CLAUSE_INFO (clause);
    2091                 :      35596 :   tree ret = NULL;
    2092                 :            : 
    2093                 :      35596 :   if (info)
    2094                 :       1373 :     ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 0), decl, NULL);
    2095                 :            : 
    2096                 :      35596 :   return ret;
    2097                 :            : }
    2098                 :            : 
    2099                 :            : /* Return code to initialize DST with a copy constructor from SRC.  */
    2100                 :            : 
    2101                 :            : tree
    2102                 :       9330 : cxx_omp_clause_copy_ctor (tree clause, tree dst, tree src)
    2103                 :            : {
    2104                 :       9330 :   tree info = CP_OMP_CLAUSE_INFO (clause);
    2105                 :       9330 :   tree ret = NULL;
    2106                 :            : 
    2107                 :       9330 :   if (info)
    2108                 :        281 :     ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 0), dst, src);
    2109                 :        281 :   if (ret == NULL)
    2110                 :       9110 :     ret = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
    2111                 :            : 
    2112                 :       9330 :   return ret;
    2113                 :            : }
    2114                 :            : 
    2115                 :            : /* Similarly, except use an assignment operator instead.  */
    2116                 :            : 
    2117                 :            : tree
    2118                 :      10509 : cxx_omp_clause_assign_op (tree clause, tree dst, tree src)
    2119                 :            : {
    2120                 :      10509 :   tree info = CP_OMP_CLAUSE_INFO (clause);
    2121                 :      10509 :   tree ret = NULL;
    2122                 :            : 
    2123                 :      10509 :   if (info)
    2124                 :        812 :     ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 2), dst, src);
    2125                 :        812 :   if (ret == NULL)
    2126                 :       9720 :     ret = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
    2127                 :            : 
    2128                 :      10509 :   return ret;
    2129                 :            : }
    2130                 :            : 
    2131                 :            : /* Return code to destroy DECL.  */
    2132                 :            : 
    2133                 :            : tree
    2134                 :      51000 : cxx_omp_clause_dtor (tree clause, tree decl)
    2135                 :            : {
    2136                 :      51000 :   tree info = CP_OMP_CLAUSE_INFO (clause);
    2137                 :      51000 :   tree ret = NULL;
    2138                 :            : 
    2139                 :      51000 :   if (info)
    2140                 :       1259 :     ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 1), decl, NULL);
    2141                 :            : 
    2142                 :      51000 :   return ret;
    2143                 :            : }
    2144                 :            : 
    2145                 :            : /* True if OpenMP should privatize what this DECL points to rather
    2146                 :            :    than the DECL itself.  */
    2147                 :            : 
    2148                 :            : bool
    2149                 :     414886 : cxx_omp_privatize_by_reference (const_tree decl)
    2150                 :            : {
    2151                 :     414886 :   return (TYPE_REF_P (TREE_TYPE (decl))
    2152                 :     414886 :           || is_invisiref_parm (decl));
    2153                 :            : }
    2154                 :            : 
    2155                 :            : /* Return true if DECL is const qualified var having no mutable member.  */
    2156                 :            : bool
    2157                 :       9696 : cxx_omp_const_qual_no_mutable (tree decl)
    2158                 :            : {
    2159                 :       9696 :   tree type = TREE_TYPE (decl);
    2160                 :       9696 :   if (TYPE_REF_P (type))
    2161                 :            :     {
    2162                 :        804 :       if (!is_invisiref_parm (decl))
    2163                 :            :         return false;
    2164                 :          0 :       type = TREE_TYPE (type);
    2165                 :            : 
    2166                 :          0 :       if (TREE_CODE (decl) == RESULT_DECL && DECL_NAME (decl))
    2167                 :            :         {
    2168                 :            :           /* NVR doesn't preserve const qualification of the
    2169                 :            :              variable's type.  */
    2170                 :          0 :           tree outer = outer_curly_brace_block (current_function_decl);
    2171                 :          0 :           tree var;
    2172                 :            : 
    2173                 :          0 :           if (outer)
    2174                 :          0 :             for (var = BLOCK_VARS (outer); var; var = DECL_CHAIN (var))
    2175                 :          0 :               if (VAR_P (var)
    2176                 :          0 :                   && DECL_NAME (decl) == DECL_NAME (var)
    2177                 :          0 :                   && (TYPE_MAIN_VARIANT (type)
    2178                 :          0 :                       == TYPE_MAIN_VARIANT (TREE_TYPE (var))))
    2179                 :            :                 {
    2180                 :          0 :                   if (TYPE_READONLY (TREE_TYPE (var)))
    2181                 :          0 :                     type = TREE_TYPE (var);
    2182                 :            :                   break;
    2183                 :            :                 }
    2184                 :            :         }
    2185                 :            :     }
    2186                 :            : 
    2187                 :       8892 :   if (type == error_mark_node)
    2188                 :            :     return false;
    2189                 :            : 
    2190                 :            :   /* Variables with const-qualified type having no mutable member
    2191                 :            :      are predetermined shared.  */
    2192                 :       8872 :   if (TYPE_READONLY (type) && !cp_has_mutable_p (type))
    2193                 :         92 :     return true;
    2194                 :            : 
    2195                 :            :   return false;
    2196                 :            : }
    2197                 :            : 
    2198                 :            : /* True if OpenMP sharing attribute of DECL is predetermined.  */
    2199                 :            : 
    2200                 :            : enum omp_clause_default_kind
    2201                 :      42180 : cxx_omp_predetermined_sharing_1 (tree decl)
    2202                 :            : {
    2203                 :            :   /* Static data members are predetermined shared.  */
    2204                 :      42180 :   if (TREE_STATIC (decl))
    2205                 :            :     {
    2206                 :      10675 :       tree ctx = CP_DECL_CONTEXT (decl);
    2207                 :      10675 :       if (TYPE_P (ctx) && MAYBE_CLASS_TYPE_P (ctx))
    2208                 :            :         return OMP_CLAUSE_DEFAULT_SHARED;
    2209                 :            : 
    2210                 :      10566 :       if (c_omp_predefined_variable (decl))
    2211                 :            :         return OMP_CLAUSE_DEFAULT_SHARED;
    2212                 :            :     }
    2213                 :            : 
    2214                 :            :   /* this may not be specified in data-sharing clauses, still we need
    2215                 :            :      to predetermined it firstprivate.  */
    2216                 :      42035 :   if (decl == current_class_ptr)
    2217                 :        122 :     return OMP_CLAUSE_DEFAULT_FIRSTPRIVATE;
    2218                 :            : 
    2219                 :            :   return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
    2220                 :            : }
    2221                 :            : 
    2222                 :            : /* Likewise, but also include the artificial vars.  We don't want to
    2223                 :            :    disallow the artificial vars being mentioned in explicit clauses,
    2224                 :            :    as we use artificial vars e.g. for loop constructs with random
    2225                 :            :    access iterators other than pointers, but during gimplification
    2226                 :            :    we want to treat them as predetermined.  */
    2227                 :            : 
    2228                 :            : enum omp_clause_default_kind
    2229                 :      29164 : cxx_omp_predetermined_sharing (tree decl)
    2230                 :            : {
    2231                 :      29164 :   enum omp_clause_default_kind ret = cxx_omp_predetermined_sharing_1 (decl);
    2232                 :      29164 :   if (ret != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
    2233                 :            :     return ret;
    2234                 :            : 
    2235                 :            :   /* Predetermine artificial variables holding integral values, those
    2236                 :            :      are usually result of gimplify_one_sizepos or SAVE_EXPR
    2237                 :            :      gimplification.  */
    2238                 :      28953 :   if (VAR_P (decl)
    2239                 :      19398 :       && DECL_ARTIFICIAL (decl)
    2240                 :       5756 :       && INTEGRAL_TYPE_P (TREE_TYPE (decl))
    2241                 :      29370 :       && !(DECL_LANG_SPECIFIC (decl)
    2242                 :          2 :            && DECL_OMP_PRIVATIZED_MEMBER (decl)))
    2243                 :            :     return OMP_CLAUSE_DEFAULT_SHARED;
    2244                 :            : 
    2245                 :            :   /* Similarly for typeinfo symbols.  */
    2246                 :      47521 :   if (VAR_P (decl) && DECL_ARTIFICIAL (decl) && DECL_TINFO_P (decl))
    2247                 :         76 :     return OMP_CLAUSE_DEFAULT_SHARED;
    2248                 :            : 
    2249                 :            :   return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
    2250                 :            : }
    2251                 :            : 
    2252                 :            : /* Finalize an implicitly determined clause.  */
    2253                 :            : 
    2254                 :            : void
    2255                 :      57244 : cxx_omp_finish_clause (tree c, gimple_seq *)
    2256                 :            : {
    2257                 :      57244 :   tree decl, inner_type;
    2258                 :      57244 :   bool make_shared = false;
    2259                 :            : 
    2260                 :      57244 :   if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_FIRSTPRIVATE
    2261                 :      57244 :       && (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_LASTPRIVATE
    2262                 :       4416 :           || !OMP_CLAUSE_LASTPRIVATE_LOOP_IV (c)))
    2263                 :            :     return;
    2264                 :            : 
    2265                 :       6992 :   decl = OMP_CLAUSE_DECL (c);
    2266                 :       6992 :   decl = require_complete_type (decl);
    2267                 :       6992 :   inner_type = TREE_TYPE (decl);
    2268                 :       6992 :   if (decl == error_mark_node)
    2269                 :       6992 :     make_shared = true;
    2270                 :       6992 :   else if (TYPE_REF_P (TREE_TYPE (decl)))
    2271                 :         79 :     inner_type = TREE_TYPE (inner_type);
    2272                 :            : 
    2273                 :            :   /* We're interested in the base element, not arrays.  */
    2274                 :       7036 :   while (TREE_CODE (inner_type) == ARRAY_TYPE)
    2275                 :         44 :     inner_type = TREE_TYPE (inner_type);
    2276                 :            : 
    2277                 :            :   /* Check for special function availability by building a call to one.
    2278                 :            :      Save the results, because later we won't be in the right context
    2279                 :            :      for making these queries.  */
    2280                 :       6992 :   bool first = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE;
    2281                 :       6992 :   if (!make_shared
    2282                 :       7191 :       && CLASS_TYPE_P (inner_type)
    2283                 :       7191 :       && cxx_omp_create_clause_info (c, inner_type, !first, first, !first,
    2284                 :            :                                      true))
    2285                 :            :     make_shared = true;
    2286                 :            : 
    2287                 :       6984 :   if (make_shared)
    2288                 :            :     {
    2289                 :          8 :       OMP_CLAUSE_CODE (c) = OMP_CLAUSE_SHARED;
    2290                 :          8 :       OMP_CLAUSE_SHARED_FIRSTPRIVATE (c) = 0;
    2291                 :          8 :       OMP_CLAUSE_SHARED_READONLY (c) = 0;
    2292                 :            :     }
    2293                 :            : }
    2294                 :            : 
    2295                 :            : /* Return true if DECL's DECL_VALUE_EXPR (if any) should be
    2296                 :            :    disregarded in OpenMP construct, because it is going to be
    2297                 :            :    remapped during OpenMP lowering.  SHARED is true if DECL
    2298                 :            :    is going to be shared, false if it is going to be privatized.  */
    2299                 :            : 
    2300                 :            : bool
    2301                 :     459774 : cxx_omp_disregard_value_expr (tree decl, bool shared)
    2302                 :            : {
    2303                 :     459774 :   if (shared)
    2304                 :            :     return false;
    2305                 :     327791 :   if (VAR_P (decl)
    2306                 :     311282 :       && DECL_HAS_VALUE_EXPR_P (decl)
    2307                 :       8390 :       && DECL_ARTIFICIAL (decl)
    2308                 :       8027 :       && DECL_LANG_SPECIFIC (decl)
    2309                 :     335280 :       && DECL_OMP_PRIVATIZED_MEMBER (decl))
    2310                 :            :     return true;
    2311                 :     628581 :   if (VAR_P (decl) && DECL_CONTEXT (decl) && is_capture_proxy (decl))
    2312                 :         58 :     return true;
    2313                 :            :   return false;
    2314                 :            : }
    2315                 :            : 
    2316                 :            : /* Fold expression X which is used as an rvalue if RVAL is true.  */
    2317                 :            : 
    2318                 :            : tree
    2319                 :  222935000 : cp_fold_maybe_rvalue (tree x, bool rval)
    2320                 :            : {
    2321                 :  225272000 :   while (true)
    2322                 :            :     {
    2323                 :  224103000 :       x = cp_fold (x);
    2324                 :  224103000 :       if (rval)
    2325                 :  158956000 :         x = mark_rvalue_use (x);
    2326                 :  158956000 :       if (rval && DECL_P (x)
    2327                 :  260151000 :           && !TYPE_REF_P (TREE_TYPE (x)))
    2328                 :            :         {
    2329                 :   29937900 :           tree v = decl_constant_value (x);
    2330                 :   29937900 :           if (v != x && v != error_mark_node)
    2331                 :            :             {
    2332                 :    1168540 :               x = v;
    2333                 :    1168540 :               continue;
    2334                 :            :             }
    2335                 :            :         }
    2336                 :  222935000 :       break;
    2337                 :    1168540 :     }
    2338                 :  222935000 :   return x;
    2339                 :            : }
    2340                 :            : 
    2341                 :            : /* Fold expression X which is used as an rvalue.  */
    2342                 :            : 
    2343                 :            : tree
    2344                 :   74776400 : cp_fold_rvalue (tree x)
    2345                 :            : {
    2346                 :   74776400 :   return cp_fold_maybe_rvalue (x, true);
    2347                 :            : }
    2348                 :            : 
    2349                 :            : /* Perform folding on expression X.  */
    2350                 :            : 
    2351                 :            : tree
    2352                 :   26738500 : cp_fully_fold (tree x)
    2353                 :            : {
    2354                 :   26738500 :   if (processing_template_decl)
    2355                 :            :     return x;
    2356                 :            :   /* FIXME cp_fold ought to be a superset of maybe_constant_value so we don't
    2357                 :            :      have to call both.  */
    2358                 :   25659100 :   if (cxx_dialect >= cxx11)
    2359                 :            :     {
    2360                 :   24768800 :       x = maybe_constant_value (x);
    2361                 :            :       /* Sometimes we are given a CONSTRUCTOR but the call above wraps it into
    2362                 :            :          a TARGET_EXPR; undo that here.  */
    2363                 :   24768800 :       if (TREE_CODE (x) == TARGET_EXPR)
    2364                 :     100852 :         x = TARGET_EXPR_INITIAL (x);
    2365                 :   24667900 :       else if (TREE_CODE (x) == VIEW_CONVERT_EXPR
    2366                 :    3343080 :                && TREE_CODE (TREE_OPERAND (x, 0)) == CONSTRUCTOR
    2367                 :   24668000 :                && TREE_TYPE (TREE_OPERAND (x, 0)) == TREE_TYPE (x))
    2368                 :         92 :         x = TREE_OPERAND (x, 0);
    2369                 :            :     }
    2370                 :   25659100 :   return cp_fold_rvalue (x);
    2371                 :            : }
    2372                 :            : 
    2373                 :            : /* Likewise, but also fold recursively, which cp_fully_fold doesn't perform
    2374                 :            :    in some cases.  */
    2375                 :            : 
    2376                 :            : tree
    2377                 :    3463610 : cp_fully_fold_init (tree x)
    2378                 :            : {
    2379                 :    3463610 :   if (processing_template_decl)
    2380                 :      79639 :     return x;
    2381                 :    3383980 :   x = cp_fully_fold (x);
    2382                 :    3383980 :   hash_set<tree> pset;
    2383                 :    3383980 :   cp_walk_tree (&x, cp_fold_r, &pset, NULL);
    2384                 :    3383980 :   return x;
    2385                 :            : }
    2386                 :            : 
    2387                 :            : /* c-common interface to cp_fold.  If IN_INIT, this is in a static initializer
    2388                 :            :    and certain changes are made to the folding done.  Or should be (FIXME).  We
    2389                 :            :    never touch maybe_const, as it is only used for the C front-end
    2390                 :            :    C_MAYBE_CONST_EXPR.  */
    2391                 :            : 
    2392                 :            : tree
    2393                 :   12227800 : c_fully_fold (tree x, bool /*in_init*/, bool */*maybe_const*/, bool lval)
    2394                 :            : {
    2395                 :   12227800 :   return cp_fold_maybe_rvalue (x, !lval);
    2396                 :            : }
    2397                 :            : 
    2398                 :            : static GTY((deletable)) hash_map<tree, tree> *fold_cache;
    2399                 :            : 
    2400                 :            : /* Dispose of the whole FOLD_CACHE.  */
    2401                 :            : 
    2402                 :            : void
    2403                 :    2417250 : clear_fold_cache (void)
    2404                 :            : {
    2405                 :    2417250 :   if (fold_cache != NULL)
    2406                 :    2277860 :     fold_cache->empty ();
    2407                 :    2417250 : }
    2408                 :            : 
    2409                 :            : /*  This function tries to fold an expression X.
    2410                 :            :     To avoid combinatorial explosion, folding results are kept in fold_cache.
    2411                 :            :     If X is invalid, we don't fold at all.
    2412                 :            :     For performance reasons we don't cache expressions representing a
    2413                 :            :     declaration or constant.
    2414                 :            :     Function returns X or its folded variant.  */
    2415                 :            : 
    2416                 :            : static tree
    2417                 :  636518000 : cp_fold (tree x)
    2418                 :            : {
    2419                 :  636518000 :   tree op0, op1, op2, op3;
    2420                 :  636518000 :   tree org_x = x, r = NULL_TREE;
    2421                 :  636518000 :   enum tree_code code;
    2422                 :  636518000 :   location_t loc;
    2423                 :  636518000 :   bool rval_ops = true;
    2424                 :            : 
    2425                 :  636518000 :   if (!x || x == error_mark_node)
    2426                 :            :     return x;
    2427                 :            : 
    2428                 :  635613000 :   if (EXPR_P (x) && (!TREE_TYPE (x) || TREE_TYPE (x) == error_mark_node))
    2429                 :            :     return x;
    2430                 :            : 
    2431                 :            :   /* Don't bother to cache DECLs or constants.  */
    2432                 :  635534000 :   if (DECL_P (x) || CONSTANT_CLASS_P (x))
    2433                 :            :     return x;
    2434                 :            : 
    2435                 :  403208000 :   if (fold_cache == NULL)
    2436                 :      87416 :     fold_cache = hash_map<tree, tree>::create_ggc (101);
    2437                 :            : 
    2438                 :  403208000 :   if (tree *cached = fold_cache->get (x))
    2439                 :  103169000 :     return *cached;
    2440                 :            : 
    2441                 :  300039000 :   code = TREE_CODE (x);
    2442                 :  300039000 :   switch (code)
    2443                 :            :     {
    2444                 :   19222600 :     case CLEANUP_POINT_EXPR:
    2445                 :            :       /* Strip CLEANUP_POINT_EXPR if the expression doesn't have side
    2446                 :            :          effects.  */
    2447                 :   19222600 :       r = cp_fold_rvalue (TREE_OPERAND (x, 0));
    2448                 :   19222600 :       if (!TREE_SIDE_EFFECTS (r))
    2449                 :      19735 :         x = r;
    2450                 :            :       break;
    2451                 :            : 
    2452                 :     402965 :     case SIZEOF_EXPR:
    2453                 :     402965 :       x = fold_sizeof_expr (x);
    2454                 :     402965 :       break;
    2455                 :            : 
    2456                 :   18085600 :     case VIEW_CONVERT_EXPR:
    2457                 :   18085600 :       rval_ops = false;
    2458                 :            :       /* FALLTHRU */
    2459                 :   70233100 :     case CONVERT_EXPR:
    2460                 :   70233100 :     case NOP_EXPR:
    2461                 :   70233100 :     case NON_LVALUE_EXPR:
    2462                 :            : 
    2463                 :   70233100 :       if (VOID_TYPE_P (TREE_TYPE (x)))
    2464                 :            :         {
    2465                 :            :           /* This is just to make sure we don't end up with casts to
    2466                 :            :              void from error_mark_node.  If we just return x, then
    2467                 :            :              cp_fold_r might fold the operand into error_mark_node and
    2468                 :            :              leave the conversion in the IR.  STRIP_USELESS_TYPE_CONVERSION
    2469                 :            :              during gimplification doesn't like such casts.
    2470                 :            :              Don't create a new tree if op0 != TREE_OPERAND (x, 0), the
    2471                 :            :              folding of the operand should be in the caches and if in cp_fold_r
    2472                 :            :              it will modify it in place.  */
    2473                 :    7297430 :           op0 = cp_fold (TREE_OPERAND (x, 0));
    2474                 :    7297430 :           if (op0 == error_mark_node)
    2475                 :          9 :             x = error_mark_node;
    2476                 :            :           break;
    2477                 :            :         }
    2478                 :            : 
    2479                 :   62935600 :       loc = EXPR_LOCATION (x);
    2480                 :   62935600 :       op0 = cp_fold_maybe_rvalue (TREE_OPERAND (x, 0), rval_ops);
    2481                 :            : 
    2482                 :   62935600 :       if (code == CONVERT_EXPR
    2483                 :    6551930 :           && SCALAR_TYPE_P (TREE_TYPE (x))
    2484                 :   69479500 :           && op0 != void_node)
    2485                 :            :         /* During parsing we used convert_to_*_nofold; re-convert now using the
    2486                 :            :            folding variants, since fold() doesn't do those transformations.  */
    2487                 :    5884040 :         x = fold (convert (TREE_TYPE (x), op0));
    2488                 :   57051600 :       else if (op0 != TREE_OPERAND (x, 0))
    2489                 :            :         {
    2490                 :   14981700 :           if (op0 == error_mark_node)
    2491                 :         11 :             x = error_mark_node;
    2492                 :            :           else
    2493                 :   14981700 :             x = fold_build1_loc (loc, code, TREE_TYPE (x), op0);
    2494                 :            :         }
    2495                 :            :       else
    2496                 :   42069900 :         x = fold (x);
    2497                 :            : 
    2498                 :            :       /* Conversion of an out-of-range value has implementation-defined
    2499                 :            :          behavior; the language considers it different from arithmetic
    2500                 :            :          overflow, which is undefined.  */
    2501                 :   62935600 :       if (TREE_CODE (op0) == INTEGER_CST
    2502                 :   62935600 :           && TREE_OVERFLOW_P (x) && !TREE_OVERFLOW_P (op0))
    2503                 :       1798 :         TREE_OVERFLOW (x) = false;
    2504                 :            : 
    2505                 :            :       break;
    2506                 :            : 
    2507                 :   13166400 :     case INDIRECT_REF:
    2508                 :            :       /* We don't need the decltype(auto) obfuscation anymore.  */
    2509                 :   26332900 :       if (REF_PARENTHESIZED_P (x))
    2510                 :            :         {
    2511                 :          0 :           tree p = maybe_undo_parenthesized_ref (x);
    2512                 :          0 :           return cp_fold (p);
    2513                 :            :         }
    2514                 :   13166400 :       goto unary;
    2515                 :            : 
    2516                 :   29833600 :     case ADDR_EXPR:
    2517                 :   29833600 :       loc = EXPR_LOCATION (x);
    2518                 :   29833600 :       op0 = cp_fold_maybe_rvalue (TREE_OPERAND (x, 0), false);
    2519                 :            : 
    2520                 :            :       /* Cope with user tricks that amount to offsetof.  */
    2521                 :   29833600 :       if (op0 != error_mark_node
    2522                 :   59667200 :           && !FUNC_OR_METHOD_TYPE_P (TREE_TYPE (op0)))
    2523                 :            :         {
    2524                 :    9623400 :           tree val = get_base_address (op0);
    2525                 :    9623400 :           if (val
    2526                 :    9623400 :               && INDIRECT_REF_P (val)
    2527                 :    4365520 :               && COMPLETE_TYPE_P (TREE_TYPE (val))
    2528                 :   13988900 :               && TREE_CONSTANT (TREE_OPERAND (val, 0)))
    2529                 :            :             {
    2530                 :        190 :               val = TREE_OPERAND (val, 0);
    2531                 :        190 :               STRIP_NOPS (val);
    2532                 :        190 :               val = maybe_constant_value (val);
    2533                 :        190 :               if (TREE_CODE (val) == INTEGER_CST)
    2534                 :        119 :                 return fold_offsetof (op0, TREE_TYPE (x));
    2535                 :            :             }
    2536                 :            :         }
    2537                 :   29833500 :       goto finish_unary;
    2538                 :            : 
    2539                 :     166186 :     case REALPART_EXPR:
    2540                 :     166186 :     case IMAGPART_EXPR:
    2541                 :     166186 :       rval_ops = false;
    2542                 :            :       /* FALLTHRU */
    2543                 :   14460600 :     case CONJ_EXPR:
    2544                 :   14460600 :     case FIX_TRUNC_EXPR:
    2545                 :   14460600 :     case FLOAT_EXPR:
    2546                 :   14460600 :     case NEGATE_EXPR:
    2547                 :   14460600 :     case ABS_EXPR:
    2548                 :   14460600 :     case ABSU_EXPR:
    2549                 :   14460600 :     case BIT_NOT_EXPR:
    2550                 :   14460600 :     case TRUTH_NOT_EXPR:
    2551                 :   14460600 :     case FIXED_CONVERT_EXPR:
    2552                 :   14460600 :     unary:
    2553                 :            : 
    2554                 :   14460600 :       loc = EXPR_LOCATION (x);
    2555                 :   14460600 :       op0 = cp_fold_maybe_rvalue (TREE_OPERAND (x, 0), rval_ops);
    2556                 :            : 
    2557                 :   44294000 :     finish_unary:
    2558                 :   44294000 :       if (op0 != TREE_OPERAND (x, 0))
    2559                 :            :         {
    2560                 :    2604000 :           if (op0 == error_mark_node)
    2561                 :          0 :             x = error_mark_node;
    2562                 :            :           else
    2563                 :            :             {
    2564                 :    2604000 :               x = fold_build1_loc (loc, code, TREE_TYPE (x), op0);
    2565                 :    2604000 :               if (code == INDIRECT_REF
    2566                 :    1635860 :                   && (INDIRECT_REF_P (x) || TREE_CODE (x) == MEM_REF))
    2567                 :            :                 {
    2568                 :    1635850 :                   TREE_READONLY (x) = TREE_READONLY (org_x);
    2569                 :    1635850 :                   TREE_SIDE_EFFECTS (x) = TREE_SIDE_EFFECTS (org_x);
    2570                 :    1635850 :                   TREE_THIS_VOLATILE (x) = TREE_THIS_VOLATILE (org_x);
    2571                 :            :                 }
    2572                 :            :             }
    2573                 :            :         }
    2574                 :            :       else
    2575                 :   41690000 :         x = fold (x);
    2576                 :            : 
    2577                 :   44294000 :       gcc_assert (TREE_CODE (x) != COND_EXPR
    2578                 :            :                   || !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (x, 0))));
    2579                 :            :       break;
    2580                 :            : 
    2581                 :      33480 :     case UNARY_PLUS_EXPR:
    2582                 :      33480 :       op0 = cp_fold_rvalue (TREE_OPERAND (x, 0));
    2583                 :      33480 :       if (op0 == error_mark_node)
    2584                 :          0 :         x = error_mark_node;
    2585                 :            :       else
    2586                 :      33480 :         x = fold_convert (TREE_TYPE (x), op0);
    2587                 :            :       break;
    2588                 :            : 
    2589                 :   17062300 :     case POSTDECREMENT_EXPR:
    2590                 :   17062300 :     case POSTINCREMENT_EXPR:
    2591                 :   17062300 :     case INIT_EXPR:
    2592                 :   17062300 :     case PREDECREMENT_EXPR:
    2593                 :   17062300 :     case PREINCREMENT_EXPR:
    2594                 :   17062300 :     case COMPOUND_EXPR:
    2595                 :   17062300 :     case MODIFY_EXPR:
    2596                 :   17062300 :       rval_ops = false;
    2597                 :            :       /* FALLTHRU */
    2598                 :   28701000 :     case POINTER_PLUS_EXPR:
    2599                 :   28701000 :     case PLUS_EXPR:
    2600                 :   28701000 :     case POINTER_DIFF_EXPR:
    2601                 :   28701000 :     case MINUS_EXPR:
    2602                 :   28701000 :     case MULT_EXPR:
    2603                 :   28701000 :     case TRUNC_DIV_EXPR:
    2604                 :   28701000 :     case CEIL_DIV_EXPR:
    2605                 :   28701000 :     case FLOOR_DIV_EXPR:
    2606                 :   28701000 :     case ROUND_DIV_EXPR:
    2607                 :   28701000 :     case TRUNC_MOD_EXPR:
    2608                 :   28701000 :     case CEIL_MOD_EXPR:
    2609                 :   28701000 :     case ROUND_MOD_EXPR:
    2610                 :   28701000 :     case RDIV_EXPR:
    2611                 :   28701000 :     case EXACT_DIV_EXPR:
    2612                 :   28701000 :     case MIN_EXPR:
    2613                 :   28701000 :     case MAX_EXPR:
    2614                 :   28701000 :     case LSHIFT_EXPR:
    2615                 :   28701000 :     case RSHIFT_EXPR:
    2616                 :   28701000 :     case LROTATE_EXPR:
    2617                 :   28701000 :     case RROTATE_EXPR:
    2618                 :   28701000 :     case BIT_AND_EXPR:
    2619                 :   28701000 :     case BIT_IOR_EXPR:
    2620                 :   28701000 :     case BIT_XOR_EXPR:
    2621                 :   28701000 :     case TRUTH_AND_EXPR:
    2622                 :   28701000 :     case TRUTH_ANDIF_EXPR:
    2623                 :   28701000 :     case TRUTH_OR_EXPR:
    2624                 :   28701000 :     case TRUTH_ORIF_EXPR:
    2625                 :   28701000 :     case TRUTH_XOR_EXPR:
    2626                 :   28701000 :     case LT_EXPR: case LE_EXPR:
    2627                 :   28701000 :     case GT_EXPR: case GE_EXPR:
    2628                 :   28701000 :     case EQ_EXPR: case NE_EXPR:
    2629                 :   28701000 :     case UNORDERED_EXPR: case ORDERED_EXPR:
    2630                 :   28701000 :     case UNLT_EXPR: case UNLE_EXPR:
    2631                 :   28701000 :     case UNGT_EXPR: case UNGE_EXPR:
    2632                 :   28701000 :     case UNEQ_EXPR: case LTGT_EXPR:
    2633                 :   28701000 :     case RANGE_EXPR: case COMPLEX_EXPR:
    2634                 :            : 
    2635                 :   28701000 :       loc = EXPR_LOCATION (x);
    2636                 :   28701000 :       op0 = cp_fold_maybe_rvalue (TREE_OPERAND (x, 0), rval_ops);
    2637                 :   28701000 :       op1 = cp_fold_rvalue (TREE_OPERAND (x, 1));
    2638                 :            : 
    2639                 :   28701000 :       if (op0 != TREE_OPERAND (x, 0) || op1 != TREE_OPERAND (x, 1))
    2640                 :            :         {
    2641                 :   15310000 :           if (op0 == error_mark_node || op1 == error_mark_node)
    2642                 :         28 :             x = error_mark_node;
    2643                 :            :           else
    2644                 :   15310000 :             x = fold_build2_loc (loc, code, TREE_TYPE (x), op0, op1);
    2645                 :            :         }
    2646                 :            :       else
    2647                 :   13390900 :         x = fold (x);
    2648                 :            : 
    2649                 :            :       /* This is only needed for -Wnonnull-compare and only if
    2650                 :            :          TREE_NO_WARNING (org_x), but to avoid that option affecting code
    2651                 :            :          generation, we do it always.  */
    2652                 :   28701000 :       if (COMPARISON_CLASS_P (org_x))
    2653                 :            :         {
    2654                 :    4005560 :           if (x == error_mark_node || TREE_CODE (x) == INTEGER_CST)
    2655                 :            :             ;
    2656                 :    3533460 :           else if (COMPARISON_CLASS_P (x))
    2657                 :            :             {
    2658                 :    3505350 :               if (TREE_NO_WARNING (org_x) && warn_nonnull_compare)
    2659                 :     106434 :                 TREE_NO_WARNING (x) = 1;
    2660                 :            :             }
    2661                 :            :           /* Otherwise give up on optimizing these, let GIMPLE folders
    2662                 :            :              optimize those later on.  */
    2663                 :      28114 :           else if (op0 != TREE_OPERAND (org_x, 0)
    2664                 :      28114 :                    || op1 != TREE_OPERAND (org_x, 1))
    2665                 :            :             {
    2666                 :      27717 :               x = build2_loc (loc, code, TREE_TYPE (org_x), op0, op1);
    2667                 :      27717 :               if (TREE_NO_WARNING (org_x) && warn_nonnull_compare)
    2668                 :         20 :                 TREE_NO_WARNING (x) = 1;
    2669                 :            :             }
    2670                 :            :           else
    2671                 :        397 :             x = org_x;
    2672                 :            :         }
    2673                 :   28701000 :       if (code == MODIFY_EXPR && TREE_CODE (x) == MODIFY_EXPR)
    2674                 :    6549370 :         TREE_THIS_VOLATILE (x) = TREE_THIS_VOLATILE (org_x);
    2675                 :            : 
    2676                 :            :       break;
    2677                 :            : 
    2678                 :    1048100 :     case VEC_COND_EXPR:
    2679                 :    1048100 :     case COND_EXPR:
    2680                 :    1048100 :       loc = EXPR_LOCATION (x);
    2681                 :    1048100 :       op0 = cp_fold_rvalue (TREE_OPERAND (x, 0));
    2682                 :    1048100 :       op1 = cp_fold (TREE_OPERAND (x, 1));
    2683                 :    1048100 :       op2 = cp_fold (TREE_OPERAND (x, 2));
    2684                 :            : 
    2685                 :    1048100 :       if (TREE_CODE (TREE_TYPE (x)) == BOOLEAN_TYPE)
    2686                 :            :         {
    2687                 :      33032 :           warning_sentinel s (warn_int_in_bool_context);
    2688                 :      16516 :           if (!VOID_TYPE_P (TREE_TYPE (op1)))
    2689                 :      16516 :             op1 = cp_truthvalue_conversion (op1, tf_warning_or_error);
    2690                 :      16516 :           if (!VOID_TYPE_P (TREE_TYPE (op2)))
    2691                 :      16504 :             op2 = cp_truthvalue_conversion (op2, tf_warning_or_error);
    2692                 :            :         }
    2693                 :    1031590 :       else if (VOID_TYPE_P (TREE_TYPE (x)))
    2694                 :            :         {
    2695                 :     457173 :           if (TREE_CODE (op0) == INTEGER_CST)
    2696                 :            :             {
    2697                 :            :               /* If the condition is constant, fold can fold away
    2698                 :            :                  the COND_EXPR.  If some statement-level uses of COND_EXPR
    2699                 :            :                  have one of the branches NULL, avoid folding crash.  */
    2700                 :     113620 :               if (!op1)
    2701                 :          0 :                 op1 = build_empty_stmt (loc);
    2702                 :     113620 :               if (!op2)
    2703                 :          0 :                 op2 = build_empty_stmt (loc);
    2704                 :            :             }
    2705                 :            :           else
    2706                 :            :             {
    2707                 :            :               /* Otherwise, don't bother folding a void condition, since
    2708                 :            :                  it can't produce a constant value.  */
    2709                 :     343553 :               if (op0 != TREE_OPERAND (x, 0)
    2710                 :     336937 :                   || op1 != TREE_OPERAND (x, 1)
    2711                 :     665264 :                   || op2 != TREE_OPERAND (x, 2))
    2712                 :      44696 :                 x = build3_loc (loc, code, TREE_TYPE (x), op0, op1, op2);
    2713                 :            :               break;
    2714                 :            :             }
    2715                 :            :         }
    2716                 :            : 
    2717                 :     704552 :       if (op0 != TREE_OPERAND (x, 0)
    2718                 :     206860 :           || op1 != TREE_OPERAND (x, 1)
    2719                 :     879315 :           || op2 != TREE_OPERAND (x, 2))
    2720                 :            :         {
    2721                 :     536968 :           if (op0 == error_mark_node
    2722                 :     536968 :               || op1 == error_mark_node
    2723                 :     536968 :               || op2 == error_mark_node)
    2724                 :          4 :             x = error_mark_node;
    2725                 :            :           else
    2726                 :     536964 :             x = fold_build3_loc (loc, code, TREE_TYPE (x), op0, op1, op2);
    2727                 :            :         }
    2728                 :            :       else
    2729                 :     167584 :         x = fold (x);
    2730                 :            : 
    2731                 :            :       /* A COND_EXPR might have incompatible types in branches if one or both
    2732                 :            :          arms are bitfields.  If folding exposed such a branch, fix it up.  */
    2733                 :     704552 :       if (TREE_CODE (x) != code
    2734                 :     405138 :           && x != error_mark_node
    2735                 :    1109690 :           && !useless_type_conversion_p (TREE_TYPE (org_x), TREE_TYPE (x)))
    2736                 :      14586 :         x = fold_convert (TREE_TYPE (org_x), x);
    2737                 :            : 
    2738                 :            :       break;
    2739                 :            : 
    2740                 :   19899700 :     case CALL_EXPR:
    2741                 :   19899700 :       {
    2742                 :   19899700 :         int i, m, sv = optimize, nw = sv, changed = 0;
    2743                 :   19899700 :         tree callee = get_callee_fndecl (x);
    2744                 :            : 
    2745                 :            :         /* Some built-in function calls will be evaluated at compile-time in
    2746                 :            :            fold ().  Set optimize to 1 when folding __builtin_constant_p inside
    2747                 :            :            a constexpr function so that fold_builtin_1 doesn't fold it to 0.  */
    2748                 :   19582900 :         if (callee && fndecl_built_in_p (callee) && !optimize
    2749                 :     234177 :             && DECL_IS_BUILTIN_CONSTANT_P (callee)
    2750                 :       2089 :             && current_function_decl
    2751                 :   19903900 :             && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
    2752                 :            :           nw = 1;
    2753                 :            : 
    2754                 :            :         /* Defer folding __builtin_is_constant_evaluated.  */
    2755                 :   19899700 :         if (callee
    2756                 :   19899700 :             && fndecl_built_in_p (callee, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
    2757                 :            :                                   BUILT_IN_FRONTEND))
    2758                 :            :           break;
    2759                 :            : 
    2760                 :   19890300 :         if (callee
    2761                 :   19890300 :             && fndecl_built_in_p (callee, CP_BUILT_IN_SOURCE_LOCATION,
    2762                 :            :                                   BUILT_IN_FRONTEND))
    2763                 :            :           {
    2764                 :          0 :             x = fold_builtin_source_location (EXPR_LOCATION (x));
    2765                 :          0 :             break;
    2766                 :            :           }
    2767                 :            : 
    2768                 :   19890300 :         x = copy_node (x);
    2769                 :            : 
    2770                 :   19890300 :         m = call_expr_nargs (x);
    2771                 :   49238800 :         for (i = 0; i < m; i++)
    2772                 :            :           {
    2773                 :   29348500 :             r = cp_fold (CALL_EXPR_ARG (x, i));
    2774                 :   29348500 :             if (r != CALL_EXPR_ARG (x, i))
    2775                 :            :               {
    2776                 :   14744600 :                 if (r == error_mark_node)
    2777                 :            :                   {
    2778                 :          0 :                     x = error_mark_node;
    2779                 :          0 :                     break;
    2780                 :            :                   }
    2781                 :            :                 changed = 1;
    2782                 :            :               }
    2783                 :   29348500 :             CALL_EXPR_ARG (x, i) = r;
    2784                 :            :           }
    2785                 :   19890300 :         if (x == error_mark_node)
    2786                 :            :           break;
    2787                 :            : 
    2788                 :   19890300 :         optimize = nw;
    2789                 :   19890300 :         r = fold (x);
    2790                 :   19890300 :         optimize = sv;
    2791                 :            : 
    2792                 :   19890300 :         if (TREE_CODE (r) != CALL_EXPR)
    2793                 :            :           {
    2794                 :     108940 :             x = cp_fold (r);
    2795                 :     108940 :             break;
    2796                 :            :           }
    2797                 :            : 
    2798                 :   19781300 :         optimize = nw;
    2799                 :            : 
    2800                 :            :         /* Invoke maybe_constant_value for functions declared
    2801                 :            :            constexpr and not called with AGGR_INIT_EXPRs.
    2802                 :            :            TODO:
    2803                 :            :            Do constexpr expansion of expressions where the call itself is not
    2804                 :            :            constant, but the call followed by an INDIRECT_REF is.  */
    2805                 :   38929000 :         if (callee && DECL_DECLARED_CONSTEXPR_P (callee)
    2806                 :   22728900 :             && !flag_no_inline)
    2807                 :    2825280 :           r = maybe_constant_value (x);
    2808                 :   19781300 :         optimize = sv;
    2809                 :            : 
    2810                 :   19781300 :         if (TREE_CODE (r) != CALL_EXPR)
    2811                 :            :           {
    2812                 :     307690 :             if (DECL_CONSTRUCTOR_P (callee))
    2813                 :            :               {
    2814                 :          0 :                 loc = EXPR_LOCATION (x);
    2815                 :          0 :                 tree s = build_fold_indirect_ref_loc (loc,
    2816                 :          0 :                                                       CALL_EXPR_ARG (x, 0));
    2817                 :          0 :                 r = build2_loc (loc, INIT_EXPR, TREE_TYPE (s), s, r);
    2818                 :            :               }
    2819                 :     153845 :             x = r;
    2820                 :     153845 :             break;
    2821                 :            :           }
    2822                 :            : 
    2823                 :   19627500 :         if (!changed)
    2824                 :   10694100 :           x = org_x;
    2825                 :            :         break;
    2826                 :            :       }
    2827                 :            : 
    2828                 :    4554660 :     case CONSTRUCTOR:
    2829                 :    4554660 :       {
    2830                 :    4554660 :         unsigned i;
    2831                 :    4554660 :         constructor_elt *p;
    2832                 :    4554660 :         vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (x);
    2833                 :    4554660 :         vec<constructor_elt, va_gc> *nelts = NULL;
    2834                 :    6266150 :         FOR_EACH_VEC_SAFE_ELT (elts, i, p)
    2835                 :            :           {
    2836                 :    1711480 :             tree op = cp_fold (p->value);
    2837                 :    1711480 :             if (op != p->value)
    2838                 :            :               {
    2839                 :     153495 :                 if (op == error_mark_node)
    2840                 :            :                   {
    2841                 :          0 :                     x = error_mark_node;
    2842                 :          0 :                     vec_free (nelts);
    2843                 :            :                     break;
    2844                 :            :                   }
    2845                 :     153495 :                 if (nelts == NULL)
    2846                 :      53799 :                   nelts = elts->copy ();
    2847                 :     153495 :                 (*nelts)[i].value = op;
    2848                 :            :               }
    2849                 :            :           }
    2850                 :    4554660 :         if (nelts)
    2851                 :            :           {
    2852                 :      53799 :             x = build_constructor (TREE_TYPE (x), nelts);
    2853                 :      53799 :             CONSTRUCTOR_PLACEHOLDER_BOUNDARY (x)
    2854                 :      53799 :               = CONSTRUCTOR_PLACEHOLDER_BOUNDARY (org_x);
    2855                 :            :           }
    2856                 :    4554660 :         if (VECTOR_TYPE_P (TREE_TYPE (x)))
    2857                 :      20591 :           x = fold (x);
    2858                 :            :         break;
    2859                 :            :       }
    2860                 :      39397 :     case TREE_VEC:
    2861                 :      39397 :       {
    2862                 :      39397 :         bool changed = false;
    2863                 :      39397 :         releasing_vec vec;
    2864                 :      39397 :         int i, n = TREE_VEC_LENGTH (x);
    2865                 :      39397 :         vec_safe_reserve (vec, n);
    2866                 :            : 
    2867                 :     105294 :         for (i = 0; i < n; i++)
    2868                 :            :           {
    2869                 :      65897 :             tree op = cp_fold (TREE_VEC_ELT (x, i));
    2870                 :      65897 :             vec->quick_push (op);
    2871                 :      65897 :             if (op != TREE_VEC_ELT (x, i))
    2872                 :        802 :               changed = true;
    2873                 :            :           }
    2874                 :            : 
    2875                 :      39397 :         if (changed)
    2876                 :            :           {
    2877                 :        785 :             r = copy_node (x);
    2878                 :       2303 :             for (i = 0; i < n; i++)
    2879                 :       1518 :               TREE_VEC_ELT (r, i) = (*vec)[i];
    2880                 :        785 :             x = r;
    2881                 :            :           }
    2882                 :            :       }
    2883                 :            : 
    2884                 :      39397 :       break;
    2885                 :            : 
    2886                 :     445407 :     case ARRAY_REF:
    2887                 :     445407 :     case ARRAY_RANGE_REF:
    2888                 :            : 
    2889                 :     445407 :       loc = EXPR_LOCATION (x);
    2890                 :     445407 :       op0 = cp_fold (TREE_OPERAND (x, 0));
    2891                 :     445407 :       op1 = cp_fold (TREE_OPERAND (x, 1));
    2892                 :     445407 :       op2 = cp_fold (TREE_OPERAND (x, 2));
    2893                 :     445407 :       op3 = cp_fold (TREE_OPERAND (x, 3));
    2894                 :            : 
    2895                 :     445407 :       if (op0 != TREE_OPERAND (x, 0)
    2896                 :     173016 :           || op1 != TREE_OPERAND (x, 1)
    2897                 :      95662 :           || op2 != TREE_OPERAND (x, 2)
    2898                 :     541069 :           || op3 != TREE_OPERAND (x, 3))
    2899                 :            :         {
    2900                 :     349745 :           if (op0 == error_mark_node
    2901                 :     349745 :               || op1 == error_mark_node
    2902                 :     349745 :               || op2 == error_mark_node
    2903                 :     349745 :               || op3 == error_mark_node)
    2904                 :          0 :             x = error_mark_node;
    2905                 :            :           else
    2906                 :            :             {
    2907                 :     349745 :               x = build4_loc (loc, code, TREE_TYPE (x), op0, op1, op2, op3);
    2908                 :     349745 :               TREE_READONLY (x) = TREE_READONLY (org_x);
    2909                 :     349745 :               TREE_SIDE_EFFECTS (x) = TREE_SIDE_EFFECTS (org_x);
    2910                 :     349745 :               TREE_THIS_VOLATILE (x) = TREE_THIS_VOLATILE (org_x);
    2911                 :            :             }
    2912                 :            :         }
    2913                 :            : 
    2914                 :     445407 :       x = fold (x);
    2915                 :     445407 :       break;
    2916                 :            : 
    2917                 :     134459 :     case SAVE_EXPR:
    2918                 :            :       /* A SAVE_EXPR might contain e.g. (0 * i) + (0 * j), which, after
    2919                 :            :          folding, evaluates to an invariant.  In that case no need to wrap
    2920                 :            :          this folded tree with a SAVE_EXPR.  */
    2921                 :     134459 :       r = cp_fold (TREE_OPERAND (x, 0));
    2922                 :     134459 :       if (tree_invariant_p (r))
    2923                 :         35 :         x = r;
    2924                 :            :       break;
    2925                 :            : 
    2926                 :  111030000 :     default:
    2927                 :  111030000 :       return org_x;
    2928                 :            :     }
    2929                 :            : 
    2930                 :  189009000 :   fold_cache->put (org_x, x);
    2931                 :            :   /* Prevent that we try to fold an already folded result again.  */
    2932                 :  189009000 :   if (x != org_x)
    2933                 :   72704600 :     fold_cache->put (x, x);
    2934                 :            : 
    2935                 :  189009000 :   return x;
    2936                 :            : }
    2937                 :            : 
    2938                 :            : /* Look up either "hot" or "cold" in attribute list LIST.  */
    2939                 :            : 
    2940                 :            : tree
    2941                 :   17384100 : lookup_hotness_attribute (tree list)
    2942                 :            : {
    2943                 :   17385500 :   for (; list; list = TREE_CHAIN (list))
    2944                 :            :     {
    2945                 :       1697 :       tree name = get_attribute_name (list);
    2946                 :       1697 :       if (is_attribute_p ("hot", name)
    2947                 :       1697 :           || is_attribute_p ("cold", name)
    2948                 :       1697 :           || is_attribute_p ("likely", name)
    2949                 :       3271 :           || is_attribute_p ("unlikely", name))
    2950                 :            :         break;
    2951                 :            :     }
    2952                 :   17384100 :   return list;
    2953                 :            : }
    2954                 :            : 
    2955                 :            : /* Remove both "hot" and "cold" attributes from LIST.  */
    2956                 :            : 
    2957                 :            : static tree
    2958                 :        338 : remove_hotness_attribute (tree list)
    2959                 :            : {
    2960                 :        338 :   list = remove_attribute ("hot", list);
    2961                 :        338 :   list = remove_attribute ("cold", list);
    2962                 :        338 :   list = remove_attribute ("likely", list);
    2963                 :        338 :   list = remove_attribute ("unlikely", list);
    2964                 :        338 :   return list;
    2965                 :            : }
    2966                 :            : 
    2967                 :            : /* If [[likely]] or [[unlikely]] appear on this statement, turn it into a
    2968                 :            :    PREDICT_EXPR.  */
    2969                 :            : 
    2970                 :            : tree
    2971                 :   17383800 : process_stmt_hotness_attribute (tree std_attrs, location_t attrs_loc)
    2972                 :            : {
    2973                 :   17383800 :   if (std_attrs == error_mark_node)
    2974                 :            :     return std_attrs;
    2975                 :   17383800 :   if (tree attr = lookup_hotness_attribute (std_attrs))
    2976                 :            :     {
    2977                 :        338 :       tree name = get_attribute_name (attr);
    2978                 :        338 :       bool hot = (is_attribute_p ("hot", name)
    2979                 :        338 :                   || is_attribute_p ("likely", name));
    2980                 :        555 :       tree pred = build_predict_expr (hot ? PRED_HOT_LABEL : PRED_COLD_LABEL,
    2981                 :            :                                       hot ? TAKEN : NOT_TAKEN);
    2982                 :        338 :       SET_EXPR_LOCATION (pred, attrs_loc);
    2983                 :        338 :       add_stmt (pred);
    2984                 :        338 :       if (tree other = lookup_hotness_attribute (TREE_CHAIN (attr)))
    2985                 :          2 :         warning (OPT_Wattributes, "ignoring attribute %qE after earlier %qE",
    2986                 :            :                  get_attribute_name (other), name);
    2987                 :        338 :       std_attrs = remove_hotness_attribute (std_attrs);
    2988                 :            :     }
    2989                 :            :   return std_attrs;
    2990                 :            : }
    2991                 :            : 
    2992                 :            : /* Helper of fold_builtin_source_location, return the
    2993                 :            :    std::source_location::__impl type after performing verification
    2994                 :            :    on it.  LOC is used for reporting any errors.  */
    2995                 :            : 
    2996                 :            : static tree
    2997                 :         14 : get_source_location_impl_type (location_t loc)
    2998                 :            : {
    2999                 :         14 :   tree name = get_identifier ("source_location");
    3000                 :         14 :   tree decl = lookup_qualified_name (std_node, name);
    3001                 :         14 :   if (TREE_CODE (decl) != TYPE_DECL)
    3002                 :            :     {
    3003                 :          2 :       auto_diagnostic_group d;
    3004                 :          2 :       if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
    3005                 :          1 :         qualified_name_lookup_error (std_node, name, decl, loc);
    3006                 :            :       else
    3007                 :          1 :         error_at (loc, "%qD is not a type", decl);
    3008                 :          2 :       return error_mark_node;
    3009                 :            :     }
    3010                 :         12 :   name = get_identifier ("__impl");
    3011                 :         12 :   tree type = TREE_TYPE (decl);
    3012                 :         12 :   decl = lookup_qualified_name (type, name);
    3013                 :         12 :   if (TREE_CODE (decl) != TYPE_DECL)
    3014                 :            :     {
    3015                 :          3 :       auto_diagnostic_group d;
    3016                 :          3 :       if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
    3017                 :          2 :         qualified_name_lookup_error (type, name, decl, loc);
    3018                 :            :       else
    3019                 :          1 :         error_at (loc, "%qD is not a type", decl);
    3020                 :          3 :       return error_mark_node;
    3021                 :            :     }
    3022                 :          9 :   type = TREE_TYPE (decl);
    3023                 :          9 :   if (TREE_CODE (type) != RECORD_TYPE)
    3024                 :            :     {
    3025                 :          1 :       error_at (loc, "%qD is not a class type", decl);
    3026                 :          1 :       return error_mark_node;
    3027                 :            :     }
    3028                 :            : 
    3029                 :          8 :   int cnt = 0;
    3030                 :         27 :   for (tree field = TYPE_FIELDS (type);
    3031                 :         27 :        (field = next_initializable_field (field)) != NULL_TREE;
    3032                 :         19 :        field = DECL_CHAIN (field))
    3033                 :            :     {
    3034                 :         22 :       if (DECL_NAME (field) != NULL_TREE)
    3035                 :            :         {
    3036                 :         22 :           const char *n = IDENTIFIER_POINTER (DECL_NAME (field));
    3037                 :         22 :           if (strcmp (n, "_M_file_name") == 0
    3038                 :         15 :               || strcmp (n, "_M_function_name") == 0)
    3039                 :            :             {
    3040                 :         13 :               if (TREE_TYPE (field) != const_string_type_node)
    3041                 :            :                 {
    3042                 :          1 :                   error_at (loc, "%qD does not have %<const char *%> type",
    3043                 :            :                             field);
    3044                 :          1 :                   return error_mark_node;
    3045                 :            :                 }
    3046                 :         12 :               cnt++;
    3047                 :         12 :               continue;
    3048                 :            :             }
    3049                 :          9 :           else if (strcmp (n, "_M_line") == 0 || strcmp (n, "_M_column") == 0)
    3050                 :            :             {
    3051                 :          8 :               if (TREE_CODE (TREE_TYPE (field)) != INTEGER_TYPE)
    3052                 :            :                 {
    3053                 :          1 :                   error_at (loc, "%qD does not have integral type", field);
    3054                 :          1 :                   return error_mark_node;
    3055                 :            :                 }
    3056                 :          7 :               cnt++;
    3057                 :          7 :               continue;
    3058                 :            :             }
    3059                 :            :         }
    3060                 :            :       cnt = 0;
    3061                 :            :       break;
    3062                 :            :     }
    3063                 :          5 :   if (cnt != 4)
    3064                 :            :     {
    3065                 :          3 :       error_at (loc, "%<std::source_location::__impl%> does not contain only "
    3066                 :            :                      "non-static data members %<_M_file_name%>, "
    3067                 :            :                      "%<_M_function_name%>, %<_M_line%> and %<_M_column%>");
    3068                 :          3 :       return error_mark_node;
    3069                 :            :     }
    3070                 :          3 :   return build_qualified_type (type, TYPE_QUAL_CONST);
    3071                 :            : }
    3072                 :            : 
    3073                 :            : /* Type for source_location_table hash_set.  */
    3074                 :            : struct GTY((for_user)) source_location_table_entry {
    3075                 :            :   location_t loc;
    3076                 :            :   unsigned uid;
    3077                 :            :   tree var;
    3078                 :            : };
    3079                 :            : 
    3080                 :            : /* Traits class for function start hash maps below.  */
    3081                 :            : 
    3082                 :            : struct source_location_table_entry_hash
    3083                 :            :   : ggc_remove <source_location_table_entry>
    3084                 :            : {
    3085                 :            :   typedef source_location_table_entry value_type;
    3086                 :            :   typedef source_location_table_entry compare_type;
    3087                 :            : 
    3088                 :            :   static hashval_t
    3089                 :         51 :   hash (const source_location_table_entry &ref)
    3090                 :            :   {
    3091                 :         51 :     inchash::hash hstate (0);
    3092                 :         51 :     hstate.add_int (ref.loc);
    3093                 :         51 :     hstate.add_int (ref.uid);
    3094                 :         51 :     return hstate.end ();
    3095                 :            :   }
    3096                 :            : 
    3097                 :            :   static bool
    3098                 :         24 :   equal (const source_location_table_entry &ref1,
    3099                 :            :          const source_location_table_entry &ref2)
    3100                 :            :   {
    3101                 :         24 :     return ref1.loc == ref2.loc && ref1.uid == ref2.uid;
    3102                 :            :   }
    3103                 :            : 
    3104                 :            :   static void
    3105                 :            :   mark_deleted (source_location_table_entry &ref)
    3106                 :            :   {
    3107                 :            :     ref.loc = UNKNOWN_LOCATION;
    3108                 :            :     ref.uid = -1U;
    3109                 :            :     ref.var = NULL_TREE;
    3110                 :            :   }
    3111                 :            : 
    3112                 :            :   static const bool empty_zero_p = true;
    3113                 :            : 
    3114                 :            :   static void
    3115                 :          0 :   mark_empty (source_location_table_entry &ref)
    3116                 :            :   {
    3117                 :          0 :     ref.loc = UNKNOWN_LOCATION;
    3118                 :          0 :     ref.uid = 0;
    3119                 :          0 :     ref.var = NULL_TREE;
    3120                 :            :   }
    3121                 :            : 
    3122                 :            :   static bool
    3123                 :         24 :   is_deleted (const source_location_table_entry &ref)
    3124                 :            :   {
    3125                 :          0 :     return (ref.loc == UNKNOWN_LOCATION
    3126                 :            :             && ref.uid == -1U
    3127                 :         24 :             && ref.var == NULL_TREE);
    3128                 :            :   }
    3129                 :            : 
    3130                 :            :   static bool
    3131                 :        365 :   is_empty (const source_location_table_entry &ref)
    3132                 :            :   {
    3133                 :          0 :     return (ref.loc == UNKNOWN_LOCATION
    3134                 :        365 :             && ref.uid == 0
    3135                 :        365 :             && ref.var == NULL_TREE);
    3136                 :            :   }
    3137                 :            : };
    3138                 :            : 
    3139                 :            : static GTY(()) hash_table <source_location_table_entry_hash>
    3140                 :            :   *source_location_table;
    3141                 :            : static GTY(()) unsigned int source_location_id;
    3142                 :            : 
    3143                 :            : /* Fold __builtin_source_location () call.  LOC is the location
    3144                 :            :    of the call.  */
    3145                 :            : 
    3146                 :            : tree
    3147                 :         44 : fold_builtin_source_location (location_t loc)
    3148                 :            : {
    3149                 :         44 :   if (source_location_impl == NULL_TREE)
    3150                 :            :     {
    3151                 :         28 :       auto_diagnostic_group d;
    3152                 :         14 :       source_location_impl = get_source_location_impl_type (loc);
    3153                 :         14 :       if (source_location_impl == error_mark_node)
    3154                 :         11 :         inform (loc, "evaluating %qs", "__builtin_source_location");
    3155                 :            :     }
    3156                 :         44 :   if (source_location_impl == error_mark_node)
    3157                 :         11 :     return build_zero_cst (const_ptr_type_node);
    3158                 :         33 :   if (source_location_table == NULL)
    3159                 :          3 :     source_location_table
    3160                 :          3 :       = hash_table <source_location_table_entry_hash>::create_ggc (64);
    3161                 :         33 :   const line_map_ordinary *map;
    3162                 :         33 :   source_location_table_entry entry;
    3163                 :         33 :   entry.loc
    3164                 :         33 :     = linemap_resolve_location (line_table, loc, LRK_MACRO_EXPANSION_POINT,
    3165                 :            :                                 &map);
    3166                 :         33 :   entry.uid = current_function_decl ? DECL_UID (current_function_decl) : -1;
    3167                 :         33 :   entry.var = error_mark_node;
    3168                 :         33 :   source_location_table_entry *entryp
    3169                 :         33 :     = source_location_table->find_slot (entry, INSERT);
    3170                 :         33 :   tree var;
    3171                 :         33 :   if (entryp->var)
    3172                 :            :     var = entryp->var;
    3173                 :            :   else
    3174                 :            :     {
    3175                 :         29 :       char tmp_name[32];
    3176                 :         29 :       ASM_GENERATE_INTERNAL_LABEL (tmp_name, "Lsrc_loc", source_location_id++);
    3177                 :         29 :       var = build_decl (loc, VAR_DECL, get_identifier (tmp_name),
    3178                 :            :                         source_location_impl);
    3179                 :         29 :       TREE_STATIC (var) = 1;
    3180                 :         29 :       TREE_PUBLIC (var) = 0;
    3181                 :         29 :       DECL_ARTIFICIAL (var) = 1;
    3182                 :         29 :       DECL_IGNORED_P (var) = 1;
    3183                 :         29 :       DECL_EXTERNAL (var) = 0;
    3184                 :         58 :       DECL_DECLARED_CONSTEXPR_P (var) = 1;
    3185                 :         29 :       DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var) = 1;
    3186                 :         29 :       layout_decl (var, 0);
    3187                 :            : 
    3188                 :         29 :       vec<constructor_elt, va_gc> *v = NULL;
    3189                 :         29 :       vec_alloc (v, 4);
    3190                 :        145 :       for (tree field = TYPE_FIELDS (source_location_impl);
    3191                 :        145 :            (field = next_initializable_field (field)) != NULL_TREE;
    3192                 :        116 :            field = DECL_CHAIN (field))
    3193                 :            :         {
    3194                 :        116 :           const char *n = IDENTIFIER_POINTER (DECL_NAME (field));
    3195                 :        116 :           tree val = NULL_TREE;
    3196                 :        116 :           if (strcmp (n, "_M_file_name") == 0)
    3197                 :            :             {
    3198                 :         29 :               if (const char *fname = LOCATION_FILE (loc))
    3199                 :            :                 {
    3200                 :         29 :                   fname = remap_macro_filename (fname);
    3201                 :         29 :                   val = build_string_literal (strlen (fname) + 1, fname);
    3202                 :            :                 }
    3203                 :            :               else
    3204                 :          0 :                 val = build_string_literal (1, "");
    3205                 :            :             }
    3206                 :         87 :           else if (strcmp (n, "_M_function_name") == 0)
    3207                 :            :             {
    3208                 :         29 :               const char *name = "";
    3209                 :            : 
    3210                 :         29 :               if (current_function_decl)
    3211                 :         22 :                 name = cxx_printable_name (current_function_decl, 0);
    3212                 :            : 
    3213                 :         29 :               val = build_string_literal (strlen (name) + 1, name);
    3214                 :            :             }
    3215                 :         58 :           else if (strcmp (n, "_M_line") == 0)
    3216                 :         29 :             val = build_int_cst (TREE_TYPE (field), LOCATION_LINE (loc));
    3217                 :         29 :           else if (strcmp (n, "_M_column") == 0)
    3218                 :         29 :             val = build_int_cst (TREE_TYPE (field), LOCATION_COLUMN (loc));
    3219                 :            :           else
    3220                 :          0 :             gcc_unreachable ();
    3221                 :        116 :           CONSTRUCTOR_APPEND_ELT (v, field, val);
    3222                 :            :         }
    3223                 :            : 
    3224                 :         29 :       tree ctor = build_constructor (source_location_impl, v);
    3225                 :         29 :       TREE_CONSTANT (ctor) = 1;
    3226                 :         29 :       TREE_STATIC (ctor) = 1;
    3227                 :         29 :       DECL_INITIAL (var) = ctor;
    3228                 :         29 :       varpool_node::finalize_decl (var);
    3229                 :         29 :       *entryp = entry;
    3230                 :         29 :       entryp->var = var;
    3231                 :            :     }
    3232                 :            : 
    3233                 :         33 :   return build_fold_addr_expr_with_type_loc (loc, var, const_ptr_type_node);
    3234                 :            : }
    3235                 :            : 
    3236                 :            : #include "gt-cp-cp-gimplify.h"

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.