LCOV - code coverage report
Current view: top level - gcc/cp - semantics.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 4779 5101 93.7 %
Date: 2020-03-28 11:57:23 Functions: 190 194 97.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Perform the semantic phase of parsing, i.e., the process of
       2                 :            :    building tree structure, checking semantic consistency, and
       3                 :            :    building RTL.  These routines are used both during actual parsing
       4                 :            :    and during the instantiation of template functions.
       5                 :            : 
       6                 :            :    Copyright (C) 1998-2020 Free Software Foundation, Inc.
       7                 :            :    Written by Mark Mitchell (mmitchell@usa.net) based on code found
       8                 :            :    formerly in parse.y and pt.c.
       9                 :            : 
      10                 :            :    This file is part of GCC.
      11                 :            : 
      12                 :            :    GCC is free software; you can redistribute it and/or modify it
      13                 :            :    under the terms of the GNU General Public License as published by
      14                 :            :    the Free Software Foundation; either version 3, or (at your option)
      15                 :            :    any later version.
      16                 :            : 
      17                 :            :    GCC is distributed in the hope that it will be useful, but
      18                 :            :    WITHOUT ANY WARRANTY; without even the implied warranty of
      19                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      20                 :            :    General Public License for more details.
      21                 :            : 
      22                 :            : You should have received a copy of the GNU General Public License
      23                 :            : along with GCC; see the file COPYING3.  If not see
      24                 :            : <http://www.gnu.org/licenses/>.  */
      25                 :            : 
      26                 :            : #include "config.h"
      27                 :            : #include "system.h"
      28                 :            : #include "coretypes.h"
      29                 :            : #include "target.h"
      30                 :            : #include "bitmap.h"
      31                 :            : #include "cp-tree.h"
      32                 :            : #include "stringpool.h"
      33                 :            : #include "cgraph.h"
      34                 :            : #include "stmt.h"
      35                 :            : #include "varasm.h"
      36                 :            : #include "stor-layout.h"
      37                 :            : #include "c-family/c-objc.h"
      38                 :            : #include "tree-inline.h"
      39                 :            : #include "intl.h"
      40                 :            : #include "tree-iterator.h"
      41                 :            : #include "omp-general.h"
      42                 :            : #include "convert.h"
      43                 :            : #include "stringpool.h"
      44                 :            : #include "attribs.h"
      45                 :            : #include "gomp-constants.h"
      46                 :            : #include "predict.h"
      47                 :            : #include "memmodel.h"
      48                 :            : 
      49                 :            : /* There routines provide a modular interface to perform many parsing
      50                 :            :    operations.  They may therefore be used during actual parsing, or
      51                 :            :    during template instantiation, which may be regarded as a
      52                 :            :    degenerate form of parsing.  */
      53                 :            : 
      54                 :            : static tree maybe_convert_cond (tree);
      55                 :            : static tree finalize_nrv_r (tree *, int *, void *);
      56                 :            : static tree capture_decltype (tree);
      57                 :            : 
      58                 :            : /* Used for OpenMP non-static data member privatization.  */
      59                 :            : 
      60                 :            : static hash_map<tree, tree> *omp_private_member_map;
      61                 :            : static vec<tree> omp_private_member_vec;
      62                 :            : static bool omp_private_member_ignore_next;
      63                 :            : 
      64                 :            : 
      65                 :            : /* Deferred Access Checking Overview
      66                 :            :    ---------------------------------
      67                 :            : 
      68                 :            :    Most C++ expressions and declarations require access checking
      69                 :            :    to be performed during parsing.  However, in several cases,
      70                 :            :    this has to be treated differently.
      71                 :            : 
      72                 :            :    For member declarations, access checking has to be deferred
      73                 :            :    until more information about the declaration is known.  For
      74                 :            :    example:
      75                 :            : 
      76                 :            :      class A {
      77                 :            :          typedef int X;
      78                 :            :        public:
      79                 :            :          X f();
      80                 :            :      };
      81                 :            : 
      82                 :            :      A::X A::f();
      83                 :            :      A::X g();
      84                 :            : 
      85                 :            :    When we are parsing the function return type `A::X', we don't
      86                 :            :    really know if this is allowed until we parse the function name.
      87                 :            : 
      88                 :            :    Furthermore, some contexts require that access checking is
      89                 :            :    never performed at all.  These include class heads, and template
      90                 :            :    instantiations.
      91                 :            : 
      92                 :            :    Typical use of access checking functions is described here:
      93                 :            : 
      94                 :            :    1. When we enter a context that requires certain access checking
      95                 :            :       mode, the function `push_deferring_access_checks' is called with
      96                 :            :       DEFERRING argument specifying the desired mode.  Access checking
      97                 :            :       may be performed immediately (dk_no_deferred), deferred
      98                 :            :       (dk_deferred), or not performed (dk_no_check).
      99                 :            : 
     100                 :            :    2. When a declaration such as a type, or a variable, is encountered,
     101                 :            :       the function `perform_or_defer_access_check' is called.  It
     102                 :            :       maintains a vector of all deferred checks.
     103                 :            : 
     104                 :            :    3. The global `current_class_type' or `current_function_decl' is then
     105                 :            :       setup by the parser.  `enforce_access' relies on these information
     106                 :            :       to check access.
     107                 :            : 
     108                 :            :    4. Upon exiting the context mentioned in step 1,
     109                 :            :       `perform_deferred_access_checks' is called to check all declaration
     110                 :            :       stored in the vector. `pop_deferring_access_checks' is then
     111                 :            :       called to restore the previous access checking mode.
     112                 :            : 
     113                 :            :       In case of parsing error, we simply call `pop_deferring_access_checks'
     114                 :            :       without `perform_deferred_access_checks'.  */
     115                 :            : 
     116                 :            : struct GTY(()) deferred_access {
     117                 :            :   /* A vector representing name-lookups for which we have deferred
     118                 :            :      checking access controls.  We cannot check the accessibility of
     119                 :            :      names used in a decl-specifier-seq until we know what is being
     120                 :            :      declared because code like:
     121                 :            : 
     122                 :            :        class A {
     123                 :            :          class B {};
     124                 :            :          B* f();
     125                 :            :        }
     126                 :            : 
     127                 :            :        A::B* A::f() { return 0; }
     128                 :            : 
     129                 :            :      is valid, even though `A::B' is not generally accessible.  */
     130                 :            :   vec<deferred_access_check, va_gc> * GTY(()) deferred_access_checks;
     131                 :            : 
     132                 :            :   /* The current mode of access checks.  */
     133                 :            :   enum deferring_kind deferring_access_checks_kind;
     134                 :            : 
     135                 :            : };
     136                 :            : 
     137                 :            : /* Data for deferred access checking.  */
     138                 :            : static GTY(()) vec<deferred_access, va_gc> *deferred_access_stack;
     139                 :            : static GTY(()) unsigned deferred_access_no_check;
     140                 :            : 
     141                 :            : /* Save the current deferred access states and start deferred
     142                 :            :    access checking iff DEFER_P is true.  */
     143                 :            : 
     144                 :            : void
     145                 : 1528930000 : push_deferring_access_checks (deferring_kind deferring)
     146                 :            : {
     147                 :            :   /* For context like template instantiation, access checking
     148                 :            :      disabling applies to all nested context.  */
     149                 : 1528930000 :   if (deferred_access_no_check || deferring == dk_no_check)
     150                 :  963585000 :     deferred_access_no_check++;
     151                 :            :   else
     152                 :            :     {
     153                 :  565348000 :       deferred_access e = {NULL, deferring};
     154                 :  565348000 :       vec_safe_push (deferred_access_stack, e);
     155                 :            :     }
     156                 : 1528930000 : }
     157                 :            : 
     158                 :            : /* Save the current deferred access states and start deferred access
     159                 :            :    checking, continuing the set of deferred checks in CHECKS.  */
     160                 :            : 
     161                 :            : void
     162                 :   32712600 : reopen_deferring_access_checks (vec<deferred_access_check, va_gc> * checks)
     163                 :            : {
     164                 :   32712600 :   push_deferring_access_checks (dk_deferred);
     165                 :   32712600 :   if (!deferred_access_no_check)
     166                 :   18393800 :     deferred_access_stack->last().deferred_access_checks = checks;
     167                 :   32712600 : }
     168                 :            : 
     169                 :            : /* Resume deferring access checks again after we stopped doing
     170                 :            :    this previously.  */
     171                 :            : 
     172                 :            : void
     173                 :   14713900 : resume_deferring_access_checks (void)
     174                 :            : {
     175                 :   14713900 :   if (!deferred_access_no_check)
     176                 :    7984340 :     deferred_access_stack->last().deferring_access_checks_kind = dk_deferred;
     177                 :   14713900 : }
     178                 :            : 
     179                 :            : /* Stop deferring access checks.  */
     180                 :            : 
     181                 :            : void
     182                 :   39946500 : stop_deferring_access_checks (void)
     183                 :            : {
     184                 :   39946500 :   if (!deferred_access_no_check)
     185                 :   18919600 :     deferred_access_stack->last().deferring_access_checks_kind = dk_no_deferred;
     186                 :   39946500 : }
     187                 :            : 
     188                 :            : /* Discard the current deferred access checks and restore the
     189                 :            :    previous states.  */
     190                 :            : 
     191                 :            : void
     192                 :  934326000 : pop_deferring_access_checks (void)
     193                 :            : {
     194                 :  934326000 :   if (deferred_access_no_check)
     195                 :  559669000 :     deferred_access_no_check--;
     196                 :            :   else
     197                 :  374657000 :     deferred_access_stack->pop ();
     198                 :  934326000 : }
     199                 :            : 
     200                 :            : /* Returns a TREE_LIST representing the deferred checks.
     201                 :            :    The TREE_PURPOSE of each node is the type through which the
     202                 :            :    access occurred; the TREE_VALUE is the declaration named.
     203                 :            :    */
     204                 :            : 
     205                 :            : vec<deferred_access_check, va_gc> *
     206                 :  101817000 : get_deferred_access_checks (void)
     207                 :            : {
     208                 :  101817000 :   if (deferred_access_no_check)
     209                 :            :     return NULL;
     210                 :            :   else
     211                 :   54266500 :     return (deferred_access_stack->last().deferred_access_checks);
     212                 :            : }
     213                 :            : 
     214                 :            : /* Take current deferred checks and combine with the
     215                 :            :    previous states if we also defer checks previously.
     216                 :            :    Otherwise perform checks now.  */
     217                 :            : 
     218                 :            : void
     219                 :  594493000 : pop_to_parent_deferring_access_checks (void)
     220                 :            : {
     221                 :  594493000 :   if (deferred_access_no_check)
     222                 :  403915000 :     deferred_access_no_check--;
     223                 :            :   else
     224                 :            :     {
     225                 :  190578000 :       vec<deferred_access_check, va_gc> *checks;
     226                 :  190578000 :       deferred_access *ptr;
     227                 :            : 
     228                 :  190578000 :       checks = (deferred_access_stack->last ().deferred_access_checks);
     229                 :            : 
     230                 :  190578000 :       deferred_access_stack->pop ();
     231                 :  190578000 :       ptr = &deferred_access_stack->last ();
     232                 :  190578000 :       if (ptr->deferring_access_checks_kind == dk_no_deferred)
     233                 :            :         {
     234                 :            :           /* Check access.  */
     235                 :    8554450 :           perform_access_checks (checks, tf_warning_or_error);
     236                 :            :         }
     237                 :            :       else
     238                 :            :         {
     239                 :            :           /* Merge with parent.  */
     240                 :            :           int i, j;
     241                 :            :           deferred_access_check *chk, *probe;
     242                 :            : 
     243                 :  187966000 :           FOR_EACH_VEC_SAFE_ELT (checks, i, chk)
     244                 :            :             {
     245                 :    5223520 :               FOR_EACH_VEC_SAFE_ELT (ptr->deferred_access_checks, j, probe)
     246                 :            :                 {
     247                 :    2341870 :                   if (probe->binfo == chk->binfo &&
     248                 :    2305950 :                       probe->decl == chk->decl &&
     249                 :      89846 :                       probe->diag_decl == chk->diag_decl)
     250                 :      89790 :                     goto found;
     251                 :            :                 }
     252                 :            :               /* Insert into parent's checks.  */
     253                 :    2881650 :               vec_safe_push (ptr->deferred_access_checks, *chk);
     254                 :    2971440 :             found:;
     255                 :            :             }
     256                 :            :         }
     257                 :            :     }
     258                 :  594493000 : }
     259                 :            : 
     260                 :            : /* Perform the access checks in CHECKS.  The TREE_PURPOSE of each node
     261                 :            :    is the BINFO indicating the qualifying scope used to access the
     262                 :            :    DECL node stored in the TREE_VALUE of the node.  If CHECKS is empty
     263                 :            :    or we aren't in SFINAE context or all the checks succeed return TRUE,
     264                 :            :    otherwise FALSE.  */
     265                 :            : 
     266                 :            : bool
     267                 :   66287400 : perform_access_checks (vec<deferred_access_check, va_gc> *checks,
     268                 :            :                        tsubst_flags_t complain)
     269                 :            : {
     270                 :   66287400 :   int i;
     271                 :   66287400 :   deferred_access_check *chk;
     272                 :   66287400 :   location_t loc = input_location;
     273                 :   66287400 :   bool ok = true;
     274                 :            : 
     275                 :   66287400 :   if (!checks)
     276                 :            :     return true;
     277                 :            : 
     278                 :    8255710 :   FOR_EACH_VEC_SAFE_ELT (checks, i, chk)
     279                 :            :     {
     280                 :    4503350 :       input_location = chk->loc;
     281                 :    4503350 :       ok &= enforce_access (chk->binfo, chk->decl, chk->diag_decl, complain);
     282                 :            :     }
     283                 :            : 
     284                 :    3752360 :   input_location = loc;
     285                 :    3752360 :   return (complain & tf_error) ? true : ok;
     286                 :            : }
     287                 :            : 
     288                 :            : /* Perform the deferred access checks.
     289                 :            : 
     290                 :            :    After performing the checks, we still have to keep the list
     291                 :            :    `deferred_access_stack->deferred_access_checks' since we may want
     292                 :            :    to check access for them again later in a different context.
     293                 :            :    For example:
     294                 :            : 
     295                 :            :      class A {
     296                 :            :        typedef int X;
     297                 :            :        static X a;
     298                 :            :      };
     299                 :            :      A::X A::a, x;      // No error for `A::a', error for `x'
     300                 :            : 
     301                 :            :    We have to perform deferred access of `A::X', first with `A::a',
     302                 :            :    next with `x'.  Return value like perform_access_checks above.  */
     303                 :            : 
     304                 :            : bool
     305                 :   31430400 : perform_deferred_access_checks (tsubst_flags_t complain)
     306                 :            : {
     307                 :   31430400 :   return perform_access_checks (get_deferred_access_checks (), complain);
     308                 :            : }
     309                 :            : 
     310                 :            : /* Defer checking the accessibility of DECL, when looked up in
     311                 :            :    BINFO. DIAG_DECL is the declaration to use to print diagnostics.
     312                 :            :    Return value like perform_access_checks above.
     313                 :            :    If non-NULL, report failures to AFI.  */
     314                 :            : 
     315                 :            : bool
     316                 :   65479200 : perform_or_defer_access_check (tree binfo, tree decl, tree diag_decl,
     317                 :            :                                tsubst_flags_t complain,
     318                 :            :                                access_failure_info *afi)
     319                 :            : {
     320                 :   65479200 :   int i;
     321                 :   65479200 :   deferred_access *ptr;
     322                 :   65479200 :   deferred_access_check *chk;
     323                 :            : 
     324                 :            : 
     325                 :            :   /* Exit if we are in a context that no access checking is performed.
     326                 :            :      */
     327                 :   65479200 :   if (deferred_access_no_check)
     328                 :            :     return true;
     329                 :            : 
     330                 :   61548000 :   gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
     331                 :            : 
     332                 :   61548000 :   ptr = &deferred_access_stack->last ();
     333                 :            : 
     334                 :            :   /* If we are not supposed to defer access checks, just check now.  */
     335                 :   61548000 :   if (ptr->deferring_access_checks_kind == dk_no_deferred)
     336                 :            :     {
     337                 :   49046300 :       bool ok = enforce_access (binfo, decl, diag_decl, complain, afi);
     338                 :   49048800 :       return (complain & tf_error) ? true : ok;
     339                 :            :     }
     340                 :            : 
     341                 :            :   /* See if we are already going to perform this check.  */
     342                 :   15196300 :   FOR_EACH_VEC_SAFE_ELT (ptr->deferred_access_checks, i, chk)
     343                 :            :     {
     344                 :    4685040 :       if (chk->decl == decl && chk->binfo == binfo &&
     345                 :    1990470 :           chk->diag_decl == diag_decl)
     346                 :            :         {
     347                 :            :           return true;
     348                 :            :         }
     349                 :            :     }
     350                 :            :   /* If not, record the check.  */
     351                 :   10511300 :   deferred_access_check new_access = {binfo, decl, diag_decl, input_location};
     352                 :   10511300 :   vec_safe_push (ptr->deferred_access_checks, new_access);
     353                 :            : 
     354                 :   10511300 :   return true;
     355                 :            : }
     356                 :            : 
     357                 :            : /* Returns nonzero if the current statement is a full expression,
     358                 :            :    i.e. temporaries created during that statement should be destroyed
     359                 :            :    at the end of the statement.  */
     360                 :            : 
     361                 :            : int
     362                 :  190476000 : stmts_are_full_exprs_p (void)
     363                 :            : {
     364                 :  190476000 :   return current_stmt_tree ()->stmts_are_full_exprs_p;
     365                 :            : }
     366                 :            : 
     367                 :            : /* T is a statement.  Add it to the statement-tree.  This is the C++
     368                 :            :    version.  The C/ObjC frontends have a slightly different version of
     369                 :            :    this function.  */
     370                 :            : 
     371                 :            : tree
     372                 :   90135000 : add_stmt (tree t)
     373                 :            : {
     374                 :   90135000 :   enum tree_code code = TREE_CODE (t);
     375                 :            : 
     376                 :   90135000 :   if (EXPR_P (t) && code != LABEL_EXPR)
     377                 :            :     {
     378                 :   84765800 :       if (!EXPR_HAS_LOCATION (t))
     379                 :   12284500 :         SET_EXPR_LOCATION (t, input_location);
     380                 :            : 
     381                 :            :       /* When we expand a statement-tree, we must know whether or not the
     382                 :            :          statements are full-expressions.  We record that fact here.  */
     383                 :  169532000 :       STMT_IS_FULL_EXPR_P (t) = stmts_are_full_exprs_p ();
     384                 :            :     }
     385                 :            : 
     386                 :   90135000 :   if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
     387                 :     897137 :     STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
     388                 :            : 
     389                 :            :   /* Add T to the statement-tree.  Non-side-effect statements need to be
     390                 :            :      recorded during statement expressions.  */
     391                 :   90135000 :   gcc_checking_assert (!stmt_list_stack->is_empty ());
     392                 :   90135000 :   append_to_statement_list_force (t, &cur_stmt_list);
     393                 :            : 
     394                 :   90135000 :   return t;
     395                 :            : }
     396                 :            : 
     397                 :            : /* Returns the stmt_tree to which statements are currently being added.  */
     398                 :            : 
     399                 :            : stmt_tree
     400                 :  699452000 : current_stmt_tree (void)
     401                 :            : {
     402                 :  699452000 :   return (cfun
     403                 :  695773000 :           ? &cfun->language->base.x_stmt_tree
     404                 :  699452000 :           : &scope_chain->x_stmt_tree);
     405                 :            : }
     406                 :            : 
     407                 :            : /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR.  */
     408                 :            : 
     409                 :            : static tree
     410                 :      56115 : maybe_cleanup_point_expr (tree expr)
     411                 :            : {
     412                 :      56115 :   if (!processing_template_decl && stmts_are_full_exprs_p ())
     413                 :      53056 :     expr = fold_build_cleanup_point_expr (TREE_TYPE (expr), expr);
     414                 :      56115 :   return expr;
     415                 :            : }
     416                 :            : 
     417                 :            : /* Like maybe_cleanup_point_expr except have the type of the new expression be
     418                 :            :    void so we don't need to create a temporary variable to hold the inner
     419                 :            :    expression.  The reason why we do this is because the original type might be
     420                 :            :    an aggregate and we cannot create a temporary variable for that type.  */
     421                 :            : 
     422                 :            : tree
     423                 :   27807000 : maybe_cleanup_point_expr_void (tree expr)
     424                 :            : {
     425                 :   27807000 :   if (!processing_template_decl && stmts_are_full_exprs_p ())
     426                 :   17535300 :     expr = fold_build_cleanup_point_expr (void_type_node, expr);
     427                 :   27807000 :   return expr;
     428                 :            : }
     429                 :            : 
     430                 :            : 
     431                 :            : 
     432                 :            : /* Create a declaration statement for the declaration given by the DECL.  */
     433                 :            : 
     434                 :            : void
     435                 :    5508370 : add_decl_expr (tree decl)
     436                 :            : {
     437                 :    5508370 :   tree r = build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl);
     438                 :    5508370 :   if (DECL_INITIAL (decl)
     439                 :    5508370 :       || (DECL_SIZE (decl) && TREE_SIDE_EFFECTS (DECL_SIZE (decl))))
     440                 :     400313 :     r = maybe_cleanup_point_expr_void (r);
     441                 :    5508370 :   add_stmt (r);
     442                 :    5508370 : }
     443                 :            : 
     444                 :            : /* Finish a scope.  */
     445                 :            : 
     446                 :            : tree
     447                 :   29576700 : do_poplevel (tree stmt_list)
     448                 :            : {
     449                 :   29576700 :   tree block = NULL;
     450                 :            : 
     451                 :   29576700 :   if (stmts_are_full_exprs_p ())
     452                 :   29572700 :     block = poplevel (kept_level_p (), 1, 0);
     453                 :            : 
     454                 :   29576700 :   stmt_list = pop_stmt_list (stmt_list);
     455                 :            : 
     456                 :   29576700 :   if (!processing_template_decl)
     457                 :            :     {
     458                 :   17434800 :       stmt_list = c_build_bind_expr (input_location, block, stmt_list);
     459                 :            :       /* ??? See c_end_compound_stmt re statement expressions.  */
     460                 :            :     }
     461                 :            : 
     462                 :   29576700 :   return stmt_list;
     463                 :            : }
     464                 :            : 
     465                 :            : /* Begin a new scope.  */
     466                 :            : 
     467                 :            : static tree
     468                 :   29576700 : do_pushlevel (scope_kind sk)
     469                 :            : {
     470                 :   29576700 :   tree ret = push_stmt_list ();
     471                 :   29576700 :   if (stmts_are_full_exprs_p ())
     472                 :   29572700 :     begin_scope (sk, NULL);
     473                 :   29576700 :   return ret;
     474                 :            : }
     475                 :            : 
     476                 :            : /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
     477                 :            :    when the current scope is exited.  EH_ONLY is true when this is not
     478                 :            :    meant to apply to normal control flow transfer.  */
     479                 :            : 
     480                 :            : void
     481                 :    1796990 : push_cleanup (tree decl, tree cleanup, bool eh_only)
     482                 :            : {
     483                 :    1796990 :   tree stmt = build_stmt (input_location, CLEANUP_STMT, NULL, cleanup, decl);
     484                 :    1796990 :   CLEANUP_EH_ONLY (stmt) = eh_only;
     485                 :    1796990 :   add_stmt (stmt);
     486                 :    1796990 :   CLEANUP_BODY (stmt) = push_stmt_list ();
     487                 :    1796990 : }
     488                 :            : 
     489                 :            : /* Simple infinite loop tracking for -Wreturn-type.  We keep a stack of all
     490                 :            :    the current loops, represented by 'NULL_TREE' if we've seen a possible
     491                 :            :    exit, and 'error_mark_node' if not.  This is currently used only to
     492                 :            :    suppress the warning about a function with no return statements, and
     493                 :            :    therefore we don't bother noting returns as possible exits.  We also
     494                 :            :    don't bother with gotos.  */
     495                 :            : 
     496                 :            : static void
     497                 :     860750 : begin_maybe_infinite_loop (tree cond)
     498                 :            : {
     499                 :            :   /* Only track this while parsing a function, not during instantiation.  */
     500                 :     860750 :   if (!cfun || (DECL_TEMPLATE_INSTANTIATION (current_function_decl)
     501                 :     141931 :                 && !processing_template_decl))
     502                 :            :     return;
     503                 :     718535 :   bool maybe_infinite = true;
     504                 :     718535 :   if (cond)
     505                 :            :     {
     506                 :     700839 :       cond = fold_non_dependent_expr (cond);
     507                 :     700839 :       maybe_infinite = integer_nonzerop (cond);
     508                 :            :     }
     509                 :    1419370 :   vec_safe_push (cp_function_chain->infinite_loops,
     510                 :     718535 :                  maybe_infinite ? error_mark_node : NULL_TREE);
     511                 :            : 
     512                 :            : }
     513                 :            : 
     514                 :            : /* A break is a possible exit for the current loop.  */
     515                 :            : 
     516                 :            : void
     517                 :      83108 : break_maybe_infinite_loop (void)
     518                 :            : {
     519                 :      83108 :   if (!cfun)
     520                 :            :     return;
     521                 :      83108 :   cp_function_chain->infinite_loops->last() = NULL_TREE;
     522                 :            : }
     523                 :            : 
     524                 :            : /* If we reach the end of the loop without seeing a possible exit, we have
     525                 :            :    an infinite loop.  */
     526                 :            : 
     527                 :            : static void
     528                 :     860750 : end_maybe_infinite_loop (tree cond)
     529                 :            : {
     530                 :     860750 :   if (!cfun || (DECL_TEMPLATE_INSTANTIATION (current_function_decl)
     531                 :     141931 :                 && !processing_template_decl))
     532                 :            :     return;
     533                 :     718535 :   tree current = cp_function_chain->infinite_loops->pop();
     534                 :     718535 :   if (current != NULL_TREE)
     535                 :            :     {
     536                 :     193193 :       cond = fold_non_dependent_expr (cond);
     537                 :     193193 :       if (integer_nonzerop (cond))
     538                 :      18131 :         current_function_infinite_loop = 1;
     539                 :            :     }
     540                 :            : }
     541                 :            : 
     542                 :            : 
     543                 :            : /* Begin a conditional that might contain a declaration.  When generating
     544                 :            :    normal code, we want the declaration to appear before the statement
     545                 :            :    containing the conditional.  When generating template code, we want the
     546                 :            :    conditional to be rendered as the raw DECL_EXPR.  */
     547                 :            : 
     548                 :            : static void
     549                 :    4814240 : begin_cond (tree *cond_p)
     550                 :            : {
     551                 :          0 :   if (processing_template_decl)
     552                 :    2312450 :     *cond_p = push_stmt_list ();
     553                 :          0 : }
     554                 :            : 
     555                 :            : /* Finish such a conditional.  */
     556                 :            : 
     557                 :            : static void
     558                 :    4814240 : finish_cond (tree *cond_p, tree expr)
     559                 :            : {
     560                 :    4814240 :   if (processing_template_decl)
     561                 :            :     {
     562                 :    2312450 :       tree cond = pop_stmt_list (*cond_p);
     563                 :            : 
     564                 :    2312450 :       if (expr == NULL_TREE)
     565                 :            :         /* Empty condition in 'for'.  */
     566                 :      15665 :         gcc_assert (empty_expr_stmt_p (cond));
     567                 :    2296780 :       else if (check_for_bare_parameter_packs (expr))
     568                 :          0 :         expr = error_mark_node;
     569                 :    2296780 :       else if (!empty_expr_stmt_p (cond))
     570                 :      26283 :         expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), cond, expr);
     571                 :            :     }
     572                 :    4814240 :   *cond_p = expr;
     573                 :    4814240 : }
     574                 :            : 
     575                 :            : /* If *COND_P specifies a conditional with a declaration, transform the
     576                 :            :    loop such that
     577                 :            :             while (A x = 42) { }
     578                 :            :             for (; A x = 42;) { }
     579                 :            :    becomes
     580                 :            :             while (true) { A x = 42; if (!x) break; }
     581                 :            :             for (;;) { A x = 42; if (!x) break; }
     582                 :            :    The statement list for BODY will be empty if the conditional did
     583                 :            :    not declare anything.  */
     584                 :            : 
     585                 :            : static void
     586                 :     662419 : simplify_loop_decl_cond (tree *cond_p, tree body)
     587                 :            : {
     588                 :     662419 :   tree cond, if_stmt;
     589                 :            : 
     590                 :     662419 :   if (!TREE_SIDE_EFFECTS (body))
     591                 :            :     return;
     592                 :            : 
     593                 :        198 :   cond = *cond_p;
     594                 :        198 :   *cond_p = boolean_true_node;
     595                 :            : 
     596                 :        198 :   if_stmt = begin_if_stmt ();
     597                 :        198 :   cond = cp_build_unary_op (TRUTH_NOT_EXPR, cond, false, tf_warning_or_error);
     598                 :        198 :   finish_if_stmt_cond (cond, if_stmt);
     599                 :        198 :   finish_break_stmt ();
     600                 :        198 :   finish_then_clause (if_stmt);
     601                 :        198 :   finish_if_stmt (if_stmt);
     602                 :            : }
     603                 :            : 
     604                 :            : /* Finish a goto-statement.  */
     605                 :            : 
     606                 :            : tree
     607                 :       1249 : finish_goto_stmt (tree destination)
     608                 :            : {
     609                 :       1249 :   if (identifier_p (destination))
     610                 :       1004 :     destination = lookup_label (destination);
     611                 :            : 
     612                 :            :   /* We warn about unused labels with -Wunused.  That means we have to
     613                 :            :      mark the used labels as used.  */
     614                 :       1249 :   if (TREE_CODE (destination) == LABEL_DECL)
     615                 :       1131 :     TREE_USED (destination) = 1;
     616                 :            :   else
     617                 :            :     {
     618                 :        118 :       destination = mark_rvalue_use (destination);
     619                 :        118 :       if (!processing_template_decl)
     620                 :            :         {
     621                 :         94 :           destination = cp_convert (ptr_type_node, destination,
     622                 :            :                                     tf_warning_or_error);
     623                 :        176 :           if (error_operand_p (destination))
     624                 :            :             return NULL_TREE;
     625                 :         82 :           destination
     626                 :         82 :             = fold_build_cleanup_point_expr (TREE_TYPE (destination),
     627                 :            :                                              destination);
     628                 :            :         }
     629                 :            :     }
     630                 :            : 
     631                 :       1237 :   check_goto (destination);
     632                 :            : 
     633                 :       1237 :   add_stmt (build_predict_expr (PRED_GOTO, NOT_TAKEN));
     634                 :       1237 :   return add_stmt (build_stmt (input_location, GOTO_EXPR, destination));
     635                 :            : }
     636                 :            : 
     637                 :            : /* COND is the condition-expression for an if, while, etc.,
     638                 :            :    statement.  Convert it to a boolean value, if appropriate.
     639                 :            :    In addition, verify sequence points if -Wsequence-point is enabled.  */
     640                 :            : 
     641                 :            : static tree
     642                 :    4955760 : maybe_convert_cond (tree cond)
     643                 :            : {
     644                 :            :   /* Empty conditions remain empty.  */
     645                 :    4955760 :   if (!cond)
     646                 :            :     return NULL_TREE;
     647                 :            : 
     648                 :            :   /* Wait until we instantiate templates before doing conversion.  */
     649                 :    4924930 :   if (type_dependent_expression_p (cond))
     650                 :            :     return cond;
     651                 :            : 
     652                 :    3270970 :   if (warn_sequence_point && !processing_template_decl)
     653                 :     194369 :     verify_sequence_points (cond);
     654                 :            : 
     655                 :            :   /* Do the conversion.  */
     656                 :    3270970 :   cond = convert_from_reference (cond);
     657                 :            : 
     658                 :    3270970 :   if (TREE_CODE (cond) == MODIFY_EXPR
     659                 :    3270970 :       && !TREE_NO_WARNING (cond)
     660                 :        172 :       && warn_parentheses
     661                 :    3271130 :       && warning_at (cp_expr_loc_or_input_loc (cond),
     662                 :            :                      OPT_Wparentheses, "suggest parentheses around "
     663                 :            :                                        "assignment used as truth value"))
     664                 :        164 :     TREE_NO_WARNING (cond) = 1;
     665                 :            : 
     666                 :    3270970 :   return condition_conversion (cond);
     667                 :            : }
     668                 :            : 
     669                 :            : /* Finish an expression-statement, whose EXPRESSION is as indicated.  */
     670                 :            : 
     671                 :            : tree
     672                 :   15992900 : finish_expr_stmt (tree expr)
     673                 :            : {
     674                 :   15992900 :   tree r = NULL_TREE;
     675                 :   15992900 :   location_t loc = EXPR_LOCATION (expr);
     676                 :            : 
     677                 :   15992900 :   if (expr != NULL_TREE)
     678                 :            :     {
     679                 :            :       /* If we ran into a problem, make sure we complained.  */
     680                 :   15992500 :       gcc_assert (expr != error_mark_node || seen_error ());
     681                 :            : 
     682                 :   15992500 :       if (!processing_template_decl)
     683                 :            :         {
     684                 :   11347600 :           if (warn_sequence_point)
     685                 :     548257 :             verify_sequence_points (expr);
     686                 :   11347600 :           expr = convert_to_void (expr, ICV_STATEMENT, tf_warning_or_error);
     687                 :            :         }
     688                 :    4644940 :       else if (!type_dependent_expression_p (expr))
     689                 :     502590 :         convert_to_void (build_non_dependent_expr (expr), ICV_STATEMENT,
     690                 :            :                          tf_warning_or_error);
     691                 :            : 
     692                 :   15992500 :       if (check_for_bare_parameter_packs (expr))
     693                 :         21 :         expr = error_mark_node;
     694                 :            : 
     695                 :            :       /* Simplification of inner statement expressions, compound exprs,
     696                 :            :          etc can result in us already having an EXPR_STMT.  */
     697                 :   15992500 :       if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
     698                 :            :         {
     699                 :   15990800 :           if (TREE_CODE (expr) != EXPR_STMT)
     700                 :   15652000 :             expr = build_stmt (loc, EXPR_STMT, expr);
     701                 :   15990800 :           expr = maybe_cleanup_point_expr_void (expr);
     702                 :            :         }
     703                 :            : 
     704                 :   15992500 :       r = add_stmt (expr);
     705                 :            :     }
     706                 :            : 
     707                 :   15992900 :   return r;
     708                 :            : }
     709                 :            : 
     710                 :            : 
     711                 :            : /* Begin an if-statement.  Returns a newly created IF_STMT if
     712                 :            :    appropriate.  */
     713                 :            : 
     714                 :            : tree
     715                 :    4096440 : begin_if_stmt (void)
     716                 :            : {
     717                 :    4096440 :   tree r, scope;
     718                 :    4096440 :   scope = do_pushlevel (sk_cond);
     719                 :    4096440 :   r = build_stmt (input_location, IF_STMT, NULL_TREE,
     720                 :            :                   NULL_TREE, NULL_TREE, scope);
     721                 :    4096440 :   current_binding_level->this_entity = r;
     722                 :    4096440 :   begin_cond (&IF_COND (r));
     723                 :    4096440 :   return r;
     724                 :            : }
     725                 :            : 
     726                 :            : /* Returns true if FN, a CALL_EXPR, is a call to
     727                 :            :    std::is_constant_evaluated or __builtin_is_constant_evaluated.  */
     728                 :            : 
     729                 :            : static bool
     730                 :        140 : is_std_constant_evaluated_p (tree fn)
     731                 :            : {
     732                 :            :   /* std::is_constant_evaluated takes no arguments.  */
     733                 :        140 :   if (call_expr_nargs (fn) != 0)
     734                 :            :     return false;
     735                 :            : 
     736                 :         26 :   tree fndecl = cp_get_callee_fndecl_nofold (fn);
     737                 :         26 :   if (fndecl == NULL_TREE)
     738                 :            :     return false;
     739                 :            : 
     740                 :         24 :   if (fndecl_built_in_p (fndecl, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
     741                 :            :                          BUILT_IN_FRONTEND))
     742                 :            :     return true;
     743                 :            : 
     744                 :         23 :   if (!decl_in_std_namespace_p (fndecl))
     745                 :            :     return false;
     746                 :            : 
     747                 :         23 :   tree name = DECL_NAME (fndecl);
     748                 :         23 :   return name && id_equal (name, "is_constant_evaluated");
     749                 :            : }
     750                 :            : 
     751                 :            : /* Process the COND of an if-statement, which may be given by
     752                 :            :    IF_STMT.  */
     753                 :            : 
     754                 :            : tree
     755                 :    4096440 : finish_if_stmt_cond (tree cond, tree if_stmt)
     756                 :            : {
     757                 :    4096440 :   cond = maybe_convert_cond (cond);
     758                 :    4096440 :   if (IF_STMT_CONSTEXPR_P (if_stmt)
     759                 :     173279 :       && !type_dependent_expression_p (cond)
     760                 :     140660 :       && require_constant_expression (cond)
     761                 :     140648 :       && !instantiation_dependent_expression_p (cond)
     762                 :            :       /* Wait until instantiation time, since only then COND has been
     763                 :            :          converted to bool.  */
     764                 :    4151330 :       && TYPE_MAIN_VARIANT (TREE_TYPE (cond)) == boolean_type_node)
     765                 :            :     {
     766                 :            :       /* if constexpr (std::is_constant_evaluated()) is always true,
     767                 :            :          so give the user a clue.  */
     768                 :      54891 :       if (warn_tautological_compare)
     769                 :            :         {
     770                 :        554 :           tree t = cond;
     771                 :        554 :           if (TREE_CODE (t) == CLEANUP_POINT_EXPR)
     772                 :        147 :             t = TREE_OPERAND (t, 0);
     773                 :        554 :           if (TREE_CODE (t) == CALL_EXPR
     774                 :        554 :               && is_std_constant_evaluated_p (t))
     775                 :          2 :             warning_at (EXPR_LOCATION (cond), OPT_Wtautological_compare,
     776                 :            :                         "%qs always evaluates to true in %<if constexpr%>",
     777                 :            :                         "std::is_constant_evaluated");
     778                 :            :         }
     779                 :            : 
     780                 :      54891 :       cond = instantiate_non_dependent_expr (cond);
     781                 :      54891 :       cond = cxx_constant_value (cond, NULL_TREE);
     782                 :            :     }
     783                 :    4096440 :   finish_cond (&IF_COND (if_stmt), cond);
     784                 :    4096440 :   add_stmt (if_stmt);
     785                 :    4096440 :   THEN_CLAUSE (if_stmt) = push_stmt_list ();
     786                 :    4096440 :   return cond;
     787                 :            : }
     788                 :            : 
     789                 :            : /* Finish the then-clause of an if-statement, which may be given by
     790                 :            :    IF_STMT.  */
     791                 :            : 
     792                 :            : tree
     793                 :    4096380 : finish_then_clause (tree if_stmt)
     794                 :            : {
     795                 :    4096380 :   THEN_CLAUSE (if_stmt) = pop_stmt_list (THEN_CLAUSE (if_stmt));
     796                 :    4096380 :   return if_stmt;
     797                 :            : }
     798                 :            : 
     799                 :            : /* Begin the else-clause of an if-statement.  */
     800                 :            : 
     801                 :            : void
     802                 :    1271410 : begin_else_clause (tree if_stmt)
     803                 :            : {
     804                 :    1271410 :   ELSE_CLAUSE (if_stmt) = push_stmt_list ();
     805                 :    1271410 : }
     806                 :            : 
     807                 :            : /* Finish the else-clause of an if-statement, which may be given by
     808                 :            :    IF_STMT.  */
     809                 :            : 
     810                 :            : void
     811                 :    1271410 : finish_else_clause (tree if_stmt)
     812                 :            : {
     813                 :    1271410 :   ELSE_CLAUSE (if_stmt) = pop_stmt_list (ELSE_CLAUSE (if_stmt));
     814                 :    1271410 : }
     815                 :            : 
     816                 :            : /* Callback for cp_walk_tree to mark all {VAR,PARM}_DECLs in a tree as
     817                 :            :    read.  */
     818                 :            : 
     819                 :            : static tree
     820                 :    7186320 : maybe_mark_exp_read_r (tree *tp, int *, void *)
     821                 :            : {
     822                 :    7186320 :   tree t = *tp;
     823                 :    7186320 :   if (VAR_P (t) || TREE_CODE (t) == PARM_DECL)
     824                 :     532662 :     mark_exp_read (t);
     825                 :    7186320 :   return NULL_TREE;
     826                 :            : }
     827                 :            : 
     828                 :            : /* Finish an if-statement.  */
     829                 :            : 
     830                 :            : void
     831                 :    4094810 : finish_if_stmt (tree if_stmt)
     832                 :            : {
     833                 :    4094810 :   tree scope = IF_SCOPE (if_stmt);
     834                 :    4094810 :   IF_SCOPE (if_stmt) = NULL;
     835                 :    4094810 :   if (IF_STMT_CONSTEXPR_P (if_stmt))
     836                 :            :     {
     837                 :            :       /* Prevent various -Wunused warnings.  We might not instantiate
     838                 :            :          either of these branches, so we would not mark the variables
     839                 :            :          used in that branch as read.  */
     840                 :     173215 :       cp_walk_tree_without_duplicates (&THEN_CLAUSE (if_stmt),
     841                 :            :                                        maybe_mark_exp_read_r, NULL);
     842                 :     173215 :       cp_walk_tree_without_duplicates (&ELSE_CLAUSE (if_stmt),
     843                 :            :                                        maybe_mark_exp_read_r, NULL);
     844                 :            :     }
     845                 :    4094810 :   add_stmt (do_poplevel (scope));
     846                 :    4094810 : }
     847                 :            : 
     848                 :            : /* Begin a while-statement.  Returns a newly created WHILE_STMT if
     849                 :            :    appropriate.  */
     850                 :            : 
     851                 :            : tree
     852                 :     261393 : begin_while_stmt (void)
     853                 :            : {
     854                 :     261393 :   tree r;
     855                 :     261393 :   r = build_stmt (input_location, WHILE_STMT, NULL_TREE, NULL_TREE);
     856                 :     261393 :   add_stmt (r);
     857                 :     261393 :   WHILE_BODY (r) = do_pushlevel (sk_block);
     858                 :     261393 :   begin_cond (&WHILE_COND (r));
     859                 :     261393 :   return r;
     860                 :            : }
     861                 :            : 
     862                 :            : /* Process the COND of a while-statement, which may be given by
     863                 :            :    WHILE_STMT.  */
     864                 :            : 
     865                 :            : void
     866                 :     261393 : finish_while_stmt_cond (tree cond, tree while_stmt, bool ivdep,
     867                 :            :                         unsigned short unroll)
     868                 :            : {
     869                 :     261393 :   cond = maybe_convert_cond (cond);
     870                 :     261393 :   finish_cond (&WHILE_COND (while_stmt), cond);
     871                 :     261393 :   begin_maybe_infinite_loop (cond);
     872                 :     261393 :   if (ivdep && cond != error_mark_node)
     873                 :         12 :     WHILE_COND (while_stmt) = build3 (ANNOTATE_EXPR,
     874                 :          4 :                                       TREE_TYPE (WHILE_COND (while_stmt)),
     875                 :          4 :                                       WHILE_COND (while_stmt),
     876                 :            :                                       build_int_cst (integer_type_node,
     877                 :          4 :                                                      annot_expr_ivdep_kind),
     878                 :            :                                       integer_zero_node);
     879                 :     261393 :   if (unroll && cond != error_mark_node)
     880                 :          0 :     WHILE_COND (while_stmt) = build3 (ANNOTATE_EXPR,
     881                 :          0 :                                       TREE_TYPE (WHILE_COND (while_stmt)),
     882                 :          0 :                                       WHILE_COND (while_stmt),
     883                 :            :                                       build_int_cst (integer_type_node,
     884                 :          0 :                                                      annot_expr_unroll_kind),
     885                 :            :                                       build_int_cst (integer_type_node,
     886                 :            :                                                      unroll));
     887                 :     261393 :   simplify_loop_decl_cond (&WHILE_COND (while_stmt), WHILE_BODY (while_stmt));
     888                 :     261393 : }
     889                 :            : 
     890                 :            : /* Finish a while-statement, which may be given by WHILE_STMT.  */
     891                 :            : 
     892                 :            : void
     893                 :     261393 : finish_while_stmt (tree while_stmt)
     894                 :            : {
     895                 :     261393 :   end_maybe_infinite_loop (boolean_true_node);
     896                 :     261393 :   WHILE_BODY (while_stmt) = do_poplevel (WHILE_BODY (while_stmt));
     897                 :     261393 : }
     898                 :            : 
     899                 :            : /* Begin a do-statement.  Returns a newly created DO_STMT if
     900                 :            :    appropriate.  */
     901                 :            : 
     902                 :            : tree
     903                 :     195395 : begin_do_stmt (void)
     904                 :            : {
     905                 :     195395 :   tree r = build_stmt (input_location, DO_STMT, NULL_TREE, NULL_TREE);
     906                 :     195395 :   begin_maybe_infinite_loop (boolean_true_node);
     907                 :     195395 :   add_stmt (r);
     908                 :     195395 :   DO_BODY (r) = push_stmt_list ();
     909                 :     195395 :   return r;
     910                 :            : }
     911                 :            : 
     912                 :            : /* Finish the body of a do-statement, which may be given by DO_STMT.  */
     913                 :            : 
     914                 :            : void
     915                 :     195395 : finish_do_body (tree do_stmt)
     916                 :            : {
     917                 :     195395 :   tree body = DO_BODY (do_stmt) = pop_stmt_list (DO_BODY (do_stmt));
     918                 :            : 
     919                 :     195395 :   if (TREE_CODE (body) == STATEMENT_LIST && STATEMENT_LIST_TAIL (body))
     920                 :      47678 :     body = STATEMENT_LIST_TAIL (body)->stmt;
     921                 :            : 
     922                 :     195411 :   if (IS_EMPTY_STMT (body))
     923                 :         16 :     warning (OPT_Wempty_body,
     924                 :            :             "suggest explicit braces around empty body in %<do%> statement");
     925                 :     195395 : }
     926                 :            : 
     927                 :            : /* Finish a do-statement, which may be given by DO_STMT, and whose
     928                 :            :    COND is as indicated.  */
     929                 :            : 
     930                 :            : void
     931                 :     195395 : finish_do_stmt (tree cond, tree do_stmt, bool ivdep, unsigned short unroll)
     932                 :            : {
     933                 :     195395 :   cond = maybe_convert_cond (cond);
     934                 :     195395 :   end_maybe_infinite_loop (cond);
     935                 :     195395 :   if (ivdep && cond != error_mark_node)
     936                 :          4 :     cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
     937                 :          4 :                    build_int_cst (integer_type_node, annot_expr_ivdep_kind),
     938                 :            :                    integer_zero_node);
     939                 :     195395 :   if (unroll && cond != error_mark_node)
     940                 :         12 :     cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
     941                 :         12 :                    build_int_cst (integer_type_node, annot_expr_unroll_kind),
     942                 :            :                    build_int_cst (integer_type_node, unroll));
     943                 :     195395 :   DO_COND (do_stmt) = cond;
     944                 :     195395 : }
     945                 :            : 
     946                 :            : /* Finish a return-statement.  The EXPRESSION returned, if any, is as
     947                 :            :    indicated.  */
     948                 :            : 
     949                 :            : tree
     950                 :   10941400 : finish_return_stmt (tree expr)
     951                 :            : {
     952                 :   10941400 :   tree r;
     953                 :   10941400 :   bool no_warning;
     954                 :            : 
     955                 :   10941400 :   expr = check_return_expr (expr, &no_warning);
     956                 :            : 
     957                 :   21746400 :   if (error_operand_p (expr)
     958                 :   21881800 :       || (flag_openmp && !check_omp_return ()))
     959                 :            :     {
     960                 :            :       /* Suppress -Wreturn-type for this function.  */
     961                 :        979 :       if (warn_return_type)
     962                 :        972 :         TREE_NO_WARNING (current_function_decl) = true;
     963                 :        979 :       return error_mark_node;
     964                 :            :     }
     965                 :            : 
     966                 :   10940400 :   if (!processing_template_decl)
     967                 :            :     {
     968                 :    6333680 :       if (warn_sequence_point)
     969                 :     683691 :         verify_sequence_points (expr);
     970                 :            : 
     971                 :    6333680 :       if (DECL_DESTRUCTOR_P (current_function_decl)
     972                 :   12667200 :           || (DECL_CONSTRUCTOR_P (current_function_decl)
     973                 :    6333680 :               && targetm.cxx.cdtor_returns_this ()))
     974                 :            :         {
     975                 :            :           /* Similarly, all destructors must run destructors for
     976                 :            :              base-classes before returning.  So, all returns in a
     977                 :            :              destructor get sent to the DTOR_LABEL; finish_function emits
     978                 :            :              code to return a value there.  */
     979                 :        127 :           return finish_goto_stmt (cdtor_label);
     980                 :            :         }
     981                 :            :     }
     982                 :            : 
     983                 :   10940300 :   r = build_stmt (input_location, RETURN_EXPR, expr);
     984                 :   10940300 :   TREE_NO_WARNING (r) |= no_warning;
     985                 :   10940300 :   r = maybe_cleanup_point_expr_void (r);
     986                 :   10940300 :   r = add_stmt (r);
     987                 :            : 
     988                 :   10940300 :   return r;
     989                 :            : }
     990                 :            : 
     991                 :            : /* Begin the scope of a for-statement or a range-for-statement.
     992                 :            :    Both the returned trees are to be used in a call to
     993                 :            :    begin_for_stmt or begin_range_for_stmt.  */
     994                 :            : 
     995                 :            : tree
     996                 :     403962 : begin_for_scope (tree *init)
     997                 :            : {
     998                 :     403962 :   tree scope = do_pushlevel (sk_for);
     999                 :            : 
    1000                 :     403962 :   if (processing_template_decl)
    1001                 :     277340 :     *init = push_stmt_list ();
    1002                 :            :   else
    1003                 :     126622 :     *init = NULL_TREE;
    1004                 :            : 
    1005                 :     403962 :   return scope;
    1006                 :            : }
    1007                 :            : 
    1008                 :            : /* Begin a for-statement.  Returns a new FOR_STMT.
    1009                 :            :    SCOPE and INIT should be the return of begin_for_scope,
    1010                 :            :    or both NULL_TREE  */
    1011                 :            : 
    1012                 :            : tree
    1013                 :     401026 : begin_for_stmt (tree scope, tree init)
    1014                 :            : {
    1015                 :     401026 :   tree r;
    1016                 :            : 
    1017                 :     401026 :   r = build_stmt (input_location, FOR_STMT, NULL_TREE, NULL_TREE,
    1018                 :            :                   NULL_TREE, NULL_TREE, NULL_TREE);
    1019                 :            : 
    1020                 :     401026 :   if (scope == NULL_TREE)
    1021                 :            :     {
    1022                 :      75978 :       gcc_assert (!init);
    1023                 :      75978 :       scope = begin_for_scope (&init);
    1024                 :            :     }
    1025                 :            : 
    1026                 :     401026 :   FOR_INIT_STMT (r) = init;
    1027                 :     401026 :   FOR_SCOPE (r) = scope;
    1028                 :            : 
    1029                 :     401026 :   return r;
    1030                 :            : }
    1031                 :            : 
    1032                 :            : /* Finish the init-statement of a for-statement, which may be
    1033                 :            :    given by FOR_STMT.  */
    1034                 :            : 
    1035                 :            : void
    1036                 :     401026 : finish_init_stmt (tree for_stmt)
    1037                 :            : {
    1038                 :     401026 :   if (processing_template_decl)
    1039                 :     274404 :     FOR_INIT_STMT (for_stmt) = pop_stmt_list (FOR_INIT_STMT (for_stmt));
    1040                 :     401026 :   add_stmt (for_stmt);
    1041                 :     401026 :   FOR_BODY (for_stmt) = do_pushlevel (sk_block);
    1042                 :     401026 :   begin_cond (&FOR_COND (for_stmt));
    1043                 :     401026 : }
    1044                 :            : 
    1045                 :            : /* Finish the COND of a for-statement, which may be given by
    1046                 :            :    FOR_STMT.  */
    1047                 :            : 
    1048                 :            : void
    1049                 :     401026 : finish_for_cond (tree cond, tree for_stmt, bool ivdep, unsigned short unroll)
    1050                 :            : {
    1051                 :     401026 :   cond = maybe_convert_cond (cond);
    1052                 :     401026 :   finish_cond (&FOR_COND (for_stmt), cond);
    1053                 :     401026 :   begin_maybe_infinite_loop (cond);
    1054                 :     401026 :   if (ivdep && cond != error_mark_node)
    1055                 :        123 :     FOR_COND (for_stmt) = build3 (ANNOTATE_EXPR,
    1056                 :         41 :                                   TREE_TYPE (FOR_COND (for_stmt)),
    1057                 :         41 :                                   FOR_COND (for_stmt),
    1058                 :            :                                   build_int_cst (integer_type_node,
    1059                 :         41 :                                                  annot_expr_ivdep_kind),
    1060                 :            :                                   integer_zero_node);
    1061                 :     401026 :   if (unroll && cond != error_mark_node)
    1062                 :        258 :     FOR_COND (for_stmt) = build3 (ANNOTATE_EXPR,
    1063                 :         86 :                                   TREE_TYPE (FOR_COND (for_stmt)),
    1064                 :         86 :                                   FOR_COND (for_stmt),
    1065                 :            :                                   build_int_cst (integer_type_node,
    1066                 :         86 :                                                  annot_expr_unroll_kind),
    1067                 :            :                                   build_int_cst (integer_type_node,
    1068                 :            :                                                  unroll));
    1069                 :     401026 :   simplify_loop_decl_cond (&FOR_COND (for_stmt), FOR_BODY (for_stmt));
    1070                 :     401026 : }
    1071                 :            : 
    1072                 :            : /* Finish the increment-EXPRESSION in a for-statement, which may be
    1073                 :            :    given by FOR_STMT.  */
    1074                 :            : 
    1075                 :            : void
    1076                 :     401026 : finish_for_expr (tree expr, tree for_stmt)
    1077                 :            : {
    1078                 :     401026 :   if (!expr)
    1079                 :            :     return;
    1080                 :            :   /* If EXPR is an overloaded function, issue an error; there is no
    1081                 :            :      context available to use to perform overload resolution.  */
    1082                 :     366019 :   if (type_unknown_p (expr))
    1083                 :            :     {
    1084                 :          8 :       cxx_incomplete_type_error (expr, TREE_TYPE (expr));
    1085                 :          8 :       expr = error_mark_node;
    1086                 :            :     }
    1087                 :     366019 :   if (!processing_template_decl)
    1088                 :            :     {
    1089                 :     112226 :       if (warn_sequence_point)
    1090                 :       7037 :         verify_sequence_points (expr);
    1091                 :     112226 :       expr = convert_to_void (expr, ICV_THIRD_IN_FOR,
    1092                 :            :                               tf_warning_or_error);
    1093                 :            :     }
    1094                 :     253793 :   else if (!type_dependent_expression_p (expr))
    1095                 :      75392 :     convert_to_void (build_non_dependent_expr (expr), ICV_THIRD_IN_FOR,
    1096                 :            :                      tf_warning_or_error);
    1097                 :     366019 :   expr = maybe_cleanup_point_expr_void (expr);
    1098                 :     366019 :   if (check_for_bare_parameter_packs (expr))
    1099                 :          0 :     expr = error_mark_node;
    1100                 :     366019 :   FOR_EXPR (for_stmt) = expr;
    1101                 :            : }
    1102                 :            : 
    1103                 :            : /* Finish the body of a for-statement, which may be given by
    1104                 :            :    FOR_STMT.  The increment-EXPR for the loop must be
    1105                 :            :    provided.
    1106                 :            :    It can also finish RANGE_FOR_STMT. */
    1107                 :            : 
    1108                 :            : void
    1109                 :     403962 : finish_for_stmt (tree for_stmt)
    1110                 :            : {
    1111                 :     403962 :   end_maybe_infinite_loop (boolean_true_node);
    1112                 :            : 
    1113                 :     403962 :   if (TREE_CODE (for_stmt) == RANGE_FOR_STMT)
    1114                 :       2936 :     RANGE_FOR_BODY (for_stmt) = do_poplevel (RANGE_FOR_BODY (for_stmt));
    1115                 :            :   else
    1116                 :     401026 :     FOR_BODY (for_stmt) = do_poplevel (FOR_BODY (for_stmt));
    1117                 :            : 
    1118                 :            :   /* Pop the scope for the body of the loop.  */
    1119                 :     403962 :   tree *scope_ptr = (TREE_CODE (for_stmt) == RANGE_FOR_STMT
    1120                 :     403962 :                      ? &RANGE_FOR_SCOPE (for_stmt)
    1121                 :     401026 :                      : &FOR_SCOPE (for_stmt));
    1122                 :     403962 :   tree scope = *scope_ptr;
    1123                 :     403962 :   *scope_ptr = NULL;
    1124                 :            : 
    1125                 :            :   /* During parsing of the body, range for uses "__for_{range,begin,end} "
    1126                 :            :      decl names to make those unaccessible by code in the body.
    1127                 :            :      Change it to ones with underscore instead of space, so that it can
    1128                 :            :      be inspected in the debugger.  */
    1129                 :     403962 :   tree range_for_decl[3] = { NULL_TREE, NULL_TREE, NULL_TREE };
    1130                 :     403962 :   gcc_assert (CPTI_FOR_BEGIN__IDENTIFIER == CPTI_FOR_RANGE__IDENTIFIER + 1
    1131                 :            :               && CPTI_FOR_END__IDENTIFIER == CPTI_FOR_RANGE__IDENTIFIER + 2
    1132                 :            :               && CPTI_FOR_RANGE_IDENTIFIER == CPTI_FOR_RANGE__IDENTIFIER + 3
    1133                 :            :               && CPTI_FOR_BEGIN_IDENTIFIER == CPTI_FOR_BEGIN__IDENTIFIER + 3
    1134                 :            :               && CPTI_FOR_END_IDENTIFIER == CPTI_FOR_END__IDENTIFIER + 3);
    1135                 :    1615850 :   for (int i = 0; i < 3; i++)
    1136                 :            :     {
    1137                 :    1211890 :       tree id = cp_global_trees[CPTI_FOR_RANGE__IDENTIFIER + i];
    1138                 :    1211890 :       if (IDENTIFIER_BINDING (id)
    1139                 :    1211890 :           && IDENTIFIER_BINDING (id)->scope == current_binding_level)
    1140                 :            :         {
    1141                 :      11383 :           range_for_decl[i] = IDENTIFIER_BINDING (id)->value;
    1142                 :      11383 :           gcc_assert (VAR_P (range_for_decl[i])
    1143                 :            :                       && DECL_ARTIFICIAL (range_for_decl[i]));
    1144                 :            :         }
    1145                 :            :     }
    1146                 :            : 
    1147                 :     403962 :   add_stmt (do_poplevel (scope));
    1148                 :            : 
    1149                 :    1615850 :   for (int i = 0; i < 3; i++)
    1150                 :    1211890 :     if (range_for_decl[i])
    1151                 :      22766 :       DECL_NAME (range_for_decl[i])
    1152                 :      11383 :         = cp_global_trees[CPTI_FOR_RANGE_IDENTIFIER + i];
    1153                 :     403962 : }
    1154                 :            : 
    1155                 :            : /* Begin a range-for-statement.  Returns a new RANGE_FOR_STMT.
    1156                 :            :    SCOPE and INIT should be the return of begin_for_scope,
    1157                 :            :    or both NULL_TREE  .
    1158                 :            :    To finish it call finish_for_stmt(). */
    1159                 :            : 
    1160                 :            : tree
    1161                 :       2936 : begin_range_for_stmt (tree scope, tree init)
    1162                 :            : {
    1163                 :       2936 :   begin_maybe_infinite_loop (boolean_false_node);
    1164                 :            : 
    1165                 :       2936 :   tree r = build_stmt (input_location, RANGE_FOR_STMT, NULL_TREE, NULL_TREE,
    1166                 :            :                        NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
    1167                 :            : 
    1168                 :       2936 :   if (scope == NULL_TREE)
    1169                 :            :     {
    1170                 :          6 :       gcc_assert (!init);
    1171                 :          6 :       scope = begin_for_scope (&init);
    1172                 :            :     }
    1173                 :            : 
    1174                 :            :   /* Since C++20, RANGE_FOR_STMTs can use the init tree, so save it.  */
    1175                 :       2936 :   RANGE_FOR_INIT_STMT (r) = init;
    1176                 :       2936 :   RANGE_FOR_SCOPE (r) = scope;
    1177                 :            : 
    1178                 :       2936 :   return r;
    1179                 :            : }
    1180                 :            : 
    1181                 :            : /* Finish the head of a range-based for statement, which may
    1182                 :            :    be given by RANGE_FOR_STMT.  DECL must be the declaration
    1183                 :            :    and EXPR must be the loop expression. */
    1184                 :            : 
    1185                 :            : void
    1186                 :       2936 : finish_range_for_decl (tree range_for_stmt, tree decl, tree expr)
    1187                 :            : {
    1188                 :       2936 :   if (processing_template_decl)
    1189                 :       5872 :     RANGE_FOR_INIT_STMT (range_for_stmt)
    1190                 :       2936 :       = pop_stmt_list (RANGE_FOR_INIT_STMT (range_for_stmt));
    1191                 :       2936 :   RANGE_FOR_DECL (range_for_stmt) = decl;
    1192                 :       2936 :   RANGE_FOR_EXPR (range_for_stmt) = expr;
    1193                 :       2936 :   add_stmt (range_for_stmt);
    1194                 :       2936 :   RANGE_FOR_BODY (range_for_stmt) = do_pushlevel (sk_block);
    1195                 :       2936 : }
    1196                 :            : 
    1197                 :            : /* Finish a break-statement.  */
    1198                 :            : 
    1199                 :            : tree
    1200                 :     260653 : finish_break_stmt (void)
    1201                 :            : {
    1202                 :            :   /* In switch statements break is sometimes stylistically used after
    1203                 :            :      a return statement.  This can lead to spurious warnings about
    1204                 :            :      control reaching the end of a non-void function when it is
    1205                 :            :      inlined.  Note that we are calling block_may_fallthru with
    1206                 :            :      language specific tree nodes; this works because
    1207                 :            :      block_may_fallthru returns true when given something it does not
    1208                 :            :      understand.  */
    1209                 :     260653 :   if (!block_may_fallthru (cur_stmt_list))
    1210                 :       1153 :     return void_node;
    1211                 :     259500 :   note_break_stmt ();
    1212                 :     259500 :   return add_stmt (build_stmt (input_location, BREAK_STMT));
    1213                 :            : }
    1214                 :            : 
    1215                 :            : /* Finish a continue-statement.  */
    1216                 :            : 
    1217                 :            : tree
    1218                 :       9297 : finish_continue_stmt (void)
    1219                 :            : {
    1220                 :       9297 :   return add_stmt (build_stmt (input_location, CONTINUE_STMT));
    1221                 :            : }
    1222                 :            : 
    1223                 :            : /* Begin a switch-statement.  Returns a new SWITCH_STMT if
    1224                 :            :    appropriate.  */
    1225                 :            : 
    1226                 :            : tree
    1227                 :      55386 : begin_switch_stmt (void)
    1228                 :            : {
    1229                 :      55386 :   tree r, scope;
    1230                 :            : 
    1231                 :      55386 :   scope = do_pushlevel (sk_cond);
    1232                 :      55386 :   r = build_stmt (input_location, SWITCH_STMT, NULL_TREE, NULL_TREE, NULL_TREE, scope);
    1233                 :            : 
    1234                 :      55386 :   begin_cond (&SWITCH_STMT_COND (r));
    1235                 :            : 
    1236                 :      55386 :   return r;
    1237                 :            : }
    1238                 :            : 
    1239                 :            : /* Finish the cond of a switch-statement.  */
    1240                 :            : 
    1241                 :            : void
    1242                 :      55386 : finish_switch_cond (tree cond, tree switch_stmt)
    1243                 :            : {
    1244                 :      55386 :   tree orig_type = NULL;
    1245                 :            : 
    1246                 :      55386 :   if (!processing_template_decl)
    1247                 :            :     {
    1248                 :            :       /* Convert the condition to an integer or enumeration type.  */
    1249                 :      43323 :       tree orig_cond = cond;
    1250                 :      43323 :       cond = build_expr_type_conversion (WANT_INT | WANT_ENUM, cond, true);
    1251                 :      43323 :       if (cond == NULL_TREE)
    1252                 :            :         {
    1253                 :         30 :           error_at (cp_expr_loc_or_input_loc (orig_cond),
    1254                 :            :                     "switch quantity not an integer");
    1255                 :         15 :           cond = error_mark_node;
    1256                 :            :         }
    1257                 :            :       /* We want unlowered type here to handle enum bit-fields.  */
    1258                 :      43323 :       orig_type = unlowered_expr_type (cond);
    1259                 :      43323 :       if (TREE_CODE (orig_type) != ENUMERAL_TYPE)
    1260                 :      11805 :         orig_type = TREE_TYPE (cond);
    1261                 :      43323 :       if (cond != error_mark_node)
    1262                 :            :         {
    1263                 :            :           /* [stmt.switch]
    1264                 :            : 
    1265                 :            :              Integral promotions are performed.  */
    1266                 :      43300 :           cond = perform_integral_promotions (cond);
    1267                 :      43300 :           cond = maybe_cleanup_point_expr (cond);
    1268                 :            :         }
    1269                 :            :     }
    1270                 :      55386 :   if (check_for_bare_parameter_packs (cond))
    1271                 :          0 :     cond = error_mark_node;
    1272                 :      55386 :   else if (!processing_template_decl && warn_sequence_point)
    1273                 :       2020 :     verify_sequence_points (cond);
    1274                 :            : 
    1275                 :      55386 :   finish_cond (&SWITCH_STMT_COND (switch_stmt), cond);
    1276                 :      55386 :   SWITCH_STMT_TYPE (switch_stmt) = orig_type;
    1277                 :      55386 :   add_stmt (switch_stmt);
    1278                 :      55386 :   push_switch (switch_stmt);
    1279                 :      55386 :   SWITCH_STMT_BODY (switch_stmt) = push_stmt_list ();
    1280                 :      55386 : }
    1281                 :            : 
    1282                 :            : /* Finish the body of a switch-statement, which may be given by
    1283                 :            :    SWITCH_STMT.  The COND to switch on is indicated.  */
    1284                 :            : 
    1285                 :            : void
    1286                 :      53160 : finish_switch_stmt (tree switch_stmt)
    1287                 :            : {
    1288                 :      53160 :   tree scope;
    1289                 :            : 
    1290                 :     106320 :   SWITCH_STMT_BODY (switch_stmt) =
    1291                 :      53160 :     pop_stmt_list (SWITCH_STMT_BODY (switch_stmt));
    1292                 :      53160 :   pop_switch ();
    1293                 :            : 
    1294                 :      53160 :   scope = SWITCH_STMT_SCOPE (switch_stmt);
    1295                 :      53160 :   SWITCH_STMT_SCOPE (switch_stmt) = NULL;
    1296                 :      53160 :   add_stmt (do_poplevel (scope));
    1297                 :      53160 : }
    1298                 :            : 
    1299                 :            : /* Begin a try-block.  Returns a newly-created TRY_BLOCK if
    1300                 :            :    appropriate.  */
    1301                 :            : 
    1302                 :            : tree
    1303                 :     189307 : begin_try_block (void)
    1304                 :            : {
    1305                 :     189307 :   tree r = build_stmt (input_location, TRY_BLOCK, NULL_TREE, NULL_TREE);
    1306                 :     189307 :   add_stmt (r);
    1307                 :     189307 :   TRY_STMTS (r) = push_stmt_list ();
    1308                 :     189307 :   return r;
    1309                 :            : }
    1310                 :            : 
    1311                 :            : /* Likewise, for a function-try-block.  The block returned in
    1312                 :            :    *COMPOUND_STMT is an artificial outer scope, containing the
    1313                 :            :    function-try-block.  */
    1314                 :            : 
    1315                 :            : tree
    1316                 :        237 : begin_function_try_block (tree *compound_stmt)
    1317                 :            : {
    1318                 :        237 :   tree r;
    1319                 :            :   /* This outer scope does not exist in the C++ standard, but we need
    1320                 :            :      a place to put __FUNCTION__ and similar variables.  */
    1321                 :        237 :   *compound_stmt = begin_compound_stmt (0);
    1322                 :        237 :   r = begin_try_block ();
    1323                 :        237 :   FN_TRY_BLOCK_P (r) = 1;
    1324                 :        237 :   return r;
    1325                 :            : }
    1326                 :            : 
    1327                 :            : /* Finish a try-block, which may be given by TRY_BLOCK.  */
    1328                 :            : 
    1329                 :            : void
    1330                 :     188058 : finish_try_block (tree try_block)
    1331                 :            : {
    1332                 :     188058 :   TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
    1333                 :     188058 :   TRY_HANDLERS (try_block) = push_stmt_list ();
    1334                 :     188058 : }
    1335                 :            : 
    1336                 :            : /* Finish the body of a cleanup try-block, which may be given by
    1337                 :            :    TRY_BLOCK.  */
    1338                 :            : 
    1339                 :            : void
    1340                 :       1249 : finish_cleanup_try_block (tree try_block)
    1341                 :            : {
    1342                 :       1249 :   TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
    1343                 :       1249 : }
    1344                 :            : 
    1345                 :            : /* Finish an implicitly generated try-block, with a cleanup is given
    1346                 :            :    by CLEANUP.  */
    1347                 :            : 
    1348                 :            : void
    1349                 :       1249 : finish_cleanup (tree cleanup, tree try_block)
    1350                 :            : {
    1351                 :       1249 :   TRY_HANDLERS (try_block) = cleanup;
    1352                 :       1249 :   CLEANUP_P (try_block) = 1;
    1353                 :       1249 : }
    1354                 :            : 
    1355                 :            : /* Likewise, for a function-try-block.  */
    1356                 :            : 
    1357                 :            : void
    1358                 :        237 : finish_function_try_block (tree try_block)
    1359                 :            : {
    1360                 :        237 :   finish_try_block (try_block);
    1361                 :            :   /* FIXME : something queer about CTOR_INITIALIZER somehow following
    1362                 :            :      the try block, but moving it inside.  */
    1363                 :        237 :   in_function_try_handler = 1;
    1364                 :        237 : }
    1365                 :            : 
    1366                 :            : /* Finish a handler-sequence for a try-block, which may be given by
    1367                 :            :    TRY_BLOCK.  */
    1368                 :            : 
    1369                 :            : void
    1370                 :     188058 : finish_handler_sequence (tree try_block)
    1371                 :            : {
    1372                 :     188058 :   TRY_HANDLERS (try_block) = pop_stmt_list (TRY_HANDLERS (try_block));
    1373                 :     188058 :   check_handlers (TRY_HANDLERS (try_block));
    1374                 :     188058 : }
    1375                 :            : 
    1376                 :            : /* Finish the handler-seq for a function-try-block, given by
    1377                 :            :    TRY_BLOCK.  COMPOUND_STMT is the outer block created by
    1378                 :            :    begin_function_try_block.  */
    1379                 :            : 
    1380                 :            : void
    1381                 :        237 : finish_function_handler_sequence (tree try_block, tree compound_stmt)
    1382                 :            : {
    1383                 :        237 :   in_function_try_handler = 0;
    1384                 :        237 :   finish_handler_sequence (try_block);
    1385                 :        237 :   finish_compound_stmt (compound_stmt);
    1386                 :        237 : }
    1387                 :            : 
    1388                 :            : /* Begin a handler.  Returns a HANDLER if appropriate.  */
    1389                 :            : 
    1390                 :            : tree
    1391                 :     230294 : begin_handler (void)
    1392                 :            : {
    1393                 :     230294 :   tree r;
    1394                 :            : 
    1395                 :     230294 :   r = build_stmt (input_location, HANDLER, NULL_TREE, NULL_TREE);
    1396                 :     230294 :   add_stmt (r);
    1397                 :            : 
    1398                 :            :   /* Create a binding level for the eh_info and the exception object
    1399                 :            :      cleanup.  */
    1400                 :     230294 :   HANDLER_BODY (r) = do_pushlevel (sk_catch);
    1401                 :            : 
    1402                 :     230294 :   return r;
    1403                 :            : }
    1404                 :            : 
    1405                 :            : /* Finish the handler-parameters for a handler, which may be given by
    1406                 :            :    HANDLER.  DECL is the declaration for the catch parameter, or NULL
    1407                 :            :    if this is a `catch (...)' clause.  */
    1408                 :            : 
    1409                 :            : void
    1410                 :     230294 : finish_handler_parms (tree decl, tree handler)
    1411                 :            : {
    1412                 :     230294 :   tree type = NULL_TREE;
    1413                 :     230294 :   if (processing_template_decl)
    1414                 :            :     {
    1415                 :     147361 :       if (decl)
    1416                 :            :         {
    1417                 :      40432 :           decl = pushdecl (decl);
    1418                 :      40432 :           decl = push_template_decl (decl);
    1419                 :      40432 :           HANDLER_PARMS (handler) = decl;
    1420                 :      40432 :           type = TREE_TYPE (decl);
    1421                 :            :         }
    1422                 :            :     }
    1423                 :            :   else
    1424                 :            :     {
    1425                 :      82933 :       type = expand_start_catch_block (decl);
    1426                 :      82933 :       if (warn_catch_value
    1427                 :       2519 :           && type != NULL_TREE
    1428                 :        829 :           && type != error_mark_node
    1429                 :      83762 :           && !TYPE_REF_P (TREE_TYPE (decl)))
    1430                 :            :         {
    1431                 :        275 :           tree orig_type = TREE_TYPE (decl);
    1432                 :        403 :           if (CLASS_TYPE_P (orig_type))
    1433                 :            :             {
    1434                 :        128 :               if (TYPE_POLYMORPHIC_P (orig_type))
    1435                 :         64 :                 warning_at (DECL_SOURCE_LOCATION (decl),
    1436                 :            :                             OPT_Wcatch_value_,
    1437                 :            :                             "catching polymorphic type %q#T by value",
    1438                 :            :                             orig_type);
    1439                 :         64 :               else if (warn_catch_value > 1)
    1440                 :         48 :                 warning_at (DECL_SOURCE_LOCATION (decl),
    1441                 :            :                             OPT_Wcatch_value_,
    1442                 :            :                             "catching type %q#T by value", orig_type);
    1443                 :            :             }
    1444                 :        147 :           else if (warn_catch_value > 2)
    1445                 :         72 :             warning_at (DECL_SOURCE_LOCATION (decl),
    1446                 :            :                         OPT_Wcatch_value_,
    1447                 :            :                         "catching non-reference type %q#T", orig_type);
    1448                 :            :         }
    1449                 :            :     }
    1450                 :     230294 :   HANDLER_TYPE (handler) = type;
    1451                 :     230294 : }
    1452                 :            : 
    1453                 :            : /* Finish a handler, which may be given by HANDLER.  The BLOCKs are
    1454                 :            :    the return value from the matching call to finish_handler_parms.  */
    1455                 :            : 
    1456                 :            : void
    1457                 :     230294 : finish_handler (tree handler)
    1458                 :            : {
    1459                 :     230294 :   if (!processing_template_decl)
    1460                 :      82933 :     expand_end_catch_block ();
    1461                 :     230294 :   HANDLER_BODY (handler) = do_poplevel (HANDLER_BODY (handler));
    1462                 :     230294 : }
    1463                 :            : 
    1464                 :            : /* Begin a compound statement.  FLAGS contains some bits that control the
    1465                 :            :    behavior and context.  If BCS_NO_SCOPE is set, the compound statement
    1466                 :            :    does not define a scope.  If BCS_FN_BODY is set, this is the outermost
    1467                 :            :    block of a function.  If BCS_TRY_BLOCK is set, this is the block
    1468                 :            :    created on behalf of a TRY statement.  Returns a token to be passed to
    1469                 :            :    finish_compound_stmt.  */
    1470                 :            : 
    1471                 :            : tree
    1472                 :   24836100 : begin_compound_stmt (unsigned int flags)
    1473                 :            : {
    1474                 :   24836100 :   tree r;
    1475                 :            : 
    1476                 :   24836100 :   if (flags & BCS_NO_SCOPE)
    1477                 :            :     {
    1478                 :     757873 :       r = push_stmt_list ();
    1479                 :     757873 :       STATEMENT_LIST_NO_SCOPE (r) = 1;
    1480                 :            : 
    1481                 :            :       /* Normally, we try hard to keep the BLOCK for a statement-expression.
    1482                 :            :          But, if it's a statement-expression with a scopeless block, there's
    1483                 :            :          nothing to keep, and we don't want to accidentally keep a block
    1484                 :            :          *inside* the scopeless block.  */
    1485                 :     757873 :       keep_next_level (false);
    1486                 :            :     }
    1487                 :            :   else
    1488                 :            :     {
    1489                 :   24078200 :       scope_kind sk = sk_block;
    1490                 :   24078200 :       if (flags & BCS_TRY_BLOCK)
    1491                 :            :         sk = sk_try;
    1492                 :   23890100 :       else if (flags & BCS_TRANSACTION)
    1493                 :        297 :         sk = sk_transaction;
    1494                 :   24078200 :       r = do_pushlevel (sk);
    1495                 :            :     }
    1496                 :            : 
    1497                 :            :   /* When processing a template, we need to remember where the braces were,
    1498                 :            :      so that we can set up identical scopes when instantiating the template
    1499                 :            :      later.  BIND_EXPR is a handy candidate for this.
    1500                 :            :      Note that do_poplevel won't create a BIND_EXPR itself here (and thus
    1501                 :            :      result in nested BIND_EXPRs), since we don't build BLOCK nodes when
    1502                 :            :      processing templates.  */
    1503                 :   24836100 :   if (processing_template_decl)
    1504                 :            :     {
    1505                 :    9398480 :       r = build3 (BIND_EXPR, NULL, NULL, r, NULL);
    1506                 :    9398480 :       BIND_EXPR_TRY_BLOCK (r) = (flags & BCS_TRY_BLOCK) != 0;
    1507                 :    9398480 :       BIND_EXPR_BODY_BLOCK (r) = (flags & BCS_FN_BODY) != 0;
    1508                 :    9398480 :       TREE_SIDE_EFFECTS (r) = 1;
    1509                 :            :     }
    1510                 :            : 
    1511                 :   24836100 :   return r;
    1512                 :            : }
    1513                 :            : 
    1514                 :            : /* Finish a compound-statement, which is given by STMT.  */
    1515                 :            : 
    1516                 :            : void
    1517                 :   24836000 : finish_compound_stmt (tree stmt)
    1518                 :            : {
    1519                 :   24836000 :   if (TREE_CODE (stmt) == BIND_EXPR)
    1520                 :            :     {
    1521                 :    9398480 :       tree body = do_poplevel (BIND_EXPR_BODY (stmt));
    1522                 :            :       /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
    1523                 :            :          discard the BIND_EXPR so it can be merged with the containing
    1524                 :            :          STATEMENT_LIST.  */
    1525                 :    9398480 :       if (TREE_CODE (body) == STATEMENT_LIST
    1526                 :    7336150 :           && STATEMENT_LIST_HEAD (body) == NULL
    1527                 :     760612 :           && !BIND_EXPR_BODY_BLOCK (stmt)
    1528                 :   10125300 :           && !BIND_EXPR_TRY_BLOCK (stmt))
    1529                 :            :         stmt = body;
    1530                 :            :       else
    1531                 :    8671780 :         BIND_EXPR_BODY (stmt) = body;
    1532                 :            :     }
    1533                 :   15437500 :   else if (STATEMENT_LIST_NO_SCOPE (stmt))
    1534                 :     757802 :     stmt = pop_stmt_list (stmt);
    1535                 :            :   else
    1536                 :            :     {
    1537                 :            :       /* Destroy any ObjC "super" receivers that may have been
    1538                 :            :          created.  */
    1539                 :   14679700 :       objc_clear_super_receiver ();
    1540                 :            : 
    1541                 :   14679700 :       stmt = do_poplevel (stmt);
    1542                 :            :     }
    1543                 :            : 
    1544                 :            :   /* ??? See c_end_compound_stmt wrt statement expressions.  */
    1545                 :   24836000 :   add_stmt (stmt);
    1546                 :   24836000 : }
    1547                 :            : 
    1548                 :            : /* Finish an asm-statement, whose components are a STRING, some
    1549                 :            :    OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
    1550                 :            :    LABELS.  Also note whether the asm-statement should be
    1551                 :            :    considered volatile, and whether it is asm inline.  */
    1552                 :            : 
    1553                 :            : tree
    1554                 :      25783 : finish_asm_stmt (location_t loc, int volatile_p, tree string,
    1555                 :            :                  tree output_operands, tree input_operands, tree clobbers,
    1556                 :            :                  tree labels, bool inline_p)
    1557                 :            : {
    1558                 :      25783 :   tree r;
    1559                 :      25783 :   tree t;
    1560                 :      25783 :   int ninputs = list_length (input_operands);
    1561                 :      25783 :   int noutputs = list_length (output_operands);
    1562                 :            : 
    1563                 :      25783 :   if (!processing_template_decl)
    1564                 :            :     {
    1565                 :      21494 :       const char *constraint;
    1566                 :      21494 :       const char **oconstraints;
    1567                 :      21494 :       bool allows_mem, allows_reg, is_inout;
    1568                 :      21494 :       tree operand;
    1569                 :      21494 :       int i;
    1570                 :            : 
    1571                 :      21494 :       oconstraints = XALLOCAVEC (const char *, noutputs);
    1572                 :            : 
    1573                 :      21494 :       string = resolve_asm_operand_names (string, output_operands,
    1574                 :            :                                           input_operands, labels);
    1575                 :            : 
    1576                 :      38082 :       for (i = 0, t = output_operands; t; t = TREE_CHAIN (t), ++i)
    1577                 :            :         {
    1578                 :      16588 :           operand = TREE_VALUE (t);
    1579                 :            : 
    1580                 :            :           /* ??? Really, this should not be here.  Users should be using a
    1581                 :            :              proper lvalue, dammit.  But there's a long history of using
    1582                 :            :              casts in the output operands.  In cases like longlong.h, this
    1583                 :            :              becomes a primitive form of typechecking -- if the cast can be
    1584                 :            :              removed, then the output operand had a type of the proper width;
    1585                 :            :              otherwise we'll get an error.  Gross, but ...  */
    1586                 :      16588 :           STRIP_NOPS (operand);
    1587                 :            : 
    1588                 :      16588 :           operand = mark_lvalue_use (operand);
    1589                 :            : 
    1590                 :      16588 :           if (!lvalue_or_else (operand, lv_asm, tf_warning_or_error))
    1591                 :          0 :             operand = error_mark_node;
    1592                 :            : 
    1593                 :      16588 :           if (operand != error_mark_node
    1594                 :      16588 :               && (TREE_READONLY (operand)
    1595                 :      16588 :                   || CP_TYPE_CONST_P (TREE_TYPE (operand))
    1596                 :            :                   /* Functions are not modifiable, even though they are
    1597                 :            :                      lvalues.  */
    1598                 :      16580 :                   || FUNC_OR_METHOD_TYPE_P (TREE_TYPE (operand))
    1599                 :            :                   /* If it's an aggregate and any field is const, then it is
    1600                 :            :                      effectively const.  */
    1601                 :      16580 :                   || (CLASS_TYPE_P (TREE_TYPE (operand))
    1602                 :         27 :                       && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand)))))
    1603                 :          8 :             cxx_readonly_error (loc, operand, lv_asm);
    1604                 :            : 
    1605                 :            :           tree *op = &operand;
    1606                 :      16595 :           while (TREE_CODE (*op) == COMPOUND_EXPR)
    1607                 :          7 :             op = &TREE_OPERAND (*op, 1);
    1608                 :      16588 :           switch (TREE_CODE (*op))
    1609                 :            :             {
    1610                 :         29 :             case PREINCREMENT_EXPR:
    1611                 :         29 :             case PREDECREMENT_EXPR:
    1612                 :         29 :             case MODIFY_EXPR:
    1613                 :         29 :               *op = genericize_compound_lvalue (*op);
    1614                 :         29 :               op = &TREE_OPERAND (*op, 1);
    1615                 :         29 :               break;
    1616                 :            :             default:
    1617                 :            :               break;
    1618                 :            :             }
    1619                 :            : 
    1620                 :      16588 :           constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
    1621                 :      16588 :           oconstraints[i] = constraint;
    1622                 :            : 
    1623                 :      16588 :           if (parse_output_constraint (&constraint, i, ninputs, noutputs,
    1624                 :            :                                        &allows_mem, &allows_reg, &is_inout))
    1625                 :            :             {
    1626                 :            :               /* If the operand is going to end up in memory,
    1627                 :            :                  mark it addressable.  */
    1628                 :      16584 :               if (!allows_reg && !cxx_mark_addressable (*op))
    1629                 :          0 :                 operand = error_mark_node;
    1630                 :            :             }
    1631                 :            :           else
    1632                 :          4 :             operand = error_mark_node;
    1633                 :            : 
    1634                 :      16588 :           TREE_VALUE (t) = operand;
    1635                 :            :         }
    1636                 :            : 
    1637                 :      36067 :       for (i = 0, t = input_operands; t; ++i, t = TREE_CHAIN (t))
    1638                 :            :         {
    1639                 :      14573 :           constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
    1640                 :      14573 :           bool constraint_parsed
    1641                 :      14573 :             = parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
    1642                 :            :                                       oconstraints, &allows_mem, &allows_reg);
    1643                 :            :           /* If the operand is going to end up in memory, don't call
    1644                 :            :              decay_conversion.  */
    1645                 :      14573 :           if (constraint_parsed && !allows_reg && allows_mem)
    1646                 :       2091 :             operand = mark_lvalue_use (TREE_VALUE (t));
    1647                 :            :           else
    1648                 :      12482 :             operand = decay_conversion (TREE_VALUE (t), tf_warning_or_error);
    1649                 :            : 
    1650                 :            :           /* If the type of the operand hasn't been determined (e.g.,
    1651                 :            :              because it involves an overloaded function), then issue
    1652                 :            :              an error message.  There's no context available to
    1653                 :            :              resolve the overloading.  */
    1654                 :      14573 :           if (TREE_TYPE (operand) == unknown_type_node)
    1655                 :            :             {
    1656                 :          4 :               error_at (loc,
    1657                 :            :                         "type of %<asm%> operand %qE could not be determined",
    1658                 :          4 :                         TREE_VALUE (t));
    1659                 :          4 :               operand = error_mark_node;
    1660                 :            :             }
    1661                 :            : 
    1662                 :      14573 :           if (constraint_parsed)
    1663                 :            :             {
    1664                 :            :               /* If the operand is going to end up in memory,
    1665                 :            :                  mark it addressable.  */
    1666                 :      14573 :               if (!allows_reg && allows_mem)
    1667                 :            :                 {
    1668                 :            :                   /* Strip the nops as we allow this case.  FIXME, this really
    1669                 :            :                      should be rejected or made deprecated.  */
    1670                 :       2091 :                   STRIP_NOPS (operand);
    1671                 :            : 
    1672                 :       2091 :                   tree *op = &operand;
    1673                 :       2098 :                   while (TREE_CODE (*op) == COMPOUND_EXPR)
    1674                 :          7 :                     op = &TREE_OPERAND (*op, 1);
    1675                 :       2091 :                   switch (TREE_CODE (*op))
    1676                 :            :                     {
    1677                 :         29 :                     case PREINCREMENT_EXPR:
    1678                 :         29 :                     case PREDECREMENT_EXPR:
    1679                 :         29 :                     case MODIFY_EXPR:
    1680                 :         29 :                       *op = genericize_compound_lvalue (*op);
    1681                 :         29 :                       op = &TREE_OPERAND (*op, 1);
    1682                 :         29 :                       break;
    1683                 :            :                     default:
    1684                 :            :                       break;
    1685                 :            :                     }
    1686                 :            : 
    1687                 :       2091 :                   if (!cxx_mark_addressable (*op))
    1688                 :          0 :                     operand = error_mark_node;
    1689                 :            :                 }
    1690                 :      12482 :               else if (!allows_reg && !allows_mem)
    1691                 :            :                 {
    1692                 :            :                   /* If constraint allows neither register nor memory,
    1693                 :            :                      try harder to get a constant.  */
    1694                 :        100 :                   tree constop = maybe_constant_value (operand);
    1695                 :        100 :                   if (TREE_CONSTANT (constop))
    1696                 :         96 :                     operand = constop;
    1697                 :            :                 }
    1698                 :            :             }
    1699                 :            :           else
    1700                 :          0 :             operand = error_mark_node;
    1701                 :            : 
    1702                 :      14573 :           TREE_VALUE (t) = operand;
    1703                 :            :         }
    1704                 :            :     }
    1705                 :            : 
    1706                 :      25783 :   r = build_stmt (loc, ASM_EXPR, string,
    1707                 :            :                   output_operands, input_operands,
    1708                 :            :                   clobbers, labels);
    1709                 :      25783 :   ASM_VOLATILE_P (r) = volatile_p || noutputs == 0;
    1710                 :      25783 :   ASM_INLINE_P (r) = inline_p;
    1711                 :      25783 :   r = maybe_cleanup_point_expr_void (r);
    1712                 :      25783 :   return add_stmt (r);
    1713                 :            : }
    1714                 :            : 
    1715                 :            : /* Finish a label with the indicated NAME.  Returns the new label.  */
    1716                 :            : 
    1717                 :            : tree
    1718                 :       1516 : finish_label_stmt (tree name)
    1719                 :            : {
    1720                 :       1516 :   tree decl = define_label (input_location, name);
    1721                 :            : 
    1722                 :       1516 :   if (decl == error_mark_node)
    1723                 :            :     return error_mark_node;
    1724                 :            : 
    1725                 :       1508 :   add_stmt (build_stmt (input_location, LABEL_EXPR, decl));
    1726                 :            : 
    1727                 :       1508 :   return decl;
    1728                 :            : }
    1729                 :            : 
    1730                 :            : /* Finish a series of declarations for local labels.  G++ allows users
    1731                 :            :    to declare "local" labels, i.e., labels with scope.  This extension
    1732                 :            :    is useful when writing code involving statement-expressions.  */
    1733                 :            : 
    1734                 :            : void
    1735                 :         84 : finish_label_decl (tree name)
    1736                 :            : {
    1737                 :         84 :   if (!at_function_scope_p ())
    1738                 :            :     {
    1739                 :          0 :       error ("%<__label__%> declarations are only allowed in function scopes");
    1740                 :          0 :       return;
    1741                 :            :     }
    1742                 :            : 
    1743                 :         84 :   add_decl_expr (declare_local_label (name));
    1744                 :            : }
    1745                 :            : 
    1746                 :            : /* When DECL goes out of scope, make sure that CLEANUP is executed.  */
    1747                 :            : 
    1748                 :            : void
    1749                 :    1124390 : finish_decl_cleanup (tree decl, tree cleanup)
    1750                 :            : {
    1751                 :    1124390 :   push_cleanup (decl, cleanup, false);
    1752                 :    1124390 : }
    1753                 :            : 
    1754                 :            : /* If the current scope exits with an exception, run CLEANUP.  */
    1755                 :            : 
    1756                 :            : void
    1757                 :     671813 : finish_eh_cleanup (tree cleanup)
    1758                 :            : {
    1759                 :     671813 :   push_cleanup (NULL, cleanup, true);
    1760                 :     671813 : }
    1761                 :            : 
    1762                 :            : /* The MEM_INITS is a list of mem-initializers, in reverse of the
    1763                 :            :    order they were written by the user.  Each node is as for
    1764                 :            :    emit_mem_initializers.  */
    1765                 :            : 
    1766                 :            : void
    1767                 :    2362940 : finish_mem_initializers (tree mem_inits)
    1768                 :            : {
    1769                 :            :   /* Reorder the MEM_INITS so that they are in the order they appeared
    1770                 :            :      in the source program.  */
    1771                 :    2362940 :   mem_inits = nreverse (mem_inits);
    1772                 :            : 
    1773                 :    2362940 :   if (processing_template_decl)
    1774                 :            :     {
    1775                 :            :       tree mem;
    1776                 :            : 
    1777                 :    1913590 :       for (mem = mem_inits; mem; mem = TREE_CHAIN (mem))
    1778                 :            :         {
    1779                 :            :           /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
    1780                 :            :              check for bare parameter packs in the TREE_VALUE, because
    1781                 :            :              any parameter packs in the TREE_VALUE have already been
    1782                 :            :              bound as part of the TREE_PURPOSE.  See
    1783                 :            :              make_pack_expansion for more information.  */
    1784                 :    1096680 :           if (TREE_CODE (TREE_PURPOSE (mem)) != TYPE_PACK_EXPANSION
    1785                 :    1096680 :               && check_for_bare_parameter_packs (TREE_VALUE (mem)))
    1786                 :          3 :             TREE_VALUE (mem) = error_mark_node;
    1787                 :            :         }
    1788                 :            : 
    1789                 :     816913 :       add_stmt (build_min_nt_loc (UNKNOWN_LOCATION,
    1790                 :            :                                   CTOR_INITIALIZER, mem_inits));
    1791                 :            :     }
    1792                 :            :   else
    1793                 :    1546030 :     emit_mem_initializers (mem_inits);
    1794                 :    2362940 : }
    1795                 :            : 
    1796                 :            : /* Obfuscate EXPR if it looks like an id-expression or member access so
    1797                 :            :    that the call to finish_decltype in do_auto_deduction will give the
    1798                 :            :    right result.  If EVEN_UNEVAL, do this even in unevaluated context.  */
    1799                 :            : 
    1800                 :            : tree
    1801                 :    5128150 : force_paren_expr (tree expr, bool even_uneval)
    1802                 :            : {
    1803                 :            :   /* This is only needed for decltype(auto) in C++14.  */
    1804                 :    5128150 :   if (cxx_dialect < cxx14)
    1805                 :            :     return expr;
    1806                 :            : 
    1807                 :            :   /* If we're in unevaluated context, we can't be deducing a
    1808                 :            :      return/initializer type, so we don't need to mess with this.  */
    1809                 :    4226950 :   if (cp_unevaluated_operand && !even_uneval)
    1810                 :            :     return expr;
    1811                 :            : 
    1812                 :    3834270 :   if (!DECL_P (tree_strip_any_location_wrapper (expr))
    1813                 :    3621410 :       && TREE_CODE (expr) != COMPONENT_REF
    1814                 :    7444830 :       && TREE_CODE (expr) != SCOPE_REF)
    1815                 :            :     return expr;
    1816                 :            : 
    1817                 :     233512 :   location_t loc = cp_expr_location (expr);
    1818                 :            : 
    1819                 :     233512 :   if (TREE_CODE (expr) == COMPONENT_REF
    1820                 :     222659 :       || TREE_CODE (expr) == SCOPE_REF)
    1821                 :      41302 :     REF_PARENTHESIZED_P (expr) = true;
    1822                 :     212861 :   else if (processing_template_decl)
    1823                 :       8002 :     expr = build1_loc (loc, PAREN_EXPR, TREE_TYPE (expr), expr);
    1824                 :            :   else
    1825                 :            :     {
    1826                 :     204859 :       expr = build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (expr), expr);
    1827                 :     409718 :       REF_PARENTHESIZED_P (expr) = true;
    1828                 :            :     }
    1829                 :            : 
    1830                 :            :   return expr;
    1831                 :            : }
    1832                 :            : 
    1833                 :            : /* If T is an id-expression obfuscated by force_paren_expr, undo the
    1834                 :            :    obfuscation and return the underlying id-expression.  Otherwise
    1835                 :            :    return T.  */
    1836                 :            : 
    1837                 :            : tree
    1838                 :   42442200 : maybe_undo_parenthesized_ref (tree t)
    1839                 :            : {
    1840                 :   42442200 :   if (cxx_dialect < cxx14)
    1841                 :            :     return t;
    1842                 :            : 
    1843                 :   41534600 :   if (INDIRECT_REF_P (t) && REF_PARENTHESIZED_P (t))
    1844                 :            :     {
    1845                 :          0 :       t = TREE_OPERAND (t, 0);
    1846                 :          0 :       while (TREE_CODE (t) == NON_LVALUE_EXPR
    1847                 :          0 :              || TREE_CODE (t) == NOP_EXPR)
    1848                 :          0 :         t = TREE_OPERAND (t, 0);
    1849                 :            : 
    1850                 :          0 :       gcc_assert (TREE_CODE (t) == ADDR_EXPR
    1851                 :            :                   || TREE_CODE (t) == STATIC_CAST_EXPR);
    1852                 :          0 :       t = TREE_OPERAND (t, 0);
    1853                 :            :     }
    1854                 :   39223500 :   else if (TREE_CODE (t) == PAREN_EXPR)
    1855                 :        120 :     t = TREE_OPERAND (t, 0);
    1856                 :   39223400 :   else if (TREE_CODE (t) == VIEW_CONVERT_EXPR
    1857                 :   40347100 :            && REF_PARENTHESIZED_P (t))
    1858                 :        198 :     t = TREE_OPERAND (t, 0);
    1859                 :            : 
    1860                 :            :   return t;
    1861                 :            : }
    1862                 :            : 
    1863                 :            : /* Finish a parenthesized expression EXPR.  */
    1864                 :            : 
    1865                 :            : cp_expr
    1866                 :    4183810 : finish_parenthesized_expr (cp_expr expr)
    1867                 :            : {
    1868                 :    4183810 :   if (EXPR_P (expr))
    1869                 :            :     /* This inhibits warnings in c_common_truthvalue_conversion.  */
    1870                 :    4168410 :     TREE_NO_WARNING (expr) = 1;
    1871                 :            : 
    1872                 :    4183810 :   if (TREE_CODE (expr) == OFFSET_REF
    1873                 :    4183810 :       || TREE_CODE (expr) == SCOPE_REF)
    1874                 :            :     /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
    1875                 :            :        enclosed in parentheses.  */
    1876                 :      36660 :     PTRMEM_OK_P (expr) = 0;
    1877                 :            : 
    1878                 :    4183810 :   tree stripped_expr = tree_strip_any_location_wrapper (expr);
    1879                 :    4183810 :   if (TREE_CODE (stripped_expr) == STRING_CST)
    1880                 :      46345 :     PAREN_STRING_LITERAL_P (stripped_expr) = 1;
    1881                 :            : 
    1882                 :    4183810 :   expr = cp_expr (force_paren_expr (expr), expr.get_location ());
    1883                 :            : 
    1884                 :    4183810 :   return expr;
    1885                 :            : }
    1886                 :            : 
    1887                 :            : /* Finish a reference to a non-static data member (DECL) that is not
    1888                 :            :    preceded by `.' or `->'.  */
    1889                 :            : 
    1890                 :            : tree
    1891                 :    4065610 : finish_non_static_data_member (tree decl, tree object, tree qualifying_scope)
    1892                 :            : {
    1893                 :    4065610 :   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
    1894                 :    4065610 :   bool try_omp_private = !object && omp_private_member_map;
    1895                 :    4065610 :   tree ret;
    1896                 :            : 
    1897                 :    4065610 :   if (!object)
    1898                 :            :     {
    1899                 :    2300900 :       tree scope = qualifying_scope;
    1900                 :    2300900 :       if (scope == NULL_TREE)
    1901                 :            :         {
    1902                 :    2297540 :           scope = context_for_name_lookup (decl);
    1903                 :    2297540 :           if (!TYPE_P (scope))
    1904                 :            :             {
    1905                 :            :               /* Can happen during error recovery (c++/85014).  */
    1906                 :          3 :               gcc_assert (seen_error ());
    1907                 :          3 :               return error_mark_node;
    1908                 :            :             }
    1909                 :            :         }
    1910                 :    2300900 :       object = maybe_dummy_object (scope, NULL);
    1911                 :            :     }
    1912                 :            : 
    1913                 :    4065610 :   object = maybe_resolve_dummy (object, true);
    1914                 :    4065610 :   if (object == error_mark_node)
    1915                 :            :     return error_mark_node;
    1916                 :            : 
    1917                 :            :   /* DR 613/850: Can use non-static data members without an associated
    1918                 :            :      object in sizeof/decltype/alignof.  */
    1919                 :    4067050 :   if (is_dummy_object (object) && cp_unevaluated_operand == 0
    1920                 :    4065710 :       && (!processing_template_decl || !current_class_ref))
    1921                 :            :     {
    1922                 :         90 :       if (current_function_decl
    1923                 :        173 :           && DECL_STATIC_FUNCTION_P (current_function_decl))
    1924                 :          0 :         error ("invalid use of member %qD in static member function", decl);
    1925                 :            :       else
    1926                 :         90 :         error ("invalid use of non-static data member %qD", decl);
    1927                 :         90 :       inform (DECL_SOURCE_LOCATION (decl), "declared here");
    1928                 :            : 
    1929                 :         90 :       return error_mark_node;
    1930                 :            :     }
    1931                 :            : 
    1932                 :    4065520 :   if (current_class_ptr)
    1933                 :    4063080 :     TREE_USED (current_class_ptr) = 1;
    1934                 :    4065520 :   if (processing_template_decl)
    1935                 :            :     {
    1936                 :    1932710 :       tree type = TREE_TYPE (decl);
    1937                 :            : 
    1938                 :    1932710 :       if (TYPE_REF_P (type))
    1939                 :            :         /* Quals on the object don't matter.  */;
    1940                 :    1909440 :       else if (PACK_EXPANSION_P (type))
    1941                 :            :         /* Don't bother trying to represent this.  */
    1942                 :            :         type = NULL_TREE;
    1943                 :            :       else
    1944                 :            :         {
    1945                 :            :           /* Set the cv qualifiers.  */
    1946                 :    1909110 :           int quals = cp_type_quals (TREE_TYPE (object));
    1947                 :            : 
    1948                 :    1909110 :           if (DECL_MUTABLE_P (decl))
    1949                 :      27045 :             quals &= ~TYPE_QUAL_CONST;
    1950                 :            : 
    1951                 :    1909110 :           quals |= cp_type_quals (TREE_TYPE (decl));
    1952                 :    1909110 :           type = cp_build_qualified_type (type, quals);
    1953                 :            :         }
    1954                 :            : 
    1955                 :    1932710 :       if (qualifying_scope)
    1956                 :            :         /* Wrap this in a SCOPE_REF for now.  */
    1957                 :        195 :         ret = build_qualified_name (type, qualifying_scope, decl,
    1958                 :            :                                     /*template_p=*/false);
    1959                 :            :       else
    1960                 :    1932520 :         ret = (convert_from_reference
    1961                 :    1932520 :                (build_min (COMPONENT_REF, type, object, decl, NULL_TREE)));
    1962                 :            :     }
    1963                 :            :   /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
    1964                 :            :      QUALIFYING_SCOPE is also non-null.  */
    1965                 :            :   else
    1966                 :            :     {
    1967                 :    2132810 :       tree access_type = TREE_TYPE (object);
    1968                 :            : 
    1969                 :    2134700 :       perform_or_defer_access_check (TYPE_BINFO (access_type), decl,
    1970                 :            :                                      decl, tf_warning_or_error);
    1971                 :            : 
    1972                 :            :       /* If the data member was named `C::M', convert `*this' to `C'
    1973                 :            :          first.  */
    1974                 :    2132810 :       if (qualifying_scope)
    1975                 :            :         {
    1976                 :       3132 :           tree binfo = NULL_TREE;
    1977                 :       3132 :           object = build_scoped_ref (object, qualifying_scope,
    1978                 :            :                                      &binfo);
    1979                 :            :         }
    1980                 :            : 
    1981                 :    2132810 :       ret = build_class_member_access_expr (object, decl,
    1982                 :            :                                             /*access_path=*/NULL_TREE,
    1983                 :            :                                             /*preserve_reference=*/false,
    1984                 :            :                                             tf_warning_or_error);
    1985                 :            :     }
    1986                 :    4065520 :   if (try_omp_private)
    1987                 :            :     {
    1988                 :       1588 :       tree *v = omp_private_member_map->get (decl);
    1989                 :       1133 :       if (v)
    1990                 :       1133 :         ret = convert_from_reference (*v);
    1991                 :            :     }
    1992                 :            :   return ret;
    1993                 :            : }
    1994                 :            : 
    1995                 :            : /* If we are currently parsing a template and we encountered a typedef
    1996                 :            :    TYPEDEF_DECL that is being accessed though CONTEXT, this function
    1997                 :            :    adds the typedef to a list tied to the current template.
    1998                 :            :    At template instantiation time, that list is walked and access check
    1999                 :            :    performed for each typedef.
    2000                 :            :    LOCATION is the location of the usage point of TYPEDEF_DECL.  */
    2001                 :            : 
    2002                 :            : void
    2003                 :  296101000 : add_typedef_to_current_template_for_access_check (tree typedef_decl,
    2004                 :            :                                                   tree context,
    2005                 :            :                                                   location_t location)
    2006                 :            : {
    2007                 :  296101000 :     tree template_info = NULL;
    2008                 :  296101000 :     tree cs = current_scope ();
    2009                 :            : 
    2010                 :  296101000 :     if (!is_typedef_decl (typedef_decl)
    2011                 :   70860900 :         || !context
    2012                 :  113365000 :         || !CLASS_TYPE_P (context)
    2013                 :  338625000 :         || !cs)
    2014                 :            :       return;
    2015                 :            : 
    2016                 :   59774700 :     if (CLASS_TYPE_P (cs) || TREE_CODE (cs) == FUNCTION_DECL)
    2017                 :   35017500 :       template_info = get_template_info (cs);
    2018                 :            : 
    2019                 :   35017500 :     if (template_info
    2020                 :   32687300 :         && TI_TEMPLATE (template_info)
    2021                 :   67704800 :         && !currently_open_class (context))
    2022                 :   20325400 :       append_type_to_template_for_access_check (cs, typedef_decl,
    2023                 :            :                                                 context, location);
    2024                 :            : }
    2025                 :            : 
    2026                 :            : /* DECL was the declaration to which a qualified-id resolved.  Issue
    2027                 :            :    an error message if it is not accessible.  If OBJECT_TYPE is
    2028                 :            :    non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
    2029                 :            :    type of `*x', or `x', respectively.  If the DECL was named as
    2030                 :            :    `A::B' then NESTED_NAME_SPECIFIER is `A'.  */
    2031                 :            : 
    2032                 :            : void
    2033                 :  267808000 : check_accessibility_of_qualified_id (tree decl,
    2034                 :            :                                      tree object_type,
    2035                 :            :                                      tree nested_name_specifier)
    2036                 :            : {
    2037                 :  267808000 :   tree scope;
    2038                 :  267808000 :   tree qualifying_type = NULL_TREE;
    2039                 :            : 
    2040                 :            :   /* If we are parsing a template declaration and if decl is a typedef,
    2041                 :            :      add it to a list tied to the template.
    2042                 :            :      At template instantiation time, that list will be walked and
    2043                 :            :      access check performed.  */
    2044                 :  519525000 :   add_typedef_to_current_template_for_access_check (decl,
    2045                 :            :                                                     nested_name_specifier
    2046                 :            :                                                     ? nested_name_specifier
    2047                 :  251718000 :                                                     : DECL_CONTEXT (decl),
    2048                 :            :                                                     input_location);
    2049                 :            : 
    2050                 :            :   /* If we're not checking, return immediately.  */
    2051                 :  267808000 :   if (deferred_access_no_check)
    2052                 :            :     return;
    2053                 :            : 
    2054                 :            :   /* Determine the SCOPE of DECL.  */
    2055                 :   91422000 :   scope = context_for_name_lookup (decl);
    2056                 :            :   /* If the SCOPE is not a type, then DECL is not a member.  */
    2057                 :   91422000 :   if (!TYPE_P (scope))
    2058                 :            :     return;
    2059                 :            :   /* Compute the scope through which DECL is being accessed.  */
    2060                 :   13790200 :   if (object_type
    2061                 :            :       /* OBJECT_TYPE might not be a class type; consider:
    2062                 :            : 
    2063                 :            :            class A { typedef int I; };
    2064                 :            :            I *p;
    2065                 :            :            p->A::I::~I();
    2066                 :            : 
    2067                 :            :          In this case, we will have "A::I" as the DECL, but "I" as the
    2068                 :            :          OBJECT_TYPE.  */
    2069                 :      20805 :       && CLASS_TYPE_P (object_type)
    2070                 :   13800600 :       && DERIVED_FROM_P (scope, object_type))
    2071                 :            :     /* If we are processing a `->' or `.' expression, use the type of the
    2072                 :            :        left-hand side.  */
    2073                 :            :     qualifying_type = object_type;
    2074                 :   13779800 :   else if (nested_name_specifier)
    2075                 :            :     {
    2076                 :            :       /* If the reference is to a non-static member of the
    2077                 :            :          current class, treat it as if it were referenced through
    2078                 :            :          `this'.  */
    2079                 :    7200050 :       tree ct;
    2080                 :   14400100 :       if (DECL_NONSTATIC_MEMBER_P (decl)
    2081                 :       8354 :           && current_class_ptr
    2082                 :    7203690 :           && DERIVED_FROM_P (scope, ct = current_nonlambda_class_type ()))
    2083                 :            :         qualifying_type = ct;
    2084                 :            :       /* Otherwise, use the type indicated by the
    2085                 :            :          nested-name-specifier.  */
    2086                 :            :       else
    2087                 :            :         qualifying_type = nested_name_specifier;
    2088                 :            :     }
    2089                 :            :   else
    2090                 :            :     /* Otherwise, the name must be from the current class or one of
    2091                 :            :        its bases.  */
    2092                 :    6579780 :     qualifying_type = currently_open_derived_class (scope);
    2093                 :            : 
    2094                 :   13790200 :   if (qualifying_type
    2095                 :            :       /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
    2096                 :            :          or similar in a default argument value.  */
    2097                 :   27440700 :       && CLASS_TYPE_P (qualifying_type)
    2098                 :   27441000 :       && !dependent_type_p (qualifying_type))
    2099                 :   13657300 :     perform_or_defer_access_check (TYPE_BINFO (qualifying_type), decl,
    2100                 :            :                                    decl, tf_warning_or_error);
    2101                 :            : }
    2102                 :            : 
    2103                 :            : /* EXPR is the result of a qualified-id.  The QUALIFYING_CLASS was the
    2104                 :            :    class named to the left of the "::" operator.  DONE is true if this
    2105                 :            :    expression is a complete postfix-expression; it is false if this
    2106                 :            :    expression is followed by '->', '[', '(', etc.  ADDRESS_P is true
    2107                 :            :    iff this expression is the operand of '&'.  TEMPLATE_P is true iff
    2108                 :            :    the qualified-id was of the form "A::template B".  TEMPLATE_ARG_P
    2109                 :            :    is true iff this qualified name appears as a template argument.  */
    2110                 :            : 
    2111                 :            : tree
    2112                 :   10034100 : finish_qualified_id_expr (tree qualifying_class,
    2113                 :            :                           tree expr,
    2114                 :            :                           bool done,
    2115                 :            :                           bool address_p,
    2116                 :            :                           bool template_p,
    2117                 :            :                           bool template_arg_p,
    2118                 :            :                           tsubst_flags_t complain)
    2119                 :            : {
    2120                 :   10034100 :   gcc_assert (TYPE_P (qualifying_class));
    2121                 :            : 
    2122                 :   20068200 :   if (error_operand_p (expr))
    2123                 :            :     return error_mark_node;
    2124                 :            : 
    2125                 :    1889650 :   if ((DECL_P (expr) || BASELINK_P (expr))
    2126                 :   11841200 :       && !mark_used (expr, complain))
    2127                 :          9 :     return error_mark_node;
    2128                 :            : 
    2129                 :   10034100 :   if (template_p)
    2130                 :            :     {
    2131                 :     679870 :       if (TREE_CODE (expr) == UNBOUND_CLASS_TEMPLATE)
    2132                 :            :         {
    2133                 :            :           /* cp_parser_lookup_name thought we were looking for a type,
    2134                 :            :              but we're actually looking for a declaration.  */
    2135                 :         11 :           qualifying_class = TYPE_CONTEXT (expr);
    2136                 :         11 :           expr = TYPE_IDENTIFIER (expr);
    2137                 :            :         }
    2138                 :            :       else
    2139                 :     679859 :         check_template_keyword (expr);
    2140                 :            :     }
    2141                 :            : 
    2142                 :            :   /* If EXPR occurs as the operand of '&', use special handling that
    2143                 :            :      permits a pointer-to-member.  */
    2144                 :   10034100 :   if (address_p && done)
    2145                 :            :     {
    2146                 :      37840 :       if (TREE_CODE (expr) == SCOPE_REF)
    2147                 :          0 :         expr = TREE_OPERAND (expr, 1);
    2148                 :      37840 :       expr = build_offset_ref (qualifying_class, expr,
    2149                 :            :                                /*address_p=*/true, complain);
    2150                 :      37840 :       return expr;
    2151                 :            :     }
    2152                 :            : 
    2153                 :            :   /* No need to check access within an enum.  */
    2154                 :    9996270 :   if (TREE_CODE (qualifying_class) == ENUMERAL_TYPE
    2155                 :      42324 :       && TREE_CODE (expr) != IDENTIFIER_NODE)
    2156                 :            :     return expr;
    2157                 :            : 
    2158                 :            :   /* Within the scope of a class, turn references to non-static
    2159                 :            :      members into expression of the form "this->...".  */
    2160                 :    9953940 :   if (template_arg_p)
    2161                 :            :     /* But, within a template argument, we do not want make the
    2162                 :            :        transformation, as there is no "this" pointer.  */
    2163                 :            :     ;
    2164                 :    9934620 :   else if (TREE_CODE (expr) == FIELD_DECL)
    2165                 :            :     {
    2166                 :       3359 :       push_deferring_access_checks (dk_no_check);
    2167                 :       3359 :       expr = finish_non_static_data_member (expr, NULL_TREE,
    2168                 :            :                                             qualifying_class);
    2169                 :       3359 :       pop_deferring_access_checks ();
    2170                 :            :     }
    2171                 :    9931260 :   else if (BASELINK_P (expr))
    2172                 :            :     {
    2173                 :            :       /* See if any of the functions are non-static members.  */
    2174                 :            :       /* If so, the expression may be relative to 'this'.  */
    2175                 :    1771340 :       if ((type_dependent_expression_p (expr)
    2176                 :    1396120 :            || !shared_member_p (expr))
    2177                 :     401574 :           && current_class_ptr
    2178                 :    1799650 :           && DERIVED_FROM_P (qualifying_class,
    2179                 :            :                              current_nonlambda_class_type ()))
    2180                 :      27976 :         expr = (build_class_member_access_expr
    2181                 :      27976 :                 (maybe_dummy_object (qualifying_class, NULL),
    2182                 :            :                  expr,
    2183                 :      27976 :                  BASELINK_ACCESS_BINFO (expr),
    2184                 :            :                  /*preserve_reference=*/false,
    2185                 :            :                  complain));
    2186                 :    1743360 :       else if (done)
    2187                 :            :         /* The expression is a qualified name whose address is not
    2188                 :            :            being taken.  */
    2189                 :        286 :         expr = build_offset_ref (qualifying_class, expr, /*address_p=*/false,
    2190                 :            :                                  complain);
    2191                 :            :     }
    2192                 :    8159920 :   else if (!template_p
    2193                 :    8096550 :            && TREE_CODE (expr) == TEMPLATE_DECL
    2194                 :    8159920 :            && !DECL_FUNCTION_TEMPLATE_P (expr))
    2195                 :            :     {
    2196                 :          3 :       if (complain & tf_error)
    2197                 :          3 :         error ("%qE missing template arguments", expr);
    2198                 :          3 :       return error_mark_node;
    2199                 :            :     }
    2200                 :            :   else
    2201                 :            :     {
    2202                 :            :       /* In a template, return a SCOPE_REF for most qualified-ids
    2203                 :            :          so that we can check access at instantiation time.  But if
    2204                 :            :          we're looking at a member of the current instantiation, we
    2205                 :            :          know we have access and building up the SCOPE_REF confuses
    2206                 :            :          non-type template argument handling.  */
    2207                 :    8159920 :       if (processing_template_decl
    2208                 :    8159920 :           && (!currently_open_class (qualifying_class)
    2209                 :        180 :               || TREE_CODE (expr) == IDENTIFIER_NODE
    2210                 :        180 :               || TREE_CODE (expr) == TEMPLATE_ID_EXPR
    2211                 :        176 :               || TREE_CODE (expr) == BIT_NOT_EXPR))
    2212                 :     791741 :         expr = build_qualified_name (TREE_TYPE (expr),
    2213                 :            :                                      qualifying_class, expr,
    2214                 :            :                                      template_p);
    2215                 :    7368170 :       else if (tree wrap = maybe_get_tls_wrapper_call (expr))
    2216                 :         51 :         expr = wrap;
    2217                 :            : 
    2218                 :    8159920 :       expr = convert_from_reference (expr);
    2219                 :            :     }
    2220                 :            : 
    2221                 :            :   return expr;
    2222                 :            : }
    2223                 :            : 
    2224                 :            : /* Begin a statement-expression.  The value returned must be passed to
    2225                 :            :    finish_stmt_expr.  */
    2226                 :            : 
    2227                 :            : tree
    2228                 :     771906 : begin_stmt_expr (void)
    2229                 :            : {
    2230                 :     771906 :   return push_stmt_list ();
    2231                 :            : }
    2232                 :            : 
    2233                 :            : /* Process the final expression of a statement expression. EXPR can be
    2234                 :            :    NULL, if the final expression is empty.  Return a STATEMENT_LIST
    2235                 :            :    containing all the statements in the statement-expression, or
    2236                 :            :    ERROR_MARK_NODE if there was an error.  */
    2237                 :            : 
    2238                 :            : tree
    2239                 :      13054 : finish_stmt_expr_expr (tree expr, tree stmt_expr)
    2240                 :            : {
    2241                 :      26088 :   if (error_operand_p (expr))
    2242                 :            :     {
    2243                 :            :       /* The type of the statement-expression is the type of the last
    2244                 :            :          expression.  */
    2245                 :          4 :       TREE_TYPE (stmt_expr) = error_mark_node;
    2246                 :          4 :       return error_mark_node;
    2247                 :            :     }
    2248                 :            : 
    2249                 :            :   /* If the last statement does not have "void" type, then the value
    2250                 :            :      of the last statement is the value of the entire expression.  */
    2251                 :      13050 :   if (expr)
    2252                 :            :     {
    2253                 :      13030 :       tree type = TREE_TYPE (expr);
    2254                 :            : 
    2255                 :      13030 :       if (type && type_unknown_p (type))
    2256                 :            :         {
    2257                 :         20 :           error ("a statement expression is an insufficient context"
    2258                 :            :                  " for overload resolution");
    2259                 :         20 :           TREE_TYPE (stmt_expr) = error_mark_node;
    2260                 :         20 :           return error_mark_node;
    2261                 :            :         }
    2262                 :      13010 :       else if (processing_template_decl)
    2263                 :            :         {
    2264                 :        167 :           expr = build_stmt (input_location, EXPR_STMT, expr);
    2265                 :        167 :           expr = add_stmt (expr);
    2266                 :            :           /* Mark the last statement so that we can recognize it as such at
    2267                 :            :              template-instantiation time.  */
    2268                 :        167 :           EXPR_STMT_STMT_EXPR_RESULT (expr) = 1;
    2269                 :            :         }
    2270                 :      12843 :       else if (VOID_TYPE_P (type))
    2271                 :            :         {
    2272                 :            :           /* Just treat this like an ordinary statement.  */
    2273                 :         28 :           expr = finish_expr_stmt (expr);
    2274                 :            :         }
    2275                 :            :       else
    2276                 :            :         {
    2277                 :            :           /* It actually has a value we need to deal with.  First, force it
    2278                 :            :              to be an rvalue so that we won't need to build up a copy
    2279                 :            :              constructor call later when we try to assign it to something.  */
    2280                 :      12815 :           expr = force_rvalue (expr, tf_warning_or_error);
    2281                 :      25630 :           if (error_operand_p (expr))
    2282                 :            :             return error_mark_node;
    2283                 :            : 
    2284                 :            :           /* Update for array-to-pointer decay.  */
    2285                 :      12815 :           type = TREE_TYPE (expr);
    2286                 :            : 
    2287                 :            :           /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
    2288                 :            :              normal statement, but don't convert to void or actually add
    2289                 :            :              the EXPR_STMT.  */
    2290                 :      12815 :           if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
    2291                 :      12815 :             expr = maybe_cleanup_point_expr (expr);
    2292                 :      12815 :           add_stmt (expr);
    2293                 :            :         }
    2294                 :            : 
    2295                 :            :       /* The type of the statement-expression is the type of the last
    2296                 :            :          expression.  */
    2297                 :      13010 :       TREE_TYPE (stmt_expr) = type;
    2298                 :            :     }
    2299                 :            : 
    2300                 :            :   return stmt_expr;
    2301                 :            : }
    2302                 :            : 
    2303                 :            : /* Finish a statement-expression.  EXPR should be the value returned
    2304                 :            :    by the previous begin_stmt_expr.  Returns an expression
    2305                 :            :    representing the statement-expression.  */
    2306                 :            : 
    2307                 :            : tree
    2308                 :     771906 : finish_stmt_expr (tree stmt_expr, bool has_no_scope)
    2309                 :            : {
    2310                 :     771906 :   tree type;
    2311                 :     771906 :   tree result;
    2312                 :            : 
    2313                 :    1543810 :   if (error_operand_p (stmt_expr))
    2314                 :            :     {
    2315                 :         24 :       pop_stmt_list (stmt_expr);
    2316                 :         24 :       return error_mark_node;
    2317                 :            :     }
    2318                 :            : 
    2319                 :     771882 :   gcc_assert (TREE_CODE (stmt_expr) == STATEMENT_LIST);
    2320                 :            : 
    2321                 :     771882 :   type = TREE_TYPE (stmt_expr);
    2322                 :     771882 :   result = pop_stmt_list (stmt_expr);
    2323                 :     771882 :   TREE_TYPE (result) = type;
    2324                 :            : 
    2325                 :     771882 :   if (processing_template_decl)
    2326                 :            :     {
    2327                 :        261 :       result = build_min (STMT_EXPR, type, result);
    2328                 :        261 :       TREE_SIDE_EFFECTS (result) = 1;
    2329                 :        261 :       STMT_EXPR_NO_SCOPE (result) = has_no_scope;
    2330                 :            :     }
    2331                 :     771707 :   else if (CLASS_TYPE_P (type))
    2332                 :            :     {
    2333                 :            :       /* Wrap the statement-expression in a TARGET_EXPR so that the
    2334                 :            :          temporary object created by the final expression is destroyed at
    2335                 :            :          the end of the full-expression containing the
    2336                 :            :          statement-expression.  */
    2337                 :         86 :       result = force_target_expr (type, result, tf_warning_or_error);
    2338                 :            :     }
    2339                 :            : 
    2340                 :            :   return result;
    2341                 :            : }
    2342                 :            : 
    2343                 :            : /* Returns the expression which provides the value of STMT_EXPR.  */
    2344                 :            : 
    2345                 :            : tree
    2346                 :        465 : stmt_expr_value_expr (tree stmt_expr)
    2347                 :            : {
    2348                 :        465 :   tree t = STMT_EXPR_STMT (stmt_expr);
    2349                 :            : 
    2350                 :        465 :   if (TREE_CODE (t) == BIND_EXPR)
    2351                 :        465 :     t = BIND_EXPR_BODY (t);
    2352                 :            : 
    2353                 :        465 :   if (TREE_CODE (t) == STATEMENT_LIST && STATEMENT_LIST_TAIL (t))
    2354                 :        378 :     t = STATEMENT_LIST_TAIL (t)->stmt;
    2355                 :            : 
    2356                 :        465 :   if (TREE_CODE (t) == EXPR_STMT)
    2357                 :        423 :     t = EXPR_STMT_EXPR (t);
    2358                 :            : 
    2359                 :        465 :   return t;
    2360                 :            : }
    2361                 :            : 
    2362                 :            : /* Return TRUE iff EXPR_STMT is an empty list of
    2363                 :            :    expression statements.  */
    2364                 :            : 
    2365                 :            : bool
    2366                 :    2312610 : empty_expr_stmt_p (tree expr_stmt)
    2367                 :            : {
    2368                 :    2312620 :   tree body = NULL_TREE;
    2369                 :            : 
    2370                 :    2312620 :   if (expr_stmt == void_node)
    2371                 :            :     return true;
    2372                 :            : 
    2373                 :    2312620 :   if (expr_stmt)
    2374                 :            :     {
    2375                 :    2312620 :       if (TREE_CODE (expr_stmt) == EXPR_STMT)
    2376                 :          5 :         body = EXPR_STMT_EXPR (expr_stmt);
    2377                 :    2312610 :       else if (TREE_CODE (expr_stmt) == STATEMENT_LIST)
    2378                 :            :         body = expr_stmt;
    2379                 :            :     }
    2380                 :            : 
    2381                 :    2286180 :   if (body)
    2382                 :            :     {
    2383                 :    2286180 :       if (TREE_CODE (body) == STATEMENT_LIST)
    2384                 :    2286170 :         return tsi_end_p (tsi_start (body));
    2385                 :            :       else
    2386                 :            :         return empty_expr_stmt_p (body);
    2387                 :            :     }
    2388                 :            :   return false;
    2389                 :            : }
    2390                 :            : 
    2391                 :            : /* Perform Koenig lookup.  FN_EXPR is the postfix-expression representing
    2392                 :            :    the function (or functions) to call; ARGS are the arguments to the
    2393                 :            :    call.  Returns the functions to be considered by overload resolution.  */
    2394                 :            : 
    2395                 :            : cp_expr
    2396                 :    2641890 : perform_koenig_lookup (cp_expr fn_expr, vec<tree, va_gc> *args,
    2397                 :            :                        tsubst_flags_t complain)
    2398                 :            : {
    2399                 :    2641890 :   tree identifier = NULL_TREE;
    2400                 :    2641890 :   tree functions = NULL_TREE;
    2401                 :    2641890 :   tree tmpl_args = NULL_TREE;
    2402                 :    2641890 :   bool template_id = false;
    2403                 :    2641890 :   location_t loc = fn_expr.get_location ();
    2404                 :    2641890 :   tree fn = fn_expr.get_value ();
    2405                 :            : 
    2406                 :    2641890 :   STRIP_ANY_LOCATION_WRAPPER (fn);
    2407                 :            : 
    2408                 :    2641890 :   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
    2409                 :            :     {
    2410                 :            :       /* Use a separate flag to handle null args.  */
    2411                 :     403661 :       template_id = true;
    2412                 :     403661 :       tmpl_args = TREE_OPERAND (fn, 1);
    2413                 :     403661 :       fn = TREE_OPERAND (fn, 0);
    2414                 :            :     }
    2415                 :            : 
    2416                 :            :   /* Find the name of the overloaded function.  */
    2417                 :    2641890 :   if (identifier_p (fn))
    2418                 :            :     identifier = fn;
    2419                 :            :   else
    2420                 :            :     {
    2421                 :    3311560 :       functions = fn;
    2422                 :    2621540 :       identifier = OVL_NAME (functions);
    2423                 :            :     }
    2424                 :            : 
    2425                 :            :   /* A call to a namespace-scope function using an unqualified name.
    2426                 :            : 
    2427                 :            :      Do Koenig lookup -- unless any of the arguments are
    2428                 :            :      type-dependent.  */
    2429                 :    2641890 :   if (!any_type_dependent_arguments_p (args)
    2430                 :    2641890 :       && !any_dependent_template_arguments_p (tmpl_args))
    2431                 :            :     {
    2432                 :    2579680 :       fn = lookup_arg_dependent (identifier, functions, args);
    2433                 :    2579680 :       if (!fn)
    2434                 :            :         {
    2435                 :            :           /* The unqualified name could not be resolved.  */
    2436                 :      13503 :           if (complain & tf_error)
    2437                 :        360 :             fn = unqualified_fn_lookup_error (cp_expr (identifier, loc));
    2438                 :            :           else
    2439                 :            :             fn = identifier;
    2440                 :            :         }
    2441                 :            :     }
    2442                 :            : 
    2443                 :    2641890 :   if (fn && template_id && fn != error_mark_node)
    2444                 :     403655 :     fn = build2 (TEMPLATE_ID_EXPR, unknown_type_node, fn, tmpl_args);
    2445                 :            :   
    2446                 :    2641890 :   return cp_expr (fn, loc);
    2447                 :            : }
    2448                 :            : 
    2449                 :            : /* Generate an expression for `FN (ARGS)'.  This may change the
    2450                 :            :    contents of ARGS.
    2451                 :            : 
    2452                 :            :    If DISALLOW_VIRTUAL is true, the call to FN will be not generated
    2453                 :            :    as a virtual call, even if FN is virtual.  (This flag is set when
    2454                 :            :    encountering an expression where the function name is explicitly
    2455                 :            :    qualified.  For example a call to `X::f' never generates a virtual
    2456                 :            :    call.)
    2457                 :            : 
    2458                 :            :    Returns code for the call.  */
    2459                 :            : 
    2460                 :            : tree
    2461                 :   23437600 : finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,
    2462                 :            :                   bool koenig_p, tsubst_flags_t complain)
    2463                 :            : {
    2464                 :   23437600 :   tree result;
    2465                 :   23437600 :   tree orig_fn;
    2466                 :   23437600 :   vec<tree, va_gc> *orig_args = *args;
    2467                 :            : 
    2468                 :   23437600 :   if (fn == error_mark_node)
    2469                 :            :     return error_mark_node;
    2470                 :            : 
    2471                 :   23429900 :   gcc_assert (!TYPE_P (fn));
    2472                 :            : 
    2473                 :            :   /* If FN may be a FUNCTION_DECL obfuscated by force_paren_expr, undo
    2474                 :            :      it so that we can tell this is a call to a known function.  */
    2475                 :   23429900 :   fn = maybe_undo_parenthesized_ref (fn);
    2476                 :            : 
    2477                 :   23429900 :   STRIP_ANY_LOCATION_WRAPPER (fn);
    2478                 :            : 
    2479                 :   23429900 :   orig_fn = fn;
    2480                 :            : 
    2481                 :   23429900 :   if (processing_template_decl)
    2482                 :            :     {
    2483                 :            :       /* If FN is a local extern declaration or set thereof, look them up
    2484                 :            :          again at instantiation time.  */
    2485                 :    8437000 :       if (is_overloaded_fn (fn))
    2486                 :            :         {
    2487                 :    6470760 :           tree ifn = get_first_fn (fn);
    2488                 :    6470760 :           if (TREE_CODE (ifn) == FUNCTION_DECL
    2489                 :    6470760 :               && DECL_LOCAL_FUNCTION_P (ifn))
    2490                 :         37 :             orig_fn = DECL_NAME (ifn);
    2491                 :            :         }
    2492                 :            : 
    2493                 :            :       /* If the call expression is dependent, build a CALL_EXPR node
    2494                 :            :          with no type; type_dependent_expression_p recognizes
    2495                 :            :          expressions with no type as being dependent.  */
    2496                 :    8437000 :       if (type_dependent_expression_p (fn)
    2497                 :    8437000 :           || any_type_dependent_arguments_p (*args))
    2498                 :            :         {
    2499                 :    7369310 :           result = build_min_nt_call_vec (orig_fn, *args);
    2500                 :    7369310 :           SET_EXPR_LOCATION (result, cp_expr_loc_or_input_loc (fn));
    2501                 :    7369310 :           KOENIG_LOOKUP_P (result) = koenig_p;
    2502                 :    7369310 :           if (is_overloaded_fn (fn))
    2503                 :    5418510 :             fn = get_fns (fn);
    2504                 :            : 
    2505                 :    7369310 :           if (cfun)
    2506                 :            :             {
    2507                 :    4521510 :               bool abnormal = true;
    2508                 :   13564500 :               for (lkp_iterator iter (fn); abnormal && iter; ++iter)
    2509                 :            :                 {
    2510                 :    4521520 :                   tree fndecl = *iter;
    2511                 :    4521520 :                   if (TREE_CODE (fndecl) != FUNCTION_DECL
    2512                 :    4521520 :                       || !TREE_THIS_VOLATILE (fndecl))
    2513                 :    4508420 :                     abnormal = false;
    2514                 :            :                 }
    2515                 :            :               /* FIXME: Stop warning about falling off end of non-void
    2516                 :            :                  function.   But this is wrong.  Even if we only see
    2517                 :            :                  no-return fns at this point, we could select a
    2518                 :            :                  future-defined return fn during instantiation.  Or
    2519                 :            :                  vice-versa.  */
    2520                 :    4521510 :               if (abnormal)
    2521                 :      13087 :                 current_function_returns_abnormally = 1;
    2522                 :            :             }
    2523                 :    7369310 :           return result;
    2524                 :            :         }
    2525                 :    1067690 :       orig_args = make_tree_vector_copy (*args);
    2526                 :    1067690 :       if (!BASELINK_P (fn)
    2527                 :     470163 :           && TREE_CODE (fn) != PSEUDO_DTOR_EXPR
    2528                 :    1537820 :           && TREE_TYPE (fn) != unknown_type_node)
    2529                 :     311131 :         fn = build_non_dependent_expr (fn);
    2530                 :    1067690 :       make_args_non_dependent (*args);
    2531                 :            :     }
    2532                 :            : 
    2533                 :   16060600 :   if (TREE_CODE (fn) == COMPONENT_REF)
    2534                 :            :     {
    2535                 :      27220 :       tree member = TREE_OPERAND (fn, 1);
    2536                 :      27220 :       if (BASELINK_P (member))
    2537                 :            :         {
    2538                 :       7093 :           tree object = TREE_OPERAND (fn, 0);
    2539                 :      14186 :           return build_new_method_call (object, member,
    2540                 :            :                                         args, NULL_TREE,
    2541                 :            :                                         (disallow_virtual
    2542                 :            :                                          ? LOOKUP_NORMAL | LOOKUP_NONVIRTUAL
    2543                 :            :                                          : LOOKUP_NORMAL),
    2544                 :            :                                         /*fn_p=*/NULL,
    2545                 :       7093 :                                         complain);
    2546                 :            :         }
    2547                 :            :     }
    2548                 :            : 
    2549                 :            :   /* Per 13.3.1.1, '(&f)(...)' is the same as '(f)(...)'.  */
    2550                 :   16053500 :   if (TREE_CODE (fn) == ADDR_EXPR
    2551                 :   16053500 :       && TREE_CODE (TREE_OPERAND (fn, 0)) == OVERLOAD)
    2552                 :         12 :     fn = TREE_OPERAND (fn, 0);
    2553                 :            : 
    2554                 :   16053500 :   if (is_overloaded_fn (fn))
    2555                 :   14522100 :     fn = baselink_for_fns (fn);
    2556                 :            : 
    2557                 :   16053500 :   result = NULL_TREE;
    2558                 :   16053500 :   if (BASELINK_P (fn))
    2559                 :            :     {
    2560                 :    3439080 :       tree object;
    2561                 :            : 
    2562                 :            :       /* A call to a member function.  From [over.call.func]:
    2563                 :            : 
    2564                 :            :            If the keyword this is in scope and refers to the class of
    2565                 :            :            that member function, or a derived class thereof, then the
    2566                 :            :            function call is transformed into a qualified function call
    2567                 :            :            using (*this) as the postfix-expression to the left of the
    2568                 :            :            . operator.... [Otherwise] a contrived object of type T
    2569                 :            :            becomes the implied object argument.
    2570                 :            : 
    2571                 :            :         In this situation:
    2572                 :            : 
    2573                 :            :           struct A { void f(); };
    2574                 :            :           struct B : public A {};
    2575                 :            :           struct C : public A { void g() { B::f(); }};
    2576                 :            : 
    2577                 :            :         "the class of that member function" refers to `A'.  But 11.2
    2578                 :            :         [class.access.base] says that we need to convert 'this' to B* as
    2579                 :            :         part of the access, so we pass 'B' to maybe_dummy_object.  */
    2580                 :            : 
    2581                 :    3439080 :       if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (get_first_fn (fn)))
    2582                 :            :         {
    2583                 :            :           /* A constructor call always uses a dummy object.  (This constructor
    2584                 :            :              call which has the form A::A () is actually invalid and we are
    2585                 :            :              going to reject it later in build_new_method_call.)  */
    2586                 :         63 :           object = build_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)));
    2587                 :            :         }
    2588                 :            :       else
    2589                 :    3439020 :         object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
    2590                 :            :                                      NULL);
    2591                 :            : 
    2592                 :    3564140 :       result = build_new_method_call (object, fn, args, NULL_TREE,
    2593                 :            :                                       (disallow_virtual
    2594                 :            :                                        ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL
    2595                 :            :                                        : LOOKUP_NORMAL),
    2596                 :            :                                       /*fn_p=*/NULL,
    2597                 :            :                                       complain);
    2598                 :            :     }
    2599                 :   12614400 :   else if (concept_check_p (fn))
    2600                 :            :     {
    2601                 :            :       /* FN is actually a template-id referring to a concept definition.  */
    2602                 :        110 :       tree id = unpack_concept_check (fn);
    2603                 :        110 :       tree tmpl = TREE_OPERAND (id, 0);
    2604                 :        110 :       tree args = TREE_OPERAND (id, 1);
    2605                 :            : 
    2606                 :        110 :       if (!function_concept_p (tmpl))
    2607                 :            :         {
    2608                 :          1 :           error_at (EXPR_LOC_OR_LOC (fn, input_location),
    2609                 :            :                     "cannot call a concept as a function");
    2610                 :          1 :           return error_mark_node;
    2611                 :            :         }
    2612                 :            : 
    2613                 :            :       /* Ensure the result is wrapped as a call expression.  */
    2614                 :        109 :       result = build_concept_check (tmpl, args, tf_warning_or_error);
    2615                 :            :     }
    2616                 :   12614300 :   else if (is_overloaded_fn (fn))
    2617                 :            :     {
    2618                 :            :       /* If the function is an overloaded builtin, resolve it.  */
    2619                 :   11083000 :       if (TREE_CODE (fn) == FUNCTION_DECL
    2620                 :   11083000 :           && (DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
    2621                 :    3244720 :               || DECL_BUILT_IN_CLASS (fn) == BUILT_IN_MD))
    2622                 :    1649660 :         result = resolve_overloaded_builtin (input_location, fn, *args);
    2623                 :            : 
    2624                 :    1649660 :       if (!result)
    2625                 :            :         {
    2626                 :   10983700 :           if (warn_sizeof_pointer_memaccess
    2627                 :    1006140 :               && (complain & tf_warning)
    2628                 :     987022 :               && !vec_safe_is_empty (*args)
    2629                 :   11768300 :               && !processing_template_decl)
    2630                 :            :             {
    2631                 :            :               location_t sizeof_arg_loc[3];
    2632                 :            :               tree sizeof_arg[3];
    2633                 :            :               unsigned int i;
    2634                 :    2807610 :               for (i = 0; i < 3; i++)
    2635                 :            :                 {
    2636                 :    2105710 :                   tree t;
    2637                 :            : 
    2638                 :    2105710 :                   sizeof_arg_loc[i] = UNKNOWN_LOCATION;
    2639                 :    2105710 :                   sizeof_arg[i] = NULL_TREE;
    2640                 :    2105710 :                   if (i >= (*args)->length ())
    2641                 :     410339 :                     continue;
    2642                 :    1695370 :                   t = (**args)[i];
    2643                 :    1695370 :                   if (TREE_CODE (t) != SIZEOF_EXPR)
    2644                 :    1689590 :                     continue;
    2645                 :       5780 :                   if (SIZEOF_EXPR_TYPE_P (t))
    2646                 :       1683 :                     sizeof_arg[i] = TREE_TYPE (TREE_OPERAND (t, 0));
    2647                 :            :                   else
    2648                 :       4097 :                     sizeof_arg[i] = TREE_OPERAND (t, 0);
    2649                 :       5780 :                   sizeof_arg_loc[i] = EXPR_LOCATION (t);
    2650                 :            :                 }
    2651                 :     701902 :               sizeof_pointer_memaccess_warning
    2652                 :     701902 :                 (sizeof_arg_loc, fn, *args,
    2653                 :            :                  sizeof_arg, same_type_ignoring_top_level_qualifiers_p);
    2654                 :            :             }
    2655                 :            : 
    2656                 :   10983700 :           if ((complain & tf_warning)
    2657                 :    6977700 :               && TREE_CODE (fn) == FUNCTION_DECL
    2658                 :    3951270 :               && fndecl_built_in_p (fn, BUILT_IN_MEMSET)
    2659                 :      25798 :               && vec_safe_length (*args) == 3
    2660                 :   11009500 :               && !any_type_dependent_arguments_p (*args))
    2661                 :            :             {
    2662                 :      25798 :               tree arg0 = (*orig_args)[0];
    2663                 :      25798 :               tree arg1 = (*orig_args)[1];
    2664                 :      25798 :               tree arg2 = (*orig_args)[2];
    2665                 :      25798 :               int literal_mask = ((literal_integer_zerop (arg1) << 1)
    2666                 :      25798 :                                   | (literal_integer_zerop (arg2) << 2));
    2667                 :      25798 :               warn_for_memset (input_location, arg0, arg2, literal_mask);
    2668                 :            :             }
    2669                 :            : 
    2670                 :            :           /* A call to a namespace-scope function.  */
    2671                 :   10983700 :           result = build_new_function_call (fn, args, complain);
    2672                 :            :         }
    2673                 :            :     }
    2674                 :    1531320 :   else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
    2675                 :            :     {
    2676                 :       8584 :       if (!vec_safe_is_empty (*args))
    2677                 :          0 :         error ("arguments to destructor are not allowed");
    2678                 :            :       /* Mark the pseudo-destructor call as having side-effects so
    2679                 :            :          that we do not issue warnings about its use.  */
    2680                 :       8584 :       result = build1 (NOP_EXPR,
    2681                 :            :                        void_type_node,
    2682                 :       8584 :                        TREE_OPERAND (fn, 0));
    2683                 :       8584 :       TREE_SIDE_EFFECTS (result) = 1;
    2684                 :            :     }
    2685                 :    1522740 :   else if (CLASS_TYPE_P (TREE_TYPE (fn)))
    2686                 :            :     /* If the "function" is really an object of class type, it might
    2687                 :            :        have an overloaded `operator ()'.  */
    2688                 :     308095 :     result = build_op_call (fn, args, complain);
    2689                 :            : 
    2690                 :   14826200 :   if (!result)
    2691                 :            :     /* A call where the function is unknown.  */
    2692                 :    1214640 :     result = cp_build_function_call_vec (fn, args, complain);
    2693                 :            : 
    2694                 :   16040800 :   if (processing_template_decl && result != error_mark_node)
    2695                 :            :     {
    2696                 :    1063540 :       if (INDIRECT_REF_P (result))
    2697                 :     110502 :         result = TREE_OPERAND (result, 0);
    2698                 :    1063540 :       result = build_call_vec (TREE_TYPE (result), orig_fn, orig_args);
    2699                 :    1063540 :       SET_EXPR_LOCATION (result, input_location);
    2700                 :    1063540 :       KOENIG_LOOKUP_P (result) = koenig_p;
    2701                 :    1063540 :       release_tree_vector (orig_args);
    2702                 :    1063540 :       result = convert_from_reference (result);
    2703                 :            :     }
    2704                 :            : 
    2705                 :            :   return result;
    2706                 :            : }
    2707                 :            : 
    2708                 :            : /* Finish a call to a postfix increment or decrement or EXPR.  (Which
    2709                 :            :    is indicated by CODE, which should be POSTINCREMENT_EXPR or
    2710                 :            :    POSTDECREMENT_EXPR.)  */
    2711                 :            : 
    2712                 :            : cp_expr
    2713                 :     213187 : finish_increment_expr (cp_expr expr, enum tree_code code)
    2714                 :            : {
    2715                 :            :   /* input_location holds the location of the trailing operator token.
    2716                 :            :      Build a location of the form:
    2717                 :            :        expr++
    2718                 :            :        ~~~~^~
    2719                 :            :      with the caret at the operator token, ranging from the start
    2720                 :            :      of EXPR to the end of the operator token.  */
    2721                 :     213187 :   location_t combined_loc = make_location (input_location,
    2722                 :            :                                            expr.get_start (),
    2723                 :            :                                            get_finish (input_location));
    2724                 :     213187 :   cp_expr result = build_x_unary_op (combined_loc, code, expr,
    2725                 :     213187 :                                      tf_warning_or_error);
    2726                 :            :   /* TODO: build_x_unary_op doesn't honor the location, so set it here.  */
    2727                 :     213187 :   result.set_location (combined_loc);
    2728                 :     213187 :   return result;
    2729                 :            : }
    2730                 :            : 
    2731                 :            : /* Finish a use of `this'.  Returns an expression for `this'.  */
    2732                 :            : 
    2733                 :            : tree
    2734                 :    2110330 : finish_this_expr (void)
    2735                 :            : {
    2736                 :    2110330 :   tree result = NULL_TREE;
    2737                 :            : 
    2738                 :    2110330 :   if (current_class_ptr)
    2739                 :            :     {
    2740                 :    2110320 :       tree type = TREE_TYPE (current_class_ref);
    2741                 :            : 
    2742                 :            :       /* In a lambda expression, 'this' refers to the captured 'this'.  */
    2743                 :    4220610 :       if (LAMBDA_TYPE_P (type))
    2744                 :        902 :         result = lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type), true);
    2745                 :            :       else
    2746                 :    2109410 :         result = current_class_ptr;
    2747                 :            :     }
    2748                 :            : 
    2749                 :    2110320 :   if (result)
    2750                 :            :     /* The keyword 'this' is a prvalue expression.  */
    2751                 :    2110310 :     return rvalue (result);
    2752                 :            : 
    2753                 :         17 :   tree fn = current_nonlambda_function ();
    2754                 :         25 :   if (fn && DECL_STATIC_FUNCTION_P (fn))
    2755                 :          4 :     error ("%<this%> is unavailable for static member functions");
    2756                 :         13 :   else if (fn)
    2757                 :          4 :     error ("invalid use of %<this%> in non-member function");
    2758                 :            :   else
    2759                 :          9 :     error ("invalid use of %<this%> at top level");
    2760                 :         17 :   return error_mark_node;
    2761                 :            : }
    2762                 :            : 
    2763                 :            : /* Finish a pseudo-destructor expression.  If SCOPE is NULL, the
    2764                 :            :    expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
    2765                 :            :    the TYPE for the type given.  If SCOPE is non-NULL, the expression
    2766                 :            :    was of the form `OBJECT.SCOPE::~DESTRUCTOR'.  */
    2767                 :            : 
    2768                 :            : tree
    2769                 :       8627 : finish_pseudo_destructor_expr (tree object, tree scope, tree destructor,
    2770                 :            :                                location_t loc)
    2771                 :            : {
    2772                 :       8627 :   if (object == error_mark_node || destructor == error_mark_node)
    2773                 :            :     return error_mark_node;
    2774                 :            : 
    2775                 :       8616 :   gcc_assert (TYPE_P (destructor));
    2776                 :            : 
    2777                 :       8616 :   if (!processing_template_decl)
    2778                 :            :     {
    2779                 :       8588 :       if (scope == error_mark_node)
    2780                 :            :         {
    2781                 :          0 :           error_at (loc, "invalid qualifying scope in pseudo-destructor name");
    2782                 :          0 :           return error_mark_node;
    2783                 :            :         }
    2784                 :       8588 :       if (is_auto (destructor))
    2785                 :          3 :         destructor = TREE_TYPE (object);
    2786                 :       8588 :       if (scope && TYPE_P (scope) && !check_dtor_name (scope, destructor))
    2787                 :            :         {
    2788                 :          4 :           error_at (loc,
    2789                 :            :                     "qualified type %qT does not match destructor name ~%qT",
    2790                 :            :                     scope, destructor);
    2791                 :          4 :           return error_mark_node;
    2792                 :            :         }
    2793                 :            : 
    2794                 :            : 
    2795                 :            :       /* [expr.pseudo] says both:
    2796                 :            : 
    2797                 :            :            The type designated by the pseudo-destructor-name shall be
    2798                 :            :            the same as the object type.
    2799                 :            : 
    2800                 :            :          and:
    2801                 :            : 
    2802                 :            :            The cv-unqualified versions of the object type and of the
    2803                 :            :            type designated by the pseudo-destructor-name shall be the
    2804                 :            :            same type.
    2805                 :            : 
    2806                 :            :          We implement the more generous second sentence, since that is
    2807                 :            :          what most other compilers do.  */
    2808                 :       8584 :       if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
    2809                 :            :                                                       destructor))
    2810                 :            :         {
    2811                 :         12 :           error_at (loc, "%qE is not of type %qT", object, destructor);
    2812                 :         12 :           return error_mark_node;
    2813                 :            :         }
    2814                 :            :     }
    2815                 :            : 
    2816                 :       8600 :   return build3_loc (loc, PSEUDO_DTOR_EXPR, void_type_node, object,
    2817                 :            :                      scope, destructor);
    2818                 :            : }
    2819                 :            : 
    2820                 :            : /* Finish an expression of the form CODE EXPR.  */
    2821                 :            : 
    2822                 :            : cp_expr
    2823                 :    2208000 : finish_unary_op_expr (location_t op_loc, enum tree_code code, cp_expr expr,
    2824                 :            :                       tsubst_flags_t complain)
    2825                 :            : {
    2826                 :            :   /* Build a location of the form:
    2827                 :            :        ++expr
    2828                 :            :        ^~~~~~
    2829                 :            :      with the caret at the operator token, ranging from the start
    2830                 :            :      of the operator token to the end of EXPR.  */
    2831                 :    2208000 :   location_t combined_loc = make_location (op_loc,
    2832                 :            :                                            op_loc, expr.get_finish ());
    2833                 :    2208000 :   cp_expr result = build_x_unary_op (combined_loc, code, expr, complain);
    2834                 :            :   /* TODO: build_x_unary_op doesn't always honor the location.  */
    2835                 :    2208000 :   result.set_location (combined_loc);
    2836                 :            : 
    2837                 :    2208000 :   if (result == error_mark_node)
    2838                 :        233 :     return result;
    2839                 :            : 
    2840                 :    2207770 :   if (!(complain & tf_warning))
    2841                 :          0 :     return result;
    2842                 :            : 
    2843                 :    2207770 :   tree result_ovl = result;
    2844                 :    2207770 :   tree expr_ovl = expr;
    2845                 :            : 
    2846                 :    2207770 :   if (!processing_template_decl)
    2847                 :     536478 :     expr_ovl = cp_fully_fold (expr_ovl);
    2848                 :            : 
    2849                 :    2207770 :   if (!CONSTANT_CLASS_P (expr_ovl)
    2850                 :    2207770 :       || TREE_OVERFLOW_P (expr_ovl))
    2851                 :    2129230 :     return result;
    2852                 :            : 
    2853                 :      78540 :   if (!processing_template_decl)
    2854                 :      77868 :     result_ovl = cp_fully_fold (result_ovl);
    2855                 :            : 
    2856                 :      78540 :   if (CONSTANT_CLASS_P (result_ovl) && TREE_OVERFLOW_P (result_ovl))
    2857                 :         10 :     overflow_warning (combined_loc, result_ovl);
    2858                 :            : 
    2859                 :      78540 :   return result;
    2860                 :            : }
    2861                 :            : 
    2862                 :            : /* Finish a compound-literal expression or C++11 functional cast with aggregate
    2863                 :            :    initializer.  TYPE is the type to which the CONSTRUCTOR in COMPOUND_LITERAL
    2864                 :            :    is being cast.  */
    2865                 :            : 
    2866                 :            : tree
    2867                 :    1155470 : finish_compound_literal (tree type, tree compound_literal,
    2868                 :            :                          tsubst_flags_t complain,
    2869                 :            :                          fcl_t fcl_context)
    2870                 :            : {
    2871                 :    1155470 :   if (type == error_mark_node)
    2872                 :            :     return error_mark_node;
    2873                 :            : 
    2874                 :    1155460 :   if (TYPE_REF_P (type))
    2875                 :            :     {
    2876                 :         33 :       compound_literal
    2877                 :         33 :         = finish_compound_literal (TREE_TYPE (type), compound_literal,
    2878                 :            :                                    complain, fcl_context);
    2879                 :            :       /* The prvalue is then used to direct-initialize the reference.  */
    2880                 :         33 :       tree r = (perform_implicit_conversion_flags
    2881                 :         33 :                 (type, compound_literal, complain, LOOKUP_NORMAL));
    2882                 :         33 :       return convert_from_reference (r);
    2883                 :            :     }
    2884                 :            : 
    2885                 :    1155420 :   if (!TYPE_OBJ_P (type))
    2886                 :            :     {
    2887                 :          7 :       if (complain & tf_error)
    2888                 :          4 :         error ("compound literal of non-object type %qT", type);
    2889                 :          7 :       return error_mark_node;
    2890                 :            :     }
    2891                 :            : 
    2892                 :    1155420 :   if (tree anode = type_uses_auto (type))
    2893                 :       9169 :     if (CLASS_PLACEHOLDER_TEMPLATE (anode))
    2894                 :            :       {
    2895                 :       9169 :         type = do_auto_deduction (type, compound_literal, anode, complain,
    2896                 :            :                                   adc_variable_type);
    2897                 :       9169 :         if (type == error_mark_node)
    2898                 :            :           return error_mark_node;
    2899                 :            :       }
    2900                 :            : 
    2901                 :            :   /* Used to hold a copy of the compound literal in a template.  */
    2902                 :    1155410 :   tree orig_cl = NULL_TREE;
    2903                 :            : 
    2904                 :    1155410 :   if (processing_template_decl)
    2905                 :            :     {
    2906                 :     330960 :       const bool dependent_p
    2907                 :     330960 :         = (instantiation_dependent_expression_p (compound_literal)
    2908                 :     330960 :            || dependent_type_p (type));
    2909                 :      71619 :       if (dependent_p)
    2910                 :            :         /* We're about to return, no need to copy.  */
    2911                 :            :         orig_cl = compound_literal;
    2912                 :            :       else
    2913                 :            :         /* We're going to need a copy.  */
    2914                 :      71619 :         orig_cl = unshare_constructor (compound_literal);
    2915                 :     330960 :       TREE_TYPE (orig_cl) = type;
    2916                 :            :       /* Mark the expression as a compound literal.  */
    2917                 :     330960 :       TREE_HAS_CONSTRUCTOR (orig_cl) = 1;
    2918                 :            :       /* And as instantiation-dependent.  */
    2919                 :     330960 :       CONSTRUCTOR_IS_DEPENDENT (orig_cl) = dependent_p;
    2920                 :     330960 :       if (fcl_context == fcl_c99)
    2921                 :         37 :         CONSTRUCTOR_C99_COMPOUND_LITERAL (orig_cl) = 1;
    2922                 :            :       /* If the compound literal is dependent, we're done for now.  */
    2923                 :     330960 :       if (dependent_p)
    2924                 :            :         return orig_cl;
    2925                 :            :       /* Otherwise, do go on to e.g. check narrowing.  */
    2926                 :            :     }
    2927                 :            : 
    2928                 :     896067 :   type = complete_type (type);
    2929                 :            : 
    2930                 :     896067 :   if (TYPE_NON_AGGREGATE_CLASS (type))
    2931                 :            :     {
    2932                 :            :       /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
    2933                 :            :          everywhere that deals with function arguments would be a pain, so
    2934                 :            :          just wrap it in a TREE_LIST.  The parser set a flag so we know
    2935                 :            :          that it came from T{} rather than T({}).  */
    2936                 :     173906 :       CONSTRUCTOR_IS_DIRECT_INIT (compound_literal) = 1;
    2937                 :     173906 :       compound_literal = build_tree_list (NULL_TREE, compound_literal);
    2938                 :     173906 :       return build_functional_cast (input_location, type,
    2939                 :     173906 :                                     compound_literal, complain);
    2940                 :            :     }
    2941                 :            : 
    2942                 :     722161 :   if (TREE_CODE (type) == ARRAY_TYPE
    2943                 :     722161 :       && check_array_initializer (NULL_TREE, type, compound_literal))
    2944                 :         12 :     return error_mark_node;
    2945                 :     722149 :   compound_literal = reshape_init (type, compound_literal, complain);
    2946                 :     721503 :   if (SCALAR_TYPE_P (type)
    2947                 :     808653 :       && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal))
    2948                 :            :     {
    2949                 :        514 :       tree t = instantiate_non_dependent_expr_sfinae (compound_literal,
    2950                 :            :                                                       complain);
    2951                 :        514 :       if (!check_narrowing (type, t, complain))
    2952                 :         34 :         return error_mark_node;
    2953                 :            :     }
    2954                 :     722115 :   if (TREE_CODE (type) == ARRAY_TYPE
    2955                 :     722115 :       && TYPE_DOMAIN (type) == NULL_TREE)
    2956                 :            :     {
    2957                 :        134 :       cp_complete_array_type_or_error (&type, compound_literal,
    2958                 :            :                                        false, complain);
    2959                 :        134 :       if (type == error_mark_node)
    2960                 :            :         return error_mark_node;
    2961                 :            :     }
    2962                 :     722112 :   compound_literal = digest_init_flags (type, compound_literal,
    2963                 :            :                                         LOOKUP_NORMAL | LOOKUP_NO_NARROWING,
    2964                 :            :                                         complain);
    2965                 :     722112 :   if (compound_literal == error_mark_node)
    2966                 :            :     return error_mark_node;
    2967                 :            : 
    2968                 :            :   /* If we're in a template, return the original compound literal.  */
    2969                 :     721821 :   if (orig_cl)
    2970                 :            :     {
    2971                 :      67503 :       if (!VECTOR_TYPE_P (type))
    2972                 :      67503 :         return get_target_expr_sfinae (orig_cl, complain);
    2973                 :            :       else
    2974                 :            :         return orig_cl;
    2975                 :            :     }
    2976                 :            : 
    2977                 :     654318 :   if (TREE_CODE (compound_literal) == CONSTRUCTOR)
    2978                 :            :     {
    2979                 :     615356 :       TREE_HAS_CONSTRUCTOR (compound_literal) = true;
    2980                 :     615356 :       if (fcl_context == fcl_c99)
    2981                 :      21752 :         CONSTRUCTOR_C99_COMPOUND_LITERAL (compound_literal) = 1;
    2982                 :            :     }
    2983                 :            : 
    2984                 :            :   /* Put static/constant array temporaries in static variables.  */
    2985                 :            :   /* FIXME all C99 compound literals should be variables rather than C++
    2986                 :            :      temporaries, unless they are used as an aggregate initializer.  */
    2987                 :     807473 :   if ((!at_function_scope_p () || CP_TYPE_CONST_P (type))
    2988                 :     502284 :       && fcl_context == fcl_c99
    2989                 :         94 :       && TREE_CODE (type) == ARRAY_TYPE
    2990                 :         37 :       && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
    2991                 :     654355 :       && initializer_constant_valid_p (compound_literal, type))
    2992                 :            :     {
    2993                 :         37 :       tree decl = create_temporary_var (type);
    2994                 :         37 :       DECL_INITIAL (decl) = compound_literal;
    2995                 :         37 :       TREE_STATIC (decl) = 1;
    2996                 :         37 :       if (literal_type_p (type) && CP_TYPE_CONST_NON_VOLATILE_P (type))
    2997                 :            :         {
    2998                 :            :           /* 5.19 says that a constant expression can include an
    2999                 :            :              lvalue-rvalue conversion applied to "a glvalue of literal type
    3000                 :            :              that refers to a non-volatile temporary object initialized
    3001                 :            :              with a constant expression".  Rather than try to communicate
    3002                 :            :              that this VAR_DECL is a temporary, just mark it constexpr.  */
    3003                 :         64 :           DECL_DECLARED_CONSTEXPR_P (decl) = true;
    3004                 :         32 :           DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = true;
    3005                 :         32 :           TREE_CONSTANT (decl) = true;
    3006                 :            :         }
    3007                 :         37 :       cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
    3008                 :         37 :       decl = pushdecl_top_level (decl);
    3009                 :         37 :       DECL_NAME (decl) = make_anon_name ();
    3010                 :         37 :       SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
    3011                 :            :       /* Make sure the destructor is callable.  */
    3012                 :         37 :       tree clean = cxx_maybe_build_cleanup (decl, complain);
    3013                 :         37 :       if (clean == error_mark_node)
    3014                 :            :         return error_mark_node;
    3015                 :         37 :       return decl;
    3016                 :            :     }
    3017                 :            : 
    3018                 :            :   /* Represent other compound literals with TARGET_EXPR so we produce
    3019                 :            :      an lvalue, but can elide copies.  */
    3020                 :     654281 :   if (!VECTOR_TYPE_P (type))
    3021                 :     633163 :     compound_literal = get_target_expr_sfinae (compound_literal, complain);
    3022                 :            : 
    3023                 :            :   return compound_literal;
    3024                 :            : }
    3025                 :            : 
    3026                 :            : /* Return the declaration for the function-name variable indicated by
    3027                 :            :    ID.  */
    3028                 :            : 
    3029                 :            : tree
    3030                 :      75555 : finish_fname (tree id)
    3031                 :            : {
    3032                 :      75555 :   tree decl;
    3033                 :            : 
    3034                 :      75555 :   decl = fname_decl (input_location, C_RID_CODE (id), id);
    3035                 :      75555 :   if (processing_template_decl && current_function_decl
    3036                 :      34052 :       && decl != error_mark_node)
    3037                 :      34052 :     decl = DECL_NAME (decl);
    3038                 :      75555 :   return decl;
    3039                 :            : }
    3040                 :            : 
    3041                 :            : /* Finish a translation unit.  */
    3042                 :            : 
    3043                 :            : void
    3044                 :      77761 : finish_translation_unit (void)
    3045                 :            : {
    3046                 :            :   /* In case there were missing closebraces,
    3047                 :            :      get us back to the global binding level.  */
    3048                 :      77761 :   pop_everything ();
    3049                 :      77761 :   while (current_namespace != global_namespace)
    3050                 :          0 :     pop_namespace ();
    3051                 :            : 
    3052                 :            :   /* Do file scope __FUNCTION__ et al.  */
    3053                 :      77761 :   finish_fname_decls ();
    3054                 :            : 
    3055                 :      77761 :   if (scope_chain->omp_declare_target_attribute)
    3056                 :            :     {
    3057                 :          4 :       if (!errorcount)
    3058                 :          4 :         error ("%<#pragma omp declare target%> without corresponding "
    3059                 :            :                "%<#pragma omp end declare target%>");
    3060                 :          4 :       scope_chain->omp_declare_target_attribute = 0;
    3061                 :            :     }
    3062                 :      77761 : }
    3063                 :            : 
    3064                 :            : /* Finish a template type parameter, specified as AGGR IDENTIFIER.
    3065                 :            :    Returns the parameter.  */
    3066                 :            : 
    3067                 :            : tree
    3068                 :   12912900 : finish_template_type_parm (tree aggr, tree identifier)
    3069                 :            : {
    3070                 :   12912900 :   if (aggr != class_type_node)
    3071                 :            :     {
    3072                 :          0 :       permerror (input_location, "template type parameters must use the keyword %<class%> or %<typename%>");
    3073                 :          0 :       aggr = class_type_node;
    3074                 :            :     }
    3075                 :            : 
    3076                 :   12912900 :   return build_tree_list (aggr, identifier);
    3077                 :            : }
    3078                 :            : 
    3079                 :            : /* Finish a template template parameter, specified as AGGR IDENTIFIER.
    3080                 :            :    Returns the parameter.  */
    3081                 :            : 
    3082                 :            : tree
    3083                 :      55643 : finish_template_template_parm (tree aggr, tree identifier)
    3084                 :            : {
    3085                 :      55643 :   tree decl = build_decl (input_location,
    3086                 :            :                           TYPE_DECL, identifier, NULL_TREE);
    3087                 :            : 
    3088                 :      55643 :   tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
    3089                 :      55643 :   DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
    3090                 :      55643 :   DECL_TEMPLATE_RESULT (tmpl) = decl;
    3091                 :      55643 :   DECL_ARTIFICIAL (decl) = 1;
    3092                 :            : 
    3093                 :            :   /* Associate the constraints with the underlying declaration,
    3094                 :            :      not the template.  */
    3095                 :      55643 :   tree reqs = TEMPLATE_PARMS_CONSTRAINTS (current_template_parms);
    3096                 :      55643 :   tree constr = build_constraints (reqs, NULL_TREE);
    3097                 :      55643 :   set_constraints (decl, constr);
    3098                 :            : 
    3099                 :      55643 :   end_template_decl ();
    3100                 :            : 
    3101                 :      55643 :   gcc_assert (DECL_TEMPLATE_PARMS (tmpl));
    3102                 :            : 
    3103                 :      55643 :   check_default_tmpl_args (decl, DECL_TEMPLATE_PARMS (tmpl),
    3104                 :            :                            /*is_primary=*/true, /*is_partial=*/false,
    3105                 :            :                            /*is_friend=*/0);
    3106                 :            : 
    3107                 :      55643 :   return finish_template_type_parm (aggr, tmpl);
    3108                 :            : }
    3109                 :            : 
    3110                 :            : /* ARGUMENT is the default-argument value for a template template
    3111                 :            :    parameter.  If ARGUMENT is invalid, issue error messages and return
    3112                 :            :    the ERROR_MARK_NODE.  Otherwise, ARGUMENT itself is returned.  */
    3113                 :            : 
    3114                 :            : tree
    3115                 :        849 : check_template_template_default_arg (tree argument)
    3116                 :            : {
    3117                 :        849 :   if (TREE_CODE (argument) != TEMPLATE_DECL
    3118                 :        849 :       && TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
    3119                 :         32 :       && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
    3120                 :            :     {
    3121                 :         24 :       if (TREE_CODE (argument) == TYPE_DECL)
    3122                 :         24 :         error ("invalid use of type %qT as a default value for a template "
    3123                 :         24 :                "template-parameter", TREE_TYPE (argument));
    3124                 :            :       else
    3125                 :          0 :         error ("invalid default argument for a template template parameter");
    3126                 :         24 :       return error_mark_node;
    3127                 :            :     }
    3128                 :            : 
    3129                 :            :   return argument;
    3130                 :            : }
    3131                 :            : 
    3132                 :            : /* Begin a class definition, as indicated by T.  */
    3133                 :            : 
    3134                 :            : tree
    3135                 :    3976490 : begin_class_definition (tree t)
    3136                 :            : {
    3137                 :   11929400 :   if (error_operand_p (t) || error_operand_p (TYPE_MAIN_DECL (t)))
    3138                 :            :     return error_mark_node;
    3139                 :            : 
    3140                 :    3976450 :   if (processing_template_parmlist && !LAMBDA_TYPE_P (t))
    3141                 :            :     {
    3142                 :         12 :       error ("definition of %q#T inside template parameter list", t);
    3143                 :         12 :       return error_mark_node;
    3144                 :            :     }
    3145                 :            : 
    3146                 :            :   /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
    3147                 :            :      are passed the same as decimal scalar types.  */
    3148                 :    3976430 :   if (TREE_CODE (t) == RECORD_TYPE
    3149                 :    3887910 :       && !processing_template_decl)
    3150                 :            :     {
    3151                 :    1337910 :       tree ns = TYPE_CONTEXT (t);
    3152                 :    1337910 :       if (ns && TREE_CODE (ns) == NAMESPACE_DECL
    3153                 :    1025920 :           && DECL_CONTEXT (ns) == std_node
    3154                 :      86079 :           && DECL_NAME (ns)
    3155                 :    1423980 :           && id_equal (DECL_NAME (ns), "decimal"))
    3156                 :            :         {
    3157                 :        150 :           const char *n = TYPE_NAME_STRING (t);
    3158                 :        150 :           if ((strcmp (n, "decimal32") == 0)
    3159                 :        104 :               || (strcmp (n, "decimal64") == 0)
    3160                 :         46 :               || (strcmp (n, "decimal128") == 0))
    3161                 :        146 :             TYPE_TRANSPARENT_AGGR (t) = 1;
    3162                 :            :         }
    3163                 :            :     }
    3164                 :            : 
    3165                 :            :   /* A non-implicit typename comes from code like:
    3166                 :            : 
    3167                 :            :        template <typename T> struct A {
    3168                 :            :          template <typename U> struct A<T>::B ...
    3169                 :            : 
    3170                 :            :      This is erroneous.  */
    3171                 :    2638520 :   else if (TREE_CODE (t) == TYPENAME_TYPE)
    3172                 :            :     {
    3173                 :          0 :       error ("invalid definition of qualified type %qT", t);
    3174                 :          0 :       t = error_mark_node;
    3175                 :            :     }
    3176                 :            : 
    3177                 :    7952870 :   if (t == error_mark_node || ! MAYBE_CLASS_TYPE_P (t))
    3178                 :            :     {
    3179                 :          0 :       t = make_class_type (RECORD_TYPE);
    3180                 :          0 :       pushtag (make_anon_name (), t, /*tag_scope=*/ts_current);
    3181                 :            :     }
    3182                 :            : 
    3183                 :    3976430 :   if (TYPE_BEING_DEFINED (t))
    3184                 :            :     {
    3185                 :          0 :       t = make_class_type (TREE_CODE (t));
    3186                 :          0 :       pushtag (TYPE_IDENTIFIER (t), t, /*tag_scope=*/ts_current);
    3187                 :            :     }
    3188                 :    3976430 :   maybe_process_partial_specialization (t);
    3189                 :    3976430 :   pushclass (t);
    3190                 :    3976430 :   TYPE_BEING_DEFINED (t) = 1;
    3191                 :    3976430 :   class_binding_level->defining_class_p = 1;
    3192                 :            : 
    3193                 :    3976430 :   if (flag_pack_struct)
    3194                 :            :     {
    3195                 :        219 :       tree v;
    3196                 :        219 :       TYPE_PACKED (t) = 1;
    3197                 :            :       /* Even though the type is being defined for the first time
    3198                 :            :          here, there might have been a forward declaration, so there
    3199                 :            :          might be cv-qualified variants of T.  */
    3200                 :        219 :       for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
    3201                 :          0 :         TYPE_PACKED (v) = 1;
    3202                 :            :     }
    3203                 :            :   /* Reset the interface data, at the earliest possible
    3204                 :            :      moment, as it might have been set via a class foo;
    3205                 :            :      before.  */
    3206                 :    3976430 :   if (! TYPE_UNNAMED_P (t))
    3207                 :            :     {
    3208                 :    3839720 :       struct c_fileinfo *finfo = \
    3209                 :    3839720 :         get_fileinfo (LOCATION_FILE (input_location));
    3210                 :    3839720 :       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
    3211                 :    3839720 :       SET_CLASSTYPE_INTERFACE_UNKNOWN_X
    3212                 :            :         (t, finfo->interface_unknown);
    3213                 :            :     }
    3214                 :    3976430 :   reset_specialization();
    3215                 :            : 
    3216                 :            :   /* Make a declaration for this class in its own scope.  */
    3217                 :    3976430 :   build_self_reference ();
    3218                 :            : 
    3219                 :    3976430 :   return t;
    3220                 :            : }
    3221                 :            : 
    3222                 :            : /* Finish the member declaration given by DECL.  */
    3223                 :            : 
    3224                 :            : void
    3225                 :   45111300 : finish_member_declaration (tree decl)
    3226                 :            : {
    3227                 :   45111300 :   if (decl == error_mark_node || decl == NULL_TREE)
    3228                 :            :     return;
    3229                 :            : 
    3230                 :   45110200 :   if (decl == void_type_node)
    3231                 :            :     /* The COMPONENT was a friend, not a member, and so there's
    3232                 :            :        nothing for us to do.  */
    3233                 :            :     return;
    3234                 :            : 
    3235                 :            :   /* We should see only one DECL at a time.  */
    3236                 :   45110200 :   gcc_assert (DECL_CHAIN (decl) == NULL_TREE);
    3237                 :            : 
    3238                 :            :   /* Don't add decls after definition.  */
    3239                 :   45110300 :   gcc_assert (TYPE_BEING_DEFINED (current_class_type)
    3240                 :            :               /* We can add lambda types when late parsing default
    3241                 :            :                  arguments.  */
    3242                 :            :               || LAMBDA_TYPE_P (TREE_TYPE (decl)));
    3243                 :            : 
    3244                 :            :   /* Set up access control for DECL.  */
    3245                 :   45110200 :   TREE_PRIVATE (decl)
    3246                 :   45110200 :     = (current_access_specifier == access_private_node);
    3247                 :   45110200 :   TREE_PROTECTED (decl)
    3248                 :   45110200 :     = (current_access_specifier == access_protected_node);
    3249                 :   45110200 :   if (TREE_CODE (decl) == TEMPLATE_DECL)
    3250                 :            :     {
    3251                 :    3557860 :       TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
    3252                 :    3557860 :       TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
    3253                 :            :     }
    3254                 :            : 
    3255                 :            :   /* Mark the DECL as a member of the current class, unless it's
    3256                 :            :      a member of an enumeration.  */
    3257                 :   45110200 :   if (TREE_CODE (decl) != CONST_DECL)
    3258                 :   44809500 :     DECL_CONTEXT (decl) = current_class_type;
    3259                 :            : 
    3260                 :   45110200 :   if (TREE_CODE (decl) == USING_DECL)
    3261                 :            :     /* For now, ignore class-scope USING_DECLS, so that debugging
    3262                 :            :        backends do not see them. */
    3263                 :     153329 :     DECL_IGNORED_P (decl) = 1;
    3264                 :            : 
    3265                 :            :   /* Check for bare parameter packs in the non-static data member
    3266                 :            :      declaration.  */
    3267                 :   45110200 :   if (TREE_CODE (decl) == FIELD_DECL)
    3268                 :            :     {
    3269                 :    2795250 :       if (check_for_bare_parameter_packs (TREE_TYPE (decl)))
    3270                 :          9 :         TREE_TYPE (decl) = error_mark_node;
    3271                 :    2795250 :       if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl)))
    3272                 :          0 :         DECL_ATTRIBUTES (decl) = NULL_TREE;
    3273                 :            :     }
    3274                 :            : 
    3275                 :            :   /* [dcl.link]
    3276                 :            : 
    3277                 :            :      A C language linkage is ignored for the names of class members
    3278                 :            :      and the member function type of class member functions.  */
    3279                 :   45110200 :   if (DECL_LANG_SPECIFIC (decl))
    3280                 :   41551300 :     SET_DECL_LANGUAGE (decl, lang_cplusplus);
    3281                 :            : 
    3282                 :   45110200 :   bool add = false;
    3283                 :            : 
    3284                 :            :   /* Functions and non-functions are added differently.  */
    3285                 :   45110200 :   if (DECL_DECLARES_FUNCTION_P (decl))
    3286                 :   15786400 :     add = add_method (current_class_type, decl, false);
    3287                 :            :   /* Enter the DECL into the scope of the class, if the class
    3288                 :            :      isn't a closure (whose fields are supposed to be unnamed).  */
    3289                 :   29323900 :   else if (CLASSTYPE_LAMBDA_EXPR (current_class_type)
    3290                 :   29323900 :            || pushdecl_class_level (decl))
    3291                 :            :     add = true;
    3292                 :            : 
    3293                 :   15786400 :   if (add)
    3294                 :            :     {
    3295                 :            :       /* All TYPE_DECLs go at the end of TYPE_FIELDS.  Ordinary fields
    3296                 :            :          go at the beginning.  The reason is that
    3297                 :            :          legacy_nonfn_member_lookup searches the list in order, and we
    3298                 :            :          want a field name to override a type name so that the "struct
    3299                 :            :          stat hack" will work.  In particular:
    3300                 :            : 
    3301                 :            :            struct S { enum E { }; static const int E = 5; int ary[S::E]; } s;
    3302                 :            : 
    3303                 :            :          is valid.  */
    3304                 :            : 
    3305                 :   45109900 :       if (TREE_CODE (decl) == TYPE_DECL)
    3306                 :   72489700 :         TYPE_FIELDS (current_class_type)
    3307                 :   24466700 :           = chainon (TYPE_FIELDS (current_class_type), decl);
    3308                 :            :       else
    3309                 :            :         {
    3310                 :   21208000 :           DECL_CHAIN (decl) = TYPE_FIELDS (current_class_type);
    3311                 :   21208000 :           TYPE_FIELDS (current_class_type) = decl;
    3312                 :            :         }
    3313                 :            : 
    3314                 :   45109900 :       maybe_add_class_template_decl_list (current_class_type, decl,
    3315                 :            :                                           /*friend_p=*/0);
    3316                 :            :     }
    3317                 :            : }
    3318                 :            : 
    3319                 :            : /* Finish processing a complete template declaration.  The PARMS are
    3320                 :            :    the template parameters.  */
    3321                 :            : 
    3322                 :            : void
    3323                 :    7522070 : finish_template_decl (tree parms)
    3324                 :            : {
    3325                 :    7522070 :   if (parms)
    3326                 :    7522060 :     end_template_decl ();
    3327                 :            :   else
    3328                 :          8 :     end_specialization ();
    3329                 :    7522070 : }
    3330                 :            : 
    3331                 :            : // Returns the template type of the class scope being entered. If we're
    3332                 :            : // entering a constrained class scope. TYPE is the class template
    3333                 :            : // scope being entered and we may need to match the intended type with
    3334                 :            : // a constrained specialization. For example:
    3335                 :            : //
    3336                 :            : //    template<Object T>
    3337                 :            : //      struct S { void f(); }; #1
    3338                 :            : //
    3339                 :            : //    template<Object T>
    3340                 :            : //      void S<T>::f() { }      #2
    3341                 :            : //
    3342                 :            : // We check, in #2, that S<T> refers precisely to the type declared by
    3343                 :            : // #1 (i.e., that the constraints match). Note that the following should
    3344                 :            : // be an error since there is no specialization of S<T> that is
    3345                 :            : // unconstrained, but this is not diagnosed here.
    3346                 :            : //
    3347                 :            : //    template<typename T>
    3348                 :            : //      void S<T>::f() { }
    3349                 :            : //
    3350                 :            : // We cannot diagnose this problem here since this function also matches
    3351                 :            : // qualified template names that are not part of a definition. For example:
    3352                 :            : //
    3353                 :            : //    template<Integral T, Floating_point U>
    3354                 :            : //      typename pair<T, U>::first_type void f(T, U);
    3355                 :            : //
    3356                 :            : // Here, it is unlikely that there is a partial specialization of
    3357                 :            : // pair constrained for for Integral and Floating_point arguments.
    3358                 :            : //
    3359                 :            : // The general rule is: if a constrained specialization with matching
    3360                 :            : // constraints is found return that type. Also note that if TYPE is not a
    3361                 :            : // class-type (e.g. a typename type), then no fixup is needed.
    3362                 :            : 
    3363                 :            : static tree
    3364                 :     409485 : fixup_template_type (tree type)
    3365                 :            : {
    3366                 :            :   // Find the template parameter list at the a depth appropriate to
    3367                 :            :   // the scope we're trying to enter.
    3368                 :     409485 :   tree parms = current_template_parms;
    3369                 :     409485 :   int depth = template_class_depth (type);
    3370                 :     472247 :   for (int n = processing_template_decl; n > depth && parms; --n)
    3371                 :      62762 :     parms = TREE_CHAIN (parms);
    3372                 :     409485 :   if (!parms)
    3373                 :            :     return type;
    3374                 :     407154 :   tree cur_reqs = TEMPLATE_PARMS_CONSTRAINTS (parms);
    3375                 :     407154 :   tree cur_constr = build_constraints (cur_reqs, NULL_TREE);
    3376                 :            : 
    3377                 :            :   // Search for a specialization whose type and constraints match.
    3378                 :     407154 :   tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
    3379                 :     407154 :   tree specs = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
    3380                 :     669223 :   while (specs)
    3381                 :            :     {
    3382                 :     269128 :       tree spec_constr = get_constraints (TREE_VALUE (specs));
    3383                 :            : 
    3384                 :            :       // If the type and constraints match a specialization, then we
    3385                 :            :       // are entering that type.
    3386                 :     269128 :       if (same_type_p (type, TREE_TYPE (specs))
    3387                 :     269128 :           && equivalent_constraints (cur_constr, spec_constr))
    3388                 :       7059 :         return TREE_TYPE (specs);
    3389                 :     262069 :       specs = TREE_CHAIN (specs);
    3390                 :            :     }
    3391                 :            : 
    3392                 :            :   // If no specialization matches, then must return the type
    3393                 :            :   // previously found.
    3394                 :            :   return type;
    3395                 :            : }
    3396                 :            : 
    3397                 :            : /* Finish processing a template-id (which names a type) of the form
    3398                 :            :    NAME < ARGS >.  Return the TYPE_DECL for the type named by the
    3399                 :            :    template-id.  If ENTERING_SCOPE is nonzero we are about to enter
    3400                 :            :    the scope of template-id indicated.  */
    3401                 :            : 
    3402                 :            : tree
    3403                 :   12718300 : finish_template_type (tree name, tree args, int entering_scope)
    3404                 :            : {
    3405                 :   12718300 :   tree type;
    3406                 :            : 
    3407                 :   12718300 :   type = lookup_template_class (name, args,
    3408                 :            :                                 NULL_TREE, NULL_TREE, entering_scope,
    3409                 :            :                                 tf_warning_or_error | tf_user);
    3410                 :            : 
    3411                 :            :   /* If we might be entering the scope of a partial specialization,
    3412                 :            :      find the one with the right constraints.  */
    3413                 :   12718300 :   if (flag_concepts
    3414                 :    3380780 :       && entering_scope
    3415                 :     832194 :       && CLASS_TYPE_P (type)
    3416                 :     414100 :       && CLASSTYPE_TEMPLATE_INFO (type)
    3417                 :     414097 :       && dependent_type_p (type)
    3418                 :   13127800 :       && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
    3419                 :     409485 :     type = fixup_template_type (type);
    3420                 :            : 
    3421                 :   12718300 :   if (type == error_mark_node)
    3422                 :            :     return type;
    3423                 :   24251600 :   else if (CLASS_TYPE_P (type) && !alias_type_or_template_p (type))
    3424                 :   11228000 :     return TYPE_STUB_DECL (type);
    3425                 :            :   else
    3426                 :    1489620 :     return TYPE_NAME (type);
    3427                 :            : }
    3428                 :            : 
    3429                 :            : /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
    3430                 :            :    Return a TREE_LIST containing the ACCESS_SPECIFIER and the
    3431                 :            :    BASE_CLASS, or NULL_TREE if an error occurred.  The
    3432                 :            :    ACCESS_SPECIFIER is one of
    3433                 :            :    access_{default,public,protected_private}_node.  For a virtual base
    3434                 :            :    we set TREE_TYPE.  */
    3435                 :            : 
    3436                 :            : tree
    3437                 :    1882670 : finish_base_specifier (tree base, tree access, bool virtual_p)
    3438                 :            : {
    3439                 :    1882670 :   tree result;
    3440                 :            : 
    3441                 :    1882670 :   if (base == error_mark_node)
    3442                 :            :     {
    3443                 :          0 :       error ("invalid base-class specification");
    3444                 :          0 :       result = NULL_TREE;
    3445                 :            :     }
    3446                 :    3498290 :   else if (! MAYBE_CLASS_TYPE_P (base))
    3447                 :            :     {
    3448                 :          3 :       error ("%qT is not a class type", base);
    3449                 :          3 :       result = NULL_TREE;
    3450                 :            :     }
    3451                 :            :   else
    3452                 :            :     {
    3453                 :    1882660 :       if (cp_type_quals (base) != 0)
    3454                 :            :         {
    3455                 :            :           /* DR 484: Can a base-specifier name a cv-qualified
    3456                 :            :              class type?  */
    3457                 :         16 :           base = TYPE_MAIN_VARIANT (base);
    3458                 :            :         }
    3459                 :    1882660 :       result = build_tree_list (access, base);
    3460                 :    1882660 :       if (virtual_p)
    3461                 :       6598 :         TREE_TYPE (result) = integer_type_node;
    3462                 :            :     }
    3463                 :            : 
    3464                 :    1882670 :   return result;
    3465                 :            : }
    3466                 :            : 
    3467                 :            : /* If FNS is a member function, a set of member functions, or a
    3468                 :            :    template-id referring to one or more member functions, return a
    3469                 :            :    BASELINK for FNS, incorporating the current access context.
    3470                 :            :    Otherwise, return FNS unchanged.  */
    3471                 :            : 
    3472                 :            : tree
    3473                 :   21937700 : baselink_for_fns (tree fns)
    3474                 :            : {
    3475                 :   21937700 :   tree scope;
    3476                 :   21937700 :   tree cl;
    3477                 :            : 
    3478                 :   21937700 :   if (BASELINK_P (fns)
    3479                 :   40436300 :       || error_operand_p (fns))
    3480                 :            :     return fns;
    3481                 :            : 
    3482                 :   18498600 :   scope = ovl_scope (fns);
    3483                 :   19125200 :   if (!CLASS_TYPE_P (scope))
    3484                 :            :     return fns;
    3485                 :            : 
    3486                 :     626581 :   cl = currently_open_derived_class (scope);
    3487                 :     626581 :   if (!cl)
    3488                 :     344896 :     cl = scope;
    3489                 :     626581 :   cl = TYPE_BINFO (cl);
    3490                 :     626581 :   return build_baselink (cl, cl, fns, /*optype=*/NULL_TREE);
    3491                 :            : }
    3492                 :            : 
    3493                 :            : /* Returns true iff DECL is a variable from a function outside
    3494                 :            :    the current one.  */
    3495                 :            : 
    3496                 :            : static bool
    3497                 :  240394000 : outer_var_p (tree decl)
    3498                 :            : {
    3499                 :  240394000 :   return ((VAR_P (decl) || TREE_CODE (decl) == PARM_DECL)
    3500                 :  225494000 :           && DECL_FUNCTION_SCOPE_P (decl)
    3501                 :            :           /* Don't get confused by temporaries.  */
    3502                 :  188323000 :           && DECL_NAME (decl)
    3503                 :  425833000 :           && (DECL_CONTEXT (decl) != current_function_decl
    3504                 :  184863000 :               || parsing_nsdmi ()));
    3505                 :            : }
    3506                 :            : 
    3507                 :            : /* As above, but also checks that DECL is automatic.  */
    3508                 :            : 
    3509                 :            : bool
    3510                 :  240394000 : outer_automatic_var_p (tree decl)
    3511                 :            : {
    3512                 :  240394000 :   return (outer_var_p (decl)
    3513                 :  240394000 :           && !TREE_STATIC (decl));
    3514                 :            : }
    3515                 :            : 
    3516                 :            : /* DECL satisfies outer_automatic_var_p.  Possibly complain about it or
    3517                 :            :    rewrite it for lambda capture.
    3518                 :            : 
    3519                 :            :    If ODR_USE is true, we're being called from mark_use, and we complain about
    3520                 :            :    use of constant variables.  If ODR_USE is false, we're being called for the
    3521                 :            :    id-expression, and we do lambda capture.  */
    3522                 :            : 
    3523                 :            : tree
    3524                 :     155398 : process_outer_var_ref (tree decl, tsubst_flags_t complain, bool odr_use)
    3525                 :            : {
    3526                 :     155398 :   if (cp_unevaluated_operand)
    3527                 :            :     {
    3528                 :     120228 :       tree type = TREE_TYPE (decl);
    3529                 :     120228 :       if (!dependent_type_p (type)
    3530                 :     120228 :           && variably_modified_type_p (type, NULL_TREE))
    3531                 :            :         /* VLAs are used even in unevaluated context.  */;
    3532                 :            :       else
    3533                 :            :         /* It's not a use (3.2) if we're in an unevaluated context.  */
    3534                 :     120222 :         return decl;
    3535                 :            :     }
    3536                 :      35176 :   if (decl == error_mark_node)
    3537                 :            :     return decl;
    3538                 :            : 
    3539                 :      35168 :   tree context = DECL_CONTEXT (decl);
    3540                 :      35168 :   tree containing_function = current_function_decl;
    3541                 :      35168 :   tree lambda_stack = NULL_TREE;
    3542                 :      35168 :   tree lambda_expr = NULL_TREE;
    3543                 :      35168 :   tree initializer = convert_from_reference (decl);
    3544                 :            : 
    3545                 :            :   /* Mark it as used now even if the use is ill-formed.  */
    3546                 :      35168 :   if (!mark_used (decl, complain))
    3547                 :          3 :     return error_mark_node;
    3548                 :            : 
    3549                 :      35165 :   if (parsing_nsdmi ())
    3550                 :            :     containing_function = NULL_TREE;
    3551                 :            : 
    3552                 :     140470 :   if (containing_function && LAMBDA_FUNCTION_P (containing_function))
    3553                 :            :     {
    3554                 :            :       /* Check whether we've already built a proxy.  */
    3555                 :            :       tree var = decl;
    3556                 :      35130 :       while (is_normal_capture_proxy (var))
    3557                 :         36 :         var = DECL_CAPTURED_VARIABLE (var);
    3558                 :      35094 :       tree d = retrieve_local_specialization (var);
    3559                 :            : 
    3560                 :      35094 :       if (d && d != decl && is_capture_proxy (d))
    3561                 :            :         {
    3562                 :       6162 :           if (DECL_CONTEXT (d) == containing_function)
    3563                 :            :             /* We already have an inner proxy.  */
    3564                 :            :             return d;
    3565                 :            :           else
    3566                 :            :             /* We need to capture an outer proxy.  */
    3567                 :         27 :             return process_outer_var_ref (d, complain, odr_use);
    3568                 :            :         }
    3569                 :            :     }
    3570                 :            : 
    3571                 :            :   /* If we are in a lambda function, we can move out until we hit
    3572                 :            :      1. the context,
    3573                 :            :      2. a non-lambda function, or
    3574                 :            :      3. a non-default capturing lambda function.  */
    3575                 :      29013 :   while (context != containing_function
    3576                 :            :          /* containing_function can be null with invalid generic lambdas.  */
    3577                 :      58016 :          && containing_function
    3578                 :     145333 :          && LAMBDA_FUNCTION_P (containing_function))
    3579                 :            :     {
    3580                 :      29090 :       tree closure = DECL_CONTEXT (containing_function);
    3581                 :      29090 :       lambda_expr = CLASSTYPE_LAMBDA_EXPR (closure);
    3582                 :            : 
    3583                 :      29090 :       if (TYPE_CLASS_SCOPE_P (closure))
    3584                 :            :         /* A lambda in an NSDMI (c++/64496).  */
    3585                 :            :         break;
    3586                 :            : 
    3587                 :      29087 :       if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_NONE)
    3588                 :            :         break;
    3589                 :            : 
    3590                 :      29013 :       lambda_stack = tree_cons (NULL_TREE, lambda_expr, lambda_stack);
    3591                 :            : 
    3592                 :      29013 :       containing_function = decl_function_context (containing_function);
    3593                 :            :     }
    3594                 :            : 
    3595                 :            :   /* In a lambda within a template, wait until instantiation time to implicitly
    3596                 :            :      capture a parameter pack.  We want to wait because we don't know if we're
    3597                 :            :      capturing the whole pack or a single element, and it's OK to wait because
    3598                 :            :      find_parameter_packs_r walks into the lambda body.  */
    3599                 :      29003 :   if (context == containing_function
    3600                 :      57858 :       && DECL_PACK_P (decl))
    3601                 :            :     return decl;
    3602                 :            : 
    3603                 :      28470 :   if (lambda_expr && VAR_P (decl) && DECL_ANON_UNION_VAR_P (decl))
    3604                 :            :     {
    3605                 :          6 :       if (complain & tf_error)
    3606                 :          6 :         error ("cannot capture member %qD of anonymous union", decl);
    3607                 :          6 :       return error_mark_node;
    3608                 :            :     }
    3609                 :            :   /* Do lambda capture when processing the id-expression, not when
    3610                 :            :      odr-using a variable.  */
    3611                 :      28464 :   if (!odr_use && context == containing_function)
    3612                 :      28316 :     decl = add_default_capture (lambda_stack,
    3613                 :      28316 :                                 /*id=*/DECL_NAME (decl), initializer);
    3614                 :            :   /* Only an odr-use of an outer automatic variable causes an
    3615                 :            :      error, and a constant variable can decay to a prvalue
    3616                 :            :      constant without odr-use.  So don't complain yet.  */
    3617                 :        148 :   else if (!odr_use && decl_constant_var_p (decl))
    3618                 :            :     return decl;
    3619                 :         96 :   else if (lambda_expr)
    3620                 :            :     {
    3621                 :         39 :       if (complain & tf_error)
    3622                 :            :         {
    3623                 :         39 :           error ("%qD is not captured", decl);
    3624                 :         39 :           tree closure = LAMBDA_EXPR_CLOSURE (lambda_expr);
    3625                 :         39 :           if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_NONE)
    3626                 :         36 :             inform (location_of (closure),
    3627                 :            :                     "the lambda has no capture-default");
    3628                 :          3 :           else if (TYPE_CLASS_SCOPE_P (closure))
    3629                 :          3 :             inform (UNKNOWN_LOCATION, "lambda in local class %q+T cannot "
    3630                 :            :                     "capture variables from the enclosing context",
    3631                 :          3 :                     TYPE_CONTEXT (closure));
    3632                 :         39 :           inform (DECL_SOURCE_LOCATION (decl), "%q#D declared here", decl);
    3633                 :            :         }
    3634                 :         39 :       return error_mark_node;
    3635                 :            :     }
    3636                 :            :   else
    3637                 :            :     {
    3638                 :         57 :       if (complain & tf_error)
    3639                 :            :         {
    3640                 :         82 :           error (VAR_P (decl)
    3641                 :            :                  ? G_("use of local variable with automatic storage from "
    3642                 :            :                       "containing function")
    3643                 :            :                  : G_("use of parameter from containing function"));
    3644                 :         51 :           inform (DECL_SOURCE_LOCATION (decl), "%q#D declared here", decl);
    3645                 :            :         }
    3646                 :         57 :       return error_mark_node;
    3647                 :            :     }
    3648                 :      28316 :   return decl;
    3649                 :            : }
    3650                 :            : 
    3651                 :            : /* ID_EXPRESSION is a representation of parsed, but unprocessed,
    3652                 :            :    id-expression.  (See cp_parser_id_expression for details.)  SCOPE,
    3653                 :            :    if non-NULL, is the type or namespace used to explicitly qualify
    3654                 :            :    ID_EXPRESSION.  DECL is the entity to which that name has been
    3655                 :            :    resolved.
    3656                 :            : 
    3657                 :            :    *CONSTANT_EXPRESSION_P is true if we are presently parsing a
    3658                 :            :    constant-expression.  In that case, *NON_CONSTANT_EXPRESSION_P will
    3659                 :            :    be set to true if this expression isn't permitted in a
    3660                 :            :    constant-expression, but it is otherwise not set by this function.
    3661                 :            :    *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
    3662                 :            :    constant-expression, but a non-constant expression is also
    3663                 :            :    permissible.
    3664                 :            : 
    3665                 :            :    DONE is true if this expression is a complete postfix-expression;
    3666                 :            :    it is false if this expression is followed by '->', '[', '(', etc.
    3667                 :            :    ADDRESS_P is true iff this expression is the operand of '&'.
    3668                 :            :    TEMPLATE_P is true iff the qualified-id was of the form
    3669                 :            :    "A::template B".  TEMPLATE_ARG_P is true iff this qualified name
    3670                 :            :    appears as a template argument.
    3671                 :            : 
    3672                 :            :    If an error occurs, and it is the kind of error that might cause
    3673                 :            :    the parser to abort a tentative parse, *ERROR_MSG is filled in.  It
    3674                 :            :    is the caller's responsibility to issue the message.  *ERROR_MSG
    3675                 :            :    will be a string with static storage duration, so the caller need
    3676                 :            :    not "free" it.
    3677                 :            : 
    3678                 :            :    Return an expression for the entity, after issuing appropriate
    3679                 :            :    diagnostics.  This function is also responsible for transforming a
    3680                 :            :    reference to a non-static member into a COMPONENT_REF that makes
    3681                 :            :    the use of "this" explicit.
    3682                 :            : 
    3683                 :            :    Upon return, *IDK will be filled in appropriately.  */
    3684                 :            : static cp_expr
    3685                 :   45665700 : finish_id_expression_1 (tree id_expression,
    3686                 :            :                         tree decl,
    3687                 :            :                         tree scope,
    3688                 :            :                         cp_id_kind *idk,
    3689                 :            :                         bool integral_constant_expression_p,
    3690                 :            :                         bool allow_non_integral_constant_expression_p,
    3691                 :            :                         bool *non_integral_constant_expression_p,
    3692                 :            :                         bool template_p,
    3693                 :            :                         bool done,
    3694                 :            :                         bool address_p,
    3695                 :            :                         bool template_arg_p,
    3696                 :            :                         const char **error_msg,
    3697                 :            :                         location_t location)
    3698                 :            : {
    3699                 :   45665700 :   decl = strip_using_decl (decl);
    3700                 :            : 
    3701                 :            :   /* Initialize the output parameters.  */
    3702                 :   45665700 :   *idk = CP_ID_KIND_NONE;
    3703                 :   45665700 :   *error_msg = NULL;
    3704                 :            : 
    3705                 :   45665700 :   if (id_expression == error_mark_node)
    3706                 :         16 :     return error_mark_node;
    3707                 :            :   /* If we have a template-id, then no further lookup is
    3708                 :            :      required.  If the template-id was for a template-class, we
    3709                 :            :      will sometimes have a TYPE_DECL at this point.  */
    3710                 :   45665700 :   else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
    3711                 :   43065000 :            || TREE_CODE (decl) == TYPE_DECL)
    3712                 :            :     ;
    3713                 :            :   /* Look up the name.  */
    3714                 :            :   else
    3715                 :            :     {
    3716                 :   43061500 :       if (decl == error_mark_node)
    3717                 :            :         {
    3718                 :            :           /* Name lookup failed.  */
    3719                 :      30643 :           if (scope
    3720                 :      30643 :               && (!TYPE_P (scope)
    3721                 :        133 :                   || (!dependent_type_p (scope)
    3722                 :        123 :                       && !(identifier_p (id_expression)
    3723                 :        105 :                            && IDENTIFIER_CONV_OP_P (id_expression)
    3724                 :          4 :                            && dependent_type_p (TREE_TYPE (id_expression))))))
    3725                 :            :             {
    3726                 :            :               /* If the qualifying type is non-dependent (and the name
    3727                 :            :                  does not name a conversion operator to a dependent
    3728                 :            :                  type), issue an error.  */
    3729                 :        375 :               qualified_name_lookup_error (scope, id_expression, decl, location);
    3730                 :        375 :               return error_mark_node;
    3731                 :            :             }
    3732                 :      30268 :           else if (!scope)
    3733                 :            :             {
    3734                 :            :               /* It may be resolved via Koenig lookup.  */
    3735                 :      30250 :               *idk = CP_ID_KIND_UNQUALIFIED;
    3736                 :      30250 :               return id_expression;
    3737                 :            :             }
    3738                 :            :           else
    3739                 :            :             decl = id_expression;
    3740                 :            :         }
    3741                 :            : 
    3742                 :            :       /* Remember that the name was used in the definition of
    3743                 :            :          the current class so that we can check later to see if
    3744                 :            :          the meaning would have been different after the class
    3745                 :            :          was entirely defined.  */
    3746                 :   43030900 :       if (!scope && decl != error_mark_node && identifier_p (id_expression))
    3747                 :   39740300 :         maybe_note_name_used_in_class (id_expression, decl);
    3748                 :            : 
    3749                 :            :       /* A use in unevaluated operand might not be instantiated appropriately
    3750                 :            :          if tsubst_copy builds a dummy parm, or if we never instantiate a
    3751                 :            :          generic lambda, so mark it now.  */
    3752                 :   43030900 :       if (processing_template_decl && cp_unevaluated_operand)
    3753                 :    1048640 :         mark_type_use (decl);
    3754                 :            : 
    3755                 :            :       /* Disallow uses of local variables from containing functions, except
    3756                 :            :          within lambda-expressions.  */
    3757                 :   43030900 :       if (outer_automatic_var_p (decl))
    3758                 :            :         {
    3759                 :      14531 :           decl = process_outer_var_ref (decl, tf_warning_or_error);
    3760                 :      14531 :           if (decl == error_mark_node)
    3761                 :         84 :             return error_mark_node;
    3762                 :            :         }
    3763                 :            : 
    3764                 :            :       /* Also disallow uses of function parameters outside the function
    3765                 :            :          body, except inside an unevaluated context (i.e. decltype).  */
    3766                 :   43030800 :       if (TREE_CODE (decl) == PARM_DECL
    3767                 :   20691800 :           && DECL_CONTEXT (decl) == NULL_TREE
    3768                 :   43747700 :           && !cp_unevaluated_operand)
    3769                 :            :         {
    3770                 :         38 :           *error_msg = G_("use of parameter outside function body");
    3771                 :         38 :           return error_mark_node;
    3772                 :            :         }
    3773                 :            :     }
    3774                 :            : 
    3775                 :            :   /* If we didn't find anything, or what we found was a type,
    3776                 :            :      then this wasn't really an id-expression.  */
    3777                 :   45635000 :   if (TREE_CODE (decl) == TEMPLATE_DECL
    3778                 :   45635000 :       && !DECL_FUNCTION_TEMPLATE_P (decl))
    3779                 :            :     {
    3780                 :         62 :       *error_msg = G_("missing template arguments");
    3781                 :         62 :       return error_mark_node;
    3782                 :            :     }
    3783                 :   45634900 :   else if (TREE_CODE (decl) == TYPE_DECL
    3784                 :   45631500 :            || TREE_CODE (decl) == NAMESPACE_DECL)
    3785                 :            :     {
    3786                 :       3445 :       *error_msg = G_("expected primary-expression");
    3787                 :       3445 :       return error_mark_node;
    3788                 :            :     }
    3789                 :            : 
    3790                 :            :   /* If the name resolved to a template parameter, there is no
    3791                 :            :      need to look it up again later.  */
    3792                 :    1906660 :   if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
    3793                 :   46318200 :       || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
    3794                 :            :     {
    3795                 :    1219920 :       tree r;
    3796                 :            : 
    3797                 :    1219920 :       *idk = CP_ID_KIND_NONE;
    3798                 :    1219920 :       if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
    3799                 :          0 :         decl = TEMPLATE_PARM_DECL (decl);
    3800                 :    1219920 :       r = DECL_INITIAL (decl);
    3801                 :    1219920 :       if (CLASS_TYPE_P (TREE_TYPE (r)) && !CP_TYPE_CONST_P (TREE_TYPE (r)))
    3802                 :            :         {
    3803                 :            :           /* If the entity is a template parameter object for a template
    3804                 :            :              parameter of type T, the type of the expression is const T.  */
    3805                 :         24 :           tree ctype = TREE_TYPE (r);
    3806                 :         24 :           ctype = cp_build_qualified_type (ctype, (cp_type_quals (ctype)
    3807                 :            :                                                    | TYPE_QUAL_CONST));
    3808                 :         24 :           r = build1 (VIEW_CONVERT_EXPR, ctype, r);
    3809                 :            :         }
    3810                 :    1219920 :       r = convert_from_reference (r);
    3811                 :    1219920 :       if (integral_constant_expression_p
    3812                 :     221138 :           && !dependent_type_p (TREE_TYPE (decl))
    3813                 :    1429460 :           && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
    3814                 :            :         {
    3815                 :         47 :           if (!allow_non_integral_constant_expression_p)
    3816                 :          8 :             error ("template parameter %qD of type %qT is not allowed in "
    3817                 :            :                    "an integral constant expression because it is not of "
    3818                 :          8 :                    "integral or enumeration type", decl, TREE_TYPE (decl));
    3819                 :         47 :           *non_integral_constant_expression_p = true;
    3820                 :            :         }
    3821                 :    1219920 :       return r;
    3822                 :            :     }
    3823                 :            :   else
    3824                 :            :     {
    3825                 :   44411500 :       bool dependent_p = type_dependent_expression_p (decl);
    3826                 :            : 
    3827                 :            :       /* If the declaration was explicitly qualified indicate
    3828                 :            :          that.  The semantics of `A::f(3)' are different than
    3829                 :            :          `f(3)' if `f' is virtual.  */
    3830                 :   88823100 :       *idk = (scope
    3831                 :   44411500 :               ? CP_ID_KIND_QUALIFIED
    3832                 :   39574200 :               : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
    3833                 :   39574200 :                  ? CP_ID_KIND_TEMPLATE_ID
    3834                 :            :                  : (dependent_p
    3835                 :   38520200 :                     ? CP_ID_KIND_UNQUALIFIED_DEPENDENT
    3836                 :            :                     : CP_ID_KIND_UNQUALIFIED)));
    3837                 :            : 
    3838                 :   44411500 :       if (dependent_p
    3839                 :   23248200 :           && DECL_P (decl)
    3840                 :   64771300 :           && any_dependent_type_attributes_p (DECL_ATTRIBUTES (decl)))
    3841                 :            :         /* Dependent type attributes on the decl mean that the TREE_TYPE is
    3842                 :            :            wrong, so just return the identifier.  */
    3843                 :         44 :         return id_expression;
    3844                 :            : 
    3845                 :   44411500 :       if (DECL_CLASS_TEMPLATE_P (decl))
    3846                 :            :         {
    3847                 :          0 :           error ("use of class template %qT as expression", decl);
    3848                 :          0 :           return error_mark_node;
    3849                 :            :         }
    3850                 :            : 
    3851                 :   44411500 :       if (TREE_CODE (decl) == TREE_LIST)
    3852                 :            :         {
    3853                 :            :           /* Ambiguous reference to base members.  */
    3854                 :          0 :           error ("request for member %qD is ambiguous in "
    3855                 :            :                  "multiple inheritance lattice", id_expression);
    3856                 :          0 :           print_candidates (decl);
    3857                 :          0 :           return error_mark_node;
    3858                 :            :         }
    3859                 :            : 
    3860                 :            :       /* Mark variable-like entities as used.  Functions are similarly
    3861                 :            :          marked either below or after overload resolution.  */
    3862                 :   44411500 :       if ((VAR_P (decl)
    3863                 :   33879700 :            || TREE_CODE (decl) == PARM_DECL
    3864                 :   13188000 :            || TREE_CODE (decl) == CONST_DECL
    3865                 :   12501200 :            || TREE_CODE (decl) == RESULT_DECL)
    3866                 :   65790000 :           && !mark_used (decl))
    3867                 :         17 :         return error_mark_node;
    3868                 :            : 
    3869                 :            :       /* Only certain kinds of names are allowed in constant
    3870                 :            :          expression.  Template parameters have already
    3871                 :            :          been handled above.  */
    3872                 :   44411500 :       if (! error_operand_p (decl)
    3873                 :   44411200 :           && !dependent_p
    3874                 :   44411200 :           && integral_constant_expression_p
    3875                 :    4801980 :           && !decl_constant_var_p (decl)
    3876                 :    4215480 :           && TREE_CODE (decl) != CONST_DECL
    3877                 :    3774140 :           && !builtin_valid_in_constant_expr_p (decl)
    3878                 :   48183600 :           && !concept_check_p (decl))
    3879                 :            :         {
    3880                 :    3760220 :           if (!allow_non_integral_constant_expression_p)
    3881                 :            :             {
    3882                 :         29 :               error ("%qD cannot appear in a constant-expression", decl);
    3883                 :         29 :               return error_mark_node;
    3884                 :            :             }
    3885                 :    3760200 :           *non_integral_constant_expression_p = true;
    3886                 :            :         }
    3887                 :            : 
    3888                 :   44411400 :       if (tree wrap = maybe_get_tls_wrapper_call (decl))
    3889                 :            :         /* Replace an evaluated use of the thread_local variable with
    3890                 :            :            a call to its wrapper.  */
    3891                 :            :         decl = wrap;
    3892                 :   44411200 :       else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
    3893                 :    2600730 :                && !dependent_p
    3894                 :     540659 :                && variable_template_p (TREE_OPERAND (decl, 0))
    3895                 :   44414000 :                && !concept_check_p (decl))
    3896                 :            :         {
    3897                 :       2704 :           decl = finish_template_variable (decl);
    3898                 :       2704 :           mark_used (decl);
    3899                 :       2704 :           decl = convert_from_reference (decl);
    3900                 :            :         }
    3901                 :   44408500 :       else if (concept_check_p (decl))
    3902                 :            :         {
    3903                 :            :           /* Nothing more to do. All of the analysis for concept checks
    3904                 :            :              is done by build_conept_id, called from the parser.  */
    3905                 :            :         }
    3906                 :   43968100 :       else if (scope)
    3907                 :            :         {
    3908                 :    4795590 :           if (TREE_CODE (decl) == SCOPE_REF)
    3909                 :            :             {
    3910                 :         26 :               gcc_assert (same_type_p (scope, TREE_OPERAND (decl, 0)));
    3911                 :         26 :               decl = TREE_OPERAND (decl, 1);
    3912                 :            :             }
    3913                 :            : 
    3914                 :    4795590 :           decl = (adjust_result_of_qualified_name_lookup
    3915                 :    4795590 :                   (decl, scope, current_nonlambda_class_type()));
    3916                 :            : 
    3917                 :    4795590 :           if (TREE_CODE (decl) == FUNCTION_DECL)
    3918                 :     255618 :             mark_used (decl);
    3919                 :            : 
    3920                 :    4795590 :           cp_warn_deprecated_use_scopes (scope);
    3921                 :            : 
    3922                 :    4795590 :           if (TYPE_P (scope))
    3923                 :     798496 :             decl = finish_qualified_id_expr (scope,
    3924                 :            :                                              decl,
    3925                 :            :                                              done,
    3926                 :            :                                              address_p,
    3927                 :            :                                              template_p,
    3928                 :            :                                              template_arg_p,
    3929                 :            :                                              tf_warning_or_error);
    3930                 :            :           else
    3931                 :    3997100 :             decl = convert_from_reference (decl);
    3932                 :            :         }
    3933                 :   39172500 :       else if (TREE_CODE (decl) == FIELD_DECL)
    3934                 :            :         {
    3935                 :            :           /* Since SCOPE is NULL here, this is an unqualified name.
    3936                 :            :              Access checking has been performed during name lookup
    3937                 :            :              already.  Turn off checking to avoid duplicate errors.  */
    3938                 :    2296640 :           push_deferring_access_checks (dk_no_check);
    3939                 :    2296640 :           decl = finish_non_static_data_member (decl, NULL_TREE,
    3940                 :            :                                                 /*qualifying_scope=*/NULL_TREE);
    3941                 :    2296640 :           pop_deferring_access_checks ();
    3942                 :            :         }
    3943                 :   36875800 :       else if (is_overloaded_fn (decl))
    3944                 :            :         {
    3945                 :            :           /* We only need to look at the first function,
    3946                 :            :              because all the fns share the attribute we're
    3947                 :            :              concerned with (all member fns or all non-members).  */
    3948                 :    5468060 :           tree first_fn = get_first_fn (decl);
    3949                 :    5468060 :           first_fn = STRIP_TEMPLATE (first_fn);
    3950                 :            : 
    3951                 :            :           /* [basic.def.odr]: "A function whose name appears as a
    3952                 :            :              potentially-evaluated expression is odr-used if it is the unique
    3953                 :            :              lookup result".
    3954                 :            : 
    3955                 :            :              But only mark it if it's a complete postfix-expression; in a call,
    3956                 :            :              ADL might select a different function, and we'll call mark_used in
    3957                 :            :              build_over_call.  */
    3958                 :    5468060 :           if (done
    3959                 :     196263 :               && !really_overloaded_fn (decl)
    3960                 :    5627020 :               && !mark_used (first_fn))
    3961                 :          3 :             return error_mark_node;
    3962                 :            : 
    3963                 :    5468060 :           if (!template_arg_p
    3964                 :    5468060 :               && (TREE_CODE (first_fn) == USING_DECL
    3965                 :    5457340 :                   || (TREE_CODE (first_fn) == FUNCTION_DECL
    3966                 :    5457340 :                       && DECL_FUNCTION_MEMBER_P (first_fn)
    3967                 :    2210110 :                       && !shared_member_p (decl))))
    3968                 :            :             {
    3969                 :            :               /* A set of member functions.  */
    3970                 :    1591030 :               decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
    3971                 :    1591030 :               return finish_class_member_access_expr (decl, id_expression,
    3972                 :            :                                                       /*template_p=*/false,
    3973                 :    1591030 :                                                       tf_warning_or_error);
    3974                 :            :             }
    3975                 :            : 
    3976                 :    3877030 :           decl = baselink_for_fns (decl);
    3977                 :            :         }
    3978                 :            :       else
    3979                 :            :         {
    3980                 :   31271700 :           if (DECL_P (decl) && DECL_NONLOCAL (decl)
    3981                 :   31564300 :               && DECL_CLASS_SCOPE_P (decl))
    3982                 :            :             {
    3983                 :     156540 :               tree context = context_for_name_lookup (decl);
    3984                 :     156540 :               if (context != current_class_type)
    3985                 :            :                 {
    3986                 :      25988 :                   tree path = currently_open_derived_class (context);
    3987                 :      25988 :                   perform_or_defer_access_check (TYPE_BINFO (path),
    3988                 :            :                                                  decl, decl,
    3989                 :            :                                                  tf_warning_or_error);
    3990                 :            :                 }
    3991                 :            :             }
    3992                 :            : 
    3993                 :   31407800 :           decl = convert_from_reference (decl);
    3994                 :            :         }
    3995                 :            :     }
    3996                 :            : 
    3997                 :   42820400 :   return cp_expr (decl, location);
    3998                 :            : }
    3999                 :            : 
    4000                 :            : /* As per finish_id_expression_1, but adding a wrapper node
    4001                 :            :    around the result if needed to express LOCATION.  */
    4002                 :            : 
    4003                 :            : cp_expr
    4004                 :   45665700 : finish_id_expression (tree id_expression,
    4005                 :            :                       tree decl,
    4006                 :            :                       tree scope,
    4007                 :            :                       cp_id_kind *idk,
    4008                 :            :                       bool integral_constant_expression_p,
    4009                 :            :                       bool allow_non_integral_constant_expression_p,
    4010                 :            :                       bool *non_integral_constant_expression_p,
    4011                 :            :                       bool template_p,
    4012                 :            :                       bool done,
    4013                 :            :                       bool address_p,
    4014                 :            :                       bool template_arg_p,
    4015                 :            :                       const char **error_msg,
    4016                 :            :                       location_t location)
    4017                 :            : {
    4018                 :   45665700 :   cp_expr result
    4019                 :            :     = finish_id_expression_1 (id_expression, decl, scope, idk,
    4020                 :            :                               integral_constant_expression_p,
    4021                 :            :                               allow_non_integral_constant_expression_p,
    4022                 :            :                               non_integral_constant_expression_p,
    4023                 :            :                               template_p, done, address_p, template_arg_p,
    4024                 :   45665700 :                               error_msg, location);
    4025                 :   45665700 :   return result.maybe_add_location_wrapper ();
    4026                 :            : }
    4027                 :            : 
    4028                 :            : /* Implement the __typeof keyword: Return the type of EXPR, suitable for
    4029                 :            :    use as a type-specifier.  */
    4030                 :            : 
    4031                 :            : tree
    4032                 :     105469 : finish_typeof (tree expr)
    4033                 :            : {
    4034                 :     105469 :   tree type;
    4035                 :            : 
    4036                 :     105469 :   if (type_dependent_expression_p (expr))
    4037                 :            :     {
    4038                 :       9355 :       type = cxx_make_type (TYPEOF_TYPE);
    4039                 :       9355 :       TYPEOF_TYPE_EXPR (type) = expr;
    4040                 :       9355 :       SET_TYPE_STRUCTURAL_EQUALITY (type);
    4041                 :            : 
    4042                 :       9355 :       return type;
    4043                 :            :     }
    4044                 :            : 
    4045                 :      96114 :   expr = mark_type_use (expr);
    4046                 :            : 
    4047                 :      96114 :   type = unlowered_expr_type (expr);
    4048                 :            : 
    4049                 :      96114 :   if (!type || type == unknown_type_node)
    4050                 :            :     {
    4051                 :          4 :       error ("type of %qE is unknown", expr);
    4052                 :          4 :       return error_mark_node;
    4053                 :            :     }
    4054                 :            : 
    4055                 :            :   return type;
    4056                 :            : }
    4057                 :            : 
    4058                 :            : /* Implement the __underlying_type keyword: Return the underlying
    4059                 :            :    type of TYPE, suitable for use as a type-specifier.  */
    4060                 :            : 
    4061                 :            : tree
    4062                 :       5447 : finish_underlying_type (tree type)
    4063                 :            : {
    4064                 :       5447 :   tree underlying_type;
    4065                 :            : 
    4066                 :       5447 :   if (processing_template_decl)
    4067                 :            :     {
    4068                 :       4327 :       underlying_type = cxx_make_type (UNDERLYING_TYPE);
    4069                 :       4327 :       UNDERLYING_TYPE_TYPE (underlying_type) = type;
    4070                 :       4327 :       SET_TYPE_STRUCTURAL_EQUALITY (underlying_type);
    4071                 :            : 
    4072                 :       4327 :       return underlying_type;
    4073                 :            :     }
    4074                 :            : 
    4075                 :       1120 :   if (!complete_type_or_else (type, NULL_TREE))
    4076                 :          3 :     return error_mark_node;
    4077                 :            : 
    4078                 :       1117 :   if (TREE_CODE (type) != ENUMERAL_TYPE)
    4079                 :            :     {
    4080                 :         28 :       error ("%qT is not an enumeration type", type);
    4081                 :         28 :       return error_mark_node;
    4082                 :            :     }
    4083                 :            : 
    4084                 :       1089 :   underlying_type = ENUM_UNDERLYING_TYPE (type);
    4085                 :            : 
    4086                 :            :   /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
    4087                 :            :      includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
    4088                 :            :      See finish_enum_value_list for details.  */
    4089                 :       1089 :   if (!ENUM_FIXED_UNDERLYING_TYPE_P (type))
    4090                 :         49 :     underlying_type
    4091                 :         49 :       = c_common_type_for_mode (TYPE_MODE (underlying_type),
    4092                 :         49 :                                 TYPE_UNSIGNED (underlying_type));
    4093                 :            : 
    4094                 :            :   return underlying_type;
    4095                 :            : }
    4096                 :            : 
    4097                 :            : /* Implement the __direct_bases keyword: Return the direct base classes
    4098                 :            :    of type.  */
    4099                 :            : 
    4100                 :            : tree
    4101                 :         15 : calculate_direct_bases (tree type, tsubst_flags_t complain)
    4102                 :            : {
    4103                 :         15 :   if (!complete_type_or_maybe_complain (type, NULL_TREE, complain)
    4104                 :         22 :       || !NON_UNION_CLASS_TYPE_P (type))
    4105                 :          8 :     return make_tree_vec (0);
    4106                 :            : 
    4107                 :          7 :   releasing_vec vector;
    4108                 :          7 :   vec<tree, va_gc> *base_binfos = BINFO_BASE_BINFOS (TYPE_BINFO (type));
    4109                 :            :   tree binfo;
    4110                 :            :   unsigned i;
    4111                 :            : 
    4112                 :            :   /* Virtual bases are initialized first */
    4113                 :         20 :   for (i = 0; base_binfos->iterate (i, &binfo); i++)
    4114                 :         13 :     if (BINFO_VIRTUAL_P (binfo))
    4115                 :         13 :       vec_safe_push (vector, binfo);
    4116                 :            : 
    4117                 :            :   /* Now non-virtuals */
    4118                 :         20 :   for (i = 0; base_binfos->iterate (i, &binfo); i++)
    4119                 :         13 :     if (!BINFO_VIRTUAL_P (binfo))
    4120                 :         13 :       vec_safe_push (vector, binfo);
    4121                 :            : 
    4122                 :          7 :   tree bases_vec = make_tree_vec (vector->length ());
    4123                 :            : 
    4124                 :         20 :   for (i = 0; i < vector->length (); ++i)
    4125                 :         13 :     TREE_VEC_ELT (bases_vec, i) = BINFO_TYPE ((*vector)[i]);
    4126                 :            : 
    4127                 :          7 :   return bases_vec;
    4128                 :            : }
    4129                 :            : 
    4130                 :            : /* Implement the __bases keyword: Return the base classes
    4131                 :            :    of type */
    4132                 :            : 
    4133                 :            : /* Find morally non-virtual base classes by walking binfo hierarchy */
    4134                 :            : /* Virtual base classes are handled separately in finish_bases */
    4135                 :            : 
    4136                 :            : static tree
    4137                 :         73 : dfs_calculate_bases_pre (tree binfo, void * /*data_*/)
    4138                 :            : {
    4139                 :            :   /* Don't walk bases of virtual bases */
    4140                 :         73 :   return BINFO_VIRTUAL_P (binfo) ? dfs_skip_bases : NULL_TREE;
    4141                 :            : }
    4142                 :            : 
    4143                 :            : static tree
    4144                 :         73 : dfs_calculate_bases_post (tree binfo, void *data_)
    4145                 :            : {
    4146                 :         73 :   vec<tree, va_gc> **data = ((vec<tree, va_gc> **) data_);
    4147                 :         73 :   if (!BINFO_VIRTUAL_P (binfo))
    4148                 :         48 :     vec_safe_push (*data, BINFO_TYPE (binfo));
    4149                 :         73 :   return NULL_TREE;
    4150                 :            : }
    4151                 :            : 
    4152                 :            : /* Calculates the morally non-virtual base classes of a class */
    4153                 :            : static vec<tree, va_gc> *
    4154                 :         16 : calculate_bases_helper (tree type)
    4155                 :            : {
    4156                 :         16 :   vec<tree, va_gc> *vector = make_tree_vector ();
    4157                 :            : 
    4158                 :            :   /* Now add non-virtual base classes in order of construction */
    4159                 :         16 :   if (TYPE_BINFO (type))
    4160                 :         16 :     dfs_walk_all (TYPE_BINFO (type),
    4161                 :            :                   dfs_calculate_bases_pre, dfs_calculate_bases_post, &vector);
    4162                 :         16 :   return vector;
    4163                 :            : }
    4164                 :            : 
    4165                 :            : tree
    4166                 :         12 : calculate_bases (tree type, tsubst_flags_t complain)
    4167                 :            : {
    4168                 :         12 :   if (!complete_type_or_maybe_complain (type, NULL_TREE, complain)
    4169                 :         19 :       || !NON_UNION_CLASS_TYPE_P (type))
    4170                 :          5 :     return make_tree_vec (0);
    4171                 :            : 
    4172                 :          7 :   releasing_vec vector;
    4173                 :          7 :   tree bases_vec = NULL_TREE;
    4174                 :          7 :   unsigned i;
    4175                 :          7 :   vec<tree, va_gc> *vbases;
    4176                 :          7 :   tree binfo;
    4177                 :            : 
    4178                 :            :   /* First go through virtual base classes */
    4179                 :          7 :   for (vbases = CLASSTYPE_VBASECLASSES (type), i = 0;
    4180                 :         16 :        vec_safe_iterate (vbases, i, &binfo); i++)
    4181                 :            :     {
    4182                 :          9 :       releasing_vec vbase_bases
    4183                 :         18 :         = calculate_bases_helper (BINFO_TYPE (binfo));
    4184                 :          9 :       vec_safe_splice (vector, vbase_bases);
    4185                 :            :     }
    4186                 :            : 
    4187                 :            :   /* Now for the non-virtual bases */
    4188                 :         14 :   releasing_vec nonvbases = calculate_bases_helper (type);
    4189                 :          7 :   vec_safe_splice (vector, nonvbases);
    4190                 :            : 
    4191                 :            :   /* Note that during error recovery vector->length can even be zero.  */
    4192                 :          7 :   if (vector->length () > 1)
    4193                 :            :     {
    4194                 :            :       /* Last element is entire class, so don't copy */
    4195                 :          6 :       bases_vec = make_tree_vec (vector->length () - 1);
    4196                 :            : 
    4197                 :         47 :       for (i = 0; i < vector->length () - 1; ++i)
    4198                 :         41 :         TREE_VEC_ELT (bases_vec, i) = (*vector)[i];
    4199                 :            :     }
    4200                 :            :   else
    4201                 :          1 :     bases_vec = make_tree_vec (0);
    4202                 :            : 
    4203                 :          7 :   return bases_vec;
    4204                 :            : }
    4205                 :            : 
    4206                 :            : tree
    4207                 :         28 : finish_bases (tree type, bool direct)
    4208                 :            : {
    4209                 :         28 :   tree bases = NULL_TREE;
    4210                 :            : 
    4211                 :         28 :   if (!processing_template_decl)
    4212                 :            :     {
    4213                 :            :       /* Parameter packs can only be used in templates */
    4214                 :          0 :       error ("parameter pack %<__bases%> only valid in template declaration");
    4215                 :          0 :       return error_mark_node;
    4216                 :            :     }
    4217                 :            : 
    4218                 :         28 :   bases = cxx_make_type (BASES);
    4219                 :         28 :   BASES_TYPE (bases) = type;
    4220                 :         28 :   BASES_DIRECT (bases) = direct;
    4221                 :         28 :   SET_TYPE_STRUCTURAL_EQUALITY (bases);
    4222                 :            : 
    4223                 :         28 :   return bases;
    4224                 :            : }
    4225                 :            : 
    4226                 :            : /* Perform C++-specific checks for __builtin_offsetof before calling
    4227                 :            :    fold_offsetof.  */
    4228                 :            : 
    4229                 :            : tree
    4230                 :       2427 : finish_offsetof (tree object_ptr, tree expr, location_t loc)
    4231                 :            : {
    4232                 :            :   /* If we're processing a template, we can't finish the semantics yet.
    4233                 :            :      Otherwise we can fold the entire expression now.  */
    4234                 :       2427 :   if (processing_template_decl)
    4235                 :            :     {
    4236                 :         78 :       expr = build2 (OFFSETOF_EXPR, size_type_node, expr, object_ptr);
    4237                 :         78 :       SET_EXPR_LOCATION (expr, loc);
    4238                 :         78 :       return expr;
    4239                 :            :     }
    4240                 :            : 
    4241                 :       2349 :   if (expr == error_mark_node)
    4242                 :            :     return error_mark_node;
    4243                 :            : 
    4244                 :       2335 :   if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
    4245                 :            :     {
    4246                 :          8 :       error ("cannot apply %<offsetof%> to destructor %<~%T%>",
    4247                 :          8 :               TREE_OPERAND (expr, 2));
    4248                 :          8 :       return error_mark_node;
    4249                 :            :     }
    4250                 :       4634 :   if (FUNC_OR_METHOD_TYPE_P (TREE_TYPE (expr))
    4251                 :       4634 :       || TREE_TYPE (expr) == unknown_type_node)
    4252                 :            :     {
    4253                 :         40 :       while (TREE_CODE (expr) == COMPONENT_REF
    4254                 :         40 :              || TREE_CODE (expr) == COMPOUND_EXPR)
    4255                 :         16 :         expr = TREE_OPERAND (expr, 1);
    4256                 :            : 
    4257                 :         24 :       if (DECL_P (expr))
    4258                 :            :         {
    4259                 :          0 :           error ("cannot apply %<offsetof%> to member function %qD", expr);
    4260                 :          0 :           inform (DECL_SOURCE_LOCATION (expr), "declared here");
    4261                 :            :         }
    4262                 :            :       else
    4263                 :         24 :         error ("cannot apply %<offsetof%> to member function");
    4264                 :         24 :       return error_mark_node;
    4265                 :            :     }
    4266                 :       2303 :   if (TREE_CODE (expr) == CONST_DECL)
    4267                 :            :     {
    4268                 :          4 :       error ("cannot apply %<offsetof%> to an enumerator %qD", expr);
    4269                 :          4 :       return error_mark_node;
    4270                 :            :     }
    4271                 :       2299 :   if (REFERENCE_REF_P (expr))
    4272                 :         12 :     expr = TREE_OPERAND (expr, 0);
    4273                 :       2299 :   if (!complete_type_or_else (TREE_TYPE (TREE_TYPE (object_ptr)), object_ptr))
    4274                 :          4 :     return error_mark_node;
    4275                 :       2295 :   if (warn_invalid_offsetof
    4276                 :       2295 :       && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (object_ptr)))
    4277                 :       2295 :       && CLASSTYPE_NON_STD_LAYOUT (TREE_TYPE (TREE_TYPE (object_ptr)))
    4278                 :       2347 :       && cp_unevaluated_operand == 0)
    4279                 :         52 :     warning_at (loc, OPT_Winvalid_offsetof, "%<offsetof%> within "
    4280                 :            :                 "non-standard-layout type %qT is conditionally-supported",
    4281                 :         52 :                 TREE_TYPE (TREE_TYPE (object_ptr)));
    4282                 :       2295 :   return fold_offsetof (expr);
    4283                 :            : }
    4284                 :            : 
    4285                 :            : /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR.  This
    4286                 :            :    function is broken out from the above for the benefit of the tree-ssa
    4287                 :            :    project.  */
    4288                 :            : 
    4289                 :            : void
    4290                 :     197720 : simplify_aggr_init_expr (tree *tp)
    4291                 :            : {
    4292                 :     197720 :   tree aggr_init_expr = *tp;
    4293                 :            : 
    4294                 :            :   /* Form an appropriate CALL_EXPR.  */
    4295                 :     197720 :   tree fn = AGGR_INIT_EXPR_FN (aggr_init_expr);
    4296                 :     197720 :   tree slot = AGGR_INIT_EXPR_SLOT (aggr_init_expr);
    4297                 :     197720 :   tree type = TREE_TYPE (slot);
    4298                 :            : 
    4299                 :     197720 :   tree call_expr;
    4300                 :     197720 :   enum style_t { ctor, arg, pcc } style;
    4301                 :            : 
    4302                 :     197720 :   if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
    4303                 :            :     style = ctor;
    4304                 :            : #ifdef PCC_STATIC_STRUCT_RETURN
    4305                 :            :   else if (1)
    4306                 :            :     style = pcc;
    4307                 :            : #endif
    4308                 :            :   else
    4309                 :            :     {
    4310                 :      45447 :       gcc_assert (TREE_ADDRESSABLE (type));
    4311                 :            :       style = arg;
    4312                 :            :     }
    4313                 :            : 
    4314                 :     197720 :   call_expr = build_call_array_loc (input_location,
    4315                 :     197720 :                                     TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
    4316                 :            :                                     fn,
    4317                 :     197720 :                                     aggr_init_expr_nargs (aggr_init_expr),
    4318                 :     197720 :                                     AGGR_INIT_EXPR_ARGP (aggr_init_expr));
    4319                 :     197720 :   TREE_NOTHROW (call_expr) = TREE_NOTHROW (aggr_init_expr);
    4320                 :     197720 :   CALL_FROM_THUNK_P (call_expr) = AGGR_INIT_FROM_THUNK_P (aggr_init_expr);
    4321                 :     395440 :   CALL_EXPR_OPERATOR_SYNTAX (call_expr)
    4322                 :     395440 :     = CALL_EXPR_OPERATOR_SYNTAX (aggr_init_expr);
    4323                 :     593160 :   CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (aggr_init_expr);
    4324                 :     593160 :   CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (aggr_init_expr);
    4325                 :            : 
    4326                 :     197720 :   if (style == ctor)
    4327                 :            :     {
    4328                 :            :       /* Replace the first argument to the ctor with the address of the
    4329                 :            :          slot.  */
    4330                 :     152273 :       cxx_mark_addressable (slot);
    4331                 :     304546 :       CALL_EXPR_ARG (call_expr, 0) =
    4332                 :     304546 :         build1 (ADDR_EXPR, build_pointer_type (type), slot);
    4333                 :            :     }
    4334                 :      45447 :   else if (style == arg)
    4335                 :            :     {
    4336                 :            :       /* Just mark it addressable here, and leave the rest to
    4337                 :            :          expand_call{,_inline}.  */
    4338                 :      45447 :       cxx_mark_addressable (slot);
    4339                 :      45447 :       CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
    4340                 :      45447 :       call_expr = build2 (INIT_EXPR, TREE_TYPE (call_expr), slot, call_expr);
    4341                 :            :     }
    4342                 :            :   else if (style == pcc)
    4343                 :            :     {
    4344                 :            :       /* If we're using the non-reentrant PCC calling convention, then we
    4345                 :            :          need to copy the returned value out of the static buffer into the
    4346                 :            :          SLOT.  */
    4347                 :            :       push_deferring_access_checks (dk_no_check);
    4348                 :            :       call_expr = build_aggr_init (slot, call_expr,
    4349                 :            :                                    DIRECT_BIND | LOOKUP_ONLYCONVERTING,
    4350                 :            :                                    tf_warning_or_error);
    4351                 :            :       pop_deferring_access_checks ();
    4352                 :            :       call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
    4353                 :            :     }
    4354                 :            : 
    4355                 :     197720 :   if (AGGR_INIT_ZERO_FIRST (aggr_init_expr))
    4356                 :            :     {
    4357                 :       2348 :       tree init = build_zero_init (type, NULL_TREE,
    4358                 :            :                                    /*static_storage_p=*/false);
    4359                 :       2348 :       init = build2 (INIT_EXPR, void_type_node, slot, init);
    4360                 :       2348 :       call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (call_expr),
    4361                 :            :                           init, call_expr);
    4362                 :            :     }
    4363                 :            : 
    4364                 :     197720 :   *tp = call_expr;
    4365                 :     197720 : }
    4366                 :            : 
    4367                 :            : /* Emit all thunks to FN that should be emitted when FN is emitted.  */
    4368                 :            : 
    4369                 :            : void
    4370                 :   11937700 : emit_associated_thunks (tree fn)
    4371                 :            : {
    4372                 :            :   /* When we use vcall offsets, we emit thunks with the virtual
    4373                 :            :      functions to which they thunk. The whole point of vcall offsets
    4374                 :            :      is so that you can know statically the entire set of thunks that
    4375                 :            :      will ever be needed for a given virtual function, thereby
    4376                 :            :      enabling you to output all the thunks with the function itself.  */
    4377                 :   11937700 :   if (DECL_VIRTUAL_P (fn)
    4378                 :            :       /* Do not emit thunks for extern template instantiations.  */
    4379                 :   11937700 :       && ! DECL_REALLY_EXTERN (fn))
    4380                 :            :     {
    4381                 :     271797 :       tree thunk;
    4382                 :            : 
    4383                 :     548182 :       for (thunk = DECL_THUNKS (fn); thunk; thunk = DECL_CHAIN (thunk))
    4384                 :            :         {
    4385                 :       4588 :           if (!THUNK_ALIAS (thunk))
    4386                 :            :             {
    4387                 :       4588 :               use_thunk (thunk, /*emit_p=*/1);
    4388                 :       9176 :               if (DECL_RESULT_THUNK_P (thunk))
    4389                 :            :                 {
    4390                 :        227 :                   tree probe;
    4391                 :            : 
    4392                 :        417 :                   for (probe = DECL_THUNKS (thunk);
    4393                 :        417 :                        probe; probe = DECL_CHAIN (probe))
    4394                 :        190 :                     use_thunk (probe, /*emit_p=*/1);
    4395                 :            :                 }
    4396                 :            :             }
    4397                 :            :           else
    4398                 :          0 :             gcc_assert (!DECL_THUNKS (thunk));
    4399                 :            :         }
    4400                 :            :     }
    4401                 :   11937700 : }
    4402                 :            : 
    4403                 :            : /* Generate RTL for FN.  */
    4404                 :            : 
    4405                 :            : bool
    4406                 :   19800500 : expand_or_defer_fn_1 (tree fn)
    4407                 :            : {
    4408                 :            :   /* When the parser calls us after finishing the body of a template
    4409                 :            :      function, we don't really want to expand the body.  */
    4410                 :   19800500 :   if (processing_template_decl)
    4411                 :            :     {
    4412                 :            :       /* Normally, collection only occurs in rest_of_compilation.  So,
    4413                 :            :          if we don't collect here, we never collect junk generated
    4414                 :            :          during the processing of templates until we hit a
    4415                 :            :          non-template function.  It's not safe to do this inside a
    4416                 :            :          nested class, though, as the parser may have local state that
    4417                 :            :          is not a GC root.  */
    4418                 :    5683630 :       if (!function_depth)
    4419                 :    5669970 :         ggc_collect ();
    4420                 :    5683630 :       return false;
    4421                 :            :     }
    4422                 :            : 
    4423                 :   14116800 :   gcc_assert (DECL_SAVED_TREE (fn));
    4424                 :            : 
    4425                 :            :   /* We make a decision about linkage for these functions at the end
    4426                 :            :      of the compilation.  Until that point, we do not want the back
    4427                 :            :      end to output them -- but we do want it to see the bodies of
    4428                 :            :      these functions so that it can inline them as appropriate.  */
    4429                 :   14792800 :   if (DECL_DECLARED_INLINE_P (fn) || DECL_IMPLICIT_INSTANTIATION (fn))
    4430                 :            :     {
    4431                 :   13897200 :       if (DECL_INTERFACE_KNOWN (fn))
    4432                 :            :         /* We've already made a decision as to how this function will
    4433                 :            :            be handled.  */;
    4434                 :    7309920 :       else if (!at_eof
    4435                 :    5371250 :                || DECL_IMMEDIATE_FUNCTION_P (fn)
    4436                 :   12681200 :                || DECL_OMP_DECLARE_REDUCTION_P (fn))
    4437                 :    1938670 :         tentative_decl_linkage (fn);
    4438                 :            :       else
    4439                 :    5371250 :         import_export_decl (fn);
    4440                 :            : 
    4441                 :            :       /* If the user wants us to keep all inline functions, then mark
    4442                 :            :          this function as needed so that finish_file will make sure to
    4443                 :            :          output it later.  Similarly, all dllexport'd functions must
    4444                 :            :          be emitted; there may be callers in other DLLs.  */
    4445                 :   13897200 :       if (DECL_DECLARED_INLINE_P (fn)
    4446                 :   13440900 :           && !DECL_REALLY_EXTERN (fn)
    4447                 :   11619900 :           && !DECL_IMMEDIATE_FUNCTION_P (fn)
    4448                 :   11619800 :           && !DECL_OMP_DECLARE_REDUCTION_P (fn)
    4449                 :   25517100 :           && (flag_keep_inline_functions
    4450                 :   11619400 :               || (flag_keep_inline_dllexport
    4451                 :   11619400 :                   && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn)))))
    4452                 :            :         {
    4453                 :        440 :           mark_needed (fn);
    4454                 :        440 :           DECL_EXTERNAL (fn) = 0;
    4455                 :            :         }
    4456                 :            :     }
    4457                 :            : 
    4458                 :            :   /* If this is a constructor or destructor body, we have to clone
    4459                 :            :      it.  */
    4460                 :   14116800 :   if (maybe_clone_body (fn))
    4461                 :            :     {
    4462                 :            :       /* We don't want to process FN again, so pretend we've written
    4463                 :            :          it out, even though we haven't.  */
    4464                 :    2176140 :       TREE_ASM_WRITTEN (fn) = 1;
    4465                 :            :       /* If this is a constexpr function, keep DECL_SAVED_TREE.  */
    4466                 :    4352280 :       if (!DECL_DECLARED_CONSTEXPR_P (fn))
    4467                 :    1816270 :         DECL_SAVED_TREE (fn) = NULL_TREE;
    4468                 :    2176140 :       return false;
    4469                 :            :     }
    4470                 :            : 
    4471                 :            :   /* There's no reason to do any of the work here if we're only doing
    4472                 :            :      semantic analysis; this code just generates RTL.  */
    4473                 :   11940700 :   if (flag_syntax_only)
    4474                 :            :     {
    4475                 :            :       /* Pretend that this function has been written out so that we don't try
    4476                 :            :          to expand it again.  */
    4477                 :       2942 :       TREE_ASM_WRITTEN (fn) = 1;
    4478                 :       2942 :       return false;
    4479                 :            :     }
    4480                 :            : 
    4481                 :   11937800 :   if (DECL_OMP_DECLARE_REDUCTION_P (fn))
    4482                 :         16 :     return false;
    4483                 :            : 
    4484                 :            :   return true;
    4485                 :            : }
    4486                 :            : 
    4487                 :            : void
    4488                 :   17685600 : expand_or_defer_fn (tree fn)
    4489                 :            : {
    4490                 :   17685600 :   if (expand_or_defer_fn_1 (fn))
    4491                 :            :     {
    4492                 :    9823200 :       function_depth++;
    4493                 :            : 
    4494                 :            :       /* Expand or defer, at the whim of the compilation unit manager.  */
    4495                 :    9823200 :       cgraph_node::finalize_function (fn, function_depth > 1);
    4496                 :    9823200 :       emit_associated_thunks (fn);
    4497                 :            : 
    4498                 :    9823200 :       function_depth--;
    4499                 :            :     }
    4500                 :   17685600 : }
    4501                 :            : 
    4502                 :      26130 : class nrv_data
    4503                 :            : {
    4504                 :            : public:
    4505                 :      26130 :   nrv_data () : visited (37) {}
    4506                 :            : 
    4507                 :            :   tree var;
    4508                 :            :   tree result;
    4509                 :            :   hash_table<nofree_ptr_hash <tree_node> > visited;
    4510                 :            : };
    4511                 :            : 
    4512                 :            : /* Helper function for walk_tree, used by finalize_nrv below.  */
    4513                 :            : 
    4514                 :            : static tree
    4515                 :    3818020 : finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
    4516                 :            : {
    4517                 :    3818020 :   class nrv_data *dp = (class nrv_data *)data;
    4518                 :    3818020 :   tree_node **slot;
    4519                 :            : 
    4520                 :            :   /* No need to walk into types.  There wouldn't be any need to walk into
    4521                 :            :      non-statements, except that we have to consider STMT_EXPRs.  */
    4522                 :    3818020 :   if (TYPE_P (*tp))
    4523                 :         26 :     *walk_subtrees = 0;
    4524                 :            :   /* Change all returns to just refer to the RESULT_DECL; this is a nop,
    4525                 :            :      but differs from using NULL_TREE in that it indicates that we care
    4526                 :            :      about the value of the RESULT_DECL.  */
    4527                 :    3817990 :   else if (TREE_CODE (*tp) == RETURN_EXPR)
    4528                 :      26216 :     TREE_OPERAND (*tp, 0) = dp->result;
    4529                 :            :   /* Change all cleanups for the NRV to only run when an exception is
    4530                 :            :      thrown.  */
    4531                 :    3791780 :   else if (TREE_CODE (*tp) == CLEANUP_STMT
    4532                 :    3791780 :            && CLEANUP_DECL (*tp) == dp->var)
    4533                 :      22279 :     CLEANUP_EH_ONLY (*tp) = 1;
    4534                 :            :   /* Replace the DECL_EXPR for the NRV with an initialization of the
    4535                 :            :      RESULT_DECL, if needed.  */
    4536                 :    3769500 :   else if (TREE_CODE (*tp) == DECL_EXPR
    4537                 :    3769500 :            && DECL_EXPR_DECL (*tp) == dp->var)
    4538                 :            :     {
    4539                 :      26132 :       tree init;
    4540                 :      26132 :       if (DECL_INITIAL (dp->var)
    4541                 :      26132 :           && DECL_INITIAL (dp->var) != error_mark_node)
    4542                 :        912 :         init = build2 (INIT_EXPR, void_type_node, dp->result,
    4543                 :        912 :                        DECL_INITIAL (dp->var));
    4544                 :            :       else
    4545                 :      25220 :         init = build_empty_stmt (EXPR_LOCATION (*tp));
    4546                 :      26132 :       DECL_INITIAL (dp->var) = NULL_TREE;
    4547                 :      26132 :       SET_EXPR_LOCATION (init, EXPR_LOCATION (*tp));
    4548                 :      26132 :       *tp = init;
    4549                 :            :     }
    4550                 :            :   /* And replace all uses of the NRV with the RESULT_DECL.  */
    4551                 :    3743360 :   else if (*tp == dp->var)
    4552                 :     115204 :     *tp = dp->result;
    4553                 :            : 
    4554                 :            :   /* Avoid walking into the same tree more than once.  Unfortunately, we
    4555                 :            :      can't just use walk_tree_without duplicates because it would only call
    4556                 :            :      us for the first occurrence of dp->var in the function body.  */
    4557                 :    3818020 :   slot = dp->visited.find_slot (*tp, INSERT);
    4558                 :    3818020 :   if (*slot)
    4559                 :    1049580 :     *walk_subtrees = 0;
    4560                 :            :   else
    4561                 :    2768440 :     *slot = *tp;
    4562                 :            : 
    4563                 :            :   /* Keep iterating.  */
    4564                 :    3818020 :   return NULL_TREE;
    4565                 :            : }
    4566                 :            : 
    4567                 :            : /* Called from finish_function to implement the named return value
    4568                 :            :    optimization by overriding all the RETURN_EXPRs and pertinent
    4569                 :            :    CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
    4570                 :            :    RESULT_DECL for the function.  */
    4571                 :            : 
    4572                 :            : void
    4573                 :      26130 : finalize_nrv (tree *tp, tree var, tree result)
    4574                 :            : {
    4575                 :      26130 :   class nrv_data data;
    4576                 :            : 
    4577                 :            :   /* Copy name from VAR to RESULT.  */
    4578                 :      26130 :   DECL_NAME (result) = DECL_NAME (var);
    4579                 :            :   /* Don't forget that we take its address.  */
    4580                 :      26130 :   TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);
    4581                 :            :   /* Finally set DECL_VALUE_EXPR to avoid assigning
    4582                 :            :      a stack slot at -O0 for the original var and debug info
    4583                 :            :      uses RESULT location for VAR.  */
    4584                 :      26130 :   SET_DECL_VALUE_EXPR (var, result);
    4585                 :      26130 :   DECL_HAS_VALUE_EXPR_P (var) = 1;
    4586                 :            : 
    4587                 :      26130 :   data.var = var;
    4588                 :      26130 :   data.result = result;
    4589                 :      26130 :   cp_walk_tree (tp, finalize_nrv_r, &data, 0);
    4590                 :      26130 : }
    4591                 :            : 
    4592                 :            : /* Create CP_OMP_CLAUSE_INFO for clause C.  Returns true if it is invalid.  */
    4593                 :            : 
    4594                 :            : bool
    4595                 :       2283 : cxx_omp_create_clause_info (tree c, tree type, bool need_default_ctor,
    4596                 :            :                             bool need_copy_ctor, bool need_copy_assignment,
    4597                 :            :                             bool need_dtor)
    4598                 :            : {
    4599                 :       2283 :   int save_errorcount = errorcount;
    4600                 :       2283 :   tree info, t;
    4601                 :            : 
    4602                 :            :   /* Always allocate 3 elements for simplicity.  These are the
    4603                 :            :      function decls for the ctor, dtor, and assignment op.
    4604                 :            :      This layout is known to the three lang hooks,
    4605                 :            :      cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
    4606                 :            :      and cxx_omp_clause_assign_op.  */
    4607                 :       2283 :   info = make_tree_vec (3);
    4608                 :       2283 :   CP_OMP_CLAUSE_INFO (c) = info;
    4609                 :            : 
    4610                 :       2283 :   if (need_default_ctor || need_copy_ctor)
    4611                 :            :     {
    4612                 :       1775 :       if (need_default_ctor)
    4613                 :       1383 :         t = get_default_ctor (type);
    4614                 :            :       else
    4615                 :        392 :         t = get_copy_ctor (type, tf_warning_or_error);
    4616                 :            : 
    4617                 :       1775 :       if (t && !trivial_fn_p (t))
    4618                 :       1535 :         TREE_VEC_ELT (info, 0) = t;
    4619                 :            :     }
    4620                 :            : 
    4621                 :       4537 :   if (need_dtor && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
    4622                 :       1726 :     TREE_VEC_ELT (info, 1) = get_dtor (type, tf_warning_or_error);
    4623                 :            : 
    4624                 :       2283 :   if (need_copy_assignment)
    4625                 :            :     {
    4626                 :        433 :       t = get_copy_assign (type);
    4627                 :            : 
    4628                 :        433 :       if (t && !trivial_fn_p (t))
    4629                 :        372 :         TREE_VEC_ELT (info, 2) = t;
    4630                 :            :     }
    4631                 :            : 
    4632                 :       2283 :   return errorcount != save_errorcount;
    4633                 :            : }
    4634                 :            : 
    4635                 :            : /* If DECL is DECL_OMP_PRIVATIZED_MEMBER, return corresponding
    4636                 :            :    FIELD_DECL, otherwise return DECL itself.  */
    4637                 :            : 
    4638                 :            : static tree
    4639                 :      15719 : omp_clause_decl_field (tree decl)
    4640                 :            : {
    4641                 :      15719 :   if (VAR_P (decl)
    4642                 :      10106 :       && DECL_HAS_VALUE_EXPR_P (decl)
    4643                 :        322 :       && DECL_ARTIFICIAL (decl)
    4644                 :        322 :       && DECL_LANG_SPECIFIC (decl)
    4645                 :      16017 :       && DECL_OMP_PRIVATIZED_MEMBER (decl))
    4646                 :            :     {
    4647                 :        292 :       tree f = DECL_VALUE_EXPR (decl);
    4648                 :        292 :       if (INDIRECT_REF_P (f))
    4649                 :          0 :         f = TREE_OPERAND (f, 0);
    4650                 :        292 :       if (TREE_CODE (f) == COMPONENT_REF)
    4651                 :            :         {
    4652                 :        292 :           f = TREE_OPERAND (f, 1);
    4653                 :        292 :           gcc_assert (TREE_CODE (f) == FIELD_DECL);
    4654                 :            :           return f;
    4655                 :            :         }
    4656                 :            :     }
    4657                 :            :   return NULL_TREE;
    4658                 :            : }
    4659                 :            : 
    4660                 :            : /* Adjust DECL if needed for printing using %qE.  */
    4661                 :            : 
    4662                 :            : static tree
    4663                 :        212 : omp_clause_printable_decl (tree decl)
    4664                 :            : {
    4665                 :          0 :   tree t = omp_clause_decl_field (decl);
    4666                 :        212 :   if (t)
    4667                 :         60 :     return t;
    4668                 :            :   return decl;
    4669                 :            : }
    4670                 :            : 
    4671                 :            : /* For a FIELD_DECL F and corresponding DECL_OMP_PRIVATIZED_MEMBER
    4672                 :            :    VAR_DECL T that doesn't need a DECL_EXPR added, record it for
    4673                 :            :    privatization.  */
    4674                 :            : 
    4675                 :            : static void
    4676                 :        168 : omp_note_field_privatization (tree f, tree t)
    4677                 :            : {
    4678                 :        168 :   if (!omp_private_member_map)
    4679                 :         48 :     omp_private_member_map = new hash_map<tree, tree>;
    4680                 :        168 :   tree &v = omp_private_member_map->get_or_insert (f);
    4681                 :        168 :   if (v == NULL_TREE)
    4682                 :            :     {
    4683                 :        128 :       v = t;
    4684                 :        128 :       omp_private_member_vec.safe_push (f);
    4685                 :            :       /* Signal that we don't want to create DECL_EXPR for this dummy var.  */
    4686                 :        128 :       omp_private_member_vec.safe_push (integer_zero_node);
    4687                 :            :     }
    4688                 :        168 : }
    4689                 :            : 
    4690                 :            : /* Privatize FIELD_DECL T, return corresponding DECL_OMP_PRIVATIZED_MEMBER
    4691                 :            :    dummy VAR_DECL.  */
    4692                 :            : 
    4693                 :            : tree
    4694                 :        896 : omp_privatize_field (tree t, bool shared)
    4695                 :            : {
    4696                 :        896 :   tree m = finish_non_static_data_member (t, NULL_TREE, NULL_TREE);
    4697                 :        896 :   if (m == error_mark_node)
    4698                 :            :     return error_mark_node;
    4699                 :        896 :   if (!omp_private_member_map && !shared)
    4700                 :        380 :     omp_private_member_map = new hash_map<tree, tree>;
    4701                 :        896 :   if (TYPE_REF_P (TREE_TYPE (t)))
    4702                 :            :     {
    4703                 :        139 :       gcc_assert (INDIRECT_REF_P (m));
    4704                 :        139 :       m = TREE_OPERAND (m, 0);
    4705                 :            :     }
    4706                 :        896 :   tree vb = NULL_TREE;
    4707                 :        896 :   tree &v = shared ? vb : omp_private_member_map->get_or_insert (t);
    4708                 :        896 :   if (v == NULL_TREE)
    4709                 :            :     {
    4710                 :        823 :       v = create_temporary_var (TREE_TYPE (m));
    4711                 :        823 :       retrofit_lang_decl (v);
    4712                 :        823 :       DECL_OMP_PRIVATIZED_MEMBER (v) = 1;
    4713                 :        823 :       SET_DECL_VALUE_EXPR (v, m);
    4714                 :        823 :       DECL_HAS_VALUE_EXPR_P (v) = 1;
    4715                 :        823 :       if (!shared)
    4716                 :        725 :         omp_private_member_vec.safe_push (t);
    4717                 :            :     }
    4718                 :        896 :   return v;
    4719                 :            : }
    4720                 :            : 
    4721                 :            : /* Helper function for handle_omp_array_sections.  Called recursively
    4722                 :            :    to handle multiple array-section-subscripts.  C is the clause,
    4723                 :            :    T current expression (initially OMP_CLAUSE_DECL), which is either
    4724                 :            :    a TREE_LIST for array-section-subscript (TREE_PURPOSE is low-bound
    4725                 :            :    expression if specified, TREE_VALUE length expression if specified,
    4726                 :            :    TREE_CHAIN is what it has been specified after, or some decl.
    4727                 :            :    TYPES vector is populated with array section types, MAYBE_ZERO_LEN
    4728                 :            :    set to true if any of the array-section-subscript could have length
    4729                 :            :    of zero (explicit or implicit), FIRST_NON_ONE is the index of the
    4730                 :            :    first array-section-subscript which is known not to have length
    4731                 :            :    of one.  Given say:
    4732                 :            :    map(a[:b][2:1][:c][:2][:d][e:f][2:5])
    4733                 :            :    FIRST_NON_ONE will be 3, array-section-subscript [:b], [2:1] and [:c]
    4734                 :            :    all are or may have length of 1, array-section-subscript [:2] is the
    4735                 :            :    first one known not to have length 1.  For array-section-subscript
    4736                 :            :    <= FIRST_NON_ONE we diagnose non-contiguous arrays if low bound isn't
    4737                 :            :    0 or length isn't the array domain max + 1, for > FIRST_NON_ONE we
    4738                 :            :    can if MAYBE_ZERO_LEN is false.  MAYBE_ZERO_LEN will be true in the above
    4739                 :            :    case though, as some lengths could be zero.  */
    4740                 :            : 
    4741                 :            : static tree
    4742                 :      11681 : handle_omp_array_sections_1 (tree c, tree t, vec<tree> &types,
    4743                 :            :                              bool &maybe_zero_len, unsigned int &first_non_one,
    4744                 :            :                              enum c_omp_region_type ort)
    4745                 :            : {
    4746                 :      11681 :   tree ret, low_bound, length, type;
    4747                 :      11681 :   if (TREE_CODE (t) != TREE_LIST)
    4748                 :            :     {
    4749                 :      10690 :       if (error_operand_p (t))
    4750                 :            :         return error_mark_node;
    4751                 :         34 :       if (REFERENCE_REF_P (t)
    4752                 :       5379 :           && TREE_CODE (TREE_OPERAND (t, 0)) == COMPONENT_REF)
    4753                 :         34 :         t = TREE_OPERAND (t, 0);
    4754                 :       5345 :       ret = t;
    4755                 :       5345 :       if (TREE_CODE (t) == COMPONENT_REF
    4756                 :        390 :           && (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
    4757                 :         48 :               || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TO
    4758                 :         24 :               || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FROM)
    4759                 :       5735 :           && !type_dependent_expression_p (t))
    4760                 :            :         {
    4761                 :        281 :           if (TREE_CODE (TREE_OPERAND (t, 1)) == FIELD_DECL
    4762                 :        281 :               && DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
    4763                 :            :             {
    4764                 :          0 :               error_at (OMP_CLAUSE_LOCATION (c),
    4765                 :            :                         "bit-field %qE in %qs clause",
    4766                 :          0 :                         t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    4767                 :          0 :               return error_mark_node;
    4768                 :            :             }
    4769                 :        582 :           while (TREE_CODE (t) == COMPONENT_REF)
    4770                 :            :             {
    4771                 :        301 :               if (TREE_TYPE (TREE_OPERAND (t, 0))
    4772                 :        301 :                   && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == UNION_TYPE)
    4773                 :            :                 {
    4774                 :          0 :                   error_at (OMP_CLAUSE_LOCATION (c),
    4775                 :            :                             "%qE is a member of a union", t);
    4776                 :          0 :                   return error_mark_node;
    4777                 :            :                 }
    4778                 :        301 :               t = TREE_OPERAND (t, 0);
    4779                 :        301 :               if (ort == C_ORT_ACC && TREE_CODE (t) == INDIRECT_REF)
    4780                 :         16 :                 t = TREE_OPERAND (t, 0);
    4781                 :            :             }
    4782                 :        281 :           if (REFERENCE_REF_P (t))
    4783                 :         14 :             t = TREE_OPERAND (t, 0);
    4784                 :            :         }
    4785                 :       5345 :       if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
    4786                 :            :         {
    4787                 :        149 :           if (processing_template_decl && TREE_CODE (t) != OVERLOAD)
    4788                 :            :             return NULL_TREE;
    4789                 :         24 :           if (DECL_P (t))
    4790                 :         24 :             error_at (OMP_CLAUSE_LOCATION (c),
    4791                 :            :                       "%qD is not a variable in %qs clause", t,
    4792                 :         24 :                       omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    4793                 :            :           else
    4794                 :          0 :             error_at (OMP_CLAUSE_LOCATION (c),
    4795                 :            :                       "%qE is not a variable in %qs clause", t,
    4796                 :          0 :                       omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    4797                 :         24 :           return error_mark_node;
    4798                 :            :         }
    4799                 :       5196 :       else if (ort == C_ORT_OMP
    4800                 :       3367 :                && TREE_CODE (t) == PARM_DECL
    4801                 :       1214 :                && DECL_ARTIFICIAL (t)
    4802                 :       5228 :                && DECL_NAME (t) == this_identifier)
    4803                 :            :         {
    4804                 :         32 :           error_at (OMP_CLAUSE_LOCATION (c),
    4805                 :            :                     "%<this%> allowed in OpenMP only in %<declare simd%>"
    4806                 :            :                     " clauses");
    4807                 :         32 :           return error_mark_node;
    4808                 :            :         }
    4809                 :       5164 :       else if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
    4810                 :       5164 :                && VAR_P (t) && CP_DECL_THREAD_LOCAL_P (t))
    4811                 :            :         {
    4812                 :          4 :           error_at (OMP_CLAUSE_LOCATION (c),
    4813                 :            :                     "%qD is threadprivate variable in %qs clause", t,
    4814                 :          4 :                     omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    4815                 :          4 :           return error_mark_node;
    4816                 :            :         }
    4817                 :       5160 :       if (type_dependent_expression_p (ret))
    4818                 :            :         return NULL_TREE;
    4819                 :       4988 :       ret = convert_from_reference (ret);
    4820                 :       4988 :       return ret;
    4821                 :            :     }
    4822                 :            : 
    4823                 :       6336 :   if (ort == C_ORT_OMP
    4824                 :       4494 :       && (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
    4825                 :       3784 :           || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
    4826                 :       2574 :           || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION)
    4827                 :       8361 :       && TREE_CODE (TREE_CHAIN (t)) == FIELD_DECL)
    4828                 :         43 :     TREE_CHAIN (t) = omp_privatize_field (TREE_CHAIN (t), false);
    4829                 :       6336 :   ret = handle_omp_array_sections_1 (c, TREE_CHAIN (t), types,
    4830                 :            :                                      maybe_zero_len, first_non_one, ort);
    4831                 :       6336 :   if (ret == error_mark_node || ret == NULL_TREE)
    4832                 :            :     return ret;
    4833                 :            : 
    4834                 :       5825 :   type = TREE_TYPE (ret);
    4835                 :       5825 :   low_bound = TREE_PURPOSE (t);
    4836                 :       5825 :   length = TREE_VALUE (t);
    4837                 :       4897 :   if ((low_bound && type_dependent_expression_p (low_bound))
    4838                 :      10628 :       || (length && type_dependent_expression_p (length)))
    4839                 :         99 :     return NULL_TREE;
    4840                 :            : 
    4841                 :       5726 :   if (low_bound == error_mark_node || length == error_mark_node)
    4842                 :            :     return error_mark_node;
    4843                 :            : 
    4844                 :      10524 :   if (low_bound && !INTEGRAL_TYPE_P (TREE_TYPE (low_bound)))
    4845                 :            :     {
    4846                 :         36 :       error_at (OMP_CLAUSE_LOCATION (c),
    4847                 :            :                 "low bound %qE of array section does not have integral type",
    4848                 :            :                 low_bound);
    4849                 :         36 :       return error_mark_node;
    4850                 :            :     }
    4851                 :      10832 :   if (length && !INTEGRAL_TYPE_P (TREE_TYPE (length)))
    4852                 :            :     {
    4853                 :         36 :       error_at (OMP_CLAUSE_LOCATION (c),
    4854                 :            :                 "length %qE of array section does not have integral type",
    4855                 :            :                 length);
    4856                 :         36 :       return error_mark_node;
    4857                 :            :     }
    4858                 :       5654 :   if (low_bound)
    4859                 :       4758 :     low_bound = mark_rvalue_use (low_bound);
    4860                 :       5654 :   if (length)
    4861                 :       5106 :     length = mark_rvalue_use (length);
    4862                 :            :   /* We need to reduce to real constant-values for checks below.  */
    4863                 :       5654 :   if (length)
    4864                 :       5106 :     length = fold_simple (length);
    4865                 :       5654 :   if (low_bound)
    4866                 :       4758 :     low_bound = fold_simple (low_bound);
    4867                 :       5654 :   if (low_bound
    4868                 :       4758 :       && TREE_CODE (low_bound) == INTEGER_CST
    4869                 :       8056 :       && TYPE_PRECISION (TREE_TYPE (low_bound))
    4870                 :       2402 :          > TYPE_PRECISION (sizetype))
    4871                 :          0 :     low_bound = fold_convert (sizetype, low_bound);
    4872                 :       5654 :   if (length
    4873                 :       5106 :       && TREE_CODE (length) == INTEGER_CST
    4874                 :       8445 :       && TYPE_PRECISION (TREE_TYPE (length))
    4875                 :       2791 :          > TYPE_PRECISION (sizetype))
    4876                 :          0 :     length = fold_convert (sizetype, length);
    4877                 :       5654 :   if (low_bound == NULL_TREE)
    4878                 :        896 :     low_bound = integer_zero_node;
    4879                 :            : 
    4880                 :       5654 :   if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
    4881                 :       5654 :       && (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ATTACH
    4882                 :       2555 :           || OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_DETACH))
    4883                 :            :     {
    4884                 :         80 :       if (length != integer_one_node)
    4885                 :            :         {
    4886                 :         48 :           error_at (OMP_CLAUSE_LOCATION (c),
    4887                 :            :                     "expected single pointer in %qs clause",
    4888                 :            :                     c_omp_map_clause_name (c, ort == C_ORT_ACC));
    4889                 :         48 :           return error_mark_node;
    4890                 :            :         }
    4891                 :            :     }
    4892                 :       5606 :   if (length != NULL_TREE)
    4893                 :            :     {
    4894                 :       5090 :       if (!integer_nonzerop (length))
    4895                 :            :         {
    4896                 :       1805 :           if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
    4897                 :       1765 :               || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
    4898                 :       1601 :               || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
    4899                 :       3216 :               || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION)
    4900                 :            :             {
    4901                 :        421 :               if (integer_zerop (length))
    4902                 :            :                 {
    4903                 :         32 :                   error_at (OMP_CLAUSE_LOCATION (c),
    4904                 :            :                             "zero length array section in %qs clause",
    4905                 :         32 :                             omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    4906                 :         32 :                   return error_mark_node;
    4907                 :            :                 }
    4908                 :            :             }
    4909                 :            :           else
    4910                 :       1384 :             maybe_zero_len = true;
    4911                 :            :         }
    4912                 :       5058 :       if (first_non_one == types.length ()
    4913                 :       5058 :           && (TREE_CODE (length) != INTEGER_CST || integer_onep (length)))
    4914                 :       3235 :         first_non_one++;
    4915                 :            :     }
    4916                 :       5574 :   if (TREE_CODE (type) == ARRAY_TYPE)
    4917                 :            :     {
    4918                 :       2958 :       if (length == NULL_TREE
    4919                 :       2958 :           && (TYPE_DOMAIN (type) == NULL_TREE
    4920                 :        476 :               || TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE))
    4921                 :            :         {
    4922                 :         20 :           error_at (OMP_CLAUSE_LOCATION (c),
    4923                 :            :                     "for unknown bound array type length expression must "
    4924                 :            :                     "be specified");
    4925                 :         20 :           return error_mark_node;
    4926                 :            :         }
    4927                 :       2938 :       if (TREE_CODE (low_bound) == INTEGER_CST
    4928                 :       2938 :           && tree_int_cst_sgn (low_bound) == -1)
    4929                 :            :         {
    4930                 :         64 :           error_at (OMP_CLAUSE_LOCATION (c),
    4931                 :            :                     "negative low bound in array section in %qs clause",
    4932                 :         64 :                     omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    4933                 :         64 :           return error_mark_node;
    4934                 :            :         }
    4935                 :       2874 :       if (length != NULL_TREE
    4936                 :       2422 :           && TREE_CODE (length) == INTEGER_CST
    4937                 :       4416 :           && tree_int_cst_sgn (length) == -1)
    4938                 :            :         {
    4939                 :         64 :           error_at (OMP_CLAUSE_LOCATION (c),
    4940                 :            :                     "negative length in array section in %qs clause",
    4941                 :         64 :                     omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    4942                 :         64 :           return error_mark_node;
    4943                 :            :         }
    4944                 :       2810 :       if (TYPE_DOMAIN (type)
    4945                 :       2782 :           && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
    4946                 :       5592 :           && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
    4947                 :            :                         == INTEGER_CST)
    4948                 :            :         {
    4949                 :       2497 :           tree size
    4950                 :       2497 :             = fold_convert (sizetype, TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
    4951                 :       2497 :           size = size_binop (PLUS_EXPR, size, size_one_node);
    4952                 :       2497 :           if (TREE_CODE (low_bound) == INTEGER_CST)
    4953                 :            :             {
    4954                 :       1753 :               if (tree_int_cst_lt (size, low_bound))
    4955                 :            :                 {
    4956                 :         32 :                   error_at (OMP_CLAUSE_LOCATION (c),
    4957                 :            :                             "low bound %qE above array section size "
    4958                 :            :                             "in %qs clause", low_bound,
    4959                 :         32 :                             omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    4960                 :         32 :                   return error_mark_node;
    4961                 :            :                 }
    4962                 :       1721 :               if (tree_int_cst_equal (size, low_bound))
    4963                 :            :                 {
    4964                 :         20 :                   if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
    4965                 :          8 :                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
    4966                 :          0 :                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
    4967                 :         20 :                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION)
    4968                 :            :                     {
    4969                 :         20 :                       error_at (OMP_CLAUSE_LOCATION (c),
    4970                 :            :                                 "zero length array section in %qs clause",
    4971                 :         20 :                                 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    4972                 :         20 :                       return error_mark_node;
    4973                 :            :                     }
    4974                 :          0 :                   maybe_zero_len = true;
    4975                 :            :                 }
    4976                 :       1701 :               else if (length == NULL_TREE
    4977                 :        784 :                        && first_non_one == types.length ()
    4978                 :       1844 :                        && tree_int_cst_equal
    4979                 :        143 :                             (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
    4980                 :            :                              low_bound))
    4981                 :         56 :                 first_non_one++;
    4982                 :            :             }
    4983                 :        744 :           else if (length == NULL_TREE)
    4984                 :            :             {
    4985                 :          7 :               if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
    4986                 :          3 :                   && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_REDUCTION
    4987                 :          0 :                   && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_IN_REDUCTION
    4988                 :          7 :                   && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_TASK_REDUCTION)
    4989                 :          0 :                 maybe_zero_len = true;
    4990                 :         14 :               if (first_non_one == types.length ())
    4991                 :          3 :                 first_non_one++;
    4992                 :            :             }
    4993                 :       2445 :           if (length && TREE_CODE (length) == INTEGER_CST)
    4994                 :            :             {
    4995                 :       1445 :               if (tree_int_cst_lt (size, length))
    4996                 :            :                 {
    4997                 :         36 :                   error_at (OMP_CLAUSE_LOCATION (c),
    4998                 :            :                             "length %qE above array section size "
    4999                 :            :                             "in %qs clause", length,
    5000                 :         36 :                             omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    5001                 :         36 :                   return error_mark_node;
    5002                 :            :                 }
    5003                 :       1409 :               if (TREE_CODE (low_bound) == INTEGER_CST)
    5004                 :            :                 {
    5005                 :       1220 :                   tree lbpluslen
    5006                 :       1220 :                     = size_binop (PLUS_EXPR,
    5007                 :            :                                   fold_convert (sizetype, low_bound),
    5008                 :            :                                   fold_convert (sizetype, length));
    5009                 :       1220 :                   if (TREE_CODE (lbpluslen) == INTEGER_CST
    5010                 :       1220 :                       && tree_int_cst_lt (size, lbpluslen))
    5011                 :            :                     {
    5012                 :         32 :                       error_at (OMP_CLAUSE_LOCATION (c),
    5013                 :            :                                 "high bound %qE above array section size "
    5014                 :            :                                 "in %qs clause", lbpluslen,
    5015                 :         32 :                                 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    5016                 :         32 :                       return error_mark_node;
    5017                 :            :                     }
    5018                 :            :                 }
    5019                 :            :             }
    5020                 :            :         }
    5021                 :        313 :       else if (length == NULL_TREE)
    5022                 :            :         {
    5023                 :          1 :           if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
    5024                 :          1 :               && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_REDUCTION
    5025                 :          0 :               && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_IN_REDUCTION
    5026                 :          1 :               && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_TASK_REDUCTION)
    5027                 :          0 :             maybe_zero_len = true;
    5028                 :          2 :           if (first_non_one == types.length ())
    5029                 :          1 :             first_non_one++;
    5030                 :            :         }
    5031                 :            : 
    5032                 :            :       /* For [lb:] we will need to evaluate lb more than once.  */
    5033                 :       3090 :       if (length == NULL_TREE && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND)
    5034                 :            :         {
    5035                 :        292 :           tree lb = cp_save_expr (low_bound);
    5036                 :        292 :           if (lb != low_bound)
    5037                 :            :             {
    5038                 :          2 :               TREE_PURPOSE (t) = lb;
    5039                 :          2 :               low_bound = lb;
    5040                 :            :             }
    5041                 :            :         }
    5042                 :            :     }
    5043                 :       2616 :   else if (TYPE_PTR_P (type))
    5044                 :            :     {
    5045                 :       2596 :       if (length == NULL_TREE)
    5046                 :            :         {
    5047                 :         20 :           error_at (OMP_CLAUSE_LOCATION (c),
    5048                 :            :                     "for pointer type length expression must be specified");
    5049                 :         20 :           return error_mark_node;
    5050                 :            :         }
    5051                 :       2576 :       if (length != NULL_TREE
    5052                 :       2576 :           && TREE_CODE (length) == INTEGER_CST
    5053                 :       1161 :           && tree_int_cst_sgn (length) == -1)
    5054                 :            :         {
    5055                 :         32 :           error_at (OMP_CLAUSE_LOCATION (c),
    5056                 :            :                     "negative length in array section in %qs clause",
    5057                 :         32 :                     omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    5058                 :         32 :           return error_mark_node;
    5059                 :            :         }
    5060                 :            :       /* If there is a pointer type anywhere but in the very first
    5061                 :            :          array-section-subscript, the array section can't be contiguous.  */
    5062                 :       2544 :       if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
    5063                 :       4732 :           && TREE_CODE (TREE_CHAIN (t)) == TREE_LIST)
    5064                 :            :         {
    5065                 :          8 :           error_at (OMP_CLAUSE_LOCATION (c),
    5066                 :            :                     "array section is not contiguous in %qs clause",
    5067                 :          8 :                     omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    5068                 :          8 :           return error_mark_node;
    5069                 :            :         }
    5070                 :            :     }
    5071                 :            :   else
    5072                 :            :     {
    5073                 :         20 :       error_at (OMP_CLAUSE_LOCATION (c),
    5074                 :            :                 "%qE does not have pointer or array type", ret);
    5075                 :         20 :       return error_mark_node;
    5076                 :            :     }
    5077                 :       5226 :   if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND)
    5078                 :       4374 :     types.safe_push (TREE_TYPE (ret));
    5079                 :            :   /* We will need to evaluate lb more than once.  */
    5080                 :       5226 :   tree lb = cp_save_expr (low_bound);
    5081                 :       5226 :   if (lb != low_bound)
    5082                 :            :     {
    5083                 :        575 :       TREE_PURPOSE (t) = lb;
    5084                 :        575 :       low_bound = lb;
    5085                 :            :     }
    5086                 :            :   /* Temporarily disable -fstrong-eval-order for array reductions.
    5087                 :            :      The SAVE_EXPR and COMPOUND_EXPR added if low_bound has side-effects
    5088                 :            :      is something the middle-end can't cope with and more importantly,
    5089                 :            :      it needs to be the actual base variable that is privatized, not some
    5090                 :            :      temporary assigned previous value of it.  That, together with OpenMP
    5091                 :            :      saying how many times the side-effects are evaluated is unspecified,
    5092                 :            :      makes int *a, *b; ... reduction(+:a[a = b, 3:10]) really unspecified.  */
    5093                 :       5226 :   warning_sentinel s (flag_strong_eval_order,
    5094                 :       5226 :                       OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
    5095                 :       4669 :                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
    5096                 :       9991 :                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION);
    5097                 :       5226 :   ret = grok_array_decl (OMP_CLAUSE_LOCATION (c), ret, low_bound, false);
    5098                 :       5226 :   return ret;
    5099                 :            : }
    5100                 :            : 
    5101                 :            : /* Handle array sections for clause C.  */
    5102                 :            : 
    5103                 :            : static bool
    5104                 :       5345 : handle_omp_array_sections (tree c, enum c_omp_region_type ort)
    5105                 :            : {
    5106                 :       5345 :   bool maybe_zero_len = false;
    5107                 :       5345 :   unsigned int first_non_one = 0;
    5108                 :       5345 :   auto_vec<tree, 10> types;
    5109                 :       5345 :   tree *tp = &OMP_CLAUSE_DECL (c);
    5110                 :       5345 :   if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
    5111                 :        916 :       && TREE_CODE (*tp) == TREE_LIST
    5112                 :        916 :       && TREE_PURPOSE (*tp)
    5113                 :       6101 :       && TREE_CODE (TREE_PURPOSE (*tp)) == TREE_VEC)
    5114                 :        184 :     tp = &TREE_VALUE (*tp);
    5115                 :       5345 :   tree first = handle_omp_array_sections_1 (c, *tp, types,
    5116                 :            :                                             maybe_zero_len, first_non_one,
    5117                 :            :                                             ort);
    5118                 :       5345 :   if (first == error_mark_node)
    5119                 :            :     return true;
    5120                 :       4785 :   if (first == NULL_TREE)
    5121                 :            :     return false;
    5122                 :       4389 :   if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND)
    5123                 :            :     {
    5124                 :        572 :       tree t = *tp;
    5125                 :        572 :       tree tem = NULL_TREE;
    5126                 :        572 :       if (processing_template_decl)
    5127                 :            :         return false;
    5128                 :            :       /* Need to evaluate side effects in the length expressions
    5129                 :            :          if any.  */
    5130                 :        988 :       while (TREE_CODE (t) == TREE_LIST)
    5131                 :            :         {
    5132                 :        548 :           if (TREE_VALUE (t) && TREE_SIDE_EFFECTS (TREE_VALUE (t)))
    5133                 :            :             {
    5134                 :         16 :               if (tem == NULL_TREE)
    5135                 :        548 :                 tem = TREE_VALUE (t);
    5136                 :            :               else
    5137                 :          4 :                 tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem),
    5138                 :          4 :                               TREE_VALUE (t), tem);
    5139                 :            :             }
    5140                 :        548 :           t = TREE_CHAIN (t);
    5141                 :            :         }
    5142                 :        440 :       if (tem)
    5143                 :         12 :         first = build2 (COMPOUND_EXPR, TREE_TYPE (first), tem, first);
    5144                 :        440 :       *tp = first;
    5145                 :            :     }
    5146                 :            :   else
    5147                 :            :     {
    5148                 :       3817 :       unsigned int num = types.length (), i;
    5149                 :       3817 :       tree t, side_effects = NULL_TREE, size = NULL_TREE;
    5150                 :       3817 :       tree condition = NULL_TREE;
    5151                 :            : 
    5152                 :       3817 :       if (int_size_in_bytes (TREE_TYPE (first)) <= 0)
    5153                 :          0 :         maybe_zero_len = true;
    5154                 :       3817 :       if (processing_template_decl && maybe_zero_len)
    5155                 :            :         return false;
    5156                 :            : 
    5157                 :      12196 :       for (i = num, t = OMP_CLAUSE_DECL (c); i > 0;
    5158                 :       4195 :            t = TREE_CHAIN (t))
    5159                 :            :         {
    5160                 :       4215 :           tree low_bound = TREE_PURPOSE (t);
    5161                 :       4215 :           tree length = TREE_VALUE (t);
    5162                 :            : 
    5163                 :       4215 :           i--;
    5164                 :       4215 :           if (low_bound
    5165                 :       3719 :               && TREE_CODE (low_bound) == INTEGER_CST
    5166                 :       5767 :               && TYPE_PRECISION (TREE_TYPE (low_bound))
    5167                 :       1552 :                  > TYPE_PRECISION (sizetype))
    5168                 :          0 :             low_bound = fold_convert (sizetype, low_bound);
    5169                 :       4215 :           if (length
    5170                 :       3959 :               && TREE_CODE (length) == INTEGER_CST
    5171                 :       5922 :               && TYPE_PRECISION (TREE_TYPE (length))
    5172                 :       1707 :                  > TYPE_PRECISION (sizetype))
    5173                 :          0 :             length = fold_convert (sizetype, length);
    5174                 :       4215 :           if (low_bound == NULL_TREE)
    5175                 :        496 :             low_bound = integer_zero_node;
    5176                 :       4215 :           if (!maybe_zero_len && i > first_non_one)
    5177                 :            :             {
    5178                 :        339 :               if (integer_nonzerop (low_bound))
    5179                 :          8 :                 goto do_warn_noncontiguous;
    5180                 :        331 :               if (length != NULL_TREE
    5181                 :        118 :                   && TREE_CODE (length) == INTEGER_CST
    5182                 :        118 :                   && TYPE_DOMAIN (types[i])
    5183                 :        118 :                   && TYPE_MAX_VALUE (TYPE_DOMAIN (types[i]))
    5184                 :        449 :                   && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])))
    5185                 :            :                      == INTEGER_CST)
    5186                 :            :                 {
    5187                 :        118 :                   tree size;
    5188                 :        118 :                   size = size_binop (PLUS_EXPR,
    5189                 :            :                                      TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])),
    5190                 :            :                                      size_one_node);
    5191                 :        118 :                   if (!tree_int_cst_equal (length, size))
    5192                 :            :                     {
    5193                 :         12 :                      do_warn_noncontiguous:
    5194                 :         20 :                       error_at (OMP_CLAUSE_LOCATION (c),
    5195                 :            :                                 "array section is not contiguous in %qs "
    5196                 :            :                                 "clause",
    5197                 :         20 :                                 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    5198                 :         20 :                       return true;
    5199                 :            :                     }
    5200                 :            :                 }
    5201                 :        319 :               if (!processing_template_decl
    5202                 :        248 :                   && length != NULL_TREE
    5203                 :        407 :                   && TREE_SIDE_EFFECTS (length))
    5204                 :            :                 {
    5205                 :          0 :                   if (side_effects == NULL_TREE)
    5206                 :            :                     side_effects = length;
    5207                 :            :                   else
    5208                 :          0 :                     side_effects = build2 (COMPOUND_EXPR,
    5209                 :          0 :                                            TREE_TYPE (side_effects),
    5210                 :            :                                            length, side_effects);
    5211                 :            :                 }
    5212                 :            :             }
    5213                 :       3876 :           else if (processing_template_decl)
    5214                 :        276 :             continue;
    5215                 :            :           else
    5216                 :            :             {
    5217                 :       3600 :               tree l;
    5218                 :            : 
    5219                 :       3600 :               if (i > first_non_one
    5220                 :       3600 :                   && ((length && integer_nonzerop (length))
    5221                 :          0 :                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
    5222                 :          0 :                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
    5223                 :          0 :                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION))
    5224                 :          0 :                 continue;
    5225                 :       3600 :               if (length)
    5226                 :       3566 :                 l = fold_convert (sizetype, length);
    5227                 :            :               else
    5228                 :            :                 {
    5229                 :         34 :                   l = size_binop (PLUS_EXPR,
    5230                 :            :                                   TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])),
    5231                 :            :                                   size_one_node);
    5232                 :         34 :                   l = size_binop (MINUS_EXPR, l,
    5233                 :            :                                   fold_convert (sizetype, low_bound));
    5234                 :            :                 }
    5235                 :       3600 :               if (i > first_non_one)
    5236                 :            :                 {
    5237                 :          0 :                   l = fold_build2 (NE_EXPR, boolean_type_node, l,
    5238                 :            :                                    size_zero_node);
    5239                 :          0 :                   if (condition == NULL_TREE)
    5240                 :            :                     condition = l;
    5241                 :            :                   else
    5242                 :          0 :                     condition = fold_build2 (BIT_AND_EXPR, boolean_type_node,
    5243                 :            :                                              l, condition);
    5244                 :            :                 }
    5245                 :       3600 :               else if (size == NULL_TREE)
    5246                 :            :                 {
    5247                 :       3510 :                   size = size_in_bytes (TREE_TYPE (types[i]));
    5248                 :       3510 :                   tree eltype = TREE_TYPE (types[num - 1]);
    5249                 :       3563 :                   while (TREE_CODE (eltype) == ARRAY_TYPE)
    5250                 :         53 :                     eltype = TREE_TYPE (eltype);
    5251                 :       3510 :                   if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
    5252                 :       3182 :                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
    5253                 :       6013 :                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION)
    5254                 :       1080 :                     size = size_binop (EXACT_DIV_EXPR, size,
    5255                 :            :                                        size_in_bytes (eltype));
    5256                 :       3510 :                   size = size_binop (MULT_EXPR, size, l);
    5257                 :       3510 :                   if (condition)
    5258                 :          0 :                     size = fold_build3 (COND_EXPR, sizetype, condition,
    5259                 :            :                                         size, size_zero_node);
    5260                 :            :                 }
    5261                 :            :               else
    5262                 :         90 :                 size = size_binop (MULT_EXPR, size, l);
    5263                 :            :             }
    5264                 :            :         }
    5265                 :       3786 :       if (!processing_template_decl)
    5266                 :            :         {
    5267                 :       3510 :           if (side_effects)
    5268                 :          0 :             size = build2 (COMPOUND_EXPR, sizetype, side_effects, size);
    5269                 :       3510 :           if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
    5270                 :       3182 :               || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION
    5271                 :       6013 :               || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TASK_REDUCTION)
    5272                 :            :             {
    5273                 :       1080 :               size = size_binop (MINUS_EXPR, size, size_one_node);
    5274                 :       1080 :               size = save_expr (size);
    5275                 :       1080 :               tree index_type = build_index_type (size);
    5276                 :       1080 :               tree eltype = TREE_TYPE (first);
    5277                 :       1117 :               while (TREE_CODE (eltype) == ARRAY_TYPE)
    5278                 :         37 :                 eltype = TREE_TYPE (eltype);
    5279                 :       1080 :               tree type = build_array_type (eltype, index_type);
    5280                 :       1080 :               tree ptype = build_pointer_type (eltype);
    5281                 :       1080 :               if (TYPE_REF_P (TREE_TYPE (t))
    5282                 :       1080 :                   && INDIRECT_TYPE_P (TREE_TYPE (TREE_TYPE (t))))
    5283                 :         98 :                 t = convert_from_reference (t);
    5284                 :        982 :               else if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
    5285                 :        416 :                 t = build_fold_addr_expr (t);
    5286                 :       1080 :               tree t2 = build_fold_addr_expr (first);
    5287                 :       1080 :               t2 = fold_convert_loc (OMP_CLAUSE_LOCATION (c),
    5288                 :            :                                      ptrdiff_type_node, t2);
    5289                 :       2160 :               t2 = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MINUS_EXPR,
    5290                 :            :                                     ptrdiff_type_node, t2,
    5291                 :       1080 :                                     fold_convert_loc (OMP_CLAUSE_LOCATION (c),
    5292                 :            :                                                       ptrdiff_type_node, t));
    5293                 :       1080 :               if (tree_fits_shwi_p (t2))
    5294                 :        735 :                 t = build2 (MEM_REF, type, t,
    5295                 :        735 :                             build_int_cst (ptype, tree_to_shwi (t2)));
    5296                 :            :               else
    5297                 :            :                 {
    5298                 :        345 :                   t2 = fold_convert_loc (OMP_CLAUSE_LOCATION (c),
    5299                 :            :                                          sizetype, t2);
    5300                 :        690 :                   t = build2_loc (OMP_CLAUSE_LOCATION (c), POINTER_PLUS_EXPR,
    5301                 :        345 :                                   TREE_TYPE (t), t, t2);
    5302                 :        345 :                   t = build2 (MEM_REF, type, t, build_int_cst (ptype, 0));
    5303                 :            :                 }
    5304                 :       1080 :               OMP_CLAUSE_DECL (c) = t;
    5305                 :       1080 :               return false;
    5306                 :            :             }
    5307                 :       2430 :           OMP_CLAUSE_DECL (c) = first;
    5308                 :       2430 :           OMP_CLAUSE_SIZE (c) = size;
    5309                 :       2430 :           if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP
    5310                 :       2430 :               || (TREE_CODE (t) == COMPONENT_REF
    5311                 :        221 :                   && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE))
    5312                 :            :             return false;
    5313                 :       2137 :           if (ort == C_ORT_OMP || ort == C_ORT_ACC)
    5314                 :       2137 :             switch (OMP_CLAUSE_MAP_KIND (c))
    5315                 :            :               {
    5316                 :       2105 :               case GOMP_MAP_ALLOC:
    5317                 :       2105 :               case GOMP_MAP_IF_PRESENT:
    5318                 :       2105 :               case GOMP_MAP_TO:
    5319                 :       2105 :               case GOMP_MAP_FROM:
    5320                 :       2105 :               case GOMP_MAP_TOFROM:
    5321                 :       2105 :               case GOMP_MAP_ALWAYS_TO:
    5322                 :       2105 :               case GOMP_MAP_ALWAYS_FROM:
    5323                 :       2105 :               case GOMP_MAP_ALWAYS_TOFROM:
    5324                 :       2105 :               case GOMP_MAP_RELEASE:
    5325                 :       2105 :               case GOMP_MAP_DELETE:
    5326                 :       2105 :               case GOMP_MAP_FORCE_TO:
    5327                 :       2105 :               case GOMP_MAP_FORCE_FROM:
    5328                 :       2105 :               case GOMP_MAP_FORCE_TOFROM:
    5329                 :       2105 :               case GOMP_MAP_FORCE_PRESENT:
    5330                 :       2105 :                 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (c) = 1;
    5331                 :       2105 :                 break;
    5332                 :            :               default:
    5333                 :            :                 break;
    5334                 :            :               }
    5335                 :       2137 :           tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
    5336                 :            :                                       OMP_CLAUSE_MAP);
    5337                 :       2137 :           if ((ort & C_ORT_OMP_DECLARE_SIMD) != C_ORT_OMP && ort != C_ORT_ACC)
    5338                 :          0 :             OMP_CLAUSE_SET_MAP_KIND (c2, GOMP_MAP_POINTER);
    5339                 :       2137 :           else if (TREE_CODE (t) == COMPONENT_REF)
    5340                 :            :             {
    5341                 :        158 :               gomp_map_kind k = (ort == C_ORT_ACC) ? GOMP_MAP_ATTACH_DETACH
    5342                 :            :                                                    : GOMP_MAP_ALWAYS_POINTER;
    5343                 :        158 :               OMP_CLAUSE_SET_MAP_KIND (c2, k);
    5344                 :            :             }
    5345                 :         26 :           else if (REFERENCE_REF_P (t)
    5346                 :       2005 :                    && TREE_CODE (TREE_OPERAND (t, 0)) == COMPONENT_REF)
    5347                 :            :             {
    5348                 :         26 :               t = TREE_OPERAND (t, 0);
    5349                 :         26 :               gomp_map_kind k = (ort == C_ORT_ACC) ? GOMP_MAP_ATTACH_DETACH
    5350                 :            :                                                    : GOMP_MAP_ALWAYS_POINTER;
    5351                 :         26 :               OMP_CLAUSE_SET_MAP_KIND (c2, k);
    5352                 :            :             }
    5353                 :            :           else
    5354                 :       1953 :             OMP_CLAUSE_SET_MAP_KIND (c2, GOMP_MAP_FIRSTPRIVATE_POINTER);
    5355                 :       2137 :           if (OMP_CLAUSE_MAP_KIND (c2) != GOMP_MAP_FIRSTPRIVATE_POINTER
    5356                 :       2137 :               && !cxx_mark_addressable (t))
    5357                 :            :             return false;
    5358                 :       2137 :           OMP_CLAUSE_DECL (c2) = t;
    5359                 :       2137 :           t = build_fold_addr_expr (first);
    5360                 :       2137 :           t = fold_convert_loc (OMP_CLAUSE_LOCATION (c),
    5361                 :            :                                 ptrdiff_type_node, t);
    5362                 :       2137 :           tree ptr = OMP_CLAUSE_DECL (c2);
    5363                 :       2137 :           ptr = convert_from_reference (ptr);
    5364                 :       2137 :           if (!INDIRECT_TYPE_P (TREE_TYPE (ptr)))
    5365                 :        499 :             ptr = build_fold_addr_expr (ptr);
    5366                 :       4274 :           t = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MINUS_EXPR,
    5367                 :            :                                ptrdiff_type_node, t,
    5368                 :       2137 :                                fold_convert_loc (OMP_CLAUSE_LOCATION (c),
    5369                 :            :                                                  ptrdiff_type_node, ptr));
    5370                 :       2137 :           OMP_CLAUSE_SIZE (c2) = t;
    5371                 :       2137 :           OMP_CLAUSE_CHAIN (c2) = OMP_CLAUSE_CHAIN (c);
    5372                 :       2137 :           OMP_CLAUSE_CHAIN (c) = c2;
    5373                 :       2137 :           ptr = OMP_CLAUSE_DECL (c2);
    5374                 :       2137 :           if (OMP_CLAUSE_MAP_KIND (c2) != GOMP_MAP_FIRSTPRIVATE_POINTER
    5375                 :        184 :               && TYPE_REF_P (TREE_TYPE (ptr))
    5376                 :       2203 :               && INDIRECT_TYPE_P (TREE_TYPE (TREE_TYPE (ptr))))
    5377                 :            :             {
    5378                 :         31 :               tree c3 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
    5379                 :            :                                           OMP_CLAUSE_MAP);
    5380                 :         31 :               OMP_CLAUSE_SET_MAP_KIND (c3, OMP_CLAUSE_MAP_KIND (c2));
    5381                 :         31 :               OMP_CLAUSE_DECL (c3) = ptr;
    5382                 :         31 :               if (OMP_CLAUSE_MAP_KIND (c2) == GOMP_MAP_ALWAYS_POINTER)
    5383                 :         31 :                 OMP_CLAUSE_DECL (c2) = build_simple_mem_ref (ptr);
    5384                 :            :               else
    5385                 :          0 :                 OMP_CLAUSE_DECL (c2) = convert_from_reference (ptr);
    5386                 :         31 :               OMP_CLAUSE_SIZE (c3) = size_zero_node;
    5387                 :         31 :               OMP_CLAUSE_CHAIN (c3) = OMP_CLAUSE_CHAIN (c2);
    5388                 :         31 :               OMP_CLAUSE_CHAIN (c2) = c3;
    5389                 :            :             }
    5390                 :            :         }
    5391                 :            :     }
    5392                 :            :   return false;
    5393                 :            : }
    5394                 :            : 
    5395                 :            : /* Return identifier to look up for omp declare reduction.  */
    5396                 :            : 
    5397                 :            : tree
    5398                 :       7656 : omp_reduction_id (enum tree_code reduction_code, tree reduction_id, tree type)
    5399                 :            : {
    5400                 :       7656 :   const char *p = NULL;
    5401                 :       7656 :   const char *m = NULL;
    5402                 :       7656 :   switch (reduction_code)
    5403                 :            :     {
    5404                 :       4455 :     case PLUS_EXPR:
    5405                 :       4455 :     case MULT_EXPR:
    5406                 :       4455 :     case MINUS_EXPR:
    5407                 :       4455 :     case BIT_AND_EXPR:
    5408                 :       4455 :     case BIT_XOR_EXPR:
    5409                 :       4455 :     case BIT_IOR_EXPR:
    5410                 :       4455 :     case TRUTH_ANDIF_EXPR:
    5411                 :       4455 :     case TRUTH_ORIF_EXPR:
    5412                 :       4455 :       reduction_id = ovl_op_identifier (false, reduction_code);
    5413                 :       4455 :       break;
    5414                 :            :     case MIN_EXPR:
    5415                 :            :       p = "min";
    5416                 :            :       break;
    5417                 :         83 :     case MAX_EXPR:
    5418                 :         83 :       p = "max";
    5419                 :         83 :       break;
    5420                 :            :     default:
    5421                 :            :       break;
    5422                 :            :     }
    5423                 :            : 
    5424                 :       4455 :   if (p == NULL)
    5425                 :            :     {
    5426                 :       7516 :       if (TREE_CODE (reduction_id) != IDENTIFIER_NODE)
    5427                 :          0 :         return error_mark_node;
    5428                 :       7516 :       p = IDENTIFIER_POINTER (reduction_id);
    5429                 :            :     }
    5430                 :            : 
    5431                 :       7656 :   if (type != NULL_TREE)
    5432                 :       2211 :     m = mangle_type_string (TYPE_MAIN_VARIANT (type));
    5433                 :            : 
    5434                 :       7656 :   const char prefix[] = "omp declare reduction ";
    5435                 :       7656 :   size_t lenp = sizeof (prefix);
    5436                 :       7656 :   if (strncmp (p, prefix, lenp - 1) == 0)
    5437                 :       2211 :     lenp = 1;
    5438                 :       7656 :   size_t len = strlen (p);
    5439                 :       7656 :   size_t lenm = m ? strlen (m) + 1 : 0;
    5440                 :       7656 :   char *name = XALLOCAVEC (char, lenp + len + lenm);
    5441                 :       7656 :   if (lenp > 1)
    5442                 :       5445 :     memcpy (name, prefix, lenp - 1);
    5443                 :       7656 :   memcpy (name + lenp - 1, p, len + 1);
    5444                 :       7656 :   if (m)
    5445                 :            :     {
    5446                 :       2211 :       name[lenp + len - 1] = '~';
    5447                 :       2211 :       memcpy (name + lenp + len, m, lenm);
    5448                 :            :     }
    5449                 :       7656 :   return get_identifier (name);
    5450                 :            : }
    5451                 :            : 
    5452                 :            : /* Lookup OpenMP UDR ID for TYPE, return the corresponding artificial
    5453                 :            :    FUNCTION_DECL or NULL_TREE if not found.  */
    5454                 :            : 
    5455                 :            : static tree
    5456                 :       1306 : omp_reduction_lookup (location_t loc, tree id, tree type, tree *baselinkp,
    5457                 :            :                       vec<tree> *ambiguousp)
    5458                 :            : {
    5459                 :       1306 :   tree orig_id = id;
    5460                 :       1306 :   tree baselink = NULL_TREE;
    5461                 :       1306 :   if (identifier_p (id))
    5462                 :            :     {
    5463                 :       1272 :       cp_id_kind idk;
    5464                 :       1272 :       bool nonint_cst_expression_p;
    5465                 :       1272 :       const char *error_msg;
    5466                 :       1272 :       id = omp_reduction_id (ERROR_MARK, id, type);
    5467                 :       1272 :       tree decl = lookup_name (id);
    5468                 :       1272 :       if (decl == NULL_TREE)
    5469                 :         96 :         decl = error_mark_node;
    5470                 :       2544 :       id = finish_id_expression (id, decl, NULL_TREE, &idk, false, true,
    5471                 :            :                                  &nonint_cst_expression_p, false, true, false,
    5472                 :       1272 :                                  false, &error_msg, loc);
    5473                 :       1272 :       if (idk == CP_ID_KIND_UNQUALIFIED
    5474                 :       1368 :           && identifier_p (id))
    5475                 :            :         {
    5476                 :         96 :           vec<tree, va_gc> *args = NULL;
    5477                 :         96 :           vec_safe_push (args, build_reference_type (type));
    5478                 :         96 :           id = perform_koenig_lookup (id, args, tf_none);
    5479                 :            :         }
    5480                 :            :     }
    5481                 :         34 :   else if (TREE_CODE (id) == SCOPE_REF)
    5482                 :         34 :     id = lookup_qualified_name (TREE_OPERAND (id, 0),
    5483                 :            :                                 omp_reduction_id (ERROR_MARK,
    5484                 :         34 :                                                   TREE_OPERAND (id, 1),
    5485                 :            :                                                   type),
    5486                 :            :                                 false, false);
    5487                 :       1306 :   tree fns = id;
    5488                 :       1306 :   id = NULL_TREE;
    5489                 :       1306 :   if (fns && is_overloaded_fn (fns))
    5490                 :            :     {
    5491                 :       2432 :       for (lkp_iterator iter (get_fns (fns)); iter; ++iter)
    5492                 :            :         {
    5493                 :       1216 :           tree fndecl = *iter;
    5494                 :       1216 :           if (TREE_CODE (fndecl) == FUNCTION_DECL)
    5495                 :            :             {
    5496                 :       1216 :               tree argtype = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)));
    5497                 :       1216 :               if (same_type_p (TREE_TYPE (argtype), type))
    5498                 :            :                 {
    5499                 :       1216 :                   id = fndecl;
    5500                 :       1216 :                   break;
    5501                 :            :                 }
    5502                 :            :             }
    5503                 :            :         }
    5504                 :            : 
    5505                 :       1216 :       if (id && BASELINK_P (fns))
    5506                 :            :         {
    5507                 :        110 :           if (baselinkp)
    5508                 :          0 :             *baselinkp = fns;
    5509                 :            :           else
    5510                 :        110 :             baselink = fns;
    5511                 :            :         }
    5512                 :            :     }
    5513                 :            : 
    5514                 :       1344 :   if (!id && CLASS_TYPE_P (type) && TYPE_BINFO (type))
    5515                 :            :     {
    5516                 :         38 :       vec<tree> ambiguous = vNULL;
    5517                 :         38 :       tree binfo = TYPE_BINFO (type), base_binfo, ret = NULL_TREE;
    5518                 :         38 :       unsigned int ix;
    5519                 :         38 :       if (ambiguousp == NULL)
    5520                 :         20 :         ambiguousp = &ambiguous;
    5521                 :         84 :       for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
    5522                 :            :         {
    5523                 :         62 :           id = omp_reduction_lookup (loc, orig_id, BINFO_TYPE (base_binfo),
    5524                 :            :                                      baselinkp ? baselinkp : &baselink,
    5525                 :            :                                      ambiguousp);
    5526                 :         46 :           if (id == NULL_TREE)
    5527                 :         16 :             continue;
    5528                 :         30 :           if (!ambiguousp->is_empty ())
    5529                 :          4 :             ambiguousp->safe_push (id);
    5530                 :         26 :           else if (ret != NULL_TREE)
    5531                 :            :             {
    5532                 :          8 :               ambiguousp->safe_push (ret);
    5533                 :          8 :               ambiguousp->safe_push (id);
    5534                 :          8 :               ret = NULL_TREE;
    5535                 :            :             }
    5536                 :            :           else
    5537                 :         18 :             ret = id;
    5538                 :            :         }
    5539                 :         38 :       if (ambiguousp != &ambiguous)
    5540                 :         18 :         return ret;
    5541                 :         20 :       if (!ambiguous.is_empty ())
    5542                 :            :         {
    5543                 :          8 :           const char *str = _("candidates are:");
    5544                 :          8 :           unsigned int idx;
    5545                 :          8 :           tree udr;
    5546                 :          8 :           error_at (loc, "user defined reduction lookup is ambiguous");
    5547                 :         28 :           FOR_EACH_VEC_ELT (ambiguous, idx, udr)
    5548                 :            :             {
    5549                 :         20 :               inform (DECL_SOURCE_LOCATION (udr), "%s %#qD", str, udr);
    5550                 :         20 :               if (idx == 0)
    5551                 :          8 :                 str = get_spaces (str);
    5552                 :            :             }
    5553                 :          8 :           ambiguous.release ();
    5554                 :          8 :           ret = error_mark_node;
    5555                 :          8 :           baselink = NULL_TREE;
    5556                 :            :         }
    5557                 :         20 :       id = ret;
    5558                 :            :     }
    5559                 :       1288 :   if (id && baselink)
    5560                 :        110 :     perform_or_defer_access_check (BASELINK_BINFO (baselink),
    5561                 :            :                                    id, id, tf_warning_or_error);
    5562                 :       1288 :   return id;
    5563                 :            : }
    5564                 :            : 
    5565                 :            : /* Helper function for cp_parser_omp_declare_reduction_exprs
    5566                 :            :    and tsubst_omp_udr.
    5567                 :            :    Remove CLEANUP_STMT for data (omp_priv variable).
    5568                 :            :    Also append INIT_EXPR for DECL_INITIAL of omp_priv after its
    5569                 :            :    DECL_EXPR.  */
    5570                 :            : 
    5571                 :            : tree
    5572                 :       4130 : cp_remove_omp_priv_cleanup_stmt (tree *tp, int *walk_subtrees, void *data)
    5573                 :            : {
    5574                 :       4130 :   if (TYPE_P (*tp))
    5575                 :         20 :     *walk_subtrees = 0;
    5576                 :       4110 :   else if (TREE_CODE (*tp) == CLEANUP_STMT && CLEANUP_DECL (*tp) == (tree) data)
    5577                 :         48 :     *tp = CLEANUP_BODY (*tp);
    5578                 :       4062 :   else if (TREE_CODE (*tp) == DECL_EXPR)
    5579                 :            :     {
    5580                 :        279 :       tree decl = DECL_EXPR_DECL (*tp);
    5581                 :        279 :       if (!processing_template_decl
    5582                 :        223 :           && decl == (tree) data
    5583                 :        223 :           && DECL_INITIAL (decl)
    5584                 :        348 :           && DECL_INITIAL (decl) != error_mark_node)
    5585                 :            :         {
    5586                 :         69 :           tree list = NULL_TREE;
    5587                 :         69 :           append_to_statement_list_force (*tp, &list);
    5588                 :         69 :           tree init_expr = build2 (INIT_EXPR, void_type_node,
    5589                 :         69 :                                    decl, DECL_INITIAL (decl));
    5590                 :         69 :           DECL_INITIAL (decl) = NULL_TREE;
    5591                 :         69 :           append_to_statement_list_force (init_expr, &list);
    5592                 :         69 :           *tp = list;
    5593                 :            :         }
    5594                 :            :     }
    5595                 :       4130 :   return NULL_TREE;
    5596                 :            : }
    5597                 :            : 
    5598                 :            : /* Data passed from cp_check_omp_declare_reduction to
    5599                 :            :    cp_check_omp_declare_reduction_r.  */
    5600                 :            : 
    5601                 :            : struct cp_check_omp_declare_reduction_data
    5602                 :            : {
    5603                 :            :   location_t loc;
    5604                 :            :   tree stmts[7];
    5605                 :            :   bool combiner_p;
    5606                 :            : };
    5607                 :            : 
    5608                 :            : /* Helper function for cp_check_omp_declare_reduction, called via
    5609                 :            :    cp_walk_tree.  */
    5610                 :            : 
    5611                 :            : static tree
    5612                 :      16356 : cp_check_omp_declare_reduction_r (tree *tp, int *, void *data)
    5613                 :            : {
    5614                 :      16356 :   struct cp_check_omp_declare_reduction_data *udr_data
    5615                 :            :     = (struct cp_check_omp_declare_reduction_data *) data;
    5616                 :      13301 :   if (SSA_VAR_P (*tp)
    5617                 :       3055 :       && !DECL_ARTIFICIAL (*tp)
    5618                 :        300 :       && *tp != DECL_EXPR_DECL (udr_data->stmts[udr_data->combiner_p ? 0 : 3])
    5619                 :      16656 :       && *tp != DECL_EXPR_DECL (udr_data->stmts[udr_data->combiner_p ? 1 : 4]))
    5620                 :            :     {
    5621                 :        180 :       location_t loc = udr_data->loc;
    5622                 :        180 :       if (udr_data->combiner_p)
    5623                 :         60 :         error_at (loc, "%<#pragma omp declare reduction%> combiner refers to "
    5624                 :            :                        "variable %qD which is not %<omp_out%> nor %<omp_in%>",
    5625                 :            :                   *tp);
    5626                 :            :       else
    5627                 :        120 :         error_at (loc, "%<#pragma omp declare reduction%> initializer refers "
    5628                 :            :                        "to variable %qD which is not %<omp_priv%> nor "
    5629                 :            :                        "%<omp_orig%>",
    5630                 :            :                   *tp);
    5631                 :        180 :       return *tp;
    5632                 :            :     }
    5633                 :            :   return NULL_TREE;
    5634                 :            : }
    5635                 :            : 
    5636                 :            : /* Diagnose violation of OpenMP #pragma omp declare reduction restrictions.  */
    5637                 :            : 
    5638                 :            : void
    5639                 :       1257 : cp_check_omp_declare_reduction (tree udr)
    5640                 :            : {
    5641                 :       1257 :   tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (udr)));
    5642                 :       1257 :   gcc_assert (TYPE_REF_P (type));
    5643                 :       1257 :   type = TREE_TYPE (type);
    5644                 :       1257 :   int i;
    5645                 :       1257 :   location_t loc = DECL_SOURCE_LOCATION (udr);
    5646                 :            : 
    5647                 :       1257 :   if (type == error_mark_node)
    5648                 :        338 :     return;
    5649                 :       1257 :   if (ARITHMETIC_TYPE_P (type))
    5650                 :            :     {
    5651                 :            :       static enum tree_code predef_codes[]
    5652                 :            :         = { PLUS_EXPR, MULT_EXPR, MINUS_EXPR, BIT_AND_EXPR, BIT_XOR_EXPR,
    5653                 :            :             BIT_IOR_EXPR, TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR };
    5654                 :       3555 :       for (i = 0; i < 8; i++)
    5655                 :            :         {
    5656                 :       3168 :           tree id = omp_reduction_id (predef_codes[i], NULL_TREE, NULL_TREE);
    5657                 :       3168 :           const char *n1 = IDENTIFIER_POINTER (DECL_NAME (udr));
    5658                 :       3168 :           const char *n2 = IDENTIFIER_POINTER (id);
    5659                 :       3168 :           if (strncmp (n1, n2, IDENTIFIER_LENGTH (id)) == 0
    5660                 :       3168 :               && (n1[IDENTIFIER_LENGTH (id)] == '~'
    5661                 :          0 :                   || n1[IDENTIFIER_LENGTH (id)] == '\0'))
    5662                 :            :             break;
    5663                 :            :         }
    5664                 :            : 
    5665                 :        411 :       if (i == 8
    5666                 :        387 :           && TREE_CODE (type) != COMPLEX_EXPR)
    5667                 :            :         {
    5668                 :        387 :           const char prefix_minmax[] = "omp declare reduction m";
    5669                 :        387 :           size_t prefix_size = sizeof (prefix_minmax) - 1;
    5670                 :        387 :           const char *n = IDENTIFIER_POINTER (DECL_NAME (udr));
    5671                 :        387 :           if (strncmp (IDENTIFIER_POINTER (DECL_NAME (udr)),
    5672                 :            :                        prefix_minmax, prefix_size) == 0
    5673                 :         12 :               && ((n[prefix_size] == 'i' && n[prefix_size + 1] == 'n')
    5674                 :          4 :                   || (n[prefix_size] == 'a' && n[prefix_size + 1] == 'x'))
    5675                 :        399 :               && (n[prefix_size + 2] == '~' || n[prefix_size + 2] == '\0'))
    5676                 :          8 :             i = 0;
    5677                 :            :         }
    5678                 :        411 :       if (i < 8)
    5679                 :            :         {
    5680                 :         32 :           error_at (loc, "predeclared arithmetic type %qT in "
    5681                 :            :                          "%<#pragma omp declare reduction%>", type);
    5682                 :         32 :           return;
    5683                 :            :         }
    5684                 :            :     }
    5685                 :        846 :   else if (FUNC_OR_METHOD_TYPE_P (type)
    5686                 :        830 :            || TREE_CODE (type) == ARRAY_TYPE)
    5687                 :            :     {
    5688                 :         32 :       error_at (loc, "function or array type %qT in "
    5689                 :            :                      "%<#pragma omp declare reduction%>", type);
    5690                 :         32 :       return;
    5691                 :            :     }
    5692                 :        814 :   else if (TYPE_REF_P (type))
    5693                 :            :     {
    5694                 :          0 :       error_at (loc, "reference type %qT in %<#pragma omp declare reduction%>",
    5695                 :            :                 type);
    5696                 :          0 :       return;
    5697                 :            :     }
    5698                 :        814 :   else if (TYPE_QUALS_NO_ADDR_SPACE (type))
    5699                 :            :     {
    5700                 :         32 :       error_at (loc, "%<const%>, %<volatile%> or %<__restrict%>-qualified "
    5701                 :            :                 "type %qT in %<#pragma omp declare reduction%>", type);
    5702                 :         32 :       return;
    5703                 :            :     }
    5704                 :            : 
    5705                 :       1161 :   tree body = DECL_SAVED_TREE (udr);
    5706                 :       1161 :   if (body == NULL_TREE || TREE_CODE (body) != STATEMENT_LIST)
    5707                 :            :     return;
    5708                 :            : 
    5709                 :        919 :   tree_stmt_iterator tsi;
    5710                 :        919 :   struct cp_check_omp_declare_reduction_data data;
    5711                 :        919 :   memset (data.stmts, 0, sizeof data.stmts);
    5712                 :        919 :   for (i = 0, tsi = tsi_start (body);
    5713                 :       4970 :        i < 7 && !tsi_end_p (tsi);
    5714                 :       4051 :        i++, tsi_next (&tsi))
    5715                 :       4051 :     data.stmts[i] = tsi_stmt (tsi);
    5716                 :        919 :   data.loc = loc;
    5717                 :        919 :   gcc_assert (tsi_end_p (tsi));
    5718                 :        919 :   if (i >= 3)
    5719                 :            :     {
    5720                 :        919 :       gcc_assert (TREE_CODE (data.stmts[0]) == DECL_EXPR
    5721                 :            :                   && TREE_CODE (data.stmts[1]) == DECL_EXPR);
    5722                 :        919 :       if (TREE_NO_WARNING (DECL_EXPR_DECL (data.stmts[0])))
    5723                 :            :         return;
    5724                 :        919 :       data.combiner_p = true;
    5725                 :        919 :       if (cp_walk_tree (&data.stmts[2], cp_check_omp_declare_reduction_r,
    5726                 :            :                         &data, NULL))
    5727                 :         60 :         TREE_NO_WARNING (DECL_EXPR_DECL (data.stmts[0])) = 1;
    5728                 :            :     }
    5729                 :        919 :   if (i >= 6)
    5730                 :            :     {
    5731                 :        362 :       gcc_assert (TREE_CODE (data.stmts[3]) == DECL_EXPR
    5732                 :            :                   && TREE_CODE (data.stmts[4]) == DECL_EXPR);
    5733                 :        362 :       data.combiner_p = false;
    5734                 :        362 :       if (cp_walk_tree (&data.stmts[5], cp_check_omp_declare_reduction_r,
    5735                 :            :                         &data, NULL)
    5736                 :        362 :           || cp_walk_tree (&DECL_INITIAL (DECL_EXPR_DECL (data.stmts[3])),
    5737                 :            :                            cp_check_omp_declare_reduction_r, &data, NULL))
    5738                 :        120 :         TREE_NO_WARNING (DECL_EXPR_DECL (data.stmts[0])) = 1;
    5739                 :        362 :       if (i == 7)
    5740                 :        208 :         gcc_assert (TREE_CODE (data.stmts[6]) == DECL_EXPR);
    5741                 :            :     }
    5742                 :            : }
    5743                 :            : 
    5744                 :            : /* Helper function of finish_omp_clauses.  Clone STMT as if we were making
    5745                 :            :    an inline call.  But, remap
    5746                 :            :    the OMP_DECL1 VAR_DECL (omp_out resp. omp_orig) to PLACEHOLDER
    5747                 :            :    and OMP_DECL2 VAR_DECL (omp_in resp. omp_priv) to DECL.  */
    5748                 :            : 
    5749                 :            : static tree
    5750                 :       2160 : clone_omp_udr (tree stmt, tree omp_decl1, tree omp_decl2,
    5751                 :            :                tree decl, tree placeholder)
    5752                 :            : {
    5753                 :       2160 :   copy_body_data id;
    5754                 :       2160 :   hash_map<tree, tree> decl_map;
    5755                 :            : 
    5756                 :       2160 :   decl_map.put (omp_decl1, placeholder);
    5757                 :       2160 :   decl_map.put (omp_decl2, decl);
    5758                 :       2160 :   memset (&id, 0, sizeof (id));
    5759                 :       2160 :   id.src_fn = DECL_CONTEXT (omp_decl1);
    5760                 :       2160 :   id.dst_fn = current_function_decl;
    5761                 :       2160 :   id.src_cfun = DECL_STRUCT_FUNCTION (id.src_fn);
    5762                 :       2160 :   id.decl_map = &decl_map;
    5763                 :            : 
    5764                 :       2160 :   id.copy_decl = copy_decl_no_change;
    5765                 :       2160 :   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
    5766                 :       2160 :   id.transform_new_cfg = true;
    5767                 :       2160 :   id.transform_return_to_modify = false;
    5768                 :       2160 :   id.transform_lang_insert_block = NULL;
    5769                 :       2160 :   id.eh_lp_nr = 0;
    5770                 :       2160 :   walk_tree (&stmt, copy_tree_body_r, &id, NULL);
    5771                 :       2160 :   return stmt;
    5772                 :            : }
    5773                 :            : 
    5774                 :            : /* Helper function of finish_omp_clauses, called via cp_walk_tree.
    5775                 :            :    Find OMP_CLAUSE_PLACEHOLDER (passed in DATA) in *TP.  */
    5776                 :            : 
    5777                 :            : static tree
    5778                 :      14293 : find_omp_placeholder_r (tree *tp, int *, void *data)
    5779                 :            : {
    5780                 :      14293 :   if (*tp == (tree) data)
    5781                 :        299 :     return *tp;
    5782                 :            :   return NULL_TREE;
    5783                 :            : }
    5784                 :            : 
    5785                 :            : /* Helper function of finish_omp_clauses.  Handle OMP_CLAUSE_REDUCTION C.
    5786                 :            :    Return true if there is some error and the clause should be removed.  */
    5787                 :            : 
    5788                 :            : static bool
    5789                 :       5718 : finish_omp_reduction_clause (tree c, bool *need_default_ctor, bool *need_dtor)
    5790                 :            : {
    5791                 :       5718 :   tree t = OMP_CLAUSE_DECL (c);
    5792                 :       5718 :   bool predefined = false;
    5793                 :       5718 :   if (TREE_CODE (t) == TREE_LIST)
    5794                 :            :     {
    5795                 :          0 :       gcc_assert (processing_template_decl);
    5796                 :            :       return false;
    5797                 :            :     }
    5798                 :       5718 :   tree type = TREE_TYPE (t);
    5799                 :       5718 :   if (TREE_CODE (t) == MEM_REF)
    5800                 :       1076 :     type = TREE_TYPE (type);
    5801                 :       5718 :   if (TYPE_REF_P (type))
    5802                 :        462 :     type = TREE_TYPE (type);
    5803                 :       5718 :   if (TREE_CODE (type) == ARRAY_TYPE)
    5804                 :            :     {
    5805                 :        238 :       tree oatype = type;
    5806                 :        238 :       gcc_assert (TREE_CODE (t) != MEM_REF);
    5807                 :        480 :       while (TREE_CODE (type) == ARRAY_TYPE)
    5808                 :        242 :         type = TREE_TYPE (type);
    5809                 :        238 :       if (!processing_template_decl)
    5810                 :            :         {
    5811                 :        173 :           t = require_complete_type (t);
    5812                 :        173 :           if (t == error_mark_node)
    5813                 :            :             return true;
    5814                 :        165 :           tree size = size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (oatype),
    5815                 :            :                                   TYPE_SIZE_UNIT (type));
    5816                 :        165 :           if (integer_zerop (size))
    5817                 :            :             {
    5818                 :          8 :               error_at (OMP_CLAUSE_LOCATION (c),
    5819                 :            :                         "%qE in %<reduction%> clause is a zero size array",
    5820                 :            :                         omp_clause_printable_decl (t));
    5821                 :          4 :               return true;
    5822                 :            :             }
    5823                 :        161 :           size = size_binop (MINUS_EXPR, size, size_one_node);
    5824                 :        161 :           size = save_expr (size);
    5825                 :        161 :           tree index_type = build_index_type (size);
    5826                 :        161 :           tree atype = build_array_type (type, index_type);
    5827                 :        161 :           tree ptype = build_pointer_type (type);
    5828                 :        161 :           if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
    5829                 :         99 :             t = build_fold_addr_expr (t);
    5830                 :        161 :           t = build2 (MEM_REF, atype, t, build_int_cst (ptype, 0));
    5831                 :        161 :           OMP_CLAUSE_DECL (c) = t;
    5832                 :            :         }
    5833                 :            :     }
    5834                 :       5706 :   if (type == error_mark_node)
    5835                 :            :     return true;
    5836                 :       5702 :   else if (ARITHMETIC_TYPE_P (type))
    5837                 :       4505 :     switch (OMP_CLAUSE_REDUCTION_CODE (c))
    5838                 :            :       {
    5839                 :            :       case PLUS_EXPR:
    5840                 :            :       case MULT_EXPR:
    5841                 :            :       case MINUS_EXPR:
    5842                 :            :         predefined = true;
    5843                 :            :         break;
    5844                 :        222 :       case MIN_EXPR:
    5845                 :        222 :       case MAX_EXPR:
    5846                 :        222 :         if (TREE_CODE (type) == COMPLEX_TYPE)
    5847                 :            :           break;
    5848                 :            :         predefined = true;
    5849                 :            :         break;
    5850                 :        100 :       case BIT_AND_EXPR:
    5851                 :        100 :       case BIT_IOR_EXPR:
    5852                 :        100 :       case BIT_XOR_EXPR:
    5853                 :        124 :         if (FLOAT_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
    5854                 :            :           break;
    5855                 :            :         predefined = true;
    5856                 :            :         break;
    5857                 :         48 :       case TRUTH_ANDIF_EXPR:
    5858                 :         48 :       case TRUTH_ORIF_EXPR:
    5859                 :         48 :         if (FLOAT_TYPE_P (type))
    5860                 :            :           break;
    5861                 :            :         predefined = true;
    5862                 :            :         break;
    5863                 :            :       default:
    5864                 :            :         break;
    5865                 :            :       }
    5866                 :       1197 :   else if (TYPE_READONLY (type))
    5867                 :            :     {
    5868                 :         24 :       error_at (OMP_CLAUSE_LOCATION (c),
    5869                 :            :                 "%qE has const type for %<reduction%>",
    5870                 :            :                 omp_clause_printable_decl (t));
    5871                 :         12 :       return true;
    5872                 :            :     }
    5873                 :       1185 :   else if (!processing_template_decl)
    5874                 :            :     {
    5875                 :        994 :       t = require_complete_type (t);
    5876                 :        994 :       if (t == error_mark_node)
    5877                 :            :         return true;
    5878                 :        994 :       OMP_CLAUSE_DECL (c) = t;
    5879                 :            :     }
    5880                 :            : 
    5881                 :        994 :   if (predefined)
    5882                 :            :     {
    5883                 :       4229 :       OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = NULL_TREE;
    5884                 :       4229 :       return false;
    5885                 :            :     }
    5886                 :       1461 :   else if (processing_template_decl)
    5887                 :            :     {
    5888                 :        201 :       if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) == error_mark_node)
    5889                 :            :         return true;
    5890                 :        197 :       return false;
    5891                 :            :     }
    5892                 :            : 
    5893                 :       1260 :   tree id = OMP_CLAUSE_REDUCTION_PLACEHOLDER (c);
    5894                 :            : 
    5895                 :       1260 :   type = TYPE_MAIN_VARIANT (type);
    5896                 :       1260 :   OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = NULL_TREE;
    5897                 :       1260 :   if (id == NULL_TREE)
    5898                 :        874 :     id = omp_reduction_id (OMP_CLAUSE_REDUCTION_CODE (c),
    5899                 :            :                            NULL_TREE, NULL_TREE);
    5900                 :       1260 :   id = omp_reduction_lookup (OMP_CLAUSE_LOCATION (c), id, type, NULL, NULL);
    5901                 :       1260 :   if (id)
    5902                 :            :     {
    5903                 :       1204 :       if (id == error_mark_node)
    5904                 :            :         return true;
    5905                 :       1196 :       mark_used (id);
    5906                 :       1196 :       tree body = DECL_SAVED_TREE (id);
    5907                 :       1196 :       if (!body)
    5908                 :            :         return true;
    5909                 :       1192 :       if (TREE_CODE (body) == STATEMENT_LIST)
    5910                 :            :         {
    5911                 :       1192 :           tree_stmt_iterator tsi;
    5912                 :       1192 :           tree placeholder = NULL_TREE, decl_placeholder = NULL_TREE;
    5913                 :       1192 :           int i;
    5914                 :       1192 :           tree stmts[7];
    5915                 :       1192 :           tree atype = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (id)));
    5916                 :       1192 :           atype = TREE_TYPE (atype);
    5917                 :       1192 :           bool need_static_cast = !same_type_p (type, atype);
    5918                 :       1192 :           memset (stmts, 0, sizeof stmts);
    5919                 :       1192 :           for (i = 0, tsi = tsi_start (body);
    5920                 :       8363 :                i < 7 && !tsi_end_p (tsi);
    5921                 :       7171 :                i++, tsi_next (&tsi))
    5922                 :       7171 :             stmts[i] = tsi_stmt (tsi);
    5923                 :       1192 :           gcc_assert (tsi_end_p (tsi));
    5924                 :            : 
    5925                 :       1192 :           if (i >= 3)
    5926                 :            :             {
    5927                 :       1192 :               gcc_assert (TREE_CODE (stmts[0]) == DECL_EXPR
    5928                 :            :                           && TREE_CODE (stmts[1]) == DECL_EXPR);
    5929                 :       1192 :               placeholder = build_lang_decl (VAR_DECL, NULL_TREE, type);
    5930                 :       1192 :               DECL_ARTIFICIAL (placeholder) = 1;
    5931                 :       1192 :               DECL_IGNORED_P (placeholder) = 1;
    5932                 :       1192 :               OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = placeholder;
    5933                 :       1192 :               if (TREE_CODE (t) == MEM_REF)
    5934                 :            :                 {
    5935                 :        538 :                   decl_placeholder = build_lang_decl (VAR_DECL, NULL_TREE,
    5936                 :            :                                                       type);
    5937                 :        538 :                   DECL_ARTIFICIAL (decl_placeholder) = 1;
    5938                 :        538 :                   DECL_IGNORED_P (decl_placeholder) = 1;
    5939                 :        538 :                   OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c) = decl_placeholder;
    5940                 :            :                 }
    5941                 :       1192 :               if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts[0])))
    5942                 :        309 :                 cxx_mark_addressable (placeholder);
    5943                 :       1192 :               if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts[1]))
    5944                 :        309 :                   && (decl_placeholder
    5945                 :       1365 :                       || !TYPE_REF_P (TREE_TYPE (OMP_CLAUSE_DECL (c)))))
    5946                 :        420 :                 cxx_mark_addressable (decl_placeholder ? decl_placeholder
    5947                 :        142 :                                       : OMP_CLAUSE_DECL (c));
    5948                 :       1192 :               tree omp_out = placeholder;
    5949                 :       1192 :               tree omp_in = decl_placeholder ? decl_placeholder
    5950                 :        654 :                             : convert_from_reference (OMP_CLAUSE_DECL (c));
    5951                 :       1192 :               if (need_static_cast)
    5952                 :            :                 {
    5953                 :          8 :                   tree rtype = build_reference_type (atype);
    5954                 :          8 :                   omp_out = build_static_cast (input_location,
    5955                 :            :                                                rtype, omp_out,
    5956                 :            :                                                tf_warning_or_error);
    5957                 :          8 :                   omp_in = build_static_cast (input_location,
    5958                 :            :                                               rtype, omp_in,
    5959                 :            :                                               tf_warning_or_error);
    5960                 :          8 :                   if (omp_out == error_mark_node || omp_in == error_mark_node)
    5961                 :          4 :                     return true;
    5962                 :          8 :                   omp_out = convert_from_reference (omp_out);
    5963                 :          8 :                   omp_in = convert_from_reference (omp_in);
    5964                 :            :                 }
    5965                 :       1192 :               OMP_CLAUSE_REDUCTION_MERGE (c)
    5966                 :       2384 :                 = clone_omp_udr (stmts[2], DECL_EXPR_DECL (stmts[0]),
    5967                 :       1192 :                                  DECL_EXPR_DECL (stmts[1]), omp_in, omp_out);
    5968                 :            :             }
    5969                 :       1192 :           if (i >= 6)
    5970                 :            :             {
    5971                 :        972 :               gcc_assert (TREE_CODE (stmts[3]) == DECL_EXPR
    5972                 :            :                           && TREE_CODE (stmts[4]) == DECL_EXPR);
    5973                 :        972 :               if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts[3]))
    5974                 :        746 :                   && (decl_placeholder
    5975                 :       1214 :                       || !TYPE_REF_P (TREE_TYPE (OMP_CLAUSE_DECL (c)))))
    5976                 :        864 :                 cxx_mark_addressable (decl_placeholder ? decl_placeholder
    5977                 :        180 :                                       : OMP_CLAUSE_DECL (c));
    5978                 :        972 :               if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts[4])))
    5979                 :        217 :                 cxx_mark_addressable (placeholder);
    5980                 :        972 :               tree omp_priv = decl_placeholder ? decl_placeholder
    5981                 :        460 :                               : convert_from_reference (OMP_CLAUSE_DECL (c));
    5982                 :        972 :               tree omp_orig = placeholder;
    5983                 :        972 :               if (need_static_cast)
    5984                 :            :                 {
    5985                 :          6 :                   if (i == 7)
    5986                 :            :                     {
    5987                 :          4 :                       error_at (OMP_CLAUSE_LOCATION (c),
    5988                 :            :                                 "user defined reduction with constructor "
    5989                 :            :                                 "initializer for base class %qT", atype);
    5990                 :          4 :                       return true;
    5991                 :            :                     }
    5992                 :          2 :                   tree rtype = build_reference_type (atype);
    5993                 :          2 :                   omp_priv = build_static_cast (input_location,
    5994                 :            :                                                 rtype, omp_priv,
    5995                 :            :                                                 tf_warning_or_error);
    5996                 :          2 :                   omp_orig = build_static_cast (input_location,
    5997                 :            :                                                 rtype, omp_orig,
    5998                 :            :                                                 tf_warning_or_error);
    5999                 :          2 :                   if (omp_priv == error_mark_node
    6000                 :          2 :                       || omp_orig == error_mark_node)
    6001                 :            :                     return true;
    6002                 :          2 :                   omp_priv = convert_from_reference (omp_priv);
    6003                 :          2 :                   omp_orig = convert_from_reference (omp_orig);
    6004                 :            :                 }
    6005                 :        968 :               if (i == 6)
    6006                 :        293 :                 *need_default_ctor = true;
    6007                 :        968 :               OMP_CLAUSE_REDUCTION_INIT (c)
    6008                 :       1936 :                 = clone_omp_udr (stmts[5], DECL_EXPR_DECL (stmts[4]),
    6009                 :        968 :                                  DECL_EXPR_DECL (stmts[3]),
    6010                 :            :                                  omp_priv, omp_orig);
    6011                 :        968 :               if (cp_walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c),
    6012                 :            :                                 find_omp_placeholder_r, placeholder, NULL))
    6013                 :        275 :                 OMP_CLAUSE_REDUCTION_OMP_ORIG_REF (c) = 1;
    6014                 :            :             }
    6015                 :        220 :           else if (i >= 3)
    6016                 :            :             {
    6017                 :        430 :               if (CLASS_TYPE_P (type) && !pod_type_p (type))
    6018                 :        202 :                 *need_default_ctor = true;
    6019                 :            :               else
    6020                 :            :                 {
    6021                 :         18 :                   tree init;
    6022                 :         18 :                   tree v = decl_placeholder ? decl_placeholder
    6023                 :         18 :                            : convert_from_reference (t);
    6024                 :         18 :                   if (AGGREGATE_TYPE_P (TREE_TYPE (v)))
    6025                 :          8 :                     init = build_constructor (TREE_TYPE (v), NULL);
    6026                 :            :                   else
    6027                 :         10 :                     init = fold_convert (TREE_TYPE (v), integer_zero_node);
    6028                 :         36 :                   OMP_CLAUSE_REDUCTION_INIT (c)
    6029                 :         36 :                     = build2 (INIT_EXPR, TREE_TYPE (v), v, init);
    6030                 :            :                 }
    6031                 :            :             }
    6032                 :            :         }
    6033                 :            :     }
    6034                 :       1244 :   if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
    6035                 :       1188 :     *need_dtor = true;
    6036                 :            :   else
    6037                 :            :     {
    6038                 :        112 :       error_at (OMP_CLAUSE_LOCATION (c),
    6039                 :            :                 "user defined reduction not found for %qE",
    6040                 :            :                 omp_clause_printable_decl (t));
    6041                 :         56 :       return true;
    6042                 :            :     }
    6043                 :       1188 :   if (TREE_CODE (OMP_CLAUSE_DECL (c)) == MEM_REF)
    6044                 :        538 :     gcc_assert (TYPE_SIZE_UNIT (type)
    6045                 :            :                 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST);
    6046                 :            :   return false;
    6047                 :            : }
    6048                 :            : 
    6049                 :            : /* Called from finish_struct_1.  linear(this) or linear(this:step)
    6050                 :            :    clauses might not be finalized yet because the class has been incomplete
    6051                 :            :    when parsing #pragma omp declare simd methods.  Fix those up now.  */
    6052                 :            : 
    6053                 :            : void
    6054                 :      22790 : finish_omp_declare_simd_methods (tree t)
    6055                 :            : {
    6056                 :      22790 :   if (processing_template_decl)
    6057                 :            :     return;
    6058                 :            : 
    6059                 :     140372 :   for (tree x = TYPE_FIELDS (t); x; x = DECL_CHAIN (x))
    6060                 :            :     {
    6061                 :     195218 :       if (TREE_CODE (x) == USING_DECL
    6062                 :     231112 :           || !DECL_NONSTATIC_MEMBER_FUNCTION_P (x))
    6063                 :      79522 :         continue;
    6064                 :      36174 :       tree ods = lookup_attribute ("omp declare simd", DECL_ATTRIBUTES (x));
    6065                 :      36298 :       if (!ods || !TREE_VALUE (ods))
    6066                 :      36050 :         continue;
    6067                 :        416 :       for (tree c = TREE_VALUE (TREE_VALUE (ods)); c; c = OMP_CLAUSE_CHAIN (c))
    6068                 :        292 :         if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
    6069                 :         76 :             && integer_zerop (OMP_CLAUSE_DECL (c))
    6070                 :         24 :             && OMP_CLAUSE_LINEAR_STEP (c)
    6071                 :        316 :             && TYPE_PTR_P (TREE_TYPE (OMP_CLAUSE_LINEAR_STEP (c))))
    6072                 :            :           {
    6073                 :         24 :             tree s = OMP_CLAUSE_LINEAR_STEP (c);
    6074                 :         24 :             s = fold_convert_loc (OMP_CLAUSE_LOCATION (c), sizetype, s);
    6075                 :         48 :             s = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MULT_EXPR,
    6076                 :         24 :                                  sizetype, s, TYPE_SIZE_UNIT (t));
    6077                 :         24 :             OMP_CLAUSE_LINEAR_STEP (c) = s;
    6078                 :            :           }
    6079                 :            :     }
    6080                 :            : }
    6081                 :            : 
    6082                 :            : /* Adjust sink depend clause to take into account pointer offsets.
    6083                 :            : 
    6084                 :            :    Return TRUE if there was a problem processing the offset, and the
    6085                 :            :    whole clause should be removed.  */
    6086                 :            : 
    6087                 :            : static bool
    6088                 :        242 : cp_finish_omp_clause_depend_sink (tree sink_clause)
    6089                 :            : {
    6090                 :        242 :   tree t = OMP_CLAUSE_DECL (sink_clause);
    6091                 :        242 :   gcc_assert (TREE_CODE (t) == TREE_LIST);
    6092                 :            : 
    6093                 :            :   /* Make sure we don't adjust things twice for templates.  */
    6094                 :        242 :   if (processing_template_decl)
    6095                 :            :     return false;
    6096                 :            : 
    6097                 :        536 :   for (; t; t = TREE_CHAIN (t))
    6098                 :            :     {
    6099                 :        318 :       tree decl = TREE_VALUE (t);
    6100                 :        318 :       if (TYPE_PTR_P (TREE_TYPE (decl)))
    6101                 :            :         {
    6102                 :          8 :           tree offset = TREE_PURPOSE (t);
    6103                 :          8 :           bool neg = wi::neg_p (wi::to_wide (offset));
    6104                 :          8 :           offset = fold_unary (ABS_EXPR, TREE_TYPE (offset), offset);
    6105                 :          8 :           decl = mark_rvalue_use (decl);
    6106                 :          8 :           decl = convert_from_reference (decl);
    6107                 :         16 :           tree t2 = pointer_int_sum (OMP_CLAUSE_LOCATION (sink_clause),
    6108                 :            :                                      neg ? MINUS_EXPR : PLUS_EXPR,
    6109                 :            :                                      decl, offset);
    6110                 :          8 :           t2 = fold_build2_loc (OMP_CLAUSE_LOCATION (sink_clause),
    6111                 :            :                                 MINUS_EXPR, sizetype,
    6112                 :            :                                 fold_convert (sizetype, t2),
    6113                 :            :                                 fold_convert (sizetype, decl));
    6114                 :          8 :           if (t2 == error_mark_node)
    6115                 :            :             return true;
    6116                 :          8 :           TREE_PURPOSE (t) = t2;
    6117                 :            :         }
    6118                 :            :     }
    6119                 :            :   return false;
    6120                 :            : }
    6121                 :            : 
    6122                 :            : /* Finish OpenMP iterators ITER.  Return true if they are errorneous
    6123                 :            :    and clauses containing them should be removed.  */
    6124                 :            : 
    6125                 :            : static bool
    6126                 :        465 : cp_omp_finish_iterators (tree iter)
    6127                 :            : {
    6128                 :        465 :   bool ret = false;
    6129                 :       1033 :   for (tree it = iter; it; it = TREE_CHAIN (it))
    6130                 :            :     {
    6131                 :        568 :       tree var = TREE_VEC_ELT (it, 0);
    6132                 :        568 :       tree begin = TREE_VEC_ELT (it, 1);
    6133                 :        568 :       tree end = TREE_VEC_ELT (it, 2);
    6134                 :        568 :       tree step = TREE_VEC_ELT (it, 3);
    6135                 :        568 :       tree orig_step;
    6136                 :        568 :       tree type = TREE_TYPE (var);
    6137                 :        568 :       location_t loc = DECL_SOURCE_LOCATION (var);
    6138                 :        568 :       if (type == error_mark_node)
    6139                 :            :         {
    6140                 :          0 :           ret = true;
    6141                 :          0 :           continue;
    6142                 :            :         }
    6143                 :        568 :       if (type_dependent_expression_p (var))
    6144                 :         76 :         continue;
    6145                 :        492 :       if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
    6146                 :            :         {
    6147                 :         24 :           error_at (loc, "iterator %qD has neither integral nor pointer type",
    6148                 :            :                     var);
    6149                 :         24 :           ret = true;
    6150                 :         24 :           continue;
    6151                 :            :         }
    6152                 :        468 :       else if (TYPE_READONLY (type))
    6153                 :            :         {
    6154                 :         24 :           error_at (loc, "iterator %qD has const qualified type", var);
    6155                 :         24 :           ret = true;
    6156                 :         24 :           continue;
    6157                 :            :         }
    6158                 :        444 :       if (type_dependent_expression_p (begin)
    6159                 :        432 :           || type_dependent_expression_p (end)
    6160                 :        876 :           || type_dependent_expression_p (step))
    6161                 :         20 :         continue;
    6162                 :        848 :       else if (error_operand_p (step))
    6163                 :            :         {
    6164                 :          0 :           ret = true;
    6165                 :          0 :           continue;
    6166                 :            :         }
    6167                 :        424 :       else if (!INTEGRAL_TYPE_P (TREE_TYPE (step)))
    6168                 :            :         {
    6169                 :         20 :           error_at (EXPR_LOC_OR_LOC (step, loc),
    6170                 :            :                     "iterator step with non-integral type");
    6171                 :         20 :           ret = true;
    6172                 :         20 :           continue;
    6173                 :            :         }
    6174                 :            : 
    6175                 :        404 :       begin = mark_rvalue_use (begin);
    6176                 :        404 :       end = mark_rvalue_use (end);
    6177                 :        404 :       step = mark_rvalue_use (step);
    6178                 :        404 :       begin = cp_build_c_cast (input_location, type, begin,
    6179                 :            :                                tf_warning_or_error);
    6180                 :        404 :       end = cp_build_c_cast (input_location, type, end,
    6181                 :            :                              tf_warning_or_error);
    6182                 :        404 :       orig_step = step;
    6183                 :        404 :       if (!processing_template_decl)
    6184                 :        320 :         step = orig_step = save_expr (step);
    6185                 :        404 :       tree stype = POINTER_TYPE_P (type) ? sizetype : type;
    6186                 :        404 :       step = cp_build_c_cast (input_location, stype, step,
    6187                 :            :                               tf_warning_or_error);
    6188                 :        404 :       if (POINTER_TYPE_P (type) && !processing_template_decl)
    6189                 :            :         {
    6190                 :         63 :           begin = save_expr (begin);
    6191                 :         63 :           step = pointer_int_sum (loc, PLUS_EXPR, begin, step);
    6192                 :         63 :           step = fold_build2_loc (loc, MINUS_EXPR, sizetype,
    6193                 :            :                                   fold_convert (sizetype, step),
    6194                 :            :                                   fold_convert (sizetype, begin));
    6195                 :         63 :           step = fold_convert (ssizetype, step);
    6196                 :            :         }
    6197                 :        404 :       if (!processing_template_decl)
    6198                 :            :         {
    6199                 :        320 :           begin = maybe_constant_value (begin);
    6200                 :        320 :           end = maybe_constant_value (end);
    6201                 :        320 :           step = maybe_constant_value (step);
    6202                 :        320 :           orig_step = maybe_constant_value (orig_step);
    6203                 :            :         }
    6204                 :        404 :       if (integer_zerop (step))
    6205                 :            :         {
    6206                 :         24 :           error_at (loc, "iterator %qD has zero step", var);
    6207                 :         24 :           ret = true;
    6208                 :         24 :           continue;
    6209                 :            :         }
    6210                 :            : 
    6211                 :        380 :       if (begin == error_mark_node
    6212                 :        372 :           || end == error_mark_node
    6213                 :        364 :           || step == error_mark_node
    6214                 :        364 :           || orig_step == error_mark_node)
    6215                 :            :         {
    6216                 :         16 :           ret = true;
    6217                 :         16 :           continue;
    6218                 :            :         }
    6219                 :            : 
    6220                 :        364 :       if (!processing_template_decl)
    6221                 :            :         {
    6222                 :        280 :           begin = fold_build_cleanup_point_expr (TREE_TYPE (begin), begin);
    6223                 :        280 :           end = fold_build_cleanup_point_expr (TREE_TYPE (end), end);
    6224                 :        280 :           step = fold_build_cleanup_point_expr (TREE_TYPE (step), step);
    6225                 :        280 :           orig_step = fold_build_cleanup_point_expr (TREE_TYPE (orig_step),
    6226                 :            :                                                      orig_step);
    6227                 :            :         }
    6228                 :        704 :       hash_set<tree> pset;
    6229                 :        364 :       tree it2;
    6230                 :        436 :       for (it2 = TREE_CHAIN (it); it2; it2 = TREE_CHAIN (it2))
    6231                 :            :         {
    6232                 :         96 :           tree var2 = TREE_VEC_ELT (it2, 0);
    6233                 :         96 :           tree begin2 = TREE_VEC_ELT (it2, 1);
    6234                 :         96 :           tree end2 = TREE_VEC_ELT (it2, 2);
    6235                 :         96 :           tree step2 = TREE_VEC_ELT (it2, 3);
    6236                 :         96 :           location_t loc2 = DECL_SOURCE_LOCATION (var2);
    6237                 :         96 :           if (cp_walk_tree (&begin2, find_omp_placeholder_r, var, &pset))
    6238                 :            :             {
    6239                 :          8 :               error_at (EXPR_LOC_OR_LOC (begin2, loc2),
    6240                 :            :                         "begin expression refers to outer iterator %qD", var);
    6241                 :         32 :               break;
    6242                 :            :             }
    6243                 :         88 :           else if (cp_walk_tree (&end2, find_omp_placeholder_r, var, &pset))
    6244                 :            :             {
    6245                 :          8 :               error_at (EXPR_LOC_OR_LOC (end2, loc2),
    6246                 :            :                         "end expression refers to outer iterator %qD", var);
    6247                 :          8 :               break;
    6248                 :            :             }
    6249                 :         80 :           else if (cp_walk_tree (&step2, find_omp_placeholder_r, var, &pset))
    6250                 :            :             {
    6251                 :          8 :               error_at (EXPR_LOC_OR_LOC (step2, loc2),
    6252                 :            :                         "step expression refers to outer iterator %qD", var);
    6253                 :          8 :               break;
    6254                 :            :             }
    6255                 :            :         }
    6256                 :        364 :       if (it2)
    6257                 :            :         {
    6258                 :         24 :           ret = true;
    6259                 :        228 :           continue;
    6260                 :            :         }
    6261                 :        340 :       TREE_VEC_ELT (it, 1) = begin;
    6262                 :        340 :       TREE_VEC_ELT (it, 2) = end;
    6263                 :        340 :       if (processing_template_decl)
    6264                 :         76 :         TREE_VEC_ELT (it, 3) = orig_step;
    6265                 :            :       else
    6266                 :            :         {
    6267                 :        264 :           TREE_VEC_ELT (it, 3) = step;
    6268                 :        264 :           TREE_VEC_ELT (it, 4) = orig_step;
    6269                 :            :         }
    6270                 :            :     }
    6271                 :        465 :   return ret;
    6272                 :            : }
    6273                 :            : 
    6274                 :            : /* Ensure that pointers are used in OpenACC attach and detach clauses.
    6275                 :            :    Return true if an error has been detected.  */
    6276                 :            : 
    6277                 :            : static bool
    6278                 :      11262 : cp_oacc_check_attachments (tree c)
    6279                 :            : {
    6280                 :      11262 :   if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP)
    6281                 :            :     return false;
    6282                 :            : 
    6283                 :            :   /* OpenACC attach / detach clauses must be pointers.  */
    6284                 :       8823 :   if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ATTACH
    6285                 :       8823 :       || OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_DETACH)
    6286                 :            :     {
    6287                 :        187 :       tree t = OMP_CLAUSE_DECL (c);
    6288                 :        235 :       tree type;
    6289                 :            : 
    6290                 :        235 :       while (TREE_CODE (t) == TREE_LIST)
    6291                 :         48 :         t = TREE_CHAIN (t);
    6292                 :            : 
    6293                 :        187 :       type = TREE_TYPE (t);
    6294                 :            : 
    6295                 :        187 :       if (TREE_CODE (type) == REFERENCE_TYPE)
    6296                 :         48 :         type = TREE_TYPE (type);
    6297                 :            : 
    6298                 :        187 :       if (TREE_CODE (type) != POINTER_TYPE)
    6299                 :            :         {
    6300                 :         48 :           error_at (OMP_CLAUSE_LOCATION (c), "expected pointer in %qs clause",
    6301                 :            :                     c_omp_map_clause_name (c, true));
    6302                 :         48 :           return true;
    6303                 :            :         }
    6304                 :            :     }
    6305                 :            : 
    6306                 :            :   return false;
    6307                 :            : }
    6308                 :            : 
    6309                 :            : /* For all elements of CLAUSES, validate them vs OpenMP constraints.
    6310                 :            :    Remove any elements from the list that are invalid.  */
    6311                 :            : 
    6312                 :            : tree
    6313                 :      44482 : finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
    6314                 :            : {
    6315                 :      44482 :   bitmap_head generic_head, firstprivate_head, lastprivate_head;
    6316                 :      44482 :   bitmap_head aligned_head, map_head, map_field_head, oacc_reduction_head;
    6317                 :      44482 :   tree c, t, *pc;
    6318                 :      44482 :   tree safelen = NULL_TREE;
    6319                 :      44482 :   bool branch_seen = false;
    6320                 :      44482 :   bool copyprivate_seen = false;
    6321                 :      44482 :   bool ordered_seen = false;
    6322                 :      44482 :   bool order_seen = false;
    6323                 :      44482 :   bool schedule_seen = false;
    6324                 :      44482 :   bool oacc_async = false;
    6325                 :      44482 :   tree last_iterators = NULL_TREE;
    6326                 :      44482 :   bool last_iterators_remove = false;
    6327                 :            :   /* 1 if normal/task reduction has been seen, -1 if inscan reduction
    6328                 :            :      has been seen, -2 if mixed inscan/normal reduction diagnosed.  */
    6329                 :      44482 :   int reduction_seen = 0;
    6330                 :            : 
    6331                 :      44482 :   bitmap_obstack_initialize (NULL);
    6332                 :      44482 :   bitmap_initialize (&generic_head, &bitmap_default_obstack);
    6333                 :      44482 :   bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
    6334                 :      44482 :   bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
    6335                 :      44482 :   bitmap_initialize (&aligned_head, &bitmap_default_obstack);
    6336                 :            :   /* If ort == C_ORT_OMP_DECLARE_SIMD used as uniform_head instead.  */
    6337                 :      44482 :   bitmap_initialize (&map_head, &bitmap_default_obstack);
    6338                 :      44482 :   bitmap_initialize (&map_field_head, &bitmap_default_obstack);
    6339                 :            :   /* If ort == C_ORT_OMP used as nontemporal_head or use_device_xxx_head
    6340                 :            :      instead.  */
    6341                 :      44482 :   bitmap_initialize (&oacc_reduction_head, &bitmap_default_obstack);
    6342                 :            : 
    6343                 :      44482 :   if (ort & C_ORT_ACC)
    6344                 :      23872 :     for (c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
    6345                 :      14004 :       if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_ASYNC)
    6346                 :            :         {
    6347                 :            :           oacc_async = true;
    6348                 :            :           break;
    6349                 :            :         }
    6350                 :            : 
    6351                 :     106864 :   for (pc = &clauses, c = clauses; c ; c = *pc)
    6352                 :            :     {
    6353                 :      62382 :       bool remove = false;
    6354                 :      62382 :       bool field_ok = false;
    6355                 :            : 
    6356                 :      62382 :       switch (OMP_CLAUSE_CODE (c))
    6357                 :            :         {
    6358                 :       1375 :         case OMP_CLAUSE_SHARED:
    6359                 :       1375 :           field_ok = ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP);
    6360                 :       1375 :           goto check_dup_generic;
    6361                 :       1571 :         case OMP_CLAUSE_PRIVATE:
    6362                 :       1571 :           field_ok = ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP);
    6363                 :       1571 :           goto check_dup_generic;
    6364                 :       4742 :         case OMP_CLAUSE_REDUCTION:
    6365                 :       4742 :           if (reduction_seen == 0)
    6366                 :       3730 :             reduction_seen = OMP_CLAUSE_REDUCTION_INSCAN (c) ? -1 : 1;
    6367                 :       1012 :           else if (reduction_seen != -2
    6368                 :       2024 :                    && reduction_seen != (OMP_CLAUSE_REDUCTION_INSCAN (c)
    6369                 :       1012 :                                          ? -1 : 1))
    6370                 :            :             {
    6371                 :          8 :               error_at (OMP_CLAUSE_LOCATION (c),
    6372                 :            :                         "%<inscan%> and non-%<inscan%> %<reduction%> clauses "
    6373                 :            :                         "on the same construct");
    6374                 :          8 :               reduction_seen = -2;
    6375                 :            :             }
    6376                 :            :           /* FALLTHRU */
    6377                 :       6262 :         case OMP_CLAUSE_IN_REDUCTION:
    6378                 :       6262 :         case OMP_CLAUSE_TASK_REDUCTION:
    6379                 :       6262 :           field_ok = ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP);
    6380                 :       6262 :           t = OMP_CLAUSE_DECL (c);
    6381                 :       6262 :           if (TREE_CODE (t) == TREE_LIST)
    6382                 :            :             {
    6383                 :       1607 :               if (handle_omp_array_sections (c, ort))
    6384                 :            :                 {
    6385                 :            :                   remove = true;
    6386                 :            :                   break;
    6387                 :            :                 }
    6388                 :       1551 :               if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
    6389                 :       1551 :                   && OMP_CLAUSE_REDUCTION_INSCAN (c))
    6390                 :            :                 {
    6391                 :          4 :                   error_at (OMP_CLAUSE_LOCATION (c),
    6392                 :            :                             "%<inscan%> %<reduction%> clause with array "
    6393                 :            :                             "section");
    6394                 :          4 :                   remove = true;
    6395                 :          4 :                   break;
    6396                 :            :                 }
    6397                 :       1547 :               if (TREE_CODE (t) == TREE_LIST)
    6398                 :            :                 {
    6399                 :       3444 :                   while (TREE_CODE (t) == TREE_LIST)
    6400                 :       1897 :                     t = TREE_CHAIN (t);
    6401                 :            :                 }
    6402                 :            :               else
    6403                 :            :                 {
    6404                 :          0 :                   gcc_assert (TREE_CODE (t) == MEM_REF);
    6405                 :          0 :                   t = TREE_OPERAND (t, 0);
    6406                 :          0 :                   if (TREE_CODE (t) == POINTER_PLUS_EXPR)
    6407                 :          0 :                     t = TREE_OPERAND (t, 0);
    6408                 :          0 :                   if (TREE_CODE (t) == ADDR_EXPR
    6409                 :          0 :                       || INDIRECT_REF_P (t))
    6410                 :          0 :                     t = TREE_OPERAND (t, 0);
    6411                 :            :                 }
    6412                 :       1547 :               tree n = omp_clause_decl_field (t);
    6413                 :       1547 :               if (n)
    6414                 :         59 :                 t = n;
    6415                 :       1547 :               goto check_dup_generic_t;
    6416                 :            :             }
    6417                 :       4655 :           if (oacc_async)
    6418                 :          7 :             cxx_mark_addressable (t);
    6419                 :       4655 :           goto check_dup_generic;
    6420                 :        111 :         case OMP_CLAUSE_COPYPRIVATE:
    6421                 :        111 :           copyprivate_seen = true;
    6422                 :        111 :           field_ok = ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP);
    6423                 :        111 :           goto check_dup_generic;
    6424                 :        100 :         case OMP_CLAUSE_COPYIN:
    6425                 :        100 :           goto check_dup_generic;
    6426                 :       1318 :         case OMP_CLAUSE_LINEAR:
    6427                 :       1318 :           field_ok = ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP);
    6428                 :       1318 :           t = OMP_CLAUSE_DECL (c);
    6429                 :       1318 :           if (ort != C_ORT_OMP_DECLARE_SIMD
    6430                 :       1318 :               && OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_DEFAULT)
    6431                 :            :             {
    6432                 :         56 :               error_at (OMP_CLAUSE_LOCATION (c),
    6433                 :            :                         "modifier should not be specified in %<linear%> "
    6434                 :            :                         "clause on %<simd%> or %<for%> constructs");
    6435                 :         56 :               OMP_CLAUSE_LINEAR_KIND (c) = OMP_CLAUSE_LINEAR_DEFAULT;
    6436                 :            :             }
    6437                 :        967 :           if ((VAR_P (t) || TREE_CODE (t) == PARM_DECL)
    6438                 :       2216 :               && !type_dependent_expression_p (t))
    6439                 :            :             {
    6440                 :       1209 :               tree type = TREE_TYPE (t);
    6441                 :       1209 :               if ((OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_REF
    6442                 :       1145 :                    || OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_UVAL)
    6443                 :       1265 :                   && !TYPE_REF_P (type))
    6444                 :            :                 {
    6445                 :         16 :                   error_at (OMP_CLAUSE_LOCATION (c),
    6446                 :            :                             "linear clause with %qs modifier applied to "
    6447                 :            :                             "non-reference variable with %qT type",
    6448                 :         16 :                             OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_REF
    6449                 :         16 :                             ? "ref" : "uval", TREE_TYPE (t));
    6450                 :         16 :                   remove = true;
    6451                 :         16 :                   break;
    6452                 :            :                 }
    6453                 :       1193 :               if (TYPE_REF_P (type))
    6454                 :        230 :                 type = TREE_TYPE (type);
    6455                 :       1193 :               if (OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_REF)
    6456                 :            :                 {
    6457                 :       1137 :                   if (!INTEGRAL_TYPE_P (type)
    6458                 :        109 :                       && !TYPE_PTR_P (type))
    6459                 :            :                     {
    6460                 :         24 :                       error_at (OMP_CLAUSE_LOCATION (c),
    6461                 :            :                                 "linear clause applied to non-integral "
    6462                 :            :                                 "non-pointer variable with %qT type",
    6463                 :         24 :                                 TREE_TYPE (t));
    6464                 :         24 :                       remove = true;
    6465                 :         24 :                       break;
    6466                 :            :                     }
    6467                 :            :                 }
    6468                 :            :             }
    6469                 :       1278 :           t = OMP_CLAUSE_LINEAR_STEP (c);
    6470                 :       1278 :           if (t == NULL_TREE)
    6471                 :          6 :             t = integer_one_node;
    6472                 :       1278 :           if (t == error_mark_node)
    6473                 :            :             {
    6474                 :            :               remove = true;
    6475                 :            :               break;
    6476                 :            :             }
    6477                 :       1278 :           else if (!type_dependent_expression_p (t)
    6478                 :       1276 :                    && !INTEGRAL_TYPE_P (TREE_TYPE (t))
    6479                 :       1294 :                    && (ort != C_ORT_OMP_DECLARE_SIMD
    6480                 :         12 :                        || TREE_CODE (t) != PARM_DECL
    6481                 :          8 :                        || !TYPE_REF_P (TREE_TYPE (t))
    6482                 :          8 :                        || !INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (t)))))
    6483                 :            :             {
    6484                 :          8 :               error_at (OMP_CLAUSE_LOCATION (c),
    6485                 :            :                         "linear step expression must be integral");
    6486                 :          8 :               remove = true;
    6487                 :          8 :               break;
    6488                 :            :             }
    6489                 :            :           else
    6490                 :            :             {
    6491                 :       1270 :               t = mark_rvalue_use (t);
    6492                 :       1270 :               if (ort == C_ORT_OMP_DECLARE_SIMD && TREE_CODE (t) == PARM_DECL)
    6493                 :            :                 {
    6494                 :         40 :                   OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c) = 1;
    6495                 :         40 :                   goto check_dup_generic;
    6496                 :            :                 }
    6497                 :       1230 :               if (!processing_template_decl
    6498                 :       2306 :                   && (VAR_P (OMP_CLAUSE_DECL (c))
    6499                 :        763 :                       || TREE_CODE (OMP_CLAUSE_DECL (c)) == PARM_DECL))
    6500                 :            :                 {
    6501                 :       1017 :                   if (ort == C_ORT_OMP_DECLARE_SIMD)
    6502                 :            :                     {
    6503                 :        553 :                       t = maybe_constant_value (t);
    6504                 :        553 :                       if (TREE_CODE (t) != INTEGER_CST)
    6505                 :            :                         {
    6506                 :          0 :                           error_at (OMP_CLAUSE_LOCATION (c),
    6507                 :            :                                     "%<linear%> clause step %qE is neither "
    6508                 :            :                                      "constant nor a parameter", t);
    6509                 :          0 :                           remove = true;
    6510                 :          0 :                           break;
    6511                 :            :                         }
    6512                 :            :                     }
    6513                 :       1017 :                   t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    6514                 :       1017 :                   tree type = TREE_TYPE (OMP_CLAUSE_DECL (c));
    6515                 :       1017 :                   if (TYPE_REF_P (type))
    6516                 :        206 :                     type = TREE_TYPE (type);
    6517                 :       1017 :                   if (OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_REF)
    6518                 :            :                     {
    6519                 :         52 :                       type = build_pointer_type (type);
    6520                 :         52 :                       tree d = fold_convert (type, OMP_CLAUSE_DECL (c));
    6521                 :         52 :                       t = pointer_int_sum (OMP_CLAUSE_LOCATION (c), PLUS_EXPR,
    6522                 :            :                                            d, t);
    6523                 :         52 :                       t = fold_build2_loc (OMP_CLAUSE_LOCATION (c),
    6524                 :            :                                            MINUS_EXPR, sizetype,
    6525                 :            :                                            fold_convert (sizetype, t),
    6526                 :            :                                            fold_convert (sizetype, d));
    6527                 :         52 :                       if (t == error_mark_node)
    6528                 :            :                         {
    6529                 :            :                           remove = true;
    6530                 :            :                           break;
    6531                 :            :                         }
    6532                 :            :                     }
    6533                 :        965 :                   else if (TYPE_PTR_P (type)
    6534                 :            :                            /* Can't multiply the step yet if *this
    6535                 :            :                               is still incomplete type.  */
    6536                 :        965 :                            && (ort != C_ORT_OMP_DECLARE_SIMD
    6537                 :         64 :                                || TREE_CODE (OMP_CLAUSE_DECL (c)) != PARM_DECL
    6538                 :         64 :                                || !DECL_ARTIFICIAL (OMP_CLAUSE_DECL (c))
    6539                 :         44 :                                || DECL_NAME (OMP_CLAUSE_DECL (c))
    6540                 :         44 :                                   != this_identifier
    6541                 :         44 :                                || !TYPE_BEING_DEFINED (TREE_TYPE (type))))
    6542                 :            :                     {
    6543                 :         41 :                       tree d = convert_from_reference (OMP_CLAUSE_DECL (c));
    6544                 :         41 :                       t = pointer_int_sum (OMP_CLAUSE_LOCATION (c), PLUS_EXPR,
    6545                 :            :                                            d, t);
    6546                 :         41 :                       t = fold_build2_loc (OMP_CLAUSE_LOCATION (c),
    6547                 :            :                                            MINUS_EXPR, sizetype,
    6548                 :            :                                            fold_convert (sizetype, t),
    6549                 :            :                                            fold_convert (sizetype, d));
    6550                 :         41 :                       if (t == error_mark_node)
    6551                 :            :                         {
    6552                 :            :                           remove = true;
    6553                 :            :                           break;
    6554                 :            :                         }
    6555                 :            :                     }
    6556                 :            :                   else
    6557                 :        924 :                     t = fold_convert (type, t);
    6558                 :            :                 }
    6559                 :       1230 :               OMP_CLAUSE_LINEAR_STEP (c) = t;
    6560                 :            :             }
    6561                 :       1230 :           goto check_dup_generic;
    6562                 :       9782 :         check_dup_generic:
    6563                 :       9782 :           t = omp_clause_decl_field (OMP_CLAUSE_DECL (c));
    6564                 :       9782 :           if (t)
    6565                 :            :             {
    6566                 :        146 :               if (!remove && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_SHARED)
    6567                 :         73 :                 omp_note_field_privatization (t, OMP_CLAUSE_DECL (c));
    6568                 :            :             }
    6569                 :            :           else
    6570                 :       9709 :             t = OMP_CLAUSE_DECL (c);
    6571                 :      11329 :         check_dup_generic_t:
    6572                 :      11329 :           if (t == current_class_ptr
    6573                 :      11329 :               && ((ort != C_ORT_OMP_DECLARE_SIMD && ort != C_ORT_ACC)
    6574                 :        128 :                   || (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_LINEAR
    6575                 :         80 :                       && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_UNIFORM)))
    6576                 :            :             {
    6577                 :         32 :               error_at (OMP_CLAUSE_LOCATION (c),
    6578                 :            :                         "%<this%> allowed in OpenMP only in %<declare simd%>"
    6579                 :            :                         " clauses");
    6580                 :         32 :               remove = true;
    6581                 :         32 :               break;
    6582                 :            :             }
    6583                 :      11297 :           if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL
    6584                 :        592 :               && (!field_ok || TREE_CODE (t) != FIELD_DECL))
    6585                 :            :             {
    6586                 :         76 :               if (processing_template_decl && TREE_CODE (t) != OVERLOAD)
    6587                 :            :                 break;
    6588                 :         52 :               if (DECL_P (t))
    6589                 :         20 :                 error_at (OMP_CLAUSE_LOCATION (c),
    6590                 :            :                           "%qD is not a variable in clause %qs", t,
    6591                 :         20 :                           omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    6592                 :            :               else
    6593                 :         32 :                 error_at (OMP_CLAUSE_LOCATION (c),
    6594                 :            :                           "%qE is not a variable in clause %qs", t,
    6595                 :         32 :                           omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    6596                 :            :               remove = true;
    6597                 :            :             }
    6598                 :      11221 :           else if ((ort == C_ORT_ACC
    6599                 :       1952 :                     && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
    6600                 :      11392 :                    || (ort == C_ORT_OMP
    6601                 :       8108 :                        && (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_USE_DEVICE_PTR
    6602                 :       8088 :                            || (OMP_CLAUSE_CODE (c)
    6603                 :            :                                == OMP_CLAUSE_USE_DEVICE_ADDR))))
    6604                 :            :             {
    6605                 :       1831 :               if (bitmap_bit_p (&oacc_reduction_head, DECL_UID (t)))
    6606                 :            :                 {
    6607                 :          8 :                   error_at (OMP_CLAUSE_LOCATION (c),
    6608                 :            :                             ort == C_ORT_ACC
    6609                 :            :                             ? "%qD appears more than once in reduction clauses"
    6610                 :            :                             : "%qD appears more than once in data clauses",
    6611                 :            :                             t);
    6612                 :          8 :                   remove = true;
    6613                 :            :                 }
    6614                 :            :               else
    6615                 :       1823 :                 bitmap_set_bit (&oacc_reduction_head, DECL_UID (t));
    6616                 :            :             }
    6617                 :       9390 :           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
    6618                 :       9326 :                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
    6619                 :      18712 :                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
    6620                 :            :             {
    6621                 :         68 :               error_at (OMP_CLAUSE_LOCATION (c),
    6622                 :            :                         "%qD appears more than once in data clauses", t);
    6623                 :         68 :               remove = true;
    6624                 :            :             }
    6625                 :       9322 :           else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
    6626                 :      10854 :                    && bitmap_bit_p (&map_head, DECL_UID (t)))
    6627                 :            :             {
    6628                 :          0 :               if (ort == C_ORT_ACC)
    6629                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    6630                 :            :                           "%qD appears more than once in data clauses", t);
    6631                 :            :               else
    6632                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    6633                 :            :                           "%qD appears both in data and map clauses", t);
    6634                 :            :               remove = true;
    6635                 :            :             }
    6636                 :            :           else
    6637                 :       9322 :             bitmap_set_bit (&generic_head, DECL_UID (t));
    6638                 :      11273 :           if (!field_ok)
    6639                 :            :             break;
    6640                 :       8060 :         handle_field_decl:
    6641                 :      11753 :           if (!remove
    6642                 :      11589 :               && TREE_CODE (t) == FIELD_DECL
    6643                 :      12810 :               && t == OMP_CLAUSE_DECL (c))
    6644                 :            :             {
    6645                 :        830 :               OMP_CLAUSE_DECL (c)
    6646                 :       1660 :                 = omp_privatize_field (t, (OMP_CLAUSE_CODE (c)
    6647                 :            :                                            == OMP_CLAUSE_SHARED));
    6648                 :        830 :               if (OMP_CLAUSE_DECL (c) == error_mark_node)
    6649                 :          0 :                 remove = true;
    6650                 :            :             }
    6651                 :            :           break;
    6652                 :            : 
    6653                 :       2072 :         case OMP_CLAUSE_FIRSTPRIVATE:
    6654                 :       2072 :           t = omp_clause_decl_field (OMP_CLAUSE_DECL (c));
    6655                 :       2072 :           if (t)
    6656                 :         55 :             omp_note_field_privatization (t, OMP_CLAUSE_DECL (c));
    6657                 :            :           else
    6658                 :       2017 :             t = OMP_CLAUSE_DECL (c);
    6659                 :       2072 :           if (ort != C_ORT_ACC && t == current_class_ptr)
    6660                 :            :             {
    6661                 :          8 :               error_at (OMP_CLAUSE_LOCATION (c),
    6662                 :            :                         "%<this%> allowed in OpenMP only in %<declare simd%>"
    6663                 :            :                         " clauses");
    6664                 :          8 :               remove = true;
    6665                 :          8 :               break;
    6666                 :            :             }
    6667                 :       2064 :           if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL
    6668                 :        330 :               && ((ort & C_ORT_OMP_DECLARE_SIMD) != C_ORT_OMP
    6669                 :        330 :                   || TREE_CODE (t) != FIELD_DECL))
    6670                 :            :             {
    6671                 :         53 :               if (processing_template_decl && TREE_CODE (t) != OVERLOAD)
    6672                 :            :                 break;
    6673                 :         24 :               if (DECL_P (t))
    6674                 :         16 :                 error_at (OMP_CLAUSE_LOCATION (c),
    6675                 :            :                           "%qD is not a variable in clause %<firstprivate%>",
    6676                 :            :                           t);
    6677                 :            :               else
    6678                 :          8 :                 error_at (OMP_CLAUSE_LOCATION (c),
    6679                 :            :                           "%qE is not a variable in clause %<firstprivate%>",
    6680                 :            :                           t);
    6681                 :            :               remove = true;
    6682                 :            :             }
    6683                 :       2011 :           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
    6684                 :       4014 :                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
    6685                 :            :             {
    6686                 :         12 :               error_at (OMP_CLAUSE_LOCATION (c),
    6687                 :            :                         "%qD appears more than once in data clauses", t);
    6688                 :         12 :               remove = true;
    6689                 :            :             }
    6690                 :       1999 :           else if (bitmap_bit_p (&map_head, DECL_UID (t)))
    6691                 :            :             {
    6692                 :         12 :               if (ort == C_ORT_ACC)
    6693                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    6694                 :            :                           "%qD appears more than once in data clauses", t);
    6695                 :            :               else
    6696                 :         12 :                 error_at (OMP_CLAUSE_LOCATION (c),
    6697                 :            :                           "%qD appears both in data and map clauses", t);
    6698                 :            :               remove = true;
    6699                 :            :             }
    6700                 :            :           else
    6701                 :       1987 :             bitmap_set_bit (&firstprivate_head, DECL_UID (t));
    6702                 :       2035 :           goto handle_field_decl;
    6703                 :            : 
    6704                 :       1699 :         case OMP_CLAUSE_LASTPRIVATE:
    6705                 :       1699 :           t = omp_clause_decl_field (OMP_CLAUSE_DECL (c));
    6706                 :       1699 :           if (t)
    6707                 :         40 :             omp_note_field_privatization (t, OMP_CLAUSE_DECL (c));
    6708                 :            :           else
    6709                 :       1659 :             t = OMP_CLAUSE_DECL (c);
    6710                 :       1699 :           if (ort != C_ORT_ACC && t == current_class_ptr)
    6711                 :            :             {
    6712                 :          8 :               error_at (OMP_CLAUSE_LOCATION (c),
    6713                 :            :                         "%<this%> allowed in OpenMP only in %<declare simd%>"
    6714                 :            :                         " clauses");
    6715                 :          8 :               remove = true;
    6716                 :          8 :               break;
    6717                 :            :             }
    6718                 :       1691 :           if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL
    6719                 :        325 :               && ((ort & C_ORT_OMP_DECLARE_SIMD) != C_ORT_OMP
    6720                 :        325 :                   || TREE_CODE (t) != FIELD_DECL))
    6721                 :            :             {
    6722                 :         45 :               if (processing_template_decl && TREE_CODE (t) != OVERLOAD)
    6723                 :            :                 break;
    6724                 :         12 :               if (DECL_P (t))
    6725                 :          4 :                 error_at (OMP_CLAUSE_LOCATION (c),
    6726                 :            :                           "%qD is not a variable in clause %<lastprivate%>",
    6727                 :            :                           t);
    6728                 :            :               else
    6729                 :          8 :                 error_at (OMP_CLAUSE_LOCATION (c),
    6730                 :            :                           "%qE is not a variable in clause %<lastprivate%>",
    6731                 :            :                           t);
    6732                 :            :               remove = true;
    6733                 :            :             }
    6734                 :       1646 :           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
    6735                 :       3284 :                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
    6736                 :            :             {
    6737                 :         16 :               error_at (OMP_CLAUSE_LOCATION (c),
    6738                 :            :                         "%qD appears more than once in data clauses", t);
    6739                 :         16 :               remove = true;
    6740                 :            :             }
    6741                 :            :           else
    6742                 :       1630 :             bitmap_set_bit (&lastprivate_head, DECL_UID (t));
    6743                 :       1658 :           goto handle_field_decl;
    6744                 :            : 
    6745                 :       1318 :         case OMP_CLAUSE_IF:
    6746                 :       1318 :           t = OMP_CLAUSE_IF_EXPR (c);
    6747                 :       1318 :           t = maybe_convert_cond (t);
    6748                 :       1318 :           if (t == error_mark_node)
    6749                 :            :             remove = true;
    6750                 :       1314 :           else if (!processing_template_decl)
    6751                 :       1256 :             t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    6752                 :       1318 :           OMP_CLAUSE_IF_EXPR (c) = t;
    6753                 :       1318 :           break;
    6754                 :            : 
    6755                 :        109 :         case OMP_CLAUSE_FINAL:
    6756                 :        109 :           t = OMP_CLAUSE_FINAL_EXPR (c);
    6757                 :        109 :           t = maybe_convert_cond (t);
    6758                 :        109 :           if (t == error_mark_node)
    6759                 :            :             remove = true;
    6760                 :        109 :           else if (!processing_template_decl)
    6761                 :        101 :             t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    6762                 :        109 :           OMP_CLAUSE_FINAL_EXPR (c) = t;
    6763                 :        109 :           break;
    6764                 :            : 
    6765                 :       1280 :         case OMP_CLAUSE_GANG:
    6766                 :            :           /* Operand 1 is the gang static: argument.  */
    6767                 :       1280 :           t = OMP_CLAUSE_OPERAND (c, 1);
    6768                 :       1280 :           if (t != NULL_TREE)
    6769                 :            :             {
    6770                 :        136 :               if (t == error_mark_node)
    6771                 :            :                 remove = true;
    6772                 :        136 :               else if (!type_dependent_expression_p (t)
    6773                 :        272 :                        && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
    6774                 :            :                 {
    6775                 :          8 :                   error_at (OMP_CLAUSE_LOCATION (c),
    6776                 :            :                             "%<gang%> static expression must be integral");
    6777                 :          8 :                   remove = true;
    6778                 :            :                 }
    6779                 :            :               else
    6780                 :            :                 {
    6781                 :        128 :                   t = mark_rvalue_use (t);
    6782                 :        128 :                   if (!processing_template_decl)
    6783                 :            :                     {
    6784                 :        128 :                       t = maybe_constant_value (t);
    6785                 :        128 :                       if (TREE_CODE (t) == INTEGER_CST
    6786                 :        110 :                           && tree_int_cst_sgn (t) != 1
    6787                 :        181 :                           && t != integer_minus_one_node)
    6788                 :            :                         {
    6789                 :          0 :                           warning_at (OMP_CLAUSE_LOCATION (c), 0,
    6790                 :            :                                       "%<gang%> static value must be "
    6791                 :            :                                       "positive");
    6792                 :          0 :                           t = integer_one_node;
    6793                 :            :                         }
    6794                 :        128 :                       t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    6795                 :            :                     }
    6796                 :            :                 }
    6797                 :        136 :               OMP_CLAUSE_OPERAND (c, 1) = t;
    6798                 :            :             }
    6799                 :            :           /* Check operand 0, the num argument.  */
    6800                 :            :           /* FALLTHRU */
    6801                 :            : 
    6802                 :       3760 :         case OMP_CLAUSE_WORKER:
    6803                 :       3760 :         case OMP_CLAUSE_VECTOR:
    6804                 :       3760 :           if (OMP_CLAUSE_OPERAND (c, 0) == NULL_TREE)
    6805                 :            :             break;
    6806                 :            :           /* FALLTHRU */
    6807                 :            : 
    6808                 :       2124 :         case OMP_CLAUSE_NUM_TASKS:
    6809                 :       2124 :         case OMP_CLAUSE_NUM_TEAMS:
    6810                 :       2124 :         case OMP_CLAUSE_NUM_THREADS:
    6811                 :       2124 :         case OMP_CLAUSE_NUM_GANGS:
    6812                 :       2124 :         case OMP_CLAUSE_NUM_WORKERS:
    6813                 :       2124 :         case OMP_CLAUSE_VECTOR_LENGTH:
    6814                 :       2124 :           t = OMP_CLAUSE_OPERAND (c, 0);
    6815                 :       2124 :           if (t == error_mark_node)
    6816                 :            :             remove = true;
    6817                 :       2124 :           else if (!type_dependent_expression_p (t)
    6818                 :       4192 :                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
    6819                 :            :             {
    6820                 :        124 :              switch (OMP_CLAUSE_CODE (c))
    6821                 :            :                 {
    6822                 :         16 :                 case OMP_CLAUSE_GANG:
    6823                 :         16 :                   error_at (OMP_CLAUSE_LOCATION (c),
    6824                 :         16 :                             "%<gang%> num expression must be integral"); break;
    6825                 :         16 :                 case OMP_CLAUSE_VECTOR:
    6826                 :         16 :                   error_at (OMP_CLAUSE_LOCATION (c),
    6827                 :            :                             "%<vector%> length expression must be integral");
    6828                 :         16 :                   break;
    6829                 :         16 :                 case OMP_CLAUSE_WORKER:
    6830                 :         16 :                   error_at (OMP_CLAUSE_LOCATION (c),
    6831                 :            :                             "%<worker%> num expression must be integral");
    6832                 :         16 :                   break;
    6833                 :         76 :                 default:
    6834                 :         76 :                   error_at (OMP_CLAUSE_LOCATION (c),
    6835                 :            :                             "%qs expression must be integral",
    6836                 :         76 :                             omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    6837                 :            :                 }
    6838                 :            :               remove = true;
    6839                 :            :             }
    6840                 :            :           else
    6841                 :            :             {
    6842                 :       2000 :               t = mark_rvalue_use (t);
    6843                 :       2000 :               if (!processing_template_decl)
    6844                 :            :                 {
    6845                 :       1865 :                   t = maybe_constant_value (t);
    6846                 :       1865 :                   if (TREE_CODE (t) == INTEGER_CST
    6847                 :       1865 :                       && tree_int_cst_sgn (t) != 1)
    6848                 :            :                     {
    6849                 :         64 :                       switch (OMP_CLAUSE_CODE (c))
    6850                 :            :                         {
    6851                 :          4 :                         case OMP_CLAUSE_GANG:
    6852                 :          4 :                           warning_at (OMP_CLAUSE_LOCATION (c), 0,
    6853                 :            :                                       "%<gang%> num value must be positive");
    6854                 :          4 :                           break;
    6855                 :          0 :                         case OMP_CLAUSE_VECTOR:
    6856                 :          0 :                           warning_at (OMP_CLAUSE_LOCATION (c), 0,
    6857                 :            :                                       "%<vector%> length value must be "
    6858                 :            :                                       "positive");
    6859                 :          0 :                           break;
    6860                 :          0 :                         case OMP_CLAUSE_WORKER:
    6861                 :          0 :                           warning_at (OMP_CLAUSE_LOCATION (c), 0,
    6862                 :            :                                       "%<worker%> num value must be "
    6863                 :            :                                       "positive");
    6864                 :          0 :                           break;
    6865                 :         60 :                         default:
    6866                 :         60 :                           warning_at (OMP_CLAUSE_LOCATION (c), 0,
    6867                 :            :                                       "%qs value must be positive",
    6868                 :            :                                       omp_clause_code_name
    6869                 :         60 :                                       [OMP_CLAUSE_CODE (c)]);
    6870                 :            :                         }
    6871                 :         64 :                       t = integer_one_node;
    6872                 :            :                     }
    6873                 :       1865 :                   t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    6874                 :            :                 }
    6875                 :       2000 :               OMP_CLAUSE_OPERAND (c, 0) = t;
    6876                 :            :             }
    6877                 :            :           break;
    6878                 :            : 
    6879                 :       3689 :         case OMP_CLAUSE_SCHEDULE:
    6880                 :       3689 :           t = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c);
    6881                 :       3689 :           if (t == NULL)
    6882                 :            :             ;
    6883                 :       1924 :           else if (t == error_mark_node)
    6884                 :            :             remove = true;
    6885                 :       1924 :           else if (!type_dependent_expression_p (t)
    6886                 :       3828 :                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
    6887                 :            :             {
    6888                 :         12 :               error_at (OMP_CLAUSE_LOCATION (c),
    6889                 :            :                         "schedule chunk size expression must be integral");
    6890                 :         12 :               remove = true;
    6891                 :            :             }
    6892                 :            :           else
    6893                 :            :             {
    6894                 :       1912 :               t = mark_rvalue_use (t);
    6895                 :       1912 :               if (!processing_template_decl)
    6896                 :            :                 {
    6897                 :       1867 :                   t = maybe_constant_value (t);
    6898                 :       1867 :                   if (TREE_CODE (t) == INTEGER_CST
    6899                 :       1867 :                       && tree_int_cst_sgn (t) != 1)
    6900                 :            :                   {
    6901                 :          8 :                     warning_at (OMP_CLAUSE_LOCATION (c), 0,
    6902                 :            :                               "chunk size value must be positive");
    6903                 :          8 :                     t = integer_one_node;
    6904                 :            :                   }
    6905                 :       1867 :                   t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    6906                 :            :                 }
    6907                 :       1912 :               OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
    6908                 :            :             }
    6909                 :       1924 :           if (!remove)
    6910                 :            :             schedule_seen = true;
    6911                 :            :           break;
    6912                 :            : 
    6913                 :        744 :         case OMP_CLAUSE_SIMDLEN:
    6914                 :        744 :         case OMP_CLAUSE_SAFELEN:
    6915                 :        744 :           t = OMP_CLAUSE_OPERAND (c, 0);
    6916                 :        744 :           if (t == error_mark_node)
    6917                 :            :             remove = true;
    6918                 :        744 :           else if (!type_dependent_expression_p (t)
    6919                 :       1488 :                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
    6920                 :            :             {
    6921                 :          0 :               error_at (OMP_CLAUSE_LOCATION (c),
    6922                 :            :                         "%qs length expression must be integral",
    6923                 :          0 :                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    6924                 :          0 :               remove = true;
    6925                 :            :             }
    6926                 :            :           else
    6927                 :            :             {
    6928                 :        744 :               t = mark_rvalue_use (t);
    6929                 :        744 :               if (!processing_template_decl)
    6930                 :            :                 {
    6931                 :        679 :                   t = maybe_constant_value (t);
    6932                 :        679 :                   if (TREE_CODE (t) != INTEGER_CST
    6933                 :        679 :                       || tree_int_cst_sgn (t) != 1)
    6934                 :            :                     {
    6935                 :          0 :                       error_at (OMP_CLAUSE_LOCATION (c),
    6936                 :            :                                 "%qs length expression must be positive "
    6937                 :            :                                 "constant integer expression",
    6938                 :          0 :                                 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    6939                 :          0 :                       remove = true;
    6940                 :            :                     }
    6941                 :            :                 }
    6942                 :        744 :               OMP_CLAUSE_OPERAND (c, 0) = t;
    6943                 :        744 :               if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SAFELEN)
    6944                 :        241 :                 safelen = c;
    6945                 :            :             }
    6946                 :            :           break;
    6947                 :            : 
    6948                 :        370 :         case OMP_CLAUSE_ASYNC:
    6949                 :        370 :           t = OMP_CLAUSE_ASYNC_EXPR (c);
    6950                 :        370 :           if (t == error_mark_node)
    6951                 :            :             remove = true;
    6952                 :        326 :           else if (!type_dependent_expression_p (t)
    6953                 :        652 :                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
    6954                 :            :             {
    6955                 :         16 :               error_at (OMP_CLAUSE_LOCATION (c),
    6956                 :            :                         "%<async%> expression must be integral");
    6957                 :         16 :               remove = true;
    6958                 :            :             }
    6959                 :            :           else
    6960                 :            :             {
    6961                 :        310 :               t = mark_rvalue_use (t);
    6962                 :        310 :               if (!processing_template_decl)
    6963                 :        299 :                 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    6964                 :        310 :               OMP_CLAUSE_ASYNC_EXPR (c) = t;
    6965                 :            :             }
    6966                 :            :           break;
    6967                 :            : 
    6968                 :        214 :         case OMP_CLAUSE_WAIT:
    6969                 :        214 :           t = OMP_CLAUSE_WAIT_EXPR (c);
    6970                 :        214 :           if (t == error_mark_node)
    6971                 :            :             remove = true;
    6972                 :        214 :           else if (!processing_template_decl)
    6973                 :        204 :             t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    6974                 :        214 :           OMP_CLAUSE_WAIT_EXPR (c) = t;
    6975                 :        214 :           break;
    6976                 :            : 
    6977                 :        345 :         case OMP_CLAUSE_THREAD_LIMIT:
    6978                 :        345 :           t = OMP_CLAUSE_THREAD_LIMIT_EXPR (c);
    6979                 :        345 :           if (t == error_mark_node)
    6980                 :            :             remove = true;
    6981                 :        345 :           else if (!type_dependent_expression_p (t)
    6982                 :        690 :                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
    6983                 :            :             {
    6984                 :          0 :               error_at (OMP_CLAUSE_LOCATION (c),
    6985                 :            :                         "%<thread_limit%> expression must be integral");
    6986                 :          0 :               remove = true;
    6987                 :            :             }
    6988                 :            :           else
    6989                 :            :             {
    6990                 :        345 :               t = mark_rvalue_use (t);
    6991                 :        345 :               if (!processing_template_decl)
    6992                 :            :                 {
    6993                 :        293 :                   t = maybe_constant_value (t);
    6994                 :        293 :                   if (TREE_CODE (t) == INTEGER_CST
    6995                 :        293 :                       && tree_int_cst_sgn (t) != 1)
    6996                 :            :                     {
    6997                 :          0 :                       warning_at (OMP_CLAUSE_LOCATION (c), 0,
    6998                 :            :                                   "%<thread_limit%> value must be positive");
    6999                 :          0 :                       t = integer_one_node;
    7000                 :            :                     }
    7001                 :        293 :                   t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    7002                 :            :                 }
    7003                 :        345 :               OMP_CLAUSE_THREAD_LIMIT_EXPR (c) = t;
    7004                 :            :             }
    7005                 :            :           break;
    7006                 :            : 
    7007                 :        220 :         case OMP_CLAUSE_DEVICE:
    7008                 :        220 :           t = OMP_CLAUSE_DEVICE_ID (c);
    7009                 :        220 :           if (t == error_mark_node)
    7010                 :            :             remove = true;
    7011                 :        220 :           else if (!type_dependent_expression_p (t)
    7012                 :        440 :                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
    7013                 :            :             {
    7014                 :          0 :               error_at (OMP_CLAUSE_LOCATION (c),
    7015                 :            :                         "%<device%> id must be integral");
    7016                 :          0 :               remove = true;
    7017                 :            :             }
    7018                 :            :           else
    7019                 :            :             {
    7020                 :        220 :               t = mark_rvalue_use (t);
    7021                 :        220 :               if (!processing_template_decl)
    7022                 :        220 :                 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    7023                 :        220 :               OMP_CLAUSE_DEVICE_ID (c) = t;
    7024                 :            :             }
    7025                 :            :           break;
    7026                 :            : 
    7027                 :       1657 :         case OMP_CLAUSE_DIST_SCHEDULE:
    7028                 :       1657 :           t = OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c);
    7029                 :       1657 :           if (t == NULL)
    7030                 :            :             ;
    7031                 :       1645 :           else if (t == error_mark_node)
    7032                 :            :             remove = true;
    7033                 :       1645 :           else if (!type_dependent_expression_p (t)
    7034                 :       3290 :                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
    7035                 :            :             {
    7036                 :          0 :               error_at (OMP_CLAUSE_LOCATION (c),
    7037                 :            :                         "%<dist_schedule%> chunk size expression must be "
    7038                 :            :                         "integral");
    7039                 :          0 :               remove = true;
    7040                 :            :             }
    7041                 :            :           else
    7042                 :            :             {
    7043                 :       1645 :               t = mark_rvalue_use (t);
    7044                 :       1645 :               if (!processing_template_decl)
    7045                 :       1645 :                 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    7046                 :       1645 :               OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c) = t;
    7047                 :            :             }
    7048                 :            :           break;
    7049                 :            : 
    7050                 :        608 :         case OMP_CLAUSE_ALIGNED:
    7051                 :        608 :           t = OMP_CLAUSE_DECL (c);
    7052                 :        608 :           if (t == current_class_ptr && ort != C_ORT_OMP_DECLARE_SIMD)
    7053                 :            :             {
    7054                 :          0 :               error_at (OMP_CLAUSE_LOCATION (c),
    7055                 :            :                         "%<this%> allowed in OpenMP only in %<declare simd%>"
    7056                 :            :                         " clauses");
    7057                 :          0 :               remove = true;
    7058                 :          0 :               break;
    7059                 :            :             }
    7060                 :        608 :           if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
    7061                 :            :             {
    7062                 :          0 :               if (processing_template_decl && TREE_CODE (t) != OVERLOAD)
    7063                 :            :                 break;
    7064                 :          0 :               if (DECL_P (t))
    7065                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7066                 :            :                           "%qD is not a variable in %<aligned%> clause", t);
    7067                 :            :               else
    7068                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7069                 :            :                           "%qE is not a variable in %<aligned%> clause", t);
    7070                 :            :               remove = true;
    7071                 :            :             }
    7072                 :        608 :           else if (!type_dependent_expression_p (t)
    7073                 :        588 :                    && !TYPE_PTR_P (TREE_TYPE (t))
    7074                 :        126 :                    && TREE_CODE (TREE_TYPE (t)) != ARRAY_TYPE
    7075                 :        668 :                    && (!TYPE_REF_P (TREE_TYPE (t))
    7076                 :         36 :                        || (!INDIRECT_TYPE_P (TREE_TYPE (TREE_TYPE (t)))
    7077                 :         28 :                            && (TREE_CODE (TREE_TYPE (TREE_TYPE (t)))
    7078                 :            :                                != ARRAY_TYPE))))
    7079                 :            :             {
    7080                 :         44 :               error_at (OMP_CLAUSE_LOCATION (c),
    7081                 :            :                         "%qE in %<aligned%> clause is neither a pointer nor "
    7082                 :            :                         "an array nor a reference to pointer or array", t);
    7083                 :         44 :               remove = true;
    7084                 :            :             }
    7085                 :        564 :           else if (bitmap_bit_p (&aligned_head, DECL_UID (t)))
    7086                 :            :             {
    7087                 :          0 :               error_at (OMP_CLAUSE_LOCATION (c),
    7088                 :            :                         "%qD appears more than once in %<aligned%> clauses",
    7089                 :            :                         t);
    7090                 :          0 :               remove = true;
    7091                 :            :             }
    7092                 :            :           else
    7093                 :        564 :             bitmap_set_bit (&aligned_head, DECL_UID (t));
    7094                 :        608 :           t = OMP_CLAUSE_ALIGNED_ALIGNMENT (c);
    7095                 :        608 :           if (t == error_mark_node)
    7096                 :            :             remove = true;
    7097                 :        608 :           else if (t == NULL_TREE)
    7098                 :            :             break;
    7099                 :        532 :           else if (!type_dependent_expression_p (t)
    7100                 :       1064 :                    && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
    7101                 :            :             {
    7102                 :          0 :               error_at (OMP_CLAUSE_LOCATION (c),
    7103                 :            :                         "%<aligned%> clause alignment expression must "
    7104                 :            :                         "be integral");
    7105                 :          0 :               remove = true;
    7106                 :            :             }
    7107                 :            :           else
    7108                 :            :             {
    7109                 :        532 :               t = mark_rvalue_use (t);
    7110                 :        532 :               if (!processing_template_decl)
    7111                 :            :                 {
    7112                 :        464 :                   t = maybe_constant_value (t);
    7113                 :        464 :                   if (TREE_CODE (t) != INTEGER_CST
    7114                 :        464 :                       || tree_int_cst_sgn (t) != 1)
    7115                 :            :                     {
    7116                 :          0 :                       error_at (OMP_CLAUSE_LOCATION (c),
    7117                 :            :                                 "%<aligned%> clause alignment expression must "
    7118                 :            :                                 "be positive constant integer expression");
    7119                 :          0 :                       remove = true;
    7120                 :            :                     }
    7121                 :            :                   else
    7122                 :        464 :                     t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
    7123                 :            :                 }
    7124                 :        532 :               OMP_CLAUSE_ALIGNED_ALIGNMENT (c) = t;
    7125                 :            :             }
    7126                 :            :           break;
    7127                 :            : 
    7128                 :        124 :         case OMP_CLAUSE_NONTEMPORAL:
    7129                 :        124 :           t = OMP_CLAUSE_DECL (c);
    7130                 :        124 :           if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
    7131                 :            :             {
    7132                 :          0 :               if (processing_template_decl && TREE_CODE (t) != OVERLOAD)
    7133                 :            :                 break;
    7134                 :          0 :               if (DECL_P (t))
    7135                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7136                 :            :                           "%qD is not a variable in %<nontemporal%> clause",
    7137                 :            :                           t);
    7138                 :            :               else
    7139                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7140                 :            :                           "%qE is not a variable in %<nontemporal%> clause",
    7141                 :            :                           t);
    7142                 :            :               remove = true;
    7143                 :            :             }
    7144                 :        124 :           else if (bitmap_bit_p (&oacc_reduction_head, DECL_UID (t)))
    7145                 :            :             {
    7146                 :          8 :               error_at (OMP_CLAUSE_LOCATION (c),
    7147                 :            :                         "%qD appears more than once in %<nontemporal%> "
    7148                 :            :                         "clauses", t);
    7149                 :          8 :               remove = true;
    7150                 :            :             }
    7151                 :            :           else
    7152                 :        116 :             bitmap_set_bit (&oacc_reduction_head, DECL_UID (t));
    7153                 :            :           break;
    7154                 :            : 
    7155                 :       2213 :         case OMP_CLAUSE_DEPEND:
    7156                 :       2213 :           t = OMP_CLAUSE_DECL (c);
    7157                 :       2213 :           if (t == NULL_TREE)
    7158                 :            :             {
    7159                 :        220 :               gcc_assert (OMP_CLAUSE_DEPEND_KIND (c)
    7160                 :            :                           == OMP_CLAUSE_DEPEND_SOURCE);
    7161                 :            :               break;
    7162                 :            :             }
    7163                 :       1993 :           if (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK)
    7164                 :            :             {
    7165                 :        242 :               if (cp_finish_omp_clause_depend_sink (c))
    7166                 :          0 :                 remove = true;
    7167                 :            :               break;
    7168                 :            :             }
    7169                 :       1751 :           if (TREE_CODE (t) == TREE_LIST
    7170                 :       1274 :               && TREE_PURPOSE (t)
    7171                 :       2865 :               && TREE_CODE (TREE_PURPOSE (t)) == TREE_VEC)
    7172                 :            :             {
    7173                 :        542 :               if (TREE_PURPOSE (t) != last_iterators)
    7174                 :        465 :                 last_iterators_remove
    7175                 :        465 :                   = cp_omp_finish_iterators (TREE_PURPOSE (t));
    7176                 :        542 :               last_iterators = TREE_PURPOSE (t);
    7177                 :        542 :               t = TREE_VALUE (t);
    7178                 :        542 :               if (last_iterators_remove)
    7179                 :        132 :                 t = error_mark_node;
    7180                 :            :             }
    7181                 :            :           else
    7182                 :            :             last_iterators = NULL_TREE;
    7183                 :            : 
    7184                 :       1751 :           if (TREE_CODE (t) == TREE_LIST)
    7185                 :            :             {
    7186                 :        916 :               if (handle_omp_array_sections (c, ort))
    7187                 :            :                 remove = true;
    7188                 :        624 :               else if (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_DEPOBJ)
    7189                 :            :                 {
    7190                 :          8 :                   error_at (OMP_CLAUSE_LOCATION (c),
    7191                 :            :                             "%<depend%> clause with %<depobj%> dependence "
    7192                 :            :                             "type on array section");
    7193                 :          8 :                   remove = true;
    7194                 :            :                 }
    7195                 :            :               break;
    7196                 :            :             }
    7197                 :        835 :           if (t == error_mark_node)
    7198                 :            :             remove = true;
    7199                 :        703 :           else if (ort != C_ORT_ACC && t == current_class_ptr)
    7200                 :            :             {
    7201                 :          8 :               error_at (OMP_CLAUSE_LOCATION (c),
    7202                 :            :                         "%<this%> allowed in OpenMP only in %<declare simd%>"
    7203                 :            :                         " clauses");
    7204                 :          8 :               remove = true;
    7205                 :            :             }
    7206                 :        695 :           else if (processing_template_decl && TREE_CODE (t) != OVERLOAD)
    7207                 :            :             break;
    7208                 :        459 :           else if (!lvalue_p (t))
    7209                 :            :             {
    7210                 :          4 :               if (DECL_P (t))
    7211                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7212                 :            :                           "%qD is not lvalue expression nor array section "
    7213                 :            :                           "in %<depend%> clause", t);
    7214                 :            :               else
    7215                 :          4 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7216                 :            :                           "%qE is not lvalue expression nor array section "
    7217                 :            :                           "in %<depend%> clause", t);
    7218                 :            :               remove = true;
    7219                 :            :             }
    7220                 :        455 :           else if (TREE_CODE (t) == COMPONENT_REF
    7221                 :         24 :                    && TREE_CODE (TREE_OPERAND (t, 1)) == FIELD_DECL
    7222                 :        479 :                    && DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
    7223                 :            :             {
    7224                 :          4 :               error_at (OMP_CLAUSE_LOCATION (c),
    7225                 :            :                         "bit-field %qE in %qs clause", t, "depend");
    7226                 :          4 :               remove = true;
    7227                 :            :             }
    7228                 :        451 :           else if (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_DEPOBJ)
    7229                 :            :             {
    7230                 :        144 :               if (!c_omp_depend_t_p (TYPE_REF_P (TREE_TYPE (t))
    7231                 :         10 :                                      ? TREE_TYPE (TREE_TYPE (t))
    7232                 :         72 :                                      : TREE_TYPE (t)))
    7233                 :            :                 {
    7234                 :         16 :                   error_at (OMP_CLAUSE_LOCATION (c),
    7235                 :            :                             "%qE does not have %<omp_depend_t%> type in "
    7236                 :            :                             "%<depend%> clause with %<depobj%> dependence "
    7237                 :            :                             "type", t);
    7238                 :         16 :                   remove = true;
    7239                 :            :                 }
    7240                 :            :             }
    7241                 :        758 :           else if (c_omp_depend_t_p (TYPE_REF_P (TREE_TYPE (t))
    7242                 :          5 :                                      ? TREE_TYPE (TREE_TYPE (t))
    7243                 :        379 :                                      : TREE_TYPE (t)))
    7244                 :            :             {
    7245                 :         20 :               error_at (OMP_CLAUSE_LOCATION (c),
    7246                 :            :                         "%qE should not have %<omp_depend_t%> type in "
    7247                 :            :                         "%<depend%> clause with dependence type other than "
    7248                 :            :                         "%<depobj%>", t);
    7249                 :         20 :               remove = true;
    7250                 :            :             }
    7251                 :         48 :           if (!remove)
    7252                 :            :             {
    7253                 :        415 :               tree addr = cp_build_addr_expr (t, tf_warning_or_error);
    7254                 :        415 :               if (addr == error_mark_node)
    7255                 :            :                 remove = true;
    7256                 :            :               else
    7257                 :            :                 {
    7258                 :        415 :                   t = cp_build_indirect_ref (OMP_CLAUSE_LOCATION (c),
    7259                 :            :                                              addr, RO_UNARY_STAR,
    7260                 :            :                                              tf_warning_or_error);
    7261                 :        415 :                   if (t == error_mark_node)
    7262                 :            :                     remove = true;
    7263                 :        415 :                   else if (TREE_CODE (OMP_CLAUSE_DECL (c)) == TREE_LIST
    7264                 :        118 :                            && TREE_PURPOSE (OMP_CLAUSE_DECL (c))
    7265                 :        533 :                            && (TREE_CODE (TREE_PURPOSE (OMP_CLAUSE_DECL (c)))
    7266                 :            :                                == TREE_VEC))
    7267                 :        118 :                     TREE_VALUE (OMP_CLAUSE_DECL (c)) = t;
    7268                 :            :                   else
    7269                 :        297 :                     OMP_CLAUSE_DECL (c) = t;
    7270                 :            :                 }
    7271                 :            :             }
    7272                 :            :           break;
    7273                 :            : 
    7274                 :      11314 :         case OMP_CLAUSE_MAP:
    7275                 :      11314 :         case OMP_CLAUSE_TO:
    7276                 :      11314 :         case OMP_CLAUSE_FROM:
    7277                 :      11314 :         case OMP_CLAUSE__CACHE_:
    7278                 :      11314 :           t = OMP_CLAUSE_DECL (c);
    7279                 :      11314 :           if (TREE_CODE (t) == TREE_LIST)
    7280                 :            :             {
    7281                 :       2822 :               if (handle_omp_array_sections (c, ort))
    7282                 :            :                 remove = true;
    7283                 :            :               else
    7284                 :            :                 {
    7285                 :       2590 :                   t = OMP_CLAUSE_DECL (c);
    7286                 :       2590 :                   if (TREE_CODE (t) != TREE_LIST
    7287                 :       2430 :                       && !type_dependent_expression_p (t)
    7288                 :       5020 :                       && !cp_omp_mappable_type (TREE_TYPE (t)))
    7289                 :            :                     {
    7290                 :          0 :                       error_at (OMP_CLAUSE_LOCATION (c),
    7291                 :            :                                 "array section does not have mappable type "
    7292                 :            :                                 "in %qs clause",
    7293                 :          0 :                                 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7294                 :          0 :                       cp_omp_emit_unmappable_type_notes (TREE_TYPE (t));
    7295                 :          0 :                       remove = true;
    7296                 :            :                     }
    7297                 :       3433 :                   while (TREE_CODE (t) == ARRAY_REF)
    7298                 :        843 :                     t = TREE_OPERAND (t, 0);
    7299                 :       2590 :                   if (TREE_CODE (t) == COMPONENT_REF
    7300                 :       2661 :                       && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
    7301                 :            :                     {
    7302                 :        147 :                       while (TREE_CODE (t) == COMPONENT_REF)
    7303                 :         76 :                         t = TREE_OPERAND (t, 0);
    7304                 :         71 :                       if (REFERENCE_REF_P (t))
    7305                 :          3 :                         t = TREE_OPERAND (t, 0);
    7306                 :         71 :                       if (bitmap_bit_p (&map_field_head, DECL_UID (t)))
    7307                 :            :                         break;
    7308                 :         23 :                       if (bitmap_bit_p (&map_head, DECL_UID (t)))
    7309                 :            :                         {
    7310                 :          0 :                           if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP)
    7311                 :          0 :                             error_at (OMP_CLAUSE_LOCATION (c),
    7312                 :            :                                       "%qD appears more than once in motion"
    7313                 :            :                                       " clauses", t);
    7314                 :          0 :                           else if (ort == C_ORT_ACC)
    7315                 :          0 :                             error_at (OMP_CLAUSE_LOCATION (c),
    7316                 :            :                                       "%qD appears more than once in data"
    7317                 :            :                                       " clauses", t);
    7318                 :            :                           else
    7319                 :          0 :                             error_at (OMP_CLAUSE_LOCATION (c),
    7320                 :            :                                       "%qD appears more than once in map"
    7321                 :            :                                       " clauses", t);
    7322                 :            :                           remove = true;
    7323                 :            :                         }
    7324                 :            :                       else
    7325                 :            :                         {
    7326                 :         23 :                           bitmap_set_bit (&map_head, DECL_UID (t));
    7327                 :         23 :                           bitmap_set_bit (&map_field_head, DECL_UID (t));
    7328                 :            :                         }
    7329                 :            :                     }
    7330                 :            :                 }
    7331                 :       2774 :               if (cp_oacc_check_attachments (c))
    7332                 :         16 :                 remove = true;
    7333                 :            :               break;
    7334                 :            :             }
    7335                 :       8492 :           if (t == error_mark_node)
    7336                 :            :             {
    7337                 :            :               remove = true;
    7338                 :            :               break;
    7339                 :            :             }
    7340                 :            :           /* OpenACC attach / detach clauses must be pointers.  */
    7341                 :       8488 :           if (cp_oacc_check_attachments (c))
    7342                 :            :             {
    7343                 :            :               remove = true;
    7344                 :            :               break;
    7345                 :            :             }
    7346                 :         25 :           if (REFERENCE_REF_P (t)
    7347                 :       8481 :               && TREE_CODE (TREE_OPERAND (t, 0)) == COMPONENT_REF)
    7348                 :            :             {
    7349                 :         25 :               t = TREE_OPERAND (t, 0);
    7350                 :         25 :               OMP_CLAUSE_DECL (c) = t;
    7351                 :            :             }
    7352                 :       8456 :           if (ort == C_ORT_ACC
    7353                 :       4390 :               && TREE_CODE (t) == COMPONENT_REF
    7354                 :       8531 :               && TREE_CODE (TREE_OPERAND (t, 0)) == INDIRECT_REF)
    7355                 :         33 :             t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
    7356                 :       8456 :           if (TREE_CODE (t) == COMPONENT_REF
    7357                 :        623 :               && ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP
    7358                 :         43 :                   || ort == C_ORT_ACC)
    7359                 :       9079 :               && OMP_CLAUSE_CODE (c) != OMP_CLAUSE__CACHE_)
    7360                 :            :             {
    7361                 :        623 :               if (type_dependent_expression_p (t))
    7362                 :            :                 break;
    7363                 :        505 :               if (TREE_CODE (TREE_OPERAND (t, 1)) == FIELD_DECL
    7364                 :        505 :                   && DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
    7365                 :            :                 {
    7366                 :         24 :                   error_at (OMP_CLAUSE_LOCATION (c),
    7367                 :            :                             "bit-field %qE in %qs clause",
    7368                 :         24 :                             t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7369                 :         24 :                   remove = true;
    7370                 :            :                 }
    7371                 :        481 :               else if (!cp_omp_mappable_type (TREE_TYPE (t)))
    7372                 :            :                 {
    7373                 :          0 :                   error_at (OMP_CLAUSE_LOCATION (c),
    7374                 :            :                             "%qE does not have a mappable type in %qs clause",
    7375                 :          0 :                             t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7376                 :          0 :                   cp_omp_emit_unmappable_type_notes (TREE_TYPE (t));
    7377                 :          0 :                   remove = true;
    7378                 :            :                 }
    7379                 :       1042 :               while (TREE_CODE (t) == COMPONENT_REF)
    7380                 :            :                 {
    7381                 :        537 :                   if (TREE_TYPE (TREE_OPERAND (t, 0))
    7382                 :        537 :                       && (TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
    7383                 :            :                           == UNION_TYPE))
    7384                 :            :                     {
    7385                 :          0 :                       error_at (OMP_CLAUSE_LOCATION (c),
    7386                 :            :                                 "%qE is a member of a union", t);
    7387                 :          0 :                       remove = true;
    7388                 :          0 :                       break;
    7389                 :            :                     }
    7390                 :        537 :                   t = TREE_OPERAND (t, 0);
    7391                 :            :                 }
    7392                 :        505 :               if (remove)
    7393                 :            :                 break;
    7394                 :        481 :               if (REFERENCE_REF_P (t))
    7395                 :         54 :                 t = TREE_OPERAND (t, 0);
    7396                 :        481 :               if (VAR_P (t) || TREE_CODE (t) == PARM_DECL)
    7397                 :            :                 {
    7398                 :        480 :                   if (bitmap_bit_p (&map_field_head, DECL_UID (t)))
    7399                 :        287 :                     goto handle_map_references;
    7400                 :            :                 }
    7401                 :            :             }
    7402                 :       8027 :           if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
    7403                 :            :             {
    7404                 :         34 :               if (processing_template_decl && TREE_CODE (t) != OVERLOAD)
    7405                 :            :                 break;
    7406                 :         34 :               if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
    7407                 :         34 :                   && (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_POINTER
    7408                 :         34 :                       || OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_POINTER
    7409                 :          3 :                       || OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ATTACH_DETACH))
    7410                 :            :                 break;
    7411                 :          0 :               if (DECL_P (t))
    7412                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7413                 :            :                           "%qD is not a variable in %qs clause", t,
    7414                 :          0 :                           omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7415                 :            :               else
    7416                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7417                 :            :                           "%qE is not a variable in %qs clause", t,
    7418                 :          0 :                           omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7419                 :            :               remove = true;
    7420                 :            :             }
    7421                 :       7993 :           else if (VAR_P (t) && CP_DECL_THREAD_LOCAL_P (t))
    7422                 :            :             {
    7423                 :          0 :               error_at (OMP_CLAUSE_LOCATION (c),
    7424                 :            :                         "%qD is threadprivate variable in %qs clause", t,
    7425                 :          0 :                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7426                 :          0 :               remove = true;
    7427                 :            :             }
    7428                 :       7993 :           else if (ort != C_ORT_ACC && t == current_class_ptr)
    7429                 :            :             {
    7430                 :         24 :               error_at (OMP_CLAUSE_LOCATION (c),
    7431                 :            :                         "%<this%> allowed in OpenMP only in %<declare simd%>"
    7432                 :            :                         " clauses");
    7433                 :         24 :               remove = true;
    7434                 :         24 :               break;
    7435                 :            :             }
    7436                 :       7969 :           else if (!processing_template_decl
    7437                 :       7705 :                    && !TYPE_REF_P (TREE_TYPE (t))
    7438                 :       7500 :                    && (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP
    7439                 :       5405 :                        || (OMP_CLAUSE_MAP_KIND (c)
    7440                 :            :                            != GOMP_MAP_FIRSTPRIVATE_POINTER))
    7441                 :      13592 :                    && !cxx_mark_addressable (t))
    7442                 :            :             remove = true;
    7443                 :       7969 :           else if (!(OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
    7444                 :       5852 :                      && (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_POINTER
    7445                 :       5852 :                          || (OMP_CLAUSE_MAP_KIND (c)
    7446                 :            :                              == GOMP_MAP_FIRSTPRIVATE_POINTER)))
    7447                 :       6016 :                    && t == OMP_CLAUSE_DECL (c)
    7448                 :       5793 :                    && !type_dependent_expression_p (t)
    7449                 :      19271 :                    && !cp_omp_mappable_type (TYPE_REF_P (TREE_TYPE (t))
    7450                 :         95 :                                              ? TREE_TYPE (TREE_TYPE (t))
    7451                 :       5651 :                                              : TREE_TYPE (t)))
    7452                 :            :             {
    7453                 :         32 :               error_at (OMP_CLAUSE_LOCATION (c),
    7454                 :            :                         "%qD does not have a mappable type in %qs clause", t,
    7455                 :         32 :                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7456                 :         32 :               cp_omp_emit_unmappable_type_notes (TREE_TYPE (t));
    7457                 :         32 :               remove = true;
    7458                 :            :             }
    7459                 :       7937 :           else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
    7460                 :       5828 :                    && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FORCE_DEVICEPTR
    7461                 :        119 :                    && !type_dependent_expression_p (t)
    7462                 :       8048 :                    && !INDIRECT_TYPE_P (TREE_TYPE (t)))
    7463                 :            :             {
    7464                 :          8 :               error_at (OMP_CLAUSE_LOCATION (c),
    7465                 :            :                         "%qD is not a pointer variable", t);
    7466                 :          8 :               remove = true;
    7467                 :            :             }
    7468                 :       7929 :           else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
    7469                 :       7929 :                    && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
    7470                 :            :             {
    7471                 :       1953 :               if (bitmap_bit_p (&generic_head, DECL_UID (t))
    7472                 :       3890 :                   || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
    7473                 :            :                 {
    7474                 :         20 :                   error_at (OMP_CLAUSE_LOCATION (c),
    7475                 :            :                             "%qD appears more than once in data clauses", t);
    7476                 :         20 :                   remove = true;
    7477                 :            :                 }
    7478                 :       1933 :               else if (bitmap_bit_p (&map_head, DECL_UID (t)))
    7479                 :            :                 {
    7480                 :          8 :                   if (ort == C_ORT_ACC)
    7481                 :          4 :                     error_at (OMP_CLAUSE_LOCATION (c),
    7482                 :            :                               "%qD appears more than once in data clauses", t);
    7483                 :            :                   else
    7484                 :          4 :                     error_at (OMP_CLAUSE_LOCATION (c),
    7485                 :            :                               "%qD appears both in data and map clauses", t);
    7486                 :            :                   remove = true;
    7487                 :            :                 }
    7488                 :            :               else
    7489                 :       1925 :                 bitmap_set_bit (&generic_head, DECL_UID (t));
    7490                 :            :             }
    7491                 :       5976 :           else if (bitmap_bit_p (&map_head, DECL_UID (t))
    7492                 :       5976 :                    && (ort != C_ORT_ACC
    7493                 :         14 :                        || !bitmap_bit_p (&map_field_head, DECL_UID (t))))
    7494                 :            :             {
    7495                 :         36 :               if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP)
    7496                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7497                 :            :                           "%qD appears more than once in motion clauses", t);
    7498                 :         36 :               if (ort == C_ORT_ACC)
    7499                 :         12 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7500                 :            :                           "%qD appears more than once in data clauses", t);
    7501                 :            :               else
    7502                 :         24 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7503                 :            :                           "%qD appears more than once in map clauses", t);
    7504                 :            :               remove = true;
    7505                 :            :             }
    7506                 :       5940 :           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
    7507                 :      11876 :                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
    7508                 :            :             {
    7509                 :         28 :               if (ort == C_ORT_ACC)
    7510                 :          0 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7511                 :            :                           "%qD appears more than once in data clauses", t);
    7512                 :            :               else
    7513                 :         28 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7514                 :            :                           "%qD appears both in data and map clauses", t);
    7515                 :            :               remove = true;
    7516                 :            :             }
    7517                 :            :           else
    7518                 :            :             {
    7519                 :       5912 :               bitmap_set_bit (&map_head, DECL_UID (t));
    7520                 :       5912 :               if (t != OMP_CLAUSE_DECL (c)
    7521                 :       5912 :                   && TREE_CODE (OMP_CLAUSE_DECL (c)) == COMPONENT_REF)
    7522                 :        199 :                 bitmap_set_bit (&map_field_head, DECL_UID (t));
    7523                 :            :             }
    7524                 :       8184 :         handle_map_references:
    7525                 :         60 :           if (!remove
    7526                 :       8124 :               && !processing_template_decl
    7527                 :       7858 :               && ort != C_ORT_DECLARE_SIMD
    7528                 :       7858 :               && TYPE_REF_P (TREE_TYPE (OMP_CLAUSE_DECL (c))))
    7529                 :            :             {
    7530                 :        307 :               t = OMP_CLAUSE_DECL (c);
    7531                 :        307 :               if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP)
    7532                 :            :                 {
    7533                 :         18 :                   OMP_CLAUSE_DECL (c) = build_simple_mem_ref (t);
    7534                 :         18 :                   if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
    7535                 :         36 :                     OMP_CLAUSE_SIZE (c)
    7536                 :         36 :                       = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t)));
    7537                 :            :                 }
    7538                 :        289 :               else if (OMP_CLAUSE_MAP_KIND (c)
    7539                 :            :                        != GOMP_MAP_FIRSTPRIVATE_POINTER
    7540                 :        213 :                        && (OMP_CLAUSE_MAP_KIND (c)
    7541                 :            :                            != GOMP_MAP_FIRSTPRIVATE_REFERENCE)
    7542                 :        502 :                        && (OMP_CLAUSE_MAP_KIND (c)
    7543                 :            :                            != GOMP_MAP_ALWAYS_POINTER))
    7544                 :            :                 {
    7545                 :        147 :                   tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
    7546                 :            :                                               OMP_CLAUSE_MAP);
    7547                 :        147 :                   if (TREE_CODE (t) == COMPONENT_REF)
    7548                 :            :                     {
    7549                 :        118 :                       gomp_map_kind k
    7550                 :         59 :                         = (ort == C_ORT_ACC) ? GOMP_MAP_ATTACH_DETACH
    7551                 :            :                                              : GOMP_MAP_ALWAYS_POINTER;
    7552                 :         59 :                       OMP_CLAUSE_SET_MAP_KIND (c2, k);
    7553                 :            :                     }
    7554                 :            :                   else
    7555                 :         88 :                     OMP_CLAUSE_SET_MAP_KIND (c2,
    7556                 :            :                                              GOMP_MAP_FIRSTPRIVATE_REFERENCE);
    7557                 :        147 :                   OMP_CLAUSE_DECL (c2) = t;
    7558                 :        147 :                   OMP_CLAUSE_SIZE (c2) = size_zero_node;
    7559                 :        147 :                   OMP_CLAUSE_CHAIN (c2) = OMP_CLAUSE_CHAIN (c);
    7560                 :        147 :                   OMP_CLAUSE_CHAIN (c) = c2;
    7561                 :        147 :                   OMP_CLAUSE_DECL (c) = build_simple_mem_ref (t);
    7562                 :        147 :                   if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
    7563                 :        294 :                     OMP_CLAUSE_SIZE (c)
    7564                 :        294 :                       = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t)));
    7565                 :            :                   c = c2;
    7566                 :            :                 }
    7567                 :            :             }
    7568                 :            :           break;
    7569                 :            : 
    7570                 :        392 :         case OMP_CLAUSE_TO_DECLARE:
    7571                 :        392 :         case OMP_CLAUSE_LINK:
    7572                 :        392 :           t = OMP_CLAUSE_DECL (c);
    7573                 :        392 :           if (TREE_CODE (t) == FUNCTION_DECL
    7574                 :        392 :               && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TO_DECLARE)
    7575                 :            :             ;
    7576                 :        216 :           else if (!VAR_P (t))
    7577                 :            :             {
    7578                 :         12 :               if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TO_DECLARE)
    7579                 :            :                 {
    7580                 :          8 :                   if (TREE_CODE (t) == TEMPLATE_ID_EXPR)
    7581                 :          4 :                     error_at (OMP_CLAUSE_LOCATION (c),
    7582                 :            :                               "template %qE in clause %qs", t,
    7583                 :          4 :                               omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7584                 :          4 :                   else if (really_overloaded_fn (t))
    7585                 :          4 :                     error_at (OMP_CLAUSE_LOCATION (c),
    7586                 :            :                               "overloaded function name %qE in clause %qs", t,
    7587                 :          4 :                               omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7588                 :            :                   else
    7589                 :          0 :                     error_at (OMP_CLAUSE_LOCATION (c),
    7590                 :            :                               "%qE is neither a variable nor a function name "
    7591                 :            :                               "in clause %qs", t,
    7592                 :          0 :                               omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7593                 :            :                 }
    7594                 :            :               else
    7595                 :          4 :                 error_at (OMP_CLAUSE_LOCATION (c),
    7596                 :            :                           "%qE is not a variable in clause %qs", t,
    7597                 :          4 :                           omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7598                 :            :               remove = true;
    7599                 :            :             }
    7600                 :        236 :           else if (DECL_THREAD_LOCAL_P (t))
    7601                 :            :             {
    7602                 :          8 :               error_at (OMP_CLAUSE_LOCATION (c),
    7603                 :            :                         "%qD is threadprivate variable in %qs clause", t,
    7604                 :          8 :                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
    7605                 :          8 :               remove = true;
    7606                 :            :             }
    7607                 :        196 :           else if (!cp_omp_mappable_type (TREE_TYPE (t)))
    7608                 :            :             {
    7609                 :         20 :               error_at (OMP_CLAUSE_LOCATION (c),
    7610