Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / gcc / c / c-parser.c
1 /* Parser for C and Objective-C.
2    Copyright (C) 1987-2015 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 #include "system.h"
40 #include "coretypes.h"
41 #include "tm.h"                 /* For rtl.h: needs enum reg_class.  */
42 #include "hash-set.h"
43 #include "vec.h"
44 #include "symtab.h"
45 #include "input.h"
46 #include "alias.h"
47 #include "double-int.h"
48 #include "machmode.h"
49 #include "flags.h"
50 #include "inchash.h"
51 #include "tree.h"
52 #include "fold-const.h"
53 #include "stringpool.h"
54 #include "attribs.h"
55 #include "stor-layout.h"
56 #include "varasm.h"
57 #include "trans-mem.h"
58 #include "langhooks.h"
59 #include "input.h"
60 #include "cpplib.h"
61 #include "timevar.h"
62 #include "c-family/c-pragma.h"
63 #include "c-tree.h"
64 #include "c-lang.h"
65 #include "flags.h"
66 #include "ggc.h"
67 #include "c-family/c-common.h"
68 #include "c-family/c-objc.h"
69 #include "vec.h"
70 #include "target.h"
71 #include "hash-map.h"
72 #include "is-a.h"
73 #include "plugin-api.h"
74 #include "hashtab.h"
75 #include "hash-set.h"
76 #include "machmode.h"
77 #include "hard-reg-set.h"
78 #include "function.h"
79 #include "ipa-ref.h"
80 #include "cgraph.h"
81 #include "plugin.h"
82 #include "omp-low.h"
83 #include "builtins.h"
84 #include "gomp-constants.h"
85
86 \f
87 /* Initialization routine for this file.  */
88
89 void
90 c_parse_init (void)
91 {
92   /* The only initialization required is of the reserved word
93      identifiers.  */
94   unsigned int i;
95   tree id;
96   int mask = 0;
97
98   /* Make sure RID_MAX hasn't grown past the 8 bits used to hold the keyword in
99      the c_token structure.  */
100   gcc_assert (RID_MAX <= 255);
101
102   mask |= D_CXXONLY;
103   if (!flag_isoc99)
104     mask |= D_C99;
105   if (flag_no_asm)
106     {
107       mask |= D_ASM | D_EXT;
108       if (!flag_isoc99)
109         mask |= D_EXT89;
110     }
111   if (!c_dialect_objc ())
112     mask |= D_OBJC | D_CXX_OBJC;
113
114   ridpointers = ggc_cleared_vec_alloc<tree> ((int) RID_MAX);
115   for (i = 0; i < num_c_common_reswords; i++)
116     {
117       /* If a keyword is disabled, do not enter it into the table
118          and so create a canonical spelling that isn't a keyword.  */
119       if (c_common_reswords[i].disable & mask)
120         {
121           if (warn_cxx_compat
122               && (c_common_reswords[i].disable & D_CXXWARN))
123             {
124               id = get_identifier (c_common_reswords[i].word);
125               C_SET_RID_CODE (id, RID_CXX_COMPAT_WARN);
126               C_IS_RESERVED_WORD (id) = 1;
127             }
128           continue;
129         }
130
131       id = get_identifier (c_common_reswords[i].word);
132       C_SET_RID_CODE (id, c_common_reswords[i].rid);
133       C_IS_RESERVED_WORD (id) = 1;
134       ridpointers [(int) c_common_reswords[i].rid] = id;
135     }
136
137   for (i = 0; i < NUM_INT_N_ENTS; i++)
138     {
139       /* We always create the symbols but they aren't always supported.  */
140       char name[50];
141       sprintf (name, "__int%d", int_n_data[i].bitsize);
142       id = get_identifier (xstrdup (name));
143       C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
144       C_IS_RESERVED_WORD (id) = 1;
145     }
146 }
147 \f
148 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
149    and the C parser.  Unlike the C++ lexer, the parser structure
150    stores the lexer information instead of using a separate structure.
151    Identifiers are separated into ordinary identifiers, type names,
152    keywords and some other Objective-C types of identifiers, and some
153    look-ahead is maintained.
154
155    ??? It might be a good idea to lex the whole file up front (as for
156    C++).  It would then be possible to share more of the C and C++
157    lexer code, if desired.  */
158
159 /* More information about the type of a CPP_NAME token.  */
160 typedef enum c_id_kind {
161   /* An ordinary identifier.  */
162   C_ID_ID,
163   /* An identifier declared as a typedef name.  */
164   C_ID_TYPENAME,
165   /* An identifier declared as an Objective-C class name.  */
166   C_ID_CLASSNAME,
167   /* An address space identifier.  */
168   C_ID_ADDRSPACE,
169   /* Not an identifier.  */
170   C_ID_NONE
171 } c_id_kind;
172
173 /* A single C token after string literal concatenation and conversion
174    of preprocessing tokens to tokens.  */
175 typedef struct GTY (()) c_token {
176   /* The kind of token.  */
177   ENUM_BITFIELD (cpp_ttype) type : 8;
178   /* If this token is a CPP_NAME, this value indicates whether also
179      declared as some kind of type.  Otherwise, it is C_ID_NONE.  */
180   ENUM_BITFIELD (c_id_kind) id_kind : 8;
181   /* If this token is a keyword, this value indicates which keyword.
182      Otherwise, this value is RID_MAX.  */
183   ENUM_BITFIELD (rid) keyword : 8;
184   /* If this token is a CPP_PRAGMA, this indicates the pragma that
185      was seen.  Otherwise it is PRAGMA_NONE.  */
186   ENUM_BITFIELD (pragma_kind) pragma_kind : 8;
187   /* The location at which this token was found.  */
188   location_t location;
189   /* The value associated with this token, if any.  */
190   tree value;
191 } c_token;
192
193 /* A parser structure recording information about the state and
194    context of parsing.  Includes lexer information with up to two
195    tokens of look-ahead; more are not needed for C.  */
196 typedef struct GTY(()) c_parser {
197   /* The look-ahead tokens.  */
198   c_token * GTY((skip)) tokens;
199   /* Buffer for look-ahead tokens.  */
200   c_token tokens_buf[2];
201   /* How many look-ahead tokens are available (0, 1 or 2, or
202      more if parsing from pre-lexed tokens).  */
203   unsigned int tokens_avail;
204   /* True if a syntax error is being recovered from; false otherwise.
205      c_parser_error sets this flag.  It should clear this flag when
206      enough tokens have been consumed to recover from the error.  */
207   BOOL_BITFIELD error : 1;
208   /* True if we're processing a pragma, and shouldn't automatically
209      consume CPP_PRAGMA_EOL.  */
210   BOOL_BITFIELD in_pragma : 1;
211   /* True if we're parsing the outermost block of an if statement.  */
212   BOOL_BITFIELD in_if_block : 1;
213   /* True if we want to lex an untranslated string.  */
214   BOOL_BITFIELD lex_untranslated_string : 1;
215
216   /* Objective-C specific parser/lexer information.  */
217
218   /* True if we are in a context where the Objective-C "PQ" keywords
219      are considered keywords.  */
220   BOOL_BITFIELD objc_pq_context : 1;
221   /* True if we are parsing a (potential) Objective-C foreach
222      statement.  This is set to true after we parsed 'for (' and while
223      we wait for 'in' or ';' to decide if it's a standard C for loop or an
224      Objective-C foreach loop.  */
225   BOOL_BITFIELD objc_could_be_foreach_context : 1;
226   /* The following flag is needed to contextualize Objective-C lexical
227      analysis.  In some cases (e.g., 'int NSObject;'), it is
228      undesirable to bind an identifier to an Objective-C class, even
229      if a class with that name exists.  */
230   BOOL_BITFIELD objc_need_raw_identifier : 1;
231   /* Nonzero if we're processing a __transaction statement.  The value
232      is 1 | TM_STMT_ATTR_*.  */
233   unsigned int in_transaction : 4;
234   /* True if we are in a context where the Objective-C "Property attribute"
235      keywords are valid.  */
236   BOOL_BITFIELD objc_property_attr_context : 1;
237
238   /* Cilk Plus specific parser/lexer information.  */
239
240   /* Buffer to hold all the tokens from parsing the vector attribute for the
241      SIMD-enabled functions (formerly known as elemental functions).  */
242   vec <c_token, va_gc> *cilk_simd_fn_tokens;
243 } c_parser;
244
245
246 /* The actual parser and external interface.  ??? Does this need to be
247    garbage-collected?  */
248
249 static GTY (()) c_parser *the_parser;
250
251 /* Read in and lex a single token, storing it in *TOKEN.  */
252
253 static void
254 c_lex_one_token (c_parser *parser, c_token *token)
255 {
256   timevar_push (TV_LEX);
257
258   token->type = c_lex_with_flags (&token->value, &token->location, NULL,
259                                   (parser->lex_untranslated_string
260                                    ? C_LEX_STRING_NO_TRANSLATE : 0));
261   token->id_kind = C_ID_NONE;
262   token->keyword = RID_MAX;
263   token->pragma_kind = PRAGMA_NONE;
264
265   switch (token->type)
266     {
267     case CPP_NAME:
268       {
269         tree decl;
270
271         bool objc_force_identifier = parser->objc_need_raw_identifier;
272         if (c_dialect_objc ())
273           parser->objc_need_raw_identifier = false;
274
275         if (C_IS_RESERVED_WORD (token->value))
276           {
277             enum rid rid_code = C_RID_CODE (token->value);
278
279             if (rid_code == RID_CXX_COMPAT_WARN)
280               {
281                 warning_at (token->location,
282                             OPT_Wc___compat,
283                             "identifier %qE conflicts with C++ keyword",
284                             token->value);
285               }
286             else if (rid_code >= RID_FIRST_ADDR_SPACE
287                      && rid_code <= RID_LAST_ADDR_SPACE)
288               {
289                 token->id_kind = C_ID_ADDRSPACE;
290                 token->keyword = rid_code;
291                 break;
292               }
293             else if (c_dialect_objc () && OBJC_IS_PQ_KEYWORD (rid_code))
294               {
295                 /* We found an Objective-C "pq" keyword (in, out,
296                    inout, bycopy, byref, oneway).  They need special
297                    care because the interpretation depends on the
298                    context.  */
299                 if (parser->objc_pq_context)
300                   {
301                     token->type = CPP_KEYWORD;
302                     token->keyword = rid_code;
303                     break;
304                   }
305                 else if (parser->objc_could_be_foreach_context
306                          && rid_code == RID_IN)
307                   {
308                     /* We are in Objective-C, inside a (potential)
309                        foreach context (which means after having
310                        parsed 'for (', but before having parsed ';'),
311                        and we found 'in'.  We consider it the keyword
312                        which terminates the declaration at the
313                        beginning of a foreach-statement.  Note that
314                        this means you can't use 'in' for anything else
315                        in that context; in particular, in Objective-C
316                        you can't use 'in' as the name of the running
317                        variable in a C for loop.  We could potentially
318                        try to add code here to disambiguate, but it
319                        seems a reasonable limitation.  */
320                     token->type = CPP_KEYWORD;
321                     token->keyword = rid_code;
322                     break;
323                   }
324                 /* Else, "pq" keywords outside of the "pq" context are
325                    not keywords, and we fall through to the code for
326                    normal tokens.  */
327               }
328             else if (c_dialect_objc () && OBJC_IS_PATTR_KEYWORD (rid_code))
329               {
330                 /* We found an Objective-C "property attribute"
331                    keyword (getter, setter, readonly, etc). These are
332                    only valid in the property context.  */
333                 if (parser->objc_property_attr_context)
334                   {
335                     token->type = CPP_KEYWORD;
336                     token->keyword = rid_code;
337                     break;
338                   }
339                 /* Else they are not special keywords.
340                 */
341               }
342             else if (c_dialect_objc () 
343                      && (OBJC_IS_AT_KEYWORD (rid_code)
344                          || OBJC_IS_CXX_KEYWORD (rid_code)))
345               {
346                 /* We found one of the Objective-C "@" keywords (defs,
347                    selector, synchronized, etc) or one of the
348                    Objective-C "cxx" keywords (class, private,
349                    protected, public, try, catch, throw) without a
350                    preceding '@' sign.  Do nothing and fall through to
351                    the code for normal tokens (in C++ we would still
352                    consider the CXX ones keywords, but not in C).  */
353                 ;
354               }
355             else
356               {
357                 token->type = CPP_KEYWORD;
358                 token->keyword = rid_code;
359                 break;
360               }
361           }
362
363         decl = lookup_name (token->value);
364         if (decl)
365           {
366             if (TREE_CODE (decl) == TYPE_DECL)
367               {
368                 token->id_kind = C_ID_TYPENAME;
369                 break;
370               }
371           }
372         else if (c_dialect_objc ())
373           {
374             tree objc_interface_decl = objc_is_class_name (token->value);
375             /* Objective-C class names are in the same namespace as
376                variables and typedefs, and hence are shadowed by local
377                declarations.  */
378             if (objc_interface_decl
379                 && (!objc_force_identifier || global_bindings_p ()))
380               {
381                 token->value = objc_interface_decl;
382                 token->id_kind = C_ID_CLASSNAME;
383                 break;
384               }
385           }
386         token->id_kind = C_ID_ID;
387       }
388       break;
389     case CPP_AT_NAME:
390       /* This only happens in Objective-C; it must be a keyword.  */
391       token->type = CPP_KEYWORD;
392       switch (C_RID_CODE (token->value))
393         {
394           /* Replace 'class' with '@class', 'private' with '@private',
395              etc.  This prevents confusion with the C++ keyword
396              'class', and makes the tokens consistent with other
397              Objective-C 'AT' keywords.  For example '@class' is
398              reported as RID_AT_CLASS which is consistent with
399              '@synchronized', which is reported as
400              RID_AT_SYNCHRONIZED.
401           */
402         case RID_CLASS:     token->keyword = RID_AT_CLASS; break;
403         case RID_PRIVATE:   token->keyword = RID_AT_PRIVATE; break;
404         case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
405         case RID_PUBLIC:    token->keyword = RID_AT_PUBLIC; break;
406         case RID_THROW:     token->keyword = RID_AT_THROW; break;
407         case RID_TRY:       token->keyword = RID_AT_TRY; break;
408         case RID_CATCH:     token->keyword = RID_AT_CATCH; break;
409         default:            token->keyword = C_RID_CODE (token->value);
410         }
411       break;
412     case CPP_COLON:
413     case CPP_COMMA:
414     case CPP_CLOSE_PAREN:
415     case CPP_SEMICOLON:
416       /* These tokens may affect the interpretation of any identifiers
417          following, if doing Objective-C.  */
418       if (c_dialect_objc ())
419         parser->objc_need_raw_identifier = false;
420       break;
421     case CPP_PRAGMA:
422       /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST.  */
423       token->pragma_kind = (enum pragma_kind) TREE_INT_CST_LOW (token->value);
424       token->value = NULL;
425       break;
426     default:
427       break;
428     }
429   timevar_pop (TV_LEX);
430 }
431
432 /* Return a pointer to the next token from PARSER, reading it in if
433    necessary.  */
434
435 static inline c_token *
436 c_parser_peek_token (c_parser *parser)
437 {
438   if (parser->tokens_avail == 0)
439     {
440       c_lex_one_token (parser, &parser->tokens[0]);
441       parser->tokens_avail = 1;
442     }
443   return &parser->tokens[0];
444 }
445
446 /* Return true if the next token from PARSER has the indicated
447    TYPE.  */
448
449 static inline bool
450 c_parser_next_token_is (c_parser *parser, enum cpp_ttype type)
451 {
452   return c_parser_peek_token (parser)->type == type;
453 }
454
455 /* Return true if the next token from PARSER does not have the
456    indicated TYPE.  */
457
458 static inline bool
459 c_parser_next_token_is_not (c_parser *parser, enum cpp_ttype type)
460 {
461   return !c_parser_next_token_is (parser, type);
462 }
463
464 /* Return true if the next token from PARSER is the indicated
465    KEYWORD.  */
466
467 static inline bool
468 c_parser_next_token_is_keyword (c_parser *parser, enum rid keyword)
469 {
470   return c_parser_peek_token (parser)->keyword == keyword;
471 }
472
473 /* Return a pointer to the next-but-one token from PARSER, reading it
474    in if necessary.  The next token is already read in.  */
475
476 static c_token *
477 c_parser_peek_2nd_token (c_parser *parser)
478 {
479   if (parser->tokens_avail >= 2)
480     return &parser->tokens[1];
481   gcc_assert (parser->tokens_avail == 1);
482   gcc_assert (parser->tokens[0].type != CPP_EOF);
483   gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL);
484   c_lex_one_token (parser, &parser->tokens[1]);
485   parser->tokens_avail = 2;
486   return &parser->tokens[1];
487 }
488
489 /* Return true if TOKEN can start a type name,
490    false otherwise.  */
491 static bool
492 c_token_starts_typename (c_token *token)
493 {
494   switch (token->type)
495     {
496     case CPP_NAME:
497       switch (token->id_kind)
498         {
499         case C_ID_ID:
500           return false;
501         case C_ID_ADDRSPACE:
502           return true;
503         case C_ID_TYPENAME:
504           return true;
505         case C_ID_CLASSNAME:
506           gcc_assert (c_dialect_objc ());
507           return true;
508         default:
509           gcc_unreachable ();
510         }
511     case CPP_KEYWORD:
512       switch (token->keyword)
513         {
514         case RID_UNSIGNED:
515         case RID_LONG:
516         case RID_SHORT:
517         case RID_SIGNED:
518         case RID_COMPLEX:
519         case RID_INT:
520         case RID_CHAR:
521         case RID_FLOAT:
522         case RID_DOUBLE:
523         case RID_VOID:
524         case RID_DFLOAT32:
525         case RID_DFLOAT64:
526         case RID_DFLOAT128:
527         case RID_BOOL:
528         case RID_ENUM:
529         case RID_STRUCT:
530         case RID_UNION:
531         case RID_TYPEOF:
532         case RID_CONST:
533         case RID_ATOMIC:
534         case RID_VOLATILE:
535         case RID_RESTRICT:
536         case RID_ATTRIBUTE:
537         case RID_FRACT:
538         case RID_ACCUM:
539         case RID_SAT:
540         case RID_AUTO_TYPE:
541           return true;
542         default:
543           if (token->keyword >= RID_FIRST_INT_N
544               && token->keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS
545               && int_n_enabled_p[token->keyword - RID_FIRST_INT_N])
546             return true;
547           return false;
548         }
549     case CPP_LESS:
550       if (c_dialect_objc ())
551         return true;
552       return false;
553     default:
554       return false;
555     }
556 }
557
558 enum c_lookahead_kind {
559   /* Always treat unknown identifiers as typenames.  */
560   cla_prefer_type,
561
562   /* Could be parsing a nonabstract declarator.  Only treat an identifier
563      as a typename if followed by another identifier or a star.  */
564   cla_nonabstract_decl,
565
566   /* Never treat identifiers as typenames.  */
567   cla_prefer_id
568 };
569
570 /* Return true if the next token from PARSER can start a type name,
571    false otherwise.  LA specifies how to do lookahead in order to
572    detect unknown type names.  If unsure, pick CLA_PREFER_ID.  */
573
574 static inline bool
575 c_parser_next_tokens_start_typename (c_parser *parser, enum c_lookahead_kind la)
576 {
577   c_token *token = c_parser_peek_token (parser);
578   if (c_token_starts_typename (token))
579     return true;
580
581   /* Try a bit harder to detect an unknown typename.  */
582   if (la != cla_prefer_id
583       && token->type == CPP_NAME
584       && token->id_kind == C_ID_ID
585
586       /* Do not try too hard when we could have "object in array".  */
587       && !parser->objc_could_be_foreach_context
588
589       && (la == cla_prefer_type
590           || c_parser_peek_2nd_token (parser)->type == CPP_NAME
591           || c_parser_peek_2nd_token (parser)->type == CPP_MULT)
592
593       /* Only unknown identifiers.  */
594       && !lookup_name (token->value))
595     return true;
596
597   return false;
598 }
599
600 /* Return true if TOKEN is a type qualifier, false otherwise.  */
601 static bool
602 c_token_is_qualifier (c_token *token)
603 {
604   switch (token->type)
605     {
606     case CPP_NAME:
607       switch (token->id_kind)
608         {
609         case C_ID_ADDRSPACE:
610           return true;
611         default:
612           return false;
613         }
614     case CPP_KEYWORD:
615       switch (token->keyword)
616         {
617         case RID_CONST:
618         case RID_VOLATILE:
619         case RID_RESTRICT:
620         case RID_ATTRIBUTE:
621         case RID_ATOMIC:
622           return true;
623         default:
624           return false;
625         }
626     case CPP_LESS:
627       return false;
628     default:
629       gcc_unreachable ();
630     }
631 }
632
633 /* Return true if the next token from PARSER is a type qualifier,
634    false otherwise.  */
635 static inline bool
636 c_parser_next_token_is_qualifier (c_parser *parser)
637 {
638   c_token *token = c_parser_peek_token (parser);
639   return c_token_is_qualifier (token);
640 }
641
642 /* Return true if TOKEN can start declaration specifiers, false
643    otherwise.  */
644 static bool
645 c_token_starts_declspecs (c_token *token)
646 {
647   switch (token->type)
648     {
649     case CPP_NAME:
650       switch (token->id_kind)
651         {
652         case C_ID_ID:
653           return false;
654         case C_ID_ADDRSPACE:
655           return true;
656         case C_ID_TYPENAME:
657           return true;
658         case C_ID_CLASSNAME:
659           gcc_assert (c_dialect_objc ());
660           return true;
661         default:
662           gcc_unreachable ();
663         }
664     case CPP_KEYWORD:
665       switch (token->keyword)
666         {
667         case RID_STATIC:
668         case RID_EXTERN:
669         case RID_REGISTER:
670         case RID_TYPEDEF:
671         case RID_INLINE:
672         case RID_NORETURN:
673         case RID_AUTO:
674         case RID_THREAD:
675         case RID_UNSIGNED:
676         case RID_LONG:
677         case RID_SHORT:
678         case RID_SIGNED:
679         case RID_COMPLEX:
680         case RID_INT:
681         case RID_CHAR:
682         case RID_FLOAT:
683         case RID_DOUBLE:
684         case RID_VOID:
685         case RID_DFLOAT32:
686         case RID_DFLOAT64:
687         case RID_DFLOAT128:
688         case RID_BOOL:
689         case RID_ENUM:
690         case RID_STRUCT:
691         case RID_UNION:
692         case RID_TYPEOF:
693         case RID_CONST:
694         case RID_VOLATILE:
695         case RID_RESTRICT:
696         case RID_ATTRIBUTE:
697         case RID_FRACT:
698         case RID_ACCUM:
699         case RID_SAT:
700         case RID_ALIGNAS:
701         case RID_ATOMIC:
702         case RID_AUTO_TYPE:
703           return true;
704         default:
705           if (token->keyword >= RID_FIRST_INT_N
706               && token->keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS
707               && int_n_enabled_p[token->keyword - RID_FIRST_INT_N])
708             return true;
709           return false;
710         }
711     case CPP_LESS:
712       if (c_dialect_objc ())
713         return true;
714       return false;
715     default:
716       return false;
717     }
718 }
719
720
721 /* Return true if TOKEN can start declaration specifiers or a static
722    assertion, false otherwise.  */
723 static bool
724 c_token_starts_declaration (c_token *token)
725 {
726   if (c_token_starts_declspecs (token)
727       || token->keyword == RID_STATIC_ASSERT)
728     return true;
729   else
730     return false;
731 }
732
733 /* Return true if the next token from PARSER can start declaration
734    specifiers, false otherwise.  */
735 static inline bool
736 c_parser_next_token_starts_declspecs (c_parser *parser)
737 {
738   c_token *token = c_parser_peek_token (parser);
739
740   /* In Objective-C, a classname normally starts a declspecs unless it
741      is immediately followed by a dot.  In that case, it is the
742      Objective-C 2.0 "dot-syntax" for class objects, ie, calls the
743      setter/getter on the class.  c_token_starts_declspecs() can't
744      differentiate between the two cases because it only checks the
745      current token, so we have a special check here.  */
746   if (c_dialect_objc () 
747       && token->type == CPP_NAME
748       && token->id_kind == C_ID_CLASSNAME 
749       && c_parser_peek_2nd_token (parser)->type == CPP_DOT)
750     return false;
751
752   return c_token_starts_declspecs (token);
753 }
754
755 /* Return true if the next tokens from PARSER can start declaration
756    specifiers or a static assertion, false otherwise.  */
757 static inline bool
758 c_parser_next_tokens_start_declaration (c_parser *parser)
759 {
760   c_token *token = c_parser_peek_token (parser);
761
762   /* Same as above.  */
763   if (c_dialect_objc () 
764       && token->type == CPP_NAME
765       && token->id_kind == C_ID_CLASSNAME 
766       && c_parser_peek_2nd_token (parser)->type == CPP_DOT)
767     return false;
768
769   /* Labels do not start declarations.  */
770   if (token->type == CPP_NAME
771       && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
772     return false;
773
774   if (c_token_starts_declaration (token))
775     return true;
776
777   if (c_parser_next_tokens_start_typename (parser, cla_nonabstract_decl))
778     return true;
779
780   return false;
781 }
782
783 /* Consume the next token from PARSER.  */
784
785 static void
786 c_parser_consume_token (c_parser *parser)
787 {
788   gcc_assert (parser->tokens_avail >= 1);
789   gcc_assert (parser->tokens[0].type != CPP_EOF);
790   gcc_assert (!parser->in_pragma || parser->tokens[0].type != CPP_PRAGMA_EOL);
791   gcc_assert (parser->error || parser->tokens[0].type != CPP_PRAGMA);
792   if (parser->tokens != &parser->tokens_buf[0])
793     parser->tokens++;
794   else if (parser->tokens_avail == 2)
795     parser->tokens[0] = parser->tokens[1];
796   parser->tokens_avail--;
797 }
798
799 /* Expect the current token to be a #pragma.  Consume it and remember
800    that we've begun parsing a pragma.  */
801
802 static void
803 c_parser_consume_pragma (c_parser *parser)
804 {
805   gcc_assert (!parser->in_pragma);
806   gcc_assert (parser->tokens_avail >= 1);
807   gcc_assert (parser->tokens[0].type == CPP_PRAGMA);
808   if (parser->tokens != &parser->tokens_buf[0])
809     parser->tokens++;
810   else if (parser->tokens_avail == 2)
811     parser->tokens[0] = parser->tokens[1];
812   parser->tokens_avail--;
813   parser->in_pragma = true;
814 }
815
816 /* Update the global input_location from TOKEN.  */
817 static inline void
818 c_parser_set_source_position_from_token (c_token *token)
819 {
820   if (token->type != CPP_EOF)
821     {
822       input_location = token->location;
823     }
824 }
825
826 /* Issue a diagnostic of the form
827       FILE:LINE: MESSAGE before TOKEN
828    where TOKEN is the next token in the input stream of PARSER.
829    MESSAGE (specified by the caller) is usually of the form "expected
830    OTHER-TOKEN".
831
832    Do not issue a diagnostic if still recovering from an error.
833
834    ??? This is taken from the C++ parser, but building up messages in
835    this way is not i18n-friendly and some other approach should be
836    used.  */
837
838 static void
839 c_parser_error (c_parser *parser, const char *gmsgid)
840 {
841   c_token *token = c_parser_peek_token (parser);
842   if (parser->error)
843     return;
844   parser->error = true;
845   if (!gmsgid)
846     return;
847   /* This diagnostic makes more sense if it is tagged to the line of
848      the token we just peeked at.  */
849   c_parser_set_source_position_from_token (token);
850   c_parse_error (gmsgid,
851                  /* Because c_parse_error does not understand
852                     CPP_KEYWORD, keywords are treated like
853                     identifiers.  */
854                  (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
855                  /* ??? The C parser does not save the cpp flags of a
856                     token, we need to pass 0 here and we will not get
857                     the source spelling of some tokens but rather the
858                     canonical spelling.  */
859                  token->value, /*flags=*/0);
860 }
861
862 /* If the next token is of the indicated TYPE, consume it.  Otherwise,
863    issue the error MSGID.  If MSGID is NULL then a message has already
864    been produced and no message will be produced this time.  Returns
865    true if found, false otherwise.  */
866
867 static bool
868 c_parser_require (c_parser *parser,
869                   enum cpp_ttype type,
870                   const char *msgid)
871 {
872   if (c_parser_next_token_is (parser, type))
873     {
874       c_parser_consume_token (parser);
875       return true;
876     }
877   else
878     {
879       c_parser_error (parser, msgid);
880       return false;
881     }
882 }
883
884 /* If the next token is the indicated keyword, consume it.  Otherwise,
885    issue the error MSGID.  Returns true if found, false otherwise.  */
886
887 static bool
888 c_parser_require_keyword (c_parser *parser,
889                           enum rid keyword,
890                           const char *msgid)
891 {
892   if (c_parser_next_token_is_keyword (parser, keyword))
893     {
894       c_parser_consume_token (parser);
895       return true;
896     }
897   else
898     {
899       c_parser_error (parser, msgid);
900       return false;
901     }
902 }
903
904 /* Like c_parser_require, except that tokens will be skipped until the
905    desired token is found.  An error message is still produced if the
906    next token is not as expected.  If MSGID is NULL then a message has
907    already been produced and no message will be produced this
908    time.  */
909
910 static void
911 c_parser_skip_until_found (c_parser *parser,
912                            enum cpp_ttype type,
913                            const char *msgid)
914 {
915   unsigned nesting_depth = 0;
916
917   if (c_parser_require (parser, type, msgid))
918     return;
919
920   /* Skip tokens until the desired token is found.  */
921   while (true)
922     {
923       /* Peek at the next token.  */
924       c_token *token = c_parser_peek_token (parser);
925       /* If we've reached the token we want, consume it and stop.  */
926       if (token->type == type && !nesting_depth)
927         {
928           c_parser_consume_token (parser);
929           break;
930         }
931
932       /* If we've run out of tokens, stop.  */
933       if (token->type == CPP_EOF)
934         return;
935       if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
936         return;
937       if (token->type == CPP_OPEN_BRACE
938           || token->type == CPP_OPEN_PAREN
939           || token->type == CPP_OPEN_SQUARE)
940         ++nesting_depth;
941       else if (token->type == CPP_CLOSE_BRACE
942                || token->type == CPP_CLOSE_PAREN
943                || token->type == CPP_CLOSE_SQUARE)
944         {
945           if (nesting_depth-- == 0)
946             break;
947         }
948       /* Consume this token.  */
949       c_parser_consume_token (parser);
950     }
951   parser->error = false;
952 }
953
954 /* Skip tokens until the end of a parameter is found, but do not
955    consume the comma, semicolon or closing delimiter.  */
956
957 static void
958 c_parser_skip_to_end_of_parameter (c_parser *parser)
959 {
960   unsigned nesting_depth = 0;
961
962   while (true)
963     {
964       c_token *token = c_parser_peek_token (parser);
965       if ((token->type == CPP_COMMA || token->type == CPP_SEMICOLON)
966           && !nesting_depth)
967         break;
968       /* If we've run out of tokens, stop.  */
969       if (token->type == CPP_EOF)
970         return;
971       if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
972         return;
973       if (token->type == CPP_OPEN_BRACE
974           || token->type == CPP_OPEN_PAREN
975           || token->type == CPP_OPEN_SQUARE)
976         ++nesting_depth;
977       else if (token->type == CPP_CLOSE_BRACE
978                || token->type == CPP_CLOSE_PAREN
979                || token->type == CPP_CLOSE_SQUARE)
980         {
981           if (nesting_depth-- == 0)
982             break;
983         }
984       /* Consume this token.  */
985       c_parser_consume_token (parser);
986     }
987   parser->error = false;
988 }
989
990 /* Expect to be at the end of the pragma directive and consume an
991    end of line marker.  */
992
993 static void
994 c_parser_skip_to_pragma_eol (c_parser *parser)
995 {
996   gcc_assert (parser->in_pragma);
997   parser->in_pragma = false;
998
999   if (!c_parser_require (parser, CPP_PRAGMA_EOL, "expected end of line"))
1000     while (true)
1001       {
1002         c_token *token = c_parser_peek_token (parser);
1003         if (token->type == CPP_EOF)
1004           break;
1005         if (token->type == CPP_PRAGMA_EOL)
1006           {
1007             c_parser_consume_token (parser);
1008             break;
1009           }
1010         c_parser_consume_token (parser);
1011       }
1012
1013   parser->error = false;
1014 }
1015
1016 /* Skip tokens until we have consumed an entire block, or until we
1017    have consumed a non-nested ';'.  */
1018
1019 static void
1020 c_parser_skip_to_end_of_block_or_statement (c_parser *parser)
1021 {
1022   unsigned nesting_depth = 0;
1023   bool save_error = parser->error;
1024
1025   while (true)
1026     {
1027       c_token *token;
1028
1029       /* Peek at the next token.  */
1030       token = c_parser_peek_token (parser);
1031
1032       switch (token->type)
1033         {
1034         case CPP_EOF:
1035           return;
1036
1037         case CPP_PRAGMA_EOL:
1038           if (parser->in_pragma)
1039             return;
1040           break;
1041
1042         case CPP_SEMICOLON:
1043           /* If the next token is a ';', we have reached the
1044              end of the statement.  */
1045           if (!nesting_depth)
1046             {
1047               /* Consume the ';'.  */
1048               c_parser_consume_token (parser);
1049               goto finished;
1050             }
1051           break;
1052
1053         case CPP_CLOSE_BRACE:
1054           /* If the next token is a non-nested '}', then we have
1055              reached the end of the current block.  */
1056           if (nesting_depth == 0 || --nesting_depth == 0)
1057             {
1058               c_parser_consume_token (parser);
1059               goto finished;
1060             }
1061           break;
1062
1063         case CPP_OPEN_BRACE:
1064           /* If it the next token is a '{', then we are entering a new
1065              block.  Consume the entire block.  */
1066           ++nesting_depth;
1067           break;
1068
1069         case CPP_PRAGMA:
1070           /* If we see a pragma, consume the whole thing at once.  We
1071              have some safeguards against consuming pragmas willy-nilly.
1072              Normally, we'd expect to be here with parser->error set,
1073              which disables these safeguards.  But it's possible to get
1074              here for secondary error recovery, after parser->error has
1075              been cleared.  */
1076           c_parser_consume_pragma (parser);
1077           c_parser_skip_to_pragma_eol (parser);
1078           parser->error = save_error;
1079           continue;
1080
1081         default:
1082           break;
1083         }
1084
1085       c_parser_consume_token (parser);
1086     }
1087
1088  finished:
1089   parser->error = false;
1090 }
1091
1092 /* CPP's options (initialized by c-opts.c).  */
1093 extern cpp_options *cpp_opts;
1094
1095 /* Save the warning flags which are controlled by __extension__.  */
1096
1097 static inline int
1098 disable_extension_diagnostics (void)
1099 {
1100   int ret = (pedantic
1101              | (warn_pointer_arith << 1)
1102              | (warn_traditional << 2)
1103              | (flag_iso << 3)
1104              | (warn_long_long << 4)
1105              | (warn_cxx_compat << 5)
1106              | (warn_overlength_strings << 6)
1107              /* warn_c90_c99_compat has three states: -1/0/1, so we must
1108                 play tricks to properly restore it.  */
1109              | ((warn_c90_c99_compat == 1) << 7)
1110              | ((warn_c90_c99_compat == -1) << 8)
1111              /* Similarly for warn_c99_c11_compat.  */
1112              | ((warn_c99_c11_compat == 1) << 9)
1113              | ((warn_c99_c11_compat == -1) << 10)
1114              );
1115   cpp_opts->cpp_pedantic = pedantic = 0;
1116   warn_pointer_arith = 0;
1117   cpp_opts->cpp_warn_traditional = warn_traditional = 0;
1118   flag_iso = 0;
1119   cpp_opts->cpp_warn_long_long = warn_long_long = 0;
1120   warn_cxx_compat = 0;
1121   warn_overlength_strings = 0;
1122   warn_c90_c99_compat = 0;
1123   warn_c99_c11_compat = 0;
1124   return ret;
1125 }
1126
1127 /* Restore the warning flags which are controlled by __extension__.
1128    FLAGS is the return value from disable_extension_diagnostics.  */
1129
1130 static inline void
1131 restore_extension_diagnostics (int flags)
1132 {
1133   cpp_opts->cpp_pedantic = pedantic = flags & 1;
1134   warn_pointer_arith = (flags >> 1) & 1;
1135   cpp_opts->cpp_warn_traditional = warn_traditional = (flags >> 2) & 1;
1136   flag_iso = (flags >> 3) & 1;
1137   cpp_opts->cpp_warn_long_long = warn_long_long = (flags >> 4) & 1;
1138   warn_cxx_compat = (flags >> 5) & 1;
1139   warn_overlength_strings = (flags >> 6) & 1;
1140   /* See above for why is this needed.  */
1141   warn_c90_c99_compat = (flags >> 7) & 1 ? 1 : ((flags >> 8) & 1 ? -1 : 0);
1142   warn_c99_c11_compat = (flags >> 9) & 1 ? 1 : ((flags >> 10) & 1 ? -1 : 0);
1143 }
1144
1145 /* Possibly kinds of declarator to parse.  */
1146 typedef enum c_dtr_syn {
1147   /* A normal declarator with an identifier.  */
1148   C_DTR_NORMAL,
1149   /* An abstract declarator (maybe empty).  */
1150   C_DTR_ABSTRACT,
1151   /* A parameter declarator: may be either, but after a type name does
1152      not redeclare a typedef name as an identifier if it can
1153      alternatively be interpreted as a typedef name; see DR#009,
1154      applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
1155      following DR#249.  For example, given a typedef T, "int T" and
1156      "int *T" are valid parameter declarations redeclaring T, while
1157      "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
1158      abstract declarators rather than involving redundant parentheses;
1159      the same applies with attributes inside the parentheses before
1160      "T".  */
1161   C_DTR_PARM
1162 } c_dtr_syn;
1163
1164 /* The binary operation precedence levels, where 0 is a dummy lowest level
1165    used for the bottom of the stack.  */
1166 enum c_parser_prec {
1167   PREC_NONE,
1168   PREC_LOGOR,
1169   PREC_LOGAND,
1170   PREC_BITOR,
1171   PREC_BITXOR,
1172   PREC_BITAND,
1173   PREC_EQ,
1174   PREC_REL,
1175   PREC_SHIFT,
1176   PREC_ADD,
1177   PREC_MULT,
1178   NUM_PRECS
1179 };
1180
1181 static void c_parser_external_declaration (c_parser *);
1182 static void c_parser_asm_definition (c_parser *);
1183 static void c_parser_declaration_or_fndef (c_parser *, bool, bool, bool,
1184                                            bool, bool, tree *, vec<c_token>);
1185 static void c_parser_static_assert_declaration_no_semi (c_parser *);
1186 static void c_parser_static_assert_declaration (c_parser *);
1187 static void c_parser_declspecs (c_parser *, struct c_declspecs *, bool, bool,
1188                                 bool, bool, bool, enum c_lookahead_kind);
1189 static struct c_typespec c_parser_enum_specifier (c_parser *);
1190 static struct c_typespec c_parser_struct_or_union_specifier (c_parser *);
1191 static tree c_parser_struct_declaration (c_parser *);
1192 static struct c_typespec c_parser_typeof_specifier (c_parser *);
1193 static tree c_parser_alignas_specifier (c_parser *);
1194 static struct c_declarator *c_parser_declarator (c_parser *, bool, c_dtr_syn,
1195                                                  bool *);
1196 static struct c_declarator *c_parser_direct_declarator (c_parser *, bool,
1197                                                         c_dtr_syn, bool *);
1198 static struct c_declarator *c_parser_direct_declarator_inner (c_parser *,
1199                                                               bool,
1200                                                               struct c_declarator *);
1201 static struct c_arg_info *c_parser_parms_declarator (c_parser *, bool, tree);
1202 static struct c_arg_info *c_parser_parms_list_declarator (c_parser *, tree,
1203                                                           tree);
1204 static struct c_parm *c_parser_parameter_declaration (c_parser *, tree);
1205 static tree c_parser_simple_asm_expr (c_parser *);
1206 static tree c_parser_attributes (c_parser *);
1207 static struct c_type_name *c_parser_type_name (c_parser *);
1208 static struct c_expr c_parser_initializer (c_parser *);
1209 static struct c_expr c_parser_braced_init (c_parser *, tree, bool);
1210 static void c_parser_initelt (c_parser *, struct obstack *);
1211 static void c_parser_initval (c_parser *, struct c_expr *,
1212                               struct obstack *);
1213 static tree c_parser_compound_statement (c_parser *);
1214 static void c_parser_compound_statement_nostart (c_parser *);
1215 static void c_parser_label (c_parser *);
1216 static void c_parser_statement (c_parser *);
1217 static void c_parser_statement_after_labels (c_parser *);
1218 static void c_parser_if_statement (c_parser *);
1219 static void c_parser_switch_statement (c_parser *);
1220 static void c_parser_while_statement (c_parser *, bool);
1221 static void c_parser_do_statement (c_parser *, bool);
1222 static void c_parser_for_statement (c_parser *, bool);
1223 static tree c_parser_asm_statement (c_parser *);
1224 static tree c_parser_asm_operands (c_parser *);
1225 static tree c_parser_asm_goto_operands (c_parser *);
1226 static tree c_parser_asm_clobbers (c_parser *);
1227 static struct c_expr c_parser_expr_no_commas (c_parser *, struct c_expr *,
1228                                               tree = NULL_TREE);
1229 static struct c_expr c_parser_conditional_expression (c_parser *,
1230                                                       struct c_expr *, tree);
1231 static struct c_expr c_parser_binary_expression (c_parser *, struct c_expr *,
1232                                                  tree);
1233 static struct c_expr c_parser_cast_expression (c_parser *, struct c_expr *);
1234 static struct c_expr c_parser_unary_expression (c_parser *);
1235 static struct c_expr c_parser_sizeof_expression (c_parser *);
1236 static struct c_expr c_parser_alignof_expression (c_parser *);
1237 static struct c_expr c_parser_postfix_expression (c_parser *);
1238 static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *,
1239                                                                    struct c_type_name *,
1240                                                                    location_t);
1241 static struct c_expr c_parser_postfix_expression_after_primary (c_parser *,
1242                                                                 location_t loc,
1243                                                                 struct c_expr);
1244 static tree c_parser_transaction (c_parser *, enum rid);
1245 static struct c_expr c_parser_transaction_expression (c_parser *, enum rid);
1246 static tree c_parser_transaction_cancel (c_parser *);
1247 static struct c_expr c_parser_expression (c_parser *);
1248 static struct c_expr c_parser_expression_conv (c_parser *);
1249 static vec<tree, va_gc> *c_parser_expr_list (c_parser *, bool, bool,
1250                                              vec<tree, va_gc> **, location_t *,
1251                                              tree *, vec<location_t> *,
1252                                              unsigned int * = NULL);
1253 static void c_parser_oacc_enter_exit_data (c_parser *, bool);
1254 static void c_parser_oacc_update (c_parser *);
1255 static tree c_parser_oacc_loop (location_t, c_parser *, char *);
1256 static void c_parser_omp_construct (c_parser *);
1257 static void c_parser_omp_threadprivate (c_parser *);
1258 static void c_parser_omp_barrier (c_parser *);
1259 static void c_parser_omp_flush (c_parser *);
1260 static tree c_parser_omp_for_loop (location_t, c_parser *, enum tree_code,
1261                                    tree, tree *);
1262 static void c_parser_omp_taskwait (c_parser *);
1263 static void c_parser_omp_taskyield (c_parser *);
1264 static void c_parser_omp_cancel (c_parser *);
1265 static void c_parser_omp_cancellation_point (c_parser *);
1266
1267 enum pragma_context { pragma_external, pragma_struct, pragma_param,
1268                       pragma_stmt, pragma_compound };
1269 static bool c_parser_pragma (c_parser *, enum pragma_context);
1270 static bool c_parser_omp_target (c_parser *, enum pragma_context);
1271 static void c_parser_omp_end_declare_target (c_parser *);
1272 static void c_parser_omp_declare (c_parser *, enum pragma_context);
1273
1274 /* These Objective-C parser functions are only ever called when
1275    compiling Objective-C.  */
1276 static void c_parser_objc_class_definition (c_parser *, tree);
1277 static void c_parser_objc_class_instance_variables (c_parser *);
1278 static void c_parser_objc_class_declaration (c_parser *);
1279 static void c_parser_objc_alias_declaration (c_parser *);
1280 static void c_parser_objc_protocol_definition (c_parser *, tree);
1281 static bool c_parser_objc_method_type (c_parser *);
1282 static void c_parser_objc_method_definition (c_parser *);
1283 static void c_parser_objc_methodprotolist (c_parser *);
1284 static void c_parser_objc_methodproto (c_parser *);
1285 static tree c_parser_objc_method_decl (c_parser *, bool, tree *, tree *);
1286 static tree c_parser_objc_type_name (c_parser *);
1287 static tree c_parser_objc_protocol_refs (c_parser *);
1288 static void c_parser_objc_try_catch_finally_statement (c_parser *);
1289 static void c_parser_objc_synchronized_statement (c_parser *);
1290 static tree c_parser_objc_selector (c_parser *);
1291 static tree c_parser_objc_selector_arg (c_parser *);
1292 static tree c_parser_objc_receiver (c_parser *);
1293 static tree c_parser_objc_message_args (c_parser *);
1294 static tree c_parser_objc_keywordexpr (c_parser *);
1295 static void c_parser_objc_at_property_declaration (c_parser *);
1296 static void c_parser_objc_at_synthesize_declaration (c_parser *);
1297 static void c_parser_objc_at_dynamic_declaration (c_parser *);
1298 static bool c_parser_objc_diagnose_bad_element_prefix
1299   (c_parser *, struct c_declspecs *);
1300
1301 /* Cilk Plus supporting routines.  */
1302 static void c_parser_cilk_simd (c_parser *);
1303 static void c_parser_cilk_for (c_parser *, tree);
1304 static bool c_parser_cilk_verify_simd (c_parser *, enum pragma_context);
1305 static tree c_parser_array_notation (location_t, c_parser *, tree, tree);
1306 static tree c_parser_cilk_clause_vectorlength (c_parser *, tree, bool);
1307 static void c_parser_cilk_grainsize (c_parser *);
1308
1309 /* Parse a translation unit (C90 6.7, C99 6.9).
1310
1311    translation-unit:
1312      external-declarations
1313
1314    external-declarations:
1315      external-declaration
1316      external-declarations external-declaration
1317
1318    GNU extensions:
1319
1320    translation-unit:
1321      empty
1322 */
1323
1324 static void
1325 c_parser_translation_unit (c_parser *parser)
1326 {
1327   if (c_parser_next_token_is (parser, CPP_EOF))
1328     {
1329       pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
1330                "ISO C forbids an empty translation unit");
1331     }
1332   else
1333     {
1334       void *obstack_position = obstack_alloc (&parser_obstack, 0);
1335       mark_valid_location_for_stdc_pragma (false);
1336       do
1337         {
1338           ggc_collect ();
1339           c_parser_external_declaration (parser);
1340           obstack_free (&parser_obstack, obstack_position);
1341         }
1342       while (c_parser_next_token_is_not (parser, CPP_EOF));
1343     }
1344 }
1345
1346 /* Parse an external declaration (C90 6.7, C99 6.9).
1347
1348    external-declaration:
1349      function-definition
1350      declaration
1351
1352    GNU extensions:
1353
1354    external-declaration:
1355      asm-definition
1356      ;
1357      __extension__ external-declaration
1358
1359    Objective-C:
1360
1361    external-declaration:
1362      objc-class-definition
1363      objc-class-declaration
1364      objc-alias-declaration
1365      objc-protocol-definition
1366      objc-method-definition
1367      @end
1368 */
1369
1370 static void
1371 c_parser_external_declaration (c_parser *parser)
1372 {
1373   int ext;
1374   switch (c_parser_peek_token (parser)->type)
1375     {
1376     case CPP_KEYWORD:
1377       switch (c_parser_peek_token (parser)->keyword)
1378         {
1379         case RID_EXTENSION:
1380           ext = disable_extension_diagnostics ();
1381           c_parser_consume_token (parser);
1382           c_parser_external_declaration (parser);
1383           restore_extension_diagnostics (ext);
1384           break;
1385         case RID_ASM:
1386           c_parser_asm_definition (parser);
1387           break;
1388         case RID_AT_INTERFACE:
1389         case RID_AT_IMPLEMENTATION:
1390           gcc_assert (c_dialect_objc ());
1391           c_parser_objc_class_definition (parser, NULL_TREE);
1392           break;
1393         case RID_AT_CLASS:
1394           gcc_assert (c_dialect_objc ());
1395           c_parser_objc_class_declaration (parser);
1396           break;
1397         case RID_AT_ALIAS:
1398           gcc_assert (c_dialect_objc ());
1399           c_parser_objc_alias_declaration (parser);
1400           break;
1401         case RID_AT_PROTOCOL:
1402           gcc_assert (c_dialect_objc ());
1403           c_parser_objc_protocol_definition (parser, NULL_TREE);
1404           break;
1405         case RID_AT_PROPERTY:
1406           gcc_assert (c_dialect_objc ());
1407           c_parser_objc_at_property_declaration (parser);
1408           break;
1409         case RID_AT_SYNTHESIZE:
1410           gcc_assert (c_dialect_objc ());
1411           c_parser_objc_at_synthesize_declaration (parser);
1412           break;
1413         case RID_AT_DYNAMIC:
1414           gcc_assert (c_dialect_objc ());
1415           c_parser_objc_at_dynamic_declaration (parser);
1416           break;
1417         case RID_AT_END:
1418           gcc_assert (c_dialect_objc ());
1419           c_parser_consume_token (parser);
1420           objc_finish_implementation ();
1421           break;
1422         default:
1423           goto decl_or_fndef;
1424         }
1425       break;
1426     case CPP_SEMICOLON:
1427       pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
1428                "ISO C does not allow extra %<;%> outside of a function");
1429       c_parser_consume_token (parser);
1430       break;
1431     case CPP_PRAGMA:
1432       mark_valid_location_for_stdc_pragma (true);
1433       c_parser_pragma (parser, pragma_external);
1434       mark_valid_location_for_stdc_pragma (false);
1435       break;
1436     case CPP_PLUS:
1437     case CPP_MINUS:
1438       if (c_dialect_objc ())
1439         {
1440           c_parser_objc_method_definition (parser);
1441           break;
1442         }
1443       /* Else fall through, and yield a syntax error trying to parse
1444          as a declaration or function definition.  */
1445     default:
1446     decl_or_fndef:
1447       /* A declaration or a function definition (or, in Objective-C,
1448          an @interface or @protocol with prefix attributes).  We can
1449          only tell which after parsing the declaration specifiers, if
1450          any, and the first declarator.  */
1451       c_parser_declaration_or_fndef (parser, true, true, true, false, true,
1452                                      NULL, vNULL);
1453       break;
1454     }
1455 }
1456
1457 static void c_finish_omp_declare_simd (c_parser *, tree, tree, vec<c_token>);
1458
1459 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1460    6.7, 6.9.1).  If FNDEF_OK is true, a function definition is
1461    accepted; otherwise (old-style parameter declarations) only other
1462    declarations are accepted.  If STATIC_ASSERT_OK is true, a static
1463    assertion is accepted; otherwise (old-style parameter declarations)
1464    it is not.  If NESTED is true, we are inside a function or parsing
1465    old-style parameter declarations; any functions encountered are
1466    nested functions and declaration specifiers are required; otherwise
1467    we are at top level and functions are normal functions and
1468    declaration specifiers may be optional.  If EMPTY_OK is true, empty
1469    declarations are OK (subject to all other constraints); otherwise
1470    (old-style parameter declarations) they are diagnosed.  If
1471    START_ATTR_OK is true, the declaration specifiers may start with
1472    attributes; otherwise they may not.
1473    OBJC_FOREACH_OBJECT_DECLARATION can be used to get back the parsed
1474    declaration when parsing an Objective-C foreach statement.
1475
1476    declaration:
1477      declaration-specifiers init-declarator-list[opt] ;
1478      static_assert-declaration
1479
1480    function-definition:
1481      declaration-specifiers[opt] declarator declaration-list[opt]
1482        compound-statement
1483
1484    declaration-list:
1485      declaration
1486      declaration-list declaration
1487
1488    init-declarator-list:
1489      init-declarator
1490      init-declarator-list , init-declarator
1491
1492    init-declarator:
1493      declarator simple-asm-expr[opt] attributes[opt]
1494      declarator simple-asm-expr[opt] attributes[opt] = initializer
1495
1496    GNU extensions:
1497
1498    nested-function-definition:
1499      declaration-specifiers declarator declaration-list[opt]
1500        compound-statement
1501
1502    Objective-C:
1503      attributes objc-class-definition
1504      attributes objc-category-definition
1505      attributes objc-protocol-definition
1506
1507    The simple-asm-expr and attributes are GNU extensions.
1508
1509    This function does not handle __extension__; that is handled in its
1510    callers.  ??? Following the old parser, __extension__ may start
1511    external declarations, declarations in functions and declarations
1512    at the start of "for" loops, but not old-style parameter
1513    declarations.
1514
1515    C99 requires declaration specifiers in a function definition; the
1516    absence is diagnosed through the diagnosis of implicit int.  In GNU
1517    C we also allow but diagnose declarations without declaration
1518    specifiers, but only at top level (elsewhere they conflict with
1519    other syntax).
1520
1521    In Objective-C, declarations of the looping variable in a foreach
1522    statement are exceptionally terminated by 'in' (for example, 'for
1523    (NSObject *object in array) { ... }').
1524
1525    OpenMP:
1526
1527    declaration:
1528      threadprivate-directive  */
1529
1530 static void
1531 c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok,
1532                                bool static_assert_ok, bool empty_ok,
1533                                bool nested, bool start_attr_ok,
1534                                tree *objc_foreach_object_declaration,
1535                                vec<c_token> omp_declare_simd_clauses)
1536 {
1537   struct c_declspecs *specs;
1538   tree prefix_attrs;
1539   tree all_prefix_attrs;
1540   bool diagnosed_no_specs = false;
1541   location_t here = c_parser_peek_token (parser)->location;
1542
1543   if (static_assert_ok
1544       && c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
1545     {
1546       c_parser_static_assert_declaration (parser);
1547       return;
1548     }
1549   specs = build_null_declspecs ();
1550
1551   /* Try to detect an unknown type name when we have "A B" or "A *B".  */
1552   if (c_parser_peek_token (parser)->type == CPP_NAME
1553       && c_parser_peek_token (parser)->id_kind == C_ID_ID
1554       && (c_parser_peek_2nd_token (parser)->type == CPP_NAME
1555           || c_parser_peek_2nd_token (parser)->type == CPP_MULT)
1556       && (!nested || !lookup_name (c_parser_peek_token (parser)->value)))
1557     {
1558       error_at (here, "unknown type name %qE",
1559                 c_parser_peek_token (parser)->value);
1560
1561       /* Parse declspecs normally to get a correct pointer type, but avoid
1562          a further "fails to be a type name" error.  Refuse nested functions
1563          since it is not how the user likely wants us to recover.  */
1564       c_parser_peek_token (parser)->type = CPP_KEYWORD;
1565       c_parser_peek_token (parser)->keyword = RID_VOID;
1566       c_parser_peek_token (parser)->value = error_mark_node;
1567       fndef_ok = !nested;
1568     }
1569
1570   c_parser_declspecs (parser, specs, true, true, start_attr_ok,
1571                       true, true, cla_nonabstract_decl);
1572   if (parser->error)
1573     {
1574       c_parser_skip_to_end_of_block_or_statement (parser);
1575       return;
1576     }
1577   if (nested && !specs->declspecs_seen_p)
1578     {
1579       c_parser_error (parser, "expected declaration specifiers");
1580       c_parser_skip_to_end_of_block_or_statement (parser);
1581       return;
1582     }
1583   finish_declspecs (specs);
1584   bool auto_type_p = specs->typespec_word == cts_auto_type;
1585   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1586     {
1587       if (auto_type_p)
1588         error_at (here, "%<__auto_type%> in empty declaration");
1589       else if (empty_ok)
1590         shadow_tag (specs);
1591       else
1592         {
1593           shadow_tag_warned (specs, 1);
1594           pedwarn (here, 0, "empty declaration");
1595         }
1596       c_parser_consume_token (parser);
1597       return;
1598     }
1599
1600   /* Provide better error recovery.  Note that a type name here is usually
1601      better diagnosed as a redeclaration.  */
1602   if (empty_ok
1603       && specs->typespec_kind == ctsk_tagdef
1604       && c_parser_next_token_starts_declspecs (parser)
1605       && !c_parser_next_token_is (parser, CPP_NAME))
1606     {
1607       c_parser_error (parser, "expected %<;%>, identifier or %<(%>");
1608       parser->error = false;
1609       shadow_tag_warned (specs, 1);
1610       return;
1611     }
1612   else if (c_dialect_objc () && !auto_type_p)
1613     {
1614       /* Prefix attributes are an error on method decls.  */
1615       switch (c_parser_peek_token (parser)->type)
1616         {
1617           case CPP_PLUS:
1618           case CPP_MINUS:
1619             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
1620               return;
1621             if (specs->attrs)
1622               {
1623                 warning_at (c_parser_peek_token (parser)->location, 
1624                             OPT_Wattributes,
1625                             "prefix attributes are ignored for methods");
1626                 specs->attrs = NULL_TREE;
1627               }
1628             if (fndef_ok)
1629               c_parser_objc_method_definition (parser);
1630             else
1631               c_parser_objc_methodproto (parser);
1632             return;
1633             break;
1634           default:
1635             break;
1636         }
1637       /* This is where we parse 'attributes @interface ...',
1638          'attributes @implementation ...', 'attributes @protocol ...'
1639          (where attributes could be, for example, __attribute__
1640          ((deprecated)).
1641       */
1642       switch (c_parser_peek_token (parser)->keyword)
1643         {
1644         case RID_AT_INTERFACE:
1645           {
1646             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
1647               return;
1648             c_parser_objc_class_definition (parser, specs->attrs);
1649             return;
1650           }
1651           break;
1652         case RID_AT_IMPLEMENTATION:
1653           {
1654             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
1655               return;
1656             if (specs->attrs)
1657               {
1658                 warning_at (c_parser_peek_token (parser)->location, 
1659                         OPT_Wattributes,
1660                         "prefix attributes are ignored for implementations");
1661                 specs->attrs = NULL_TREE;
1662               }
1663             c_parser_objc_class_definition (parser, NULL_TREE);     
1664             return;
1665           }
1666           break;
1667         case RID_AT_PROTOCOL:
1668           {
1669             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
1670               return;
1671             c_parser_objc_protocol_definition (parser, specs->attrs);
1672             return;
1673           }
1674           break;
1675         case RID_AT_ALIAS:
1676         case RID_AT_CLASS:
1677         case RID_AT_END:
1678         case RID_AT_PROPERTY:
1679           if (specs->attrs)
1680             {
1681               c_parser_error (parser, "unexpected attribute");
1682               specs->attrs = NULL;
1683             }
1684           break;
1685         default:
1686           break;
1687         }
1688     }
1689   
1690   pending_xref_error ();
1691   prefix_attrs = specs->attrs;
1692   all_prefix_attrs = prefix_attrs;
1693   specs->attrs = NULL_TREE;
1694   while (true)
1695     {
1696       struct c_declarator *declarator;
1697       bool dummy = false;
1698       timevar_id_t tv;
1699       tree fnbody;
1700       /* Declaring either one or more declarators (in which case we
1701          should diagnose if there were no declaration specifiers) or a
1702          function definition (in which case the diagnostic for
1703          implicit int suffices).  */
1704       declarator = c_parser_declarator (parser, 
1705                                         specs->typespec_kind != ctsk_none,
1706                                         C_DTR_NORMAL, &dummy);
1707       if (declarator == NULL)
1708         {
1709           if (omp_declare_simd_clauses.exists ()
1710               || !vec_safe_is_empty (parser->cilk_simd_fn_tokens))
1711             c_finish_omp_declare_simd (parser, NULL_TREE, NULL_TREE,
1712                                        omp_declare_simd_clauses);
1713           c_parser_skip_to_end_of_block_or_statement (parser);
1714           return;
1715         }
1716       if (auto_type_p && declarator->kind != cdk_id)
1717         {
1718           error_at (here,
1719                     "%<__auto_type%> requires a plain identifier"
1720                     " as declarator");
1721           c_parser_skip_to_end_of_block_or_statement (parser);
1722           return;
1723         }
1724       if (c_parser_next_token_is (parser, CPP_EQ)
1725           || c_parser_next_token_is (parser, CPP_COMMA)
1726           || c_parser_next_token_is (parser, CPP_SEMICOLON)
1727           || c_parser_next_token_is_keyword (parser, RID_ASM)
1728           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)
1729           || c_parser_next_token_is_keyword (parser, RID_IN))
1730         {
1731           tree asm_name = NULL_TREE;
1732           tree postfix_attrs = NULL_TREE;
1733           if (!diagnosed_no_specs && !specs->declspecs_seen_p)
1734             {
1735               diagnosed_no_specs = true;
1736               pedwarn (here, 0, "data definition has no type or storage class");
1737             }
1738           /* Having seen a data definition, there cannot now be a
1739              function definition.  */
1740           fndef_ok = false;
1741           if (c_parser_next_token_is_keyword (parser, RID_ASM))
1742             asm_name = c_parser_simple_asm_expr (parser);
1743           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1744             {
1745               postfix_attrs = c_parser_attributes (parser);
1746               if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
1747                 {
1748                   /* This means there is an attribute specifier after
1749                      the declarator in a function definition.  Provide
1750                      some more information for the user.  */
1751                   error_at (here, "attributes should be specified before the "
1752                             "declarator in a function definition");
1753                   c_parser_skip_to_end_of_block_or_statement (parser);
1754                   return;
1755                 }
1756             }
1757           if (c_parser_next_token_is (parser, CPP_EQ))
1758             {
1759               tree d;
1760               struct c_expr init;
1761               location_t init_loc;
1762               c_parser_consume_token (parser);
1763               if (auto_type_p)
1764                 {
1765                   start_init (NULL_TREE, asm_name, global_bindings_p ());
1766                   init_loc = c_parser_peek_token (parser)->location;
1767                   init = c_parser_expr_no_commas (parser, NULL);
1768                   if (TREE_CODE (init.value) == COMPONENT_REF
1769                       && DECL_C_BIT_FIELD (TREE_OPERAND (init.value, 1)))
1770                     error_at (here,
1771                               "%<__auto_type%> used with a bit-field"
1772                               " initializer");
1773                   init = convert_lvalue_to_rvalue (init_loc, init, true, true);
1774                   tree init_type = TREE_TYPE (init.value);
1775                   /* As with typeof, remove all qualifiers from atomic types.  */
1776                   if (init_type != error_mark_node && TYPE_ATOMIC (init_type))
1777                     init_type
1778                       = c_build_qualified_type (init_type, TYPE_UNQUALIFIED);
1779                   bool vm_type = variably_modified_type_p (init_type,
1780                                                            NULL_TREE);
1781                   if (vm_type)
1782                     init.value = c_save_expr (init.value);
1783                   finish_init ();
1784                   specs->typespec_kind = ctsk_typeof;
1785                   specs->locations[cdw_typedef] = init_loc;
1786                   specs->typedef_p = true;
1787                   specs->type = init_type;
1788                   if (vm_type)
1789                     {
1790                       bool maybe_const = true;
1791                       tree type_expr = c_fully_fold (init.value, false,
1792                                                      &maybe_const);
1793                       specs->expr_const_operands &= maybe_const;
1794                       if (specs->expr)
1795                         specs->expr = build2 (COMPOUND_EXPR,
1796                                               TREE_TYPE (type_expr),
1797                                               specs->expr, type_expr);
1798                       else
1799                         specs->expr = type_expr;
1800                     }
1801                   d = start_decl (declarator, specs, true,
1802                                   chainon (postfix_attrs, all_prefix_attrs));
1803                   if (!d)
1804                     d = error_mark_node;
1805                   if (omp_declare_simd_clauses.exists ()
1806                       || !vec_safe_is_empty (parser->cilk_simd_fn_tokens))
1807                     c_finish_omp_declare_simd (parser, d, NULL_TREE,
1808                                                omp_declare_simd_clauses);
1809                 }
1810               else
1811                 {
1812                   /* The declaration of the variable is in effect while
1813                      its initializer is parsed.  */
1814                   d = start_decl (declarator, specs, true,
1815                                   chainon (postfix_attrs, all_prefix_attrs));
1816                   if (!d)
1817                     d = error_mark_node;
1818                   if (omp_declare_simd_clauses.exists ()
1819                       || !vec_safe_is_empty (parser->cilk_simd_fn_tokens))
1820                     c_finish_omp_declare_simd (parser, d, NULL_TREE,
1821                                                omp_declare_simd_clauses);
1822                   start_init (d, asm_name, global_bindings_p ());
1823                   init_loc = c_parser_peek_token (parser)->location;
1824                   init = c_parser_initializer (parser);
1825                   finish_init ();
1826                 }
1827               if (d != error_mark_node)
1828                 {
1829                   maybe_warn_string_init (init_loc, TREE_TYPE (d), init);
1830                   finish_decl (d, init_loc, init.value,
1831                                init.original_type, asm_name);
1832                 }
1833             }
1834           else
1835             {
1836               if (auto_type_p)
1837                 {
1838                   error_at (here,
1839                             "%<__auto_type%> requires an initialized "
1840                             "data declaration");
1841                   c_parser_skip_to_end_of_block_or_statement (parser);
1842                   return;
1843                 }
1844               tree d = start_decl (declarator, specs, false,
1845                                    chainon (postfix_attrs,
1846                                             all_prefix_attrs));
1847               if (omp_declare_simd_clauses.exists ()
1848                   || !vec_safe_is_empty (parser->cilk_simd_fn_tokens))
1849                 {
1850                   tree parms = NULL_TREE;
1851                   if (d && TREE_CODE (d) == FUNCTION_DECL)
1852                     {
1853                       struct c_declarator *ce = declarator;
1854                       while (ce != NULL)
1855                         if (ce->kind == cdk_function)
1856                           {
1857                             parms = ce->u.arg_info->parms;
1858                             break;
1859                           }
1860                         else
1861                           ce = ce->declarator;
1862                     }
1863                   if (parms)
1864                     temp_store_parm_decls (d, parms);
1865                   c_finish_omp_declare_simd (parser, d, parms,
1866                                              omp_declare_simd_clauses);
1867                   if (parms)
1868                     temp_pop_parm_decls ();
1869                 }
1870               if (d)
1871                 finish_decl (d, UNKNOWN_LOCATION, NULL_TREE,
1872                              NULL_TREE, asm_name);
1873               
1874               if (c_parser_next_token_is_keyword (parser, RID_IN))
1875                 {
1876                   if (d)
1877                     *objc_foreach_object_declaration = d;
1878                   else
1879                     *objc_foreach_object_declaration = error_mark_node;             
1880                 }
1881             }
1882           if (c_parser_next_token_is (parser, CPP_COMMA))
1883             {
1884               if (auto_type_p)
1885                 {
1886                   error_at (here,
1887                             "%<__auto_type%> may only be used with"
1888                             " a single declarator");
1889                   c_parser_skip_to_end_of_block_or_statement (parser);
1890                   return;
1891                 }
1892               c_parser_consume_token (parser);
1893               if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1894                 all_prefix_attrs = chainon (c_parser_attributes (parser),
1895                                             prefix_attrs);
1896               else
1897                 all_prefix_attrs = prefix_attrs;
1898               continue;
1899             }
1900           else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1901             {
1902               c_parser_consume_token (parser);
1903               return;
1904             }
1905           else if (c_parser_next_token_is_keyword (parser, RID_IN))
1906             {
1907               /* This can only happen in Objective-C: we found the
1908                  'in' that terminates the declaration inside an
1909                  Objective-C foreach statement.  Do not consume the
1910                  token, so that the caller can use it to determine
1911                  that this indeed is a foreach context.  */
1912               return;
1913             }
1914           else
1915             {
1916               c_parser_error (parser, "expected %<,%> or %<;%>");
1917               c_parser_skip_to_end_of_block_or_statement (parser);
1918               return;
1919             }
1920         }
1921       else if (auto_type_p)
1922         {
1923           error_at (here,
1924                     "%<__auto_type%> requires an initialized data declaration");
1925           c_parser_skip_to_end_of_block_or_statement (parser);
1926           return;
1927         }
1928       else if (!fndef_ok)
1929         {
1930           c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
1931                           "%<asm%> or %<__attribute__%>");
1932           c_parser_skip_to_end_of_block_or_statement (parser);
1933           return;
1934         }
1935       /* Function definition (nested or otherwise).  */
1936       if (nested)
1937         {
1938           pedwarn (here, OPT_Wpedantic, "ISO C forbids nested functions");
1939           c_push_function_context ();
1940         }
1941       if (!start_function (specs, declarator, all_prefix_attrs))
1942         {
1943           /* This can appear in many cases looking nothing like a
1944              function definition, so we don't give a more specific
1945              error suggesting there was one.  */
1946           c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
1947                           "or %<__attribute__%>");
1948           if (nested)
1949             c_pop_function_context ();
1950           break;
1951         }
1952
1953       if (DECL_DECLARED_INLINE_P (current_function_decl))
1954         tv = TV_PARSE_INLINE;
1955       else
1956         tv = TV_PARSE_FUNC;
1957       timevar_push (tv);
1958
1959       /* Parse old-style parameter declarations.  ??? Attributes are
1960          not allowed to start declaration specifiers here because of a
1961          syntax conflict between a function declaration with attribute
1962          suffix and a function definition with an attribute prefix on
1963          first old-style parameter declaration.  Following the old
1964          parser, they are not accepted on subsequent old-style
1965          parameter declarations either.  However, there is no
1966          ambiguity after the first declaration, nor indeed on the
1967          first as long as we don't allow postfix attributes after a
1968          declarator with a nonempty identifier list in a definition;
1969          and postfix attributes have never been accepted here in
1970          function definitions either.  */
1971       while (c_parser_next_token_is_not (parser, CPP_EOF)
1972              && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE))
1973         c_parser_declaration_or_fndef (parser, false, false, false,
1974                                        true, false, NULL, vNULL);
1975       store_parm_decls ();
1976       if (omp_declare_simd_clauses.exists ()
1977           || !vec_safe_is_empty (parser->cilk_simd_fn_tokens))
1978         c_finish_omp_declare_simd (parser, current_function_decl, NULL_TREE,
1979                                    omp_declare_simd_clauses);
1980       DECL_STRUCT_FUNCTION (current_function_decl)->function_start_locus
1981         = c_parser_peek_token (parser)->location;
1982       fnbody = c_parser_compound_statement (parser);
1983       if (flag_cilkplus && contains_array_notation_expr (fnbody))
1984         fnbody = expand_array_notation_exprs (fnbody);
1985       if (nested)
1986         {
1987           tree decl = current_function_decl;
1988           /* Mark nested functions as needing static-chain initially.
1989              lower_nested_functions will recompute it but the
1990              DECL_STATIC_CHAIN flag is also used before that happens,
1991              by initializer_constant_valid_p.  See gcc.dg/nested-fn-2.c.  */
1992           DECL_STATIC_CHAIN (decl) = 1;
1993           add_stmt (fnbody);
1994           finish_function ();
1995           c_pop_function_context ();
1996           add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
1997         }
1998       else
1999         {
2000           add_stmt (fnbody);
2001           finish_function ();
2002         }
2003
2004       timevar_pop (tv);
2005       break;
2006     }
2007 }
2008
2009 /* Parse an asm-definition (asm() outside a function body).  This is a
2010    GNU extension.
2011
2012    asm-definition:
2013      simple-asm-expr ;
2014 */
2015
2016 static void
2017 c_parser_asm_definition (c_parser *parser)
2018 {
2019   tree asm_str = c_parser_simple_asm_expr (parser);
2020   if (asm_str)
2021     symtab->finalize_toplevel_asm (asm_str);
2022   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
2023 }
2024
2025 /* Parse a static assertion (C11 6.7.10).
2026
2027    static_assert-declaration:
2028      static_assert-declaration-no-semi ;
2029 */
2030
2031 static void
2032 c_parser_static_assert_declaration (c_parser *parser)
2033 {
2034   c_parser_static_assert_declaration_no_semi (parser);
2035   if (parser->error
2036       || !c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
2037     c_parser_skip_to_end_of_block_or_statement (parser);
2038 }
2039
2040 /* Parse a static assertion (C11 6.7.10), without the trailing
2041    semicolon.
2042
2043    static_assert-declaration-no-semi:
2044      _Static_assert ( constant-expression , string-literal )
2045 */
2046
2047 static void
2048 c_parser_static_assert_declaration_no_semi (c_parser *parser)
2049 {
2050   location_t assert_loc, value_loc;
2051   tree value;
2052   tree string;
2053
2054   gcc_assert (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT));
2055   assert_loc = c_parser_peek_token (parser)->location;
2056   if (flag_isoc99)
2057     pedwarn_c99 (assert_loc, OPT_Wpedantic,
2058                  "ISO C99 does not support %<_Static_assert%>");
2059   else
2060     pedwarn_c99 (assert_loc, OPT_Wpedantic,
2061                  "ISO C90 does not support %<_Static_assert%>");
2062   c_parser_consume_token (parser);
2063   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2064     return;
2065   value_loc = c_parser_peek_token (parser)->location;
2066   value = c_parser_expr_no_commas (parser, NULL).value;
2067   parser->lex_untranslated_string = true;
2068   if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
2069     {
2070       parser->lex_untranslated_string = false;
2071       return;
2072     }
2073   switch (c_parser_peek_token (parser)->type)
2074     {
2075     case CPP_STRING:
2076     case CPP_STRING16:
2077     case CPP_STRING32:
2078     case CPP_WSTRING:
2079     case CPP_UTF8STRING:
2080       string = c_parser_peek_token (parser)->value;
2081       c_parser_consume_token (parser);
2082       parser->lex_untranslated_string = false;
2083       break;
2084     default:
2085       c_parser_error (parser, "expected string literal");
2086       parser->lex_untranslated_string = false;
2087       return;
2088     }
2089   c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>");
2090
2091   if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
2092     {
2093       error_at (value_loc, "expression in static assertion is not an integer");
2094       return;
2095     }
2096   if (TREE_CODE (value) != INTEGER_CST)
2097     {
2098       value = c_fully_fold (value, false, NULL);
2099       /* Strip no-op conversions.  */
2100       STRIP_TYPE_NOPS (value);
2101       if (TREE_CODE (value) == INTEGER_CST)
2102         pedwarn (value_loc, OPT_Wpedantic, "expression in static assertion "
2103                  "is not an integer constant expression");
2104     }
2105   if (TREE_CODE (value) != INTEGER_CST)
2106     {
2107       error_at (value_loc, "expression in static assertion is not constant");
2108       return;
2109     }
2110   constant_expression_warning (value);
2111   if (integer_zerop (value))
2112     error_at (assert_loc, "static assertion failed: %E", string);
2113 }
2114
2115 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
2116    6.7), adding them to SPECS (which may already include some).
2117    Storage class specifiers are accepted iff SCSPEC_OK; type
2118    specifiers are accepted iff TYPESPEC_OK; alignment specifiers are
2119    accepted iff ALIGNSPEC_OK; attributes are accepted at the start
2120    iff START_ATTR_OK; __auto_type is accepted iff AUTO_TYPE_OK.
2121
2122    declaration-specifiers:
2123      storage-class-specifier declaration-specifiers[opt]
2124      type-specifier declaration-specifiers[opt]
2125      type-qualifier declaration-specifiers[opt]
2126      function-specifier declaration-specifiers[opt]
2127      alignment-specifier declaration-specifiers[opt]
2128
2129    Function specifiers (inline) are from C99, and are currently
2130    handled as storage class specifiers, as is __thread.  Alignment
2131    specifiers are from C11.
2132
2133    C90 6.5.1, C99 6.7.1:
2134    storage-class-specifier:
2135      typedef
2136      extern
2137      static
2138      auto
2139      register
2140      _Thread_local
2141
2142    (_Thread_local is new in C11.)
2143
2144    C99 6.7.4:
2145    function-specifier:
2146      inline
2147      _Noreturn
2148
2149    (_Noreturn is new in C11.)
2150
2151    C90 6.5.2, C99 6.7.2:
2152    type-specifier:
2153      void
2154      char
2155      short
2156      int
2157      long
2158      float
2159      double
2160      signed
2161      unsigned
2162      _Bool
2163      _Complex
2164      [_Imaginary removed in C99 TC2]
2165      struct-or-union-specifier
2166      enum-specifier
2167      typedef-name
2168      atomic-type-specifier
2169
2170    (_Bool and _Complex are new in C99.)
2171    (atomic-type-specifier is new in C11.)
2172
2173    C90 6.5.3, C99 6.7.3:
2174
2175    type-qualifier:
2176      const
2177      restrict
2178      volatile
2179      address-space-qualifier
2180      _Atomic
2181
2182    (restrict is new in C99.)
2183    (_Atomic is new in C11.)
2184
2185    GNU extensions:
2186
2187    declaration-specifiers:
2188      attributes declaration-specifiers[opt]
2189
2190    type-qualifier:
2191      address-space
2192
2193    address-space:
2194      identifier recognized by the target
2195
2196    storage-class-specifier:
2197      __thread
2198
2199    type-specifier:
2200      typeof-specifier
2201      __auto_type
2202      __intN
2203      _Decimal32
2204      _Decimal64
2205      _Decimal128
2206      _Fract
2207      _Accum
2208      _Sat
2209
2210   (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
2211    http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
2212
2213    atomic-type-specifier
2214     _Atomic ( type-name )
2215
2216    Objective-C:
2217
2218    type-specifier:
2219      class-name objc-protocol-refs[opt]
2220      typedef-name objc-protocol-refs
2221      objc-protocol-refs
2222 */
2223
2224 static void
2225 c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
2226                     bool scspec_ok, bool typespec_ok, bool start_attr_ok,
2227                     bool alignspec_ok, bool auto_type_ok,
2228                     enum c_lookahead_kind la)
2229 {
2230   bool attrs_ok = start_attr_ok;
2231   bool seen_type = specs->typespec_kind != ctsk_none;
2232
2233   if (!typespec_ok)
2234     gcc_assert (la == cla_prefer_id);
2235
2236   while (c_parser_next_token_is (parser, CPP_NAME)
2237          || c_parser_next_token_is (parser, CPP_KEYWORD)
2238          || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
2239     {
2240       struct c_typespec t;
2241       tree attrs;
2242       tree align;
2243       location_t loc = c_parser_peek_token (parser)->location;
2244
2245       /* If we cannot accept a type, exit if the next token must start
2246          one.  Also, if we already have seen a tagged definition,
2247          a typename would be an error anyway and likely the user
2248          has simply forgotten a semicolon, so we exit.  */
2249       if ((!typespec_ok || specs->typespec_kind == ctsk_tagdef)
2250           && c_parser_next_tokens_start_typename (parser, la)
2251           && !c_parser_next_token_is_qualifier (parser))
2252         break;
2253
2254       if (c_parser_next_token_is (parser, CPP_NAME))
2255         {
2256           c_token *name_token = c_parser_peek_token (parser);
2257           tree value = name_token->value;
2258           c_id_kind kind = name_token->id_kind;
2259
2260           if (kind == C_ID_ADDRSPACE)
2261             {
2262               addr_space_t as
2263                 = name_token->keyword - RID_FIRST_ADDR_SPACE;
2264               declspecs_add_addrspace (name_token->location, specs, as);
2265               c_parser_consume_token (parser);
2266               attrs_ok = true;
2267               continue;
2268             }
2269
2270           gcc_assert (!c_parser_next_token_is_qualifier (parser));
2271
2272           /* If we cannot accept a type, and the next token must start one,
2273              exit.  Do the same if we already have seen a tagged definition,
2274              since it would be an error anyway and likely the user has simply
2275              forgotten a semicolon.  */
2276           if (seen_type || !c_parser_next_tokens_start_typename (parser, la))
2277             break;
2278
2279           /* Now at an unknown typename (C_ID_ID), a C_ID_TYPENAME or
2280              a C_ID_CLASSNAME.  */
2281           c_parser_consume_token (parser);
2282           seen_type = true;
2283           attrs_ok = true;
2284           if (kind == C_ID_ID)
2285             {
2286               error_at (loc, "unknown type name %qE", value);
2287               t.kind = ctsk_typedef;
2288               t.spec = error_mark_node;
2289             }
2290           else if (kind == C_ID_TYPENAME
2291                    && (!c_dialect_objc ()
2292                        || c_parser_next_token_is_not (parser, CPP_LESS)))
2293             {
2294               t.kind = ctsk_typedef;
2295               /* For a typedef name, record the meaning, not the name.
2296                  In case of 'foo foo, bar;'.  */
2297               t.spec = lookup_name (value);
2298             }
2299           else
2300             {
2301               tree proto = NULL_TREE;
2302               gcc_assert (c_dialect_objc ());
2303               t.kind = ctsk_objc;
2304               if (c_parser_next_token_is (parser, CPP_LESS))
2305                 proto = c_parser_objc_protocol_refs (parser);
2306               t.spec = objc_get_protocol_qualified_type (value, proto);
2307             }
2308           t.expr = NULL_TREE;
2309           t.expr_const_operands = true;
2310           declspecs_add_type (name_token->location, specs, t);
2311           continue;
2312         }
2313       if (c_parser_next_token_is (parser, CPP_LESS))
2314         {
2315           /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
2316              nisse@lysator.liu.se.  */
2317           tree proto;
2318           gcc_assert (c_dialect_objc ());
2319           if (!typespec_ok || seen_type)
2320             break;
2321           proto = c_parser_objc_protocol_refs (parser);
2322           t.kind = ctsk_objc;
2323           t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
2324           t.expr = NULL_TREE;
2325           t.expr_const_operands = true;
2326           declspecs_add_type (loc, specs, t);
2327           continue;
2328         }
2329       gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
2330       switch (c_parser_peek_token (parser)->keyword)
2331         {
2332         case RID_STATIC:
2333         case RID_EXTERN:
2334         case RID_REGISTER:
2335         case RID_TYPEDEF:
2336         case RID_INLINE:
2337         case RID_NORETURN:
2338         case RID_AUTO:
2339         case RID_THREAD:
2340           if (!scspec_ok)
2341             goto out;
2342           attrs_ok = true;
2343           /* TODO: Distinguish between function specifiers (inline, noreturn)
2344              and storage class specifiers, either here or in
2345              declspecs_add_scspec.  */
2346           declspecs_add_scspec (loc, specs,
2347                                 c_parser_peek_token (parser)->value);
2348           c_parser_consume_token (parser);
2349           break;
2350         case RID_AUTO_TYPE:
2351           if (!auto_type_ok)
2352             goto out;
2353           /* Fall through.  */
2354         case RID_UNSIGNED:
2355         case RID_LONG:
2356         case RID_SHORT:
2357         case RID_SIGNED:
2358         case RID_COMPLEX:
2359         case RID_INT:
2360         case RID_CHAR:
2361         case RID_FLOAT:
2362         case RID_DOUBLE:
2363         case RID_VOID:
2364         case RID_DFLOAT32:
2365         case RID_DFLOAT64:
2366         case RID_DFLOAT128:
2367         case RID_BOOL:
2368         case RID_FRACT:
2369         case RID_ACCUM:
2370         case RID_SAT:
2371         case RID_INT_N_0:
2372         case RID_INT_N_1:
2373         case RID_INT_N_2:
2374         case RID_INT_N_3:
2375           if (!typespec_ok)
2376             goto out;
2377           attrs_ok = true;
2378           seen_type = true;
2379           if (c_dialect_objc ())
2380             parser->objc_need_raw_identifier = true;
2381           t.kind = ctsk_resword;
2382           t.spec = c_parser_peek_token (parser)->value;
2383           t.expr = NULL_TREE;
2384           t.expr_const_operands = true;
2385           declspecs_add_type (loc, specs, t);
2386           c_parser_consume_token (parser);
2387           break;
2388         case RID_ENUM:
2389           if (!typespec_ok)
2390             goto out;
2391           attrs_ok = true;
2392           seen_type = true;
2393           t = c_parser_enum_specifier (parser);
2394           declspecs_add_type (loc, specs, t);
2395           break;
2396         case RID_STRUCT:
2397         case RID_UNION:
2398           if (!typespec_ok)
2399             goto out;
2400           attrs_ok = true;
2401           seen_type = true;
2402           t = c_parser_struct_or_union_specifier (parser);
2403           invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec);
2404           declspecs_add_type (loc, specs, t);
2405           break;
2406         case RID_TYPEOF:
2407           /* ??? The old parser rejected typeof after other type
2408              specifiers, but is a syntax error the best way of
2409              handling this?  */
2410           if (!typespec_ok || seen_type)
2411             goto out;
2412           attrs_ok = true;
2413           seen_type = true;
2414           t = c_parser_typeof_specifier (parser);
2415           declspecs_add_type (loc, specs, t);
2416           break;
2417         case RID_ATOMIC:
2418           /* C parser handling of Objective-C constructs needs
2419              checking for correct lvalue-to-rvalue conversions, and
2420              the code in build_modify_expr handling various
2421              Objective-C cases, and that in build_unary_op handling
2422              Objective-C cases for increment / decrement, also needs
2423              updating; uses of TYPE_MAIN_VARIANT in objc_compare_types
2424              and objc_types_are_equivalent may also need updates.  */
2425           if (c_dialect_objc ())
2426             sorry ("%<_Atomic%> in Objective-C");
2427           /* C parser handling of OpenMP constructs needs checking for
2428              correct lvalue-to-rvalue conversions.  */
2429           if (flag_openmp)
2430             sorry ("%<_Atomic%> with OpenMP");
2431           if (flag_isoc99)
2432             pedwarn_c99 (loc, OPT_Wpedantic,
2433                          "ISO C99 does not support the %<_Atomic%> qualifier");
2434           else
2435             pedwarn_c99 (loc, OPT_Wpedantic,
2436                          "ISO C90 does not support the %<_Atomic%> qualifier");
2437           attrs_ok = true;
2438           tree value;
2439           value = c_parser_peek_token (parser)->value;
2440           c_parser_consume_token (parser);
2441           if (typespec_ok && c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2442             {
2443               /* _Atomic ( type-name ).  */
2444               seen_type = true;
2445               c_parser_consume_token (parser);
2446               struct c_type_name *type = c_parser_type_name (parser);
2447               t.kind = ctsk_typeof;
2448               t.spec = error_mark_node;
2449               t.expr = NULL_TREE;
2450               t.expr_const_operands = true;
2451               if (type != NULL)
2452                 t.spec = groktypename (type, &t.expr,
2453                                        &t.expr_const_operands);
2454               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2455                                          "expected %<)%>");
2456               if (t.spec != error_mark_node)
2457                 {
2458                   if (TREE_CODE (t.spec) == ARRAY_TYPE)
2459                     error_at (loc, "%<_Atomic%>-qualified array type");
2460                   else if (TREE_CODE (t.spec) == FUNCTION_TYPE)
2461                     error_at (loc, "%<_Atomic%>-qualified function type");
2462                   else if (TYPE_QUALS (t.spec) != TYPE_UNQUALIFIED)
2463                     error_at (loc, "%<_Atomic%> applied to a qualified type");
2464                   else
2465                     t.spec = c_build_qualified_type (t.spec, TYPE_QUAL_ATOMIC);
2466                 }
2467               declspecs_add_type (loc, specs, t);
2468             }
2469           else
2470             declspecs_add_qual (loc, specs, value);
2471           break;
2472         case RID_CONST:
2473         case RID_VOLATILE:
2474         case RID_RESTRICT:
2475           attrs_ok = true;
2476           declspecs_add_qual (loc, specs, c_parser_peek_token (parser)->value);
2477           c_parser_consume_token (parser);
2478           break;
2479         case RID_ATTRIBUTE:
2480           if (!attrs_ok)
2481             goto out;
2482           attrs = c_parser_attributes (parser);
2483           declspecs_add_attrs (loc, specs, attrs);
2484           break;
2485         case RID_ALIGNAS:
2486           if (!alignspec_ok)
2487             goto out;
2488           align = c_parser_alignas_specifier (parser);
2489           declspecs_add_alignas (loc, specs, align);
2490           break;
2491         default:
2492           goto out;
2493         }
2494     }
2495  out: ;
2496 }
2497
2498 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
2499
2500    enum-specifier:
2501      enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
2502      enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
2503      enum attributes[opt] identifier
2504
2505    The form with trailing comma is new in C99.  The forms with
2506    attributes are GNU extensions.  In GNU C, we accept any expression
2507    without commas in the syntax (assignment expressions, not just
2508    conditional expressions); assignment expressions will be diagnosed
2509    as non-constant.
2510
2511    enumerator-list:
2512      enumerator
2513      enumerator-list , enumerator
2514
2515    enumerator:
2516      enumeration-constant
2517      enumeration-constant = constant-expression
2518 */
2519
2520 static struct c_typespec
2521 c_parser_enum_specifier (c_parser *parser)
2522 {
2523   struct c_typespec ret;
2524   tree attrs;
2525   tree ident = NULL_TREE;
2526   location_t enum_loc;
2527   location_t ident_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
2528   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM));
2529   enum_loc = c_parser_peek_token (parser)->location;
2530   c_parser_consume_token (parser);
2531   attrs = c_parser_attributes (parser);
2532   enum_loc = c_parser_peek_token (parser)->location;
2533   /* Set the location in case we create a decl now.  */
2534   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
2535   if (c_parser_next_token_is (parser, CPP_NAME))
2536     {
2537       ident = c_parser_peek_token (parser)->value;
2538       ident_loc = c_parser_peek_token (parser)->location;
2539       enum_loc = ident_loc;
2540       c_parser_consume_token (parser);
2541     }
2542   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
2543     {
2544       /* Parse an enum definition.  */
2545       struct c_enum_contents the_enum;
2546       tree type;
2547       tree postfix_attrs;
2548       /* We chain the enumerators in reverse order, then put them in
2549          forward order at the end.  */
2550       tree values;
2551       timevar_push (TV_PARSE_ENUM);
2552       type = start_enum (enum_loc, &the_enum, ident);
2553       values = NULL_TREE;
2554       c_parser_consume_token (parser);
2555       while (true)
2556         {
2557           tree enum_id;
2558           tree enum_value;
2559           tree enum_decl;
2560           bool seen_comma;
2561           c_token *token;
2562           location_t comma_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
2563           location_t decl_loc, value_loc;
2564           if (c_parser_next_token_is_not (parser, CPP_NAME))
2565             {
2566               c_parser_error (parser, "expected identifier");
2567               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
2568               values = error_mark_node;
2569               break;
2570             }
2571           token = c_parser_peek_token (parser);
2572           enum_id = token->value;
2573           /* Set the location in case we create a decl now.  */
2574           c_parser_set_source_position_from_token (token);
2575           decl_loc = value_loc = token->location;
2576           c_parser_consume_token (parser);
2577           if (c_parser_next_token_is (parser, CPP_EQ))
2578             {
2579               c_parser_consume_token (parser);
2580               value_loc = c_parser_peek_token (parser)->location;
2581               enum_value = c_parser_expr_no_commas (parser, NULL).value;
2582             }
2583           else
2584             enum_value = NULL_TREE;
2585           enum_decl = build_enumerator (decl_loc, value_loc,
2586                                         &the_enum, enum_id, enum_value);
2587           TREE_CHAIN (enum_decl) = values;
2588           values = enum_decl;
2589           seen_comma = false;
2590           if (c_parser_next_token_is (parser, CPP_COMMA))
2591             {
2592               comma_loc = c_parser_peek_token (parser)->location;
2593               seen_comma = true;
2594               c_parser_consume_token (parser);
2595             }
2596           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2597             {
2598               if (seen_comma)
2599                 pedwarn_c90 (comma_loc, OPT_Wpedantic,
2600                              "comma at end of enumerator list");
2601               c_parser_consume_token (parser);
2602               break;
2603             }
2604           if (!seen_comma)
2605             {
2606               c_parser_error (parser, "expected %<,%> or %<}%>");
2607               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
2608               values = error_mark_node;
2609               break;
2610             }
2611         }
2612       postfix_attrs = c_parser_attributes (parser);
2613       ret.spec = finish_enum (type, nreverse (values),
2614                               chainon (attrs, postfix_attrs));
2615       ret.kind = ctsk_tagdef;
2616       ret.expr = NULL_TREE;
2617       ret.expr_const_operands = true;
2618       timevar_pop (TV_PARSE_ENUM);
2619       return ret;
2620     }
2621   else if (!ident)
2622     {
2623       c_parser_error (parser, "expected %<{%>");
2624       ret.spec = error_mark_node;
2625       ret.kind = ctsk_tagref;
2626       ret.expr = NULL_TREE;
2627       ret.expr_const_operands = true;
2628       return ret;
2629     }
2630   ret = parser_xref_tag (ident_loc, ENUMERAL_TYPE, ident);
2631   /* In ISO C, enumerated types can be referred to only if already
2632      defined.  */
2633   if (pedantic && !COMPLETE_TYPE_P (ret.spec))
2634     {
2635       gcc_assert (ident);
2636       pedwarn (enum_loc, OPT_Wpedantic,
2637                "ISO C forbids forward references to %<enum%> types");
2638     }
2639   return ret;
2640 }
2641
2642 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
2643
2644    struct-or-union-specifier:
2645      struct-or-union attributes[opt] identifier[opt]
2646        { struct-contents } attributes[opt]
2647      struct-or-union attributes[opt] identifier
2648
2649    struct-contents:
2650      struct-declaration-list
2651
2652    struct-declaration-list:
2653      struct-declaration ;
2654      struct-declaration-list struct-declaration ;
2655
2656    GNU extensions:
2657
2658    struct-contents:
2659      empty
2660      struct-declaration
2661      struct-declaration-list struct-declaration
2662
2663    struct-declaration-list:
2664      struct-declaration-list ;
2665      ;
2666
2667    (Note that in the syntax here, unlike that in ISO C, the semicolons
2668    are included here rather than in struct-declaration, in order to
2669    describe the syntax with extra semicolons and missing semicolon at
2670    end.)
2671
2672    Objective-C:
2673
2674    struct-declaration-list:
2675      @defs ( class-name )
2676
2677    (Note this does not include a trailing semicolon, but can be
2678    followed by further declarations, and gets a pedwarn-if-pedantic
2679    when followed by a semicolon.)  */
2680
2681 static struct c_typespec
2682 c_parser_struct_or_union_specifier (c_parser *parser)
2683 {
2684   struct c_typespec ret;
2685   tree attrs;
2686   tree ident = NULL_TREE;
2687   location_t struct_loc;
2688   location_t ident_loc = UNKNOWN_LOCATION;
2689   enum tree_code code;
2690   switch (c_parser_peek_token (parser)->keyword)
2691     {
2692     case RID_STRUCT:
2693       code = RECORD_TYPE;
2694       break;
2695     case RID_UNION:
2696       code = UNION_TYPE;
2697       break;
2698     default:
2699       gcc_unreachable ();
2700     }
2701   struct_loc = c_parser_peek_token (parser)->location;
2702   c_parser_consume_token (parser);
2703   attrs = c_parser_attributes (parser);
2704
2705   /* Set the location in case we create a decl now.  */
2706   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
2707
2708   if (c_parser_next_token_is (parser, CPP_NAME))
2709     {
2710       ident = c_parser_peek_token (parser)->value;
2711       ident_loc = c_parser_peek_token (parser)->location;
2712       struct_loc = ident_loc;
2713       c_parser_consume_token (parser);
2714     }
2715   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
2716     {
2717       /* Parse a struct or union definition.  Start the scope of the
2718          tag before parsing components.  */
2719       struct c_struct_parse_info *struct_info;
2720       tree type = start_struct (struct_loc, code, ident, &struct_info);
2721       tree postfix_attrs;
2722       /* We chain the components in reverse order, then put them in
2723          forward order at the end.  Each struct-declaration may
2724          declare multiple components (comma-separated), so we must use
2725          chainon to join them, although when parsing each
2726          struct-declaration we can use TREE_CHAIN directly.
2727
2728          The theory behind all this is that there will be more
2729          semicolon separated fields than comma separated fields, and
2730          so we'll be minimizing the number of node traversals required
2731          by chainon.  */
2732       tree contents;
2733       timevar_push (TV_PARSE_STRUCT);
2734       contents = NULL_TREE;
2735       c_parser_consume_token (parser);
2736       /* Handle the Objective-C @defs construct,
2737          e.g. foo(sizeof(struct{ @defs(ClassName) }));.  */
2738       if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
2739         {
2740           tree name;
2741           gcc_assert (c_dialect_objc ());
2742           c_parser_consume_token (parser);
2743           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2744             goto end_at_defs;
2745           if (c_parser_next_token_is (parser, CPP_NAME)
2746               && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
2747             {
2748               name = c_parser_peek_token (parser)->value;
2749               c_parser_consume_token (parser);
2750             }
2751           else
2752             {
2753               c_parser_error (parser, "expected class name");
2754               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2755               goto end_at_defs;
2756             }
2757           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2758                                      "expected %<)%>");
2759           contents = nreverse (objc_get_class_ivars (name));
2760         }
2761     end_at_defs:
2762       /* Parse the struct-declarations and semicolons.  Problems with
2763          semicolons are diagnosed here; empty structures are diagnosed
2764          elsewhere.  */
2765       while (true)
2766         {
2767           tree decls;
2768           /* Parse any stray semicolon.  */
2769           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2770             {
2771               pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
2772                        "extra semicolon in struct or union specified");
2773               c_parser_consume_token (parser);
2774               continue;
2775             }
2776           /* Stop if at the end of the struct or union contents.  */
2777           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2778             {
2779               c_parser_consume_token (parser);
2780               break;
2781             }
2782           /* Accept #pragmas at struct scope.  */
2783           if (c_parser_next_token_is (parser, CPP_PRAGMA))
2784             {
2785               c_parser_pragma (parser, pragma_struct);
2786               continue;
2787             }
2788           /* Parse some comma-separated declarations, but not the
2789              trailing semicolon if any.  */
2790           decls = c_parser_struct_declaration (parser);
2791           contents = chainon (decls, contents);
2792           /* If no semicolon follows, either we have a parse error or
2793              are at the end of the struct or union and should
2794              pedwarn.  */
2795           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2796             c_parser_consume_token (parser);
2797           else
2798             {
2799               if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2800                 pedwarn (c_parser_peek_token (parser)->location, 0,
2801                          "no semicolon at end of struct or union");
2802               else if (parser->error
2803                        || !c_parser_next_token_starts_declspecs (parser))
2804                 {
2805                   c_parser_error (parser, "expected %<;%>");
2806                   c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
2807                   break;
2808                 }
2809
2810               /* If we come here, we have already emitted an error
2811                  for an expected `;', identifier or `(', and we also
2812                  recovered already.  Go on with the next field. */
2813             }
2814         }
2815       postfix_attrs = c_parser_attributes (parser);
2816       ret.spec = finish_struct (struct_loc, type, nreverse (contents),
2817                                 chainon (attrs, postfix_attrs), struct_info);
2818       ret.kind = ctsk_tagdef;
2819       ret.expr = NULL_TREE;
2820       ret.expr_const_operands = true;
2821       timevar_pop (TV_PARSE_STRUCT);
2822       return ret;
2823     }
2824   else if (!ident)
2825     {
2826       c_parser_error (parser, "expected %<{%>");
2827       ret.spec = error_mark_node;
2828       ret.kind = ctsk_tagref;
2829       ret.expr = NULL_TREE;
2830       ret.expr_const_operands = true;
2831       return ret;
2832     }
2833   ret = parser_xref_tag (ident_loc, code, ident);
2834   return ret;
2835 }
2836
2837 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
2838    the trailing semicolon.
2839
2840    struct-declaration:
2841      specifier-qualifier-list struct-declarator-list
2842      static_assert-declaration-no-semi
2843
2844    specifier-qualifier-list:
2845      type-specifier specifier-qualifier-list[opt]
2846      type-qualifier specifier-qualifier-list[opt]
2847      attributes specifier-qualifier-list[opt]
2848
2849    struct-declarator-list:
2850      struct-declarator
2851      struct-declarator-list , attributes[opt] struct-declarator
2852
2853    struct-declarator:
2854      declarator attributes[opt]
2855      declarator[opt] : constant-expression attributes[opt]
2856
2857    GNU extensions:
2858
2859    struct-declaration:
2860      __extension__ struct-declaration
2861      specifier-qualifier-list
2862
2863    Unlike the ISO C syntax, semicolons are handled elsewhere.  The use
2864    of attributes where shown is a GNU extension.  In GNU C, we accept
2865    any expression without commas in the syntax (assignment
2866    expressions, not just conditional expressions); assignment
2867    expressions will be diagnosed as non-constant.  */
2868
2869 static tree
2870 c_parser_struct_declaration (c_parser *parser)
2871 {
2872   struct c_declspecs *specs;
2873   tree prefix_attrs;
2874   tree all_prefix_attrs;
2875   tree decls;
2876   location_t decl_loc;
2877   if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
2878     {
2879       int ext;
2880       tree decl;
2881       ext = disable_extension_diagnostics ();
2882       c_parser_consume_token (parser);
2883       decl = c_parser_struct_declaration (parser);
2884       restore_extension_diagnostics (ext);
2885       return decl;
2886     }
2887   if (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
2888     {
2889       c_parser_static_assert_declaration_no_semi (parser);
2890       return NULL_TREE;
2891     }
2892   specs = build_null_declspecs ();
2893   decl_loc = c_parser_peek_token (parser)->location;
2894   /* Strictly by the standard, we shouldn't allow _Alignas here,
2895      but it appears to have been intended to allow it there, so
2896      we're keeping it as it is until WG14 reaches a conclusion
2897      of N1731.
2898      <http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1731.pdf>  */
2899   c_parser_declspecs (parser, specs, false, true, true,
2900                       true, false, cla_nonabstract_decl);
2901   if (parser->error)
2902     return NULL_TREE;
2903   if (!specs->declspecs_seen_p)
2904     {
2905       c_parser_error (parser, "expected specifier-qualifier-list");
2906       return NULL_TREE;
2907     }
2908   finish_declspecs (specs);
2909   if (c_parser_next_token_is (parser, CPP_SEMICOLON)
2910       || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2911     {
2912       tree ret;
2913       if (specs->typespec_kind == ctsk_none)
2914         {
2915           pedwarn (decl_loc, OPT_Wpedantic,
2916                    "ISO C forbids member declarations with no members");
2917           shadow_tag_warned (specs, pedantic);
2918           ret = NULL_TREE;
2919         }
2920       else
2921         {
2922           /* Support for unnamed structs or unions as members of
2923              structs or unions (which is [a] useful and [b] supports
2924              MS P-SDK).  */
2925           tree attrs = NULL;
2926
2927           ret = grokfield (c_parser_peek_token (parser)->location,
2928                            build_id_declarator (NULL_TREE), specs,
2929                            NULL_TREE, &attrs);
2930           if (ret)
2931             decl_attributes (&ret, attrs, 0);
2932         }
2933       return ret;
2934     }
2935
2936   /* Provide better error recovery.  Note that a type name here is valid,
2937      and will be treated as a field name.  */
2938   if (specs->typespec_kind == ctsk_tagdef
2939       && TREE_CODE (specs->type) != ENUMERAL_TYPE
2940       && c_parser_next_token_starts_declspecs (parser)
2941       && !c_parser_next_token_is (parser, CPP_NAME))
2942     {
2943       c_parser_error (parser, "expected %<;%>, identifier or %<(%>");
2944       parser->error = false;
2945       return NULL_TREE;
2946     }
2947
2948   pending_xref_error ();
2949   prefix_attrs = specs->attrs;
2950   all_prefix_attrs = prefix_attrs;
2951   specs->attrs = NULL_TREE;
2952   decls = NULL_TREE;
2953   while (true)
2954     {
2955       /* Declaring one or more declarators or un-named bit-fields.  */
2956       struct c_declarator *declarator;
2957       bool dummy = false;
2958       if (c_parser_next_token_is (parser, CPP_COLON))
2959         declarator = build_id_declarator (NULL_TREE);
2960       else
2961         declarator = c_parser_declarator (parser,
2962                                           specs->typespec_kind != ctsk_none,
2963                                           C_DTR_NORMAL, &dummy);
2964       if (declarator == NULL)
2965         {
2966           c_parser_skip_to_end_of_block_or_statement (parser);
2967           break;
2968         }
2969       if (c_parser_next_token_is (parser, CPP_COLON)
2970           || c_parser_next_token_is (parser, CPP_COMMA)
2971           || c_parser_next_token_is (parser, CPP_SEMICOLON)
2972           || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
2973           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2974         {
2975           tree postfix_attrs = NULL_TREE;
2976           tree width = NULL_TREE;
2977           tree d;
2978           if (c_parser_next_token_is (parser, CPP_COLON))
2979             {
2980               c_parser_consume_token (parser);
2981               width = c_parser_expr_no_commas (parser, NULL).value;
2982             }
2983           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2984             postfix_attrs = c_parser_attributes (parser);
2985           d = grokfield (c_parser_peek_token (parser)->location,
2986                          declarator, specs, width, &all_prefix_attrs);
2987           decl_attributes (&d, chainon (postfix_attrs,
2988                                         all_prefix_attrs), 0);
2989           DECL_CHAIN (d) = decls;
2990           decls = d;
2991           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2992             all_prefix_attrs = chainon (c_parser_attributes (parser),
2993                                         prefix_attrs);
2994           else
2995             all_prefix_attrs = prefix_attrs;
2996           if (c_parser_next_token_is (parser, CPP_COMMA))
2997             c_parser_consume_token (parser);
2998           else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
2999                    || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3000             {
3001               /* Semicolon consumed in caller.  */
3002               break;
3003             }
3004           else
3005             {
3006               c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
3007               break;
3008             }
3009         }
3010       else
3011         {
3012           c_parser_error (parser,
3013                           "expected %<:%>, %<,%>, %<;%>, %<}%> or "
3014                           "%<__attribute__%>");
3015           break;
3016         }
3017     }
3018   return decls;
3019 }
3020
3021 /* Parse a typeof specifier (a GNU extension).
3022
3023    typeof-specifier:
3024      typeof ( expression )
3025      typeof ( type-name )
3026 */
3027
3028 static struct c_typespec
3029 c_parser_typeof_specifier (c_parser *parser)
3030 {
3031   struct c_typespec ret;
3032   ret.kind = ctsk_typeof;
3033   ret.spec = error_mark_node;
3034   ret.expr = NULL_TREE;
3035   ret.expr_const_operands = true;
3036   gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF));
3037   c_parser_consume_token (parser);
3038   c_inhibit_evaluation_warnings++;
3039   in_typeof++;
3040   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3041     {
3042       c_inhibit_evaluation_warnings--;
3043       in_typeof--;
3044       return ret;
3045     }
3046   if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
3047     {
3048       struct c_type_name *type = c_parser_type_name (parser);
3049       c_inhibit_evaluation_warnings--;
3050       in_typeof--;
3051       if (type != NULL)
3052         {
3053           ret.spec = groktypename (type, &ret.expr, &ret.expr_const_operands);
3054           pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
3055         }
3056     }
3057   else
3058     {
3059       bool was_vm;
3060       location_t here = c_parser_peek_token (parser)->location;
3061       struct c_expr expr = c_parser_expression (parser);
3062       c_inhibit_evaluation_warnings--;
3063       in_typeof--;
3064       if (TREE_CODE (expr.value) == COMPONENT_REF
3065           && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
3066         error_at (here, "%<typeof%> applied to a bit-field");
3067       mark_exp_read (expr.value);
3068       ret.spec = TREE_TYPE (expr.value);
3069       was_vm = variably_modified_type_p (ret.spec, NULL_TREE);
3070       /* This is returned with the type so that when the type is
3071          evaluated, this can be evaluated.  */
3072       if (was_vm)
3073         ret.expr = c_fully_fold (expr.value, false, &ret.expr_const_operands);
3074       pop_maybe_used (was_vm);
3075       /* For use in macros such as those in <stdatomic.h>, remove all
3076          qualifiers from atomic types.  (const can be an issue for more macros
3077          using typeof than just the <stdatomic.h> ones.)  */
3078       if (ret.spec != error_mark_node && TYPE_ATOMIC (ret.spec))
3079         ret.spec = c_build_qualified_type (ret.spec, TYPE_UNQUALIFIED);
3080     }
3081   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
3082   return ret;
3083 }
3084
3085 /* Parse an alignment-specifier.
3086
3087    C11 6.7.5:
3088
3089    alignment-specifier:
3090      _Alignas ( type-name )
3091      _Alignas ( constant-expression )
3092 */
3093
3094 static tree
3095 c_parser_alignas_specifier (c_parser * parser)
3096 {
3097   tree ret = error_mark_node;
3098   location_t loc = c_parser_peek_token (parser)->location;
3099   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNAS));
3100   c_parser_consume_token (parser);
3101   if (flag_isoc99)
3102     pedwarn_c99 (loc, OPT_Wpedantic,
3103                  "ISO C99 does not support %<_Alignas%>");
3104   else
3105     pedwarn_c99 (loc, OPT_Wpedantic,
3106                  "ISO C90 does not support %<_Alignas%>");
3107   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3108     return ret;
3109   if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
3110     {
3111       struct c_type_name *type = c_parser_type_name (parser);
3112       if (type != NULL)
3113         ret = c_sizeof_or_alignof_type (loc, groktypename (type, NULL, NULL),
3114                                         false, true, 1);
3115     }
3116   else
3117     ret = c_parser_expr_no_commas (parser, NULL).value;
3118   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
3119   return ret;
3120 }
3121
3122 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
3123    6.5.5, C99 6.7.5, 6.7.6).  If TYPE_SEEN_P then a typedef name may
3124    be redeclared; otherwise it may not.  KIND indicates which kind of
3125    declarator is wanted.  Returns a valid declarator except in the
3126    case of a syntax error in which case NULL is returned.  *SEEN_ID is
3127    set to true if an identifier being declared is seen; this is used
3128    to diagnose bad forms of abstract array declarators and to
3129    determine whether an identifier list is syntactically permitted.
3130
3131    declarator:
3132      pointer[opt] direct-declarator
3133
3134    direct-declarator:
3135      identifier
3136      ( attributes[opt] declarator )
3137      direct-declarator array-declarator
3138      direct-declarator ( parameter-type-list )
3139      direct-declarator ( identifier-list[opt] )
3140
3141    pointer:
3142      * type-qualifier-list[opt]
3143      * type-qualifier-list[opt] pointer
3144
3145    type-qualifier-list:
3146      type-qualifier
3147      attributes
3148      type-qualifier-list type-qualifier
3149      type-qualifier-list attributes
3150
3151    array-declarator:
3152      [ type-qualifier-list[opt] assignment-expression[opt] ]
3153      [ static type-qualifier-list[opt] assignment-expression ]
3154      [ type-qualifier-list static assignment-expression ]
3155      [ type-qualifier-list[opt] * ]
3156
3157    parameter-type-list:
3158      parameter-list
3159      parameter-list , ...
3160
3161    parameter-list:
3162      parameter-declaration
3163      parameter-list , parameter-declaration
3164
3165    parameter-declaration:
3166      declaration-specifiers declarator attributes[opt]
3167      declaration-specifiers abstract-declarator[opt] attributes[opt]
3168
3169    identifier-list:
3170      identifier
3171      identifier-list , identifier
3172
3173    abstract-declarator:
3174      pointer
3175      pointer[opt] direct-abstract-declarator
3176
3177    direct-abstract-declarator:
3178      ( attributes[opt] abstract-declarator )
3179      direct-abstract-declarator[opt] array-declarator
3180      direct-abstract-declarator[opt] ( parameter-type-list[opt] )
3181
3182    GNU extensions:
3183
3184    direct-declarator:
3185      direct-declarator ( parameter-forward-declarations
3186                          parameter-type-list[opt] )
3187
3188    direct-abstract-declarator:
3189      direct-abstract-declarator[opt] ( parameter-forward-declarations
3190                                        parameter-type-list[opt] )
3191
3192    parameter-forward-declarations:
3193      parameter-list ;
3194      parameter-forward-declarations parameter-list ;
3195
3196    The uses of attributes shown above are GNU extensions.
3197
3198    Some forms of array declarator are not included in C99 in the
3199    syntax for abstract declarators; these are disallowed elsewhere.
3200    This may be a defect (DR#289).
3201
3202    This function also accepts an omitted abstract declarator as being
3203    an abstract declarator, although not part of the formal syntax.  */
3204
3205 static struct c_declarator *
3206 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
3207                      bool *seen_id)
3208 {
3209   /* Parse any initial pointer part.  */
3210   if (c_parser_next_token_is (parser, CPP_MULT))
3211     {
3212       struct c_declspecs *quals_attrs = build_null_declspecs ();
3213       struct c_declarator *inner;
3214       c_parser_consume_token (parser);
3215       c_parser_declspecs (parser, quals_attrs, false, false, true,
3216                           false, false, cla_prefer_id);
3217       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
3218       if (inner == NULL)
3219         return NULL;
3220       else
3221         return make_pointer_declarator (quals_attrs, inner);
3222     }
3223   /* Now we have a direct declarator, direct abstract declarator or
3224      nothing (which counts as a direct abstract declarator here).  */
3225   return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
3226 }
3227
3228 /* Parse a direct declarator or direct abstract declarator; arguments
3229    as c_parser_declarator.  */
3230
3231 static struct c_declarator *
3232 c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
3233                             bool *seen_id)
3234 {
3235   /* The direct declarator must start with an identifier (possibly
3236      omitted) or a parenthesized declarator (possibly abstract).  In
3237      an ordinary declarator, initial parentheses must start a
3238      parenthesized declarator.  In an abstract declarator or parameter
3239      declarator, they could start a parenthesized declarator or a
3240      parameter list.  To tell which, the open parenthesis and any
3241      following attributes must be read.  If a declaration specifier
3242      follows, then it is a parameter list; if the specifier is a
3243      typedef name, there might be an ambiguity about redeclaring it,
3244      which is resolved in the direction of treating it as a typedef
3245      name.  If a close parenthesis follows, it is also an empty
3246      parameter list, as the syntax does not permit empty abstract
3247      declarators.  Otherwise, it is a parenthesized declarator (in
3248      which case the analysis may be repeated inside it, recursively).
3249
3250      ??? There is an ambiguity in a parameter declaration "int
3251      (__attribute__((foo)) x)", where x is not a typedef name: it
3252      could be an abstract declarator for a function, or declare x with
3253      parentheses.  The proper resolution of this ambiguity needs
3254      documenting.  At present we follow an accident of the old
3255      parser's implementation, whereby the first parameter must have
3256      some declaration specifiers other than just attributes.  Thus as
3257      a parameter declaration it is treated as a parenthesized
3258      parameter named x, and as an abstract declarator it is
3259      rejected.
3260
3261      ??? Also following the old parser, attributes inside an empty
3262      parameter list are ignored, making it a list not yielding a
3263      prototype, rather than giving an error or making it have one
3264      parameter with implicit type int.
3265
3266      ??? Also following the old parser, typedef names may be
3267      redeclared in declarators, but not Objective-C class names.  */
3268
3269   if (kind != C_DTR_ABSTRACT
3270       && c_parser_next_token_is (parser, CPP_NAME)
3271       && ((type_seen_p
3272            && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
3273                || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
3274           || c_parser_peek_token (parser)->id_kind == C_ID_ID))
3275     {
3276       struct c_declarator *inner
3277         = build_id_declarator (c_parser_peek_token (parser)->value);
3278       *seen_id = true;
3279       inner->id_loc = c_parser_peek_token (parser)->location;
3280       c_parser_consume_token (parser);
3281       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
3282     }
3283
3284   if (kind != C_DTR_NORMAL
3285       && c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
3286     {
3287       struct c_declarator *inner = build_id_declarator (NULL_TREE);
3288       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
3289     }
3290
3291   /* Either we are at the end of an abstract declarator, or we have
3292      parentheses.  */
3293
3294   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
3295     {
3296       tree attrs;
3297       struct c_declarator *inner;
3298       c_parser_consume_token (parser);
3299       attrs = c_parser_attributes (parser);
3300       if (kind != C_DTR_NORMAL
3301           && (c_parser_next_token_starts_declspecs (parser)
3302               || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
3303         {
3304           struct c_arg_info *args
3305             = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
3306                                          attrs);
3307           if (args == NULL)
3308             return NULL;
3309           else
3310             {
3311               inner
3312                 = build_function_declarator (args,
3313                                              build_id_declarator (NULL_TREE));
3314               return c_parser_direct_declarator_inner (parser, *seen_id,
3315                                                        inner);
3316             }
3317         }
3318       /* A parenthesized declarator.  */
3319       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
3320       if (inner != NULL && attrs != NULL)
3321         inner = build_attrs_declarator (attrs, inner);
3322       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3323         {
3324           c_parser_consume_token (parser);
3325           if (inner == NULL)
3326             return NULL;
3327           else
3328             return c_parser_direct_declarator_inner (parser, *seen_id, inner);
3329         }
3330       else
3331         {
3332           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3333                                      "expected %<)%>");
3334           return NULL;
3335         }
3336     }
3337   else
3338     {
3339       if (kind == C_DTR_NORMAL)
3340         {
3341           c_parser_error (parser, "expected identifier or %<(%>");
3342           return NULL;
3343         }
3344       else
3345         return build_id_declarator (NULL_TREE);
3346     }
3347 }
3348
3349 /* Parse part of a direct declarator or direct abstract declarator,
3350    given that some (in INNER) has already been parsed; ID_PRESENT is
3351    true if an identifier is present, false for an abstract
3352    declarator.  */
3353
3354 static struct c_declarator *
3355 c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
3356                                   struct c_declarator *inner)
3357 {
3358   /* Parse a sequence of array declarators and parameter lists.  */
3359   if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
3360     {
3361       location_t brace_loc = c_parser_peek_token (parser)->location;
3362       struct c_declarator *declarator;
3363       struct c_declspecs *quals_attrs = build_null_declspecs ();
3364       bool static_seen;
3365       bool star_seen;
3366       struct c_expr dimen;
3367       dimen.value = NULL_TREE;
3368       dimen.original_code = ERROR_MARK;
3369       dimen.original_type = NULL_TREE;
3370       c_parser_consume_token (parser);
3371       c_parser_declspecs (parser, quals_attrs, false, false, true,
3372                           false, false, cla_prefer_id);
3373       static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
3374       if (static_seen)
3375         c_parser_consume_token (parser);
3376       if (static_seen && !quals_attrs->declspecs_seen_p)
3377         c_parser_declspecs (parser, quals_attrs, false, false, true,
3378                             false, false, cla_prefer_id);
3379       if (!quals_attrs->declspecs_seen_p)
3380         quals_attrs = NULL;
3381       /* If "static" is present, there must be an array dimension.
3382          Otherwise, there may be a dimension, "*", or no
3383          dimension.  */
3384       if (static_seen)
3385         {
3386           star_seen = false;
3387           dimen = c_parser_expr_no_commas (parser, NULL);
3388         }
3389       else
3390         {
3391           if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3392             {
3393               dimen.value = NULL_TREE;
3394               star_seen = false;
3395             }
3396           else if (flag_cilkplus
3397                    && c_parser_next_token_is (parser, CPP_COLON))
3398             {
3399               dimen.value = error_mark_node;
3400               star_seen = false;
3401               error_at (c_parser_peek_token (parser)->location,
3402                         "array notations cannot be used in declaration");
3403               c_parser_consume_token (parser);
3404             }   
3405           else if (c_parser_next_token_is (parser, CPP_MULT))
3406             {
3407               if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
3408                 {
3409                   dimen.value = NULL_TREE;
3410                   star_seen = true;
3411                   c_parser_consume_token (parser);
3412                 }
3413               else
3414                 {
3415                   star_seen = false;
3416                   dimen = c_parser_expr_no_commas (parser, NULL);
3417                 }
3418             }
3419           else
3420             {
3421               star_seen = false;
3422               dimen = c_parser_expr_no_commas (parser, NULL);
3423             }
3424         }
3425       if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3426         c_parser_consume_token (parser);
3427       else if (flag_cilkplus
3428                && c_parser_next_token_is (parser, CPP_COLON))
3429         {
3430           error_at (c_parser_peek_token (parser)->location,
3431                     "array notations cannot be used in declaration");
3432           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
3433           return NULL;
3434         }
3435       else
3436         {
3437           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3438                                      "expected %<]%>");
3439           return NULL;
3440         }
3441       if (dimen.value)
3442         dimen = convert_lvalue_to_rvalue (brace_loc, dimen, true, true);
3443       declarator = build_array_declarator (brace_loc, dimen.value, quals_attrs,
3444                                            static_seen, star_seen);
3445       if (declarator == NULL)
3446         return NULL;
3447       inner = set_array_declarator_inner (declarator, inner);
3448       return c_parser_direct_declarator_inner (parser, id_present, inner);
3449     }
3450   else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
3451     {
3452       tree attrs;
3453       struct c_arg_info *args;
3454       c_parser_consume_token (parser);
3455       attrs = c_parser_attributes (parser);
3456       args = c_parser_parms_declarator (parser, id_present, attrs);
3457       if (args == NULL)
3458         return NULL;
3459       else
3460         {
3461           inner = build_function_declarator (args, inner);
3462           return c_parser_direct_declarator_inner (parser, id_present, inner);
3463         }
3464     }
3465   return inner;
3466 }
3467
3468 /* Parse a parameter list or identifier list, including the closing
3469    parenthesis but not the opening one.  ATTRS are the attributes at
3470    the start of the list.  ID_LIST_OK is true if an identifier list is
3471    acceptable; such a list must not have attributes at the start.  */
3472
3473 static struct c_arg_info *
3474 c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs)
3475 {
3476   push_scope ();
3477   declare_parm_level ();
3478   /* If the list starts with an identifier, it is an identifier list.
3479      Otherwise, it is either a prototype list or an empty list.  */
3480   if (id_list_ok
3481       && !attrs
3482       && c_parser_next_token_is (parser, CPP_NAME)
3483       && c_parser_peek_token (parser)->id_kind == C_ID_ID
3484       
3485       /* Look ahead to detect typos in type names.  */
3486       && c_parser_peek_2nd_token (parser)->type != CPP_NAME
3487       && c_parser_peek_2nd_token (parser)->type != CPP_MULT
3488       && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN
3489       && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_SQUARE)
3490     {
3491       tree list = NULL_TREE, *nextp = &list;
3492       while (c_parser_next_token_is (parser, CPP_NAME)
3493              && c_parser_peek_token (parser)->id_kind == C_ID_ID)
3494         {
3495           *nextp = build_tree_list (NULL_TREE,
3496                                     c_parser_peek_token (parser)->value);
3497           nextp = & TREE_CHAIN (*nextp);
3498           c_parser_consume_token (parser);
3499           if (c_parser_next_token_is_not (parser, CPP_COMMA))
3500             break;
3501           c_parser_consume_token (parser);
3502           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3503             {
3504               c_parser_error (parser, "expected identifier");
3505               break;
3506             }
3507         }
3508       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3509         {
3510           struct c_arg_info *ret = build_arg_info ();
3511           ret->types = list;
3512           c_parser_consume_token (parser);
3513           pop_scope ();
3514           return ret;
3515         }
3516       else
3517         {
3518           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3519                                      "expected %<)%>");
3520           pop_scope ();
3521           return NULL;
3522         }
3523     }
3524   else
3525     {
3526       struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs,
3527                                                                NULL);
3528       pop_scope ();
3529       return ret;
3530     }
3531 }
3532
3533 /* Parse a parameter list (possibly empty), including the closing
3534    parenthesis but not the opening one.  ATTRS are the attributes at
3535    the start of the list.  EXPR is NULL or an expression that needs to
3536    be evaluated for the side effects of array size expressions in the
3537    parameters.  */
3538
3539 static struct c_arg_info *
3540 c_parser_parms_list_declarator (c_parser *parser, tree attrs, tree expr)
3541 {
3542   bool bad_parm = false;
3543
3544   /* ??? Following the old parser, forward parameter declarations may
3545      use abstract declarators, and if no real parameter declarations
3546      follow the forward declarations then this is not diagnosed.  Also
3547      note as above that attributes are ignored as the only contents of
3548      the parentheses, or as the only contents after forward
3549      declarations.  */
3550   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3551     {
3552       struct c_arg_info *ret = build_arg_info ();
3553       c_parser_consume_token (parser);
3554       return ret;
3555     }
3556   if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3557     {
3558       struct c_arg_info *ret = build_arg_info ();
3559
3560       if (flag_allow_parameterless_variadic_functions)
3561         {
3562           /* F (...) is allowed.  */
3563           ret->types = NULL_TREE;
3564         }
3565       else
3566         {
3567           /* Suppress -Wold-style-definition for this case.  */
3568           ret->types = error_mark_node;
3569           error_at (c_parser_peek_token (parser)->location,
3570                     "ISO C requires a named argument before %<...%>");
3571         }
3572       c_parser_consume_token (parser);
3573       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3574         {
3575           c_parser_consume_token (parser);
3576           return ret;
3577         }
3578       else
3579         {
3580           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3581                                      "expected %<)%>");
3582           return NULL;
3583         }
3584     }
3585   /* Nonempty list of parameters, either terminated with semicolon
3586      (forward declarations; recurse) or with close parenthesis (normal
3587      function) or with ", ... )" (variadic function).  */
3588   while (true)
3589     {
3590       /* Parse a parameter.  */
3591       struct c_parm *parm = c_parser_parameter_declaration (parser, attrs);
3592       attrs = NULL_TREE;
3593       if (parm == NULL)
3594         bad_parm = true;
3595       else
3596         push_parm_decl (parm, &expr);
3597       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3598         {
3599           tree new_attrs;
3600           c_parser_consume_token (parser);
3601           mark_forward_parm_decls ();
3602           new_attrs = c_parser_attributes (parser);
3603           return c_parser_parms_list_declarator (parser, new_attrs, expr);
3604         }
3605       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3606         {
3607           c_parser_consume_token (parser);
3608           if (bad_parm)
3609             return NULL;
3610           else
3611             return get_parm_info (false, expr);
3612         }
3613       if (!c_parser_require (parser, CPP_COMMA,
3614                              "expected %<;%>, %<,%> or %<)%>"))
3615         {
3616           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3617           return NULL;
3618         }
3619       if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3620         {
3621           c_parser_consume_token (parser);
3622           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3623             {
3624               c_parser_consume_token (parser);
3625               if (bad_parm)
3626                 return NULL;
3627               else
3628                 return get_parm_info (true, expr);
3629             }
3630           else
3631             {
3632               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3633                                          "expected %<)%>");
3634               return NULL;
3635             }
3636         }
3637     }
3638 }
3639
3640 /* Parse a parameter declaration.  ATTRS are the attributes at the
3641    start of the declaration if it is the first parameter.  */
3642
3643 static struct c_parm *
3644 c_parser_parameter_declaration (c_parser *parser, tree attrs)
3645 {
3646   struct c_declspecs *specs;
3647   struct c_declarator *declarator;
3648   tree prefix_attrs;
3649   tree postfix_attrs = NULL_TREE;
3650   bool dummy = false;
3651
3652   /* Accept #pragmas between parameter declarations.  */
3653   while (c_parser_next_token_is (parser, CPP_PRAGMA))
3654     c_parser_pragma (parser, pragma_param);
3655
3656   if (!c_parser_next_token_starts_declspecs (parser))
3657     {
3658       c_token *token = c_parser_peek_token (parser);
3659       if (parser->error)
3660         return NULL;
3661       c_parser_set_source_position_from_token (token);
3662       if (c_parser_next_tokens_start_typename (parser, cla_prefer_type))
3663         {
3664           error_at (token->location, "unknown type name %qE", token->value);
3665           parser->error = true;
3666         }
3667       /* ??? In some Objective-C cases '...' isn't applicable so there
3668          should be a different message.  */
3669       else
3670         c_parser_error (parser,
3671                         "expected declaration specifiers or %<...%>");
3672       c_parser_skip_to_end_of_parameter (parser);
3673       return NULL;
3674     }
3675   specs = build_null_declspecs ();
3676   if (attrs)
3677     {
3678       declspecs_add_attrs (input_location, specs, attrs);
3679       attrs = NULL_TREE;
3680     }
3681   c_parser_declspecs (parser, specs, true, true, true, true, false,
3682                       cla_nonabstract_decl);
3683   finish_declspecs (specs);
3684   pending_xref_error ();
3685   prefix_attrs = specs->attrs;
3686   specs->attrs = NULL_TREE;
3687   declarator = c_parser_declarator (parser,
3688                                     specs->typespec_kind != ctsk_none,
3689                                     C_DTR_PARM, &dummy);
3690   if (declarator == NULL)
3691     {
3692       c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3693       return NULL;
3694     }
3695   if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
3696     postfix_attrs = c_parser_attributes (parser);
3697   return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
3698                        declarator);
3699 }
3700
3701 /* Parse a string literal in an asm expression.  It should not be
3702    translated, and wide string literals are an error although
3703    permitted by the syntax.  This is a GNU extension.
3704
3705    asm-string-literal:
3706      string-literal
3707
3708    ??? At present, following the old parser, the caller needs to have
3709    set lex_untranslated_string to 1.  It would be better to follow the
3710    C++ parser rather than using this kludge.  */
3711
3712 static tree
3713 c_parser_asm_string_literal (c_parser *parser)
3714 {
3715   tree str;
3716   int save_flag = warn_overlength_strings;
3717   warn_overlength_strings = 0;
3718   if (c_parser_next_token_is (parser, CPP_STRING))
3719     {
3720       str = c_parser_peek_token (parser)->value;
3721       c_parser_consume_token (parser);
3722     }
3723   else if (c_parser_next_token_is (parser, CPP_WSTRING))
3724     {
3725       error_at (c_parser_peek_token (parser)->location,
3726                 "wide string literal in %<asm%>");
3727       str = build_string (1, "");
3728       c_parser_consume_token (parser);
3729     }
3730   else
3731     {
3732       c_parser_error (parser, "expected string literal");
3733       str = NULL_TREE;
3734     }
3735   warn_overlength_strings = save_flag;
3736   return str;
3737 }
3738
3739 /* Parse a simple asm expression.  This is used in restricted
3740    contexts, where a full expression with inputs and outputs does not
3741    make sense.  This is a GNU extension.
3742
3743    simple-asm-expr:
3744      asm ( asm-string-literal )
3745 */
3746
3747 static tree
3748 c_parser_simple_asm_expr (c_parser *parser)
3749 {
3750   tree str;
3751   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
3752   /* ??? Follow the C++ parser rather than using the
3753      lex_untranslated_string kludge.  */
3754   parser->lex_untranslated_string = true;
3755   c_parser_consume_token (parser);
3756   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3757     {
3758       parser->lex_untranslated_string = false;
3759       return NULL_TREE;
3760     }
3761   str = c_parser_asm_string_literal (parser);
3762   parser->lex_untranslated_string = false;
3763   if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
3764     {
3765       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3766       return NULL_TREE;
3767     }
3768   return str;
3769 }
3770
3771 static tree
3772 c_parser_attribute_any_word (c_parser *parser)
3773 {
3774   tree attr_name = NULL_TREE;
3775
3776   if (c_parser_next_token_is (parser, CPP_KEYWORD))
3777     {
3778       /* ??? See comment above about what keywords are accepted here.  */
3779       bool ok;
3780       switch (c_parser_peek_token (parser)->keyword)
3781         {
3782         case RID_STATIC:
3783         case RID_UNSIGNED:
3784         case RID_LONG:
3785         case RID_CONST:
3786         case RID_EXTERN:
3787         case RID_REGISTER:
3788         case RID_TYPEDEF:
3789         case RID_SHORT:
3790         case RID_INLINE:
3791         case RID_NORETURN:
3792         case RID_VOLATILE:
3793         case RID_SIGNED:
3794         case RID_AUTO:
3795         case RID_RESTRICT:
3796         case RID_COMPLEX:
3797         case RID_THREAD:
3798         case RID_INT:
3799         case RID_CHAR:
3800         case RID_FLOAT:
3801         case RID_DOUBLE:
3802         case RID_VOID:
3803         case RID_DFLOAT32:
3804         case RID_DFLOAT64:
3805         case RID_DFLOAT128:
3806         case RID_BOOL:
3807         case RID_FRACT:
3808         case RID_ACCUM:
3809         case RID_SAT:
3810         case RID_TRANSACTION_ATOMIC:
3811         case RID_TRANSACTION_CANCEL:
3812         case RID_ATOMIC:
3813         case RID_AUTO_TYPE:
3814         case RID_INT_N_0:
3815         case RID_INT_N_1:
3816         case RID_INT_N_2:
3817         case RID_INT_N_3:
3818           ok = true;
3819           break;
3820         default:
3821           ok = false;
3822           break;
3823         }
3824       if (!ok)
3825         return NULL_TREE;
3826
3827       /* Accept __attribute__((__const)) as __attribute__((const)) etc.  */
3828       attr_name = ridpointers[(int) c_parser_peek_token (parser)->keyword];
3829     }
3830   else if (c_parser_next_token_is (parser, CPP_NAME))
3831     attr_name = c_parser_peek_token (parser)->value;
3832
3833   return attr_name;
3834 }
3835
3836 /* Returns true of NAME is an IDENTIFIER_NODE with identiifer "vector,"
3837    "__vector" or "__vector__."  */
3838
3839 static inline bool
3840 is_cilkplus_vector_p (tree name)
3841
3842   if (flag_cilkplus && is_attribute_p ("vector", name)) 
3843     return true;
3844   return false;
3845 }
3846
3847 #define CILK_SIMD_FN_CLAUSE_MASK                                  \
3848         ((OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_VECTORLENGTH)   \
3849          | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_LINEAR)       \
3850          | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_UNIFORM)      \
3851          | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_MASK)         \
3852          | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_NOMASK))
3853
3854 /* Parses the vector attribute of SIMD enabled functions in Cilk Plus.
3855    VEC_TOKEN is the "vector" token that is replaced with "simd" and
3856    pushed into the token list. 
3857    Syntax:
3858    vector
3859    vector (<vector attributes>).  */
3860
3861 static void
3862 c_parser_cilk_simd_fn_vector_attrs (c_parser *parser, c_token vec_token)
3863 {
3864   gcc_assert (is_cilkplus_vector_p (vec_token.value));
3865   
3866   int paren_scope = 0;
3867   vec_safe_push (parser->cilk_simd_fn_tokens, vec_token);
3868   /* Consume the "vector" token.  */
3869   c_parser_consume_token (parser);
3870
3871   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
3872     {
3873       c_parser_consume_token (parser);
3874       paren_scope++;
3875     }
3876   while (paren_scope > 0)
3877     {
3878       c_token *token = c_parser_peek_token (parser);
3879       if (token->type == CPP_OPEN_PAREN)
3880         paren_scope++;
3881       else if (token->type == CPP_CLOSE_PAREN)
3882         paren_scope--;
3883       /* Do not push the last ')' since we are not pushing the '('.  */
3884       if (!(token->type == CPP_CLOSE_PAREN && paren_scope == 0))
3885         vec_safe_push (parser->cilk_simd_fn_tokens, *token);
3886       c_parser_consume_token (parser);
3887     }
3888   
3889   /* Since we are converting an attribute to a pragma, we need to end the
3890      attribute with PRAGMA_EOL.  */
3891   c_token eol_token;
3892   memset (&eol_token, 0, sizeof (eol_token));
3893   eol_token.type = CPP_PRAGMA_EOL;
3894   vec_safe_push (parser->cilk_simd_fn_tokens, eol_token);
3895 }
3896
3897 /* Add 2 CPP_EOF at the end of PARSER->ELEM_FN_TOKENS vector.  */
3898
3899 static void
3900 c_finish_cilk_simd_fn_tokens (c_parser *parser)
3901 {
3902   c_token last_token = parser->cilk_simd_fn_tokens->last ();
3903
3904   /* c_parser_attributes is called in several places, so if these EOF
3905      tokens are already inserted, then don't do them again.  */
3906   if (last_token.type == CPP_EOF)
3907     return;
3908   
3909   /* Two CPP_EOF token are added as a safety net since the normal C
3910      front-end has two token look-ahead.  */
3911   c_token eof_token;
3912   eof_token.type = CPP_EOF;
3913   vec_safe_push (parser->cilk_simd_fn_tokens, eof_token);
3914   vec_safe_push (parser->cilk_simd_fn_tokens, eof_token);
3915 }
3916
3917 /* Parse (possibly empty) attributes.  This is a GNU extension.
3918
3919    attributes:
3920      empty
3921      attributes attribute
3922
3923    attribute:
3924      __attribute__ ( ( attribute-list ) )
3925
3926    attribute-list:
3927      attrib
3928      attribute_list , attrib
3929
3930    attrib:
3931      empty
3932      any-word
3933      any-word ( identifier )
3934      any-word ( identifier , nonempty-expr-list )
3935      any-word ( expr-list )
3936
3937    where the "identifier" must not be declared as a type, and
3938    "any-word" may be any identifier (including one declared as a
3939    type), a reserved word storage class specifier, type specifier or
3940    type qualifier.  ??? This still leaves out most reserved keywords
3941    (following the old parser), shouldn't we include them, and why not
3942    allow identifiers declared as types to start the arguments?  */
3943
3944 static tree
3945 c_parser_attributes (c_parser *parser)
3946 {
3947   tree attrs = NULL_TREE;
3948   while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
3949     {
3950       /* ??? Follow the C++ parser rather than using the
3951          lex_untranslated_string kludge.  */
3952       parser->lex_untranslated_string = true;
3953       c_parser_consume_token (parser);
3954       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3955         {
3956           parser->lex_untranslated_string = false;
3957           return attrs;
3958         }
3959       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3960         {
3961           parser->lex_untranslated_string = false;
3962           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3963           return attrs;
3964         }
3965       /* Parse the attribute list.  */
3966       while (c_parser_next_token_is (parser, CPP_COMMA)
3967              || c_parser_next_token_is (parser, CPP_NAME)
3968              || c_parser_next_token_is (parser, CPP_KEYWORD))
3969         {
3970           tree attr, attr_name, attr_args;
3971           vec<tree, va_gc> *expr_list;
3972           if (c_parser_next_token_is (parser, CPP_COMMA))
3973             {
3974               c_parser_consume_token (parser);
3975               continue;
3976             }
3977
3978           attr_name = c_parser_attribute_any_word (parser);
3979           if (attr_name == NULL)
3980             break;
3981           if (is_cilkplus_vector_p (attr_name))           
3982             {
3983               c_token *v_token = c_parser_peek_token (parser);
3984               c_parser_cilk_simd_fn_vector_attrs (parser, *v_token);
3985               continue;
3986             }
3987           c_parser_consume_token (parser);
3988           if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
3989             {
3990               attr = build_tree_list (attr_name, NULL_TREE);
3991               attrs = chaino