LCOV - code coverage report
Current view: top level - gcc/c - c-parser.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 9130 10702 85.3 %
Date: 2020-03-28 11:57:23 Functions: 225 267 84.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Parser for C and Objective-C.
       2                 :            :    Copyright (C) 1987-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            :    Parser actions based on the old Bison parser; structure somewhat
       5                 :            :    influenced by and fragments based on the C++ parser.
       6                 :            : 
       7                 :            : This file is part of GCC.
       8                 :            : 
       9                 :            : GCC is free software; you can redistribute it and/or modify it under
      10                 :            : the terms of the GNU General Public License as published by the Free
      11                 :            : Software Foundation; either version 3, or (at your option) any later
      12                 :            : version.
      13                 :            : 
      14                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      15                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      16                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      17                 :            : for more details.
      18                 :            : 
      19                 :            : You should have received a copy of the GNU General Public License
      20                 :            : along with GCC; see the file COPYING3.  If not see
      21                 :            : <http://www.gnu.org/licenses/>.  */
      22                 :            : 
      23                 :            : /* TODO:
      24                 :            : 
      25                 :            :    Make sure all relevant comments, and all relevant code from all
      26                 :            :    actions, brought over from old parser.  Verify exact correspondence
      27                 :            :    of syntax accepted.
      28                 :            : 
      29                 :            :    Add testcases covering every input symbol in every state in old and
      30                 :            :    new parsers.
      31                 :            : 
      32                 :            :    Include full syntax for GNU C, including erroneous cases accepted
      33                 :            :    with error messages, in syntax productions in comments.
      34                 :            : 
      35                 :            :    Make more diagnostics in the front end generally take an explicit
      36                 :            :    location rather than implicitly using input_location.  */
      37                 :            : 
      38                 :            : #include "config.h"
      39                 :            : #define INCLUDE_UNIQUE_PTR
      40                 :            : #include "system.h"
      41                 :            : #include "coretypes.h"
      42                 :            : #include "target.h"
      43                 :            : #include "function.h"
      44                 :            : #include "c-tree.h"
      45                 :            : #include "timevar.h"
      46                 :            : #include "stringpool.h"
      47                 :            : #include "cgraph.h"
      48                 :            : #include "attribs.h"
      49                 :            : #include "stor-layout.h"
      50                 :            : #include "varasm.h"
      51                 :            : #include "trans-mem.h"
      52                 :            : #include "c-family/c-pragma.h"
      53                 :            : #include "c-lang.h"
      54                 :            : #include "c-family/c-objc.h"
      55                 :            : #include "plugin.h"
      56                 :            : #include "omp-general.h"
      57                 :            : #include "omp-offload.h"
      58                 :            : #include "builtins.h"
      59                 :            : #include "gomp-constants.h"
      60                 :            : #include "c-family/c-indentation.h"
      61                 :            : #include "gimple-expr.h"
      62                 :            : #include "context.h"
      63                 :            : #include "gcc-rich-location.h"
      64                 :            : #include "c-parser.h"
      65                 :            : #include "gimple-parser.h"
      66                 :            : #include "read-rtl-function.h"
      67                 :            : #include "run-rtl-passes.h"
      68                 :            : #include "intl.h"
      69                 :            : #include "c-family/name-hint.h"
      70                 :            : #include "tree-iterator.h"
      71                 :            : #include "memmodel.h"
      72                 :            : 
      73                 :            : /* We need to walk over decls with incomplete struct/union/enum types
      74                 :            :    after parsing the whole translation unit.
      75                 :            :    In finish_decl(), if the decl is static, has incomplete
      76                 :            :    struct/union/enum type, it is appeneded to incomplete_record_decls.
      77                 :            :    In c_parser_translation_unit(), we iterate over incomplete_record_decls
      78                 :            :    and report error if any of the decls are still incomplete.  */ 
      79                 :            : 
      80                 :            : vec<tree> incomplete_record_decls;
      81                 :            : 
      82                 :            : void
      83                 :  121658000 : set_c_expr_source_range (c_expr *expr,
      84                 :            :                          location_t start, location_t finish)
      85                 :            : {
      86                 :  121658000 :   expr->src_range.m_start = start;
      87                 :  121658000 :   expr->src_range.m_finish = finish;
      88                 :  121658000 :   if (expr->value)
      89                 :  121658000 :     set_source_range (expr->value, start, finish);
      90                 :  121658000 : }
      91                 :            : 
      92                 :            : void
      93                 :  121976000 : set_c_expr_source_range (c_expr *expr,
      94                 :            :                          source_range src_range)
      95                 :            : {
      96                 :  121976000 :   expr->src_range = src_range;
      97                 :  121976000 :   if (expr->value)
      98                 :  121976000 :     set_source_range (expr->value, src_range);
      99                 :  121976000 : }
     100                 :            : 
     101                 :            : 
     102                 :            : /* Initialization routine for this file.  */
     103                 :            : 
     104                 :            : void
     105                 :      78603 : c_parse_init (void)
     106                 :            : {
     107                 :            :   /* The only initialization required is of the reserved word
     108                 :            :      identifiers.  */
     109                 :      78603 :   unsigned int i;
     110                 :      78603 :   tree id;
     111                 :      78603 :   int mask = 0;
     112                 :            : 
     113                 :            :   /* Make sure RID_MAX hasn't grown past the 8 bits used to hold the keyword in
     114                 :            :      the c_token structure.  */
     115                 :      78603 :   gcc_assert (RID_MAX <= 255);
     116                 :            : 
     117                 :      78603 :   mask |= D_CXXONLY;
     118                 :      78603 :   if (!flag_isoc99)
     119                 :       1195 :     mask |= D_C99;
     120                 :      78603 :   if (flag_no_asm)
     121                 :            :     {
     122                 :       1980 :       mask |= D_ASM | D_EXT;
     123                 :       1980 :       if (!flag_isoc99)
     124                 :        983 :         mask |= D_EXT89;
     125                 :            :     }
     126                 :      78603 :   if (!c_dialect_objc ())
     127                 :      78603 :     mask |= D_OBJC | D_CXX_OBJC;
     128                 :            : 
     129                 :      78603 :   ridpointers = ggc_cleared_vec_alloc<tree> ((int) RID_MAX);
     130                 :   17607100 :   for (i = 0; i < num_c_common_reswords; i++)
     131                 :            :     {
     132                 :            :       /* If a keyword is disabled, do not enter it into the table
     133                 :            :          and so create a canonical spelling that isn't a keyword.  */
     134                 :   17528500 :       if (c_common_reswords[i].disable & mask)
     135                 :            :         {
     136                 :    9130030 :           if (warn_cxx_compat
     137                 :      81042 :               && (c_common_reswords[i].disable & D_CXXWARN))
     138                 :            :             {
     139                 :      32108 :               id = get_identifier (c_common_reswords[i].word);
     140                 :      32108 :               C_SET_RID_CODE (id, RID_CXX_COMPAT_WARN);
     141                 :      64216 :               C_IS_RESERVED_WORD (id) = 1;
     142                 :            :             }
     143                 :    9130030 :           continue;
     144                 :            :         }
     145                 :            : 
     146                 :    8398440 :       id = get_identifier (c_common_reswords[i].word);
     147                 :    8398440 :       C_SET_RID_CODE (id, c_common_reswords[i].rid);
     148                 :    8398440 :       C_IS_RESERVED_WORD (id) = 1;
     149                 :    8398440 :       ridpointers [(int) c_common_reswords[i].rid] = id;
     150                 :            :     }
     151                 :            : 
     152                 :     157206 :   for (i = 0; i < NUM_INT_N_ENTS; i++)
     153                 :            :     {
     154                 :            :       /* We always create the symbols but they aren't always supported.  */
     155                 :      78603 :       char name[50];
     156                 :      78603 :       sprintf (name, "__int%d", int_n_data[i].bitsize);
     157                 :      78603 :       id = get_identifier (name);
     158                 :      78603 :       C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
     159                 :      78603 :       C_IS_RESERVED_WORD (id) = 1;
     160                 :            : 
     161                 :      78603 :       sprintf (name, "__int%d__", int_n_data[i].bitsize);
     162                 :      78603 :       id = get_identifier (name);
     163                 :      78603 :       C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
     164                 :     157206 :       C_IS_RESERVED_WORD (id) = 1;
     165                 :            :     }
     166                 :      78603 : }
     167                 :            : 
     168                 :            : /* A parser structure recording information about the state and
     169                 :            :    context of parsing.  Includes lexer information with up to two
     170                 :            :    tokens of look-ahead; more are not needed for C.  */
     171                 :            : struct GTY(()) c_parser {
     172                 :            :   /* The look-ahead tokens.  */
     173                 :            :   c_token * GTY((skip)) tokens;
     174                 :            :   /* Buffer for look-ahead tokens.  */
     175                 :            :   c_token tokens_buf[4];
     176                 :            :   /* How many look-ahead tokens are available (0 - 4, or
     177                 :            :      more if parsing from pre-lexed tokens).  */
     178                 :            :   unsigned int tokens_avail;
     179                 :            :   /* Raw look-ahead tokens, used only for checking in Objective-C
     180                 :            :      whether '[[' starts attributes.  */
     181                 :            :   vec<c_token, va_gc> *raw_tokens;
     182                 :            :   /* The number of raw look-ahead tokens that have since been fully
     183                 :            :      lexed.  */
     184                 :            :   unsigned int raw_tokens_used;
     185                 :            :   /* True if a syntax error is being recovered from; false otherwise.
     186                 :            :      c_parser_error sets this flag.  It should clear this flag when
     187                 :            :      enough tokens have been consumed to recover from the error.  */
     188                 :            :   BOOL_BITFIELD error : 1;
     189                 :            :   /* True if we're processing a pragma, and shouldn't automatically
     190                 :            :      consume CPP_PRAGMA_EOL.  */
     191                 :            :   BOOL_BITFIELD in_pragma : 1;
     192                 :            :   /* True if we're parsing the outermost block of an if statement.  */
     193                 :            :   BOOL_BITFIELD in_if_block : 1;
     194                 :            :   /* True if we want to lex a translated, joined string (for an
     195                 :            :      initial #pragma pch_preprocess).  Otherwise the parser is
     196                 :            :      responsible for concatenating strings and translating to the
     197                 :            :      execution character set as needed.  */
     198                 :            :   BOOL_BITFIELD lex_joined_string : 1;
     199                 :            :   /* True if, when the parser is concatenating string literals, it
     200                 :            :      should translate them to the execution character set (false
     201                 :            :      inside attributes).  */
     202                 :            :   BOOL_BITFIELD translate_strings_p : 1;
     203                 :            : 
     204                 :            :   /* Objective-C specific parser/lexer information.  */
     205                 :            : 
     206                 :            :   /* True if we are in a context where the Objective-C "PQ" keywords
     207                 :            :      are considered keywords.  */
     208                 :            :   BOOL_BITFIELD objc_pq_context : 1;
     209                 :            :   /* True if we are parsing a (potential) Objective-C foreach
     210                 :            :      statement.  This is set to true after we parsed 'for (' and while
     211                 :            :      we wait for 'in' or ';' to decide if it's a standard C for loop or an
     212                 :            :      Objective-C foreach loop.  */
     213                 :            :   BOOL_BITFIELD objc_could_be_foreach_context : 1;
     214                 :            :   /* The following flag is needed to contextualize Objective-C lexical
     215                 :            :      analysis.  In some cases (e.g., 'int NSObject;'), it is
     216                 :            :      undesirable to bind an identifier to an Objective-C class, even
     217                 :            :      if a class with that name exists.  */
     218                 :            :   BOOL_BITFIELD objc_need_raw_identifier : 1;
     219                 :            :   /* Nonzero if we're processing a __transaction statement.  The value
     220                 :            :      is 1 | TM_STMT_ATTR_*.  */
     221                 :            :   unsigned int in_transaction : 4;
     222                 :            :   /* True if we are in a context where the Objective-C "Property attribute"
     223                 :            :      keywords are valid.  */
     224                 :            :   BOOL_BITFIELD objc_property_attr_context : 1;
     225                 :            : 
     226                 :            :   /* Location of the last consumed token.  */
     227                 :            :   location_t last_token_location;
     228                 :            : };
     229                 :            : 
     230                 :            : /* Return a pointer to the Nth token in PARSERs tokens_buf.  */
     231                 :            : 
     232                 :            : c_token *
     233                 :         94 : c_parser_tokens_buf (c_parser *parser, unsigned n)
     234                 :            : {
     235                 :         94 :   return &parser->tokens_buf[n];
     236                 :            : }
     237                 :            : 
     238                 :            : /* Return the error state of PARSER.  */
     239                 :            : 
     240                 :            : bool
     241                 :       2264 : c_parser_error (c_parser *parser)
     242                 :            : {
     243                 :       2264 :   return parser->error;
     244                 :            : }
     245                 :            : 
     246                 :            : /* Set the error state of PARSER to ERR.  */
     247                 :            : 
     248                 :            : void
     249                 :          0 : c_parser_set_error (c_parser *parser, bool err)
     250                 :            : {
     251                 :          0 :   parser->error = err;
     252                 :          0 : }
     253                 :            : 
     254                 :            : 
     255                 :            : /* The actual parser and external interface.  ??? Does this need to be
     256                 :            :    garbage-collected?  */
     257                 :            : 
     258                 :            : static GTY (()) c_parser *the_parser;
     259                 :            : 
     260                 :            : /* Read in and lex a single token, storing it in *TOKEN.  If RAW,
     261                 :            :    context-sensitive postprocessing of the token is not done.  */
     262                 :            : 
     263                 :            : static void
     264                 : 1343730000 : c_lex_one_token (c_parser *parser, c_token *token, bool raw = false)
     265                 :            : {
     266                 : 1343730000 :   timevar_push (TV_LEX);
     267                 :            : 
     268                 : 1343730000 :   if (raw || vec_safe_length (parser->raw_tokens) == 0)
     269                 :            :     {
     270                 : 1343730000 :       token->type = c_lex_with_flags (&token->value, &token->location,
     271                 :            :                                       &token->flags,
     272                 :            :                                       (parser->lex_joined_string
     273                 : 1343730000 :                                        ? 0 : C_LEX_STRING_NO_JOIN));
     274                 : 1343730000 :       token->id_kind = C_ID_NONE;
     275                 : 1343730000 :       token->keyword = RID_MAX;
     276                 : 1343730000 :       token->pragma_kind = PRAGMA_NONE;
     277                 :            :     }
     278                 :            :   else
     279                 :            :     {
     280                 :            :       /* Use a token previously lexed as a raw look-ahead token, and
     281                 :            :          complete the processing on it.  */
     282                 :          0 :       *token = (*parser->raw_tokens)[parser->raw_tokens_used];
     283                 :          0 :       ++parser->raw_tokens_used;
     284                 :          0 :       if (parser->raw_tokens_used == vec_safe_length (parser->raw_tokens))
     285                 :            :         {
     286                 :          0 :           vec_free (parser->raw_tokens);
     287                 :          0 :           parser->raw_tokens_used = 0;
     288                 :            :         }
     289                 :            :     }
     290                 :            : 
     291                 : 1343730000 :   if (raw)
     292                 :          0 :     goto out;
     293                 :            : 
     294                 : 1343730000 :   switch (token->type)
     295                 :            :     {
     296                 :  606867000 :     case CPP_NAME:
     297                 :  606867000 :       {
     298                 :  606867000 :         tree decl;
     299                 :            : 
     300                 :  606867000 :         bool objc_force_identifier = parser->objc_need_raw_identifier;
     301                 :  606867000 :         if (c_dialect_objc ())
     302                 :          0 :           parser->objc_need_raw_identifier = false;
     303                 :            : 
     304                 : 1213730000 :         if (C_IS_RESERVED_WORD (token->value))
     305                 :            :           {
     306                 :  174259000 :             enum rid rid_code = C_RID_CODE (token->value);
     307                 :            : 
     308                 :  174259000 :             if (rid_code == RID_CXX_COMPAT_WARN)
     309                 :            :               {
     310                 :         35 :                 warning_at (token->location,
     311                 :            :                             OPT_Wc___compat,
     312                 :            :                             "identifier %qE conflicts with C++ keyword",
     313                 :            :                             token->value);
     314                 :            :               }
     315                 :  174259000 :             else if (rid_code >= RID_FIRST_ADDR_SPACE
     316                 :  174259000 :                      && rid_code <= RID_LAST_ADDR_SPACE)
     317                 :            :               {
     318                 :         29 :                 addr_space_t as;
     319                 :         29 :                 as = (addr_space_t) (rid_code - RID_FIRST_ADDR_SPACE);
     320                 :         29 :                 targetm.addr_space.diagnose_usage (as, token->location);
     321                 :         29 :                 token->id_kind = C_ID_ADDRSPACE;
     322                 :         29 :                 token->keyword = rid_code;
     323                 :         29 :                 break;
     324                 :            :               }
     325                 :  174259000 :             else if (c_dialect_objc () && OBJC_IS_PQ_KEYWORD (rid_code))
     326                 :            :               {
     327                 :            :                 /* We found an Objective-C "pq" keyword (in, out,
     328                 :            :                    inout, bycopy, byref, oneway).  They need special
     329                 :            :                    care because the interpretation depends on the
     330                 :            :                    context.  */
     331                 :          0 :                 if (parser->objc_pq_context)
     332                 :            :                   {
     333                 :          0 :                     token->type = CPP_KEYWORD;
     334                 :          0 :                     token->keyword = rid_code;
     335                 :          0 :                     break;
     336                 :            :                   }
     337                 :          0 :                 else if (parser->objc_could_be_foreach_context
     338                 :          0 :                          && rid_code == RID_IN)
     339                 :            :                   {
     340                 :            :                     /* We are in Objective-C, inside a (potential)
     341                 :            :                        foreach context (which means after having
     342                 :            :                        parsed 'for (', but before having parsed ';'),
     343                 :            :                        and we found 'in'.  We consider it the keyword
     344                 :            :                        which terminates the declaration at the
     345                 :            :                        beginning of a foreach-statement.  Note that
     346                 :            :                        this means you can't use 'in' for anything else
     347                 :            :                        in that context; in particular, in Objective-C
     348                 :            :                        you can't use 'in' as the name of the running
     349                 :            :                        variable in a C for loop.  We could potentially
     350                 :            :                        try to add code here to disambiguate, but it
     351                 :            :                        seems a reasonable limitation.  */
     352                 :          0 :                     token->type = CPP_KEYWORD;
     353                 :          0 :                     token->keyword = rid_code;
     354                 :          0 :                     break;
     355                 :            :                   }
     356                 :            :                 /* Else, "pq" keywords outside of the "pq" context are
     357                 :            :                    not keywords, and we fall through to the code for
     358                 :            :                    normal tokens.  */
     359                 :            :               }
     360                 :  174259000 :             else if (c_dialect_objc () && OBJC_IS_PATTR_KEYWORD (rid_code))
     361                 :            :               {
     362                 :            :                 /* We found an Objective-C "property attribute"
     363                 :            :                    keyword (getter, setter, readonly, etc). These are
     364                 :            :                    only valid in the property context.  */
     365                 :          0 :                 if (parser->objc_property_attr_context)
     366                 :            :                   {
     367                 :          0 :                     token->type = CPP_KEYWORD;
     368                 :          0 :                     token->keyword = rid_code;
     369                 :          0 :                     break;
     370                 :            :                   }
     371                 :            :                 /* Else they are not special keywords.
     372                 :            :                 */
     373                 :            :               }
     374                 :  174259000 :             else if (c_dialect_objc () 
     375                 :          0 :                      && (OBJC_IS_AT_KEYWORD (rid_code)
     376                 :          0 :                          || OBJC_IS_CXX_KEYWORD (rid_code)))
     377                 :            :               {
     378                 :            :                 /* We found one of the Objective-C "@" keywords (defs,
     379                 :            :                    selector, synchronized, etc) or one of the
     380                 :            :                    Objective-C "cxx" keywords (class, private,
     381                 :            :                    protected, public, try, catch, throw) without a
     382                 :            :                    preceding '@' sign.  Do nothing and fall through to
     383                 :            :                    the code for normal tokens (in C++ we would still
     384                 :            :                    consider the CXX ones keywords, but not in C).  */
     385                 :            :                 ;
     386                 :            :               }
     387                 :            :             else
     388                 :            :               {
     389                 :  174259000 :                 token->type = CPP_KEYWORD;
     390                 :  174259000 :                 token->keyword = rid_code;
     391                 :  174259000 :                 break;
     392                 :            :               }
     393                 :            :           }
     394                 :            : 
     395                 :  432608000 :         decl = lookup_name (token->value);
     396                 :  432608000 :         if (decl)
     397                 :            :           {
     398                 :  239220000 :             if (TREE_CODE (decl) == TYPE_DECL)
     399                 :            :               {
     400                 :  141577000 :                 token->id_kind = C_ID_TYPENAME;
     401                 :  141577000 :                 break;
     402                 :            :               }
     403                 :            :           }
     404                 :  193388000 :         else if (c_dialect_objc ())
     405                 :            :           {
     406                 :          0 :             tree objc_interface_decl = objc_is_class_name (token->value);
     407                 :            :             /* Objective-C class names are in the same namespace as
     408                 :            :                variables and typedefs, and hence are shadowed by local
     409                 :            :                declarations.  */
     410                 :          0 :             if (objc_interface_decl
     411                 :          0 :                 && (!objc_force_identifier || global_bindings_p ()))
     412                 :            :               {
     413                 :          0 :                 token->value = objc_interface_decl;
     414                 :          0 :                 token->id_kind = C_ID_CLASSNAME;
     415                 :          0 :                 break;
     416                 :            :               }
     417                 :            :           }
     418                 :  291031000 :         token->id_kind = C_ID_ID;
     419                 :            :       }
     420                 :  291031000 :       break;
     421                 :          0 :     case CPP_AT_NAME:
     422                 :            :       /* This only happens in Objective-C; it must be a keyword.  */
     423                 :          0 :       token->type = CPP_KEYWORD;
     424                 :          0 :       switch (C_RID_CODE (token->value))
     425                 :            :         {
     426                 :            :           /* Replace 'class' with '@class', 'private' with '@private',
     427                 :            :              etc.  This prevents confusion with the C++ keyword
     428                 :            :              'class', and makes the tokens consistent with other
     429                 :            :              Objective-C 'AT' keywords.  For example '@class' is
     430                 :            :              reported as RID_AT_CLASS which is consistent with
     431                 :            :              '@synchronized', which is reported as
     432                 :            :              RID_AT_SYNCHRONIZED.
     433                 :            :           */
     434                 :          0 :         case RID_CLASS:     token->keyword = RID_AT_CLASS; break;
     435                 :          0 :         case RID_PRIVATE:   token->keyword = RID_AT_PRIVATE; break;
     436                 :          0 :         case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
     437                 :          0 :         case RID_PUBLIC:    token->keyword = RID_AT_PUBLIC; break;
     438                 :          0 :         case RID_THROW:     token->keyword = RID_AT_THROW; break;
     439                 :          0 :         case RID_TRY:       token->keyword = RID_AT_TRY; break;
     440                 :          0 :         case RID_CATCH:     token->keyword = RID_AT_CATCH; break;
     441                 :          0 :         case RID_SYNCHRONIZED: token->keyword = RID_AT_SYNCHRONIZED; break;
     442                 :          0 :         default:            token->keyword = C_RID_CODE (token->value);
     443                 :            :         }
     444                 :            :       break;
     445                 :  397524000 :     case CPP_COLON:
     446                 :  397524000 :     case CPP_COMMA:
     447                 :  397524000 :     case CPP_CLOSE_PAREN:
     448                 :  397524000 :     case CPP_SEMICOLON:
     449                 :            :       /* These tokens may affect the interpretation of any identifiers
     450                 :            :          following, if doing Objective-C.  */
     451                 :  397524000 :       if (c_dialect_objc ())
     452                 :          0 :         parser->objc_need_raw_identifier = false;
     453                 :            :       break;
     454                 :     803991 :     case CPP_PRAGMA:
     455                 :            :       /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST.  */
     456                 :     803991 :       token->pragma_kind = (enum pragma_kind) TREE_INT_CST_LOW (token->value);
     457                 :     803991 :       token->value = NULL;
     458                 :     803991 :       break;
     459                 :            :     default:
     460                 :            :       break;
     461                 :            :     }
     462                 : 1343730000 :  out:
     463                 : 1343730000 :   timevar_pop (TV_LEX);
     464                 : 1343730000 : }
     465                 :            : 
     466                 :            : /* Return a pointer to the next token from PARSER, reading it in if
     467                 :            :    necessary.  */
     468                 :            : 
     469                 :            : c_token *
     470                 : 9919970000 : c_parser_peek_token (c_parser *parser)
     471                 :            : {
     472                 : 9919970000 :   if (parser->tokens_avail == 0)
     473                 :            :     {
     474                 : 1095080000 :       c_lex_one_token (parser, &parser->tokens[0]);
     475                 : 1095080000 :       parser->tokens_avail = 1;
     476                 :            :     }
     477                 : 9919970000 :   return &parser->tokens[0];
     478                 :            : }
     479                 :            : 
     480                 :            : /* Return a pointer to the next-but-one token from PARSER, reading it
     481                 :            :    in if necessary.  The next token is already read in.  */
     482                 :            : 
     483                 :            : c_token *
     484                 :  105866000 : c_parser_peek_2nd_token (c_parser *parser)
     485                 :            : {
     486                 :  105866000 :   if (parser->tokens_avail >= 2)
     487                 :   17192400 :     return &parser->tokens[1];
     488                 :   88674000 :   gcc_assert (parser->tokens_avail == 1);
     489                 :   88674000 :   gcc_assert (parser->tokens[0].type != CPP_EOF);
     490                 :   88674000 :   gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL);
     491                 :   88674000 :   c_lex_one_token (parser, &parser->tokens[1]);
     492                 :   88674000 :   parser->tokens_avail = 2;
     493                 :   88674000 :   return &parser->tokens[1];
     494                 :            : }
     495                 :            : 
     496                 :            : /* Return a pointer to the Nth token from PARSER, reading it
     497                 :            :    in if necessary.  The N-1th token is already read in.  */
     498                 :            : 
     499                 :            : c_token *
     500                 :  528796000 : c_parser_peek_nth_token (c_parser *parser, unsigned int n)
     501                 :            : {
     502                 :            :   /* N is 1-based, not zero-based.  */
     503                 :  528796000 :   gcc_assert (n > 0);
     504                 :            : 
     505                 :  528796000 :   if (parser->tokens_avail >= n)
     506                 :  368824000 :     return &parser->tokens[n - 1];
     507                 :  159972000 :   gcc_assert (parser->tokens_avail == n - 1);
     508                 :  159972000 :   c_lex_one_token (parser, &parser->tokens[n - 1]);
     509                 :  159972000 :   parser->tokens_avail = n;
     510                 :  159972000 :   return &parser->tokens[n - 1];
     511                 :            : }
     512                 :            : 
     513                 :            : /* Return a pointer to the Nth token from PARSER, reading it in as a
     514                 :            :    raw look-ahead token if necessary.  The N-1th token is already read
     515                 :            :    in.  Raw look-ahead tokens remain available for when the non-raw
     516                 :            :    functions above are called.  */
     517                 :            : 
     518                 :            : c_token *
     519                 :          0 : c_parser_peek_nth_token_raw (c_parser *parser, unsigned int n)
     520                 :            : {
     521                 :            :   /* N is 1-based, not zero-based.  */
     522                 :          0 :   gcc_assert (n > 0);
     523                 :            : 
     524                 :          0 :   if (parser->tokens_avail >= n)
     525                 :          0 :     return &parser->tokens[n - 1];
     526                 :          0 :   unsigned int raw_len = vec_safe_length (parser->raw_tokens);
     527                 :          0 :   unsigned int raw_avail
     528                 :          0 :     = parser->tokens_avail + raw_len - parser->raw_tokens_used;
     529                 :          0 :   gcc_assert (raw_avail >= n - 1);
     530                 :          0 :   if (raw_avail >= n)
     531                 :          0 :     return &(*parser->raw_tokens)[parser->raw_tokens_used
     532                 :          0 :                                   + n - 1 - parser->tokens_avail];
     533                 :          0 :   vec_safe_reserve (parser->raw_tokens, 1);
     534                 :          0 :   parser->raw_tokens->quick_grow (raw_len + 1);
     535                 :          0 :   c_lex_one_token (parser, &(*parser->raw_tokens)[raw_len], true);
     536                 :          0 :   return &(*parser->raw_tokens)[raw_len];
     537                 :            : }
     538                 :            : 
     539                 :            : bool
     540                 :   26804800 : c_keyword_starts_typename (enum rid keyword)
     541                 :            : {
     542                 :   26804800 :   switch (keyword)
     543                 :            :     {
     544                 :            :     case RID_UNSIGNED:
     545                 :            :     case RID_LONG:
     546                 :            :     case RID_SHORT:
     547                 :            :     case RID_SIGNED:
     548                 :            :     case RID_COMPLEX:
     549                 :            :     case RID_INT:
     550                 :            :     case RID_CHAR:
     551                 :            :     case RID_FLOAT:
     552                 :            :     case RID_DOUBLE:
     553                 :            :     case RID_VOID:
     554                 :            :     case RID_DFLOAT32:
     555                 :            :     case RID_DFLOAT64:
     556                 :            :     case RID_DFLOAT128:
     557                 :            :     CASE_RID_FLOATN_NX:
     558                 :            :     case RID_BOOL:
     559                 :            :     case RID_ENUM:
     560                 :            :     case RID_STRUCT:
     561                 :            :     case RID_UNION:
     562                 :            :     case RID_TYPEOF:
     563                 :            :     case RID_CONST:
     564                 :            :     case RID_ATOMIC:
     565                 :            :     case RID_VOLATILE:
     566                 :            :     case RID_RESTRICT:
     567                 :            :     case RID_ATTRIBUTE:
     568                 :            :     case RID_FRACT:
     569                 :            :     case RID_ACCUM:
     570                 :            :     case RID_SAT:
     571                 :            :     case RID_AUTO_TYPE:
     572                 :            :     case RID_ALIGNAS:
     573                 :            :       return true;
     574                 :   21527300 :     default:
     575                 :   21527300 :       if (keyword >= RID_FIRST_INT_N
     576                 :            :           && keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS
     577                 :        249 :           && int_n_enabled_p[keyword - RID_FIRST_INT_N])
     578                 :        249 :         return true;
     579                 :            :       return false;
     580                 :            :     }
     581                 :            : }
     582                 :            : 
     583                 :            : /* Return true if TOKEN can start a type name,
     584                 :            :    false otherwise.  */
     585                 :            : bool
     586                 :  263663000 : c_token_starts_typename (c_token *token)
     587                 :            : {
     588                 :  263663000 :   switch (token->type)
     589                 :            :     {
     590                 :  233194000 :     case CPP_NAME:
     591                 :  233194000 :       switch (token->id_kind)
     592                 :            :         {
     593                 :            :         case C_ID_ID:
     594                 :            :           return false;
     595                 :          2 :         case C_ID_ADDRSPACE:
     596                 :          2 :           return true;
     597                 :  210667000 :         case C_ID_TYPENAME:
     598                 :  210667000 :           return true;
     599                 :          0 :         case C_ID_CLASSNAME:
     600                 :          0 :           gcc_assert (c_dialect_objc ());
     601                 :            :           return true;
     602                 :          0 :         default:
     603                 :          0 :           gcc_unreachable ();
     604                 :            :         }
     605                 :   26767800 :     case CPP_KEYWORD:
     606                 :   26767800 :       return c_keyword_starts_typename (token->keyword);
     607                 :          0 :     case CPP_LESS:
     608                 :          0 :       if (c_dialect_objc ())
     609                 :            :         return true;
     610                 :            :       return false;
     611                 :            :     default:
     612                 :            :       return false;
     613                 :            :     }
     614                 :            : }
     615                 :            : 
     616                 :            : /* Return true if the next token from PARSER can start a type name,
     617                 :            :    false otherwise.  LA specifies how to do lookahead in order to
     618                 :            :    detect unknown type names.  If unsure, pick CLA_PREFER_ID.  */
     619                 :            : 
     620                 :            : static inline bool
     621                 :  186995000 : c_parser_next_tokens_start_typename (c_parser *parser, enum c_lookahead_kind la)
     622                 :            : {
     623                 :  186995000 :   c_token *token = c_parser_peek_token (parser);
     624                 :  186995000 :   if (c_token_starts_typename (token))
     625                 :            :     return true;
     626                 :            : 
     627                 :            :   /* Try a bit harder to detect an unknown typename.  */
     628                 :   42856300 :   if (la != cla_prefer_id
     629                 :            :       && token->type == CPP_NAME
     630                 :   25599900 :       && token->id_kind == C_ID_ID
     631                 :            : 
     632                 :            :       /* Do not try too hard when we could have "object in array".  */
     633                 :    3767880 :       && !parser->objc_could_be_foreach_context
     634                 :            : 
     635                 :    3767880 :       && (la == cla_prefer_type
     636                 :    3767800 :           || c_parser_peek_2nd_token (parser)->type == CPP_NAME
     637                 :    3767740 :           || c_parser_peek_2nd_token (parser)->type == CPP_MULT)
     638                 :            : 
     639                 :            :       /* Only unknown identifiers.  */
     640                 :   42857600 :       && !lookup_name (token->value))
     641                 :        166 :     return true;
     642                 :            : 
     643                 :            :   return false;
     644                 :            : }
     645                 :            : 
     646                 :            : /* Return true if TOKEN is a type qualifier, false otherwise.  */
     647                 :            : static bool
     648                 :  253639000 : c_token_is_qualifier (c_token *token)
     649                 :            : {
     650                 :  253639000 :   switch (token->type)
     651                 :            :     {
     652                 :  250999000 :     case CPP_NAME:
     653                 :  250999000 :       switch (token->id_kind)
     654                 :            :         {
     655                 :            :         case C_ID_ADDRSPACE:
     656                 :            :           return true;
     657                 :  250999000 :         default:
     658                 :  250999000 :           return false;
     659                 :            :         }
     660                 :    2639960 :     case CPP_KEYWORD:
     661                 :    2639960 :       switch (token->keyword)
     662                 :            :         {
     663                 :            :         case RID_CONST:
     664                 :            :         case RID_VOLATILE:
     665                 :            :         case RID_RESTRICT:
     666                 :            :         case RID_ATTRIBUTE:
     667                 :            :         case RID_ATOMIC:
     668                 :            :           return true;
     669                 :         18 :         default:
     670                 :         18 :           return false;
     671                 :            :         }
     672                 :            :     case CPP_LESS:
     673                 :            :       return false;
     674                 :          0 :     default:
     675                 :          0 :       gcc_unreachable ();
     676                 :            :     }
     677                 :            : }
     678                 :            : 
     679                 :            : /* Return true if the next token from PARSER is a type qualifier,
     680                 :            :    false otherwise.  */
     681                 :            : static inline bool
     682                 :  253639000 : c_parser_next_token_is_qualifier (c_parser *parser)
     683                 :            : {
     684                 :    2639980 :   c_token *token = c_parser_peek_token (parser);
     685                 :  253639000 :   return c_token_is_qualifier (token);
     686                 :            : }
     687                 :            : 
     688                 :            : /* Return true if TOKEN can start declaration specifiers (not
     689                 :            :    including standard attributes), false otherwise.  */
     690                 :            : static bool
     691                 :  101316000 : c_token_starts_declspecs (c_token *token)
     692                 :            : {
     693                 :  101316000 :   switch (token->type)
     694                 :            :     {
     695                 :   54783800 :     case CPP_NAME:
     696                 :   54783800 :       switch (token->id_kind)
     697                 :            :         {
     698                 :            :         case C_ID_ID:
     699                 :            :           return false;
     700                 :          2 :         case C_ID_ADDRSPACE:
     701                 :          2 :           return true;
     702                 :   51029100 :         case C_ID_TYPENAME:
     703                 :   51029100 :           return true;
     704                 :          0 :         case C_ID_CLASSNAME:
     705                 :          0 :           gcc_assert (c_dialect_objc ());
     706                 :            :           return true;
     707                 :          0 :         default:
     708                 :          0 :           gcc_unreachable ();
     709                 :            :         }
     710                 :   45893200 :     case CPP_KEYWORD:
     711                 :   45893200 :       switch (token->keyword)
     712                 :            :         {
     713                 :            :         case RID_STATIC:
     714                 :            :         case RID_EXTERN:
     715                 :            :         case RID_REGISTER:
     716                 :            :         case RID_TYPEDEF:
     717                 :            :         case RID_INLINE:
     718                 :            :         case RID_NORETURN:
     719                 :            :         case RID_AUTO:
     720                 :            :         case RID_THREAD:
     721                 :            :         case RID_UNSIGNED:
     722                 :            :         case RID_LONG:
     723                 :            :         case RID_SHORT:
     724                 :            :         case RID_SIGNED:
     725                 :            :         case RID_COMPLEX:
     726                 :            :         case RID_INT:
     727                 :            :         case RID_CHAR:
     728                 :            :         case RID_FLOAT:
     729                 :            :         case RID_DOUBLE:
     730                 :            :         case RID_VOID:
     731                 :            :         case RID_DFLOAT32:
     732                 :            :         case RID_DFLOAT64:
     733                 :            :         case RID_DFLOAT128:
     734                 :            :         CASE_RID_FLOATN_NX:
     735                 :            :         case RID_BOOL:
     736                 :            :         case RID_ENUM:
     737                 :            :         case RID_STRUCT:
     738                 :            :         case RID_UNION:
     739                 :            :         case RID_TYPEOF:
     740                 :            :         case RID_CONST:
     741                 :            :         case RID_VOLATILE:
     742                 :            :         case RID_RESTRICT:
     743                 :            :         case RID_ATTRIBUTE:
     744                 :            :         case RID_FRACT:
     745                 :            :         case RID_ACCUM:
     746                 :            :         case RID_SAT:
     747                 :            :         case RID_ALIGNAS:
     748                 :            :         case RID_ATOMIC:
     749                 :            :         case RID_AUTO_TYPE:
     750                 :            :           return true;
     751                 :   21254600 :         default:
     752                 :   21254600 :           if (token->keyword >= RID_FIRST_INT_N
     753                 :            :               && token->keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS
     754                 :        226 :               && int_n_enabled_p[token->keyword - RID_FIRST_INT_N])
     755                 :        226 :             return true;
     756                 :            :           return false;
     757                 :            :         }
     758                 :          2 :     case CPP_LESS:
     759                 :          2 :       if (c_dialect_objc ())
     760                 :            :         return true;
     761                 :            :       return false;
     762                 :            :     default:
     763                 :            :       return false;
     764                 :            :     }
     765                 :            : }
     766                 :            : 
     767                 :            : 
     768                 :            : /* Return true if TOKEN can start declaration specifiers (not
     769                 :            :    including standard attributes) or a static assertion, false
     770                 :            :    otherwise.  */
     771                 :            : static bool
     772                 :   28344900 : c_token_starts_declaration (c_token *token)
     773                 :            : {
     774                 :          0 :   if (c_token_starts_declspecs (token)
     775                 :   28344900 :       || token->keyword == RID_STATIC_ASSERT)
     776                 :          0 :     return true;
     777                 :            :   else
     778                 :            :     return false;
     779                 :            : }
     780                 :            : 
     781                 :            : /* Return true if the next token from PARSER can start declaration
     782                 :            :    specifiers (not including standard attributes), false
     783                 :            :    otherwise.  */
     784                 :            : bool
     785                 :   72971400 : c_parser_next_token_starts_declspecs (c_parser *parser)
     786                 :            : {
     787                 :   72971400 :   c_token *token = c_parser_peek_token (parser);
     788                 :            : 
     789                 :            :   /* In Objective-C, a classname normally starts a declspecs unless it
     790                 :            :      is immediately followed by a dot.  In that case, it is the
     791                 :            :      Objective-C 2.0 "dot-syntax" for class objects, ie, calls the
     792                 :            :      setter/getter on the class.  c_token_starts_declspecs() can't
     793                 :            :      differentiate between the two cases because it only checks the
     794                 :            :      current token, so we have a special check here.  */
     795                 :   72971400 :   if (c_dialect_objc () 
     796                 :            :       && token->type == CPP_NAME
     797                 :          0 :       && token->id_kind == C_ID_CLASSNAME 
     798                 :   72971400 :       && c_parser_peek_2nd_token (parser)->type == CPP_DOT)
     799                 :            :     return false;
     800                 :            : 
     801                 :   72971400 :   return c_token_starts_declspecs (token);
     802                 :            : }
     803                 :            : 
     804                 :            : /* Return true if the next tokens from PARSER can start declaration
     805                 :            :    specifiers (not including standard attributes) or a static
     806                 :            :    assertion, false otherwise.  */
     807                 :            : bool
     808                 :   28344400 : c_parser_next_tokens_start_declaration (c_parser *parser)
     809                 :            : {
     810                 :   28344400 :   c_token *token = c_parser_peek_token (parser);
     811                 :            : 
     812                 :            :   /* Same as above.  */
     813                 :   28344400 :   if (c_dialect_objc () 
     814                 :            :       && token->type == CPP_NAME
     815                 :          0 :       && token->id_kind == C_ID_CLASSNAME 
     816                 :   28344400 :       && c_parser_peek_2nd_token (parser)->type == CPP_DOT)
     817                 :            :     return false;
     818                 :            : 
     819                 :            :   /* Labels do not start declarations.  */
     820                 :   28344400 :   if (token->type == CPP_NAME
     821                 :   28344400 :       && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
     822                 :            :     return false;
     823                 :            : 
     824                 :   28344100 :   if (c_token_starts_declaration (token))
     825                 :            :     return true;
     826                 :            : 
     827                 :   24988100 :   if (c_parser_next_tokens_start_typename (parser, cla_nonabstract_decl))
     828                 :         42 :     return true;
     829                 :            : 
     830                 :            :   return false;
     831                 :            : }
     832                 :            : 
     833                 :            : /* Consume the next token from PARSER.  */
     834                 :            : 
     835                 :            : void
     836                 : 1342860000 : c_parser_consume_token (c_parser *parser)
     837                 :            : {
     838                 : 1342860000 :   gcc_assert (parser->tokens_avail >= 1);
     839                 : 1342860000 :   gcc_assert (parser->tokens[0].type != CPP_EOF);
     840                 : 1342860000 :   gcc_assert (!parser->in_pragma || parser->tokens[0].type != CPP_PRAGMA_EOL);
     841                 : 1342860000 :   gcc_assert (parser->error || parser->tokens[0].type != CPP_PRAGMA);
     842                 : 1342860000 :   parser->last_token_location = parser->tokens[0].location;
     843                 : 1342860000 :   if (parser->tokens != &parser->tokens_buf[0])
     844                 :       9999 :     parser->tokens++;
     845                 : 1342850000 :   else if (parser->tokens_avail >= 2)
     846                 :            :     {
     847                 :   89430400 :       parser->tokens[0] = parser->tokens[1];
     848                 :   89430400 :       if (parser->tokens_avail >= 3)
     849                 :            :         {
     850                 :        253 :           parser->tokens[1] = parser->tokens[2];
     851                 :        253 :           if (parser->tokens_avail >= 4)
     852                 :         22 :             parser->tokens[2] = parser->tokens[3];
     853                 :            :         }
     854                 :            :     }
     855                 : 1342860000 :   parser->tokens_avail--;
     856                 : 1342860000 : }
     857                 :            : 
     858                 :            : /* Expect the current token to be a #pragma.  Consume it and remember
     859                 :            :    that we've begun parsing a pragma.  */
     860                 :            : 
     861                 :            : static void
     862                 :     803902 : c_parser_consume_pragma (c_parser *parser)
     863                 :            : {
     864                 :     803902 :   gcc_assert (!parser->in_pragma);
     865                 :     803902 :   gcc_assert (parser->tokens_avail >= 1);
     866                 :     803902 :   gcc_assert (parser->tokens[0].type == CPP_PRAGMA);
     867                 :     803902 :   if (parser->tokens != &parser->tokens_buf[0])
     868                 :          0 :     parser->tokens++;
     869                 :     803902 :   else if (parser->tokens_avail >= 2)
     870                 :            :     {
     871                 :         63 :       parser->tokens[0] = parser->tokens[1];
     872                 :         63 :       if (parser->tokens_avail >= 3)
     873                 :          0 :         parser->tokens[1] = parser->tokens[2];
     874                 :            :     }
     875                 :     803902 :   parser->tokens_avail--;
     876                 :     803902 :   parser->in_pragma = true;
     877                 :     803902 : }
     878                 :            : 
     879                 :            : /* Update the global input_location from TOKEN.  */
     880                 :            : static inline void
     881                 :    6021000 : c_parser_set_source_position_from_token (c_token *token)
     882                 :            : {
     883                 :    6021000 :   if (token->type != CPP_EOF)
     884                 :            :     {
     885                 :    6020960 :       input_location = token->location;
     886                 :            :     }
     887                 :            : }
     888                 :            : 
     889                 :            : /* Helper function for c_parser_error.
     890                 :            :    Having peeked a token of kind TOK1_KIND that might signify
     891                 :            :    a conflict marker, peek successor tokens to determine
     892                 :            :    if we actually do have a conflict marker.
     893                 :            :    Specifically, we consider a run of 7 '<', '=' or '>' characters
     894                 :            :    at the start of a line as a conflict marker.
     895                 :            :    These come through the lexer as three pairs and a single,
     896                 :            :    e.g. three CPP_LSHIFT ("<<") and a CPP_LESS ('<').
     897                 :            :    If it returns true, *OUT_LOC is written to with the location/range
     898                 :            :    of the marker.  */
     899                 :            : 
     900                 :            : static bool
     901                 :         28 : c_parser_peek_conflict_marker (c_parser *parser, enum cpp_ttype tok1_kind,
     902                 :            :                                location_t *out_loc)
     903                 :            : {
     904                 :         28 :   c_token *token2 = c_parser_peek_2nd_token (parser);
     905                 :         28 :   if (token2->type != tok1_kind)
     906                 :            :     return false;
     907                 :         25 :   c_token *token3 = c_parser_peek_nth_token (parser, 3);
     908                 :         25 :   if (token3->type != tok1_kind)
     909                 :            :     return false;
     910                 :         22 :   c_token *token4 = c_parser_peek_nth_token (parser, 4);
     911                 :         22 :   if (token4->type != conflict_marker_get_final_tok_kind (tok1_kind))
     912                 :            :     return false;
     913                 :            : 
     914                 :            :   /* It must be at the start of the line.  */
     915                 :         15 :   location_t start_loc = c_parser_peek_token (parser)->location;
     916                 :         15 :   if (LOCATION_COLUMN (start_loc) != 1)
     917                 :            :     return false;
     918                 :            : 
     919                 :            :   /* We have a conflict marker.  Construct a location of the form:
     920                 :            :        <<<<<<<
     921                 :            :        ^~~~~~~
     922                 :            :      with start == caret, finishing at the end of the marker.  */
     923                 :         12 :   location_t finish_loc = get_finish (token4->location);
     924                 :         12 :   *out_loc = make_location (start_loc, start_loc, finish_loc);
     925                 :            : 
     926                 :         12 :   return true;
     927                 :            : }
     928                 :            : 
     929                 :            : /* Issue a diagnostic of the form
     930                 :            :       FILE:LINE: MESSAGE before TOKEN
     931                 :            :    where TOKEN is the next token in the input stream of PARSER.
     932                 :            :    MESSAGE (specified by the caller) is usually of the form "expected
     933                 :            :    OTHER-TOKEN".
     934                 :            : 
     935                 :            :    Use RICHLOC as the location of the diagnostic.
     936                 :            : 
     937                 :            :    Do not issue a diagnostic if still recovering from an error.
     938                 :            : 
     939                 :            :    Return true iff an error was actually emitted.
     940                 :            : 
     941                 :            :    ??? This is taken from the C++ parser, but building up messages in
     942                 :            :    this way is not i18n-friendly and some other approach should be
     943                 :            :    used.  */
     944                 :            : 
     945                 :            : static bool
     946                 :       2348 : c_parser_error_richloc (c_parser *parser, const char *gmsgid,
     947                 :            :                         rich_location *richloc)
     948                 :            : {
     949                 :       2348 :   c_token *token = c_parser_peek_token (parser);
     950                 :       2348 :   if (parser->error)
     951                 :            :     return false;
     952                 :       1829 :   parser->error = true;
     953                 :       1829 :   if (!gmsgid)
     954                 :            :     return false;
     955                 :            : 
     956                 :            :   /* If this is actually a conflict marker, report it as such.  */
     957                 :       1736 :   if (token->type == CPP_LSHIFT
     958                 :       1736 :       || token->type == CPP_RSHIFT
     959                 :       1717 :       || token->type == CPP_EQ_EQ)
     960                 :            :     {
     961                 :         28 :       location_t loc;
     962                 :         28 :       if (c_parser_peek_conflict_marker (parser, token->type, &loc))
     963                 :            :         {
     964                 :         12 :           error_at (loc, "version control conflict marker in file");
     965                 :         12 :           return true;
     966                 :            :         }
     967                 :            :     }
     968                 :            : 
     969                 :       3448 :   c_parse_error (gmsgid,
     970                 :            :                  /* Because c_parse_error does not understand
     971                 :            :                     CPP_KEYWORD, keywords are treated like
     972                 :            :                     identifiers.  */
     973                 :       1724 :                  (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
     974                 :            :                  /* ??? The C parser does not save the cpp flags of a
     975                 :            :                     token, we need to pass 0 here and we will not get
     976                 :            :                     the source spelling of some tokens but rather the
     977                 :            :                     canonical spelling.  */
     978                 :            :                  token->value, /*flags=*/0, richloc);
     979                 :       1724 :   return true;
     980                 :            : }
     981                 :            : 
     982                 :            : /* As c_parser_error_richloc, but issue the message at the
     983                 :            :    location of PARSER's next token, or at input_location
     984                 :            :    if the next token is EOF.  */
     985                 :            : 
     986                 :            : bool
     987                 :       1450 : c_parser_error (c_parser *parser, const char *gmsgid)
     988                 :            : {
     989                 :       1450 :   c_token *token = c_parser_peek_token (parser);
     990                 :       1450 :   c_parser_set_source_position_from_token (token);
     991                 :       2900 :   rich_location richloc (line_table, input_location);
     992                 :       1450 :   return c_parser_error_richloc (parser, gmsgid, &richloc);
     993                 :            : }
     994                 :            : 
     995                 :            : /* Some tokens naturally come in pairs e.g.'(' and ')'.
     996                 :            :    This class is for tracking such a matching pair of symbols.
     997                 :            :    In particular, it tracks the location of the first token,
     998                 :            :    so that if the second token is missing, we can highlight the
     999                 :            :    location of the first token when notifying the user about the
    1000                 :            :    problem.  */
    1001                 :            : 
    1002                 :            : template <typename traits_t>
    1003                 :            : class token_pair
    1004                 :            : {
    1005                 :            :  public:
    1006                 :            :   /* token_pair's ctor.  */
    1007                 :   76043100 :   token_pair () : m_open_loc (UNKNOWN_LOCATION) {}
    1008                 :            : 
    1009                 :            :   /* If the next token is the opening symbol for this pair, consume it and
    1010                 :            :      return true.
    1011                 :            :      Otherwise, issue an error and return false.
    1012                 :            :      In either case, record the location of the opening token.  */
    1013                 :            : 
    1014                 :            :   bool require_open (c_parser *parser)
    1015                 :            :   {
    1016                 :            :     c_token *token = c_parser_peek_token (parser);
    1017                 :            :     if (token)
    1018                 :            :       m_open_loc = token->location;
    1019                 :            : 
    1020                 :            :     return c_parser_require (parser, traits_t::open_token_type,
    1021                 :            :                              traits_t::open_gmsgid);
    1022                 :            :   }
    1023                 :            : 
    1024                 :            :   /* Consume the next token from PARSER, recording its location as
    1025                 :            :      that of the opening token within the pair.  */
    1026                 :            : 
    1027                 :            :   void consume_open (c_parser *parser)
    1028                 :            :   {
    1029                 :            :     c_token *token = c_parser_peek_token (parser);
    1030                 :            :     gcc_assert (token->type == traits_t::open_token_type);
    1031                 :            :     m_open_loc = token->location;
    1032                 :            :     c_parser_consume_token (parser);
    1033                 :            :   }
    1034                 :            : 
    1035                 :            :   /* If the next token is the closing symbol for this pair, consume it
    1036                 :            :      and return true.
    1037                 :            :      Otherwise, issue an error, highlighting the location of the
    1038                 :            :      corresponding opening token, and return false.  */
    1039                 :            : 
    1040                 :    1253180 :   bool require_close (c_parser *parser) const
    1041                 :            :   {
    1042                 :    1253180 :     return c_parser_require (parser, traits_t::close_token_type,
    1043                 :          0 :                              traits_t::close_gmsgid, m_open_loc);
    1044                 :            :   }
    1045                 :            : 
    1046                 :            :   /* Like token_pair::require_close, except that tokens will be skipped
    1047                 :            :      until the desired token is found.  An error message is still produced
    1048                 :            :      if the next token is not as expected.  */
    1049                 :            : 
    1050                 :   73952700 :   void skip_until_found_close (c_parser *parser) const
    1051                 :            :   {
    1052                 :   73952700 :     c_parser_skip_until_found (parser, traits_t::close_token_type,
    1053                 :            :                                traits_t::close_gmsgid, m_open_loc);
    1054                 :    1066010 :   }
    1055                 :            : 
    1056                 :            :  private:
    1057                 :            :   location_t m_open_loc;
    1058                 :            : };
    1059                 :            : 
    1060                 :            : /* Traits for token_pair<T> for tracking matching pairs of parentheses.  */
    1061                 :            : 
    1062                 :            : struct matching_paren_traits
    1063                 :            : {
    1064                 :            :   static const enum cpp_ttype open_token_type = CPP_OPEN_PAREN;
    1065                 :            :   static const char * const open_gmsgid;
    1066                 :            :   static const enum cpp_ttype close_token_type = CPP_CLOSE_PAREN;
    1067                 :            :   static const char * const close_gmsgid;
    1068                 :            : };
    1069                 :            : 
    1070                 :            : const char * const matching_paren_traits::open_gmsgid = "expected %<(%>";
    1071                 :            : const char * const matching_paren_traits::close_gmsgid = "expected %<)%>";
    1072                 :            : 
    1073                 :            : /* "matching_parens" is a token_pair<T> class for tracking matching
    1074                 :            :    pairs of parentheses.  */
    1075                 :            : 
    1076                 :            : typedef token_pair<matching_paren_traits> matching_parens;
    1077                 :            : 
    1078                 :            : /* Traits for token_pair<T> for tracking matching pairs of braces.  */
    1079                 :            : 
    1080                 :            : struct matching_brace_traits
    1081                 :            : {
    1082                 :            :   static const enum cpp_ttype open_token_type = CPP_OPEN_BRACE;
    1083                 :            :   static const char * const open_gmsgid;
    1084                 :            :   static const enum cpp_ttype close_token_type = CPP_CLOSE_BRACE;
    1085                 :            :   static const char * const close_gmsgid;
    1086                 :            : };
    1087                 :            : 
    1088                 :            : const char * const matching_brace_traits::open_gmsgid = "expected %<{%>";
    1089                 :            : const char * const matching_brace_traits::close_gmsgid = "expected %<}%>";
    1090                 :            : 
    1091                 :            : /* "matching_braces" is a token_pair<T> class for tracking matching
    1092                 :            :    pairs of braces.  */
    1093                 :            : 
    1094                 :            : typedef token_pair<matching_brace_traits> matching_braces;
    1095                 :            : 
    1096                 :            : /* Get a description of the matching symbol to TYPE e.g. "(" for
    1097                 :            :    CPP_CLOSE_PAREN.  */
    1098                 :            : 
    1099                 :            : static const char *
    1100                 :          3 : get_matching_symbol (enum cpp_ttype type)
    1101                 :            : {
    1102                 :          0 :   switch (type)
    1103                 :            :     {
    1104                 :          0 :     default:
    1105                 :          0 :       gcc_unreachable ();
    1106                 :            :       return "";
    1107                 :            :     case CPP_CLOSE_PAREN:
    1108                 :            :       return "(";
    1109                 :          1 :     case CPP_CLOSE_BRACE:
    1110                 :          1 :       return "{";
    1111                 :            :     }
    1112                 :            : }
    1113                 :            : 
    1114                 :            : /* If the next token is of the indicated TYPE, consume it.  Otherwise,
    1115                 :            :    issue the error MSGID.  If MSGID is NULL then a message has already
    1116                 :            :    been produced and no message will be produced this time.  Returns
    1117                 :            :    true if found, false otherwise.
    1118                 :            : 
    1119                 :            :    If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
    1120                 :            :    within any error as the location of an "opening" token matching
    1121                 :            :    the close token TYPE (e.g. the location of the '(' when TYPE is
    1122                 :            :    CPP_CLOSE_PAREN).
    1123                 :            : 
    1124                 :            :    If TYPE_IS_UNIQUE is true (the default) then msgid describes exactly
    1125                 :            :    one type (e.g. "expected %<)%>") and thus it may be reasonable to
    1126                 :            :    attempt to generate a fix-it hint for the problem.
    1127                 :            :    Otherwise msgid describes multiple token types (e.g.
    1128                 :            :    "expected %<;%>, %<,%> or %<)%>"), and thus we shouldn't attempt to
    1129                 :            :    generate a fix-it hint.  */
    1130                 :            : 
    1131                 :            : bool
    1132                 :  264157000 : c_parser_require (c_parser *parser,
    1133                 :            :                   enum cpp_ttype type,
    1134                 :            :                   const char *msgid,
    1135                 :            :                   location_t matching_location,
    1136                 :            :                   bool type_is_unique)
    1137                 :            : {
    1138                 :  264157000 :   if (c_parser_next_token_is (parser, type))
    1139                 :            :     {
    1140                 :  264156000 :       c_parser_consume_token (parser);
    1141                 :  264156000 :       return true;
    1142                 :            :     }
    1143                 :            :   else
    1144                 :            :     {
    1145                 :        898 :       location_t next_token_loc = c_parser_peek_token (parser)->location;
    1146                 :       1796 :       gcc_rich_location richloc (next_token_loc);
    1147                 :            : 
    1148                 :            :       /* Potentially supply a fix-it hint, suggesting to add the
    1149                 :            :          missing token immediately after the *previous* token.
    1150                 :            :          This may move the primary location within richloc.  */
    1151                 :        898 :       if (!parser->error && type_is_unique)
    1152                 :        535 :         maybe_suggest_missing_token_insertion (&richloc, type,
    1153                 :            :                                                parser->last_token_location);
    1154                 :            : 
    1155                 :            :       /* If matching_location != UNKNOWN_LOCATION, highlight it.
    1156                 :            :          Attempt to consolidate diagnostics by printing it as a
    1157                 :            :          secondary range within the main diagnostic.  */
    1158                 :        898 :       bool added_matching_location = false;
    1159                 :        898 :       if (matching_location != UNKNOWN_LOCATION)
    1160                 :        262 :         added_matching_location
    1161                 :        262 :           = richloc.add_location_if_nearby (matching_location);
    1162                 :            : 
    1163                 :        898 :       if (c_parser_error_richloc (parser, msgid, &richloc))
    1164                 :            :         /* If we weren't able to consolidate matching_location, then
    1165                 :            :            print it as a secondary diagnostic.  */
    1166                 :        450 :         if (matching_location != UNKNOWN_LOCATION && !added_matching_location)
    1167                 :          4 :           inform (matching_location, "to match this %qs",
    1168                 :            :                   get_matching_symbol (type));
    1169                 :            : 
    1170                 :        898 :       return false;
    1171                 :            :     }
    1172                 :            : }
    1173                 :            : 
    1174                 :            : /* If the next token is the indicated keyword, consume it.  Otherwise,
    1175                 :            :    issue the error MSGID.  Returns true if found, false otherwise.  */
    1176                 :            : 
    1177                 :            : static bool
    1178                 :     109846 : c_parser_require_keyword (c_parser *parser,
    1179                 :            :                           enum rid keyword,
    1180                 :            :                           const char *msgid)
    1181                 :            : {
    1182                 :     109846 :   if (c_parser_next_token_is_keyword (parser, keyword))
    1183                 :            :     {
    1184                 :     109846 :       c_parser_consume_token (parser);
    1185                 :     109846 :       return true;
    1186                 :            :     }
    1187                 :            :   else
    1188                 :            :     {
    1189                 :          0 :       c_parser_error (parser, msgid);
    1190                 :          0 :       return false;
    1191                 :            :     }
    1192                 :            : }
    1193                 :            : 
    1194                 :            : /* Like c_parser_require, except that tokens will be skipped until the
    1195                 :            :    desired token is found.  An error message is still produced if the
    1196                 :            :    next token is not as expected.  If MSGID is NULL then a message has
    1197                 :            :    already been produced and no message will be produced this
    1198                 :            :    time.
    1199                 :            : 
    1200                 :            :    If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
    1201                 :            :    within any error as the location of an "opening" token matching
    1202                 :            :    the close token TYPE (e.g. the location of the '(' when TYPE is
    1203                 :            :    CPP_CLOSE_PAREN).  */
    1204                 :            : 
    1205                 :            : void
    1206                 :  131881000 : c_parser_skip_until_found (c_parser *parser,
    1207                 :            :                            enum cpp_ttype type,
    1208                 :            :                            const char *msgid,
    1209                 :            :                            location_t matching_location)
    1210                 :            : {
    1211                 :  131881000 :   unsigned nesting_depth = 0;
    1212                 :            : 
    1213                 :  131881000 :   if (c_parser_require (parser, type, msgid, matching_location))
    1214                 :            :     return;
    1215                 :            : 
    1216                 :            :   /* Skip tokens until the desired token is found.  */
    1217                 :       4717 :   while (true)
    1218                 :            :     {
    1219                 :            :       /* Peek at the next token.  */
    1220                 :       2729 :       c_token *token = c_parser_peek_token (parser);
    1221                 :            :       /* If we've reached the token we want, consume it and stop.  */
    1222                 :       2729 :       if (token->type == type && !nesting_depth)
    1223                 :            :         {
    1224                 :        568 :           c_parser_consume_token (parser);
    1225                 :        568 :           break;
    1226                 :            :         }
    1227                 :            : 
    1228                 :            :       /* If we've run out of tokens, stop.  */
    1229                 :       2161 :       if (token->type == CPP_EOF)
    1230                 :            :         return;
    1231                 :       2143 :       if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
    1232                 :            :         return;
    1233                 :       2092 :       if (token->type == CPP_OPEN_BRACE
    1234                 :       2092 :           || token->type == CPP_OPEN_PAREN
    1235                 :       1887 :           || token->type == CPP_OPEN_SQUARE)
    1236                 :        239 :         ++nesting_depth;
    1237                 :       1853 :       else if (token->type == CPP_CLOSE_BRACE
    1238                 :       1853 :                || token->type == CPP_CLOSE_PAREN
    1239                 :       1544 :                || token->type == CPP_CLOSE_SQUARE)
    1240                 :            :         {
    1241                 :        342 :           if (nesting_depth-- == 0)
    1242                 :            :             break;
    1243                 :            :         }
    1244                 :            :       /* Consume this token.  */
    1245                 :       1988 :       c_parser_consume_token (parser);
    1246                 :       1988 :     }
    1247                 :        672 :   parser->error = false;
    1248                 :            : }
    1249                 :            : 
    1250                 :            : /* Skip tokens until the end of a parameter is found, but do not
    1251                 :            :    consume the comma, semicolon or closing delimiter.  */
    1252                 :            : 
    1253                 :            : static void
    1254                 :         94 : c_parser_skip_to_end_of_parameter (c_parser *parser)
    1255                 :            : {
    1256                 :         94 :   unsigned nesting_depth = 0;
    1257                 :            : 
    1258                 :        492 :   while (true)
    1259                 :            :     {
    1260                 :        293 :       c_token *token = c_parser_peek_token (parser);
    1261                 :        293 :       if ((token->type == CPP_COMMA || token->type == CPP_SEMICOLON)
    1262                 :         25 :           && !nesting_depth)
    1263                 :            :         break;
    1264                 :            :       /* If we've run out of tokens, stop.  */
    1265                 :        268 :       if (token->type == CPP_EOF)
    1266                 :            :         return;
    1267                 :        268 :       if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
    1268                 :            :         return;
    1269                 :        268 :       if (token->type == CPP_OPEN_BRACE
    1270                 :        268 :           || token->type == CPP_OPEN_PAREN
    1271                 :        266 :           || token->type == CPP_OPEN_SQUARE)
    1272                 :          3 :         ++nesting_depth;
    1273                 :        265 :       else if (token->type == CPP_CLOSE_BRACE
    1274                 :        265 :                || token->type == CPP_CLOSE_PAREN
    1275                 :        194 :                || token->type == CPP_CLOSE_SQUARE)
    1276                 :            :         {
    1277                 :         72 :           if (nesting_depth-- == 0)
    1278                 :            :             break;
    1279                 :            :         }
    1280                 :            :       /* Consume this token.  */
    1281                 :        199 :       c_parser_consume_token (parser);
    1282                 :        199 :     }
    1283                 :         94 :   parser->error = false;
    1284                 :            : }
    1285                 :            : 
    1286                 :            : /* Expect to be at the end of the pragma directive and consume an
    1287                 :            :    end of line marker.  */
    1288                 :            : 
    1289                 :            : static void
    1290                 :     804412 : c_parser_skip_to_pragma_eol (c_parser *parser, bool error_if_not_eol = true)
    1291                 :            : {
    1292                 :     804412 :   gcc_assert (parser->in_pragma);
    1293                 :     804412 :   parser->in_pragma = false;
    1294                 :            : 
    1295                 :     804412 :   if (error_if_not_eol && c_parser_peek_token (parser)->type != CPP_PRAGMA_EOL)
    1296                 :        100 :     c_parser_error (parser, "expected end of line");
    1297                 :            : 
    1298                 :     805045 :   cpp_ttype token_type;
    1299                 :     805045 :   do
    1300                 :            :     {
    1301                 :     805045 :       c_token *token = c_parser_peek_token (parser);
    1302                 :     805045 :       token_type = token->type;
    1303                 :     805045 :       if (token_type == CPP_EOF)
    1304                 :            :         break;
    1305                 :     805045 :       c_parser_consume_token (parser);
    1306                 :            :     }
    1307                 :     805045 :   while (token_type != CPP_PRAGMA_EOL);
    1308                 :            : 
    1309                 :     804412 :   parser->error = false;
    1310                 :     804412 : }
    1311                 :            : 
    1312                 :            : /* Skip tokens until we have consumed an entire block, or until we
    1313                 :            :    have consumed a non-nested ';'.  */
    1314                 :            : 
    1315                 :            : static void
    1316                 :        341 : c_parser_skip_to_end_of_block_or_statement (c_parser *parser)
    1317                 :            : {
    1318                 :        341 :   unsigned nesting_depth = 0;
    1319                 :        341 :   bool save_error = parser->error;
    1320                 :            : 
    1321                 :       1230 :   while (true)
    1322                 :            :     {
    1323                 :       1230 :       c_token *token;
    1324                 :            : 
    1325                 :            :       /* Peek at the next token.  */
    1326                 :       1230 :       token = c_parser_peek_token (parser);
    1327                 :            : 
    1328                 :       1230 :       switch (token->type)
    1329                 :            :         {
    1330                 :            :         case CPP_EOF:
    1331                 :            :           return;
    1332                 :            : 
    1333                 :          0 :         case CPP_PRAGMA_EOL:
    1334                 :          0 :           if (parser->in_pragma)
    1335                 :            :             return;
    1336                 :            :           break;
    1337                 :            : 
    1338                 :        312 :         case CPP_SEMICOLON:
    1339                 :            :           /* If the next token is a ';', we have reached the
    1340                 :            :              end of the statement.  */
    1341                 :        312 :           if (!nesting_depth)
    1342                 :            :             {
    1343                 :            :               /* Consume the ';'.  */
    1344                 :        271 :               c_parser_consume_token (parser);
    1345                 :        271 :               goto finished;
    1346                 :            :             }
    1347                 :            :           break;
    1348                 :            : 
    1349                 :         59 :         case CPP_CLOSE_BRACE:
    1350                 :            :           /* If the next token is a non-nested '}', then we have
    1351                 :            :              reached the end of the current block.  */
    1352                 :         59 :           if (nesting_depth == 0 || --nesting_depth == 0)
    1353                 :            :             {
    1354                 :         59 :               c_parser_consume_token (parser);
    1355                 :         59 :               goto finished;
    1356                 :            :             }
    1357                 :            :           break;
    1358                 :            : 
    1359                 :         35 :         case CPP_OPEN_BRACE:
    1360                 :            :           /* If it the next token is a '{', then we are entering a new
    1361                 :            :              block.  Consume the entire block.  */
    1362                 :         35 :           ++nesting_depth;
    1363                 :         35 :           break;
    1364                 :            : 
    1365                 :          5 :         case CPP_PRAGMA:
    1366                 :            :           /* If we see a pragma, consume the whole thing at once.  We
    1367                 :            :              have some safeguards against consuming pragmas willy-nilly.
    1368                 :            :              Normally, we'd expect to be here with parser->error set,
    1369                 :            :              which disables these safeguards.  But it's possible to get
    1370                 :            :              here for secondary error recovery, after parser->error has
    1371                 :            :              been cleared.  */
    1372                 :          5 :           c_parser_consume_pragma (parser);
    1373                 :          5 :           c_parser_skip_to_pragma_eol (parser);
    1374                 :          5 :           parser->error = save_error;
    1375                 :          5 :           continue;
    1376                 :            : 
    1377                 :            :         default:
    1378                 :            :           break;
    1379                 :            :         }
    1380                 :            : 
    1381                 :        884 :       c_parser_consume_token (parser);
    1382                 :            :     }
    1383                 :            : 
    1384                 :        330 :  finished:
    1385                 :        330 :   parser->error = false;
    1386                 :            : }
    1387                 :            : 
    1388                 :            : /* CPP's options (initialized by c-opts.c).  */
    1389                 :            : extern cpp_options *cpp_opts;
    1390                 :            : 
    1391                 :            : /* Save the warning flags which are controlled by __extension__.  */
    1392                 :            : 
    1393                 :            : static inline int
    1394                 :     642900 : disable_extension_diagnostics (void)
    1395                 :            : {
    1396                 :    1285800 :   int ret = (pedantic
    1397                 :     642900 :              | (warn_pointer_arith << 1)
    1398                 :     642900 :              | (warn_traditional << 2)
    1399                 :     642900 :              | (flag_iso << 3)
    1400                 :     642900 :              | (warn_long_long << 4)
    1401                 :     642900 :              | (warn_cxx_compat << 5)
    1402                 :     642900 :              | (warn_overlength_strings << 6)
    1403                 :            :              /* warn_c90_c99_compat has three states: -1/0/1, so we must
    1404                 :            :                 play tricks to properly restore it.  */
    1405                 :     642900 :              | ((warn_c90_c99_compat == 1) << 7)
    1406                 :     642900 :              | ((warn_c90_c99_compat == -1) << 8)
    1407                 :            :              /* Similarly for warn_c99_c11_compat.  */
    1408                 :     642900 :              | ((warn_c99_c11_compat == 1) << 9)
    1409                 :     642900 :              | ((warn_c99_c11_compat == -1) << 10)
    1410                 :            :              /* Similarly for warn_c11_c2x_compat.  */
    1411                 :     642900 :              | ((warn_c11_c2x_compat == 1) << 11)
    1412                 :     642900 :              | ((warn_c11_c2x_compat == -1) << 12)
    1413                 :            :              );
    1414                 :     642900 :   cpp_opts->cpp_pedantic = pedantic = 0;
    1415                 :     642900 :   warn_pointer_arith = 0;
    1416                 :     642900 :   cpp_opts->cpp_warn_traditional = warn_traditional = 0;
    1417                 :     642900 :   flag_iso = 0;
    1418                 :     642900 :   cpp_opts->cpp_warn_long_long = warn_long_long = 0;
    1419                 :     642900 :   warn_cxx_compat = 0;
    1420                 :     642900 :   warn_overlength_strings = 0;
    1421                 :     642900 :   warn_c90_c99_compat = 0;
    1422                 :     642900 :   warn_c99_c11_compat = 0;
    1423                 :     642900 :   warn_c11_c2x_compat = 0;
    1424                 :     642900 :   return ret;
    1425                 :            : }
    1426                 :            : 
    1427                 :            : /* Restore the warning flags which are controlled by __extension__.
    1428                 :            :    FLAGS is the return value from disable_extension_diagnostics.  */
    1429                 :            : 
    1430                 :            : static inline void
    1431                 :     642900 : restore_extension_diagnostics (int flags)
    1432                 :            : {
    1433                 :     642900 :   cpp_opts->cpp_pedantic = pedantic = flags & 1;
    1434                 :     642900 :   warn_pointer_arith = (flags >> 1) & 1;
    1435                 :     642900 :   cpp_opts->cpp_warn_traditional = warn_traditional = (flags >> 2) & 1;
    1436                 :     642900 :   flag_iso = (flags >> 3) & 1;
    1437                 :     642900 :   cpp_opts->cpp_warn_long_long = warn_long_long = (flags >> 4) & 1;
    1438                 :     642900 :   warn_cxx_compat = (flags >> 5) & 1;
    1439                 :     642900 :   warn_overlength_strings = (flags >> 6) & 1;
    1440                 :            :   /* See above for why is this needed.  */
    1441                 :     642900 :   warn_c90_c99_compat = (flags >> 7) & 1 ? 1 : ((flags >> 8) & 1 ? -1 : 0);
    1442                 :     642900 :   warn_c99_c11_compat = (flags >> 9) & 1 ? 1 : ((flags >> 10) & 1 ? -1 : 0);
    1443                 :     642900 :   warn_c11_c2x_compat = (flags >> 11) & 1 ? 1 : ((flags >> 12) & 1 ? -1 : 0);
    1444                 :     642900 : }
    1445                 :            : 
    1446                 :            : /* Helper data structure for parsing #pragma acc routine.  */
    1447                 :            : struct oacc_routine_data {
    1448                 :            :   bool error_seen; /* Set if error has been reported.  */
    1449                 :            :   bool fndecl_seen; /* Set if one fn decl/definition has been seen already.  */
    1450                 :            :   tree clauses;
    1451                 :            :   location_t loc;
    1452                 :            : };
    1453                 :            : 
    1454                 :            : static bool c_parser_nth_token_starts_std_attributes (c_parser *,
    1455                 :            :                                                       unsigned int);
    1456                 :            : static tree c_parser_std_attribute_specifier_sequence (c_parser *);
    1457                 :            : static void c_parser_external_declaration (c_parser *);
    1458                 :            : static void c_parser_asm_definition (c_parser *);
    1459                 :            : static void c_parser_declaration_or_fndef (c_parser *, bool, bool, bool,
    1460                 :            :                                            bool, bool, tree *, vec<c_token>,
    1461                 :            :                                            bool have_attrs = false,
    1462                 :            :                                            tree attrs = NULL,
    1463                 :            :                                            struct oacc_routine_data * = NULL,
    1464                 :            :                                            bool * = NULL);
    1465                 :            : static void c_parser_static_assert_declaration_no_semi (c_parser *);
    1466                 :            : static void c_parser_static_assert_declaration (c_parser *);
    1467                 :            : static struct c_typespec c_parser_enum_specifier (c_parser *);
    1468                 :            : static struct c_typespec c_parser_struct_or_union_specifier (c_parser *);
    1469                 :            : static tree c_parser_struct_declaration (c_parser *);
    1470                 :            : static struct c_typespec c_parser_typeof_specifier (c_parser *);
    1471                 :            : static tree c_parser_alignas_specifier (c_parser *);
    1472                 :            : static struct c_declarator *c_parser_direct_declarator (c_parser *, bool,
    1473                 :            :                                                         c_dtr_syn, bool *);
    1474                 :            : static struct c_declarator *c_parser_direct_declarator_inner (c_parser *,
    1475                 :            :                                                               bool,
    1476                 :            :                                                               struct c_declarator *);
    1477                 :            : static struct c_arg_info *c_parser_parms_declarator (c_parser *, bool, tree,
    1478                 :            :                                                      bool);
    1479                 :            : static struct c_arg_info *c_parser_parms_list_declarator (c_parser *, tree,
    1480                 :            :                                                           tree, bool);
    1481                 :            : static struct c_parm *c_parser_parameter_declaration (c_parser *, tree, bool);
    1482                 :            : static tree c_parser_simple_asm_expr (c_parser *);
    1483                 :            : static tree c_parser_gnu_attributes (c_parser *);
    1484                 :            : static struct c_expr c_parser_initializer (c_parser *);
    1485                 :            : static struct c_expr c_parser_braced_init (c_parser *, tree, bool,
    1486                 :            :                                            struct obstack *);
    1487                 :            : static void c_parser_initelt (c_parser *, struct obstack *);
    1488                 :            : static void c_parser_initval (c_parser *, struct c_expr *,
    1489                 :            :                               struct obstack *);
    1490                 :            : static tree c_parser_compound_statement (c_parser *, location_t * = NULL);
    1491                 :            : static location_t c_parser_compound_statement_nostart (c_parser *);
    1492                 :            : static void c_parser_label (c_parser *);
    1493                 :            : static void c_parser_statement (c_parser *, bool *, location_t * = NULL);
    1494                 :            : static void c_parser_statement_after_labels (c_parser *, bool *,
    1495                 :            :                                              vec<tree> * = NULL);
    1496                 :            : static tree c_parser_c99_block_statement (c_parser *, bool *,
    1497                 :            :                                           location_t * = NULL);
    1498                 :            : static void c_parser_if_statement (c_parser *, bool *, vec<tree> *);
    1499                 :            : static void c_parser_switch_statement (c_parser *, bool *);
    1500                 :            : static void c_parser_while_statement (c_parser *, bool, unsigned short, bool *);
    1501                 :            : static void c_parser_do_statement (c_parser *, bool, unsigned short);
    1502                 :            : static void c_parser_for_statement (c_parser *, bool, unsigned short, bool *);
    1503                 :            : static tree c_parser_asm_statement (c_parser *);
    1504                 :            : static tree c_parser_asm_operands (c_parser *);
    1505                 :            : static tree c_parser_asm_goto_operands (c_parser *);
    1506                 :            : static tree c_parser_asm_clobbers (c_parser *);
    1507                 :            : static struct c_expr c_parser_expr_no_commas (c_parser *, struct c_expr *,
    1508                 :            :                                               tree = NULL_TREE);
    1509                 :            : static struct c_expr c_parser_conditional_expression (c_parser *,
    1510                 :            :                                                       struct c_expr *, tree);
    1511                 :            : static struct c_expr c_parser_binary_expression (c_parser *, struct c_expr *,
    1512                 :            :                                                  tree);
    1513                 :            : static struct c_expr c_parser_cast_expression (c_parser *, struct c_expr *);
    1514                 :            : static struct c_expr c_parser_unary_expression (c_parser *);
    1515                 :            : static struct c_expr c_parser_sizeof_expression (c_parser *);
    1516                 :            : static struct c_expr c_parser_alignof_expression (c_parser *);
    1517                 :            : static struct c_expr c_parser_postfix_expression (c_parser *);
    1518                 :            : static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *,
    1519                 :            :                                                                    struct c_type_name *,
    1520                 :            :                                                                    location_t);
    1521                 :            : static struct c_expr c_parser_postfix_expression_after_primary (c_parser *,
    1522                 :            :                                                                 location_t loc,
    1523                 :            :                                                                 struct c_expr);
    1524                 :            : static tree c_parser_transaction (c_parser *, enum rid);
    1525                 :            : static struct c_expr c_parser_transaction_expression (c_parser *, enum rid);
    1526                 :            : static tree c_parser_transaction_cancel (c_parser *);
    1527                 :            : static struct c_expr c_parser_expression (c_parser *);
    1528                 :            : static struct c_expr c_parser_expression_conv (c_parser *);
    1529                 :            : static vec<tree, va_gc> *c_parser_expr_list (c_parser *, bool, bool,
    1530                 :            :                                              vec<tree, va_gc> **, location_t *,
    1531                 :            :                                              tree *, vec<location_t> *,
    1532                 :            :                                              unsigned int * = NULL);
    1533                 :            : static struct c_expr c_parser_has_attribute_expression (c_parser *);
    1534                 :            : 
    1535                 :            : static void c_parser_oacc_declare (c_parser *);
    1536                 :            : static void c_parser_oacc_enter_exit_data (c_parser *, bool);
    1537                 :            : static void c_parser_oacc_update (c_parser *);
    1538                 :            : static void c_parser_omp_construct (c_parser *, bool *);
    1539                 :            : static void c_parser_omp_threadprivate (c_parser *);
    1540                 :            : static void c_parser_omp_barrier (c_parser *);
    1541                 :            : static void c_parser_omp_depobj (c_parser *);
    1542                 :            : static void c_parser_omp_flush (c_parser *);
    1543                 :            : static tree c_parser_omp_for_loop (location_t, c_parser *, enum tree_code,
    1544                 :            :                                    tree, tree *, bool *);
    1545                 :            : static void c_parser_omp_taskwait (c_parser *);
    1546                 :            : static void c_parser_omp_taskyield (c_parser *);
    1547                 :            : static void c_parser_omp_cancel (c_parser *);
    1548                 :            : 
    1549                 :            : enum pragma_context { pragma_external, pragma_struct, pragma_param,
    1550                 :            :                       pragma_stmt, pragma_compound };
    1551                 :            : static bool c_parser_pragma (c_parser *, enum pragma_context, bool *);
    1552                 :            : static void c_parser_omp_cancellation_point (c_parser *, enum pragma_context);
    1553                 :            : static bool c_parser_omp_target (c_parser *, enum pragma_context, bool *);
    1554                 :            : static void c_parser_omp_end_declare_target (c_parser *);
    1555                 :            : static void c_parser_omp_declare (c_parser *, enum pragma_context);
    1556                 :            : static void c_parser_omp_requires (c_parser *);
    1557                 :            : static bool c_parser_omp_ordered (c_parser *, enum pragma_context, bool *);
    1558                 :            : static void c_parser_oacc_routine (c_parser *, enum pragma_context);
    1559                 :            : 
    1560                 :            : /* These Objective-C parser functions are only ever called when
    1561                 :            :    compiling Objective-C.  */
    1562                 :            : static void c_parser_objc_class_definition (c_parser *, tree);
    1563                 :            : static void c_parser_objc_class_instance_variables (c_parser *);
    1564                 :            : static void c_parser_objc_class_declaration (c_parser *);
    1565                 :            : static void c_parser_objc_alias_declaration (c_parser *);
    1566                 :            : static void c_parser_objc_protocol_definition (c_parser *, tree);
    1567                 :            : static bool c_parser_objc_method_type (c_parser *);
    1568                 :            : static void c_parser_objc_method_definition (c_parser *);
    1569                 :            : static void c_parser_objc_methodprotolist (c_parser *);
    1570                 :            : static void c_parser_objc_methodproto (c_parser *);
    1571                 :            : static tree c_parser_objc_method_decl (c_parser *, bool, tree *, tree *);
    1572                 :            : static tree c_parser_objc_type_name (c_parser *);
    1573                 :            : static tree c_parser_objc_protocol_refs (c_parser *);
    1574                 :            : static void c_parser_objc_try_catch_finally_statement (c_parser *);
    1575                 :            : static void c_parser_objc_synchronized_statement (c_parser *);
    1576                 :            : static tree c_parser_objc_selector (c_parser *);
    1577                 :            : static tree c_parser_objc_selector_arg (c_parser *);
    1578                 :            : static tree c_parser_objc_receiver (c_parser *);
    1579                 :            : static tree c_parser_objc_message_args (c_parser *);
    1580                 :            : static tree c_parser_objc_keywordexpr (c_parser *);
    1581                 :            : static void c_parser_objc_at_property_declaration (c_parser *);
    1582                 :            : static void c_parser_objc_at_synthesize_declaration (c_parser *);
    1583                 :            : static void c_parser_objc_at_dynamic_declaration (c_parser *);
    1584                 :            : static bool c_parser_objc_diagnose_bad_element_prefix
    1585                 :            :   (c_parser *, struct c_declspecs *);
    1586                 :            : static location_t c_parser_parse_rtl_body (c_parser *, char *);
    1587                 :            : 
    1588                 :            : /* Parse a translation unit (C90 6.7, C99 6.9, C11 6.9).
    1589                 :            : 
    1590                 :            :    translation-unit:
    1591                 :            :      external-declarations
    1592                 :            : 
    1593                 :            :    external-declarations:
    1594                 :            :      external-declaration
    1595                 :            :      external-declarations external-declaration
    1596                 :            : 
    1597                 :            :    GNU extensions:
    1598                 :            : 
    1599                 :            :    translation-unit:
    1600                 :            :      empty
    1601                 :            : */
    1602                 :            : 
    1603                 :            : static void
    1604                 :      77028 : c_parser_translation_unit (c_parser *parser)
    1605                 :            : {
    1606                 :      77028 :   if (c_parser_next_token_is (parser, CPP_EOF))
    1607                 :            :     {
    1608                 :        597 :       pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
    1609                 :            :                "ISO C forbids an empty translation unit");
    1610                 :            :     }
    1611                 :            :   else
    1612                 :            :     {
    1613                 :      76431 :       void *obstack_position = obstack_alloc (&parser_obstack, 0);
    1614                 :      76431 :       mark_valid_location_for_stdc_pragma (false);
    1615                 :   35537000 :       do
    1616                 :            :         {
    1617                 :   35537000 :           ggc_collect ();
    1618                 :   35537000 :           c_parser_external_declaration (parser);
    1619                 :   35536900 :           obstack_free (&parser_obstack, obstack_position);
    1620                 :            :         }
    1621                 :   35536900 :       while (c_parser_next_token_is_not (parser, CPP_EOF));
    1622                 :            :     }
    1623                 :            : 
    1624                 :            :   unsigned int i;
    1625                 :            :   tree decl;
    1626                 :      77119 :   FOR_EACH_VEC_ELT (incomplete_record_decls, i, decl)
    1627                 :        150 :     if (DECL_SIZE (decl) == NULL_TREE && TREE_TYPE (decl) != error_mark_node)
    1628                 :         17 :       error ("storage size of %q+D isn%'t known", decl);
    1629                 :            : 
    1630                 :      76969 :   if (current_omp_declare_target_attribute)
    1631                 :            :     {
    1632                 :          1 :       if (!errorcount)
    1633                 :          1 :         error ("%<#pragma omp declare target%> without corresponding "
    1634                 :            :                "%<#pragma omp end declare target%>");
    1635                 :          1 :       current_omp_declare_target_attribute = 0;
    1636                 :            :     }
    1637                 :      76969 : }
    1638                 :            : 
    1639                 :            : /* Parse an external declaration (C90 6.7, C99 6.9, C11 6.9).
    1640                 :            : 
    1641                 :            :    external-declaration:
    1642                 :            :      function-definition
    1643                 :            :      declaration
    1644                 :            : 
    1645                 :            :    GNU extensions:
    1646                 :            : 
    1647                 :            :    external-declaration:
    1648                 :            :      asm-definition
    1649                 :            :      ;
    1650                 :            :      __extension__ external-declaration
    1651                 :            : 
    1652                 :            :    Objective-C:
    1653                 :            : 
    1654                 :            :    external-declaration:
    1655                 :            :      objc-class-definition
    1656                 :            :      objc-class-declaration
    1657                 :            :      objc-alias-declaration
    1658                 :            :      objc-protocol-definition
    1659                 :            :      objc-method-definition
    1660                 :            :      @end
    1661                 :            : */
    1662                 :            : 
    1663                 :            : static void
    1664                 :   35820500 : c_parser_external_declaration (c_parser *parser)
    1665                 :            : {
    1666                 :   35820500 :   int ext;
    1667                 :   35820500 :   switch (c_parser_peek_token (parser)->type)
    1668                 :            :     {
    1669                 :   34888500 :     case CPP_KEYWORD:
    1670                 :   34888500 :       switch (c_parser_peek_token (parser)->keyword)
    1671                 :            :         {
    1672                 :     283569 :         case RID_EXTENSION:
    1673                 :     283569 :           ext = disable_extension_diagnostics ();
    1674                 :     283569 :           c_parser_consume_token (parser);
    1675                 :     283569 :           c_parser_external_declaration (parser);
    1676                 :     283569 :           restore_extension_diagnostics (ext);
    1677                 :     283569 :           break;
    1678                 :        140 :         case RID_ASM:
    1679                 :        140 :           c_parser_asm_definition (parser);
    1680                 :        140 :           break;
    1681                 :          0 :         case RID_AT_INTERFACE:
    1682                 :          0 :         case RID_AT_IMPLEMENTATION:
    1683                 :          0 :           gcc_assert (c_dialect_objc ());
    1684                 :          0 :           c_parser_objc_class_definition (parser, NULL_TREE);
    1685                 :          0 :           break;
    1686                 :          0 :         case RID_AT_CLASS:
    1687                 :          0 :           gcc_assert (c_dialect_objc ());
    1688                 :          0 :           c_parser_objc_class_declaration (parser);
    1689                 :          0 :           break;
    1690                 :          0 :         case RID_AT_ALIAS:
    1691                 :          0 :           gcc_assert (c_dialect_objc ());
    1692                 :          0 :           c_parser_objc_alias_declaration (parser);
    1693                 :          0 :           break;
    1694                 :          0 :         case RID_AT_PROTOCOL:
    1695                 :          0 :           gcc_assert (c_dialect_objc ());
    1696                 :          0 :           c_parser_objc_protocol_definition (parser, NULL_TREE);
    1697                 :          0 :           break;
    1698                 :          0 :         case RID_AT_PROPERTY:
    1699                 :          0 :           gcc_assert (c_dialect_objc ());
    1700                 :          0 :           c_parser_objc_at_property_declaration (parser);
    1701                 :          0 :           break;
    1702                 :          0 :         case RID_AT_SYNTHESIZE:
    1703                 :          0 :           gcc_assert (c_dialect_objc ());
    1704                 :          0 :           c_parser_objc_at_synthesize_declaration (parser);
    1705                 :          0 :           break;
    1706                 :          0 :         case RID_AT_DYNAMIC:
    1707                 :          0 :           gcc_assert (c_dialect_objc ());
    1708                 :          0 :           c_parser_objc_at_dynamic_declaration (parser);
    1709                 :          0 :           break;
    1710                 :          0 :         case RID_AT_END:
    1711                 :          0 :           gcc_assert (c_dialect_objc ());
    1712                 :          0 :           c_parser_consume_token (parser);
    1713                 :          0 :           objc_finish_implementation ();
    1714                 :          0 :           break;
    1715                 :   34604800 :         default:
    1716                 :   34604800 :           goto decl_or_fndef;
    1717                 :            :         }
    1718                 :            :       break;
    1719                 :        886 :     case CPP_SEMICOLON:
    1720                 :        886 :       pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
    1721                 :            :                "ISO C does not allow extra %<;%> outside of a function");
    1722                 :        886 :       c_parser_consume_token (parser);
    1723                 :        886 :       break;
    1724                 :     784905 :     case CPP_PRAGMA:
    1725                 :     784905 :       mark_valid_location_for_stdc_pragma (true);
    1726                 :     784905 :       c_parser_pragma (parser, pragma_external, NULL);
    1727                 :     784905 :       mark_valid_location_for_stdc_pragma (false);
    1728                 :     784905 :       break;
    1729                 :          1 :     case CPP_PLUS:
    1730                 :          1 :     case CPP_MINUS:
    1731                 :          1 :       if (c_dialect_objc ())
    1732                 :            :         {
    1733                 :          0 :           c_parser_objc_method_definition (parser);
    1734                 :          0 :           break;
    1735                 :            :         }
    1736                 :            :       /* Else fall through, and yield a syntax error trying to parse
    1737                 :            :          as a declaration or function definition.  */
    1738                 :            :       /* FALLTHRU */
    1739                 :   34751000 :     default:
    1740                 :          1 :     decl_or_fndef:
    1741                 :            :       /* A declaration or a function definition (or, in Objective-C,
    1742                 :            :          an @interface or @protocol with prefix attributes).  We can
    1743                 :            :          only tell which after parsing the declaration specifiers, if
    1744                 :            :          any, and the first declarator.  */
    1745                 :   34751000 :       c_parser_declaration_or_fndef (parser, true, true, true, false, true,
    1746                 :            :                                      NULL, vNULL);
    1747                 :   34751000 :       break;
    1748                 :            :     }
    1749                 :   35820500 : }
    1750                 :            : 
    1751                 :            : static void c_finish_omp_declare_simd (c_parser *, tree, tree, vec<c_token>);
    1752                 :            : static void c_finish_oacc_routine (struct oacc_routine_data *, tree, bool);
    1753                 :            : 
    1754                 :            : /* Build and add a DEBUG_BEGIN_STMT statement with location LOC.  */
    1755                 :            : 
    1756                 :            : static void
    1757                 :   63010700 : add_debug_begin_stmt (location_t loc)
    1758                 :            : {
    1759                 :            :   /* Don't add DEBUG_BEGIN_STMTs outside of functions, see PR84721.  */
    1760                 :   63010700 :   if (!MAY_HAVE_DEBUG_MARKER_STMTS || !building_stmt_list_p ())
    1761                 :   61483000 :     return;
    1762                 :            : 
    1763                 :    1527720 :   tree stmt = build0 (DEBUG_BEGIN_STMT, void_type_node);
    1764                 :    1527720 :   SET_EXPR_LOCATION (stmt, loc);
    1765                 :    1527720 :   add_stmt (stmt);
    1766                 :            : }
    1767                 :            : 
    1768                 :            : /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
    1769                 :            :    6.7, 6.9.1, C11 6.7, 6.9.1).  If FNDEF_OK is true, a function definition
    1770                 :            :    is accepted; otherwise (old-style parameter declarations) only other
    1771                 :            :    declarations are accepted.  If STATIC_ASSERT_OK is true, a static
    1772                 :            :    assertion is accepted; otherwise (old-style parameter declarations)
    1773                 :            :    it is not.  If NESTED is true, we are inside a function or parsing
    1774                 :            :    old-style parameter declarations; any functions encountered are
    1775                 :            :    nested functions and declaration specifiers are required; otherwise
    1776                 :            :    we are at top level and functions are normal functions and
    1777                 :            :    declaration specifiers may be optional.  If EMPTY_OK is true, empty
    1778                 :            :    declarations are OK (subject to all other constraints); otherwise
    1779                 :            :    (old-style parameter declarations) they are diagnosed.  If
    1780                 :            :    START_ATTR_OK is true, the declaration specifiers may start with
    1781                 :            :    attributes (GNU or standard); otherwise they may not.
    1782                 :            :    OBJC_FOREACH_OBJECT_DECLARATION can be used to get back the parsed
    1783                 :            :    declaration when parsing an Objective-C foreach statement.
    1784                 :            :    FALLTHRU_ATTR_P is used to signal whether this function parsed
    1785                 :            :    "__attribute__((fallthrough));".  ATTRS are any standard attributes
    1786                 :            :    parsed in the caller (in contexts where such attributes had to be
    1787                 :            :    parsed to determine whether what follows is a declaration or a
    1788                 :            :    statement); HAVE_ATTRS says whether there were any such attributes
    1789                 :            :    (even empty).
    1790                 :            : 
    1791                 :            :    declaration:
    1792                 :            :      declaration-specifiers init-declarator-list[opt] ;
    1793                 :            :      static_assert-declaration
    1794                 :            : 
    1795                 :            :    function-definition:
    1796                 :            :      declaration-specifiers[opt] declarator declaration-list[opt]
    1797                 :            :        compound-statement
    1798                 :            : 
    1799                 :            :    declaration-list:
    1800                 :            :      declaration
    1801                 :            :      declaration-list declaration
    1802                 :            : 
    1803                 :            :    init-declarator-list:
    1804                 :            :      init-declarator
    1805                 :            :      init-declarator-list , init-declarator
    1806                 :            : 
    1807                 :            :    init-declarator:
    1808                 :            :      declarator simple-asm-expr[opt] gnu-attributes[opt]
    1809                 :            :      declarator simple-asm-expr[opt] gnu-attributes[opt] = initializer
    1810                 :            : 
    1811                 :            :    GNU extensions:
    1812                 :            : 
    1813                 :            :    nested-function-definition:
    1814                 :            :      declaration-specifiers declarator declaration-list[opt]
    1815                 :            :        compound-statement
    1816                 :            : 
    1817                 :            :    attribute ;
    1818                 :            : 
    1819                 :            :    Objective-C:
    1820                 :            :      gnu-attributes objc-class-definition
    1821                 :            :      gnu-attributes objc-category-definition
    1822                 :            :      gnu-attributes objc-protocol-definition
    1823                 :            : 
    1824                 :            :    The simple-asm-expr and gnu-attributes are GNU extensions.
    1825                 :            : 
    1826                 :            :    This function does not handle __extension__; that is handled in its
    1827                 :            :    callers.  ??? Following the old parser, __extension__ may start
    1828                 :            :    external declarations, declarations in functions and declarations
    1829                 :            :    at the start of "for" loops, but not old-style parameter
    1830                 :            :    declarations.
    1831                 :            : 
    1832                 :            :    C99 requires declaration specifiers in a function definition; the
    1833                 :            :    absence is diagnosed through the diagnosis of implicit int.  In GNU
    1834                 :            :    C we also allow but diagnose declarations without declaration
    1835                 :            :    specifiers, but only at top level (elsewhere they conflict with
    1836                 :            :    other syntax).
    1837                 :            : 
    1838                 :            :    In Objective-C, declarations of the looping variable in a foreach
    1839                 :            :    statement are exceptionally terminated by 'in' (for example, 'for
    1840                 :            :    (NSObject *object in array) { ... }').
    1841                 :            : 
    1842                 :            :    OpenMP:
    1843                 :            : 
    1844                 :            :    declaration:
    1845                 :            :      threadprivate-directive
    1846                 :            : 
    1847                 :            :    GIMPLE:
    1848                 :            : 
    1849                 :            :    gimple-function-definition:
    1850                 :            :      declaration-specifiers[opt] __GIMPLE (gimple-or-rtl-pass-list) declarator
    1851                 :            :        declaration-list[opt] compound-statement
    1852                 :            : 
    1853                 :            :    rtl-function-definition:
    1854                 :            :      declaration-specifiers[opt] __RTL (gimple-or-rtl-pass-list) declarator
    1855                 :            :        declaration-list[opt] compound-statement  */
    1856                 :            : 
    1857                 :            : static void
    1858                 :   38120100 : c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok,
    1859                 :            :                                bool static_assert_ok, bool empty_ok,
    1860                 :            :                                bool nested, bool start_attr_ok,
    1861                 :            :                                tree *objc_foreach_object_declaration,
    1862                 :            :                                vec<c_token> omp_declare_simd_clauses,
    1863                 :            :                                bool have_attrs, tree attrs,
    1864                 :            :                                struct oacc_routine_data *oacc_routine_data,
    1865                 :            :                                bool *fallthru_attr_p)
    1866                 :            : {
    1867                 :   38120100 :   struct c_declspecs *specs;
    1868                 :   38120100 :   tree prefix_attrs;
    1869                 :   38120100 :   tree all_prefix_attrs;
    1870                 :   38120100 :   bool diagnosed_no_specs = false;
    1871                 :   38120100 :   location_t here = c_parser_peek_token (parser)->location;
    1872                 :            : 
    1873                 :   38120100 :   add_debug_begin_stmt (c_parser_peek_token (parser)->location);
    1874                 :            : 
    1875                 :   38120100 :   if (static_assert_ok
    1876                 :   76227300 :       && c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
    1877                 :            :     {
    1878                 :        822 :       c_parser_static_assert_declaration (parser);
    1879                 :        822 :       return;
    1880                 :            :     }
    1881                 :   38119300 :   specs = build_null_declspecs ();
    1882                 :            : 
    1883                 :            :   /* Handle any standard attributes parsed in the caller.  */
    1884                 :   38119300 :   if (have_attrs)
    1885                 :            :     {
    1886                 :         31 :       declspecs_add_attrs (here, specs, attrs);
    1887                 :         31 :       specs->non_std_attrs_seen_p = false;
    1888                 :            :     }
    1889                 :            : 
    1890                 :            :   /* Try to detect an unknown type name when we have "A B" or "A *B".  */
    1891                 :   38119300 :   if (c_parser_peek_token (parser)->type == CPP_NAME
    1892                 :    2012610 :       && c_parser_peek_token (parser)->id_kind == C_ID_ID
    1893                 :      13132 :       && (c_parser_peek_2nd_token (parser)->type == CPP_NAME
    1894                 :      13055 :           || c_parser_peek_2nd_token (parser)->type == CPP_MULT)
    1895                 :   38119400 :       && (!nested || !lookup_name (c_parser_peek_token (parser)->value)))
    1896                 :            :     {
    1897                 :        101 :       tree name = c_parser_peek_token (parser)->value;
    1898                 :            : 
    1899                 :            :       /* Issue a warning about NAME being an unknown type name, perhaps
    1900                 :            :          with some kind of hint.
    1901                 :            :          If the user forgot a "struct" etc, suggest inserting
    1902                 :            :          it.  Otherwise, attempt to look for misspellings.  */
    1903                 :        202 :       gcc_rich_location richloc (here);
    1904                 :        101 :       if (tag_exists_p (RECORD_TYPE, name))
    1905                 :            :         {
    1906                 :            :           /* This is not C++ with its implicit typedef.  */
    1907                 :          3 :           richloc.add_fixit_insert_before ("struct ");
    1908                 :          3 :           error_at (&richloc,
    1909                 :            :                     "unknown type name %qE;"
    1910                 :            :                     " use %<struct%> keyword to refer to the type",
    1911                 :            :                     name);
    1912                 :            :         }
    1913                 :         98 :       else if (tag_exists_p (UNION_TYPE, name))
    1914                 :            :         {
    1915                 :          3 :           richloc.add_fixit_insert_before ("union ");
    1916                 :          3 :           error_at (&richloc,
    1917                 :            :                     "unknown type name %qE;"
    1918                 :            :                     " use %<union%> keyword to refer to the type",
    1919                 :            :                     name);
    1920                 :            :         }
    1921                 :         95 :       else if (tag_exists_p (ENUMERAL_TYPE, name))
    1922                 :            :         {
    1923                 :          3 :           richloc.add_fixit_insert_before ("enum ");
    1924                 :          3 :           error_at (&richloc,
    1925                 :            :                     "unknown type name %qE;"
    1926                 :            :                     " use %<enum%> keyword to refer to the type",
    1927                 :            :                     name);
    1928                 :            :         }
    1929                 :            :       else
    1930                 :            :         {
    1931                 :         92 :           auto_diagnostic_group d;
    1932                 :         92 :           name_hint hint = lookup_name_fuzzy (name, FUZZY_LOOKUP_TYPENAME,
    1933                 :        184 :                                               here);
    1934                 :         92 :           if (const char *suggestion = hint.suggestion ())
    1935                 :            :             {
    1936                 :         12 :               richloc.add_fixit_replace (suggestion);
    1937                 :         12 :               error_at (&richloc,
    1938                 :            :                         "unknown type name %qE; did you mean %qs?",
    1939                 :            :                         name, suggestion);
    1940                 :            :             }
    1941                 :            :           else
    1942                 :         80 :             error_at (here, "unknown type name %qE", name);
    1943                 :            :         }
    1944                 :            : 
    1945                 :            :       /* Parse declspecs normally to get a correct pointer type, but avoid
    1946                 :            :          a further "fails to be a type name" error.  Refuse nested functions
    1947                 :            :          since it is not how the user likely wants us to recover.  */
    1948                 :        101 :       c_parser_peek_token (parser)->type = CPP_KEYWORD;
    1949                 :        101 :       c_parser_peek_token (parser)->keyword = RID_VOID;
    1950                 :        101 :       c_parser_peek_token (parser)->value = error_mark_node;
    1951                 :        101 :       fndef_ok = !nested;
    1952                 :            :     }
    1953                 :            : 
    1954                 :            :   /* When there are standard attributes at the start of the
    1955                 :            :      declaration (to apply to the entity being declared), an
    1956                 :            :      init-declarator-list or function definition must be present.  */
    1957                 :   38119300 :   if (c_parser_nth_token_starts_std_attributes (parser, 1))
    1958                 :         45 :     have_attrs = true;
    1959                 :            : 
    1960                 :   38119300 :   c_parser_declspecs (parser, specs, true, true, start_attr_ok,
    1961                 :            :                       true, true, start_attr_ok, true, cla_nonabstract_decl);
    1962                 :   38119300 :   if (parser->error)
    1963                 :            :     {
    1964                 :         30 :       c_parser_skip_to_end_of_block_or_statement (parser);
    1965                 :         30 :       return;
    1966                 :            :     }
    1967                 :   38119300 :   if (nested && !specs->declspecs_seen_p)
    1968                 :            :     {
    1969                 :         60 :       c_parser_error (parser, "expected declaration specifiers");
    1970                 :         60 :       c_parser_skip_to_end_of_block_or_statement (parser);
    1971                 :         60 :       return;
    1972                 :            :     }
    1973                 :            : 
    1974                 :   38119200 :   finish_declspecs (specs);
    1975                 :   38119200 :   bool auto_type_p = specs->typespec_word == cts_auto_type;
    1976                 :   38119200 :   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    1977                 :            :     {
    1978                 :     384556 :       if (auto_type_p)
    1979                 :          1 :         error_at (here, "%<__auto_type%> in empty declaration");
    1980                 :     384555 :       else if (specs->typespec_kind == ctsk_none
    1981                 :     384555 :                && attribute_fallthrough_p (specs->attrs))
    1982                 :            :         {
    1983                 :         63 :           if (fallthru_attr_p != NULL)
    1984                 :         62 :             *fallthru_attr_p = true;
    1985                 :         63 :           if (nested)
    1986                 :            :             {
    1987                 :         62 :               tree fn = build_call_expr_internal_loc (here, IFN_FALLTHROUGH,
    1988                 :            :                                                       void_type_node, 0);
    1989                 :         62 :               add_stmt (fn);
    1990                 :            :             }
    1991                 :            :           else
    1992                 :          1 :             pedwarn (here, OPT_Wattributes,
    1993                 :            :                      "%<fallthrough%> attribute at top level");
    1994                 :            :         }
    1995                 :     384492 :       else if (empty_ok && !(have_attrs
    1996                 :         23 :                              && specs->non_std_attrs_seen_p))
    1997                 :     384476 :         shadow_tag (specs);
    1998                 :            :       else
    1999                 :            :         {
    2000                 :         16 :           shadow_tag_warned (specs, 1);
    2001                 :         16 :           pedwarn (here, 0, "empty declaration");
    2002                 :            :         }
    2003                 :     384556 :       c_parser_consume_token (parser);
    2004                 :     384556 :       if (oacc_routine_data)
    2005                 :          0 :         c_finish_oacc_routine (oacc_routine_data, NULL_TREE, false);
    2006                 :     384556 :       return;
    2007                 :            :     }
    2008                 :            : 
    2009                 :            :   /* Provide better error recovery.  Note that a type name here is usually
    2010                 :            :      better diagnosed as a redeclaration.  */
    2011                 :   37734700 :   if (empty_ok
    2012                 :   37721800 :       && specs->typespec_kind == ctsk_tagdef
    2013                 :     453518 :       && c_parser_next_token_starts_declspecs (parser)
    2014                 :   37734700 :       && !c_parser_next_token_is (parser, CPP_NAME))
    2015                 :            :     {
    2016                 :          6 :       c_parser_error (parser, "expected %<;%>, identifier or %<(%>");
    2017                 :          6 :       parser->error = false;
    2018                 :          6 :       shadow_tag_warned (specs, 1);
    2019                 :          6 :       return;
    2020                 :            :     }
    2021                 :   37734700 :   else if (c_dialect_objc () && !auto_type_p)
    2022                 :            :     {
    2023                 :            :       /* Prefix attributes are an error on method decls.  */
    2024                 :          0 :       switch (c_parser_peek_token (parser)->type)
    2025                 :            :         {
    2026                 :          0 :           case CPP_PLUS:
    2027                 :          0 :           case CPP_MINUS:
    2028                 :          0 :             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
    2029                 :            :               return;
    2030                 :          0 :             if (specs->attrs)
    2031                 :            :               {
    2032                 :          0 :                 warning_at (c_parser_peek_token (parser)->location, 
    2033                 :            :                             OPT_Wattributes,
    2034                 :            :                             "prefix attributes are ignored for methods");
    2035                 :          0 :                 specs->attrs = NULL_TREE;
    2036                 :            :               }
    2037                 :          0 :             if (fndef_ok)
    2038                 :          0 :               c_parser_objc_method_definition (parser);
    2039                 :            :             else
    2040                 :          0 :               c_parser_objc_methodproto (parser);
    2041                 :          0 :             return;
    2042                 :          0 :             break;
    2043                 :          0 :           default:
    2044                 :          0 :             break;
    2045                 :            :         }
    2046                 :            :       /* This is where we parse 'attributes @interface ...',
    2047                 :            :          'attributes @implementation ...', 'attributes @protocol ...'
    2048                 :            :          (where attributes could be, for example, __attribute__
    2049                 :            :          ((deprecated)).
    2050                 :            :       */
    2051                 :          0 :       switch (c_parser_peek_token (parser)->keyword)
    2052                 :            :         {
    2053                 :          0 :         case RID_AT_INTERFACE:
    2054                 :          0 :           {
    2055                 :          0 :             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
    2056                 :            :               return;
    2057                 :          0 :             c_parser_objc_class_definition (parser, specs->attrs);
    2058                 :          0 :             return;
    2059                 :            :           }
    2060                 :          0 :           break;
    2061                 :          0 :         case RID_AT_IMPLEMENTATION:
    2062                 :          0 :           {
    2063                 :          0 :             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
    2064                 :            :               return;
    2065                 :          0 :             if (specs->attrs)
    2066                 :            :               {
    2067                 :          0 :                 warning_at (c_parser_peek_token (parser)->location, 
    2068                 :            :                         OPT_Wattributes,
    2069                 :            :                         "prefix attributes are ignored for implementations");
    2070                 :          0 :                 specs->attrs = NULL_TREE;
    2071                 :            :               }
    2072                 :          0 :             c_parser_objc_class_definition (parser, NULL_TREE);     
    2073                 :          0 :             return;
    2074                 :            :           }
    2075                 :          0 :           break;
    2076                 :          0 :         case RID_AT_PROTOCOL:
    2077                 :          0 :           {
    2078                 :          0 :             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
    2079                 :            :               return;
    2080                 :          0 :             c_parser_objc_protocol_definition (parser, specs->attrs);
    2081                 :          0 :             return;
    2082                 :            :           }
    2083                 :          0 :           break;
    2084                 :          0 :         case RID_AT_ALIAS:
    2085                 :          0 :         case RID_AT_CLASS:
    2086                 :          0 :         case RID_AT_END:
    2087                 :          0 :         case RID_AT_PROPERTY:
    2088                 :          0 :           if (specs->attrs)
    2089                 :            :             {
    2090                 :          0 :               c_parser_error (parser, "unexpected attribute");
    2091                 :          0 :               specs->attrs = NULL;
    2092                 :            :             }
    2093                 :            :           break;
    2094                 :            :         default:
    2095                 :            :           break;
    2096                 :            :         }
    2097                 :            :     }
    2098                 :   37734700 :   else if (attribute_fallthrough_p (specs->attrs))
    2099                 :          5 :     warning_at (here, OPT_Wattributes,
    2100                 :            :                 "%<fallthrough%> attribute not followed by %<;%>");
    2101                 :            : 
    2102                 :   37734700 :   pending_xref_error ();
    2103                 :   37734700 :   prefix_attrs = specs->attrs;
    2104                 :   37734700 :   all_prefix_attrs = prefix_attrs;
    2105                 :   37734700 :   specs->attrs = NULL_TREE;
    2106                 :   38029800 :   while (true)
    2107                 :            :     {
    2108                 :   38029800 :       struct c_declarator *declarator;
    2109                 :   38029800 :       bool dummy = false;
    2110                 :   38029800 :       timevar_id_t tv;
    2111                 :   38029800 :       tree fnbody = NULL_TREE;
    2112                 :            :       /* Declaring either one or more declarators (in which case we
    2113                 :            :          should diagnose if there were no declaration specifiers) or a
    2114                 :            :          function definition (in which case the diagnostic for
    2115                 :            :          implicit int suffices).  */
    2116                 :   76059600 :       declarator = c_parser_declarator (parser, 
    2117                 :   38029800 :                                         specs->typespec_kind != ctsk_none,
    2118                 :            :                                         C_DTR_NORMAL, &dummy);
    2119                 :   38029800 :       if (declarator == NULL)
    2120                 :            :         {
    2121                 :        176 :           if (omp_declare_simd_clauses.exists ())
    2122                 :          0 :             c_finish_omp_declare_simd (parser, NULL_TREE, NULL_TREE,
    2123                 :            :                                        omp_declare_simd_clauses);
    2124                 :        176 :           if (oacc_routine_data)
    2125                 :          0 :             c_finish_oacc_routine (oacc_routine_data, NULL_TREE, false);
    2126                 :        176 :           c_parser_skip_to_end_of_block_or_statement (parser);
    2127                 :   17394500 :           return;
    2128                 :            :         }
    2129                 :   38029600 :       if (auto_type_p && declarator->kind != cdk_id)
    2130                 :            :         {
    2131                 :          1 :           error_at (here,
    2132                 :            :                     "%<__auto_type%> requires a plain identifier"
    2133                 :            :                     " as declarator");
    2134                 :          1 :           c_parser_skip_to_end_of_block_or_statement (parser);
    2135                 :          1 :           return;
    2136                 :            :         }
    2137                 :   38029600 :       if (c_parser_next_token_is (parser, CPP_EQ)
    2138                 :   35939700 :           || c_parser_next_token_is (parser, CPP_COMMA)
    2139                 :   35663700 :           || c_parser_next_token_is (parser, CPP_SEMICOLON)
    2140                 :   28927300 :           || c_parser_next_token_is_keyword (parser, RID_ASM)
    2141                 :   28340500 :           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)
    2142                 :   58369900 :           || c_parser_next_token_is_keyword (parser, RID_IN))
    2143                 :            :         {
    2144                 :   17689300 :           tree asm_name = NULL_TREE;
    2145                 :   17689300 :           tree postfix_attrs = NULL_TREE;
    2146                 :   17689300 :           if (!diagnosed_no_specs && !specs->declspecs_seen_p)
    2147                 :            :             {
    2148                 :         85 :               diagnosed_no_specs = true;
    2149                 :         85 :               pedwarn (here, 0, "data definition has no type or storage class");
    2150                 :            :             }
    2151                 :            :           /* Having seen a data definition, there cannot now be a
    2152                 :            :              function definition.  */
    2153                 :   17689300 :           fndef_ok = false;
    2154                 :   17689300 :           if (c_parser_next_token_is_keyword (parser, RID_ASM))
    2155                 :     586785 :             asm_name = c_parser_simple_asm_expr (parser);
    2156                 :   17689300 :           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
    2157                 :            :             {
    2158                 :    8523860 :               postfix_attrs = c_parser_gnu_attributes (parser);
    2159                 :    8523860 :               if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
    2160                 :            :                 {
    2161                 :            :                   /* This means there is an attribute specifier after
    2162                 :            :                      the declarator in a function definition.  Provide
    2163                 :            :                      some more information for the user.  */
    2164                 :          1 :                   error_at (here, "attributes should be specified before the "
    2165                 :            :                             "declarator in a function definition");
    2166                 :          1 :                   c_parser_skip_to_end_of_block_or_statement (parser);
    2167                 :          1 :                   return;
    2168                 :            :                 }
    2169                 :            :             }
    2170                 :   17689300 :           if (c_parser_next_token_is (parser, CPP_EQ))
    2171                 :            :             {
    2172                 :    2090920 :               tree d;
    2173                 :    2090920 :               struct c_expr init;
    2174                 :    2090920 :               location_t init_loc;
    2175                 :    2090920 :               c_parser_consume_token (parser);
    2176                 :    2090920 :               if (auto_type_p)
    2177                 :            :                 {
    2178                 :       1377 :                   init_loc = c_parser_peek_token (parser)->location;
    2179                 :       2754 :                   rich_location richloc (line_table, init_loc);
    2180                 :       1377 :                   start_init (NULL_TREE, asm_name, global_bindings_p (), &richloc);
    2181                 :            :                   /* A parameter is initialized, which is invalid.  Don't
    2182                 :            :                      attempt to instrument the initializer.  */
    2183                 :       1377 :                   int flag_sanitize_save = flag_sanitize;
    2184                 :       1377 :                   if (nested && !empty_ok)
    2185                 :         14 :                     flag_sanitize = 0;
    2186                 :       1377 :                   init = c_parser_expr_no_commas (parser, NULL);
    2187                 :       1377 :                   flag_sanitize = flag_sanitize_save;
    2188                 :       1377 :                   if (TREE_CODE (init.value) == COMPONENT_REF
    2189                 :       1377 :                       && DECL_C_BIT_FIELD (TREE_OPERAND (init.value, 1)))
    2190                 :          1 :                     error_at (here,
    2191                 :            :                               "%<__auto_type%> used with a bit-field"
    2192                 :            :                               " initializer");
    2193                 :       1377 :                   init = convert_lvalue_to_rvalue (init_loc, init, true, true);
    2194                 :       1377 :                   tree init_type = TREE_TYPE (init.value);
    2195                 :            :                   /* As with typeof, remove all qualifiers from atomic types.  */
    2196                 :       2752 :                   if (init_type != error_mark_node && TYPE_ATOMIC (init_type))
    2197                 :          0 :                     init_type
    2198                 :          0 :                       = c_build_qualified_type (init_type, TYPE_UNQUALIFIED);
    2199                 :       1377 :                   bool vm_type = variably_modified_type_p (init_type,
    2200                 :            :                                                            NULL_TREE);
    2201                 :       1377 :                   if (vm_type)
    2202                 :         91 :                     init.value = save_expr (init.value);
    2203                 :       1377 :                   finish_init ();
    2204                 :       1377 :                   specs->typespec_kind = ctsk_typeof;
    2205                 :       1377 :                   specs->locations[cdw_typedef] = init_loc;
    2206                 :       1377 :                   specs->typedef_p = true;
    2207                 :       1377 :                   specs->type = init_type;
    2208                 :       1377 :                   if (vm_type)
    2209                 :            :                     {
    2210                 :         91 :                       bool maybe_const = true;
    2211                 :         91 :                       tree type_expr = c_fully_fold (init.value, false,
    2212                 :            :                                                      &maybe_const);
    2213                 :         91 :                       specs->expr_const_operands &= maybe_const;
    2214                 :         91 :                       if (specs->expr)
    2215                 :          0 :                         specs->expr = build2 (COMPOUND_EXPR,
    2216                 :          0 :                                               TREE_TYPE (type_expr),
    2217                 :            :                                               specs->expr, type_expr);
    2218                 :            :                       else
    2219                 :         91 :                         specs->expr = type_expr;
    2220                 :            :                     }
    2221                 :       1377 :                   d = start_decl (declarator, specs, true,
    2222                 :            :                                   chainon (postfix_attrs, all_prefix_attrs));
    2223                 :       1377 :                   if (!d)
    2224                 :          2 :                     d = error_mark_node;
    2225                 :       1377 :                   if (omp_declare_simd_clauses.exists ())
    2226                 :          0 :                     c_finish_omp_declare_simd (parser, d, NULL_TREE,
    2227                 :            :                                                omp_declare_simd_clauses);
    2228                 :            :                 }
    2229                 :            :               else
    2230                 :            :                 {
    2231                 :            :                   /* The declaration of the variable is in effect while
    2232                 :            :                      its initializer is parsed.  */
    2233                 :    2089540 :                   d = start_decl (declarator, specs, true,
    2234                 :            :                                   chainon (postfix_attrs, all_prefix_attrs));
    2235                 :    2089540 :                   if (!d)
    2236                 :          4 :                     d = error_mark_node;
    2237                 :    2089540 :                   if (omp_declare_simd_clauses.exists ())
    2238                 :          0 :                     c_finish_omp_declare_simd (parser, d, NULL_TREE,
    2239                 :            :                                                omp_declare_simd_clauses);
    2240                 :    2089540 :                   init_loc = c_parser_peek_token (parser)->location;
    2241                 :    4179080 :                   rich_location richloc (line_table, init_loc);
    2242                 :    2089540 :                   start_init (d, asm_name, global_bindings_p (), &richloc);
    2243                 :            :                   /* A parameter is initialized, which is invalid.  Don't
    2244                 :            :                      attempt to instrument the initializer.  */
    2245                 :    2089540 :                   int flag_sanitize_save = flag_sanitize;
    2246                 :    2089540 :                   if (TREE_CODE (d) == PARM_DECL)
    2247                 :         35 :                     flag_sanitize = 0;
    2248                 :    2089540 :                   init = c_parser_initializer (parser);
    2249                 :    2089540 :                   flag_sanitize = flag_sanitize_save;
    2250                 :    2089540 :                   finish_init ();
    2251                 :            :                 }
    2252                 :    2090910 :               if (oacc_routine_data)
    2253                 :          0 :                 c_finish_oacc_routine (oacc_routine_data, d, false);
    2254                 :    2090910 :               if (d != error_mark_node)
    2255                 :            :                 {
    2256                 :    2090910 :                   maybe_warn_string_init (init_loc, TREE_TYPE (d), init);
    2257                 :    2090910 :                   finish_decl (d, init_loc, init.value,
    2258                 :            :                                init.original_type, asm_name);
    2259                 :            :                 }
    2260                 :            :             }
    2261                 :            :           else
    2262                 :            :             {
    2263                 :   15598300 :               if (auto_type_p)
    2264                 :            :                 {
    2265                 :          1 :                   error_at (here,
    2266                 :            :                             "%<__auto_type%> requires an initialized "
    2267                 :            :                             "data declaration");
    2268                 :          1 :                   c_parser_skip_to_end_of_block_or_statement (parser);
    2269                 :          1 :                   return;
    2270                 :            :                 }
    2271                 :   15598300 :               tree d = start_decl (declarator, specs, false,
    2272                 :            :                                    chainon (postfix_attrs,
    2273                 :            :                                             all_prefix_attrs));
    2274                 :   15598300 :               if (d
    2275                 :   15598300 :                   && TREE_CODE (d) == FUNCTION_DECL
    2276                 :   10288700 :                   && DECL_ARGUMENTS (d) == NULL_TREE
    2277                 :   25376800 :                   && DECL_INITIAL (d) == NULL_TREE)
    2278                 :            :                 {
    2279                 :            :                   /* Find the innermost declarator that is neither cdk_id
    2280                 :            :                      nor cdk_attrs.  */
    2281                 :            :                   const struct c_declarator *decl = declarator;
    2282                 :            :                   const struct c_declarator *last_non_id_attrs = NULL;
    2283                 :            : 
    2284                 :   19750400 :                   while (decl)
    2285                 :   19750400 :                     switch (decl->kind)
    2286                 :            :                       {
    2287                 :   10187200 :                       case cdk_array:
    2288                 :   10187200 :                       case cdk_function:
    2289                 :   10187200 :                       case cdk_pointer:
    2290                 :   10187200 :                         last_non_id_attrs = decl;
    2291                 :   10187200 :                         decl = decl->declarator;
    2292                 :   10187200 :                         break;
    2293                 :            : 
    2294                 :         45 :                       case cdk_attrs:
    2295                 :         45 :                         decl = decl->declarator;
    2296                 :         45 :                         break;
    2297                 :            : 
    2298                 :            :                       case cdk_id:
    2299                 :            :                         decl = 0;
    2300                 :            :                         break;
    2301                 :            : 
    2302                 :          0 :                       default:
    2303                 :          0 :                         gcc_unreachable ();
    2304                 :            :                       }
    2305                 :            : 
    2306                 :            :                   /* If it exists and is cdk_function, use its parameters.  */
    2307                 :    9563180 :                   if (last_non_id_attrs
    2308                 :    9535780 :                       && last_non_id_attrs->kind == cdk_function)
    2309                 :    9535780 :                     DECL_ARGUMENTS (d) = last_non_id_attrs->u.arg_info->parms;
    2310                 :            :                 }
    2311                 :   15598300 :               if (omp_declare_simd_clauses.exists ())
    2312                 :            :                 {
    2313                 :        319 :                   tree parms = NULL_TREE;
    2314                 :        319 :                   if (d && TREE_CODE (d) == FUNCTION_DECL)
    2315                 :            :                     {
    2316                 :            :                       struct c_declarator *ce = declarator;
    2317                 :        315 :                       while (ce != NULL)
    2318                 :        315 :                         if (ce->kind == cdk_function)
    2319                 :            :                           {
    2320                 :        313 :                             parms = ce->u.arg_info->parms;
    2321                 :        313 :                             break;
    2322                 :            :                           }
    2323                 :            :                         else
    2324                 :          2 :                           ce = ce->declarator;
    2325                 :            :                     }
    2326                 :        313 :                   if (parms)
    2327                 :        113 :                     temp_store_parm_decls (d, parms);
    2328                 :        319 :                   c_finish_omp_declare_simd (parser, d, parms,
    2329                 :            :                                              omp_declare_simd_clauses);
    2330                 :        319 :                   if (parms)
    2331                 :        113 :                     temp_pop_parm_decls ();
    2332                 :            :                 }
    2333                 :   15598300 :               if (oacc_routine_data)
    2334                 :         46 :                 c_finish_oacc_routine (oacc_routine_data, d, false);
    2335                 :   15598300 :               if (d)
    2336                 :   15598300 :                 finish_decl (d, UNKNOWN_LOCATION, NULL_TREE,
    2337                 :            :                              NULL_TREE, asm_name);
    2338                 :            :               
    2339                 :   15598300 :               if (c_parser_next_token_is_keyword (parser, RID_IN))
    2340                 :            :                 {
    2341                 :          0 :                   if (d)
    2342                 :          0 :                     *objc_foreach_object_declaration = d;
    2343                 :            :                   else
    2344                 :          0 :                     *objc_foreach_object_declaration = error_mark_node;             
    2345                 :            :                 }
    2346                 :            :             }
    2347                 :   17689300 :           if (c_parser_next_token_is (parser, CPP_COMMA))
    2348                 :            :             {
    2349                 :     295126 :               if (auto_type_p)
    2350                 :            :                 {
    2351                 :          1 :                   error_at (here,
    2352                 :            :                             "%<__auto_type%> may only be used with"
    2353                 :            :                             " a single declarator");
    2354                 :          1 :                   c_parser_skip_to_end_of_block_or_statement (parser);
    2355                 :          1 :                   return;
    2356                 :            :                 }
    2357                 :     295125 :               c_parser_consume_token (parser);
    2358                 :     295125 :               if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
    2359                 :         19 :                 all_prefix_attrs = chainon (c_parser_gnu_attributes (parser),
    2360                 :            :                                             prefix_attrs);
    2361                 :            :               else
    2362                 :            :                 all_prefix_attrs = prefix_attrs;
    2363                 :     295125 :               continue;
    2364                 :            :             }
    2365                 :   17394100 :           else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    2366                 :            :             {
    2367                 :   17394100 :               c_parser_consume_token (parser);
    2368                 :   17394100 :               return;
    2369                 :            :             }
    2370                 :         32 :           else if (c_parser_next_token_is_keyword (parser, RID_IN))
    2371                 :            :             {
    2372                 :            :               /* This can only happen in Objective-C: we found the
    2373                 :            :                  'in' that terminates the declaration inside an
    2374                 :            :                  Objective-C foreach statement.  Do not consume the
    2375                 :            :                  token, so that the caller can use it to determine
    2376                 :            :                  that this indeed is a foreach context.  */
    2377                 :            :               return;
    2378                 :            :             }
    2379                 :            :           else
    2380                 :            :             {
    2381                 :         32 :               c_parser_error (parser, "expected %<,%> or %<;%>");
    2382                 :         32 :               c_parser_skip_to_end_of_block_or_statement (parser);
    2383                 :         32 :               return;
    2384                 :            :             }
    2385                 :            :         }
    2386                 :   20340300 :       else if (auto_type_p)
    2387                 :            :         {
    2388                 :          1 :           error_at (here,
    2389                 :            :                     "%<__auto_type%> requires an initialized data declaration");
    2390                 :          1 :           c_parser_skip_to_end_of_block_or_statement (parser);
    2391                 :          1 :           return;
    2392                 :            :         }
    2393                 :   20340300 :       else if (!fndef_ok)
    2394                 :            :         {
    2395                 :         13 :           c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
    2396                 :            :                           "%<asm%> or %<__attribute__%>");
    2397                 :         13 :           c_parser_skip_to_end_of_block_or_statement (parser);
    2398                 :         13 :           return;
    2399                 :            :         }
    2400                 :            :       /* Function definition (nested or otherwise).  */
    2401                 :   20340300 :       if (nested)
    2402                 :            :         {
    2403                 :       1401 :           pedwarn (here, OPT_Wpedantic, "ISO C forbids nested functions");
    2404                 :       1401 :           c_push_function_context ();
    2405                 :            :         }
    2406                 :   20340300 :       if (!start_function (specs, declarator, all_prefix_attrs))
    2407                 :            :         {
    2408                 :            :           /* At this point we've consumed:
    2409                 :            :                declaration-specifiers declarator
    2410                 :            :              and the next token isn't CPP_EQ, CPP_COMMA, CPP_SEMICOLON,
    2411                 :            :              RID_ASM, RID_ATTRIBUTE, or RID_IN,
    2412                 :            :              but the
    2413                 :            :                declaration-specifiers declarator
    2414                 :            :              aren't grokkable as a function definition, so we have
    2415                 :            :              an error.  */
    2416                 :         36 :           gcc_assert (!c_parser_next_token_is (parser, CPP_SEMICOLON));
    2417                 :         36 :           if (c_parser_next_token_starts_declspecs (parser))
    2418                 :            :             {
    2419                 :            :               /* If we have
    2420                 :            :                    declaration-specifiers declarator decl-specs
    2421                 :            :                  then assume we have a missing semicolon, which would
    2422                 :            :                  give us:
    2423                 :            :                    declaration-specifiers declarator  decl-specs
    2424                 :            :                                                     ^
    2425                 :            :                                                     ;
    2426                 :            :                    <~~~~~~~~~ declaration ~~~~~~~~~~>
    2427                 :            :                  Use c_parser_require to get an error with a fix-it hint.  */
    2428                 :         12 :               c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>");
    2429                 :         12 :               parser->error = false;
    2430                 :            :             }
    2431                 :            :           else
    2432                 :            :             {
    2433                 :            :               /* This can appear in many cases looking nothing like a
    2434                 :            :                  function definition, so we don't give a more specific
    2435                 :            :                  error suggesting there was one.  */
    2436                 :         24 :               c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
    2437                 :            :                               "or %<__attribute__%>");
    2438                 :            :             }
    2439                 :         36 :           if (nested)
    2440                 :          1 :             c_pop_function_context ();
    2441                 :   20340300 :           break;
    2442                 :            :         }
    2443                 :            : 
    2444                 :   20340300 :       if (DECL_DECLARED_INLINE_P (current_function_decl))
    2445                 :            :         tv = TV_PARSE_INLINE;
    2446                 :            :       else
    2447                 :     457221 :         tv = TV_PARSE_FUNC;
    2448                 :   20340300 :       auto_timevar at (g_timer, tv);
    2449                 :            : 
    2450                 :            :       /* Parse old-style parameter declarations.  ??? Attributes are
    2451                 :            :          not allowed to start declaration specifiers here because of a
    2452                 :            :          syntax conflict between a function declaration with attribute
    2453                 :            :          suffix and a function definition with an attribute prefix on
    2454                 :            :          first old-style parameter declaration.  Following the old
    2455                 :            :          parser, they are not accepted on subsequent old-style
    2456                 :            :          parameter declarations either.  However, there is no
    2457                 :            :          ambiguity after the first declaration, nor indeed on the
    2458                 :            :          first as long as we don't allow postfix attributes after a
    2459                 :            :          declarator with a nonempty identifier list in a definition;
    2460                 :            :          and postfix attributes have never been accepted here in
    2461                 :            :          function definitions either.  */
    2462                 :   40706400 :       while (c_parser_next_token_is_not (parser, CPP_EOF)
    2463                 :   40706400 :              && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE))
    2464                 :      12906 :         c_parser_declaration_or_fndef (parser, false, false, false,
    2465                 :            :                                        true, false, NULL, vNULL);
    2466                 :   20340300 :       store_parm_decls ();
    2467                 :   20340300 :       if (omp_declare_simd_clauses.exists ())
    2468                 :        137 :         c_finish_omp_declare_simd (parser, current_function_decl, NULL_TREE,
    2469                 :            :                                    omp_declare_simd_clauses);
    2470                 :   20340300 :       if (oacc_routine_data)
    2471                 :         93 :         c_finish_oacc_routine (oacc_routine_data, current_function_decl, true);
    2472                 :   20340300 :       location_t startloc = c_parser_peek_token (parser)->location;
    2473                 :   20340300 :       DECL_STRUCT_FUNCTION (current_function_decl)->function_start_locus
    2474                 :   20340300 :         = startloc;
    2475                 :   20340300 :       location_t endloc = startloc;
    2476                 :            : 
    2477                 :            :       /* If the definition was marked with __RTL, use the RTL parser now,
    2478                 :            :          consuming the function body.  */
    2479                 :   20340300 :       if (specs->declspec_il == cdil_rtl)
    2480                 :            :         {
    2481                 :         18 :           endloc = c_parser_parse_rtl_body (parser, specs->gimple_or_rtl_pass);
    2482                 :            : 
    2483                 :            :           /* Normally, store_parm_decls sets next_is_function_body,
    2484                 :            :              anticipating a function body.  We need a push_scope/pop_scope
    2485                 :            :              pair to flush out this state, or subsequent function parsing
    2486                 :            :              will go wrong.  */
    2487                 :         17 :           push_scope ();
    2488                 :         17 :           pop_scope ();
    2489                 :            : 
    2490                 :         17 :           finish_function (endloc);
    2491                 :         17 :           return;
    2492                 :            :         }
    2493                 :            :       /* If the definition was marked with __GIMPLE then parse the
    2494                 :            :          function body as GIMPLE.  */
    2495                 :   20340300 :       else if (specs->declspec_il != cdil_none)
    2496                 :            :         {
    2497                 :        138 :           bool saved = in_late_binary_op;
    2498                 :        138 :           in_late_binary_op = true;
    2499                 :        138 :           c_parser_parse_gimple_body (parser, specs->gimple_or_rtl_pass,
    2500                 :        138 :                                       specs->declspec_il,
    2501                 :            :                                       specs->entry_bb_count);
    2502                 :        138 :           in_late_binary_op = saved;
    2503                 :            :         }
    2504                 :            :       else
    2505                 :   20340100 :         fnbody = c_parser_compound_statement (parser, &endloc);
    2506                 :   20340300 :       tree fndecl = current_function_decl;
    2507                 :   20340300 :       if (nested)
    2508                 :            :         {
    2509                 :       1400 :           tree decl = current_function_decl;
    2510                 :            :           /* Mark nested functions as needing static-chain initially.
    2511                 :            :              lower_nested_functions will recompute it but the
    2512                 :            :              DECL_STATIC_CHAIN flag is also used before that happens,
    2513                 :            :              by initializer_constant_valid_p.  See gcc.dg/nested-fn-2.c.  */
    2514                 :       1400 :           DECL_STATIC_CHAIN (decl) = 1;
    2515                 :       1400 :           add_stmt (fnbody);
    2516                 :       1400 :           finish_function (endloc);
    2517                 :       1400 :           c_pop_function_context ();
    2518                 :       1400 :           add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
    2519                 :            :         }
    2520                 :            :       else
    2521                 :            :         {
    2522                 :   20338900 :           if (fnbody)
    2523                 :   20338700 :             add_stmt (fnbody);
    2524                 :   20338900 :           finish_function (endloc);
    2525                 :            :         }
    2526                 :            :       /* Get rid of the empty stmt list for GIMPLE/RTL.  */
    2527                 :   20340300 :       if (specs->declspec_il != cdil_none)
    2528                 :        138 :         DECL_SAVED_TREE (fndecl) = NULL_TREE;
    2529                 :            : 
    2530                 :   20340300 :       break;
    2531                 :            :     }
    2532                 :            : }
    2533                 :            : 
    2534                 :            : /* Parse an asm-definition (asm() outside a function body).  This is a
    2535                 :            :    GNU extension.
    2536                 :            : 
    2537                 :            :    asm-definition:
    2538                 :            :      simple-asm-expr ;
    2539                 :            : */
    2540                 :            : 
    2541                 :            : static void
    2542                 :        140 : c_parser_asm_definition (c_parser *parser)
    2543                 :            : {
    2544                 :        140 :   tree asm_str = c_parser_simple_asm_expr (parser);
    2545                 :        140 :   if (asm_str)
    2546                 :        134 :     symtab->finalize_toplevel_asm (asm_str);
    2547                 :        140 :   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
    2548                 :        140 : }
    2549                 :            : 
    2550                 :            : /* Parse a static assertion (C11 6.7.10).
    2551                 :            : 
    2552                 :            :    static_assert-declaration:
    2553                 :            :      static_assert-declaration-no-semi ;
    2554                 :            : */
    2555                 :            : 
    2556                 :            : static void
    2557                 :        822 : c_parser_static_assert_declaration (c_parser *parser)
    2558                 :            : {
    2559                 :        822 :   c_parser_static_assert_declaration_no_semi (parser);
    2560                 :        822 :   if (parser->error
    2561                 :        822 :       || !c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
    2562                 :          8 :     c_parser_skip_to_end_of_block_or_statement (parser);
    2563                 :        822 : }
    2564                 :            : 
    2565                 :            : /* Parse a static assertion (C11 6.7.10), without the trailing
    2566                 :            :    semicolon.
    2567                 :            : 
    2568                 :            :    static_assert-declaration-no-semi:
    2569                 :            :      _Static_assert ( constant-expression , string-literal )
    2570                 :            : 
    2571                 :            :    C2X:
    2572                 :            :    static_assert-declaration-no-semi:
    2573                 :            :      _Static_assert ( constant-expression )
    2574                 :            : */
    2575                 :            : 
    2576                 :            : static void
    2577                 :        826 : c_parser_static_assert_declaration_no_semi (c_parser *parser)
    2578                 :            : {
    2579                 :        826 :   location_t assert_loc, value_loc;
    2580                 :        826 :   tree value;
    2581                 :        826 :   tree string = NULL_TREE;
    2582                 :            : 
    2583                 :        826 :   gcc_assert (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT));
    2584                 :        826 :   assert_loc = c_parser_peek_token (parser)->location;
    2585                 :        826 :   if (flag_isoc99)
    2586                 :        823 :     pedwarn_c99 (assert_loc, OPT_Wpedantic,
    2587                 :            :                  "ISO C99 does not support %<_Static_assert%>");
    2588                 :            :   else
    2589                 :          3 :     pedwarn_c99 (assert_loc, OPT_Wpedantic,
    2590                 :            :                  "ISO C90 does not support %<_Static_assert%>");
    2591                 :        826 :   c_parser_consume_token (parser);
    2592                 :        826 :   matching_parens parens;
    2593                 :        826 :   if (!parens.require_open (parser))
    2594                 :         10 :     return;
    2595                 :        825 :   location_t value_tok_loc = c_parser_peek_token (parser)->location;
    2596                 :        825 :   value = c_parser_expr_no_commas (parser, NULL).value;
    2597                 :        825 :   value_loc = EXPR_LOC_OR_LOC (value, value_tok_loc);
    2598                 :        825 :   if (c_parser_next_token_is (parser, CPP_COMMA))
    2599                 :            :     {
    2600                 :        748 :       c_parser_consume_token (parser);
    2601                 :        748 :       switch (c_parser_peek_token (parser)->type)
    2602                 :            :         {
    2603                 :        745 :         case CPP_STRING:
    2604                 :        745 :         case CPP_STRING16:
    2605                 :        745 :         case CPP_STRING32:
    2606                 :        745 :         case CPP_WSTRING:
    2607                 :        745 :         case CPP_UTF8STRING:
    2608                 :        745 :           string = c_parser_string_literal (parser, false, true).value;
    2609                 :        745 :           break;
    2610                 :          3 :         default:
    2611                 :          3 :           c_parser_error (parser, "expected string literal");
    2612                 :          3 :           return;
    2613                 :            :         }
    2614                 :            :     }
    2615                 :         77 :   else if (flag_isoc11)
    2616                 :            :     /* If pedantic for pre-C11, the use of _Static_assert itself will
    2617                 :            :        have been diagnosed, so do not also diagnose the use of this
    2618                 :            :        new C2X feature of _Static_assert.  */
    2619                 :         76 :     pedwarn_c11 (assert_loc, OPT_Wpedantic,
    2620                 :            :                  "ISO C11 does not support omitting the string in "
    2621                 :            :                  "%<_Static_assert%>");
    2622                 :        822 :   parens.require_close (parser);
    2623                 :            : 
    2624                 :        822 :   if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
    2625                 :            :     {
    2626                 :          2 :       error_at (value_loc, "expression in static assertion is not an integer");
    2627                 :          2 :       return;
    2628                 :            :     }
    2629                 :        820 :   if (TREE_CODE (value) != INTEGER_CST)
    2630                 :            :     {
    2631                 :          9 :       value = c_fully_fold (value, false, NULL);
    2632                 :            :       /* Strip no-op conversions.  */
    2633                 :          9 :       STRIP_TYPE_NOPS (value);
    2634                 :          9 :       if (TREE_CODE (value) == INTEGER_CST)
    2635                 :          5 :         pedwarn (value_loc, OPT_Wpedantic, "expression in static assertion "
    2636                 :            :                  "is not an integer constant expression");
    2637                 :            :     }
    2638                 :        820 :   if (TREE_CODE (value) != INTEGER_CST)
    2639                 :            :     {
    2640                 :          4 :       error_at (value_loc, "expression in static assertion is not constant");
    2641                 :          4 :       return;
    2642                 :            :     }
    2643                 :        816 :   constant_expression_warning (value);
    2644                 :        816 :   if (integer_zerop (value))
    2645                 :            :     {
    2646                 :          9 :       if (string)
    2647                 :          8 :         error_at (assert_loc, "static assertion failed: %E", string);
    2648                 :            :       else
    2649                 :          1 :         error_at (assert_loc, "static assertion failed");
    2650                 :            :     }
    2651                 :            : }
    2652                 :            : 
    2653                 :            : /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
    2654                 :            :    6.7, C11 6.7), adding them to SPECS (which may already include some).
    2655                 :            :    Storage class specifiers are accepted iff SCSPEC_OK; type
    2656                 :            :    specifiers are accepted iff TYPESPEC_OK; alignment specifiers are
    2657                 :            :    accepted iff ALIGNSPEC_OK; gnu-attributes are accepted at the start
    2658                 :            :    iff START_ATTR_OK; __auto_type is accepted iff AUTO_TYPE_OK.  In
    2659                 :            :    addition to the syntax shown, standard attributes are accepted at
    2660                 :            :    the start iff START_STD_ATTR_OK and at the end iff END_STD_ATTR_OK;
    2661                 :            :    unlike gnu-attributes, they are not accepted in the middle of the
    2662                 :            :    list.  (This combines various different syntax productions in the C
    2663                 :            :    standard, and in some cases gnu-attributes and standard attributes
    2664                 :            :    at the start may already have been parsed before this function is
    2665                 :            :    called.)
    2666                 :            : 
    2667                 :            :    declaration-specifiers:
    2668                 :            :      storage-class-specifier declaration-specifiers[opt]
    2669                 :            :      type-specifier declaration-specifiers[opt]
    2670                 :            :      type-qualifier declaration-specifiers[opt]
    2671                 :            :      function-specifier declaration-specifiers[opt]
    2672                 :            :      alignment-specifier declaration-specifiers[opt]
    2673                 :            : 
    2674                 :            :    Function specifiers (inline) are from C99, and are currently
    2675                 :            :    handled as storage class specifiers, as is __thread.  Alignment
    2676                 :            :    specifiers are from C11.
    2677                 :            : 
    2678                 :            :    C90 6.5.1, C99 6.7.1, C11 6.7.1:
    2679                 :            :    storage-class-specifier:
    2680                 :            :      typedef
    2681                 :            :      extern
    2682                 :            :      static
    2683                 :            :      auto
    2684                 :            :      register
    2685                 :            :      _Thread_local
    2686                 :            : 
    2687                 :            :    (_Thread_local is new in C11.)
    2688                 :            : 
    2689                 :            :    C99 6.7.4, C11 6.7.4:
    2690                 :            :    function-specifier:
    2691                 :            :      inline
    2692                 :            :      _Noreturn
    2693                 :            : 
    2694                 :            :    (_Noreturn is new in C11.)
    2695                 :            : 
    2696                 :            :    C90 6.5.2, C99 6.7.2, C11 6.7.2:
    2697                 :            :    type-specifier:
    2698                 :            :      void
    2699                 :            :      char
    2700                 :            :      short
    2701                 :            :      int
    2702                 :            :      long
    2703                 :            :      float
    2704                 :            :      double
    2705                 :            :      signed
    2706                 :            :      unsigned
    2707                 :            :      _Bool
    2708                 :            :      _Complex
    2709                 :            :      [_Imaginary removed in C99 TC2]
    2710                 :            :      struct-or-union-specifier
    2711                 :            :      enum-specifier
    2712                 :            :      typedef-name
    2713                 :            :      atomic-type-specifier
    2714                 :            : 
    2715                 :            :    (_Bool and _Complex are new in C99.)
    2716                 :            :    (atomic-type-specifier is new in C11.)
    2717                 :            : 
    2718                 :            :    C90 6.5.3, C99 6.7.3, C11 6.7.3:
    2719                 :            : 
    2720                 :            :    type-qualifier:
    2721                 :            :      const
    2722                 :            :      restrict
    2723                 :            :      volatile
    2724                 :            :      address-space-qualifier
    2725                 :            :      _Atomic
    2726                 :            : 
    2727                 :            :    (restrict is new in C99.)
    2728                 :            :    (_Atomic is new in C11.)
    2729                 :            : 
    2730                 :            :    GNU extensions:
    2731                 :            : 
    2732                 :            :    declaration-specifiers:
    2733                 :            :      gnu-attributes declaration-specifiers[opt]
    2734                 :            : 
    2735                 :            :    type-qualifier:
    2736                 :            :      address-space
    2737                 :            : 
    2738                 :            :    address-space:
    2739                 :            :      identifier recognized by the target
    2740                 :            : 
    2741                 :            :    storage-class-specifier:
    2742                 :            :      __thread
    2743                 :            : 
    2744                 :            :    type-specifier:
    2745                 :            :      typeof-specifier
    2746                 :            :      __auto_type
    2747                 :            :      __intN
    2748                 :            :      _Decimal32
    2749                 :            :      _Decimal64
    2750                 :            :      _Decimal128
    2751                 :            :      _Fract
    2752                 :            :      _Accum
    2753                 :            :      _Sat
    2754                 :            : 
    2755                 :            :   (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
    2756                 :            :    http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
    2757                 :            : 
    2758                 :            :    atomic-type-specifier
    2759                 :            :     _Atomic ( type-name )
    2760                 :            : 
    2761                 :            :    Objective-C:
    2762                 :            : 
    2763                 :            :    type-specifier:
    2764                 :            :      class-name objc-protocol-refs[opt]
    2765                 :            :      typedef-name objc-protocol-refs
    2766                 :            :      objc-protocol-refs
    2767                 :            : */
    2768                 :            : 
    2769                 :            : void
    2770                 :  198221000 : c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
    2771                 :            :                     bool scspec_ok, bool typespec_ok, bool start_attr_ok,
    2772                 :            :                     bool alignspec_ok, bool auto_type_ok,
    2773                 :            :                     bool start_std_attr_ok, bool end_std_attr_ok,
    2774                 :            :                     enum c_lookahead_kind la)
    2775                 :            : {
    2776                 :  198221000 :   bool attrs_ok = start_attr_ok;
    2777                 :  198221000 :   bool seen_type = specs->typespec_kind != ctsk_none;
    2778                 :            : 
    2779                 :  198221000 :   if (!typespec_ok)
    2780                 :   13013100 :     gcc_assert (la == cla_prefer_id);
    2781                 :            : 
    2782                 :  198221000 :   if (start_std_attr_ok
    2783                 :  198221000 :       && c_parser_nth_token_starts_std_attributes (parser, 1))
    2784                 :            :     {
    2785                 :         71 :       gcc_assert (!specs->non_std_attrs_seen_p);
    2786                 :         71 :       location_t loc = c_parser_peek_token (parser)->location;
    2787                 :         71 :       tree attrs = c_parser_std_attribute_specifier_sequence (parser);
    2788                 :         71 :       declspecs_add_attrs (loc, specs, attrs);
    2789                 :         71 :       specs->non_std_attrs_seen_p = false;
    2790                 :            :     }
    2791                 :            : 
    2792                 :  955923000 :   while (c_parser_next_token_is (parser, CPP_NAME)
    2793                 :  226962000 :          || c_parser_next_token_is (parser, CPP_KEYWORD)
    2794                 :  566680000 :          || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
    2795                 :            :     {
    2796                 :  389243000 :       struct c_typespec t;
    2797                 :  389243000 :       tree attrs;
    2798                 :  389243000 :       tree align;
    2799                 :  389243000 :       location_t loc = c_parser_peek_token (parser)->location;
    2800                 :            : 
    2801                 :            :       /* If we cannot accept a type, exit if the next token must start
    2802                 :            :          one.  Also, if we already have seen a tagged definition,
    2803                 :            :          a typename would be an error anyway and likely the user
    2804                 :            :          has simply forgotten a semicolon, so we exit.  */
    2805                 :  378379000 :       if ((!typespec_ok || specs->typespec_kind == ctsk_tagdef)
    2806                 :   11461900 :           && c_parser_next_tokens_start_typename (parser, la)
    2807                 :    2639980 :           && !c_parser_next_token_is_qualifier (parser)
    2808                 :  389243000 :           && !c_parser_next_token_is_keyword (parser, RID_ALIGNAS))
    2809                 :            :         break;
    2810                 :            : 
    2811                 :  389243000 :       if (c_parser_next_token_is (parser, CPP_NAME))
    2812                 :            :         {
    2813                 :  250999000 :           c_token *name_token = c_parser_peek_token (parser);
    2814                 :  250999000 :           tree value = name_token->value;
    2815                 :  250999000 :           c_id_kind kind = name_token->id_kind;
    2816                 :            : 
    2817                 :  250999000 :           if (kind == C_ID_ADDRSPACE)
    2818                 :            :             {
    2819                 :         29 :               addr_space_t as
    2820                 :         29 :                 = name_token->keyword - RID_FIRST_ADDR_SPACE;
    2821                 :         29 :               declspecs_add_addrspace (name_token->location, specs, as);
    2822                 :         29 :               c_parser_consume_token (parser);
    2823                 :         29 :               attrs_ok = true;
    2824                 :  141498000 :               continue;
    2825                 :            :             }
    2826                 :            : 
    2827                 :  501998000 :           gcc_assert (!c_parser_next_token_is_qualifier (parser));
    2828                 :            : 
    2829                 :            :           /* If we cannot accept a type, and the next token must start one,
    2830                 :            :              exit.  Do the same if we already have seen a tagged definition,
    2831                 :            :              since it would be an error anyway and likely the user has simply
    2832                 :            :              forgotten a semicolon.  */
    2833                 :  250999000 :           if (seen_type || !c_parser_next_tokens_start_typename (parser, la))
    2834                 :            :             break;
    2835                 :            : 
    2836                 :            :           /* Now at an unknown typename (C_ID_ID), a C_ID_TYPENAME or
    2837                 :            :              a C_ID_CLASSNAME.  */
    2838                 :  141498000 :           c_parser_consume_token (parser);
    2839                 :  141498000 :           seen_type = true;
    2840                 :  141498000 :           attrs_ok = true;
    2841                 :  141498000 :           if (kind == C_ID_ID)
    2842                 :            :             {
    2843                 :         45 :               error_at (loc, "unknown type name %qE", value);
    2844                 :         45 :               t.kind = ctsk_typedef;
    2845                 :         45 :               t.spec = error_mark_node;
    2846                 :            :             }
    2847                 :  141498000 :           else if (kind == C_ID_TYPENAME
    2848                 :  141498000 :                    && (!c_dialect_objc ()
    2849                 :          0 :                        || c_parser_next_token_is_not (parser, CPP_LESS)))
    2850                 :            :             {
    2851                 :  141498000 :               t.kind = ctsk_typedef;
    2852                 :            :               /* For a typedef name, record the meaning, not the name.
    2853                 :            :                  In case of 'foo foo, bar;'.  */
    2854                 :  141498000 :               t.spec = lookup_name (value);
    2855                 :            :             }
    2856                 :            :           else
    2857                 :            :             {
    2858                 :          0 :               tree proto = NULL_TREE;
    2859                 :          0 :               gcc_assert (c_dialect_objc ());
    2860                 :          0 :               t.kind = ctsk_objc;
    2861                 :          0 :               if (c_parser_next_token_is (parser, CPP_LESS))
    2862                 :          0 :                 proto = c_parser_objc_protocol_refs (parser);
    2863                 :          0 :               t.spec = objc_get_protocol_qualified_type (value, proto);
    2864                 :            :             }
    2865                 :  141498000 :           t.expr = NULL_TREE;
    2866                 :  141498000 :           t.expr_const_operands = true;
    2867                 :  141498000 :           declspecs_add_type (name_token->location, specs, t);
    2868                 :  141498000 :           continue;
    2869                 :            :         }
    2870                 :  138244000 :       if (c_parser_next_token_is (parser, CPP_LESS))
    2871                 :            :         {
    2872                 :            :           /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
    2873                 :            :              nisse@lysator.liu.se.  */
    2874                 :          0 :           tree proto;
    2875                 :          0 :           gcc_assert (c_dialect_objc ());
    2876                 :          0 :           if (!typespec_ok || seen_type)
    2877                 :            :             break;
    2878                 :          0 :           proto = c_parser_objc_protocol_refs (parser);
    2879                 :          0 :           t.kind = ctsk_objc;
    2880                 :          0 :           t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
    2881                 :          0 :           t.expr = NULL_TREE;
    2882                 :          0 :           t.expr_const_operands = true;
    2883                 :          0 :           declspecs_add_type (loc, specs, t);
    2884                 :          0 :           continue;
    2885                 :            :         }
    2886                 :  138244000 :       gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
    2887                 :  138244000 :       switch (c_parser_peek_token (parser)->keyword)
    2888                 :            :         {
    2889                 :   53114200 :         case RID_STATIC:
    2890                 :   53114200 :         case RID_EXTERN:
    2891                 :   53114200 :         case RID_REGISTER:
    2892                 :   53114200 :         case RID_TYPEDEF:
    2893                 :   53114200 :         case RID_INLINE:
    2894                 :   53114200 :         case RID_NORETURN:
    2895                 :   53114200 :         case RID_AUTO:
    2896                 :   53114200 :         case RID_THREAD:
    2897                 :   53114200 :           if (!scspec_ok)
    2898                 :       1447 :             goto out;
    2899                 :   53114200 :           attrs_ok = true;
    2900                 :            :           /* TODO: Distinguish between function specifiers (inline, noreturn)
    2901                 :            :              and storage class specifiers, either here or in
    2902                 :            :              declspecs_add_scspec.  */
    2903                 :   53114200 :           declspecs_add_scspec (loc, specs,
    2904                 :   53114200 :                                 c_parser_peek_token (parser)->value);
    2905                 :   53114200 :           c_parser_consume_token (parser);
    2906                 :   53114200 :           break;
    2907                 :       1387 :         case RID_AUTO_TYPE:
    2908                 :       1387 :           if (!auto_type_ok)
    2909                 :          0 :             goto out;
    2910                 :            :           /* Fall through.  */
    2911                 :   52029500 :         case RID_UNSIGNED:
    2912                 :   52029500 :         case RID_LONG:
    2913                 :   52029500 :         case RID_SHORT:
    2914                 :   52029500 :         case RID_SIGNED:
    2915                 :   52029500 :         case RID_COMPLEX:
    2916                 :   52029500 :         case RID_INT:
    2917                 :   52029500 :         case RID_CHAR:
    2918                 :   52029500 :         case RID_FLOAT:
    2919                 :   52029500 :         case RID_DOUBLE:
    2920                 :   52029500 :         case RID_VOID:
    2921                 :   52029500 :         case RID_DFLOAT32:
    2922                 :   52029500 :         case RID_DFLOAT64:
    2923                 :   52029500 :         case RID_DFLOAT128:
    2924                 :   52029500 :         CASE_RID_FLOATN_NX:
    2925                 :   52029500 :         case RID_BOOL:
    2926                 :   52029500 :         case RID_FRACT:
    2927                 :   52029500 :         case RID_ACCUM:
    2928                 :   52029500 :         case RID_SAT:
    2929                 :   52029500 :         case RID_INT_N_0:
    2930                 :   52029500 :         case RID_INT_N_1:
    2931                 :   52029500 :         case RID_INT_N_2:
    2932                 :   52029500 :         case RID_INT_N_3:
    2933                 :   52029500 :           if (!typespec_ok)
    2934                 :          0 :             goto out;
    2935                 :   52029500 :           attrs_ok = true;
    2936                 :   52029500 :           seen_type = true;
    2937                 :   52029500 :           if (c_dialect_objc ())
    2938                 :          0 :             parser->objc_need_raw_identifier = true;
    2939                 :   52029500 :           t.kind = ctsk_resword;
    2940                 :   52029500 :           t.spec = c_parser_peek_token (parser)->value;
    2941                 :   52029500 :           t.expr = NULL_TREE;
    2942                 :   52029500 :           t.expr_const_operands = true;
    2943                 :   52029500 :           declspecs_add_type (loc, specs, t);
    2944                 :   52029500 :           c_parser_consume_token (parser);
    2945                 :   52029500 :           break;
    2946                 :     179355 :         case RID_ENUM:
    2947                 :     179355 :           if (!typespec_ok)
    2948                 :          0 :             goto out;
    2949                 :     179355 :           attrs_ok = true;
    2950                 :     179355 :           seen_type = true;
    2951                 :     179355 :           t = c_parser_enum_specifier (parser);
    2952                 :     179355 :           invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec);
    2953                 :     179355 :           declspecs_add_type (loc, specs, t);
    2954                 :     179355 :           break;
    2955                 :    1590900 :         case RID_STRUCT:
    2956                 :    1590900 :         case RID_UNION:
    2957                 :    1590900 :           if (!typespec_ok)
    2958                 :          0 :             goto out;
    2959                 :    1590900 :           attrs_ok = true;
    2960                 :    1590900 :           seen_type = true;
    2961                 :    1590900 :           t = c_parser_struct_or_union_specifier (parser);
    2962                 :    1590900 :           invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec);
    2963                 :    1590900 :           declspecs_add_type (loc, specs, t);
    2964                 :    1590900 :           break;
    2965                 :     810137 :         case RID_TYPEOF:
    2966                 :            :           /* ??? The old parser rejected typeof after other type
    2967                 :            :              specifiers, but is a syntax error the best way of
    2968                 :            :              handling this?  */
    2969                 :     810137 :           if (!typespec_ok || seen_type)
    2970                 :          2 :             goto out;
    2971                 :     810135 :           attrs_ok = true;
    2972                 :     810135 :           seen_type = true;
    2973                 :     810135 :           t = c_parser_typeof_specifier (parser);
    2974                 :     810135 :           declspecs_add_type (loc, specs, t);
    2975                 :     810135 :           break;
    2976                 :      29235 :         case RID_ATOMIC:
    2977                 :            :           /* C parser handling of Objective-C constructs needs
    2978                 :            :              checking for correct lvalue-to-rvalue conversions, and
    2979                 :            :              the code in build_modify_expr handling various
    2980                 :            :              Objective-C cases, and that in build_unary_op handling
    2981                 :            :              Objective-C cases for increment / decrement, also needs
    2982                 :            :              updating; uses of TYPE_MAIN_VARIANT in objc_compare_types
    2983                 :            :              and objc_types_are_equivalent may also need updates.  */
    2984                 :      29235 :           if (c_dialect_objc ())
    2985                 :          0 :             sorry ("%<_Atomic%> in Objective-C");
    2986                 :      29235 :           if (flag_isoc99)
    2987                 :      29184 :             pedwarn_c99 (loc, OPT_Wpedantic,
    2988                 :            :                          "ISO C99 does not support the %<_Atomic%> qualifier");
    2989                 :            :           else
    2990                 :         51 :             pedwarn_c99 (loc, OPT_Wpedantic,
    2991                 :            :                          "ISO C90 does not support the %<_Atomic%> qualifier");
    2992                 :      29235 :           attrs_ok = true;
    2993                 :      29235 :           tree value;
    2994                 :      29235 :           value = c_parser_peek_token (parser)->value;
    2995                 :      29235 :           c_parser_consume_token (parser);
    2996                 :      58272 :           if (typespec_ok && c_parser_next_token_is (parser, CPP_OPEN_PAREN))
    2997                 :            :             {
    2998                 :            :               /* _Atomic ( type-name ).  */
    2999                 :      13420 :               seen_type = true;
    3000                 :      13420 :               c_parser_consume_token (parser);
    3001                 :      13420 :               struct c_type_name *type = c_parser_type_name (parser);
    3002                 :      13420 :               t.kind = ctsk_typeof;
    3003                 :      13420 :               t.spec = error_mark_node;
    3004                 :      13420 :               t.expr = NULL_TREE;
    3005                 :      13420 :               t.expr_const_operands = true;
    3006                 :      13420 :               if (type != NULL)
    3007                 :      13419 :                 t.spec = groktypename (type, &t.expr,
    3008                 :            :                                        &t.expr_const_operands);
    3009                 :      13420 :               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    3010                 :            :                                          "expected %<)%>");
    3011                 :      13420 :               if (t.spec != error_mark_node)
    3012                 :            :                 {
    3013                 :      13419 :                   if (TREE_CODE (t.spec) == ARRAY_TYPE)
    3014                 :          1 :                     error_at (loc, "%<_Atomic%>-qualified array type");
    3015                 :      13418 :                   else if (TREE_CODE (t.spec) == FUNCTION_TYPE)
    3016                 :          1 :                     error_at (loc, "%<_Atomic%>-qualified function type");
    3017                 :      13417 :                   else if (TYPE_QUALS (t.spec) != TYPE_UNQUALIFIED)
    3018                 :          4 :                     error_at (loc, "%<_Atomic%> applied to a qualified type");
    3019                 :            :                   else
    3020                 :      13413 :                     t.spec = c_build_qualified_type (t.spec, TYPE_QUAL_ATOMIC);
    3021                 :            :                 }
    3022                 :      13420 :               declspecs_add_type (loc, specs, t);
    3023                 :            :             }
    3024                 :            :           else
    3025                 :      15815 :             declspecs_add_qual (loc, specs, value);
    3026                 :            :           break;
    3027                 :   10367400 :         case RID_CONST:
    3028                 :   10367400 :         case RID_VOLATILE:
    3029                 :   10367400 :         case RID_RESTRICT:
    3030                 :   10367400 :           attrs_ok = true;
    3031                 :   10367400 :           declspecs_add_qual (loc, specs, c_parser_peek_token (parser)->value);
    3032                 :   10367400 :           c_parser_consume_token (parser);
    3033                 :   10367400 :           break;
    3034                 :   20121400 :         case RID_ATTRIBUTE:
    3035                 :   20121400 :           if (!attrs_ok)
    3036                 :          0 :             goto out;
    3037                 :   20121400 :           attrs = c_parser_gnu_attributes (parser);
    3038                 :   20121400 :           declspecs_add_attrs (loc, specs, attrs);
    3039                 :   20121400 :           break;
    3040                 :        183 :         case RID_ALIGNAS:
    3041                 :        183 :           if (!alignspec_ok)
    3042                 :         16 :             goto out;
    3043                 :        167 :           align = c_parser_alignas_specifier (parser);
    3044                 :        167 :           declspecs_add_alignas (loc, specs, align);
    3045                 :        167 :           break;
    3046                 :        138 :         case RID_GIMPLE:
    3047                 :        138 :           if (! flag_gimple)
    3048                 :          0 :             error_at (loc, "%<__GIMPLE%> only valid with %<-fgimple%>");
    3049                 :        138 :           c_parser_consume_token (parser);
    3050                 :        138 :           specs->declspec_il = cdil_gimple;
    3051                 :        138 :           specs->locations[cdw_gimple] = loc;
    3052                 :        138 :           c_parser_gimple_or_rtl_pass_list (parser, specs);
    3053                 :        138 :           break;
    3054                 :         18 :         case RID_RTL:
    3055                 :         18 :           c_parser_consume_token (parser);
    3056                 :         18 :           specs->declspec_il = cdil_rtl;
    3057                 :         18 :           specs->locations[cdw_rtl] = loc;
    3058                 :         18 :           c_parser_gimple_or_rtl_pass_list (parser, specs);
    3059                 :         18 :           break;
    3060                 :       1379 :         default:
    3061                 :       1379 :           goto out;
    3062                 :            :         }
    3063                 :            :     }
    3064                 :  198221000 :  out:
    3065                 :  198221000 :   if (end_std_attr_ok
    3066                 :  198221000 :       && c_parser_nth_token_starts_std_attributes (parser, 1))
    3067                 :         33 :     specs->postfix_attrs = c_parser_std_attribute_specifier_sequence (parser);
    3068                 :  198221000 : }
    3069                 :            : 
    3070                 :            : /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2, C11 6.7.2.2).
    3071                 :            : 
    3072                 :            :    enum-specifier:
    3073                 :            :      enum gnu-attributes[opt] identifier[opt] { enumerator-list }
    3074                 :            :        gnu-attributes[opt]
    3075                 :            :      enum gnu-attributes[opt] identifier[opt] { enumerator-list , }
    3076                 :            :        gnu-attributes[opt]
    3077                 :            :      enum gnu-attributes[opt] identifier
    3078                 :            : 
    3079                 :            :    The form with trailing comma is new in C99.  The forms with
    3080                 :            :    gnu-attributes are GNU extensions.  In GNU C, we accept any expression
    3081                 :            :    without commas in the syntax (assignment expressions, not just
    3082                 :            :    conditional expressions); assignment expressions will be diagnosed
    3083                 :            :    as non-constant.
    3084                 :            : 
    3085                 :            :    enumerator-list:
    3086                 :            :      enumerator
    3087                 :            :      enumerator-list , enumerator
    3088                 :            : 
    3089                 :            :    enumerator:
    3090                 :            :      enumeration-constant attribute-specifier-sequence[opt]
    3091                 :            :      enumeration-constant attribute-specifier-sequence[opt]
    3092                 :            :        = constant-expression
    3093                 :            : 
    3094                 :            :    GNU Extensions:
    3095                 :            : 
    3096                 :            :    enumerator:
    3097                 :            :      enumeration-constant attribute-specifier-sequence[opt] gnu-attributes[opt]
    3098                 :            :      enumeration-constant attribute-specifier-sequence[opt] gnu-attributes[opt]
    3099                 :            :        = constant-expression
    3100                 :            : 
    3101                 :            : */
    3102                 :            : 
    3103                 :            : static struct c_typespec
    3104                 :     179355 : c_parser_enum_specifier (c_parser *parser)
    3105                 :            : {
    3106                 :     179355 :   struct c_typespec ret;
    3107                 :     179355 :   bool have_std_attrs;
    3108                 :     179355 :   tree std_attrs = NULL_TREE;
    3109                 :     179355 :   tree attrs;
    3110                 :     179355 :   tree ident = NULL_TREE;
    3111                 :     179355 :   location_t enum_loc;
    3112                 :     179355 :   location_t ident_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
    3113                 :     179355 :   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM));
    3114                 :     179355 :   c_parser_consume_token (parser);
    3115                 :     179355 :   have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1);
    3116                 :     179355 :   if (have_std_attrs)
    3117                 :          8 :     std_attrs = c_parser_std_attribute_specifier_sequence (parser);
    3118                 :     179355 :   attrs = c_parser_gnu_attributes (parser);
    3119                 :     179355 :   enum_loc = c_parser_peek_token (parser)->location;
    3120                 :            :   /* Set the location in case we create a decl now.  */
    3121                 :     179355 :   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
    3122                 :     179355 :   if (c_parser_next_token_is (parser, CPP_NAME))
    3123                 :            :     {
    3124                 :     110941 :       ident = c_parser_peek_token (parser)->value;
    3125                 :     110941 :       ident_loc = c_parser_peek_token (parser)->location;
    3126                 :     110941 :       enum_loc = ident_loc;
    3127                 :     110941 :       c_parser_consume_token (parser);
    3128                 :            :     }
    3129                 :     179355 :   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
    3130                 :            :     {
    3131                 :            :       /* Parse an enum definition.  */
    3132                 :     134369 :       struct c_enum_contents the_enum;
    3133                 :     134369 :       tree type;
    3134                 :     134369 :       tree postfix_attrs;
    3135                 :            :       /* We chain the enumerators in reverse order, then put them in
    3136                 :            :          forward order at the end.  */
    3137                 :     134369 :       tree values;
    3138                 :     134369 :       timevar_push (TV_PARSE_ENUM);
    3139                 :     134369 :       type = start_enum (enum_loc, &the_enum, ident);
    3140                 :     134369 :       values = NULL_TREE;
    3141                 :     134369 :       c_parser_consume_token (parser);
    3142                 :    4249210 :       while (true)
    3143                 :            :         {
    3144                 :    4249210 :           tree enum_id;
    3145                 :    4249210 :           tree enum_value;
    3146                 :    4249210 :           tree enum_decl;
    3147                 :    4249210 :           bool seen_comma;
    3148                 :    4249210 :           c_token *token;
    3149                 :    4249210 :           location_t comma_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
    3150                 :    4249210 :           location_t decl_loc, value_loc;
    3151                 :    4249210 :           if (c_parser_next_token_is_not (parser, CPP_NAME))
    3152                 :            :             {
    3153                 :            :               /* Give a nicer error for "enum {}".  */
    3154                 :          8 :               if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
    3155                 :          8 :                   && !parser->error)
    3156                 :            :                 {
    3157                 :          6 :                   error_at (c_parser_peek_token (parser)->location,
    3158                 :            :                             "empty enum is invalid");
    3159                 :          6 :                   parser->error = true;
    3160                 :            :                 }
    3161                 :            :               else
    3162                 :          2 :                 c_parser_error (parser, "expected identifier");
    3163                 :          8 :               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
    3164                 :          8 :               values = error_mark_node;
    3165                 :          8 :               break;
    3166                 :            :             }
    3167                 :    4249200 :           token = c_parser_peek_token (parser);
    3168                 :    4249200 :           enum_id = token->value;
    3169                 :            :           /* Set the location in case we create a decl now.  */
    3170                 :    4249200 :           c_parser_set_source_position_from_token (token);
    3171                 :    4249200 :           decl_loc = value_loc = token->location;
    3172                 :    4249200 :           c_parser_consume_token (parser);
    3173                 :            :           /* Parse any specified attributes.  */
    3174                 :    4249200 :           tree std_attrs = NULL_TREE;
    3175                 :    4249200 :           if (c_parser_nth_token_starts_std_attributes (parser, 1))
    3176                 :         10 :             std_attrs = c_parser_std_attribute_specifier_sequence (parser);
    3177                 :    4249200 :           tree enum_attrs = chainon (std_attrs,
    3178                 :            :                                      c_parser_gnu_attributes (parser));
    3179                 :    4249200 :           if (c_parser_next_token_is (parser, CPP_EQ))
    3180                 :            :             {
    3181                 :    2523480 :               c_parser_consume_token (parser);
    3182                 :    2523480 :               value_loc = c_parser_peek_token (parser)->location;
    3183                 :    2523480 :               enum_value = c_parser_expr_no_commas (parser, NULL).value;
    3184                 :            :             }
    3185                 :            :           else
    3186                 :            :             enum_value = NULL_TREE;
    3187                 :    4249200 :           enum_decl = build_enumerator (decl_loc, value_loc,
    3188                 :            :                                         &the_enum, enum_id, enum_value);
    3189                 :    4249200 :           if (enum_attrs)
    3190                 :         17 :             decl_attributes (&TREE_PURPOSE (enum_decl), enum_attrs, 0);
    3191                 :    4249200 :           TREE_CHAIN (enum_decl) = values;
    3192                 :    4249200 :           values = enum_decl;
    3193                 :    4249200 :           seen_comma = false;
    3194                 :    4249200 :           if (c_parser_next_token_is (parser, CPP_COMMA))
    3195                 :            :             {
    3196                 :    4122500 :               comma_loc = c_parser_peek_token (parser)->location;
    3197                 :    4122500 :               seen_comma = true;
    3198                 :    4122500 :               c_parser_consume_token (parser);
    3199                 :            :             }
    3200                 :    4249200 :           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
    3201                 :            :             {
    3202                 :     134346 :               if (seen_comma)
    3203                 :       7655 :                 pedwarn_c90 (comma_loc, OPT_Wpedantic,
    3204                 :            :                              "comma at end of enumerator list");
    3205                 :     134346 :               c_parser_consume_token (parser);
    3206                 :     134346 :               break;
    3207                 :            :             }
    3208                 :    4114860 :           if (!seen_comma)
    3209                 :            :             {
    3210                 :         15 :               c_parser_error (parser, "expected %<,%> or %<}%>");
    3211                 :         15 :               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
    3212                 :         15 :               values = error_mark_node;
    3213                 :         15 :               break;
    3214                 :            :             }
    3215                 :            :         }
    3216                 :     134369 :       postfix_attrs = c_parser_gnu_attributes (parser);
    3217                 :     134369 :       ret.spec = finish_enum (type, nreverse (values),
    3218                 :            :                               chainon (std_attrs,
    3219                 :            :                                        chainon (attrs, postfix_attrs)));
    3220                 :     134369 :       ret.kind = ctsk_tagdef;
    3221                 :     134369 :       ret.expr = NULL_TREE;
    3222                 :     134369 :       ret.expr_const_operands = true;
    3223                 :     134369 :       timevar_pop (TV_PARSE_ENUM);
    3224                 :     134369 :       return ret;
    3225                 :            :     }
    3226                 :      44986 :   else if (!ident)
    3227                 :            :     {
    3228                 :          0 :       c_parser_error (parser, "expected %<{%>");
    3229                 :          0 :       ret.spec = error_mark_node;
    3230                 :          0 :       ret.kind = ctsk_tagref;
    3231                 :          0 :       ret.expr = NULL_TREE;
    3232                 :          0 :       ret.expr_const_operands = true;
    3233                 :          0 :       return ret;
    3234                 :            :     }
    3235                 :            :   /* Attributes may only appear when the members are defined or in
    3236                 :            :      certain forward declarations (treat enum forward declarations in
    3237                 :            :      GNU C analogously to struct and union forward declarations in
    3238                 :            :      standard C).  */
    3239                 :      44987 :   if (have_std_attrs && c_parser_next_token_is_not (parser, CPP_SEMICOLON))
    3240                 :          1 :     c_parser_error (parser, "expected %<;%>");
    3241                 :      44986 :   ret = parser_xref_tag (ident_loc, ENUMERAL_TYPE, ident, have_std_attrs,
    3242                 :      44986 :                          std_attrs);
    3243                 :            :   /* In ISO C, enumerated types can be referred to only if already
    3244                 :            :      defined.  */
    3245                 :      44986 :   if (pedantic && !COMPLETE_TYPE_P (ret.spec))
    3246                 :            :     {
    3247                 :          9 :       gcc_assert (ident);
    3248                 :          9 :       pedwarn (enum_loc, OPT_Wpedantic,
    3249                 :            :                "ISO C forbids forward references to %<enum%> types");
    3250                 :            :     }
    3251                 :            :   return ret;
    3252                 :            : }
    3253                 :            : 
    3254                 :            : /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1, C11 6.7.2.1).
    3255                 :            : 
    3256                 :            :    struct-or-union-specifier:
    3257                 :            :      struct-or-union attribute-specifier-sequence[opt] gnu-attributes[opt]
    3258                 :            :        identifier[opt] { struct-contents } gnu-attributes[opt]
    3259                 :            :      struct-or-union attribute-specifier-sequence[opt] gnu-attributes[opt]
    3260                 :            :        identifier
    3261                 :            : 
    3262                 :            :    struct-contents:
    3263                 :            :      struct-declaration-list
    3264                 :            : 
    3265                 :            :    struct-declaration-list:
    3266                 :            :      struct-declaration ;
    3267                 :            :      struct-declaration-list struct-declaration ;
    3268                 :            : 
    3269                 :            :    GNU extensions:
    3270                 :            : 
    3271                 :            :    struct-contents:
    3272                 :            :      empty
    3273                 :            :      struct-declaration
    3274                 :            :      struct-declaration-list struct-declaration
    3275                 :            : 
    3276                 :            :    struct-declaration-list:
    3277                 :            :      struct-declaration-list ;
    3278                 :            :      ;
    3279                 :            : 
    3280                 :            :    (Note that in the syntax here, unlike that in ISO C, the semicolons
    3281                 :            :    are included here rather than in struct-declaration, in order to
    3282                 :            :    describe the syntax with extra semicolons and missing semicolon at
    3283                 :            :    end.)
    3284                 :            : 
    3285                 :            :    Objective-C:
    3286                 :            : 
    3287                 :            :    struct-declaration-list:
    3288                 :            :      @defs ( class-name )
    3289                 :            : 
    3290                 :            :    (Note this does not include a trailing semicolon, but can be
    3291                 :            :    followed by further declarations, and gets a pedwarn-if-pedantic
    3292                 :            :    when followed by a semicolon.)  */
    3293                 :            : 
    3294                 :            : static struct c_typespec
    3295                 :    1590900 : c_parser_struct_or_union_specifier (c_parser *parser)
    3296                 :            : {
    3297                 :    1590900 :   struct c_typespec ret;
    3298                 :    1590900 :   bool have_std_attrs;
    3299                 :    1590900 :   tree std_attrs = NULL_TREE;
    3300                 :    1590900 :   tree attrs;
    3301                 :    1590900 :   tree ident = NULL_TREE;
    3302                 :    1590900 :   location_t struct_loc;
    3303                 :    1590900 :   location_t ident_loc = UNKNOWN_LOCATION;
    3304                 :    1590900 :   enum tree_code code;
    3305                 :    1590900 :   switch (c_parser_peek_token (parser)->keyword)
    3306                 :            :     {
    3307                 :            :     case RID_STRUCT:
    3308                 :            :       code = RECORD_TYPE;
    3309                 :            :       break;
    3310                 :     280357 :     case RID_UNION:
    3311                 :     280357 :       code = UNION_TYPE;
    3312                 :     280357 :       break;
    3313                 :          0 :     default:
    3314                 :          0 :       gcc_unreachable ();
    3315                 :            :     }
    3316                 :    1590900 :   struct_loc = c_parser_peek_token (parser)->location;
    3317                 :    1590900 :   c_parser_consume_token (parser);
    3318                 :    1590900 :   have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1);
    3319                 :    1590900 :   if (have_std_attrs)
    3320                 :         22 :     std_attrs = c_parser_std_attribute_specifier_sequence (parser);
    3321                 :    1590900 :   attrs = c_parser_gnu_attributes (parser);
    3322                 :            : 
    3323                 :            :   /* Set the location in case we create a decl now.  */
    3324                 :    1590900 :   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
    3325                 :            : 
    3326                 :    1590900 :   if (c_parser_next_token_is (parser, CPP_NAME))
    3327                 :            :     {
    3328                 :    1135460 :       ident = c_parser_peek_token (parser)->value;
    3329                 :    1135460 :       ident_loc = c_parser_peek_token (parser)->location;
    3330                 :    1135460 :       struct_loc = ident_loc;
    3331                 :    1135460 :       c_parser_consume_token (parser);
    3332                 :            :     }
    3333                 :    1590900 :   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
    3334                 :            :     {
    3335                 :            :       /* Parse a struct or union definition.  Start the scope of the
    3336                 :            :          tag before parsing components.  */
    3337                 :     816099 :       class c_struct_parse_info *struct_info;
    3338                 :     816099 :       tree type = start_struct (struct_loc, code, ident, &struct_info);
    3339                 :     816099 :       tree postfix_attrs;
    3340                 :            :       /* We chain the components in reverse order, then put them in
    3341                 :            :          forward order at the end.  Each struct-declaration may
    3342                 :            :          declare multiple components (comma-separated), so we must use
    3343                 :            :          chainon to join them, although when parsing each
    3344                 :            :          struct-declaration we can use TREE_CHAIN directly.
    3345                 :            : 
    3346                 :            :          The theory behind all this is that there will be more
    3347                 :            :          semicolon separated fields than comma separated fields, and
    3348                 :            :          so we'll be minimizing the number of node traversals required
    3349                 :            :          by chainon.  */
    3350                 :     816099 :       tree contents;
    3351                 :     816099 :       timevar_push (TV_PARSE_STRUCT);
    3352                 :     816099 :       contents = NULL_TREE;
    3353                 :     816099 :       c_parser_consume_token (parser);
    3354                 :            :       /* Handle the Objective-C @defs construct,
    3355                 :            :          e.g. foo(sizeof(struct{ @defs(ClassName) }));.  */
    3356                 :     816099 :       if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
    3357                 :            :         {
    3358                 :          0 :           tree name;
    3359                 :          0 :           gcc_assert (c_dialect_objc ());
    3360                 :          0 :           c_parser_consume_token (parser);
    3361                 :          0 :           matching_parens parens;
    3362                 :          0 :           if (!parens.require_open (parser))
    3363                 :          0 :             goto end_at_defs;
    3364                 :          0 :           if (c_parser_next_token_is (parser, CPP_NAME)
    3365                 :          0 :               && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
    3366                 :            :             {
    3367                 :          0 :               name = c_parser_peek_token (parser)->value;
    3368                 :          0 :               c_parser_consume_token (parser);
    3369                 :            :             }
    3370                 :            :           else
    3371                 :            :             {
    3372                 :          0 :               c_parser_error (parser, "expected class name");
    3373                 :          0 :               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
    3374                 :          0 :               goto end_at_defs;
    3375                 :            :             }
    3376                 :          0 :           parens.skip_until_found_close (parser);
    3377                 :          0 :           contents = nreverse (objc_get_class_ivars (name));
    3378                 :            :         }
    3379                 :     816099 :     end_at_defs:
    3380                 :            :       /* Parse the struct-declarations and semicolons.  Problems with
    3381                 :            :          semicolons are diagnosed here; empty structures are diagnosed
    3382                 :            :          elsewhere.  */
    3383                 :    3757260 :       while (true)
    3384                 :            :         {
    3385                 :    3757260 :           tree decls;
    3386                 :            :           /* Parse any stray semicolon.  */
    3387                 :    3757260 :           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    3388                 :            :             {
    3389                 :         11 :               location_t semicolon_loc
    3390                 :         11 :                 = c_parser_peek_token (parser)->location;
    3391                 :         22 :               gcc_rich_location richloc (semicolon_loc);
    3392                 :         11 :               richloc.add_fixit_remove ();
    3393                 :         11 :               pedwarn (&richloc, OPT_Wpedantic,
    3394                 :            :                        "extra semicolon in struct or union specified");
    3395                 :         11 :               c_parser_consume_token (parser);
    3396                 :         11 :               continue;
    3397                 :            :             }
    3398                 :            :           /* Stop if at the end of the struct or union contents.  */
    3399                 :    3757250 :           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
    3400                 :            :             {
    3401                 :     816090 :               c_parser_consume_token (parser);
    3402                 :     816090 :               break;
    3403                 :            :             }
    3404                 :            :           /* Accept #pragmas at struct scope.  */
    3405                 :    2941160 :           if (c_parser_next_token_is (parser, CPP_PRAGMA))
    3406                 :            :             {
    3407                 :          9 :               c_parser_pragma (parser, pragma_struct, NULL);
    3408                 :          9 :               continue;
    3409                 :            :             }
    3410                 :            :           /* Parse some comma-separated declarations, but not the
    3411                 :            :              trailing semicolon if any.  */
    3412                 :    2941150 :           decls = c_parser_struct_declaration (parser);
    3413                 :    2941150 :           contents = chainon (decls, contents);
    3414                 :            :           /* If no semicolon follows, either we have a parse error or
    3415                 :            :              are at the end of the struct or union and should
    3416                 :            :              pedwarn.  */
    3417                 :    2941150 :           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    3418                 :    2941110 :             c_parser_consume_token (parser);
    3419                 :            :           else
    3420                 :            :             {
    3421                 :         40 :               if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
    3422                 :         29 :                 pedwarn (c_parser_peek_token (parser)->location, 0,
    3423                 :            :                          "no semicolon at end of struct or union");
    3424                 :         11 :               else if (parser->error
    3425                 :         11 :                        || !c_parser_next_token_starts_declspecs (parser))
    3426                 :            :                 {
    3427                 :          9 :                   c_parser_error (parser, "expected %<;%>");
    3428                 :          9 :                   c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
    3429                 :          9 :                   break;
    3430                 :            :                 }
    3431                 :            : 
    3432                 :            :               /* If we come here, we have already emitted an error
    3433                 :            :                  for an expected `;', identifier or `(', and we also
    3434                 :            :                  recovered already.  Go on with the next field. */
    3435                 :            :             }
    3436                 :            :         }
    3437                 :     816099 :       postfix_attrs = c_parser_gnu_attributes (parser);
    3438                 :     816099 :       ret.spec = finish_struct (struct_loc, type, nreverse (contents),
    3439                 :            :                                 chainon (std_attrs,
    3440                 :            :                                          chainon (attrs, postfix_attrs)),
    3441                 :            :                                 struct_info);
    3442                 :     816099 :       ret.kind = ctsk_tagdef;
    3443                 :     816099 :       ret.expr = NULL_TREE;
    3444                 :     816099 :       ret.expr_const_operands = true;
    3445                 :     816099 :       timevar_pop (TV_PARSE_STRUCT);
    3446                 :     816099 :       return ret;
    3447                 :            :     }
    3448                 :     774798 :   else if (!ident)
    3449                 :            :     {
    3450                 :          8 :       c_parser_error (parser, "expected %<{%>");
    3451                 :          8 :       ret.spec = error_mark_node;
    3452                 :          8 :       ret.kind = ctsk_tagref;
    3453                 :          8 :       ret.expr = NULL_TREE;
    3454                 :          8 :       ret.expr_const_operands = true;
    3455                 :          8 :       return ret;
    3456                 :            :     }
    3457                 :            :   /* Attributes may only appear when the members are defined or in
    3458                 :            :      certain forward declarations.  */
    3459                 :     774800 :   if (have_std_attrs && c_parser_next_token_is_not (parser, CPP_SEMICOLON))
    3460                 :          2 :     c_parser_error (parser, "expected %<;%>");
    3461                 :            :   /* ??? Existing practice is that GNU attributes are ignored after
    3462                 :            :      the struct or union keyword when not defining the members.  */
    3463                 :     774790 :   ret = parser_xref_tag (ident_loc, code, ident, have_std_attrs, std_attrs);
    3464                 :     774790 :   return ret;
    3465                 :            : }
    3466                 :            : 
    3467                 :            : /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1, C11 6.7.2.1),
    3468                 :            :    *without* the trailing semicolon.
    3469                 :            : 
    3470                 :            :    struct-declaration:
    3471                 :            :      attribute-specifier-sequence[opt] specifier-qualifier-list
    3472                 :            :        attribute-specifier-sequence[opt] struct-declarator-list
    3473                 :            :      static_assert-declaration-no-semi
    3474                 :            : 
    3475                 :            :    specifier-qualifier-list:
    3476                 :            :      type-specifier specifier-qualifier-list[opt]
    3477                 :            :      type-qualifier specifier-qualifier-list[opt]
    3478                 :            :      alignment-specifier specifier-qualifier-list[opt]
    3479                 :            :      gnu-attributes specifier-qualifier-list[opt]
    3480                 :            : 
    3481                 :            :    struct-declarator-list:
    3482                 :            :      struct-declarator
    3483                 :            :      struct-declarator-list , gnu-attributes[opt] struct-declarator
    3484                 :            : 
    3485                 :            :    struct-declarator:
    3486                 :            :      declarator gnu-attributes[opt]
    3487                 :            :      declarator[opt] : constant-expression gnu-attributes[opt]
    3488                 :            : 
    3489                 :            :    GNU extensions:
    3490                 :            : 
    3491                 :            :    struct-declaration:
    3492                 :            :      __extension__ struct-declaration
    3493                 :            :      specifier-qualifier-list
    3494                 :            : 
    3495                 :            :    Unlike the ISO C syntax, semicolons are handled elsewhere.  The use
    3496                 :            :    of gnu-attributes where shown is a GNU extension.  In GNU C, we accept
    3497                 :            :    any expression without commas in the syntax (assignment
    3498                 :            :    expressions, not just conditional expressions); assignment
    3499                 :            :    expressions will be diagnosed as non-constant.  */
    3500                 :            : 
    3501                 :            : static tree
    3502                 :    3029790 : c_parser_struct_declaration (c_parser *parser)
    3503                 :            : {
    3504                 :    3029790 :   struct c_declspecs *specs;
    3505                 :    3029790 :   tree prefix_attrs;
    3506                 :    3029790 :   tree all_prefix_attrs;
    3507                 :    3029790 :   tree decls;
    3508                 :    3029790 :   location_t decl_loc;
    3509                 :    3029790 :   if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
    3510                 :            :     {
    3511                 :      88633 :       int ext;
    3512                 :      88633 :       tree decl;
    3513                 :      88633 :       ext = disable_extension_diagnostics ();
    3514                 :      88633 :       c_parser_consume_token (parser);
    3515                 :      88633 :       decl = c_parser_struct_declaration (parser);
    3516                 :      88633 :       restore_extension_diagnostics (ext);
    3517                 :      88633 :       return decl;
    3518                 :            :     }
    3519                 :    2941150 :   if (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
    3520                 :            :     {
    3521                 :          4 :       c_parser_static_assert_declaration_no_semi (parser);
    3522                 :          4 :       return NULL_TREE;
    3523                 :            :     }
    3524                 :    2941150 :   specs = build_null_declspecs ();
    3525                 :    2941150 :   decl_loc = c_parser_peek_token (parser)->location;
    3526                 :            :   /* Strictly by the standard, we shouldn't allow _Alignas here,
    3527                 :            :      but it appears to have been intended to allow it there, so
    3528                 :            :      we're keeping it as it is until WG14 reaches a conclusion
    3529                 :            :      of N1731.
    3530                 :            :      <http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1731.pdf>  */
    3531                 :    2941150 :   c_parser_declspecs (parser, specs, false, true, true,
    3532                 :            :                       true, false, true, true, cla_nonabstract_decl);
    3533                 :    2941150 :   if (parser->error)
    3534                 :            :     return NULL_TREE;
    3535                 :    2941140 :   if (!specs->declspecs_seen_p)
    3536                 :            :     {
    3537                 :          1 :       c_parser_error (parser, "expected specifier-qualifier-list");
    3538                 :          1 :       return NULL_TREE;
    3539                 :            :     }
    3540                 :    2941140 :   finish_declspecs (specs);
    3541                 :    2941140 :   if (c_parser_next_token_is (parser, CPP_SEMICOLON)
    3542                 :    5848380 :       || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
    3543                 :            :     {
    3544                 :      33896 :       tree ret;
    3545                 :      33896 :       if (specs->typespec_kind == ctsk_none)
    3546                 :            :         {
    3547                 :          3 :           pedwarn (decl_loc, OPT_Wpedantic,
    3548                 :            :                    "ISO C forbids member declarations with no members");
    3549                 :          3 :           shadow_tag_warned (specs, pedantic);
    3550                 :          3 :           ret = NULL_TREE;
    3551                 :            :         }
    3552                 :            :       else
    3553                 :            :         {
    3554                 :            :           /* Support for unnamed structs or unions as members of
    3555                 :            :              structs or unions (which is [a] useful and [b] supports
    3556                 :            :              MS P-SDK).  */
    3557                 :      33893 :           tree attrs = NULL;
    3558                 :            : 
    3559                 :      33893 :           ret = grokfield (c_parser_peek_token (parser)->location,
    3560                 :            :                            build_id_declarator (NULL_TREE), specs,
    3561                 :            :                            NULL_TREE, &attrs);
    3562                 :      33893 :           if (ret)
    3563                 :      33869 :             decl_attributes (&ret, attrs, 0);
    3564                 :            :         }
    3565                 :      33896 :       return ret;
    3566                 :            :     }
    3567                 :            : 
    3568                 :            :   /* Provide better error recovery.  Note that a type name here is valid,
    3569                 :            :      and will be treated as a field name.  */
    3570                 :    2907240 :   if (specs->typespec_kind == ctsk_tagdef
    3571                 :     145344 :       && TREE_CODE (specs->type) != ENUMERAL_TYPE
    3572                 :     145204 :       && c_parser_next_token_starts_declspecs (parser)
    3573                 :    2907250 :       && !c_parser_next_token_is (parser, CPP_NAME))
    3574                 :            :     {
    3575                 :          2 :       c_parser_error (parser, "expected %<;%>, identifier or %<(%>");
    3576                 :          2 :       parser->error = false;
    3577                 :          2 :       return NULL_TREE;
    3578                 :            :     }
    3579                 :            : 
    3580                 :    2907240 :   pending_xref_error ();
    3581                 :    2907240 :   prefix_attrs = specs->attrs;
    3582                 :    2907240 :   all_prefix_attrs = prefix_attrs;
    3583                 :    2907240 :   specs->attrs = NULL_TREE;
    3584                 :    2907240 :   decls = NULL_TREE;
    3585                 :    2944360 :   while (true)
    3586                 :            :     {
    3587                 :            :       /* Declaring one or more declarators or un-named bit-fields.  */
    3588                 :    2944360 :       struct c_declarator *declarator;
    3589                 :    2944360 :       bool dummy = false;
    3590                 :    2944360 :       if (c_parser_next_token_is (parser, CPP_COLON))
    3591                 :       8245 :         declarator = build_id_declarator (NULL_TREE);
    3592                 :            :       else
    3593                 :    2936120 :         declarator = c_parser_declarator (parser,
    3594                 :    2936120 :                                           specs->typespec_kind != ctsk_none,
    3595                 :            :                                           C_DTR_NORMAL, &dummy);
    3596                 :    2944360 :       if (declarator == NULL)
    3597                 :            :         {
    3598                 :          1 :           c_parser_skip_to_end_of_block_or_statement (parser);
    3599                 :          1 :           break;
    3600                 :            :         }
    3601                 :    2944360 :       if (c_parser_next_token_is (parser, CPP_COLON)
    3602                 :    2908060 :           || c_parser_next_token_is (parser, CPP_COMMA)
    3603                 :    2872930 :           || c_parser_next_token_is (parser, CPP_SEMICOLON)
    3604                 :      16391 :           || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
    3605                 :    2960730 :           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
    3606                 :            :         {
    3607                 :    2944360 :           tree postfix_attrs = NULL_TREE;
    3608                 :    2944360 :           tree width = NULL_TREE;
    3609                 :    2944360 :           tree d;
    3610                 :    2944360 :           if (c_parser_next_token_is (parser, CPP_COLON))
    3611                 :            :             {
    3612                 :      36298 :               c_parser_consume_token (parser);
    3613                 :      36298 :               width = c_parser_expr_no_commas (parser, NULL).value;
    3614                 :            :             }
    3615                 :    2944360 :           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
    3616                 :      16543 :             postfix_attrs = c_parser_gnu_attributes (parser);
    3617                 :    2944360 :           d = grokfield (c_parser_peek_token (parser)->location,
    3618                 :            :                          declarator, specs, width, &all_prefix_attrs);
    3619                 :    2944360 :           decl_attributes (&d, chainon (postfix_attrs,
    3620                 :            :                                         all_prefix_attrs), 0);
    3621                 :    2944360 :           DECL_CHAIN (d) = decls;
    3622                 :    2944360 :           decls = d;
    3623                 :    2944360 :           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
    3624                 :          0 :             all_prefix_attrs = chainon (c_parser_gnu_attributes (parser),
    3625                 :            :                                         prefix_attrs);
    3626                 :            :           else
    3627                 :    2944360 :             all_prefix_attrs = prefix_attrs;
    3628                 :    2944360 :           if (c_parser_next_token_is (parser, CPP_COMMA))
    3629                 :      37121 :             c_parser_consume_token (parser);
    3630                 :    2907240 :           else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
    3631                 :    2907270 :                    || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
    3632                 :            :             {
    3633                 :            :               /* Semicolon consumed in caller.  */
    3634                 :            :               break;
    3635                 :            :             }
    3636                 :            :           else
    3637                 :            :             {
    3638                 :          0 :               c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
    3639                 :          0 :               break;
    3640                 :            :             }
    3641                 :            :         }
    3642                 :            :       else
    3643                 :            :         {
    3644                 :          0 :           c_parser_error (parser,
    3645                 :            :                           "expected %<:%>, %<,%>, %<;%>, %<}%> or "
    3646                 :            :                           "%<__attribute__%>");
    3647                 :          0 :           break;
    3648                 :            :         }
    3649                 :            :     }
    3650                 :    2907240 :   return decls;
    3651                 :            : }
    3652                 :            : 
    3653                 :            : /* Parse a typeof specifier (a GNU extension).
    3654                 :            : 
    3655                 :            :    typeof-specifier:
    3656                 :            :      typeof ( expression )
    3657                 :            :      typeof ( type-name )
    3658                 :            : */
    3659                 :            : 
    3660                 :            : static struct c_typespec
    3661                 :     810135 : c_parser_typeof_specifier (c_parser *parser)
    3662                 :            : {
    3663                 :     810135 :   struct c_typespec ret;
    3664                 :     810135 :   ret.kind = ctsk_typeof;
    3665                 :     810135 :   ret.spec = error_mark_node;
    3666                 :     810135 :   ret.expr = NULL_TREE;
    3667                 :     810135 :   ret.expr_const_operands = true;
    3668                 :     810135 :   gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF));
    3669                 :     810135 :   c_parser_consume_token (parser);
    3670                 :     810135 :   c_inhibit_evaluation_warnings++;
    3671                 :     810135 :   in_typeof++;
    3672                 :     810135 :   matching_parens parens;
    3673                 :     810135 :   if (!parens.require_open (parser))
    3674                 :            :     {
    3675                 :          0 :       c_inhibit_evaluation_warnings--;
    3676                 :          0 :       in_typeof--;
    3677                 :          0 :       return ret;
    3678                 :            :     }
    3679                 :     810135 :   if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
    3680                 :            :     {
    3681                 :        580 :       struct c_type_name *type = c_parser_type_name (parser);
    3682                 :        580 :       c_inhibit_evaluation_warnings--;
    3683                 :        580 :       in_typeof--;
    3684                 :        580 :       if (type != NULL)
    3685                 :            :         {
    3686                 :        580 :           ret.spec = groktypename (type, &ret.expr, &ret.expr_const_operands);
    3687                 :        580 :           pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
    3688                 :            :         }
    3689                 :            :     }
    3690                 :            :   else
    3691                 :            :     {
    3692                 :     809555 :       bool was_vm;
    3693                 :     809555 :       location_t here = c_parser_peek_token (parser)->location;
    3694                 :     809555 :       struct c_expr expr = c_parser_expression (parser);
    3695                 :     809555 :       c_inhibit_evaluation_warnings--;
    3696                 :     809555 :       in_typeof--;
    3697                 :     809555 :       if (TREE_CODE (expr.value) == COMPONENT_REF
    3698                 :     809555 :           && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
    3699                 :          1 :         error_at (here, "%<typeof%> applied to a bit-field");
    3700                 :     809555 :       mark_exp_read (expr.value);
    3701                 :     809555 :       ret.spec = TREE_TYPE (expr.value);
    3702                 :     809555 :       was_vm = variably_modified_type_p (ret.spec, NULL_TREE);
    3703                 :            :       /* This is returned with the type so that when the type is
    3704                 :            :          evaluated, this can be evaluated.  */
    3705                 :     809555 :       if (was_vm)
    3706                 :        170 :         ret.expr = c_fully_fold (expr.value, false, &ret.expr_const_operands);
    3707                 :     809555 :       pop_maybe_used (was_vm);
    3708                 :            :       /* For use in macros such as those in <stdatomic.h>, remove all
    3709                 :            :          qualifiers from atomic types.  (const can be an issue for more macros
    3710                 :            :          using typeof than just the <stdatomic.h> ones.)  */
    3711                 :     809555 :       if (ret.spec != error_mark_node && TYPE_ATOMIC (ret.spec))
    3712                 :       1468 :         ret.spec = c_build_qualified_type (ret.spec, TYPE_UNQUALIFIED);
    3713                 :            :     }
    3714                 :     810135 :   parens.skip_until_found_close (parser);
    3715                 :            :   return ret;
    3716                 :            : }
    3717                 :            : 
    3718                 :            : /* Parse an alignment-specifier.
    3719                 :            : 
    3720                 :            :    C11 6.7.5:
    3721                 :            : 
    3722                 :            :    alignment-specifier:
    3723                 :            :      _Alignas ( type-name )
    3724                 :            :      _Alignas ( constant-expression )
    3725                 :            : */
    3726                 :            : 
    3727                 :            : static tree
    3728                 :        167 : c_parser_alignas_specifier (c_parser * parser)
    3729                 :            : {
    3730                 :        167 :   tree ret = error_mark_node;
    3731                 :        167 :   location_t loc = c_parser_peek_token (parser)->location;
    3732                 :        167 :   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNAS));
    3733                 :        167 :   c_parser_consume_token (parser);
    3734                 :        167 :   if (flag_isoc99)
    3735                 :        164 :     pedwarn_c99 (loc, OPT_Wpedantic,
    3736                 :            :                  "ISO C99 does not support %<_Alignas%>");
    3737                 :            :   else
    3738                 :          3 :     pedwarn_c99 (loc, OPT_Wpedantic,
    3739                 :            :                  "ISO C90 does not support %<_Alignas%>");
    3740                 :        167 :   matching_parens parens;
    3741                 :        167 :   if (!parens.require_open (parser))
    3742                 :            :     return ret;
    3743                 :        167 :   if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
    3744                 :            :     {
    3745                 :        110 :       struct c_type_name *type = c_parser_type_name (parser);
    3746                 :        110 :       if (type != NULL)
    3747                 :        109 :         ret = c_sizeof_or_alignof_type (loc, groktypename (type, NULL, NULL),
    3748                 :            :                                         false, true, 1);
    3749                 :            :     }
    3750                 :            :   else
    3751                 :         57 :     ret = c_parser_expr_no_commas (parser, NULL).value;
    3752                 :        167 :   parens.skip_until_found_close (parser);
    3753                 :        167 :   return ret;
    3754                 :            : }
    3755                 :            : 
    3756                 :            : /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
    3757                 :            :    6.5.5, C99 6.7.5, 6.7.6, C11 6.7.6, 6.7.7).  If TYPE_SEEN_P then
    3758                 :            :    a typedef name may be redeclared; otherwise it may not.  KIND
    3759                 :            :    indicates which kind of declarator is wanted.  Returns a valid
    3760                 :            :    declarator except in the case of a syntax error in which case NULL is
    3761                 :            :    returned.  *SEEN_ID is set to true if an identifier being declared is
    3762                 :            :    seen; this is used to diagnose bad forms of abstract array declarators
    3763                 :            :    and to determine whether an identifier list is syntactically permitted.
    3764                 :            : 
    3765                 :            :    declarator:
    3766                 :            :      pointer[opt] direct-declarator
    3767                 :            : 
    3768                 :            :    direct-declarator:
    3769                 :            :      identifier
    3770                 :            :      ( gnu-attributes[opt] declarator )
    3771                 :            :      direct-declarator array-declarator
    3772                 :            :      direct-declarator ( parameter-type-list )
    3773                 :            :      direct-declarator ( identifier-list[opt] )
    3774                 :            : 
    3775                 :            :    pointer:
    3776                 :            :      * type-qualifier-list[opt]
    3777                 :            :      * type-qualifier-list[opt] pointer
    3778                 :            : 
    3779                 :            :    type-qualifier-list:
    3780                 :            :      type-qualifier
    3781                 :            :      gnu-attributes
    3782                 :            :      type-qualifier-list type-qualifier
    3783                 :            :      type-qualifier-list gnu-attributes
    3784                 :            : 
    3785                 :            :    array-declarator:
    3786                 :            :      [ type-qualifier-list[opt] assignment-expression[opt] ]
    3787                 :            :      [ static type-qualifier-list[opt] assignment-expression ]
    3788                 :            :      [ type-qualifier-list static assignment-expression ]
    3789                 :            :      [ type-qualifier-list[opt] * ]
    3790                 :            : 
    3791                 :            :    parameter-type-list:
    3792                 :            :      parameter-list
    3793                 :            :      parameter-list , ...
    3794                 :            : 
    3795                 :            :    parameter-list:
    3796                 :            :      parameter-declaration
    3797                 :            :      parameter-list , parameter-declaration
    3798                 :            : 
    3799                 :            :    parameter-declaration:
    3800                 :            :      declaration-specifiers declarator gnu-attributes[opt]
    3801                 :            :      declaration-specifiers abstract-declarator[opt] gnu-attributes[opt]
    3802                 :            : 
    3803                 :            :    identifier-list:
    3804                 :            :      identifier
    3805                 :            :      identifier-list , identifier
    3806                 :            : 
    3807                 :            :    abstract-declarator:
    3808                 :            :      pointer
    3809                 :            :      pointer[opt] direct-abstract-declarator
    3810                 :            : 
    3811                 :            :    direct-abstract-declarator:
    3812                 :            :      ( gnu-attributes[opt] abstract-declarator )
    3813                 :            :      direct-abstract-declarator[opt] array-declarator
    3814                 :            :      direct-abstract-declarator[opt] ( parameter-type-list[opt] )
    3815                 :            : 
    3816                 :            :    GNU extensions:
    3817                 :            : 
    3818                 :            :    direct-declarator:
    3819                 :            :      direct-declarator ( parameter-forward-declarations
    3820                 :            :                          parameter-type-list[opt] )
    3821                 :            : 
    3822                 :            :    direct-abstract-declarator:
    3823                 :            :      direct-abstract-declarator[opt] ( parameter-forward-declarations
    3824                 :            :                                        parameter-type-list[opt] )
    3825                 :            : 
    3826                 :            :    parameter-forward-declarations:
    3827                 :            :      parameter-list ;
    3828                 :            :      parameter-forward-declarations parameter-list ;
    3829                 :            : 
    3830                 :            :    The uses of gnu-attributes shown above are GNU extensions.
    3831                 :            : 
    3832                 :            :    Some forms of array declarator are not included in C99 in the
    3833                 :            :    syntax for abstract declarators; these are disallowed elsewhere.
    3834                 :            :    This may be a defect (DR#289).
    3835                 :            : 
    3836                 :            :    This function also accepts an omitted abstract declarator as being
    3837                 :            :    an abstract declarator, although not part of the formal syntax.  */
    3838                 :            : 
    3839                 :            : struct c_declarator *
    3840                 :  197546000 : c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
    3841                 :            :                      bool *seen_id)
    3842                 :            : {
    3843                 :            :   /* Parse any initial pointer part.  */
    3844                 :  197546000 :   if (c_parser_next_token_is (parser, CPP_MULT))
    3845                 :            :     {
    3846                 :   12257100 :       struct c_declspecs *quals_attrs = build_null_declspecs ();
    3847                 :   12257100 :       struct c_declarator *inner;
    3848                 :   12257100 :       c_parser_consume_token (parser);
    3849                 :   12257100 :       c_parser_declspecs (parser, quals_attrs, false, false, true,
    3850                 :            :                           false, false, true, false, cla_prefer_id);
    3851                 :   12257100 :       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
    3852                 :   12257100 :       if (inner == NULL)
    3853                 :            :         return NULL;
    3854                 :            :       else
    3855                 :   12257100 :         return make_pointer_declarator (quals_attrs, inner);
    3856                 :            :     }
    3857                 :            :   /* Now we have a direct declarator, direct abstract declarator or
    3858                 :            :      nothing (which counts as a direct abstract declarator here).  */
    3859                 :  185289000 :   return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
    3860                 :            : }
    3861                 :            : 
    3862                 :            : /* Parse a direct declarator or direct abstract declarator; arguments
    3863                 :            :    as c_parser_declarator.  */
    3864                 :            : 
    3865                 :            : static struct c_declarator *
    3866                 :  185289000 : c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
    3867                 :            :                             bool *seen_id)
    3868                 :            : {
    3869                 :            :   /* The direct declarator must start with an identifier (possibly
    3870                 :            :      omitted) or a parenthesized declarator (possibly abstract).  In
    3871                 :            :      an ordinary declarator, initial parentheses must start a
    3872                 :            :      parenthesized declarator.  In an abstract declarator or parameter
    3873                 :            :      declarator, they could start a parenthesized declarator or a
    3874                 :            :      parameter list.  To tell which, the open parenthesis and any
    3875                 :            :      following gnu-attributes must be read.  If a declaration
    3876                 :            :      specifier or standard attributes follow, then it is a parameter
    3877                 :            :      list; if the specifier is a typedef name, there might be an
    3878                 :            :      ambiguity about redeclaring it, which is resolved in the
    3879                 :            :      direction of treating it as a typedef name.  If a close
    3880                 :            :      parenthesis follows, it is also an empty parameter list, as the
    3881                 :            :      syntax does not permit empty abstract declarators.  Otherwise, it
    3882                 :            :      is a parenthesized declarator (in which case the analysis may be
    3883                 :            :      repeated inside it, recursively).
    3884                 :            : 
    3885                 :            :      ??? There is an ambiguity in a parameter declaration "int
    3886                 :            :      (__attribute__((foo)) x)", where x is not a typedef name: it
    3887                 :            :      could be an abstract declarator for a function, or declare x with
    3888                 :            :      parentheses.  The proper resolution of this ambiguity needs
    3889                 :            :      documenting.  At present we follow an accident of the old
    3890                 :            :      parser's implementation, whereby the first parameter must have
    3891                 :            :      some declaration specifiers other than just gnu-attributes.  Thus as
    3892                 :            :      a parameter declaration it is treated as a parenthesized
    3893                 :            :      parameter named x, and as an abstract declarator it is
    3894                 :            :      rejected.
    3895                 :            : 
    3896                 :            :      ??? Also following the old parser, gnu-attributes inside an empty
    3897                 :            :      parameter list are ignored, making it a list not yielding a
    3898                 :            :      prototype, rather than giving an error or making it have one
    3899                 :            :      parameter with implicit type int.
    3900                 :            : 
    3901                 :            :      ??? Also following the old parser, typedef names may be
    3902                 :            :      redeclared in declarators, but not Objective-C class names.  */
    3903                 :            : 
    3904                 :  185289000 :   if (kind != C_DTR_ABSTRACT
    3905                 :  113451000 :       && c_parser_next_token_is (parser, CPP_NAME)
    3906                 :  295092000 :       && ((type_seen_p
    3907                 :  109790000 :            && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
    3908                 :  109718000 :                || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
    3909                 :  109731000 :           || c_parser_peek_token (parser)->id_kind == C_ID_ID))
    3910                 :            :     {
    3911                 :  109803000 :       struct c_declarator *inner
    3912                 :  109803000 :         = build_id_declarator (c_parser_peek_token (parser)->value);
    3913                 :  109803000 :       *seen_id = true;
    3914                 :  109803000 :       inner->id_loc = c_parser_peek_token (parser)->location;
    3915                 :  109803000 :       c_parser_consume_token (parser);
    3916                 :  109803000 :       if (c_parser_nth_token_starts_std_attributes (parser, 1))
    3917                 :         28 :         inner->u.id.attrs = c_parser_std_attribute_specifier_sequence (parser);
    3918                 :  109803000 :       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
    3919                 :            :     }
    3920                 :            : 
    3921                 :   75485500 :   if (kind != C_DTR_NORMAL
    3922                 :   75369200 :       && c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
    3923                 :   75486900 :       && !c_parser_nth_token_starts_std_attributes (parser, 1))
    3924                 :            :     {
    3925                 :       1414 :       struct c_declarator *inner = build_id_declarator (NULL_TREE);
    3926                 :       1414 :       inner->id_loc = c_parser_peek_token (parser)->location;
    3927                 :       1414 :       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
    3928                 :            :     }
    3929                 :            : 
    3930                 :            :   /* Either we are at the end of an abstract declarator, or we have
    3931                 :            :      parentheses.  */
    3932                 :            : 
    3933                 :   75484100 :   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
    3934                 :            :     {
    3935                 :     175973 :       tree attrs;
    3936                 :     175973 :       struct c_declarator *inner;
    3937                 :     175973 :       c_parser_consume_token (parser);
    3938                 :     175973 :       bool have_gnu_attrs = c_parser_next_token_is_keyword (parser,
    3939                 :            :                                                             RID_ATTRIBUTE);
    3940                 :     175973 :       attrs = c_parser_gnu_attributes (parser);
    3941                 :     175973 :       if (kind != C_DTR_NORMAL
    3942                 :     175973 :           && (c_parser_next_token_starts_declspecs (parser)
    3943                 :      59660 :               || (!have_gnu_attrs
    3944                 :      59658 :                   && c_parser_nth_token_starts_std_attributes (parser, 1))
    3945                 :      59660 :               || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
    3946                 :            :         {
    3947                 :         41 :           struct c_arg_info *args
    3948                 :         41 :             = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
    3949                 :            :                                          attrs, have_gnu_attrs);
    3950                 :         41 :           if (args == NULL)
    3951                 :            :             return NULL;
    3952                 :            :           else
    3953                 :            :             {
    3954                 :         41 :               inner = build_id_declarator (NULL_TREE);
    3955                 :         64 :               if (!(args->types
    3956                 :         23 :                     && args->types != error_mark_node
    3957                 :         23 :                     && TREE_CODE (TREE_VALUE (args->types)) == IDENTIFIER_NODE)
    3958                 :         64 :                   && c_parser_nth_token_starts_std_attributes (parser, 1))
    3959                 :            :                 {
    3960                 :          4 :                   tree std_attrs
    3961                 :          4 :                     = c_parser_std_attribute_specifier_sequence (parser);
    3962                 :          4 :                   if (std_attrs)
    3963                 :          2 :                     inner = build_attrs_declarator (std_attrs, inner);
    3964                 :            :                 }
    3965                 :         41 :               inner = build_function_declarator (args, inner);
    3966                 :         41 :               return c_parser_direct_declarator_inner (parser, *seen_id,
    3967                 :         41 :                                                        inner);
    3968                 :            :             }
    3969                 :            :         }
    3970                 :            :       /* A parenthesized declarator.  */
    3971                 :     175932 :       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
    3972                 :     175932 :       if (inner != NULL && attrs != NULL)
    3973                 :         23 :         inner = build_attrs_declarator (attrs, inner);
    3974                 :     175932 :       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    3975                 :            :         {
    3976                 :     175921 :           c_parser_consume_token (parser);
    3977                 :     175921 :           if (inner == NULL)
    3978                 :            :             return NULL;
    3979                 :            :           else
    3980                 :     175921 :             return c_parser_direct_declarator_inner (parser, *seen_id, inner);
    3981                 :            :         }
    3982                 :            :       else
    3983                 :            :         {
    3984                 :         11 :           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    3985                 :            :                                      "expected %<)%>");
    3986                 :         11 :           return NULL;
    3987                 :            :         }
    3988                 :            :     }
    3989                 :            :   else
    3990                 :            :     {
    3991                 :   75308100 :       if (kind == C_DTR_NORMAL)
    3992                 :            :         {
    3993                 :         58 :           c_parser_error (parser, "expected identifier or %<(%>");
    3994                 :         58 :           return NULL;
    3995                 :            :         }
    3996                 :            :       else
    3997                 :   75308100 :         return build_id_declarator (NULL_TREE);
    3998                 :            :     }
    3999                 :            : }
    4000                 :            : 
    4001                 :            : /* Parse part of a direct declarator or direct abstract declarator,
    4002                 :            :    given that some (in INNER) has already been parsed; ID_PRESENT is
    4003                 :            :    true if an identifier is present, false for an abstract
    4004                 :            :    declarator.  */
    4005                 :            : 
    4006                 :            : static struct c_declarator *
    4007                 :  140785000 : c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
    4008                 :            :                                   struct c_declarator *inner)
    4009                 :            : {
    4010                 :            :   /* Parse a sequence of array declarators and parameter lists.  */
    4011                 :  140785000 :   if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
    4012                 :  140785000 :       && !c_parser_nth_token_starts_std_attributes (parser, 1))
    4013                 :            :     {
    4014                 :     755913 :       location_t brace_loc = c_parser_peek_token (parser)->location;
    4015                 :     755913 :       struct c_declarator *declarator;
    4016                 :     755913 :       struct c_declspecs *quals_attrs = build_null_declspecs ();
    4017                 :     755913 :       bool static_seen;
    4018                 :     755913 :       bool star_seen;
    4019                 :     755913 :       struct c_expr dimen;
    4020                 :     755913 :       dimen.value = NULL_TREE;
    4021                 :     755913 :       dimen.original_code = ERROR_MARK;
    4022                 :     755913 :       dimen.original_type = NULL_TREE;
    4023                 :     755913 :       c_parser_consume_token (parser);
    4024                 :     755913 :       c_parser_declspecs (parser, quals_attrs, false, false, true,
    4025                 :            :                           false, false, false, false, cla_prefer_id);
    4026                 :     755913 :       static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
    4027                 :     755913 :       if (static_seen)
    4028                 :         48 :         c_parser_consume_token (parser);
    4029                 :     755913 :       if (static_seen && !quals_attrs->declspecs_seen_p)
    4030                 :         42 :         c_parser_declspecs (parser, quals_attrs, false, false, true,
    4031                 :            :                             false, false, false, false, cla_prefer_id);
    4032                 :     755913 :       if (!quals_attrs->declspecs_seen_p)
    4033                 :     755868 :         quals_attrs = NULL;
    4034                 :            :       /* If "static" is present, there must be an array dimension.
    4035                 :            :          Otherwise, there may be a dimension, "*", or no
    4036                 :            :          dimension.  */
    4037                 :     755913 :       if (static_seen)
    4038                 :            :         {
    4039                 :         48 :           star_seen = false;
    4040                 :         48 :           dimen = c_parser_expr_no_commas (parser, NULL);
    4041                 :            :         }
    4042                 :            :       else
    4043                 :            :         {
    4044                 :     755865 :           if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
    4045                 :            :             {
    4046                 :            :               dimen.value = NULL_TREE;
    4047                 :            :               star_seen = false;
    4048                 :            :             }
    4049                 :     635014 :           else if (c_parser_next_token_is (parser, CPP_MULT))
    4050                 :            :             {
    4051                 :         70 :               if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
    4052                 :            :                 {
    4053                 :         37 :                   dimen.value = NULL_TREE;
    4054                 :         37 :                   star_seen = true;
    4055                 :         37 :                   c_parser_consume_token (parser);
    4056                 :            :                 }
    4057                 :            :               else
    4058                 :            :                 {
    4059                 :         33 :                   star_seen = false;
    4060                 :         33 :                   dimen = c_parser_expr_no_commas (parser, NULL);
    4061                 :            :                 }
    4062                 :            :             }
    4063                 :            :           else
    4064                 :            :             {
    4065                 :     634944 :               star_seen = false;
    4066                 :     634944 :               dimen = c_parser_expr_no_commas (parser, NULL);
    4067                 :            :             }
    4068                 :            :         }
    4069                 :     755913 :       if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
    4070                 :     755899 :         c_parser_consume_token (parser);
    4071                 :            :       else
    4072                 :            :         {
    4073                 :         14 :           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
    4074                 :            :                                      "expected %<]%>");
    4075                 :         14 :           return NULL;
    4076                 :            :         }
    4077                 :     755899 :       if (dimen.value)
    4078                 :     635011 :         dimen = convert_lvalue_to_rvalue (brace_loc, dimen, true, true);
    4079                 :     755899 :       declarator = build_array_declarator (brace_loc, dimen.value, quals_attrs,
    4080                 :            :                                            static_seen, star_seen);
    4081                 :     755899 :       if (declarator == NULL)
    4082                 :            :         return NULL;
    4083                 :     755895 :       if (c_parser_nth_token_starts_std_attributes (parser, 1))
    4084                 :            :         {
    4085                 :         11 :           tree std_attrs
    4086                 :         11 :             = c_parser_std_attribute_specifier_sequence (parser);
    4087                 :         11 :           if (std_attrs)
    4088                 :          5 :             inner = build_attrs_declarator (std_attrs, inner);
    4089                 :            :         }
    4090                 :     755895 :       inner = set_array_declarator_inner (declarator, inner);
    4091                 :     755895 :       return c_parser_direct_declarator_inner (parser, id_present, inner);
    4092                 :            :     }
    4093                 :  140029000 :   else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
    4094                 :            :     {
    4095                 :   30048600 :       tree attrs;
    4096                 :   30048600 :       struct c_arg_info *args;
    4097                 :   30048600 :       c_parser_consume_token (parser);
    4098                 :   30048600 :       bool have_gnu_attrs = c_parser_next_token_is_keyword (parser,
    4099                 :            :                                                             RID_ATTRIBUTE);
    4100                 :   30048600 :       attrs = c_parser_gnu_attributes (parser);
    4101                 :   30048600 :       args = c_parser_parms_declarator (parser, id_present, attrs,
    4102                 :            :                                         have_gnu_attrs);
    4103                 :   30048600 :       if (args == NULL)
    4104                 :            :         return NULL;
    4105                 :            :       else
    4106                 :            :         {
    4107                 :   59350500 :           if (!(args->types
    4108                 :   29302000 :                 && args->types != error_mark_node
    4109                 :   29302000 :                 && TREE_CODE (TREE_VALUE (args->types)) == IDENTIFIER_NODE)
    4110                 :   59341800 :               && c_parser_nth_token_starts_std_attributes (parser, 1))
    4111                 :            :             {
    4112                 :         17 :               tree std_attrs
    4113                 :         17 :                 = c_parser_std_attribute_specifier_sequence (parser);
    4114                 :         17 :               if (std_attrs)
    4115                 :          8 :                 inner = build_attrs_declarator (std_attrs, inner);
    4116                 :            :             }
    4117                 :   30048500 :           inner = build_function_declarator (args, inner);
    4118                 :   30048500 :           return c_parser_direct_declarator_inner (parser, id_present, inner);
    4119                 :            :         }
    4120                 :            :     }
    4121                 :            :   return inner;
    4122                 :            : }
    4123                 :            : 
    4124                 :            : /* Parse a parameter list or identifier list, including the closing
    4125                 :            :    parenthesis but not the opening one.  ATTRS are the gnu-attributes
    4126                 :            :    at the start of the list.  ID_LIST_OK is true if an identifier list
    4127                 :            :    is acceptable; such a list must not have attributes at the start.
    4128                 :            :    HAVE_GNU_ATTRS says whether any gnu-attributes (including empty
    4129                 :            :    attributes) were present (in which case standard attributes cannot
    4130                 :            :    occur).  */
    4131                 :            : 
    4132                 :            : static struct c_arg_info *
    4133                 :   30048700 : c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs,
    4134                 :            :                            bool have_gnu_attrs)
    4135                 :            : {
    4136                 :   30048700 :   push_scope ();
    4137                 :   30048700 :   declare_parm_level ();
    4138                 :            :   /* If the list starts with an identifier, it is an identifier list.
    4139                 :            :      Otherwise, it is either a prototype list or an empty list.  */
    4140                 :   30048700 :   if (id_list_ok
    4141                 :   30048700 :       && !attrs
    4142                 :   30039300 :       && c_parser_next_token_is (parser, CPP_NAME)
    4143                 :   19378100 :       && c_parser_peek_token (parser)->id_kind == C_ID_ID
    4144                 :            :       
    4145                 :            :       /* Look ahead to detect typos in type names.  */
    4146                 :       8704 :       && c_parser_peek_2nd_token (parser)->type != CPP_NAME
    4147                 :       8697 :       && c_parser_peek_2nd_token (parser)->type != CPP_MULT
    4148                 :       8696 :       && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN
    4149                 :       8695 :       && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_SQUARE
    4150                 :   30057400 :       && c_parser_peek_2nd_token (parser)->type != CPP_KEYWORD)
    4151                 :            :     {
    4152                 :       8693 :       tree list = NULL_TREE, *nextp = &list;
    4153                 :      68528 :       while (c_parser_next_token_is (parser, CPP_NAME)
    4154                 :      34264 :              && c_parser_peek_token (parser)->id_kind == C_ID_ID)
    4155                 :            :         {
    4156                 :      34264 :           *nextp = build_tree_list (NULL_TREE,
    4157                 :      34264 :                                     c_parser_peek_token (parser)->value);
    4158                 :      34264 :           nextp = & TREE_CHAIN (*nextp);
    4159                 :      34264 :           c_parser_consume_token (parser);
    4160                 :      34264 :           if (c_parser_next_token_is_not (parser, CPP_COMMA))
    4161                 :            :             break;
    4162                 :      25571 :           c_parser_consume_token (parser);
    4163                 :      25571 :           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    4164                 :            :             {
    4165                 :          0 :               c_parser_error (parser, "expected identifier");
    4166                 :          0 :               break;
    4167                 :            :             }
    4168                 :            :         }
    4169                 :       8693 :       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    4170                 :            :         {
    4171                 :       8693 :           struct c_arg_info *ret = build_arg_info ();
    4172                 :       8693 :           ret->types = list;
    4173                 :       8693 :           c_parser_consume_token (parser);
    4174                 :       8693 :           pop_scope ();
    4175                 :       8693 :           return ret;
    4176                 :            :         }
    4177                 :            :       else
    4178                 :            :         {
    4179                 :          0 :           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    4180                 :            :                                      "expected %<)%>");
    4181                 :          0 :           pop_scope ();
    4182                 :          0 :           return NULL;
    4183                 :            :         }
    4184                 :            :     }
    4185                 :            :   else
    4186                 :            :     {
    4187                 :   30040000 :       struct c_arg_info *ret
    4188                 :   30040000 :         = c_parser_parms_list_declarator (parser, attrs, NULL, have_gnu_attrs);
    4189                 :   30040000 :       pop_scope ();
    4190                 :   30040000 :       return ret;
    4191                 :            :     }
    4192                 :            : }
    4193                 :            : 
    4194                 :            : /* Parse a parameter list (possibly empty), including the closing
    4195                 :            :    parenthesis but not the opening one.  ATTRS are the gnu-attributes
    4196                 :            :    at the start of the list; if HAVE_GNU_ATTRS, there were some such
    4197                 :            :    attributes (possibly empty, in which case ATTRS is NULL_TREE),
    4198                 :            :    which means standard attributes cannot start the list.  EXPR is
    4199                 :            :    NULL or an expression that needs to be evaluated for the side
    4200                 :            :    effects of array size expressions in the parameters.  */
    4201                 :            : 
    4202                 :            : static struct c_arg_info *
    4203                 :   30040000 : c_parser_parms_list_declarator (c_parser *parser, tree attrs, tree expr,
    4204                 :            :                                 bool have_gnu_attrs)
    4205                 :            : {
    4206                 :   30040000 :   bool bad_parm = false;
    4207                 :            : 
    4208                 :            :   /* ??? Following the old parser, forward parameter declarations may
    4209                 :            :      use abstract declarators, and if no real parameter declarations
    4210                 :            :      follow the forward declarations then this is not diagnosed.  Also
    4211                 :            :      note as above that gnu-attributes are ignored as the only contents of
    4212                 :            :      the parentheses, or as the only contents after forward
    4213                 :            :      declarations.  */
    4214                 :   30040000 :   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    4215                 :            :     {
    4216                 :     746529 :       struct c_arg_info *ret = build_arg_info ();
    4217                 :     746529 :       c_parser_consume_token (parser);
    4218                 :     746529 :       return ret;
    4219                 :            :     }
    4220                 :   29293500 :   if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
    4221                 :            :     {
    4222                 :          6 :       struct c_arg_info *ret = build_arg_info ();
    4223                 :            : 
    4224                 :          6 :       if (flag_allow_parameterless_variadic_functions)
    4225                 :            :         {
    4226                 :            :           /* F (...) is allowed.  */
    4227                 :          1 :           ret->types = NULL_TREE;
    4228                 :            :         }
    4229                 :            :       else
    4230                 :            :         {
    4231                 :            :           /* Suppress -Wold-style-definition for this case.  */
    4232                 :          5 :           ret->types = error_mark_node;
    4233                 :          5 :           error_at (c_parser_peek_token (parser)->location,
    4234                 :            :                     "ISO C requires a named argument before %<...%>");
    4235                 :            :         }
    4236                 :          6 :       c_parser_consume_token (parser);
    4237                 :          6 :       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    4238                 :            :         {
    4239                 :          6 :           c_parser_consume_token (parser);
    4240                 :          6 :           return ret;
    4241                 :            :         }
    4242                 :            :       else
    4243                 :            :         {
    4244                 :          0 :           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    4245                 :            :                                      "expected %<)%>");
    4246                 :          0 :           return NULL;
    4247                 :            :         }
    4248                 :            :     }
    4249                 :            :   /* Nonempty list of parameters, either terminated with semicolon
    4250                 :            :      (forward declarations; recurse) or with close parenthesis (normal
    4251                 :            :      function) or with ", ... )" (variadic function).  */
    4252                 :   72312400 :   while (true)
    4253                 :            :     {
    4254                 :            :       /* Parse a parameter.  */
    4255                 :   72312400 :       struct c_parm *parm = c_parser_parameter_declaration (parser, attrs,
    4256                 :            :                                                             have_gnu_attrs);
    4257                 :   72312400 :       attrs = NULL_TREE;
    4258                 :   72312400 :       have_gnu_attrs = false;
    4259                 :   72312400 :       if (parm == NULL)
    4260                 :            :         bad_parm = true;
    4261                 :            :       else
    4262                 :   72312300 :         push_parm_decl (parm, &expr);
    4263                 :   72312400 :       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    4264                 :            :         {
    4265                 :         36 :           tree new_attrs;
    4266                 :         36 :           c_parser_consume_token (parser);
    4267                 :         36 :           mark_forward_parm_decls ();
    4268                 :         36 :           bool new_have_gnu_attrs
    4269                 :         36 :             = c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE);
    4270                 :         36 :           new_attrs = c_parser_gnu_attributes (parser);
    4271                 :         36 :           return c_parser_parms_list_declarator (parser, new_attrs, expr,
    4272                 :         36 :                                                  new_have_gnu_attrs);
    4273                 :            :         }
    4274                 :   72312400 :       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    4275                 :            :         {
    4276                 :   29140300 :           c_parser_consume_token (parser);
    4277                 :   29140300 :           if (bad_parm)
    4278                 :            :             return NULL;
    4279                 :            :           else
    4280                 :   29140300 :             return get_parm_info (false, expr);
    4281                 :            :         }
    4282                 :   43172100 :       if (!c_parser_require (parser, CPP_COMMA,
    4283                 :            :                              "expected %<;%>, %<,%> or %<)%>",
    4284                 :            :                              UNKNOWN_LOCATION, false))
    4285                 :            :         {
    4286                 :          8 :           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
    4287                 :          8 :           return NULL;
    4288                 :            :         }
    4289                 :   43172100 :       if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
    4290                 :            :         {
    4291                 :     153101 :           c_parser_consume_token (parser);
    4292                 :     153101 :           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    4293                 :            :             {
    4294                 :     153094 :               c_parser_consume_token (parser);
    4295                 :     153094 :               if (bad_parm)
    4296                 :            :                 return NULL;
    4297                 :            :               else
    4298                 :     153086 :                 return get_parm_info (true, expr);
    4299                 :            :             }
    4300                 :            :           else
    4301                 :            :             {
    4302                 :          7 :               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    4303                 :            :                                          "expected %<)%>");
    4304                 :          7 :               return NULL;
    4305                 :            :             }
    4306                 :            :         }
    4307                 :            :     }
    4308                 :            : }
    4309                 :            : 
    4310                 :            : /* Parse a parameter declaration.  ATTRS are the gnu-attributes at the
    4311                 :            :    start of the declaration if it is the first parameter;
    4312                 :            :    HAVE_GNU_ATTRS is true if there were any gnu-attributes there (even
    4313                 :            :    empty) there.  */
    4314                 :            : 
    4315                 :            : static struct c_parm *
    4316                 :   72312400 : c_parser_parameter_declaration (c_parser *parser, tree attrs,
    4317                 :            :                                 bool have_gnu_attrs)
    4318                 :            : {
    4319                 :   72312400 :   struct c_declspecs *specs;
    4320                 :   72312400 :   struct c_declarator *declarator;
    4321                 :   72312400 :   tree prefix_attrs;
    4322                 :   72312400 :   tree postfix_attrs = NULL_TREE;
    4323                 :   72312400 :   bool dummy = false;
    4324                 :            : 
    4325                 :            :   /* Accept #pragmas between parameter declarations.  */
    4326                 :   72312400 :   while (c_parser_next_token_is (parser, CPP_PRAGMA))
    4327                 :          2 :     c_parser_pragma (parser, pragma_param, NULL);
    4328                 :            : 
    4329                 :   72312400 :   if (!c_parser_next_token_starts_declspecs (parser)
    4330                 :   72312400 :       && !c_parser_nth_token_starts_std_attributes (parser, 1))
    4331                 :            :     {
    4332                 :         94 :       c_token *token = c_parser_peek_token (parser);
    4333                 :         94 :       if (parser->error)
    4334                 :            :         return NULL;
    4335                 :         94 :       c_parser_set_source_position_from_token (token);
    4336                 :         94 :       if (c_parser_next_tokens_start_typename (parser, cla_prefer_type))
    4337                 :            :         {
    4338                 :         79 :           auto_diagnostic_group d;
    4339                 :         79 :           name_hint hint = lookup_name_fuzzy (token->value,
    4340                 :            :                                               FUZZY_LOOKUP_TYPENAME,
    4341                 :        158 :                                               token->location);
    4342                 :         79 :           if (const char *suggestion = hint.suggestion ())
    4343                 :            :             {
    4344                 :         60 :               gcc_rich_location richloc (token->location);
    4345                 :         30 :               richloc.add_fixit_replace (suggestion);
    4346                 :         30 :               error_at (&richloc,
    4347                 :            :                         "unknown type name %qE; did you mean %qs?",
    4348                 :            :                         token->value, suggestion);
    4349                 :            :             }
    4350                 :            :           else
    4351                 :         49 :             error_at (token->location, "unknown type name %qE", token->value);
    4352                 :         79 :           parser->error = true;
    4353                 :            :         }
    4354                 :            :       /* ??? In some Objective-C cases '...' isn't applicable so there
    4355                 :            :          should be a different message.  */
    4356                 :            :       else
    4357                 :         15 :         c_parser_error (parser,
    4358                 :            :                         "expected declaration specifiers or %<...%>");
    4359                 :         94 :       c_parser_skip_to_end_of_parameter (parser);
    4360                 :         94 :       return NULL;
    4361                 :            :     }
    4362                 :            : 
    4363                 :   72312300 :   location_t start_loc = c_parser_peek_token (parser)->location;
    4364                 :            : 
    4365                 :   72312300 :   specs = build_null_declspecs ();
    4366                 :   72312300 :   if (attrs)
    4367                 :            :     {
    4368                 :        274 :       declspecs_add_attrs (input_location, specs, attrs);
    4369                 :        274 :       attrs = NULL_TREE;
    4370                 :            :     }
    4371                 :   72312300 :   c_parser_declspecs (parser, specs, true, true, true, true, false,
    4372                 :   72312300 :                       !have_gnu_attrs, true, cla_nonabstract_decl);
    4373                 :   72312300 :   finish_declspecs (specs);
    4374                 :   72312300 :   pending_xref_error ();
    4375                 :   72312300 :   prefix_attrs = specs->attrs;
    4376                 :   72312300 :   specs->attrs = NULL_TREE;
    4377                 :  144625000 :   declarator = c_parser_declarator (parser,
    4378                 :   72312300 :                                     specs->typespec_kind != ctsk_none,
    4379                 :            :                                     C_DTR_PARM, &dummy);
    4380                 :   72312300 :   if (declarator == NULL)
    4381                 :            :     {
    4382                 :         11 :       c_parser_skip_until_found (parser, CPP_COMMA, NULL);
    4383                 :         11 :       return NULL;
    4384                 :            :     }
    4385                 :   72312300 :   if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
    4386                 :       8307 :     postfix_attrs = c_parser_gnu_attributes (parser);
    4387                 :            : 
    4388                 :            :   /* Generate a location for the parameter, ranging from the start of the
    4389                 :            :      initial token to the end of the final token.
    4390                 :            : 
    4391                 :            :      If we have a identifier, then use it for the caret location, e.g.
    4392                 :            : 
    4393                 :            :        extern int callee (int one, int (*two)(int, int), float three);
    4394                 :            :                                    ~~~~~~^~~~~~~~~~~~~~
    4395                 :            : 
    4396                 :            :      otherwise, reuse the start location for the caret location e.g.:
    4397                 :            : 
    4398                 :            :        extern int callee (int one, int (*)(int, int), float three);
    4399                 :            :                                    ^~~~~~~~~~~~~~~~~
    4400                 :            :   */
    4401                 :   72312300 :   location_t end_loc = parser->last_token_location;
    4402                 :            : 
    4403                 :            :   /* Find any cdk_id declarator; determine if we have an identifier.  */
    4404                 :   72312300 :   c_declarator *id_declarator = declarator;
    4405                 :   80977900 :   while (id_declarator && id_declarator->kind != cdk_id)
    4406                 :    8665540 :     id_declarator = id_declarator->declarator;
    4407                 :  144625000 :   location_t caret_loc = (id_declarator->u.id.id
    4408                 :   72312300 :                           ? id_declarator->id_loc
    4409                 :            :                           : start_loc);
    4410                 :   72312300 :   location_t param_loc = make_location (caret_loc, start_loc, end_loc);
    4411                 :            : 
    4412                 :   72312300 :   return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
    4413                 :   72312300 :                        declarator, param_loc);
    4414                 :            : }
    4415                 :            : 
    4416                 :            : /* Parse a string literal in an asm expression.  It should not be
    4417                 :            :    translated, and wide string literals are an error although
    4418                 :            :    permitted by the syntax.  This is a GNU extension.
    4419                 :            : 
    4420                 :            :    asm-string-literal:
    4421                 :            :      string-literal
    4422                 :            : */
    4423                 :            : 
    4424                 :            : static tree
    4425                 :    1392570 : c_parser_asm_string_literal (c_parser *parser)
    4426                 :            : {
    4427                 :    1392570 :   tree str;
    4428                 :    1392570 :   int save_flag = warn_overlength_strings;
    4429                 :    1392570 :   warn_overlength_strings = 0;
    4430                 :          0 :   str = c_parser_string_literal (parser, false, false).value;
    4431                 :    1392570 :   warn_overlength_strings = save_flag;
    4432                 :    1392570 :   return str;
    4433                 :            : }
    4434                 :            : 
    4435                 :            : /* Parse a simple asm expression.  This is used in restricted
    4436                 :            :    contexts, where a full expression with inputs and outputs does not
    4437                 :            :    make sense.  This is a GNU extension.
    4438                 :            : 
    4439                 :            :    simple-asm-expr:
    4440                 :            :      asm ( asm-string-literal )
    4441                 :            : */
    4442                 :            : 
    4443                 :            : static tree
    4444                 :     586925 : c_parser_simple_asm_expr (c_parser *parser)
    4445                 :            : {
    4446                 :     586925 :   tree str;
    4447                 :     586925 :   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
    4448                 :     586925 :   c_parser_consume_token (parser);
    4449                 :     586925 :   matching_parens parens;
    4450                 :     586925 :   if (!parens.require_open (parser))
    4451                 :            :     return NULL_TREE;
    4452                 :     586920 :   str = c_parser_asm_string_literal (parser);
    4453                 :     586920 :   if (!parens.require_close (parser))
    4454                 :            :     {
    4455                 :          1 :       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
    4456                 :          1 :       return NULL_TREE;
    4457                 :            :     }
    4458                 :            :   return str;
    4459                 :            : }
    4460                 :            : 
    4461                 :            : static tree
    4462                 :   77849400 : c_parser_gnu_attribute_any_word (c_parser *parser)
    4463                 :            : {
    4464                 :   77849400 :   tree attr_name = NULL_TREE;
    4465                 :            : 
    4466                 :   77849400 :   if (c_parser_next_token_is (parser, CPP_KEYWORD))
    4467                 :            :     {
    4468                 :            :       /* ??? See comment above about what keywords are accepted here.  */
    4469                 :     685540 :       bool ok;
    4470                 :     685540 :       switch (c_parser_peek_token (parser)->keyword)
    4471                 :            :         {
    4472                 :            :         case RID_STATIC:
    4473                 :            :         case RID_UNSIGNED:
    4474                 :            :         case RID_LONG:
    4475                 :            :         case RID_CONST:
    4476                 :            :         case RID_EXTERN:
    4477                 :            :         case RID_REGISTER:
    4478                 :            :         case RID_TYPEDEF:
    4479                 :            :         case RID_SHORT:
    4480                 :            :         case RID_INLINE:
    4481                 :            :         case RID_NORETURN:
    4482                 :            :         case RID_VOLATILE:
    4483                 :            :         case RID_SIGNED:
    4484                 :            :         case RID_AUTO:
    4485                 :            :         case RID_RESTRICT:
    4486                 :            :         case RID_COMPLEX:
    4487                 :            :         case RID_THREAD:
    4488                 :            :         case RID_INT:
    4489                 :            :         case RID_CHAR:
    4490                 :            :         case RID_FLOAT:
    4491                 :            :         case RID_DOUBLE:
    4492                 :            :         case RID_VOID:
    4493                 :            :         case RID_DFLOAT32:
    4494                 :            :         case RID_DFLOAT64:
    4495                 :            :         case RID_DFLOAT128:
    4496                 :            :         CASE_RID_FLOATN_NX:
    4497                 :            :         case RID_BOOL:
    4498                 :            :         case RID_FRACT:
    4499                 :            :         case RID_ACCUM:
    4500                 :            :         case RID_SAT:
    4501                 :            :         case RID_TRANSACTION_ATOMIC:
    4502                 :            :         case RID_TRANSACTION_CANCEL:
    4503                 :            :         case RID_ATOMIC:
    4504                 :            :         case RID_AUTO_TYPE:
    4505                 :            :         case RID_INT_N_0:
    4506                 :            :         case RID_INT_N_1:
    4507                 :            :         case RID_INT_N_2:
    4508                 :            :         case RID_INT_N_3:
    4509                 :            :           ok = true;
    4510                 :            :           break;
    4511                 :            :         default:
    4512                 :   77849400 :           ok = false;
    4513                 :            :           break;
    4514                 :            :         }
    4515                 :     685540 :       if (!ok)
    4516                 :            :         return NULL_TREE;
    4517                 :            : 
    4518                 :            :       /* Accept __attribute__((__const)) as __attribute__((const)) etc.  */
    4519                 :     685540 :       attr_name = ridpointers[(int) c_parser_peek_token (parser)->keyword];
    4520                 :            :     }
    4521                 :   77163800 :   else if (c_parser_next_token_is (parser, CPP_NAME))
    4522                 :   77163800 :     attr_name = c_parser_peek_token (parser)->value;
    4523                 :            : 
    4524                 :            :   return attr_name;
    4525                 :            : }
    4526                 :            : 
    4527                 :            : /* Parse attribute arguments.  This is a common form of syntax
    4528                 :            :    covering all currently valid GNU and standard attributes.
    4529                 :            : 
    4530                 :            :    gnu-attribute-arguments:
    4531                 :            :      identifier
    4532                 :            :      identifier , nonempty-expr-list
    4533                 :            :      expr-list
    4534                 :            : 
    4535                 :            :    where the "identifier" must not be declared as a type.  ??? Why not
    4536                 :            :    allow identifiers declared as types to start the arguments?  */
    4537                 :            : 
    4538                 :            : static tree
    4539                 :    2565780 : c_parser_attribute_arguments (c_parser *parser, bool takes_identifier,
    4540                 :            :                               bool require_string, bool allow_empty_args)
    4541                 :            : {
    4542                 :    2565780 :   vec<tree, va_gc> *expr_list;
    4543                 :    2565780 :   tree attr_args;
    4544                 :            :   /* Parse the attribute contents.  If they start with an
    4545                 :            :      identifier which is followed by a comma or close
    4546                 :            :      parenthesis, then the arguments start with that
    4547                 :            :      identifier; otherwise they are an expression list.
    4548                 :            :      In objective-c the identifier may be a classname.  */
    4549                 :    2565780 :   if (c_parser_next_token_is (parser, CPP_NAME)
    4550                 :     151985 :       && (c_parser_peek_token (parser)->id_kind == C_ID_ID
    4551                 :          0 :           || (c_dialect_objc ()
    4552                 :          0 :               && c_parser_peek_token (parser)->id_kind
    4553                 :            :               == C_ID_CLASSNAME))
    4554                 :     151985 :       && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
    4555                 :      35979 :           || (c_parser_peek_2nd_token (parser)->type
    4556                 :            :               == CPP_CLOSE_PAREN))
    4557                 :    2717740 :       && (takes_identifier
    4558                 :       4106 :           || (c_dialect_objc ()
    4559                 :          0 :               && c_parser_peek_token (parser)->id_kind
    4560                 :            :               == C_ID_CLASSNAME)))
    4561                 :            :     {
    4562                 :     147858 :       tree arg1 = c_parser_peek_token (parser)->value;
    4563                 :     147858 :       c_parser_consume_token (parser);
    4564                 :     147858 :       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    4565                 :      31854 :         attr_args = build_tree_list (NULL_TREE, arg1);
    4566                 :            :       else
    4567                 :            :         {
    4568                 :     116004 :           tree tree_list;
    4569                 :     116004 :           c_parser_consume_token (parser);
    4570                 :     116004 :           expr_list = c_parser_expr_list (parser, false, true,
    4571                 :            :                                           NULL, NULL, NULL, NULL);
    4572                 :     116004 :           tree_list = build_tree_list_vec (expr_list);
    4573                 :     116004 :           attr_args = tree_cons (NULL_TREE, arg1, tree_list);
    4574                 :     116004 :           release_tree_vector (expr_list);
    4575                 :            :         }
    4576                 :            :     }
    4577                 :            :   else
    4578                 :            :     {
    4579                 :    2417920 :       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    4580                 :            :         {
    4581                 :         11 :           if (!allow_empty_args)
    4582                 :          1 :             error_at (c_parser_peek_token (parser)->location,
    4583                 :            :                       "parentheses must be omitted if "
    4584                 :            :                       "attribute argument list is empty");
    4585                 :            :           attr_args = NULL_TREE;
    4586                 :            :         }
    4587                 :    2417910 :       else if (require_string)
    4588                 :            :         {
    4589                 :            :           /* The only valid argument for this attribute is a string
    4590                 :            :              literal.  Handle this specially here to avoid accepting
    4591                 :            :              string literals with excess parentheses.  */
    4592                 :          9 :           tree string = c_parser_string_literal (parser, false, true).value;
    4593                 :          9 :           attr_args = build_tree_list (NULL_TREE, string);
    4594                 :            :         }
    4595                 :            :       else
    4596                 :            :         {
    4597                 :    2417900 :           expr_list = c_parser_expr_list (parser, false, true,
    4598                 :            :                                           NULL, NULL, NULL, NULL);
    4599                 :    2417900 :           attr_args = build_tree_list_vec (expr_list);
    4600                 :    2417900 :           release_tree_vector (expr_list);
    4601                 :            :         }
    4602                 :            :     }
    4603                 :    2565780 :   return attr_args;
    4604                 :            : }
    4605                 :            : 
    4606                 :            : /* Parse (possibly empty) gnu-attributes.  This is a GNU extension.
    4607                 :            : 
    4608                 :            :    gnu-attributes:
    4609                 :            :      empty
    4610                 :            :      gnu-attributes gnu-attribute
    4611                 :            : 
    4612                 :            :    gnu-attribute:
    4613                 :            :      __attribute__ ( ( gnu-attribute-list ) )
    4614                 :            : 
    4615                 :            :    gnu-attribute-list:
    4616                 :            :      gnu-attrib
    4617                 :            :      gnu-attribute_list , gnu-attrib
    4618                 :            : 
    4619                 :            :    gnu-attrib:
    4620                 :            :      empty
    4621                 :            :      any-word
    4622                 :            :      any-word ( gnu-attribute-arguments )
    4623                 :            : 
    4624                 :            :    where "any-word" may be any identifier (including one declared as a
    4625                 :            :    type), a reserved word storage class specifier, type specifier or
    4626                 :            :    type qualifier.  ??? This still leaves out most reserved keywords
    4627                 :            :    (following the old parser), shouldn't we include them?
    4628                 :            :    When EXPECT_COMMA is true, expect the attribute to be preceded
    4629                 :            :    by a comma and fail if it isn't.
    4630                 :            :    When EMPTY_OK is true, allow and consume any number of consecutive
    4631                 :            :    commas with no attributes in between.  */
    4632                 :            : 
    4633                 :            : static tree
    4634                 :  109035000 : c_parser_gnu_attribute (c_parser *parser, tree attrs,
    4635                 :            :                         bool expect_comma = false, bool empty_ok = true)
    4636                 :            : {
    4637                 :  109035000 :   bool comma_first = c_parser_next_token_is (parser, CPP_COMMA);
    4638                 :  109035000 :   if (!comma_first
    4639                 :   62372300 :       && !c_parser_next_token_is (parser, CPP_NAME)
    4640                 :  140906000 :       && !c_parser_next_token_is (parser, CPP_KEYWORD))
    4641                 :            :     return NULL_TREE;
    4642                 :            : 
    4643                 :  124512000 :   while (c_parser_next_token_is (parser, CPP_COMMA))
    4644                 :            :     {
    4645                 :   46662800 :       c_parser_consume_token (parser);
    4646                 :   46662800 :       if (!empty_ok)
    4647                 :            :         return attrs;
    4648                 :            :     }
    4649                 :            : 
    4650                 :   77849400 :   tree attr_name = c_parser_gnu_attribute_any_word (parser);
    4651                 :   77849400 :   if (attr_name == NULL_TREE)
    4652                 :            :     return NULL_TREE;
    4653                 :            : 
    4654                 :   77849400 :   attr_name = canonicalize_attr_name (attr_name);
    4655                 :   77849400 :   c_parser_consume_token (parser);
    4656                 :            : 
    4657                 :   77849400 :   tree attr;
    4658                 :   77849400 :   if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
    4659                 :            :     {
    4660                 :   75283600 :       if (expect_comma && !comma_first)
    4661                 :            :         {
    4662                 :            :           /* A comma is missing between the last attribute on the chain
    4663                 :            :              and this one.  */
    4664                 :          7 :           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    4665                 :            :                                      "expected %<)%>");
    4666                 :          7 :           return error_mark_node;
    4667                 :            :         }
    4668                 :   75283600 :       attr = build_tree_list (attr_name, NULL_TREE);
    4669                 :            :       /* Add this attribute to the list.  */
    4670                 :   75283600 :       attrs = chainon (attrs, attr);
    4671                 :   75283600 :       return attrs;
    4672                 :            :     }
    4673                 :    2565760 :   c_parser_consume_token (parser);
    4674                 :            : 
    4675                 :    2565760 :   tree attr_args
    4676                 :    2565760 :     = c_parser_attribute_arguments (parser,
    4677                 :    2565760 :                                     attribute_takes_identifier_p (attr_name),
    4678                 :            :                                     false, true);
    4679                 :            : 
    4680                 :    2565760 :   attr = build_tree_list (attr_name, attr_args);
    4681                 :    2565760 :   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    4682                 :    2565760 :     c_parser_consume_token (parser);
    4683                 :            :   else
    4684                 :            :     {
    4685                 :          0 :       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    4686                 :            :                                  "expected %<)%>");
    4687                 :          0 :       return error_mark_node;
    4688                 :            :     }
    4689                 :            : 
    4690                 :    2565760 :   if (expect_comma && !comma_first)
    4691                 :            :     {
    4692                 :            :       /* A comma is missing between the last attribute on the chain
    4693                 :            :          and this one.  */
    4694                 :          0 :       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    4695                 :            :                                  "expected %<)%>");
    4696                 :          0 :       return error_mark_node;
    4697                 :            :     }
    4698                 :            : 
    4699                 :            :   /* Add this attribute to the list.  */
    4700                 :    2565760 :   attrs = chainon (attrs, attr);
    4701                 :    2565760 :   return attrs;
    4702                 :            : }
    4703                 :            : 
    4704                 :            : static tree
    4705                 :   65885800 : c_parser_gnu_attributes (c_parser *parser)
    4706                 :            : {
    4707                 :   65885800 :   tree attrs = NULL_TREE;
    4708                 :   97071600 :   while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
    4709                 :            :     {
    4710                 :   31185800 :       bool save_translate_strings_p = parser->translate_strings_p;
    4711                 :   31185800 :       parser->translate_strings_p = false;
    4712                 :            :       /* Consume the `__attribute__' keyword.  */
    4713                 :   31185800 :       c_parser_consume_token (parser);
    4714                 :            :       /* Look for the two `(' tokens.  */
    4715                 :   31185800 :       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    4716                 :            :         {
    4717                 :          0 :           parser->translate_strings_p = save_translate_strings_p;
    4718                 :          0 :           return attrs;
    4719                 :            :         }
    4720                 :   31185800 :       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    4721                 :            :         {
    4722                 :          0 :           parser->translate_strings_p = save_translate_strings_p;
    4723                 :          0 :           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
    4724                 :          0 :           return attrs;
    4725                 :            :         }
    4726                 :            :       /* Parse the attribute list.  Require a comma between successive
    4727                 :            :          (possibly empty) attributes.  */
    4728                 :            :       for (bool expect_comma = false; ; expect_comma = true)
    4729                 :            :         {
    4730                 :            :           /* Parse a single attribute.  */
    4731                 :  109034000 :           tree attr = c_parser_gnu_attribute (parser, attrs, expect_comma);
    4732                 :  109034000 :           if (attr == error_mark_node)
    4733                 :          7 :             return attrs;
    4734                 :  109034000 :           if (!attr)
    4735                 :            :             break;
    4736                 :            :           attrs = attr;
    4737                 :            :       }
    4738                 :            : 
    4739                 :            :       /* Look for the two `)' tokens.  */
    4740                 :   31185800 :       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    4741                 :   31185800 :         c_parser_consume_token (parser);
    4742                 :            :       else
    4743                 :            :         {
    4744                 :          0 :           parser->translate_strings_p = save_translate_strings_p;
    4745                 :          0 :           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    4746                 :            :                                      "expected %<)%>");
    4747                 :          0 :           return attrs;
    4748                 :            :         }
    4749                 :   31185800 :       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    4750                 :   31185800 :         c_parser_consume_token (parser);
    4751                 :            :       else
    4752                 :            :         {
    4753                 :          1 :           parser->translate_strings_p = save_translate_strings_p;
    4754                 :          1 :           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    4755                 :            :                                      "expected %<)%>");
    4756                 :          1 :           return attrs;
    4757                 :            :         }
    4758                 :   31185800 :       parser->translate_strings_p = save_translate_strings_p;
    4759                 :            :     }
    4760                 :            : 
    4761                 :            :   return attrs;
    4762                 :            : }
    4763                 :            : 
    4764                 :            : /* Parse an optional balanced token sequence.
    4765                 :            : 
    4766                 :            :    balanced-token-sequence:
    4767                 :            :      balanced-token
    4768                 :            :      balanced-token-sequence balanced-token
    4769                 :            : 
    4770                 :            :    balanced-token:
    4771                 :            :      ( balanced-token-sequence[opt] )
    4772                 :            :      [ balanced-token-sequence[opt] ]
    4773                 :            :      { balanced-token-sequence[opt] }
    4774                 :            :      any token other than ()[]{}
    4775                 :            : */
    4776                 :            : 
    4777                 :            : static void
    4778                 :        105 : c_parser_balanced_token_sequence (c_parser *parser)
    4779                 :            : {
    4780                 :        435 :   while (true)
    4781                 :            :     {
    4782                 :        435 :       c_token *token = c_parser_peek_token (parser);
    4783                 :        435 :       switch (token->type)
    4784                 :            :         {
    4785                 :          3 :         case CPP_OPEN_BRACE:
    4786                 :          3 :           {
    4787                 :          3 :             matching_braces braces;
    4788                 :          3 :             braces.consume_open (parser);
    4789                 :          3 :             c_parser_balanced_token_sequence (parser);
    4790                 :          3 :             braces.require_close (parser);
    4791                 :          3 :             break;
    4792                 :            :           }
    4793                 :            : 
    4794                 :         33 :         case CPP_OPEN_PAREN:
    4795                 :         33 :           {
    4796                 :         33 :             matching_parens parens;
    4797                 :         33 :             parens.consume_open (parser);
    4798                 :         33 :             c_parser_balanced_token_sequence (parser);
    4799                 :         33 :             parens.require_close (parser);
    4800                 :         33 :             break;
    4801                 :            :           }
    4802                 :            : 
    4803                 :         33 :         case CPP_OPEN_SQUARE:
    4804                 :         33 :           c_parser_consume_token (parser);
    4805                 :         33 :           c_parser_balanced_token_sequence (parser);
    4806                 :         33 :           c_parser_require (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
    4807                 :         33 :           break;
    4808                 :            : 
    4809                 :        105 :         case CPP_CLOSE_BRACE:
    4810                 :        105 :         case CPP_CLOSE_PAREN:
    4811                 :        105 :         case CPP_CLOSE_SQUARE:
    4812                 :        105 :         case CPP_EOF:
    4813                 :        105 :           return;
    4814                 :            : 
    4815                 :        261 :         default:
    4816                 :        261 :           c_parser_consume_token (parser);
    4817                 :        261 :           break;
    4818                 :            :         }
    4819                 :            :     }
    4820                 :            : }
    4821                 :            : 
    4822                 :            : /* Parse standard (C2X) attributes (including GNU attributes in the
    4823                 :            :    gnu:: namespace).
    4824                 :            : 
    4825                 :            :    attribute-specifier-sequence:
    4826                 :            :      attribute-specifier-sequence[opt] attribute-specifier
    4827                 :            : 
    4828                 :            :    attribute-specifier:
    4829                 :            :      [ [ attribute-list ] ]
    4830                 :            : 
    4831                 :            :    attribute-list:
    4832                 :            :      attribute[opt]
    4833                 :            :      attribute-list, attribute[opt]
    4834                 :            : 
    4835                 :            :    attribute:
    4836                 :            :      attribute-token attribute-argument-clause[opt]
    4837                 :            : 
    4838                 :            :    attribute-token:
    4839                 :            :      standard-attribute
    4840                 :            :      attribute-prefixed-token
    4841                 :            : 
    4842                 :            :    standard-attribute:
    4843                 :            :      identifier
    4844                 :            : 
    4845                 :            :    attribute-prefixed-token:
    4846                 :            :      attribute-prefix :: identifier
    4847                 :            : 
    4848                 :            :    attribute-prefix:
    4849                 :            :      identifier
    4850                 :            : 
    4851                 :            :    attribute-argument-clause:
    4852                 :            :      ( balanced-token-sequence[opt] )
    4853                 :            : 
    4854                 :            :    Keywords are accepted as identifiers for this purpose.
    4855                 :            : */
    4856                 :            : 
    4857                 :            : static tree
    4858                 :        213 : c_parser_std_attribute (c_parser *parser, bool for_tm)
    4859                 :            : {
    4860                 :        213 :   c_token *token = c_parser_peek_token (parser);
    4861                 :        213 :   tree ns, name, attribute;
    4862                 :            : 
    4863                 :            :   /* Parse the attribute-token.  */
    4864                 :        213 :   if (token->type != CPP_NAME && token->type != CPP_KEYWORD)
    4865                 :            :     {
    4866                 :          1 :       c_parser_error (parser, "expected identifier");
    4867                 :          1 :       return error_mark_node;
    4868                 :            :     }
    4869                 :        212 :   name = canonicalize_attr_name (token->value);
    4870                 :        212 :   c_parser_consume_token (parser);
    4871                 :        212 :   if (c_parser_next_token_is (parser, CPP_SCOPE))
    4872                 :            :     {
    4873                 :         57 :       ns = name;
    4874                 :         57 :       c_parser_consume_token (parser);
    4875                 :         57 :       token = c_parser_peek_token (parser);
    4876                 :         57 :       if (token->type != CPP_NAME && token->type != CPP_KEYWORD)
    4877                 :            :         {
    4878                 :          0 :           c_parser_error (parser, "expected identifier");
    4879                 :          0 :           return error_mark_node;
    4880                 :            :         }
    4881                 :         57 :       name = canonicalize_attr_name (token->value);
    4882                 :         57 :       c_parser_consume_token (parser);
    4883                 :            :     }
    4884                 :            :   else
    4885                 :            :     ns = NULL_TREE;
    4886                 :        212 :   attribute = build_tree_list (build_tree_list (ns, name), NULL_TREE);
    4887                 :            : 
    4888                 :            :   /* Parse the arguments, if any.  */
    4889                 :        212 :   const attribute_spec *as = lookup_attribute_spec (TREE_PURPOSE (attribute));
    4890                 :        212 :   if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
    4891                 :        153 :     goto out;
    4892                 :         59 :   {
    4893                 :         59 :     location_t open_loc = c_parser_peek_token (parser)->location;
    4894                 :         59 :     matching_parens parens;
    4895                 :         59 :     parens.consume_open (parser);
    4896                 :         22 :     if ((as && as->max_length == 0)
    4897                 :            :         /* Special-case the transactional-memory attribute "outer",
    4898                 :            :            which is specially handled but not registered as an
    4899                 :            :            attribute, to avoid allowing arbitrary balanced token
    4900                 :            :            sequences as arguments.  */
    4901                 :         75 :         || is_attribute_p ("outer", name))
    4902                 :            :       {
    4903                 :          7 :         error_at (open_loc, "%qE attribute does not take any arguments", name);
    4904                 :          7 :         parens.skip_until_found_close (parser);
    4905                 :          7 :         return error_mark_node;
    4906                 :            :       }
    4907                 :         52 :     if (as)
    4908                 :            :       {
    4909                 :         16 :         bool takes_identifier
    4910                 :            :           = (ns != NULL_TREE
    4911                 :          6 :              && strcmp (IDENTIFIER_POINTER (ns), "gnu") == 0
    4912                 :         22 :              && attribute_takes_identifier_p (name));
    4913                 :         16 :         bool require_string
    4914                 :            :           = (ns == NULL_TREE
    4915                 :         26 :              && strcmp (IDENTIFIER_POINTER (name), "deprecated") == 0);
    4916                 :         32 :         TREE_VALUE (attribute)
    4917                 :         16 :           = c_parser_attribute_arguments (parser, takes_identifier,
    4918                 :            :                                           require_string, false);
    4919                 :            :       }
    4920                 :            :     else
    4921                 :         36 :       c_parser_balanced_token_sequence (parser);
    4922                 :         52 :     parens.require_close (parser);
    4923                 :            :   }
    4924                 :        205 :  out:
    4925                 :        205 :   if (ns == NULL_TREE && !for_tm && !as && !is_attribute_p ("nodiscard", name))
    4926                 :            :     {
    4927                 :            :       /* An attribute with standard syntax and no namespace specified
    4928                 :            :          is a constraint violation if it is not one of the known
    4929                 :            :          standard attributes (of which nodiscard is the only one
    4930                 :            :          without a handler in GCC).  Diagnose it here with a pedwarn
    4931                 :            :          and then discard it to prevent a duplicate warning later.  */
    4932                 :         34 :       pedwarn (input_location, OPT_Wattributes, "%qE attribute ignored",
    4933                 :            :                name);
    4934                 :         34 :       return error_mark_node;
    4935                 :            :     }
    4936                 :            :   return attribute;
    4937                 :            : }
    4938                 :            : 
    4939                 :            : static tree
    4940                 :        298 : c_parser_std_attribute_specifier (c_parser *parser, bool for_tm)
    4941                 :            : {
    4942                 :        298 :   bool seen_deprecated = false;
    4943                 :        298 :   bool seen_fallthrough = false;
    4944                 :        298 :   bool seen_maybe_unused = false;
    4945                 :        298 :   location_t loc = c_parser_peek_token (parser)->location;
    4946                 :        298 :   if (!c_parser_require (parser, CPP_OPEN_SQUARE, "expected %<[%>"))
    4947                 :            :     return NULL_TREE;
    4948                 :        298 :   if (!c_parser_require (parser, CPP_OPEN_SQUARE, "expected %<[%>"))
    4949                 :            :     {
    4950                 :          0 :       c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
    4951                 :          0 :       return NULL_TREE;
    4952                 :            :     }
    4953                 :        298 :   if (!for_tm)
    4954                 :        278 :     pedwarn_c11 (loc, OPT_Wpedantic,
    4955                 :            :                  "ISO C does not support %<[[]]%> attributes before C2X");
    4956                 :            :   tree attributes = NULL_TREE;
    4957                 :        330 :   while (true)
    4958                 :            :     {
    4959                 :        330 :       c_token *token = c_parser_peek_token (parser);
    4960                 :        330 :       if (token->type == CPP_CLOSE_SQUARE)
    4961                 :            :         break;
    4962                 :        231 :       if (token->type == CPP_COMMA)
    4963                 :            :         {
    4964                 :         18 :           c_parser_consume_token (parser);
    4965                 :         18 :           continue;
    4966                 :            :         }
    4967                 :        213 :       tree attribute = c_parser_std_attribute (parser, for_tm);
    4968                 :        213 :       if (attribute != error_mark_node)
    4969                 :            :         {
    4970                 :        171 :           bool duplicate = false;
    4971                 :        171 :           tree name = get_attribute_name (attribute);
    4972                 :        171 :           tree ns = get_attribute_namespace (attribute);
    4973                 :        171 :           if (ns == NULL_TREE)
    4974                 :            :             {
    4975                 :            :               /* Some standard attributes may appear at most once in
    4976                 :            :                  each attribute list.  Diagnose duplicates and remove
    4977                 :            :                  them from the list to avoid subsequent diagnostics
    4978                 :            :                  such as the more general one for multiple
    4979                 :            :                  "fallthrough" attributes in the same place (including
    4980                 :            :                  in separate attribute lists in the same attribute
    4981                 :            :                  specifier sequence, which is not a constraint
    4982                 :            :                  violation).  */
    4983                 :        114 :               if (is_attribute_p ("deprecated", name))
    4984                 :            :                 {
    4985                 :         37 :                   if (seen_deprecated)
    4986                 :            :                     {
    4987                 :          4 :                       error ("attribute %<deprecated%> can appear at most "
    4988                 :            :                              "once in an attribute-list");
    4989                 :          4 :                       duplicate = true;
    4990                 :            :                     }
    4991                 :            :                   seen_deprecated = true;
    4992                 :            :                 }
    4993                 :         77 :               else if (is_attribute_p ("fallthrough", name))
    4994                 :            :                 {
    4995                 :         22 :                   if (seen_fallthrough)
    4996                 :            :                     {
    4997                 :          1 :                       error ("attribute %<fallthrough%> can appear at most "
    4998                 :            :                              "once in an attribute-list");
    4999                 :          1 :                       duplicate = true;
    5000                 :            :                     }
    5001                 :            :                   seen_fallthrough = true;
    5002                 :            :                 }
    5003                 :         55 :               else if (is_attribute_p ("maybe_unused", name))
    5004                 :            :                 {
    5005                 :         36 :                   if (seen_maybe_unused)
    5006                 :            :                     {
    5007                 :          4 :                       error ("attribute %<maybe_unused%> can appear at most "
    5008                 :            :                              "once in an attribute-list");
    5009                 :          4 :                       duplicate = true;
    5010                 :            :                     }
    5011                 :            :                   seen_maybe_unused = true;
    5012                 :            :                 }
    5013                 :            :             }
    5014                 :        171 :           if (!duplicate)
    5015                 :            :             {
    5016                 :        162 :               TREE_CHAIN (attribute) = attributes;
    5017                 :        162 :               attributes = attribute;
    5018                 :            :             }
    5019                 :            :         }
    5020                 :        213 :       if (c_parser_next_token_is_not (parser, CPP_COMMA))
    5021                 :            :         break;
    5022                 :            :     }
    5023                 :        298 :   c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
    5024                 :        298 :   c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
    5025                 :        298 :   return nreverse (attributes);
    5026                 :            : }
    5027                 :            : 
    5028                 :            : /* Look past an optional balanced token sequence of raw look-ahead
    5029                 :            :    tokens starting with the *Nth token.  *N is updated to point to the
    5030                 :            :    following token.  Return true if such a sequence was found, false
    5031                 :            :    if the tokens parsed were not balanced.  */
    5032                 :            : 
    5033                 :            : static bool
    5034                 :          0 : c_parser_check_balanced_raw_token_sequence (c_parser *parser, unsigned int *n)
    5035                 :            : {
    5036                 :          0 :   while (true)
    5037                 :            :     {
    5038                 :          0 :       c_token *token = c_parser_peek_nth_token_raw (parser, *n);
    5039                 :          0 :       switch (token->type)
    5040                 :            :         {
    5041                 :          0 :         case CPP_OPEN_BRACE:
    5042                 :          0 :           {
    5043                 :          0 :             ++*n;
    5044                 :          0 :             if (c_parser_check_balanced_raw_token_sequence (parser, n))
    5045                 :            :               {
    5046                 :          0 :                 token = c_parser_peek_nth_token_raw (parser, *n);
    5047                 :          0 :                 if (token->type == CPP_CLOSE_BRACE)
    5048                 :          0 :                   ++*n;
    5049                 :            :                 else
    5050                 :            :                   return false;
    5051                 :            :               }
    5052                 :            :             else
    5053                 :            :               return false;
    5054                 :            :             break;
    5055                 :            :           }
    5056                 :            : 
    5057                 :          0 :         case CPP_OPEN_PAREN:
    5058                 :          0 :           {
    5059                 :          0 :             ++*n;
    5060                 :          0 :             if (c_parser_check_balanced_raw_token_sequence (parser, n))
    5061                 :            :               {
    5062                 :          0 :                 token = c_parser_peek_nth_token_raw (parser, *n);
    5063                 :          0 :                 if (token->type == CPP_CLOSE_PAREN)
    5064                 :          0 :                   ++*n;
    5065                 :            :                 else
    5066                 :            :                   return false;
    5067                 :            :               }
    5068                 :            :             else
    5069                 :            :               return false;
    5070                 :            :             break;
    5071                 :            :           }
    5072                 :            : 
    5073                 :          0 :         case CPP_OPEN_SQUARE:
    5074                 :          0 :           {
    5075                 :          0 :             ++*n;
    5076                 :          0 :             if (c_parser_check_balanced_raw_token_sequence (parser, n))
    5077                 :            :               {
    5078                 :          0 :                 token = c_parser_peek_nth_token_raw (parser, *n);
    5079                 :          0 :                 if (token->type == CPP_CLOSE_SQUARE)
    5080                 :          0 :                   ++*n;
    5081                 :            :                 else
    5082                 :            :                   return false;
    5083                 :            :               }
    5084                 :            :             else
    5085                 :            :               return false;
    5086                 :            :             break;
    5087                 :            :           }
    5088                 :            : 
    5089                 :            :         case CPP_CLOSE_BRACE:
    5090                 :            :         case CPP_CLOSE_PAREN:
    5091                 :            :         case CPP_CLOSE_SQUARE:
    5092                 :            :         case CPP_EOF:
    5093                 :            :           return true;
    5094                 :            : 
    5095                 :          0 :         default:
    5096                 :          0 :           ++*n;
    5097                 :          0 :           break;
    5098                 :            :         }
    5099                 :            :     }
    5100                 :            : }
    5101                 :            : 
    5102                 :            : /* Return whether standard attributes start with the Nth token.  */
    5103                 :            : 
    5104                 :            : static bool
    5105                 :  527289000 : c_parser_nth_token_starts_std_attributes (c_parser *parser, unsigned int n)
    5106                 :            : {
    5107                 :  527289000 :   if (!(c_parser_peek_nth_token (parser, n)->type == CPP_OPEN_SQUARE
    5108                 :    1507100 :         && c_parser_peek_nth_token (parser, n + 1)->type == CPP_OPEN_SQUARE))
    5109                 :  527288000 :     return false;
    5110                 :            :   /* In C, '[[' must start attributes.  In Objective-C, we need to
    5111                 :            :      check whether '[[' is matched by ']]'.  */
    5112                 :        337 :   if (!c_dialect_objc ())
    5113                 :            :     return true;
    5114                 :          0 :   n += 2;
    5115                 :          0 :   if (!c_parser_check_balanced_raw_token_sequence (parser, &n))
    5116                 :            :     return false;
    5117                 :          0 :   c_token *token = c_parser_peek_nth_token_raw (parser, n);
    5118                 :          0 :   if (token->type != CPP_CLOSE_SQUARE)
    5119                 :            :     return false;
    5120                 :          0 :   token = c_parser_peek_nth_token_raw (parser, n + 1);
    5121                 :          0 :   return token->type == CPP_CLOSE_SQUARE;
    5122                 :            : }
    5123                 :            : 
    5124                 :            : static tree
    5125                 :        266 : c_parser_std_attribute_specifier_sequence (c_parser *parser)
    5126                 :            : {
    5127                 :        266 :   tree attributes = NULL_TREE;
    5128                 :        278 :   do
    5129                 :            :     {
    5130                 :        278 :       tree attrs = c_parser_std_attribute_specifier (parser, false);
    5131                 :        278 :       attributes = chainon (attributes, attrs);
    5132                 :            :     }
    5133                 :        278 :   while (c_parser_nth_token_starts_std_attributes (parser, 1));
    5134                 :        266 :   return attributes;
    5135                 :            : }
    5136                 :            : 
    5137                 :            : /* Parse a type name (C90 6.5.5, C99 6.7.6, C11 6.7.7).  ALIGNAS_OK
    5138                 :            :    says whether alignment specifiers are OK (only in cases that might
    5139                 :            :    be the type name of a compound literal).
    5140                 :            : 
    5141                 :            :    type-name:
    5142                 :            :      specifier-qualifier-list abstract-declarator[opt]
    5143                 :            : */
    5144                 :            : 
    5145                 :            : struct c_type_name *
    5146                 :   71834100 : c_parser_type_name (c_parser *parser, bool alignas_ok)
    5147                 :            : {
    5148                 :   71834100 :   struct c_declspecs *specs = build_null_declspecs ();
    5149                 :   71834100 :   struct c_declarator *declarator;
    5150                 :   71834100 :   struct c_type_name *ret;
    5151                 :   71834100 :   bool dummy = false;
    5152                 :   71834100 :   c_parser_declspecs (parser, specs, false, true, true, alignas_ok, false,
    5153                 :            :                       false, true, cla_prefer_type);
    5154                 :   71834100 :   if (!specs->declspecs_seen_p)
    5155                 :            :     {
    5156                 :          4 :       c_parser_error (parser, "expected specifier-qualifier-list");
    5157                 :          4 :       return NULL;
    5158                 :            :     }
    5159                 :   71834100 :   if (specs->type != error_mark_node)
    5160                 :            :     {
    5161                 :   71834100 :       pending_xref_error ();
    5162                 :   71834100 :       finish_declspecs (specs);
    5163                 :            :     }
    5164                 :  143668000 :   declarator = c_parser_declarator (parser,
    5165                 :   71834100 :                                     specs->typespec_kind != ctsk_none,
    5166                 :            :                                     C_DTR_ABSTRACT, &dummy);
    5167                 :   71834100 :   if (declarator == NULL)
    5168                 :            :     return NULL;
    5169                 :   71834100 :   ret = XOBNEW (&parser_obstack, struct c_type_name);
    5170                 :   71834100 :   ret->specs = specs;
    5171                 :   71834100 :   ret->declarator = declarator;
    5172                 :   71834100 :   return ret;
    5173                 :            : }
    5174                 :            : 
    5175                 :            : /* Parse an initializer (C90 6.5.7, C99 6.7.8, C11 6.7.9).
    5176                 :            : 
    5177                 :            :    initializer:
    5178                 :            :      assignment-expression
    5179                 :            :      { initializer-list }
    5180                 :            :      { initializer-list , }
    5181                 :            : 
    5182                 :            :    initializer-list:
    5183                 :            :      designation[opt] initializer
    5184                 :            :      initializer-list , designation[opt] initializer
    5185                 :            : 
    5186                 :            :    designation:
    5187                 :            :      designator-list =
    5188                 :            : 
    5189                 :            :    designator-list:
    5190                 :            :      designator
    5191                 :            :      designator-list designator
    5192                 :            : 
    5193                 :            :    designator:
    5194                 :            :      array-designator
    5195                 :            :      . identifier
    5196                 :            : 
    5197                 :            :    array-designator:
    5198                 :            :      [ constant-expression ]
    5199                 :            : 
    5200                 :            :    GNU extensions:
    5201                 :            : 
    5202                 :            :    initializer:
    5203                 :            :      { }
    5204                 :            : 
    5205                 :            :    designation:
    5206                 :            :      array-designator
    5207                 :            :      identifier :
    5208                 :            : 
    5209                 :            :    array-designator:
    5210                 :            :      [ constant-expression ... constant-expression ]
    5211                 :            : 
    5212                 :            :    Any expression without commas is accepted in the syntax for the
    5213                 :            :    constant-expressions, with non-constant expressions rejected later.
    5214                 :            : 
    5215                 :            :    This function is only used for top-level initializers; for nested
    5216                 :            :    ones, see c_parser_initval.  */
    5217                 :            : 
    5218                 :            : static struct c_expr
    5219                 :    2089590 : c_parser_initializer (c_parser *parser)
    5220                 :            : {
    5221                 :    2089590 :   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
    5222                 :      19533 :     return c_parser_braced_init (parser, NULL_TREE, false, NULL);
    5223                 :            :   else
    5224                 :            :     {
    5225                 :    2070060 :       struct c_expr ret;
    5226                 :    2070060 :       location_t loc = c_parser_peek_token (parser)->location;
    5227                 :    2070060 :       ret = c_parser_expr_no_commas (parser, NULL);
    5228                 :    2070050 :       if (TREE_CODE (ret.value) != STRING_CST
    5229                 :    2060590 :           && TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR)
    5230                 :    1987900 :         ret = convert_lvalue_to_rvalue (loc, ret, true, true);
    5231                 :    2070050 :       return ret;
    5232                 :            :     }
    5233                 :            : }
    5234                 :            : 
    5235                 :            : /* The location of the last comma within the current initializer list,
    5236                 :            :    or UNKNOWN_LOCATION if not within one.  */
    5237                 :            : 
    5238                 :            : location_t last_init_list_comma;
    5239                 :            : 
    5240                 :            : /* Parse a braced initializer list.  TYPE is the type specified for a
    5241                 :            :    compound literal, and NULL_TREE for other initializers and for
    5242                 :            :    nested braced lists.  NESTED_P is true for nested braced lists,
    5243                 :            :    false for the list of a compound literal or the list that is the
    5244                 :            :    top-level initializer in a declaration.  */
    5245                 :            : 
    5246                 :            : static struct c_expr
    5247                 :     814590 : c_parser_braced_init (c_parser *parser, tree type, bool nested_p,
    5248                 :            :                       struct obstack *outer_obstack)
    5249                 :            : {
    5250                 :     814590 :   struct c_expr ret;
    5251                 :     814590 :   struct obstack braced_init_obstack;
    5252                 :     814590 :   location_t brace_loc = c_parser_peek_token (parser)->location;
    5253                 :     814590 :   gcc_obstack_init (&braced_init_obstack);
    5254                 :     814590 :   gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
    5255                 :     814590 :   matching_braces braces;
    5256                 :     814590 :   braces.consume_open (parser);
    5257                 :     814590 :   if (nested_p)
    5258                 :            :     {
    5259                 :     312433 :       finish_implicit_inits (brace_loc, outer_obstack);
    5260                 :     312433 :       push_init_level (brace_loc, 0, &braced_init_obstack);
    5261                 :            :     }
    5262                 :            :   else
    5263                 :     502157 :     really_start_incremental_init (type);
    5264                 :     814590 :   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
    5265                 :            :     {
    5266                 :       1369 :       pedwarn (brace_loc, OPT_Wpedantic, "ISO C forbids empty initializer braces");
    5267                 :            :     }
    5268                 :            :   else
    5269                 :            :     {
    5270                 :            :       /* Parse a non-empty initializer list, possibly with a trailing
    5271                 :            :          comma.  */
    5272                 :    5136020 :       while (true)
    5273                 :            :         {
    5274                 :    5136020 :           c_parser_initelt (parser, &braced_init_obstack);
    5275                 :    5136020 :           if (parser->error)
    5276                 :            :             break;
    5277                 :    5135990 :           if (c_parser_next_token_is (parser, CPP_COMMA))
    5278                 :            :             {
    5279                 :    4332110 :               last_init_list_comma = c_parser_peek_token (parser)->location;
    5280                 :    4332110 :               c_parser_consume_token (parser);
    5281                 :            :             }
    5282                 :            :           else
    5283                 :            :             break;
    5284                 :    4332110 :           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
    5285                 :            :             break;
    5286                 :            :         }
    5287                 :            :     }
    5288                 :     814590 :   c_token *next_tok = c_parser_peek_token (parser);
    5289                 :     814590 :   if (next_tok->type != CPP_CLOSE_BRACE)
    5290                 :            :     {
    5291                 :         31 :       ret.set_error ();
    5292                 :         31 :       ret.original_code = ERROR_MARK;
    5293                 :         31 :       ret.original_type = NULL;
    5294                 :         31 :       braces.skip_until_found_close (parser);
    5295                 :         31 :       pop_init_level (brace_loc, 0, &braced_init_obstack, last_init_list_comma);
    5296                 :         31 :       obstack_free (&braced_init_obstack, NULL);
    5297                 :            :       return ret;
    5298                 :            :     }
    5299                 :     814559 :   location_t close_loc = next_tok->location;
    5300                 :     814559 :   c_parser_consume_token (parser);
    5301                 :     814559 :   ret = pop_init_level (brace_loc, 0, &braced_init_obstack, close_loc);
    5302                 :     814559 :   obstack_free (&braced_init_obstack, NULL);
    5303                 :     814559 :   set_c_expr_source_range (&ret, brace_loc, close_loc);
    5304                 :     814559 :   return ret;
    5305                 :            : }
    5306                 :            : 
    5307                 :            : /* Parse a nested initializer, including designators.  */
    5308                 :            : 
    5309                 :            : static void
    5310                 :    5136020 : c_parser_initelt (c_parser *parser, struct obstack * braced_init_obstack)
    5311                 :            : {
    5312                 :            :   /* Parse any designator or designator list.  A single array
    5313                 :            :      designator may have the subsequent "=" omitted in GNU C, but a
    5314                 :            :      longer list or a structure member designator may not.  */
    5315                 :    5136020 :   if (c_parser_next_token_is (parser, CPP_NAME)
    5316                 :    5136020 :       && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
    5317                 :            :     {
    5318                 :            :       /* Old-style structure member designator.  */
    5319                 :        156 :       set_init_label (c_parser_peek_token (parser)->location,
    5320                 :        156 :                       c_parser_peek_token (parser)->value,
    5321                 :        156 :                       c_parser_peek_token (parser)->location,
    5322                 :            :                       braced_init_obstack);
    5323                 :            :       /* Use the colon as the error location.  */
    5324                 :        156 :       pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_Wpedantic,
    5325                 :            :                "obsolete use of designated initializer with %<:%>");
    5326                 :        156 :       c_parser_consume_token (parser);
    5327                 :        156 :       c_parser_consume_token (parser);
    5328                 :            :     }
    5329                 :            :   else
    5330                 :            :     {
    5331                 :            :       /* des_seen is 0 if there have been no designators, 1 if there
    5332                 :            :          has been a single array designator and 2 otherwise.  */
    5333                 :            :       int des_seen = 0;
    5334                 :            :       /* Location of a designator.  */
    5335                 :            :       location_t des_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
    5336                 :   10276500 :       while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
    5337                 :   10276000 :              || c_parser_next_token_is (parser, CPP_DOT))
    5338                 :            :         {
    5339                 :       2388 :           int des_prev = des_seen;
    5340                 :       2388 :           if (!des_seen)
    5341                 :       2132 :             des_loc = c_parser_peek_token (parser)->location;
    5342                 :       2388 :           if (des_seen < 2)
    5343                 :       2192 :             des_seen++;
    5344                 :       2388 :           if (c_parser_next_token_is (parser, CPP_DOT))
    5345                 :            :             {
    5346                 :       1903 :               des_seen = 2;
    5347                 :       1903 :               c_parser_consume_token (parser);
    5348                 :       1903 :               if (c_parser_next_token_is (parser, CPP_NAME))
    5349                 :            :                 {
    5350                 :       1903 :                   set_init_label (des_loc, c_parser_peek_token (parser)->value,
    5351                 :       1903 :                                   c_parser_peek_token (parser)->location,
    5352                 :            :                                   braced_init_obstack);
    5353                 :       1903 :                   c_parser_consume_token (parser);
    5354                 :            :                 }
    5355                 :            :               else
    5356                 :            :                 {
    5357                 :          0 :                   struct c_expr init;
    5358                 :          0 :                   init.set_error ();
    5359                 :          0 :                   init.original_code = ERROR_MARK;
    5360                 :          0 :                   init.original_type = NULL;
    5361                 :          0 :                   c_parser_error (parser, "expected identifier");
    5362                 :          0 :                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
    5363                 :          0 :                   process_init_element (input_location, init, false,
    5364                 :            :                                         braced_init_obstack);
    5365                 :          0 :                   return;
    5366                 :            :                 }
    5367                 :            :             }
    5368                 :            :           else
    5369                 :            :             {
    5370                 :        485 :               tree first, second;
    5371                 :        485 :               location_t ellipsis_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
    5372                 :        485 :               location_t array_index_loc = UNKNOWN_LOCATION;
    5373                 :            :               /* ??? Following the old parser, [ objc-receiver
    5374                 :            :                  objc-message-args ] is accepted as an initializer,
    5375                 :            :                  being distinguished from a designator by what follows
    5376                 :            :                  the first assignment expression inside the square
    5377                 :            :                  brackets, but after a first array designator a
    5378                 :            :                  subsequent square bracket is for Objective-C taken to
    5379                 :            :                  start an expression, using the obsolete form of
    5380                 :            :                  designated initializer without '=', rather than
    5381                 :            :                  possibly being a second level of designation: in LALR
    5382                 :            :                  terms, the '[' is shifted rather than reducing
    5383                 :            :                  designator to designator-list.  */
    5384                 :        485 :               if (des_prev == 1 && c_dialect_objc ())
    5385                 :            :                 {
    5386                 :            :                   des_seen = des_prev;
    5387                 :            :                   break;
    5388                 :            :                 }
    5389                 :        485 :               if (des_prev == 0 && c_dialect_objc ())
    5390                 :            :                 {
    5391                 :            :                   /* This might be an array designator or an
    5392                 :            :                      Objective-C message expression.  If the former,
    5393                 :            :                      continue parsing here; if the latter, parse the
    5394                 :            :                      remainder of the initializer given the starting
    5395                 :            :                      primary-expression.  ??? It might make sense to
    5396                 :            :                      distinguish when des_prev == 1 as well; see
    5397                 :            :                      previous comment.  */
    5398                 :          0 :                   tree rec, args;
    5399                 :          0 :                   struct c_expr mexpr;
    5400                 :          0 :                   c_parser_consume_token (parser);
    5401                 :          0 :                   if (c_parser_peek_token (parser)->type == CPP_NAME
    5402                 :          0 :                       && ((c_parser_peek_token (parser)->id_kind
    5403                 :            :                            == C_ID_TYPENAME)
    5404                 :          0 :                           || (c_parser_peek_token (parser)->id_kind
    5405                 :            :                               == C_ID_CLASSNAME)))
    5406                 :            :                     {
    5407                 :            :                       /* Type name receiver.  */
    5408                 :          0 :                       tree id = c_parser_peek_token (parser)->value;
    5409                 :          0 :                       c_parser_consume_token (parser);
    5410                 :          0 :                       rec = objc_get_class_reference (id);
    5411                 :          0 :                       goto parse_message_args;
    5412                 :            :                     }
    5413                 :          0 :                   first = c_parser_expr_no_commas (parser, NULL).value;
    5414                 :          0 :                   mark_exp_read (first);
    5415                 :          0 :                   if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
    5416                 :          0 :                       || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
    5417                 :          0 :                     goto array_desig_after_first;
    5418                 :            :                   /* Expression receiver.  So far only one part
    5419                 :            :                      without commas has been parsed; there might be
    5420                 :            :                      more of the expression.  */
    5421                 :            :                   rec = first;
    5422                 :          0 :                   while (c_parser_next_token_is (parser, CPP_COMMA))
    5423                 :            :                     {
    5424                 :          0 :                       struct c_expr next;
    5425                 :          0 :                       location_t comma_loc, exp_loc;
    5426                 :          0 :                       comma_loc = c_parser_peek_token (parser)->location;
    5427                 :          0 :                       c_parser_consume_token (parser);
    5428                 :          0 :                       exp_loc = c_parser_peek_token (parser)->location;
    5429                 :          0 :                       next = c_parser_expr_no_commas (parser, NULL);
    5430                 :          0 :                       next = convert_lvalue_to_rvalue (exp_loc, next,
    5431                 :          0 :                                                        true, true);
    5432                 :          0 :                       rec = build_compound_expr (comma_loc, rec, next.value);
    5433                 :            :                     }
    5434                 :          0 :                 parse_message_args:
    5435                 :            :                   /* Now parse the objc-message-args.  */
    5436                 :          0 :                   args = c_parser_objc_message_args (parser);
    5437                 :          0 :                   c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
    5438                 :            :                                              "expected %<]%>");
    5439                 :          0 :                   mexpr.value
    5440                 :          0 :                     = objc_build_message_expr (rec, args);
    5441                 :          0 :                   mexpr.original_code = ERROR_MARK;
    5442                 :          0 :                   mexpr.original_type = NULL;
    5443                 :            :                   /* Now parse and process the remainder of the
    5444                 :            :                      initializer, starting with this message
    5445                 :            :                      expression as a primary-expression.  */
    5446                 :          0 :                   c_parser_initval (parser, &mexpr, braced_init_obstack);
    5447                 :          0 :                   return;
    5448                 :            :                 }
    5449                 :        485 :               c_parser_consume_token (parser);
    5450                 :        485 :               array_index_loc = c_parser_peek_token (parser)->location;
    5451                 :        485 :               first = c_parser_expr_no_commas (parser, NULL).value;
    5452                 :        485 :               mark_exp_read (first);
    5453                 :        485 :             array_desig_after_first:
    5454                 :        485 :               if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
    5455                 :            :                 {
    5456                 :         54 :                   ellipsis_loc = c_parser_peek_token (parser)->location;
    5457                 :         54 :                   c_parser_consume_token (parser);
    5458                 :         54 :                   second = c_parser_expr_no_commas (parser, NULL).value;
    5459                 :         54 :                   mark_exp_read (second);
    5460                 :            :                 }
    5461                 :            :               else
    5462                 :            :                 second = NULL_TREE;
    5463                 :        485 :               if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
    5464                 :            :                 {
    5465                 :        485 :                   c_parser_consume_token (parser);
    5466                 :        485 :                   set_init_index (array_index_loc, first, second,
    5467                 :            :                                   braced_init_obstack);
    5468                 :        485 :                   if (second)
    5469                 :         54 :                     pedwarn (ellipsis_loc, OPT_Wpedantic,
    5470                 :            :                              "ISO C forbids specifying range of elements to initialize");
    5471                 :            :                 }
    5472                 :            :               else
    5473                 :          0 :                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
    5474                 :            :                                            "expected %<]%>");
    5475                 :            :             }
    5476                 :            :         }
    5477                 :    5135870 :       if (des_seen >= 1)
    5478                 :            :         {
    5479                 :       2132 :           if (c_parser_next_token_is (parser, CPP_EQ))
    5480                 :            :             {
    5481                 :       2111 :               pedwarn_c90 (des_loc, OPT_Wpedantic,
    5482                 :            :                            "ISO C90 forbids specifying subobject "
    5483                 :            :                            "to initialize");
    5484                 :       2111 :               c_parser_consume_token (parser);
    5485                 :            :             }
    5486                 :            :           else
    5487                 :            :             {
    5488                 :         21 :               if (des_seen == 1)
    5489                 :         19 :                 pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
    5490                 :            :                          "obsolete use of designated initializer without %<=%>");
    5491                 :            :               else
    5492                 :            :                 {
    5493                 :          2 :                   struct c_expr init;
    5494                 :          2 :                   init.set_error ();
    5495                 :          2 :                   init.original_code = ERROR_MARK;
    5496                 :          2 :                   init.original_type = NULL;
    5497                 :          2 :                   c_parser_error (parser, "expected %<=%>");
    5498                 :          2 :                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
    5499                 :          2 :                   process_init_element (input_location, init, false,
    5500                 :            :                                         braced_init_obstack);
    5501                 :          2 :                   return;
    5502                 :            :                 }
    5503                 :            :             }
    5504                 :            :         }
    5505                 :            :     }
    5506                 :    5136020 :   c_parser_initval (parser, NULL, braced_init_obstack);
    5507                 :            : }
    5508                 :            : 
    5509                 :            : /* Parse a nested initializer; as c_parser_initializer but parses
    5510                 :            :    initializers within braced lists, after any designators have been
    5511                 :            :    applied.  If AFTER is not NULL then it is an Objective-C message
    5512                 :            :    expression which is the primary-expression starting the
    5513                 :            :    initializer.  */
    5514                 :            : 
    5515                 :            : static void
    5516                 :    5136020 : c_parser_initval (c_parser *parser, struct c_expr *after,
    5517                 :            :                   struct obstack * braced_init_obstack)
    5518                 :            : {
    5519                 :    5136020 :   struct c_expr init;
    5520                 :    5136020 :   gcc_assert (!after || c_dialect_objc ());
    5521                 :    5136020 :   location_t loc = c_parser_peek_token (parser)->location;
    5522                 :            : 
    5523                 :    5136020 :   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
    5524                 :     312433 :     init = c_parser_braced_init (parser, NULL_TREE, true,
    5525                 :     312433 :                                  braced_init_obstack);
    5526                 :            :   else
    5527                 :            :     {
    5528                 :    4823590 :       init = c_parser_expr_no_commas (parser, after);
    5529                 :    4823590 :       if (init.value != NULL_TREE
    5530                 :    4823590 :           && TREE_CODE (init.value) != STRING_CST
    5531                 :    4802020 :           && TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR)
    5532                 :    4801890 :         init = convert_lvalue_to_rvalue (loc, init, true, true);
    5533                 :            :     }
    5534                 :    5136020 :   process_init_element (loc, init, false, braced_init_obstack);
    5535                 :    5136020 : }
    5536                 :            : 
    5537                 :            : /* Parse a compound statement (possibly a function body) (C90 6.6.2,
    5538                 :            :    C99 6.8.2, C11 6.8.2).
    5539                 :            : 
    5540                 :            :    compound-statement:
    5541                 :            :      { block-item-list[opt] }
    5542                 :            :      { label-declarations block-item-list }
    5543                 :            : 
    5544                 :            :    block-item-list:
    5545                 :            :      block-item
    5546                 :            :      block-item-list block-item
    5547                 :            : 
    5548                 :            :    block-item:
    5549                 :            :      nested-declaration
    5550                 :            :      statement
    5551                 :            : 
    5552                 :            :    nested-declaration:
    5553                 :            :      declaration
    5554                 :            : 
    5555                 :            :    GNU extensions:
    5556                 :            : 
    5557                 :            :    compound-statement:
    5558                 :            :      { label-declarations block-item-list }
    5559                 :            : 
    5560                 :            :    nested-declaration:
    5561                 :            :      __extension__ nested-declaration
    5562                 :            :      nested-function-definition
    5563                 :            : 
    5564                 :            :    label-declarations:
    5565                 :            :      label-declaration
    5566                 :            :      label-declarations label-declaration
    5567                 :            : 
    5568                 :            :    label-declaration:
    5569                 :            :      __label__ identifier-list ;
    5570                 :            : 
    5571                 :            :    Allowing the mixing of declarations and code is new in C99.  The
    5572                 :            :    GNU syntax also permits (not shown above) labels at the end of
    5573                 :            :    compound statements, which yield an error.  We don't allow labels
    5574                 :            :    on declarations; this might seem like a natural extension, but
    5575                 :            :    there would be a conflict between gnu-attributes on the label and
    5576                 :            :    prefix gnu-attributes on the declaration.  ??? The syntax follows the
    5577                 :            :    old parser in requiring something after label declarations.
    5578                 :            :    Although they are erroneous if the labels declared aren't defined,
    5579                 :            :    is it useful for the syntax to be this way?
    5580                 :            : 
    5581                 :            :    OpenACC:
    5582                 :            : 
    5583                 :            :    block-item:
    5584                 :            :      openacc-directive
    5585                 :            : 
    5586                 :            :    openacc-directive:
    5587                 :            :      update-directive
    5588                 :            : 
    5589                 :            :    OpenMP:
    5590                 :            : 
    5591                 :            :    block-item:
    5592                 :            :      openmp-directive
    5593                 :            : 
    5594                 :            :    openmp-directive:
    5595                 :            :      barrier-directive
    5596                 :            :      flush-directive
    5597                 :            :      taskwait-directive
    5598                 :            :      taskyield-directive
    5599                 :            :      cancel-directive
    5600                 :            :      cancellation-point-directive  */
    5601                 :            : 
    5602                 :            : static tree
    5603                 :   20876700 : c_parser_compound_statement (c_parser *parser, location_t *endlocp)
    5604                 :            : {
    5605                 :   20876700 :   tree stmt;
    5606                 :   20876700 :   location_t brace_loc;
    5607                 :   20876700 :   brace_loc = c_parser_peek_token (parser)->location;
    5608                 :   20876700 :   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
    5609                 :            :     {
    5610                 :            :       /* Ensure a scope is entered and left anyway to avoid confusion
    5611                 :            :          if we have just prepared to enter a function body.  */
    5612                 :         16 :       stmt = c_begin_compound_stmt (true);
    5613                 :         16 :       c_end_compound_stmt (brace_loc, stmt, true);
    5614                 :         16 :       return error_mark_node;
    5615                 :            :     }
    5616                 :   20876700 :   stmt = c_begin_compound_stmt (true);
    5617                 :   20876700 :   location_t end_loc = c_parser_compound_statement_nostart (parser);
    5618                 :   20876700 :   if (endlocp)
    5619                 :   20340100 :     *endlocp = end_loc;
    5620                 :            : 
    5621                 :   20876700 :   return c_end_compound_stmt (brace_loc, stmt, true);
    5622                 :            : }
    5623                 :            : 
    5624                 :            : /* Parse a compound statement except for the opening brace.  This is
    5625                 :            :    used for parsing both compound statements and statement expressions
    5626                 :            :    (which follow different paths to handling the opening).  */
    5627                 :            : 
    5628                 :            : static location_t
    5629                 :   20907000 : c_parser_compound_statement_nostart (c_parser *parser)
    5630                 :            : {
    5631                 :   20907000 :   bool last_stmt = false;
    5632                 :   20907000 :   bool last_label = false;
    5633                 :   20907000 :   bool save_valid_for_pragma = valid_location_for_stdc_pragma_p ();
    5634                 :   20907000 :   location_t label_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
    5635                 :   20907000 :   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
    5636                 :            :     {
    5637                 :      20563 :       location_t endloc = c_parser_peek_token (parser)->location;
    5638                 :      20563 :       add_debug_begin_stmt (endloc);
    5639                 :      20563 :       c_parser_consume_token (parser);
    5640                 :      20563 :       return endloc;
    5641                 :            :     }
    5642                 :   20886400 :   mark_valid_location_for_stdc_pragma (true);
    5643                 :   20886400 :   if (c_parser_next_token_is_keyword (parser, RID_LABEL))
    5644                 :            :     {
    5645                 :            :       /* Read zero or more forward-declarations for labels that nested
    5646                 :            :          functions can jump to.  */
    5647                 :        673 :       mark_valid_location_for_stdc_pragma (false);
    5648                 :       1467 :       while (c_parser_next_token_is_keyword (parser, RID_LABEL))
    5649                 :            :         {
    5650                 :        794 :           label_loc = c_parser_peek_token (parser)->location;
    5651                 :        794 :           c_parser_consume_token (parser);
    5652                 :            :           /* Any identifiers, including those declared as type names,
    5653                 :            :              are OK here.  */
    5654                 :       1444 :           while (true)
    5655                 :            :             {
    5656                 :       1119 :               tree label;
    5657                 :       1119 :               if (c_parser_next_token_is_not (parser, CPP_NAME))
    5658                 :            :                 {
    5659                 :          0 :                   c_parser_error (parser, "expected identifier");
    5660                 :          0 :                   break;
    5661                 :            :                 }
    5662                 :       1119 :               label
    5663                 :       1119 :                 = declare_label (c_parser_peek_token (parser)->value);
    5664                 :       1119 :               C_DECLARED_LABEL_FLAG (label) = 1;
    5665                 :       1119 :               add_stmt (build_stmt (label_loc, DECL_EXPR, label));
    5666                 :       1119 :               c_parser_consume_token (parser);
    5667                 :       1119 :               if (c_parser_next_token_is (parser, CPP_COMMA))
    5668                 :        325 :                 c_parser_consume_token (parser);
    5669                 :            :               else
    5670                 :            :                 break;
    5671                 :        325 :             }
    5672                 :        794 :           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
    5673                 :            :         }
    5674                 :        673 :       pedwarn (label_loc, OPT_Wpedantic, "ISO C forbids label declarations");
    5675                 :            :     }
    5676                 :            :   /* We must now have at least one statement, label or declaration.  */
    5677                 :   20886400 :   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
    5678                 :            :     {
    5679                 :          0 :       mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
    5680                 :          0 :       c_parser_error (parser, "expected declaration or statement");
    5681                 :          0 :       location_t endloc = c_parser_peek_token (parser)->location;
    5682                 :          0 :       c_parser_consume_token (parser);
    5683                 :          0 :       return endloc;
    5684                 :            :     }
    5685                 :   49174600 :   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
    5686                 :            :     {
    5687                 :   28288300 :       location_t loc = c_parser_peek_token (parser)->location;
    5688                 :   28288300 :       loc = expansion_point_location_if_in_system_header (loc);
    5689                 :            :       /* Standard attributes may start a statement or a declaration.  */
    5690                 :   28288300 :       bool have_std_attrs
    5691                 :   28288300 :         = c_parser_nth_token_starts_std_attributes (parser, 1);
    5692                 :   28288300 :       tree std_attrs = NULL_TREE;
    5693                 :   28288300 :       if (have_std_attrs)
    5694                 :         51 :         std_attrs = c_parser_std_attribute_specifier_sequence (parser);
    5695                 :   28288300 :       if (c_parser_next_token_is_keyword (parser, RID_CASE)
    5696                 :   27367700 :           || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
    5697                 :   55630800 :           || (c_parser_next_token_is (parser, CPP_NAME)
    5698                 :    4829250 :               && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
    5699                 :            :         {
    5700                 :     966555 :           c_warn_unused_attributes (std_attrs);
    5701                 :     966555 :           if (c_parser_next_token_is_keyword (parser, RID_CASE))
    5702                 :     920542 :             label_loc = c_parser_peek_2nd_token (parser)->location;
    5703                 :            :           else
    5704                 :      46013 :             label_loc = c_parser_peek_token (parser)->location;
    5705                 :     966555 :           last_label = true;
    5706                 :     966555 :           last_stmt = false;
    5707                 :     966555 :           mark_valid_location_for_stdc_pragma (false);
    5708                 :     966555 :           c_parser_label (parser);
    5709                 :            :         }
    5710                 :   27321700 :       else if (!last_label
    5711                 :   27321700 :                && (c_parser_next_tokens_start_declaration (parser)
    5712                 :   23808700 :                    || (have_std_attrs
    5713                 :         37 :                        && c_parser_next_token_is (parser, CPP_SEMICOLON))))
    5714                 :            :         {
    5715                 :    3345380 :           last_label = false;
    5716                 :    3345380 :           mark_valid_location_for_stdc_pragma (false);
    5717                 :    3345380 :           bool fallthru_attr_p = false;
    5718                 :    3345380 :           c_parser_declaration_or_fndef (parser, true, !have_std_attrs,
    5719                 :            :                                          true, true, true, NULL,
    5720                 :            :                                          vNULL, have_std_attrs, std_attrs,
    5721                 :            :                                          NULL, &fallthru_attr_p);
    5722                 :    3345380 :           if (last_stmt && !fallthru_attr_p)
    5723                 :     116457 :             pedwarn_c90 (loc, OPT_Wdeclaration_after_statement,
    5724                 :            :                          "ISO C90 forbids mixed declarations and code");
    5725                 :    3345380 :           last_stmt = fallthru_attr_p;
    5726                 :            :         }
    5727                 :   23976300 :       else if (!last_label
    5728                 :   47785000 :                && c_parser_next_token_is_keyword (parser, RID_EXTENSION))
    5729                 :            :         {
    5730                 :            :           /* __extension__ can start a declaration, but is also an
    5731                 :            :              unary operator that can start an expression.  Consume all
    5732                 :            :              but the last of a possible series of __extension__ to
    5733                 :            :              determine which.  If standard attributes have already
    5734                 :            :              been seen, it must start a statement, not a declaration,
    5735                 :            :              but standard attributes starting a declaration may appear
    5736                 :            :              after __extension__.  */
    5737                 :          0 :           while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
    5738                 :        736 :                  && (c_parser_peek_2nd_token (parser)->keyword
    5739                 :            :                      == RID_EXTENSION))
    5740                 :          0 :             c_parser_consume_token (parser);
    5741                 :        736 :           if (!have_std_attrs
    5742                 :        736 :               && (c_token_starts_declaration (c_parser_peek_2nd_token (parser))
    5743                 :        690 :                   || c_parser_nth_token_starts_std_attributes (parser, 2)))
    5744                 :            :             {
    5745                 :         47 :               int ext;
    5746                 :         47 :               ext = disable_extension_diagnostics ();
    5747                 :         47 :               c_parser_consume_token (parser);
    5748                 :         47 :               last_label = false;
    5749                 :         47 :               mark_valid_location_for_stdc_pragma (false);
    5750                 :         47 :               c_parser_declaration_or_fndef (parser, true, true, true, true,
    5751                 :            :                                              true, NULL, vNULL);
    5752                 :            :               /* Following the old parser, __extension__ does not
    5753                 :            :                  disable this diagnostic.  */
    5754                 :         47 :               restore_extension_diagnostics (ext);
    5755                 :         47 :               if (last_stmt)
    5756                 :          6 :                 pedwarn_c90 (loc, OPT_Wdeclaration_after_statement,
    5757                 :            :                              "ISO C90 forbids mixed declarations and code");
    5758                 :            :               last_stmt = false;
    5759                 :            :             }
    5760                 :            :           else
    5761                 :        689 :             goto statement;
    5762                 :            :         }
    5763                 :   23975600 :       else if (c_parser_next_token_is (parser, CPP_PRAGMA))
    5764                 :            :         {
    5765                 :      16616 :           if (have_std_attrs)
    5766                 :          0 :             c_parser_error (parser, "expected declaration or statement");
    5767                 :            :           /* External pragmas, and some omp pragmas, are not associated
    5768                 :            :              with regular c code, and so are not to be considered statements
    5769                 :            :              syntactically.  This ensures that the user doesn't put them
    5770                 :            :              places that would turn into syntax errors if the directive
    5771                 :            :              were ignored.  */
    5772                 :      33174 :           if (c_parser_pragma (parser,
    5773                 :            :                                last_label ? pragma_stmt : pragma_compound,
    5774                 :            :                                NULL))
    5775                 :      12833 :             last_label = false, last_stmt = true;
    5776                 :            :         }
    5777                 :   23959000 :       else if (c_parser_next_token_is (parser, CPP_EOF))
    5778                 :            :         {
    5779                 :         31 :           mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
    5780                 :         31 :           c_parser_error (parser, "expected declaration or statement");
    5781                 :         31 :           return c_parser_peek_token (parser)->location;
    5782                 :            :         }
    5783                 :   23958900 :       else if (c_parser_next_token_is_keyword (parser, RID_ELSE))
    5784                 :            :         {
    5785                 :          5 :           if (parser->in_if_block)
    5786                 :            :             {
    5787                 :          2 :               mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
    5788                 :          2 :               error_at (loc, "expected %<}%> before %<else%>");
    5789                 :          2 :               return c_parser_peek_token (parser)->location;
    5790                 :            :             }
    5791                 :            :           else
    5792                 :            :             {
    5793                 :          3 :               error_at (loc, "%<else%> without a previous %<if%>");
    5794                 :          3 :               c_parser_consume_token (parser);
    5795                 :          3 :               continue;
    5796                 :            :             }
    5797                 :            :         }
    5798                 :            :       else
    5799                 :            :         {
    5800                 :   23958900 :         statement:
    5801                 :   23959600 :           c_warn_unused_attributes (std_attrs);
    5802                 :   23959600 :           last_label = false;
    5803                 :   23959600 :           last_stmt = true;
    5804                 :   23959600 :           mark_valid_location_for_stdc_pragma (false);
    5805                 :   23959600 :           c_parser_statement_after_labels (parser, NULL);
    5806                 :            :         }
    5807                 :            : 
    5808                 :   28288200 :       parser->error = false;
    5809                 :            :     }
    5810                 :   20886400 :   if (last_label)
    5811                 :          4 :     error_at (label_loc, "label at end of compound statement");
    5812                 :   20886400 :   location_t endloc = c_parser_peek_token (parser)->location;
    5813                 :   20886400 :   c_parser_consume_token (parser);
    5814                 :            :   /* Restore the value we started with.  */
    5815                 :   20886400 :   mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
    5816                 :   20886400 :   return endloc;
    5817                 :            : }
    5818                 :            : 
    5819                 :            : /* Parse all consecutive labels, possibly preceded by standard
    5820                 :            :    attributes.  In this context, a statement is required, not a
    5821                 :            :    declaration, so attributes must be followed by a statement that is
    5822                 :            :    not just a semicolon.  */
    5823                 :            : 
    5824                 :            : static void
    5825                 :    1450000 : c_parser_all_labels (c_parser *parser)
    5826                 :            : {
    5827                 :    1450000 :   if (c_parser_nth_token_starts_std_attributes (parser, 1))
    5828                 :            :     {
    5829                 :          5 :       tree std_attrs = c_parser_std_attribute_specifier_sequence (parser);
    5830                 :          5 :       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    5831                 :          0 :         c_parser_error (parser, "expected statement");
    5832                 :            :       else
    5833                 :          5 :         c_warn_unused_attributes (std_attrs);
    5834                 :            :     }
    5835                 :        408 :   while (c_parser_next_token_is_keyword (parser, RID_CASE)
    5836                 :    1450290 :          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
    5837                 :    2900690 :          || (c_parser_next_token_is (parser, CPP_NAME)
    5838                 :     415120 :              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
    5839                 :        408 :     c_parser_label (parser);
    5840                 :    1450000 : }
    5841                 :            : 
    5842                 :            : /* Parse a label (C90 6.6.1, C99 6.8.1, C11 6.8.1).
    5843                 :            : 
    5844                 :            :    label:
    5845                 :            :      identifier : gnu-attributes[opt]
    5846                 :            :      case constant-expression :
    5847                 :            :      default :
    5848                 :            : 
    5849                 :            :    GNU extensions:
    5850                 :            : 
    5851                 :            :    label:
    5852                 :            :      case constant-expression ... constant-expression :
    5853                 :            : 
    5854                 :            :    The use of gnu-attributes on labels is a GNU extension.  The syntax in
    5855                 :            :    GNU C accepts any expressions without commas, non-constant
    5856                 :            :    expressions being rejected later.  Any standard
    5857                 :            :    attribute-specifier-sequence before the first label has been parsed
    5858                 :            :    in the caller, to distinguish statements from declarations.  Any
    5859                 :            :    attribute-specifier-sequence after the label is parsed in this
    5860                 :            :    function.  */
    5861                 :            : 
    5862                 :            : static void
    5863                 :     966963 : c_parser_label (c_parser *parser)
    5864                 :            : {
    5865                 :     966963 :   location_t loc1 = c_parser_peek_token (parser)->location;
    5866                 :     966963 :   tree label = NULL_TREE;
    5867                 :            : 
    5868                 :            :   /* Remember whether this case or a user-defined label is allowed to fall
    5869                 :            :      through to.  */
    5870                 :     966963 :   bool fallthrough_p = c_parser_peek_token (parser)->flags & PREV_FALLTHROUGH;
    5871                 :            : 
    5872                 :     966963 :   if (c_parser_next_token_is_keyword (parser, RID_CASE))
    5873                 :            :     {
    5874                 :     920656 :       tree exp1, exp2;
    5875                 :     920656 :       c_parser_consume_token (parser);
    5876                 :     920656 :       exp1 = c_parser_expr_no_commas (parser, NULL).value;
    5877                 :     920656 :       if (c_parser_next_token_is (parser, CPP_COLON))
    5878                 :            :         {
    5879                 :     920501 :           c_parser_consume_token (parser);
    5880                 :     920501 :           label = do_case (loc1, exp1, NULL_TREE);
    5881                 :            :         }
    5882                 :        155 :       else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
    5883                 :            :         {
    5884                 :        147 :           c_parser_consume_token (parser);
    5885                 :        147 :           exp2 = c_parser_expr_no_commas (parser, NULL).value;
    5886                 :        147 :           if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
    5887                 :        147 :             label = do_case (loc1, exp1, exp2);
    5888                 :            :         }
    5889                 :            :       else
    5890                 :          8 :         c_parser_error (parser, "expected %<:%> or %<...%>");
    5891                 :            :     }
    5892                 :      46307 :   else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
    5893                 :            :     {
    5894                 :      25200 :       c_parser_consume_token (parser);
    5895                 :      25200 :       if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
    5896                 :      25200 :         label = do_case (loc1, NULL_TREE, NULL_TREE);
    5897                 :            :     }
    5898                 :            :   else
    5899                 :            :     {
    5900                 :      21107 :       tree name = c_parser_peek_token (parser)->value;
    5901                 :      21107 :       tree tlab;
    5902                 :      21107 :       tree attrs;
    5903                 :      21107 :       location_t loc2 = c_parser_peek_token (parser)->location;
    5904                 :      21107 :       gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
    5905                 :      21107 :       c_parser_consume_token (parser);
    5906                 :      21107 :       gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
    5907                 :      21107 :       c_parser_consume_token (parser);
    5908                 :      21107 :       attrs = c_parser_gnu_attributes (parser);
    5909                 :      21107 :       tlab = define_label (loc2, name);
    5910                 :      21107 :       if (tlab)
    5911                 :            :         {
    5912                 :      21079 :           decl_attributes (&tlab, attrs, 0);
    5913                 :      21079 :           label = add_stmt (build_stmt (loc1, LABEL_EXPR, tlab));
    5914                 :            :         }
    5915                 :            :     }
    5916                 :     966963 :   if (label)
    5917                 :            :     {
    5918                 :     966833 :       if (TREE_CODE (label) == LABEL_EXPR)
    5919                 :      21079 :         FALLTHROUGH_LABEL_P (LABEL_EXPR_LABEL (label)) = fallthrough_p;
    5920                 :            :       else
    5921                 :     945754 :         FALLTHROUGH_LABEL_P (CASE_LABEL (label)) = fallthrough_p;
    5922                 :            : 
    5923                 :            :       /* Standard attributes are only allowed here if they start a
    5924                 :            :          statement, not a declaration (including the case of an
    5925                 :            :          attribute-declaration with only attributes).  */
    5926                 :     966833 :       bool have_std_attrs
    5927                 :     966833 :         = c_parser_nth_token_starts_std_attributes (parser, 1);
    5928                 :     966833 :       tree std_attrs = NULL_TREE;
    5929                 :     966833 :       if (have_std_attrs)
    5930                 :          6 :         std_attrs = c_parser_std_attribute_specifier_sequence (parser);
    5931                 :            : 
    5932                 :            :       /* Allow '__attribute__((fallthrough));'.  */
    5933                 :     966833 :       if (!have_std_attrs
    5934                 :    1933660 :           && c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
    5935                 :            :         {
    5936                 :          7 :           location_t loc = c_parser_peek_token (parser)->location;
    5937                 :          7 :           tree attrs = c_parser_gnu_attributes (parser);
    5938                 :          7 :           if (attribute_fallthrough_p (attrs))
    5939                 :            :             {
    5940                 :          4 :               if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    5941                 :            :                 {
    5942                 :          4 :                   tree fn = build_call_expr_internal_loc (loc,
    5943                 :            :                                                           IFN_FALLTHROUGH,
    5944                 :            :                                                           void_type_node, 0);
    5945                 :          4 :                   add_stmt (fn);
    5946                 :            :                 }
    5947                 :            :               else
    5948                 :          0 :                 warning_at (loc, OPT_Wattributes, "%<fallthrough%> attribute "
    5949                 :            :                             "not followed by %<;%>");
    5950                 :            :             }
    5951                 :          3 :           else if (attrs != NULL_TREE)
    5952                 :          3 :             warning_at (loc, OPT_Wattributes, "only attribute %<fallthrough%>"
    5953                 :            :                         " can be applied to a null statement");
    5954                 :            :         }
    5955                 :     966833 :       if (c_parser_next_tokens_start_declaration (parser)
    5956                 :     966833 :           || (have_std_attrs
    5957                 :          6 :               && c_parser_next_token_is (parser, CPP_SEMICOLON)))
    5958                 :            :         {
    5959                 :          6 :           error_at (c_parser_peek_token (parser)->location,
    5960                 :            :                     "a label can only be part of a statement and "
    5961                 :            :                     "a declaration is not a statement");
    5962                 :          6 :           c_parser_declaration_or_fndef (parser, /*fndef_ok*/ false,
    5963                 :            :                                          /*static_assert_ok*/ true,
    5964                 :            :                                          /*empty_ok*/ true, /*nested*/ true,
    5965                 :            :                                          /*start_attr_ok*/ true, NULL,
    5966                 :            :                                          vNULL, have_std_attrs, std_attrs);
    5967                 :            :         }
    5968                 :     966827 :       else if (std_attrs)
    5969                 :            :         /* Nonempty attributes on the following statement are ignored.  */
    5970                 :          0 :         c_warn_unused_attributes (std_attrs);
    5971                 :            :     }
    5972                 :     966963 : }
    5973                 :            : 
    5974                 :            : /* Parse a statement (C90 6.6, C99 6.8, C11 6.8).
    5975                 :            : 
    5976                 :            :    statement:
    5977                 :            :      labeled-statement
    5978                 :            :      attribute-specifier-sequence[opt] compound-statement
    5979                 :            :      expression-statement
    5980                 :            :      attribute-specifier-sequence[opt] selection-statement
    5981                 :            :      attribute-specifier-sequence[opt] iteration-statement
    5982                 :            :      attribute-specifier-sequence[opt] jump-statement
    5983                 :            : 
    5984                 :            :    labeled-statement:
    5985                 :            :      attribute-specifier-sequence[opt] label statement
    5986                 :            : 
    5987                 :            :    expression-statement:
    5988                 :            :      expression[opt] ;
    5989                 :            :      attribute-specifier-sequence expression ;
    5990                 :            : 
    5991                 :            :    selection-statement:
    5992                 :            :      if-statement
    5993                 :            :      switch-statement
    5994                 :            : 
    5995                 :            :    iteration-statement:
    5996                 :            :      while-statement
    5997                 :            :      do-statement
    5998                 :            :      for-statement
    5999                 :            : 
    6000                 :            :    jump-statement:
    6001                 :            :      goto identifier ;
    6002                 :            :      continue ;
    6003                 :            :      break ;
    6004                 :            :      return expression[opt] ;
    6005                 :            : 
    6006                 :            :    GNU extensions:
    6007                 :            : 
    6008                 :            :    statement:
    6009                 :            :      attribute-specifier-sequence[opt] asm-statement
    6010                 :            : 
    6011                 :            :    jump-statement:
    6012                 :            :      goto * expression ;
    6013                 :            : 
    6014                 :            :    expression-statement:
    6015                 :            :      gnu-attributes ;
    6016                 :            : 
    6017                 :            :    Objective-C:
    6018                 :            : 
    6019                 :            :    statement:
    6020                 :            :      attribute-specifier-sequence[opt] objc-throw-statement
    6021                 :            :      attribute-specifier-sequence[opt] objc-try-catch-statement
    6022                 :            :      attribute-specifier-sequence[opt] objc-synchronized-statement
    6023                 :            : 
    6024                 :            :    objc-throw-statement:
    6025                 :            :      @throw expression ;
    6026                 :            :      @throw ;
    6027                 :            : 
    6028                 :            :    OpenACC:
    6029                 :            : 
    6030                 :            :    statement:
    6031                 :            :      attribute-specifier-sequence[opt] openacc-construct
    6032                 :            : 
    6033                 :            :    openacc-construct:
    6034                 :            :      parallel-construct
    6035                 :            :      kernels-construct
    6036                 :            :      data-construct
    6037                 :            :      loop-construct
    6038                 :            : 
    6039                 :            :    parallel-construct:
    6040                 :            :      parallel-directive structured-block
    6041                 :            : 
    6042                 :            :    kernels-construct:
    6043                 :            :      kernels-directive structured-block
    6044                 :            : 
    6045                 :            :    data-construct:
    6046                 :            :      data-directive structured-block
    6047                 :            : 
    6048                 :            :    loop-construct:
    6049                 :            :      loop-directive structured-block
    6050                 :            : 
    6051                 :            :    OpenMP:
    6052                 :            : 
    6053                 :            :    statement:
    6054                 :            :      attribute-specifier-sequence[opt] openmp-construct
    6055                 :            : 
    6056                 :            :    openmp-construct:
    6057                 :            :      parallel-construct
    6058                 :            :      for-construct
    6059                 :            :      simd-construct
    6060                 :            :      for-simd-construct
    6061                 :            :      sections-construct
    6062                 :            :      single-construct
    6063                 :            :      parallel-for-construct
    6064                 :            :      parallel-for-simd-construct
    6065                 :            :      parallel-sections-construct
    6066                 :            :      master-construct
    6067                 :            :      critical-construct
    6068                 :            :      atomic-construct
    6069                 :            :      ordered-construct
    6070                 :            : 
    6071                 :            :    parallel-construct:
    6072                 :            :      parallel-directive structured-block
    6073                 :            : 
    6074                 :            :    for-construct:
    6075                 :            :      for-directive iteration-statement
    6076                 :            : 
    6077                 :            :    simd-construct:
    6078                 :            :      simd-directive iteration-statements
    6079                 :            : 
    6080                 :            :    for-simd-construct:
    6081                 :            :      for-simd-directive iteration-statements
    6082                 :            : 
    6083                 :            :    sections-construct:
    6084                 :            :      sections-directive section-scope
    6085                 :            : 
    6086                 :            :    single-construct:
    6087                 :            :      single-directive structured-block
    6088                 :            : 
    6089                 :            :    parallel-for-construct:
    6090                 :            :      parallel-for-directive iteration-statement
    6091                 :            : 
    6092                 :            :    parallel-for-simd-construct:
    6093                 :            :      parallel-for-simd-directive iteration-statement
    6094                 :            : 
    6095                 :            :    parallel-sections-construct:
    6096                 :            :      parallel-sections-directive section-scope
    6097                 :            : 
    6098                 :            :    master-construct:
    6099                 :            :      master-directive structured-block
    6100                 :            : 
    6101                 :            :    critical-construct:
    6102                 :            :      critical-directive structured-block
    6103                 :            : 
    6104                 :            :    atomic-construct:
    6105                 :            :      atomic-directive expression-statement
    6106                 :            : 
    6107                 :            :    ordered-construct:
    6108                 :            :      ordered-directive structured-block
    6109                 :            : 
    6110                 :            :    Transactional Memory:
    6111                 :            : 
    6112                 :            :    statement:
    6113                 :            :      attribute-specifier-sequence[opt] transaction-statement
    6114                 :            :      attribute-specifier-sequence[opt] transaction-cancel-statement
    6115                 :            : 
    6116                 :            :    IF_P is used to track whether there's a (possibly labeled) if statement
    6117                 :            :    which is not enclosed in braces and has an else clause.  This is used to
    6118                 :            :    implement -Wparentheses.  */
    6119                 :            : 
    6120                 :            : static void
    6121                 :     404399 : c_parser_statement (c_parser *parser, bool *if_p, location_t *loc_after_labels)
    6122                 :            : {
    6123                 :     398737 :   c_parser_all_labels (parser);
    6124                 :     398737 :   if (loc_after_labels)
    6125                 :     280786 :     *loc_after_labels = c_parser_peek_token (parser)->location;
    6126                 :     404399 :   c_parser_statement_after_labels (parser, if_p, NULL);
    6127                 :     398737 : }
    6128                 :            : 
    6129                 :            : /* Parse a statement, other than a labeled statement.  CHAIN is a vector
    6130                 :            :    of if-else-if conditions.  All labels and standard attributes have
    6131                 :            :    been parsed in the caller.
    6132                 :            : 
    6133                 :            :    IF_P is used to track whether there's a (possibly labeled) if statement
    6134                 :            :    which is not enclosed in braces and has an else clause.  This is used to
    6135                 :            :    implement -Wparentheses.  */
    6136                 :            : 
    6137                 :            : static void
    6138                 :   25183500 : c_parser_statement_after_labels (c_parser *parser, bool *if_p,
    6139                 :            :                                  vec<tree> *chain)
    6140                 :            : {
    6141                 :   25183500 :   location_t loc = c_parser_peek_token (parser)->location;
    6142                 :   25183500 :   tree stmt = NULL_TREE;
    6143                 :   25183500 :   bool in_if_block = parser->in_if_block;
    6144                 :   25183500 :   parser->in_if_block = false;
    6145                 :   25183500 :   if (if_p != NULL)
    6146                 :     699182 :     *if_p = false;
    6147                 :            : 
    6148                 :   25183500 :   if (c_parser_peek_token (parser)->type != CPP_OPEN_BRACE)
    6149                 :   24870000 :     add_debug_begin_stmt (loc);
    6150                 :            : 
    6151                 :   25183500 :   switch (c_parser_peek_token (parser)->type)
    6152                 :            :     {
    6153                 :     313436 :     case CPP_OPEN_BRACE:
    6154                 :     313436 :       add_stmt (c_parser_compound_statement (parser));
    6155                 :     313436 :       break;
    6156                 :   20810500 :     case CPP_KEYWORD:
    6157                 :   20810500 :       switch (c_parser_peek_token (parser)->keyword)
    6158                 :            :         {
    6159                 :     923020 :         case RID_IF:
    6160                 :     923020 :           c_parser_if_statement (parser, if_p, chain);
    6161                 :     923020 :           break;
    6162                 :      27721 :         case RID_SWITCH:
    6163                 :      27721 :           c_parser_switch_statement (parser, if_p);
    6164                 :      27721 :           break;
    6165                 :      34347 :         case RID_WHILE:
    6166                 :      34347 :           c_parser_while_statement (parser, false, 0, if_p);
    6167                 :      34347 :           break;
    6168                 :     109841 :         case RID_DO:
    6169                 :     109841 :           c_parser_do_statement (parser, 0, false);
    6170                 :     109841 :           break;
    6171                 :     218566 :         case RID_FOR:
    6172                 :     218566 :           c_parser_for_statement (parser, false, 0, if_p);
    6173                 :     218566 :           break;
    6174                 :      81249 :         case RID_GOTO:
    6175                 :      81249 :           c_parser_consume_token (parser);
    6176                 :      81249 :           if (c_parser_next_token_is (parser, CPP_NAME))
    6177                 :            :             {
    6178                 :      80382 :               stmt = c_finish_goto_label (loc,
    6179                 :      80382 :                                           c_parser_peek_token (parser)->value);
    6180                 :      80382 :               c_parser_consume_token (parser);
    6181                 :            :             }
    6182                 :        867 :           else if (c_parser_next_token_is (parser, CPP_MULT))
    6183                 :            :             {
    6184                 :        867 :               struct c_expr val;
    6185                 :            : 
    6186                 :        867 :               c_parser_consume_token (parser);
    6187                 :        867 :               val = c_parser_expression (parser);
    6188                 :        867 :               val = convert_lvalue_to_rvalue (loc, val, false, true);
    6189                 :        867 :               stmt = c_finish_goto_ptr (loc, val.value);
    6190                 :            :             }
    6191                 :            :           else
    6192                 :          0 :             c_parser_error (parser, "expected identifier or %<*%>");
    6193                 :      81249 :           goto expect_semicolon;
    6194                 :       9818 :         case RID_CONTINUE:
    6195                 :       9818 :           c_parser_consume_token (parser);
    6196                 :       9818 :           stmt = c_finish_bc_stmt (loc, &c_cont_label, false);
    6197                 :       9818 :           goto expect_semicolon;
    6198                 :     131838 :         case RID_BREAK:
    6199                 :     131838 :           c_parser_consume_token (parser);
    6200                 :     131838 :           stmt = c_finish_bc_stmt (loc, &c_break_label, true);
    6201                 :     131838 :           goto expect_semicolon;
    6202                 :   19118000 :         case RID_RETURN:
    6203                 :   19118000 :           c_parser_consume_token (parser);
    6204                 :   19118000 :           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    6205                 :            :             {
    6206                 :      15091 :               stmt = c_finish_return (loc, NULL_TREE, NULL_TREE);
    6207                 :      15091 :               c_parser_consume_token (parser);
    6208                 :            :             }
    6209                 :            :           else
    6210                 :            :             {
    6211                 :   19102900 :               location_t xloc = c_parser_peek_token (parser)->location;
    6212                 :   19102900 :               struct c_expr expr = c_parser_expression_conv (parser);
    6213                 :   19102900 :               mark_exp_read (expr.value);
    6214                 :   19102900 :               stmt = c_finish_return (EXPR_LOC_OR_LOC (expr.value, xloc),
    6215                 :            :                                       expr.value, expr.original_type);
    6216                 :   19102900 :               goto expect_semicolon;
    6217                 :            :             }
    6218                 :      15091 :           break;
    6219                 :     150469 :         case RID_ASM:
    6220                 :     150469 :           stmt = c_parser_asm_statement (parser);
    6221                 :     150469 :           break;
    6222                 :        136 :         case RID_TRANSACTION_ATOMIC:
    6223                 :        136 :         case RID_TRANSACTION_RELAXED:
    6224                 :        272 :           stmt = c_parser_transaction (parser,
    6225                 :        136 :               c_parser_peek_token (parser)->keyword);
    6226                 :        136 :           break;
    6227                 :         27 :         case RID_TRANSACTION_CANCEL:
    6228                 :         27 :           stmt = c_parser_transaction_cancel (parser);
    6229                 :         27 :           goto expect_semicolon;
    6230                 :          0 :         case RID_AT_THROW:
    6231                 :          0 :           gcc_assert (c_dialect_objc ());
    6232                 :          0 :           c_parser_consume_token (parser);
    6233                 :          0 :           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    6234                 :            :             {
    6235                 :          0 :               stmt = objc_build_throw_stmt (loc, NULL_TREE);
    6236                 :          0 :               c_parser_consume_token (parser);
    6237                 :            :             }
    6238                 :            :           else
    6239                 :            :             {
    6240                 :          0 :               struct c_expr expr = c_parser_expression (parser);
    6241                 :          0 :               expr = convert_lvalue_to_rvalue (loc, expr, false, false);
    6242                 :          0 :               expr.value = c_fully_fold (expr.value, false, NULL);
    6243                 :          0 :               stmt = objc_build_throw_stmt (loc, expr.value);
    6244                 :          0 :               goto expect_semicolon;
    6245                 :            :             }
    6246                 :          0 :           break;
    6247                 :          0 :         case RID_AT_TRY:
    6248                 :          0 :           gcc_assert (c_dialect_objc ());
    6249                 :          0 :           c_parser_objc_try_catch_finally_statement (parser);
    6250                 :          0 :           break;
    6251                 :          0 :         case RID_AT_SYNCHRONIZED:
    6252                 :          0 :           gcc_assert (c_dialect_objc ());
    6253                 :          0 :           c_parser_objc_synchronized_statement (parser);
    6254                 :          0 :           break;
    6255                 :          5 :         case RID_ATTRIBUTE:
    6256                 :          5 :           {
    6257                 :            :             /* Allow '__attribute__((fallthrough));'.  */
    6258                 :          5 :             tree attrs = c_parser_gnu_attributes (parser);
    6259                 :          5 :             if (attribute_fallthrough_p (attrs))
    6260                 :            :               {
    6261                 :          5 :                 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    6262                 :            :                   {
    6263                 :          5 :                     tree fn = build_call_expr_internal_loc (loc,
    6264                 :            :                                                             IFN_FALLTHROUGH,
    6265                 :            :                                                             void_type_node, 0);
    6266                 :          5 :                     add_stmt (fn);
    6267                 :            :                     /* Eat the ';'.  */
    6268                 :          5 :                     c_parser_consume_token (parser);
    6269                 :            :                   }
    6270                 :            :                 else
    6271                 :          0 :                   warning_at (loc, OPT_Wattributes,
    6272                 :            :                               "%<fallthrough%> attribute not followed "
    6273                 :            :                               "by %<;%>");
    6274                 :            :               }
    6275                 :          0 :             else if (attrs != NULL_TREE)
    6276                 :          0 :               warning_at (loc, OPT_Wattributes, "only attribute %<fallthrough%>"
    6277                 :            :                           " can be applied to a null statement");
    6278                 :            :             break;
    6279                 :            :           }
    6280                 :       5474 :         default:
    6281                 :       5474 :           goto expr_stmt;
    6282                 :            :         }
    6283                 :            :       break;
    6284                 :     172198 :     case CPP_SEMICOLON:
    6285                 :     172198 :       c_parser_consume_token (parser);
    6286                 :     172198 :       break;
    6287                 :          2 :     case CPP_CLOSE_PAREN:
    6288                 :          2 :     case CPP_CLOSE_SQUARE:
    6289                 :            :       /* Avoid infinite loop in error recovery:
    6290                 :            :          c_parser_skip_until_found stops at a closing nesting
    6291                 :            :          delimiter without consuming it, but here we need to consume
    6292                 :            :          it to proceed further.  */
    6293                 :          2 :       c_parser_error (parser, "expected statement");
    6294                 :          2 :       c_parser_consume_token (parser);
    6295                 :          2 :       break;
    6296                 :       1986 :     case CPP_PRAGMA:
    6297                 :       1986 :       c_parser_pragma (parser, pragma_stmt, if_p);
    6298                 :       1986 :       break;
    6299                 :    3890860 :     default:
    6300                 :    3890860 :     expr_stmt:
    6301                 :    3890860 :       stmt = c_finish_expr_stmt (loc, c_parser_expression_conv (parser).value);
    6302                 :   23216600 :     expect_semicolon:
    6303                 :   23216600 :       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
    6304                 :   23216600 :       break;
    6305                 :            :     }
    6306                 :            :   /* Two cases cannot and do not have line numbers associated: If stmt
    6307                 :            :      is degenerate, such as "2;", then stmt is an INTEGER_CST, which
    6308                 :            :      cannot hold line numbers.  But that's OK because the statement
    6309                 :            :      will either be changed to a MODIFY_EXPR during gimplification of
    6310                 :            :      the statement expr, or discarded.  If stmt was compound, but
    6311                 :            :      without new variables, we will have skipped the creation of a
    6312                 :            :      BIND and will have a bare STATEMENT_LIST.  But that's OK because
    6313                 :            :      (recursively) all of the component statements should already have
    6314                 :            :      line numbers assigned.  ??? Can we discard no-op statements
    6315                 :            :      earlier?  */
    6316                 :   25183500 :   if (EXPR_LOCATION (stmt) == UNKNOWN_LOCATION)
    6317                 :    1803270 :     protected_set_expr_location (stmt, loc);
    6318                 :            : 
    6319                 :   25183500 :   parser->in_if_block = in_if_block;
    6320                 :   25183500 : }
    6321                 :            : 
    6322                 :            : /* Parse the condition from an if, do, while or for statements.  */
    6323                 :            : 
    6324                 :            : static tree
    6325                 :    1283410 : c_parser_condition (c_parser *parser)
    6326                 :            : {
    6327                 :    1283410 :   location_t loc = c_parser_peek_token (parser)->location;
    6328                 :    1283410 :   tree cond;
    6329                 :    1283410 :   cond = c_parser_expression_conv (parser).value;
    6330                 :    1283410 :   cond = c_objc_common_truthvalue_conversion (loc, cond);
    6331                 :    1283410 :   cond = c_fully_fold (cond, false, NULL);
    6332                 :    1283410 :   if (warn_sequence_point)
    6333                 :     213583 :     verify_sequence_points (cond);
    6334                 :    1283410 :   return cond;
    6335                 :            : }
    6336                 :            : 
    6337                 :            : /* Parse a parenthesized condition from an if, do or while statement.
    6338                 :            : 
    6339                 :            :    condition:
    6340                 :            :      ( expression )
    6341                 :            : */
    6342                 :            : static tree
    6343                 :    1067220 : c_parser_paren_condition (c_parser *parser)
    6344                 :            : {
    6345                 :    1067220 :   tree cond;
    6346                 :    1067220 :   matching_parens parens;
    6347                 :    1067220 :   if (!parens.require_open (parser))
    6348                 :          1 :     return error_mark_node;
    6349                 :    1067220 :   cond = c_parser_condition (parser);
    6350                 :    1067220 :   parens.skip_until_found_close (parser);
    6351                 :    1067220 :   return cond;
    6352                 :            : }
    6353                 :            : 
    6354                 :            : /* Parse a statement which is a block in C99.
    6355                 :            : 
    6356                 :            :    IF_P is used to track whether there's a (possibly labeled) if statement
    6357                 :            :    which is not enclosed in braces and has an else clause.  This is used to
    6358                 :            :    implement -Wparentheses.  */
    6359                 :            : 
    6360                 :            : static tree
    6361                 :     398737 : c_parser_c99_block_statement (c_parser *parser, bool *if_p,
    6362                 :            :                               location_t *loc_after_labels)
    6363                 :            : {
    6364                 :     398737 :   tree block = c_begin_compound_stmt (flag_isoc99);
    6365                 :     398737 :   location_t loc = c_parser_peek_token (parser)->location;
    6366                 :     398737 :   c_parser_statement (parser, if_p, loc_after_labels);
    6367                 :     398737 :   return c_end_compound_stmt (loc, block, flag_isoc99);
    6368                 :            : }
    6369                 :            : 
    6370                 :            : /* Parse the body of an if statement.  This is just parsing a
    6371                 :            :    statement but (a) it is a block in C99, (b) we track whether the
    6372                 :            :    body is an if statement for the sake of -Wparentheses warnings, (c)
    6373                 :            :    we handle an empty body specially for the sake of -Wempty-body
    6374                 :            :    warnings, and (d) we call parser_compound_statement directly
    6375                 :            :    because c_parser_statement_after_labels resets
    6376                 :            :    parser->in_if_block.
    6377                 :            : 
    6378                 :            :    IF_P is used to track whether there's a (possibly labeled) if statement
    6379                 :            :    which is not enclosed in braces and has an else clause.  This is used to
    6380                 :            :    implement -Wparentheses.  */
    6381                 :            : 
    6382                 :            : static tree
    6383                 :     923020 : c_parser_if_body (c_parser *parser, bool *if_p,
    6384                 :            :                   const token_indent_info &if_tinfo)
    6385                 :            : {
    6386                 :     923020 :   tree block = c_begin_compound_stmt (flag_isoc99);
    6387                 :     923020 :   location_t body_loc = c_parser_peek_token (parser)->location;
    6388                 :     923020 :   location_t body_loc_after_labels = UNKNOWN_LOCATION;
    6389                 :     923020 :   token_indent_info body_tinfo
    6390                 :     923020 :     = get_token_indent_info (c_parser_peek_token (parser));
    6391                 :            : 
    6392                 :     923020 :   c_parser_all_labels (parser);
    6393                 :     923020 :   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    6394                 :            :     {
    6395                 :       3105 :       location_t loc = c_parser_peek_token (parser)->location;
    6396                 :       3105 :       add_stmt (build_empty_stmt (loc));
    6397                 :       3105 :       c_parser_consume_token (parser);
    6398                 :       3105 :       if (!c_parser_next_token_is_keyword (parser, RID_ELSE))
    6399                 :        364 :         warning_at (loc, OPT_Wempty_body,
    6400                 :            :                     "suggest braces around empty body in an %<if%> statement");
    6401                 :            :     }
    6402                 :     919915 :   else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
    6403                 :     223015 :     add_stmt (c_parser_compound_statement (parser));
    6404                 :            :   else
    6405                 :            :     {
    6406                 :     696900 :       body_loc_after_labels = c_parser_peek_token (parser)->location;
    6407                 :     696900 :       c_parser_statement_after_labels (parser, if_p);
    6408                 :            :     }
    6409                 :            : 
    6410                 :     923020 :   token_indent_info next_tinfo
    6411                 :     923020 :     = get_token_indent_info (c_parser_peek_token (parser));
    6412                 :     923020 :   warn_for_misleading_indentation (if_tinfo, body_tinfo, next_tinfo);
    6413                 :     923020 :   if (body_loc_after_labels != UNKNOWN_LOCATION
    6414                 :     696900 :       && next_tinfo.type != CPP_SEMICOLON)
    6415                 :     692613 :     warn_for_multistatement_macros (body_loc_after_labels, next_tinfo.location,
    6416                 :     692613 :                                     if_tinfo.location, RID_IF);
    6417                 :            : 
    6418                 :     923020 :   return c_end_compound_stmt (body_loc, block, flag_isoc99);
    6419                 :            : }
    6420                 :            : 
    6421                 :            : /* Parse the else body of an if statement.  This is just parsing a
    6422                 :            :    statement but (a) it is a block in C99, (b) we handle an empty body
    6423                 :            :    specially for the sake of -Wempty-body warnings.  CHAIN is a vector
    6424                 :            :    of if-else-if conditions.  */
    6425                 :            : 
    6426                 :            : static tree
    6427                 :     122576 : c_parser_else_body (c_parser *parser, const token_indent_info &else_tinfo,
    6428                 :            :                     vec<tree> *chain)
    6429                 :            : {
    6430                 :     122576 :   location_t body_loc = c_parser_peek_token (parser)->location;
    6431                 :     122576 :   tree block = c_begin_compound_stmt (flag_isoc99);
    6432                 :     122576 :   token_indent_info body_tinfo
    6433                 :     122576 :     = get_token_indent_info (c_parser_peek_token (parser));
    6434                 :     122576 :   location_t body_loc_after_labels = UNKNOWN_LOCATION;
    6435                 :            : 
    6436                 :     122576 :   c_parser_all_labels (parser);
    6437                 :     122576 :   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    6438                 :            :     {
    6439                 :         30 :       location_t loc = c_parser_peek_token (parser)->location;
    6440                 :         30 :       warning_at (loc,
    6441                 :            :                   OPT_Wempty_body,
    6442                 :            :                  "suggest braces around empty body in an %<else%> statement");
    6443                 :         30 :       add_stmt (build_empty_stmt (loc));
    6444                 :         30 :       c_parser_consume_token (parser);
    6445                 :            :     }
    6446                 :            :   else
    6447                 :            :     {
    6448                 :     122546 :       if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE))
    6449                 :      94691 :         body_loc_after_labels = c_parser_peek_token (parser)->location;
    6450                 :     122546 :       c_parser_statement_after_labels (parser, NULL, chain);
    6451                 :            :     }
    6452                 :            : 
    6453                 :     122576 :   token_indent_info next_tinfo
    6454                 :     122576 :     = get_token_indent_info (c_parser_peek_token (parser));
    6455                 :     122576 :   warn_for_misleading_indentation (else_tinfo, body_tinfo, next_tinfo);
    6456                 :     122576 :   if (body_loc_after_labels != UNKNOWN_LOCATION
    6457                 :      94691 :       && next_tinfo.type != CPP_SEMICOLON)
    6458                 :      94682 :     warn_for_multistatement_macros (body_loc_after_labels, next_tinfo.location,
    6459                 :      94682 :                                     else_tinfo.location, RID_ELSE);
    6460                 :            : 
    6461                 :     122576 :   return c_end_compound_stmt (body_loc, block, flag_isoc99);
    6462                 :            : }
    6463                 :            : 
    6464                 :            : /* We might need to reclassify any previously-lexed identifier, e.g.
    6465                 :            :    when we've left a for loop with an if-statement without else in the
    6466                 :            :    body - we might have used a wrong scope for the token.  See PR67784.  */
    6467                 :            : 
    6468                 :            : static void
    6469                 :    1203810 : c_parser_maybe_reclassify_token (c_parser *parser)
    6470                 :            : {
    6471                 :    1203810 :   if (c_parser_next_token_is (parser, CPP_NAME))
    6472                 :            :     {
    6473                 :     153452 :       c_token *token = c_parser_peek_token (parser);
    6474                 :            : 
    6475                 :     153452 :       if (token->id_kind != C_ID_CLASSNAME)
    6476                 :            :         {
    6477                 :     153452 :           tree decl = lookup_name (token->value);
    6478                 :            : 
    6479                 :     153452 :           token->id_kind = C_ID_ID;
    6480                 :     153452 :           if (decl)
    6481                 :            :             {
    6482                 :     148236 :               if (TREE_CODE (decl) == TYPE_DECL)
    6483                 :       1336 :                 token->id_kind = C_ID_TYPENAME;
    6484                 :            :             }
    6485                 :       5216 :           else if (c_dialect_objc ())
    6486                 :            :             {
    6487                 :          0 :               tree objc_interface_decl = objc_is_class_name (token->value);
    6488                 :            :               /* Objective-C class names are in the same namespace as
    6489                 :            :                  variables and typedefs, and hence are shadowed by local
    6490                 :            :                  declarations.  */
    6491                 :          0 :               if (objc_interface_decl)
    6492                 :            :                 {
    6493                 :          0 :                   token->value = objc_interface_decl;
    6494                 :          0 :                   token->id_kind = C_ID_CLASSNAME;
    6495                 :            :                 }
    6496                 :            :             }
    6497                 :            :         }
    6498                 :            :     }
    6499                 :    1203810 : }
    6500                 :            : 
    6501                 :            : /* Parse an if statement (C90 6.6.4, C99 6.8.4, C11 6.8.4).
    6502                 :            : 
    6503                 :            :    if-statement:
    6504                 :            :      if ( expression ) statement
    6505                 :            :      if ( expression ) statement else statement
    6506                 :            : 
    6507                 :            :    CHAIN is a vector of if-else-if conditions.
    6508                 :            :    IF_P is used to track whether there's a (possibly labeled) if statement
    6509                 :            :    which is not enclosed in braces and has an else clause.  This is used to
    6510                 :            :    implement -Wparentheses.  */
    6511                 :            : 
    6512                 :            : static void
    6513                 :     923020 : c_parser_if_statement (c_parser *parser, bool *if_p, vec<tree> *chain)
    6514                 :            : {
    6515                 :     923020 :   tree block;
    6516                 :     923020 :   location_t loc;
    6517                 :     923020 :   tree cond;
    6518                 :     923020 :   bool nested_if = false;
    6519                 :     923020 :   tree first_body, second_body;
    6520                 :     923020 :   bool in_if_block;
    6521                 :            : 
    6522                 :     923020 :   gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF));
    6523                 :     923020 :   token_indent_info if_tinfo
    6524                 :     923020 :     = get_token_indent_info (c_parser_peek_token (parser));
    6525                 :     923020 :   c_parser_consume_token (parser);
    6526                 :     923020 :   block = c_begin_compound_stmt (flag_isoc99);
    6527                 :     923020 :   loc = c_parser_peek_token (parser)->location;
    6528                 :     923020 :   cond = c_parser_paren_condition (parser);
    6529                 :     923020 :   in_if_block = parser->in_if_block;
    6530                 :     923020 :   parser->in_if_block = true;
    6531                 :     923020 :   first_body = c_parser_if_body (parser, &nested_if, if_tinfo);
    6532                 :     923020 :   parser->in_if_block = in_if_block;
    6533                 :            : 
    6534                 :     923020 :   if (warn_duplicated_cond)
    6535                 :         62 :     warn_duplicated_cond_add_or_warn (EXPR_LOCATION (cond), cond, &chain);
    6536                 :            : 
    6537                 :     923020 :   if (c_parser_next_token_is_keyword (parser, RID_ELSE))
    6538                 :            :     {
    6539                 :     122576 :       token_indent_info else_tinfo
    6540                 :     122576 :         = get_token_indent_info (c_parser_peek_token (parser));
    6541                 :     122576 :       c_parser_consume_token (parser);
    6542                 :     122576 :       if (warn_duplicated_cond)
    6543                 :            :         {
    6544                 :         43 :           if (c_parser_next_token_is_keyword (parser, RID_IF)
    6545                 :         43 :               && chain == NULL)
    6546                 :            :             {
    6547                 :            :               /* We've got "if (COND) else if (COND2)".  Start the
    6548                 :            :                  condition chain and add COND as the first element.  */
    6549                 :         18 :               chain = new vec<tree> ();
    6550                 :         18 :               if (!CONSTANT_CLASS_P (cond) && !TREE_SIDE_EFFECTS (cond))
    6551                 :         12 :                 chain->safe_push (cond);
    6552                 :            :             }
    6553                 :         25 :           else if (!c_parser_next_token_is_keyword (parser, RID_IF))
    6554                 :            :             {
    6555                 :            :               /* This is if-else without subsequent if.  Zap the condition
    6556                 :            :                  chain; we would have already warned at this point.  */
    6557                 :          4 :               delete chain;
    6558                 :          4 :               chain = NULL;
    6559                 :            :             }
    6560                 :            :         }
    6561                 :     122576 :       second_body = c_parser_else_body (parser, else_tinfo, chain);
    6562                 :            :       /* Set IF_P to true to indicate that this if statement has an
    6563                 :            :          else clause.  This may trigger the Wparentheses warning
    6564                 :            :          below when we get back up to the parent if statement.  */
    6565                 :     122576 :       if (if_p != NULL)
    6566                 :        182 :         *if_p = true;
    6567                 :            :     }
    6568                 :            :   else
    6569                 :            :     {
    6570                 :     800444 :       second_body = NULL_TREE;
    6571                 :            : 
    6572                 :            :       /* Diagnose an ambiguous else if if-then-else is nested inside
    6573                 :            :          if-then.  */
    6574                 :     800444 :       if (nested_if)
    6575                 :        136 :         warning_at (loc, OPT_Wdangling_else,
    6576                 :            :                     "suggest explicit braces to avoid ambiguous %<else%>");
    6577                 :            : 
    6578                 :     800444 :       if (warn_duplicated_cond)
    6579                 :            :         {
    6580                 :            :           /* This if statement does not have an else clause.  We don't
    6581                 :            :              need the condition chain anymore.  */
    6582                 :         19 :           delete chain;
    6583                 :         19 :           chain = NULL;
    6584                 :            :         }
    6585                 :            :     }
    6586                 :     923020 :   c_finish_if_stmt (loc, cond, first_body, second_body);
    6587                 :     923020 :   add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
    6588                 :            : 
    6589                 :     923020 :   c_parser_maybe_reclassify_token (parser);
    6590                 :     923020 : }
    6591                 :            : 
    6592                 :            : /* Parse a switch statement (C90 6.6.4, C99 6.8.4, C11 6.8.4).
    6593                 :            : 
    6594                 :            :    switch-statement:
    6595                 :            :      switch (expression) statement
    6596                 :            : */
    6597                 :            : 
    6598                 :            : static void
    6599                 :      27721 : c_parser_switch_statement (c_parser *parser, bool *if_p)
    6600                 :            : {
    6601                 :      27721 :   struct c_expr ce;
    6602                 :      27721 :   tree block, expr, body, save_break;
    6603                 :      27721 :   location_t switch_loc = c_parser_peek_token (parser)->location;
    6604                 :      27721 :   location_t switch_cond_loc;
    6605                 :      27721 :   gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH));
    6606                 :      27721 :   c_parser_consume_token (parser);
    6607                 :      27721 :   block = c_begin_compound_stmt (flag_isoc99);
    6608                 :      27721 :   bool explicit_cast_p = false;
    6609                 :      27721 :   matching_parens parens;
    6610                 :      27721 :   if (parens.require_open (parser))
    6611                 :            :     {
    6612                 :      27714 :       switch_cond_loc = c_parser_peek_token (parser)->location;
    6613                 :      27714 :       if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
    6614                 :      27714 :           && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
    6615                 :            :         explicit_cast_p = true;
    6616                 :      27714 :       ce = c_parser_expression (parser);
    6617                 :      27714 :       ce = convert_lvalue_to_rvalue (switch_cond_loc, ce, true, true);
    6618                 :      27714 :       expr = ce.value;
    6619                 :            :       /* ??? expr has no valid location?  */
    6620                 :      27714 :       parens.skip_until_found_close (parser);
    6621                 :            :     }
    6622                 :            :   else
    6623                 :            :     {
    6624                 :          7 :       switch_cond_loc = UNKNOWN_LOCATION;
    6625                 :          7 :       expr = error_mark_node;
    6626                 :          7 :       ce.original_type = error_mark_node;
    6627                 :            :     }
    6628                 :      27721 :   c_start_case (switch_loc, switch_cond_loc, expr, explicit_cast_p);
    6629                 :      27721 :   save_break = c_break_label;
    6630                 :      27721 :   c_break_label = NULL_TREE;
    6631                 :      27721 :   location_t loc_after_labels;
    6632                 :      27721 :   bool open_brace_p = c_parser_peek_token (parser)->type == CPP_OPEN_BRACE;
    6633                 :      27721 :   body = c_parser_c99_block_statement (parser, if_p, &loc_after_labels);
    6634                 :      27721 :   location_t next_loc = c_parser_peek_token (parser)->location;
    6635                 :      27721 :   if (!open_brace_p && c_parser_peek_token (parser)->type != CPP_SEMICOLON)
    6636                 :        145 :     warn_for_multistatement_macros (loc_after_labels, next_loc, switch_loc,
    6637                 :            :                                     RID_SWITCH);
    6638                 :      27721 :   if (c_break_label)
    6639                 :            :     {
    6640                 :      25698 :       location_t here = c_parser_peek_token (parser)->location;
    6641                 :      25698 :       tree t = build1 (LABEL_EXPR, void_type_node, c_break_label);
    6642                 :      25698 :       SET_EXPR_LOCATION (t, here);
    6643                 :      25698 :       SWITCH_BREAK_LABEL_P (c_break_label) = 1;
    6644                 :      25698 :       append_to_statement_list_force (t, &body);
    6645                 :            :     }
    6646                 :      27721 :   c_finish_case (body, ce.original_type);
    6647                 :      27721 :   c_break_label = save_break;
    6648                 :      27721 :   add_stmt (c_end_compound_stmt (switch_loc, block, flag_isoc99));
    6649                 :      27721 :   c_parser_maybe_reclassify_token (parser);
    6650                 :      27721 : }
    6651                 :            : 
    6652                 :            : /* Parse a while statement (C90 6.6.5, C99 6.8.5, C11 6.8.5).
    6653                 :            : 
    6654                 :            :    while-statement:
    6655                 :            :       while (expression) statement
    6656                 :            : 
    6657                 :            :    IF_P is used to track whether there's a (possibly labeled) if statement
    6658                 :            :    which is not enclosed in braces and has an else clause.  This is used to
    6659                 :            :    implement -Wparentheses.  */
    6660                 :            : 
    6661                 :            : static void
    6662                 :      34350 : c_parser_while_statement (c_parser *parser, bool ivdep, unsigned short unroll,
    6663                 :            :                           bool *if_p)
    6664                 :            : {
    6665                 :      34350 :   tree block, cond, body, save_break, save_cont;
    6666                 :      34350 :   location_t loc;
    6667                 :      34350 :   gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE));
    6668                 :      34350 :   token_indent_info while_tinfo
    6669                 :      34350 :     = get_token_indent_info (c_parser_peek_token (parser));
    6670                 :      34350 :   c_parser_consume_token (parser);
    6671                 :      34350 :   block = c_begin_compound_stmt (flag_isoc99);
    6672                 :      34350 :   loc = c_parser_peek_token (parser)->location;
    6673                 :      34350 :   cond = c_parser_paren_condition (parser);
    6674                 :      34350 :   if (ivdep && cond != error_mark_node)
    6675                 :          3 :     cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
    6676                 :            :                    build_int_cst (integer_type_node,
    6677                 :          3 :                                   annot_expr_ivdep_kind),
    6678                 :            :                    integer_zero_node);
    6679                 :      34350 :   if (unroll && cond != error_mark_node)
    6680                 :          0 :     cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
    6681                 :            :                    build_int_cst (integer_type_node,
    6682                 :          0 :                                   annot_expr_unroll_kind),
    6683                 :            :                    build_int_cst (integer_type_node, unroll));
    6684                 :      34350 :   save_break = c_break_label;
    6685                 :      34350 :   c_break_label = NULL_TREE;
    6686                 :      34350 :   save_cont = c_cont_label;
    6687                 :      34350 :   c_cont_label = NULL_TREE;
    6688                 :            : 
    6689                 :      34350 :   token_indent_info body_tinfo
    6690                 :      34350 :     = get_token_indent_info (c_parser_peek_token (parser));
    6691                 :            : 
    6692                 :      34350 :   location_t loc_after_labels;
    6693                 :      34350 :   bool open_brace = c_parser_next_token_is (parser, CPP_OPEN_BRACE);
    6694                 :      34350 :   body = c_parser_c99_block_statement (parser, if_p, &loc_after_labels);
    6695                 :      34350 :   c_finish_loop (loc, loc, cond, UNKNOWN_LOCATION, NULL, body,
    6696                 :            :                  c_break_label, c_cont_label, true);
    6697                 :      34350 :   add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
    6698                 :      34350 :   c_parser_maybe_reclassify_token (parser);
    6699                 :            : 
    6700                 :      34350 :   token_indent_info next_tinfo
    6701                 :      34350 :     = get_token_indent_info (c_parser_peek_token (parser));
    6702                 :      34350 :   warn_for_misleading_indentation (while_tinfo, body_tinfo, next_tinfo);
    6703                 :            : 
    6704                 :      34350 :   if (next_tinfo.type != CPP_SEMICOLON && !open_brace)
    6705                 :       8682 :     warn_for_multistatement_macros (loc_after_labels, next_tinfo.location,
    6706                 :            :                                     while_tinfo.location, RID_WHILE);
    6707                 :            : 
    6708                 :      34350 :   c_break_label = save_break;
    6709                 :      34350 :   c_cont_label = save_cont;
    6710                 :      34350 : }
    6711                 :            : 
    6712                 :            : /* Parse a do statement (C90 6.6.5, C99 6.8.5, C11 6.8.5).
    6713                 :            : 
    6714                 :            :    do-statement:
    6715                 :            :      do statement while ( expression ) ;
    6716                 :            : */
    6717                 :            : 
    6718                 :            : static void
    6719                 :     109846 : c_parser_do_statement (c_parser *parser, bool ivdep, unsigned short unroll)
    6720                 :            : {
    6721                 :     109846 :   tree block, cond, body, save_break, save_cont, new_break, new_cont;
    6722                 :     109846 :   location_t loc;
    6723                 :     109846 :   gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO));
    6724                 :     109846 :   c_parser_consume_token (parser);
    6725                 :     109846 :   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    6726                 :         48 :     warning_at (c_parser_peek_token (parser)->location,
    6727                 :            :                 OPT_Wempty_body,
    6728                 :            :                 "suggest braces around empty body in %<do%> statement");
    6729                 :     109846 :   block = c_begin_compound_stmt (flag_isoc99);
    6730                 :     109846 :   loc = c_parser_peek_token (parser)->location;
    6731                 :     109846 :   save_break = c_break_label;
    6732                 :     109846 :   c_break_label = NULL_TREE;
    6733                 :     109846 :   save_cont = c_cont_label;
    6734                 :     109846 :   c_cont_label = NULL_TREE;
    6735                 :     109846 :   body = c_parser_c99_block_statement (parser, NULL);
    6736                 :     109846 :   c_parser_require_keyword (parser, RID_WHILE, "expected %<while%>");
    6737                 :     109846 :   new_break = c_break_label;
    6738                 :     109846 :   c_break_label = save_break;
    6739                 :     109846 :   new_cont = c_cont_label;
    6740                 :     109846 :   c_cont_label = save_cont;
    6741                 :     109846 :   location_t cond_loc = c_parser_peek_token (parser)->location;
    6742                 :     109846 :   cond = c_parser_paren_condition (parser);
    6743                 :     109846 :   if (ivdep && cond != error_mark_node)
    6744                 :          2 :     cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
    6745                 :            :                    build_int_cst (integer_type_node,
    6746                 :          2 :                                   annot_expr_ivdep_kind),
    6747                 :            :                    integer_zero_node);
    6748                 :     109846 :   if (unroll && cond != error_mark_node)
    6749                 :          3 :     cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
    6750                 :            :                    build_int_cst (integer_type_node,
    6751                 :          3 :                                   annot_expr_unroll_kind),
    6752                 :            :                    build_int_cst (integer_type_node, unroll));
    6753                 :     109846 :   if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
    6754                 :          0 :     c_parser_skip_to_end_of_block_or_statement (parser);
    6755                 :     109846 :   c_finish_loop (loc, cond_loc, cond, UNKNOWN_LOCATION, NULL, body,
    6756                 :            :                  new_break, new_cont, false);
    6757                 :     109846 :   add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
    6758                 :     109846 : }
    6759                 :            : 
    6760                 :            : /* Parse a for statement (C90 6.6.5, C99 6.8.5, C11 6.8.5).
    6761                 :            : 
    6762                 :            :    for-statement:
    6763                 :            :      for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
    6764                 :            :      for ( nested-declaration expression[opt] ; expression[opt] ) statement
    6765                 :            : 
    6766                 :            :    The form with a declaration is new in C99.
    6767                 :            : 
    6768                 :            :    ??? In accordance with the old parser, the declaration may be a
    6769                 :            :    nested function, which is then rejected in check_for_loop_decls,
    6770                 :            :    but does it make any sense for this to be included in the grammar?
    6771                 :            :    Note in particular that the nested function does not include a
    6772                 :            :    trailing ';', whereas the "declaration" production includes one.
    6773                 :            :    Also, can we reject bad declarations earlier and cheaper than
    6774                 :            :    check_for_loop_decls?
    6775                 :            : 
    6776                 :            :    In Objective-C, there are two additional variants:
    6777                 :            : 
    6778                 :            :    foreach-statement:
    6779                 :            :      for ( expression in expresssion ) statement
    6780                 :            :      for ( declaration in expression ) statement
    6781                 :            : 
    6782                 :            :    This is inconsistent with C, because the second variant is allowed
    6783                 :            :    even if c99 is not enabled.
    6784                 :            : 
    6785                 :            :    The rest of the comment documents these Objective-C foreach-statement.
    6786                 :            : 
    6787                 :            :    Here is the canonical example of the first variant:
    6788                 :            :     for (object in array)    { do something with object }
    6789                 :            :    we call the first expression ("object") the "object_expression" and 
    6790                 :            :    the second expression ("array") the "collection_expression".
    6791                 :            :    object_expression must be an lvalue of type "id" (a generic Objective-C
    6792                 :            :    object) because the loop works by assigning to object_expression the
    6793                 :            :    various objects from the collection_expression.  collection_expression
    6794                 :            :    must evaluate to something of type "id" which responds to the method
    6795                 :            :    countByEnumeratingWithState:objects:count:.
    6796                 :            : 
    6797                 :            :    The canonical example of the second variant is:
    6798                 :            :     for (id object in array)    { do something with object }
    6799                 :            :    which is completely equivalent to
    6800                 :            :     {
    6801                 :            :       id object;
    6802                 :            :       for (object in array) { do something with object }
    6803                 :            :     }
    6804                 :            :    Note that initizializing 'object' in some way (eg, "for ((object =
    6805                 :            :    xxx) in array) { do something with object }") is possibly
    6806                 :            :    technically valid, but completely pointless as 'object' will be
    6807                 :            :    assigned to something else as soon as the loop starts.  We should
    6808                 :            :    most likely reject it (TODO).
    6809                 :            : 
    6810                 :            :    The beginning of the Objective-C foreach-statement looks exactly
    6811                 :            :    like the beginning of the for-statement, and we can tell it is a
    6812                 :            :    foreach-statement only because the initial declaration or
    6813                 :            :    expression is terminated by 'in' instead of ';'.
    6814                 :            : 
    6815                 :            :    IF_P is used to track whether there's a (possibly labeled) if statement
    6816                 :            :    which is not enclosed in braces and has an else clause.  This is used to
    6817                 :            :    implement -Wparentheses.  */
    6818                 :            : 
    6819                 :            : static void
    6820                 :     218715 : c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
    6821                 :            :                         bool *if_p)
    6822                 :            : {
    6823                 :     218715 :   tree block, cond, incr, save_break, save_cont, body;
    6824                 :            :   /* The following are only used when parsing an ObjC foreach statement.  */
    6825                 :     218715 :   tree object_expression;
    6826                 :            :   /* Silence the bogus uninitialized warning.  */
    6827                 :     218715 :   tree collection_expression = NULL;
    6828                 :     218715 :   location_t loc = c_parser_peek_token (parser)->location;
    6829                 :     218715 :   location_t for_loc = loc;
    6830                 :     218715 :   location_t cond_loc = UNKNOWN_LOCATION;
    6831                 :     218715 :   location_t incr_loc = UNKNOWN_LOCATION;
    6832                 :     218715 :   bool is_foreach_statement = false;
    6833                 :     218715 :   gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR));
    6834                 :     218715 :   token_indent_info for_tinfo
    6835                 :     218715 :     = get_token_indent_info (c_parser_peek_token (parser));
    6836                 :     218715 :   c_parser_consume_token (parser);
    6837                 :            :   /* Open a compound statement in Objective-C as well, just in case this is
    6838                 :            :      as foreach expression.  */
    6839                 :     218715 :   block = c_begin_compound_stmt (flag_isoc99 || c_dialect_objc ());
    6840                 :     218715 :   cond = error_mark_node;
    6841                 :     218715 :   incr = error_mark_node;
    6842                 :     218715 :   matching_parens parens;
    6843                 :     218715 :   if (parens.require_open (parser))
    6844                 :            :     {
    6845                 :            :       /* Parse the initialization declaration or expression.  */
    6846                 :     218714 :       object_expression = error_mark_node;
    6847                 :     218714 :       parser->objc_could_be_foreach_context = c_dialect_objc ();
    6848                 :     218714 :       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    6849                 :            :         {
    6850                 :       8584 :           parser->objc_could_be_foreach_context = false;
    6851                 :       8584 :           c_parser_consume_token (parser);
    6852                 :       8584 :           c_finish_expr_stmt (loc, NULL_TREE);
    6853                 :            :         }
    6854                 :     210130 :       else if (c_parser_next_tokens_start_declaration (parser)
    6855                 :     210130 :                || c_parser_nth_token_starts_std_attributes (parser, 1))
    6856                 :            :         {
    6857                 :       7165 :           c_parser_declaration_or_fndef (parser, true, true, true, true, true, 
    6858                 :            :                                          &object_expression, vNULL);
    6859                 :       7165 :           parser->objc_could_be_foreach_context = false;
    6860                 :            :           
    6861                 :       7165 :           if (c_parser_next_token_is_keyword (parser, RID_IN))
    6862                 :            :             {
    6863                 :          0 :               c_parser_consume_token (parser);
    6864                 :          0 :               is_foreach_statement = true;
    6865                 :          0 :               if (check_for_loop_decls (for_loc, true) == NULL_TREE)
    6866                 :          0 :                 c_parser_error (parser, "multiple iterating variables in "
    6867                 :            :                                         "fast enumeration");
    6868                 :            :             }
    6869                 :            :           else
    6870                 :       7165 :             check_for_loop_decls (for_loc, flag_isoc99);
    6871                 :            :         }
    6872                 :     202965 :       else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
    6873                 :            :         {
    6874                 :            :           /* __extension__ can start a declaration, but is also an
    6875                 :            :              unary operator that can start an expression.  Consume all
    6876                 :            :              but the last of a possible series of __extension__ to
    6877                 :            :              determine which.  */
    6878                 :          0 :           while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
    6879                 :          0 :                  && (c_parser_peek_2nd_token (parser)->keyword
    6880                 :            :                      == RID_EXTENSION))
    6881                 :          0 :             c_parser_consume_token (parser);
    6882                 :          0 :           if (c_token_starts_declaration (c_parser_peek_2nd_token (parser))
    6883                 :          0 :               || c_parser_nth_token_starts_std_attributes (parser, 2))
    6884                 :            :             {
    6885                 :          0 :               int ext;
    6886                 :          0 :               ext = disable_extension_diagnostics ();
    6887                 :          0 :               c_parser_consume_token (parser);
    6888                 :          0 :               c_parser_declaration_or_fndef (parser, true, true, true, true,
    6889                 :            :                                              true, &object_expression, vNULL);
    6890                 :          0 :               parser->objc_could_be_foreach_context = false;
    6891                 :            :               
    6892                 :          0 :               restore_extension_diagnostics (ext);
    6893                 :          0 :               if (c_parser_next_token_is_keyword (parser, RID_IN))
    6894                 :            :                 {
    6895                 :          0 :                   c_parser_consume_token (parser);
    6896                 :          0 :                   is_foreach_statement = true;
    6897                 :          0 :                   if (check_for_loop_decls (for_loc, true) == NULL_TREE)
    6898                 :          0 :                     c_parser_error (parser, "multiple iterating variables in "
    6899                 :            :                                             "fast enumeration");
    6900                 :            :                 }
    6901                 :            :               else
    6902                 :          0 :                 check_for_loop_decls (for_loc, flag_isoc99);
    6903                 :            :             }
    6904                 :            :           else
    6905                 :          0 :             goto init_expr;
    6906                 :            :         }
    6907                 :            :       else
    6908                 :            :         {
    6909                 :     202965 :         init_expr:
    6910                 :     202965 :           {
    6911                 :     202965 :             struct c_expr ce;
    6912                 :     202965 :             tree init_expression;
    6913                 :     202965 :             ce = c_parser_expression (parser);
    6914                 :     202965 :             init_expression = ce.value;
    6915                 :     202965 :             parser->objc_could_be_foreach_context = false;
    6916                 :     202965 :             if (c_parser_next_token_is_keyword (parser, RID_IN))
    6917                 :            :               {
    6918                 :          0 :                 c_parser_consume_token (parser);
    6919                 :          0 :                 is_foreach_statement = true;
    6920                 :          0 :                 if (! lvalue_p (init_expression))
    6921                 :          0 :                   c_parser_error (parser, "invalid iterating variable in "
    6922                 :            :                                           "fast enumeration");
    6923                 :          0 :                 object_expression
    6924                 :          0 :                   = c_fully_fold (init_expression, false, NULL);
    6925                 :            :               }
    6926                 :            :             else
    6927                 :            :               {
    6928                 :     202965 :                 ce = convert_lvalue_to_rvalue (loc, ce, true, false);
    6929                 :     202965 :                 init_expression = ce.value;
    6930                 :     202965 :                 c_finish_expr_stmt (loc, init_expression);
    6931                 :     202965 :                 c_parser_skip_until_found (parser, CPP_SEMICOLON,
    6932                 :            :                                            "expected %<;%>");
    6933                 :            :               }
    6934                 :            :           }
    6935                 :            :         }
    6936                 :            :       /* Parse the loop condition.  In the case of a foreach
    6937                 :            :          statement, there is no loop condition.  */
    6938                 :     218714 :       gcc_assert (!parser->objc_could_be_foreach_context);
    6939                 :     218714 :       if (!is_foreach_statement)
    6940                 :            :         {
    6941                 :     218714 :           cond_loc = c_parser_peek_token (parser)->location;
    6942                 :     218714 :           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    6943                 :            :             {
    6944                 :       2515 :               if (ivdep)
    6945                 :            :                 {
    6946                 :          1 :                   c_parser_error (parser, "missing loop condition in loop "
    6947                 :            :                                           "with %<GCC ivdep%> pragma");
    6948                 :          1 :                   cond = error_mark_node;
    6949                 :            :                 }
    6950                 :       2514 :               else if (unroll)
    6951                 :            :                 {
    6952                 :          0 :                   c_parser_error (parser, "missing loop condition in loop "
    6953                 :            :                                           "with %<GCC unroll%> pragma");
    6954                 :          0 :                   cond = error_mark_node;
    6955                 :            :                 }
    6956                 :            :               else
    6957                 :            :                 {
    6958                 :       2514 :                   c_parser_consume_token (parser);
    6959                 :       2514 :                   cond = NULL_TREE;
    6960                 :            :                 }
    6961                 :            :             }
    6962                 :            :           else
    6963                 :            :             {
    6964                 :     216199 :               cond = c_parser_condition (parser);
    6965                 :     216199 :               c_parser_skip_until_found (parser, CPP_SEMICOLON,
    6966                 :            :                                          "expected %<;%>");
    6967                 :            :             }
    6968                 :     218714 :           if (ivdep && cond != error_mark_node)
    6969                 :        115 :             cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
    6970                 :            :                            build_int_cst (integer_type_node,
    6971                 :        115 :                                           annot_expr_ivdep_kind),
    6972                 :            :                            integer_zero_node);
    6973                 :     218714 :           if (unroll && cond != error_mark_node)
    6974                 :         31 :             cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
    6975                 :            :                            build_int_cst (integer_type_node,
    6976                 :         31 :                                           annot_expr_unroll_kind),
    6977                 :            :                            build_int_cst (integer_type_node, unroll));
    6978                 :            :         }
    6979                 :            :       /* Parse the increment expression (the third expression in a
    6980                 :            :          for-statement).  In the case of a foreach-statement, this is
    6981                 :            :          the expression that follows the 'in'.  */
    6982                 :     218714 :       loc = incr_loc = c_parser_peek_token (parser)->location;
    6983                 :     218714 :       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    6984                 :            :         {
    6985                 :       3328 :           if (is_foreach_statement)
    6986                 :            :             {
    6987                 :          0 :               c_parser_error (parser,
    6988                 :            :                               "missing collection in fast enumeration");
    6989                 :          0 :               collection_expression = error_mark_node;
    6990                 :            :             }
    6991                 :            :           else
    6992                 :       3328 :             incr = c_process_expr_stmt (loc, NULL_TREE);
    6993                 :            :         }
    6994                 :            :       else
    6995                 :            :         {
    6996                 :     215386 :           if (is_foreach_statement)
    6997                 :          0 :             collection_expression
    6998                 :          0 :               = c_fully_fold (c_parser_expression (parser).value, false, NULL);
    6999                 :            :           else
    7000                 :            :             {
    7001                 :     215386 :               struct c_expr ce = c_parser_expression (parser);
    7002                 :     215386 :               ce = convert_lvalue_to_rvalue (loc, ce, true, false);
    7003                 :     215386 :               incr = c_process_expr_stmt (loc, ce.value);
    7004                 :            :             }
    7005                 :            :         }
    7006                 :     218714 :       parens.skip_until_found_close (parser);
    7007                 :            :     }
    7008                 :     218715 :   save_break = c_break_label;
    7009                 :     218715 :   c_break_label = NULL_TREE;
    7010                 :     218715 :   save_cont = c_cont_label;
    7011                 :     218715 :   c_cont_label = NULL_TREE;
    7012                 :            : 
    7013                 :     218715 :   token_indent_info body_tinfo
    7014                 :     218715 :     = get_token_indent_info (c_parser_peek_token (parser));
    7015                 :            : 
    7016                 :     218715 :   location_t loc_after_labels;
    7017                 :     218715 :   bool open_brace = c_parser_next_token_is (parser, CPP_OPEN_BRACE);
    7018                 :     218715 :   body = c_parser_c99_block_statement (parser, if_p, &loc_after_labels);
    7019                 :            : 
    7020                 :     218715 :   if (is_foreach_statement)
    7021                 :          0 :     objc_finish_foreach_loop (for_loc, object_expression,
    7022                 :            :                               collection_expression, body, c_break_label,
    7023                 :            :                               c_cont_label);
    7024                 :            :   else
    7025                 :     218715 :     c_finish_loop (for_loc, cond_loc, cond, incr_loc, incr, body,
    7026                 :            :                    c_break_label, c_cont_label, true);
    7027                 :     218715 :   add_stmt (c_end_compound_stmt (for_loc, block,
    7028                 :     218715 :                                  flag_isoc99 || c_dialect_objc ()));
    7029                 :     218715 :   c_parser_maybe_reclassify_token (parser);
    7030                 :            : 
    7031                 :     218715 :   token_indent_info next_tinfo
    7032                 :     218715 :     = get_token_indent_info (c_parser_peek_token (parser));
    7033                 :     218715 :   warn_for_misleading_indentation (for_tinfo, body_tinfo, next_tinfo);
    7034                 :            : 
    7035                 :     218715 :   if (next_tinfo.type != CPP_SEMICOLON && !open_brace)
    7036                 :     138338 :     warn_for_multistatement_macros (loc_after_labels, next_tinfo.location,
    7037                 :            :                                     for_tinfo.location, RID_FOR);
    7038                 :            : 
    7039                 :     218715 :   c_break_label = save_break;
    7040                 :     218715 :   c_cont_label = save_cont;
    7041                 :     218715 : }
    7042                 :            : 
    7043                 :            : /* Parse an asm statement, a GNU extension.  This is a full-blown asm
    7044                 :            :    statement with inputs, outputs, clobbers, and volatile, inline, and goto
    7045                 :            :    tags allowed.
    7046                 :            : 
    7047                 :            :    asm-qualifier:
    7048                 :            :      volatile
    7049                 :            :      inline
    7050                 :            :      goto
    7051                 :            : 
    7052                 :            :    asm-qualifier-list:
    7053                 :            :      asm-qualifier-list asm-qualifier
    7054                 :            :      asm-qualifier
    7055                 :            : 
    7056                 :            :    asm-statement:
    7057                 :            :      asm asm-qualifier-list[opt] ( asm-argument ) ;
    7058                 :            : 
    7059                 :            :    asm-argument:
    7060                 :            :      asm-string-literal
    7061                 :            :      asm-string-literal : asm-operands[opt]
    7062                 :            :      asm-string-literal : asm-operands[opt] : asm-operands[opt]
    7063                 :            :      asm-string-literal : asm-operands[opt] : asm-operands[opt] \
    7064                 :            :        : asm-clobbers[opt]
    7065                 :            :      asm-string-literal : : asm-operands[opt] : asm-clobbers[opt] \
    7066                 :            :        : asm-goto-operands
    7067                 :            : 
    7068                 :            :    The form with asm-goto-operands is valid if and only if the
    7069                 :            :    asm-qualifier-list contains goto, and is the only allowed form in that case.
    7070                 :            :    Duplicate asm-qualifiers are not allowed.
    7071                 :            : 
    7072                 :            :    The :: token is considered equivalent to two consecutive : tokens.  */
    7073                 :            : 
    7074                 :            : static tree
    7075                 :     150469 : c_parser_asm_statement (c_parser *parser)
    7076                 :            : {
    7077                 :     150469 :   tree str, outputs, inputs, clobbers, labels, ret;
    7078                 :     150469 :   bool simple;
    7079                 :     150469 :   location_t asm_loc = c_parser_peek_token (parser)->location;
    7080                 :     150469 :   int section, nsections;
    7081                 :            : 
    7082                 :     150469 :   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
    7083                 :     150469 :   c_parser_consume_token (parser);
    7084                 :            : 
    7085                 :            :   /* Handle the asm-qualifier-list.  */
    7086                 :     150469 :   location_t volatile_loc = UNKNOWN_LOCATION;
    7087                 :     150469 :   location_t inline_loc = UNKNOWN_LOCATION;
    7088                 :     150469 :   location_t goto_loc = UNKNOWN_LOCATION;
    7089                 :     260149 :   for (;;)
    7090                 :            :     {
    7091                 :     260149 :       c_token *token = c_parser_peek_token (parser);
    7092                 :     260149 :       location_t loc = token->location;
    7093                 :     260149 :       switch (token->keyword)
    7094                 :            :         {
    7095                 :     109447 :         case RID_VOLATILE:
    7096                 :     109447 :           if (volatile_loc)
    7097                 :            :             {
    7098                 :          6 :               error_at (loc, "duplicate %<asm%> qualifier %qE", token->value);
    7099                 :          6 :               inform (volatile_loc, "first seen here");
    7100                 :            :             }
    7101                 :            :           else
    7102                 :            :             volatile_loc = loc;
    7103                 :     109447 :           c_parser_consume_token (parser);
    7104                 :     109447 :           continue;
    7105                 :            : 
    7106                 :         38 :         case RID_INLINE:
    7107                 :         38 :           if (inline_loc)
    7108                 :            :             {
    7109                 :          6 :               error_at (loc, "duplicate %<asm%> qualifier %qE", token->value);
    7110                 :          6 :               inform (inline_loc, "first seen here");
    7111                 :            :             }
    7112                 :            :           else
    7113                 :            :             inline_loc = loc;
    7114                 :         38 :           c_parser_consume_token (parser);
    7115                 :         38 :           continue;
    7116                 :            : 
    7117                 :        193 :         case RID_GOTO:
    7118                 :        193 :           if (goto_loc)
    7119                 :            :             {
    7120                 :          6 :               error_at (loc, "duplicate %<asm%> qualifier %qE", token->value);
    7121                 :          6 :               inform (goto_loc, "first seen here");
    7122                 :            :             }
    7123                 :            :           else
    7124                 :            :             goto_loc = loc;
    7125                 :        193 :           c_parser_consume_token (parser);
    7126                 :        193 :           continue;
    7127                 :            : 
    7128                 :          2 :         case RID_CONST:
    7129                 :          2 :         case RID_RESTRICT:
    7130                 :          2 :           error_at (loc, "%qE is not a valid %<asm%> qualifier", token->value);
    7131                 :          2 :           c_parser_consume_token (parser);
    7132                 :          2 :           continue;
    7133                 :            : 
    7134                 :     150469 :         default:
    7135                 :     150469 :           break;
    7136                 :            :         }
    7137                 :     150469 :       break;
    7138                 :            :     }
    7139                 :            : 
    7140                 :     150469 :   bool is_volatile = (volatile_loc != UNKNOWN_LOCATION);
    7141                 :     150469 :   bool is_inline = (inline_loc != UNKNOWN_LOCATION);
    7142                 :     150469 :   bool is_goto = (goto_loc != UNKNOWN_LOCATION);
    7143                 :            : 
    7144                 :     150469 :   ret = NULL;
    7145                 :            : 
    7146                 :     150469 :   matching_parens parens;
    7147                 :     150469 :   if (!parens.require_open (parser))
    7148                 :          0 :     goto error;
    7149                 :            : 
    7150                 :     150469 :   str = c_parser_asm_string_literal (parser);
    7151                 :     150469 :   if (str == NULL_TREE)
    7152                 :         12 :     goto error_close_paren;
    7153                 :            : 
    7154                 :     150457 :   simple = true;
    7155                 :     150457 :   outputs = NULL_TREE;
    7156                 :     150457 :   inputs = NULL_TREE;
    7157                 :     150457 :   clobbers = NULL_TREE;
    7158                 :     150457 :   labels = NULL_TREE;
    7159                 :            : 
    7160                 :     150457 :   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN) && !is_goto)
    7161                 :       1388 :     goto done_asm;
    7162                 :            : 
    7163                 :            :   /* Parse each colon-delimited section of operands.  */
    7164                 :     149069 :   nsections = 3 + is_goto;
    7165                 :     380638 :   for (section = 0; section < nsections; ++section)
    7166                 :            :     {
    7167                 :     380462 :       if (c_parser_next_token_is (parser, CPP_SCOPE))
    7168                 :            :         {
    7169                 :      30042 :           ++section;
    7170                 :      30042 :           if (section == nsections)
    7171                 :            :             {
    7172                 :          5 :               c_parser_error (parser, "expected %<)%>");
    7173                 :          5 :               goto error_close_paren;
    7174                 :            :             }
    7175                 :      30037 :           c_parser_consume_token (parser);
    7176                 :            :         }
    7177                 :     700288 :       else if (!c_parser_require (parser, CPP_COLON,
    7178                 :            :                                   is_goto
    7179                 :            :                                   ? G_("expected %<:%>")
    7180                 :            :                                   : G_("expected %<:%> or %<)%>"),
    7181                 :            :                                   UNKNOWN_LOCATION, is_goto))
    7182                 :          8 :         goto error_close_paren;
    7183                 :            : 
    7184                 :            :       /* Once past any colon, we're no longer a simple asm.  */
    7185                 :     380449 :       simple = false;
    7186                 :            : 
    7187                 :     380449 :       if ((!c_parser_next_token_is (parser, CPP_COLON)
    7188                 :     310231 :            && !c_parser_next_token_is (parser, CPP_SCOPE)
    7189                 :     310182 :            && !c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    7190                 :     380546 :           || section == 3)
    7191                 :     310135 :         switch (section)
    7192                 :            :           {
    7193                 :      96632 :           case 0:
    7194                 :            :             /* For asm goto, we don't allow output operands, but reserve
    7195                 :            :                the slot for a future extension that does allow them.  */
    7196                 :      96632 :             if (!is_goto)
    7197                 :      96630 :               outputs = c_parser_asm_operands (parser);
    7198                 :            :             break;
    7199                 :      97307 :           case 1:
    7200                 :      97307 :             inputs = c_parser_asm_operands (parser);
    7201                 :      97307 :             break;
    7202                 :     116020 :           case 2:
    7203                 :     116020 :             clobbers = c_parser_asm_clobbers (parser);
    7204                 :     116020 :             break;
    7205                 :        176 :           case 3:
    7206                 :        176 :             labels = c_parser_asm_goto_operands (parser);
    7207                 :        176 :             break;
    7208                 :          0 :           default:
    7209                 :          0 :             gcc_unreachable ();
    7210                 :            :           }
    7211                 :            : 
    7212                 :     380449 :       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN) && !is_goto)
    7213                 :     148880 :         goto done_asm;
    7214                 :            :     }
    7215                 :            : 
    7216                 :        176 :  done_asm:
    7217                 :     150444 :   if (!parens.require_close (parser))
    7218                 :            :     {
    7219                 :          0 :       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
    7220                 :          0 :       goto error;
    7221                 :            :     }
    7222                 :            : 
    7223                 :     150444 :   if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
    7224                 :          0 :     c_parser_skip_to_end_of_block_or_statement (parser);
    7225                 :            : 
    7226                 :     150444 :   ret = build_asm_stmt (is_volatile,
    7227                 :            :                         build_asm_expr (asm_loc, str, outputs, inputs,
    7228                 :            :                                         clobbers, labels, simple, is_inline));
    7229                 :            : 
    7230                 :     150469 :  error:
    7231                 :     150469 :   return ret;
    7232                 :            : 
    7233                 :         25 :  error_close_paren:
    7234                 :         25 :   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
    7235                 :         25 :   goto error;
    7236                 :            : }
    7237                 :            : 
    7238                 :            : /* Parse asm operands, a GNU extension.
    7239                 :            : 
    7240                 :            :    asm-operands:
    7241                 :            :      asm-operand
    7242                 :            :      asm-operands , asm-operand
    7243                 :            : 
    7244                 :            :    asm-operand:
    7245                 :            :      asm-string-literal ( expression )
    7246                 :            :      [ identifier ] asm-string-literal ( expression )
    7247                 :            : */
    7248                 :            : 
    7249                 :            : static tree
    7250                 :     193937 : c_parser_asm_operands (c_parser *parser)
    7251                 :            : {
    7252                 :     193937 :   tree list = NULL_TREE;
    7253                 :     834393 :   while (true)
    7254                 :            :     {
    7255                 :     514165 :       tree name, str;
    7256                 :     514165 :       struct c_expr expr;
    7257                 :     514165 :       if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
    7258                 :            :         {
    7259                 :        418 :           c_parser_consume_token (parser);
    7260                 :        418 :           if (c_parser_next_token_is (parser, CPP_NAME))
    7261                 :            :             {
    7262                 :        418 :               tree id = c_parser_peek_token (parser)->value;
    7263                 :        418 :               c_parser_consume_token (parser);
    7264                 :        418 :               name = build_string (IDENTIFIER_LENGTH (id),
    7265                 :        418 :                                    IDENTIFIER_POINTER (id));
    7266                 :            :             }
    7267                 :            :           else
    7268                 :            :             {
    7269                 :          0 :               c_parser_error (parser, "expected identifier");
    7270                 :          0 :               c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
    7271                 :          0 :               return NULL_TREE;
    7272                 :            :             }
    7273                 :        418 :           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
    7274                 :            :                                      "expected %<]%>");
    7275                 :            :         }
    7276                 :            :       else
    7277                 :            :         name = NULL_TREE;
    7278                 :     514165 :       str = c_parser_asm_string_literal (parser);
    7279                 :     514165 :       if (str == NULL_TREE)
    7280                 :            :         return NULL_TREE;
    7281                 :     514165 :       matching_parens parens;
    7282                 :     514165 :       if (!parens.require_open (parser))
    7283                 :            :         return NULL_TREE;
    7284                 :     514165 :       expr = c_parser_expression (parser);
    7285                 :     514165 :       mark_exp_read (expr.value);
    7286                 :     514165 :       if (!parens.require_close (parser))
    7287                 :            :         {
    7288                 :          0 :           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
    7289                 :          0 :           return NULL_TREE;
    7290                 :            :         }
    7291                 :     514165 :       list = chainon (list, build_tree_list (build_tree_list (name, str),
    7292                 :            :                                              expr.value));
    7293                 :     514165 :       if (c_parser_next_token_is (parser, CPP_COMMA))
    7294                 :     320228 :         c_parser_consume_token (parser);
    7295                 :            :       else
    7296                 :            :         break;
    7297                 :     320228 :     }
    7298                 :     193937 :   return list;
    7299                 :            : }
    7300                 :            : 
    7301                 :            : /* Parse asm clobbers, a GNU extension.
    7302                 :            : 
    7303                 :            :    asm-clobbers:
    7304                 :            :      asm-string-literal
    7305                 :            :      asm-clobbers , asm-string-literal
    7306                 :            : */
    7307                 :            : 
    7308                 :            : static tree
    7309                 :     116020 : c_parser_asm_clobbers (c_parser *parser)
    7310                 :            : {
    7311                 :     116020 :   tree list = NULL_TREE;
    7312                 :     166004 :   while (true)
    7313                 :            :     {
    7314                 :     141012 :       tree str = c_parser_asm_string_literal (parser);
    7315                 :     141012 :       if (str)
    7316                 :     141012 :         list = tree_cons (NULL_TREE, str, list);
    7317                 :            :       else
    7318                 :            :         return NULL_TREE;
    7319                 :     141012 :       if (c_parser_next_token_is (parser, CPP_COMMA))
    7320                 :      24992 :         c_parser_consume_token (parser);
    7321                 :            :       else
    7322                 :            :         break;
    7323                 :      24992 :     }
    7324                 :            :   return list;
    7325                 :            : }
    7326                 :            : 
    7327                 :            : /* Parse asm goto labels, a GNU extension.
    7328                 :            : 
    7329                 :            :    asm-goto-operands:
    7330                 :            :      identifier
    7331                 :            :      asm-goto-operands , identifier
    7332                 :            : */
    7333                 :            : 
    7334                 :            : static tree
    7335                 :        176 : c_parser_asm_goto_operands (c_parser *parser)
    7336                 :            : {
    7337                 :        176 :   tree list = NULL_TREE;
    7338                 :        354 :   while (true)
    7339                 :            :     {
    7340                 :        265 :       tree name, label;
    7341                 :            : 
    7342                 :        265 :       if (c_parser_next_token_is (parser, CPP_NAME))
    7343                 :            :         {
    7344                 :        264 :           c_token *tok = c_parser_peek_token (parser);
    7345                 :        264 :           name = tok->value;
    7346                 :        264 :           label = lookup_label_for_goto (tok->location, name);
    7347                 :        264 :           c_parser_consume_token (parser);
    7348                 :        264 :           TREE_USED (label) = 1;
    7349                 :            :         }
    7350                 :            :       else
    7351                 :            :         {
    7352                 :          1 :           c_parser_error (parser, "expected identifier");
    7353                 :          1 :           return NULL_TREE;
    7354                 :            :         }
    7355                 :            : 
    7356                 :        264 :       name = build_string (IDENTIFIER_LENGTH (name),
    7357                 :        264 :                            IDENTIFIER_POINTER (name));
    7358                 :        264 :       list = tree_cons (name, label, list);
    7359                 :        264 :       if (c_parser_next_token_is (parser, CPP_COMMA))
    7360                 :         89 :         c_parser_consume_token (parser);
    7361                 :            :       else
    7362                 :        175 :         return nreverse (list);
    7363                 :         89 :     }
    7364                 :            : }
    7365                 :            : 
    7366                 :            : /* Parse a possibly concatenated sequence of string literals.
    7367                 :            :    TRANSLATE says whether to translate them to the execution character
    7368                 :            :    set; WIDE_OK says whether any kind of prefixed string literal is
    7369                 :            :    permitted in this context.  This code is based on that in
    7370                 :            :    lex_string.  */
    7371                 :            : 
    7372                 :            : struct c_expr
    7373                 :    2560970 : c_parser_string_literal (c_parser *parser, bool translate, bool wide_ok)
    7374                 :            : {
    7375                 :    2560970 :   struct c_expr ret;
    7376                 :    2560970 :   size_t count;
    7377                 :    2560970 :   struct obstack str_ob;
    7378                 :    2560970 :   struct obstack loc_ob;
    7379                 :    2560970 :   cpp_string str, istr, *strs;
    7380                 :    2560970 :   c_token *tok;
    7381                 :    2560970 :   location_t loc, last_tok_loc;
    7382                 :    2560970 :   enum cpp_ttype type;
    7383                 :    2560970 :   tree value, string_tree;
    7384                 :            : 
    7385                 :    2560970 :   tok = c_parser_peek_token (parser);
    7386                 :    2560970 :   loc = tok->location;
    7387                 :    2560970 :   last_tok_loc = linemap_resolve_location (line_table, loc,
    7388                 :            :                                            LRK_MACRO_DEFINITION_LOCATION,
    7389                 :            :                                            NULL);
    7390                 :    2560970 :   type = tok->type;
    7391                 :    2560970 :   switch (type)
    7392                 :            :     {
    7393                 :    2560960 :     case CPP_STRING:
    7394                 :    2560960 :     case CPP_WSTRING:
    7395                 :    2560960 :     case CPP_STRING16:
    7396                 :    2560960 :     case CPP_STRING32:
    7397                 :    2560960 :     case CPP_UTF8STRING:
    7398                 :    2560960 :       string_tree = tok->value;
    7399                 :    2560960 :       break;
    7400                 :            : 
    7401                 :         15 :     default:
    7402                 :         15 :       c_parser_error (parser, "expected string literal");
    7403                 :         15 :       ret.set_error ();
    7404                 :         15 :       ret.value = NULL_TREE;
    7405                 :         15 :       ret.original_code = ERROR_MARK;
    7406                 :         15 :       ret.original_type = NULL_TREE;
    7407                 :         15 :       return ret;
    7408                 :            :     }
    7409                 :            : 
    7410                 :            :   /* Try to avoid the overhead of creating and destroying an obstack
    7411                 :            :      for the common case of just one string.  */
    7412                 :    2560960 :   switch (c_parser_peek_2nd_token (parser)->type)
    7413                 :            :     {
    7414                 :    1968060 :     default:
    7415                 :    1968060 :       c_parser_consume_token (parser);
    7416                 :    1968060 :       str.text = (const unsigned char *) TREE_STRING_POINTER (string_tree);
    7417                 :    1968060 :       str.len = TREE_STRING_LENGTH (string_tree);
    7418                 :    1968060 :       count = 1;
    7419                 :    1968060 :       strs = &str;
    7420                 :    1968060 :       break;
    7421                 :            : 
    7422                 :     592893 :     case CPP_STRING:
    7423                 :     592893 :     case CPP_WSTRING:
    7424                 :     592893 :     case CPP_STRING16:
    7425                 :     592893 :     case CPP_STRING32:
    7426                 :     592893 :     case CPP_UTF8STRING:
    7427                 :     592893 :       gcc_obstack_init (&str_ob);
    7428                 :     592893 :       gcc_obstack_init (&loc_ob);
    7429                 :     592893 :       count = 0;
    7430                 :   27293000 :       do
    7431                 :            :         {
    7432                 :   27293000 :           c_parser_consume_token (parser);
    7433                 :   27293000 :           count++;
    7434                 :   27293000 :           str.text = (const unsigned char *) TREE_STRING_POINTER (string_tree);
    7435                 :   27293000 :           str.len = TREE_STRING_LENGTH (string_tree);
    7436                 :   27293000 :           if (type != tok->type)
    7437                 :            :             {
    7438                 :        595 :               if (type == CPP_STRING)
    7439                 :         29 :                 type = tok->type;
    7440                 :        566 :               else if (tok->type != CPP_STRING)
    7441                 :         30 :                 error ("unsupported non-standard concatenation "
    7442                 :            :                        "of string literals");
    7443                 :            :             }
    7444                 :   27293000 :           obstack_grow (&str_ob, &str, sizeof (cpp_string));
    7445                 :   27293000 :           obstack_grow (&loc_ob, &last_tok_loc, sizeof (location_t));
    7446                 :   27293000 :           tok = c_parser_peek_token (parser);
    7447                 :   27293000 :           string_tree = tok->value;
    7448                 :   27293000 :           last_tok_loc
    7449                 :   27293000 :             = linemap_resolve_location (line_table, tok->location,
    7450                 :            :                                         LRK_MACRO_DEFINITION_LOCATION, NULL);
    7451                 :            :         }
    7452                 :   27293000 :       while (tok->type == CPP_STRING
    7453                 :            :              || tok->type == CPP_WSTRING
    7454                 :            :              || tok->type == CPP_STRING16
    7455                 :            :              || tok->type == CPP_STRING32
    7456                 :   27293000 :              || tok->type == CPP_UTF8STRING);
    7457                 :     592893 :       strs = (cpp_string *) obstack_finish (&str_ob);
    7458                 :            :     }
    7459                 :            : 
    7460                 :    2560960 :   if (count > 1 && !in_system_header_at (input_location))
    7461                 :     510746 :     warning (OPT_Wtraditional,
    7462                 :            :              "traditional C rejects string constant concatenation");
    7463                 :            : 
    7464                 :    2560960 :   if ((type == CPP_STRING || wide_ok)
    7465                 :    5121900 :       && ((translate
    7466                 :    2560950 :           ? cpp_interpret_string : cpp_interpret_string_notranslate)
    7467                 :    2560950 :           (parse_in, strs, count, &istr, type)))
    7468                 :            :     {
    7469                 :    2560950 :       value = build_string (istr.len, (const char *) istr.text);
    7470                 :    2560950 :       free (CONST_CAST (unsigned char *, istr.text));
    7471                 :    2560950 :       if (count > 1)
    7472                 :            :         {
    7473                 :     592893 :           location_t *locs = (location_t *) obstack_finish (&loc_ob);
    7474                 :     592893 :           gcc_assert (g_string_concat_db);
    7475                 :     592893 :           g_string_concat_db->record_string_concatenation (count, locs);
    7476                 :            :         }
    7477                 :            :     }
    7478                 :            :   else
    7479                 :            :     {
    7480                 :         10 :       if (type != CPP_STRING && !wide_ok)
    7481                 :            :         {
    7482                 :         10 :           error_at (loc, "a wide string is invalid in this context");
    7483                 :         10 :           type = CPP_STRING;
    7484                 :            :         }
    7485                 :            :       /* Callers cannot generally handle error_mark_node in this
    7486                 :            :          context, so return the empty string instead.  An error has
    7487                 :            :          been issued, either above or from cpp_interpret_string.  */
    7488                 :         10 :       switch (type)
    7489                 :            :         {
    7490                 :         10 :         default:
    7491                 :         10 :         case CPP_STRING:
    7492                 :         10 :         case CPP_UTF8STRING:
    7493                 :         10 :           value = build_string (1, "");
    7494                 :         10 :           break;
    7495                 :          0 :         case CPP_STRING16:
    7496                 :          0 :           value = build_string (TYPE_PRECISION (char16_type_node)
    7497                 :          0 :                                 / TYPE_PRECISION (char_type_node),
    7498                 :            :                                 "\0");  /* char16_t is 16 bits */
    7499                 :          0 :           break;
    7500                 :          0 :         case CPP_STRING32:
    7501                 :          0 :           value = build_string (TYPE_PRECISION (char32_type_node)
    7502                 :          0 :                                 / TYPE_PRECISION (char_type_node),
    7503                 :            :                                 "\0\0\0");  /* char32_t is 32 bits */
    7504                 :          0 :           break;
    7505                 :          0 :         case CPP_WSTRING:
    7506                 :          0 :           value = build_string (TYPE_PRECISION (wchar_type_node)
    7507                 :          0 :                                 / TYPE_PRECISION (char_type_node),
    7508                 :            :                                 "\0\0\0");  /* widest supported wchar_t
    7509                 :            :                                                is 32 bits */
    7510                 :          0 :           break;
    7511                 :            :         }
    7512                 :            :     }
    7513                 :            : 
    7514                 :    2560960 :   switch (type)
    7515                 :            :     {
    7516                 :    2560090 :     default:
    7517                 :    2560090 :     case CPP_STRING:
    7518                 :    2560090 :     case CPP_UTF8STRING:
    7519                 :    2560090 :       TREE_TYPE (value) = char_array_type_node;
    7520                 :    2560090 :       break;
    7521                 :        198 :     case CPP_STRING16:
    7522                 :        198 :       TREE_TYPE (value) = char16_array_type_node;
    7523                 :        198 :       break;
    7524                 :        196 :     case CPP_STRING32:
    7525                 :        196 :       TREE_TYPE (value) = char32_array_type_node;
    7526                 :        196 :       break;
    7527                 :        474 :     case CPP_WSTRING:
    7528                 :        474 :       TREE_TYPE (value) = wchar_array_type_node;
    7529                 :            :     }
    7530                 :    2560960 :   value = fix_string_type (value);
    7531                 :            : 
    7532                 :    2560960 :   if (count > 1)
    7533                 :            :     {
    7534                 :     592893 :       obstack_free (&str_ob, 0);
    7535                 :     592893 :       obstack_free (&loc_ob, 0);
    7536                 :            :     }
    7537                 :            : 
    7538                 :    2560960 :   ret.value = value;
    7539                 :    2560960 :   ret.original_code = STRING_CST;
    7540                 :    2560960 :   ret.original_type = NULL_TREE;
    7541                 :    2560960 :   set_c_expr_source_range (&ret, get_range_from_loc (line_table, loc));
    7542                 :    2560960 :   return ret;
    7543                 :            : }
    7544                 :            : 
    7545                 :            : /* Parse an expression other than a compound expression; that is, an
    7546                 :            :    assignment expression (C90 6.3.16, C99 6.5.16, C11 6.5.16).  If
    7547                 :            :    AFTER is not NULL then it is an Objective-C message expression which
    7548                 :            :    is the primary-expression starting the expression as an initializer.
    7549                 :            : 
    7550                 :            :    assignment-expression:
    7551                 :            :      conditional-expression
    7552                 :            :      unary-expression assignment-operator assignment-expression
    7553                 :            : 
    7554                 :            :    assignment-operator: one of
    7555                 :            :      = *= /= %= += -= <<= >>= &= ^= |=
    7556                 :            : 
    7557                 :            :    In GNU C we accept any conditional expression on the LHS and
    7558                 :            :    diagnose the invalid lvalue rather than producing a syntax
    7559                 :            :    error.  */
    7560                 :            : 
    7561                 :            : static struct c_expr
    7562                 :  119218000 : c_parser_expr_no_commas (c_parser *parser, struct c_expr *after,
    7563                 :            :                          tree omp_atomic_lhs)
    7564                 :            : {
    7565                 :  119218000 :   struct c_expr lhs, rhs, ret;
    7566                 :  119218000 :   enum tree_code code;
    7567                 :  119218000 :   location_t op_location, exp_location;
    7568                 :  119218000 :   gcc_assert (!after || c_dialect_objc ());
    7569                 :  119218000 :   lhs = c_parser_conditional_expression (parser, after, omp_atomic_lhs);
    7570                 :  119218000 :   op_location = c_parser_peek_token (parser)->location;
    7571                 :  119218000 :   switch (c_parser_peek_token (parser)->type)
    7572                 :            :     {
    7573                 :            :     case CPP_EQ:
    7574                 :            :       code = NOP_EXPR;
    7575                 :            :       break;
    7576                 :       6366 :     case CPP_MULT_EQ:
    7577                 :       6366 :       code = MULT_EXPR;
    7578                 :       6366 :       break;
    7579                 :       3695 :     case CPP_DIV_EQ:
    7580                 :       3695 :       code = TRUNC_DIV_EXPR;
    7581                 :       3695 :       break;
    7582                 :       2168 :     case CPP_MOD_EQ:
    7583                 :       2168 :       code = TRUNC_MOD_EXPR;
    7584                 :       2168 :       break;
    7585                 :      68062 :     case CPP_PLUS_EQ:
    7586                 :      68062 :       code = PLUS_EXPR;
    7587                 :      68062 :       break;
    7588                 :      20699 :     case CPP_MINUS_EQ:
    7589                 :      20699 :       code = MINUS_EXPR;
    7590                 :      20699 :       break;
    7591                 :       3165 :     case CPP_LSHIFT_EQ:
    7592                 :       3165 :       code = LSHIFT_EXPR;
    7593                 :       3165 :       break;
    7594                 :       2252 :     case CPP_RSHIFT_EQ:
    7595                 :       2252 :       code = RSHIFT_EXPR;
    7596                 :       2252 :       break;
    7597                 :       5526 :     case CPP_AND_EQ:
    7598                 :       5526 :       code = BIT_AND_EXPR;
    7599                 :       5526 :       break;
    7600                 :       2554 :     case CPP_XOR_EQ:
    7601                 :       2554 :       code = BIT_XOR_EXPR;
    7602                 :       2554 :       break;
    7603                 :      16750 :     case CPP_OR_EQ:
    7604                 :      16750 :       code = BIT_IOR_EXPR;
    7605                 :      16750 :       break;
    7606                 :  117186000 :     default:
    7607                 :  117186000 :       return lhs;
    7608                 :            :     }
    7609                 :    2031190 :   c_parser_consume_token (parser);
    7610                 :    2031190 :   exp_location = c_parser_peek_token (parser)->location;
    7611                 :    2031190 :   rhs = c_parser_expr_no_commas (parser, NULL);
    7612                 :    2031190 :   rhs = convert_lvalue_to_rvalue (exp_location, rhs, true, true);
    7613                 :            :   
    7614                 :    2031190 :   ret.value = build_modify_expr (op_location, lhs.value, lhs.original_type,
    7615                 :            :                                  code, exp_location, rhs.value,
    7616                 :            :                                  rhs.original_type);
    7617                 :    2031190 :   set_c_expr_source_range (&ret, lhs.get_start (), rhs.get_finish ());
    7618                 :    2031190 :   if (code == NOP_EXPR)
    7619                 :    1899950 :     ret.original_code = MODIFY_EXPR;
    7620                 :            :   else
    7621                 :            :     {
    7622                 :     131237 :       TREE_NO_WARNING (ret.value) = 1;
    7623                 :     131237 :       ret.original_code = ERROR_MARK;
    7624                 :            :     }