Branch data Line data Source code
1 : : /* -*- C++ -*- Parser.
2 : : Copyright (C) 2000-2024 Free Software Foundation, Inc.
3 : : Written by Mark Mitchell <mark@codesourcery.com>.
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify it
8 : : under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3, or (at your option)
10 : : any later version.
11 : :
12 : : GCC is distributed in the hope that it will be useful, but
13 : : WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : : General Public License for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : : #include "config.h"
22 : : #include "omp-selectors.h"
23 : : #define INCLUDE_STRING
24 : : #include "system.h"
25 : : #include "coretypes.h"
26 : : #include "cp-tree.h"
27 : : #include "c-family/c-common.h"
28 : : #include "timevar.h"
29 : : #include "stringpool.h"
30 : : #include "cgraph.h"
31 : : #include "print-tree.h"
32 : : #include "attribs.h"
33 : : #include "trans-mem.h"
34 : : #include "intl.h"
35 : : #include "decl.h"
36 : : #include "c-family/c-objc.h"
37 : : #include "plugin.h"
38 : : #include "tree-pretty-print.h"
39 : : #include "parser.h"
40 : : #include "gomp-constants.h"
41 : : #include "omp-general.h"
42 : : #include "omp-offload.h"
43 : : #include "c-family/c-indentation.h"
44 : : #include "context.h"
45 : : #include "gcc-rich-location.h"
46 : : #include "tree-iterator.h"
47 : : #include "cp-name-hint.h"
48 : : #include "memmodel.h"
49 : : #include "c-family/known-headers.h"
50 : : #include "contracts.h"
51 : : #include "bitmap.h"
52 : : #include "builtins.h"
53 : :
54 : :
55 : : /* The lexer. */
56 : :
57 : : /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
58 : : and c-lex.cc) and the C++ parser. */
59 : :
60 : : /* The various kinds of non integral constant we encounter. */
61 : : enum non_integral_constant {
62 : : NIC_NONE,
63 : : /* floating-point literal */
64 : : NIC_FLOAT,
65 : : /* %<this%> */
66 : : NIC_THIS,
67 : : /* %<__FUNCTION__%> */
68 : : NIC_FUNC_NAME,
69 : : /* %<__PRETTY_FUNCTION__%> */
70 : : NIC_PRETTY_FUNC,
71 : : /* %<__func__%> */
72 : : NIC_C99_FUNC,
73 : : /* "%<va_arg%> */
74 : : NIC_VA_ARG,
75 : : /* a cast */
76 : : NIC_CAST,
77 : : /* %<typeid%> operator */
78 : : NIC_TYPEID,
79 : : /* non-constant compound literals */
80 : : NIC_NCC,
81 : : /* a function call */
82 : : NIC_FUNC_CALL,
83 : : /* an increment */
84 : : NIC_INC,
85 : : /* an decrement */
86 : : NIC_DEC,
87 : : /* an array reference */
88 : : NIC_ARRAY_REF,
89 : : /* %<->%> */
90 : : NIC_ARROW,
91 : : /* %<.%> */
92 : : NIC_POINT,
93 : : /* the address of a label */
94 : : NIC_ADDR_LABEL,
95 : : /* %<*%> */
96 : : NIC_STAR,
97 : : /* %<&%> */
98 : : NIC_ADDR,
99 : : /* %<++%> */
100 : : NIC_PREINCREMENT,
101 : : /* %<--%> */
102 : : NIC_PREDECREMENT,
103 : : /* %<new%> */
104 : : NIC_NEW,
105 : : /* %<delete%> */
106 : : NIC_DEL,
107 : : /* calls to overloaded operators */
108 : : NIC_OVERLOADED,
109 : : /* an assignment */
110 : : NIC_ASSIGNMENT,
111 : : /* a comma operator */
112 : : NIC_COMMA,
113 : : /* a call to a constructor */
114 : : NIC_CONSTRUCTOR,
115 : : /* a transaction expression */
116 : : NIC_TRANSACTION
117 : : };
118 : :
119 : : /* The various kinds of errors about name-lookup failing. */
120 : : enum name_lookup_error {
121 : : /* NULL */
122 : : NLE_NULL,
123 : : /* is not a type */
124 : : NLE_TYPE,
125 : : /* is not a class or namespace */
126 : : NLE_CXX98,
127 : : /* is not a class, namespace, or enumeration */
128 : : NLE_NOT_CXX98
129 : : };
130 : :
131 : : /* The various kinds of required token */
132 : : enum required_token {
133 : : RT_NONE,
134 : : RT_SEMICOLON, /* ';' */
135 : : RT_OPEN_PAREN, /* '(' */
136 : : RT_CLOSE_BRACE, /* '}' */
137 : : RT_OPEN_BRACE, /* '{' */
138 : : RT_CLOSE_SQUARE, /* ']' */
139 : : RT_OPEN_SQUARE, /* '[' */
140 : : RT_COMMA, /* ',' */
141 : : RT_SCOPE, /* '::' */
142 : : RT_LESS, /* '<' */
143 : : RT_GREATER, /* '>' */
144 : : RT_EQ, /* '=' */
145 : : RT_ELLIPSIS, /* '...' */
146 : : RT_MULT, /* '*' */
147 : : RT_COMPL, /* '~' */
148 : : RT_COLON, /* ':' */
149 : : RT_COLON_SCOPE, /* ':' or '::' */
150 : : RT_CLOSE_PAREN, /* ')' */
151 : : RT_COMMA_CLOSE_PAREN, /* ',' or ')' */
152 : : RT_PRAGMA_EOL, /* end of line */
153 : : RT_NAME, /* identifier */
154 : :
155 : : /* The type is CPP_KEYWORD */
156 : : RT_NEW, /* new */
157 : : RT_DELETE, /* delete */
158 : : RT_RETURN, /* return */
159 : : RT_WHILE, /* while */
160 : : RT_EXTERN, /* extern */
161 : : RT_STATIC_ASSERT, /* static_assert */
162 : : RT_DECLTYPE, /* decltype */
163 : : RT_OPERATOR, /* operator */
164 : : RT_CLASS, /* class */
165 : : RT_TEMPLATE, /* template */
166 : : RT_NAMESPACE, /* namespace */
167 : : RT_USING, /* using */
168 : : RT_ASM, /* asm */
169 : : RT_TRY, /* try */
170 : : RT_CATCH, /* catch */
171 : : RT_THROW, /* throw */
172 : : RT_AUTO, /* auto */
173 : : RT_LABEL, /* __label__ */
174 : : RT_AT_TRY, /* @try */
175 : : RT_AT_SYNCHRONIZED, /* @synchronized */
176 : : RT_AT_THROW, /* @throw */
177 : :
178 : : RT_SELECT, /* selection-statement */
179 : : RT_ITERATION, /* iteration-statement */
180 : : RT_JUMP, /* jump-statement */
181 : : RT_CLASS_KEY, /* class-key */
182 : : RT_CLASS_TYPENAME_TEMPLATE, /* class, typename, or template */
183 : : RT_TRANSACTION_ATOMIC, /* __transaction_atomic */
184 : : RT_TRANSACTION_RELAXED, /* __transaction_relaxed */
185 : : RT_TRANSACTION_CANCEL, /* __transaction_cancel */
186 : :
187 : : RT_CO_YIELD /* co_yield */
188 : : };
189 : :
190 : : /* RAII wrapper for parser->in_type_id_in_expr_p, setting it on creation and
191 : : reverting it on destruction. */
192 : :
193 : : class type_id_in_expr_sentinel
194 : : {
195 : : cp_parser *parser;
196 : : bool saved;
197 : : public:
198 : 26316678 : type_id_in_expr_sentinel (cp_parser *parser, bool set = true)
199 : 26316678 : : parser (parser),
200 : 26316678 : saved (parser->in_type_id_in_expr_p)
201 : 26316678 : { parser->in_type_id_in_expr_p = set; }
202 : 26316678 : ~type_id_in_expr_sentinel ()
203 : 26316678 : { parser->in_type_id_in_expr_p = saved; }
204 : : };
205 : :
206 : : /* Prototypes. */
207 : :
208 : : static cp_lexer *cp_lexer_new_main
209 : : (void);
210 : : static cp_lexer *cp_lexer_new_from_tokens
211 : : (cp_token_cache *tokens);
212 : : static void cp_lexer_destroy
213 : : (cp_lexer *);
214 : : static int cp_lexer_saving_tokens
215 : : (const cp_lexer *);
216 : : static cp_token *cp_lexer_token_at
217 : : (cp_lexer *, cp_token_position);
218 : : static void cp_lexer_get_preprocessor_token
219 : : (unsigned, cp_token *);
220 : : static inline cp_token *cp_lexer_peek_token
221 : : (cp_lexer *);
222 : : static cp_token *cp_lexer_peek_nth_token
223 : : (cp_lexer *, size_t);
224 : : static inline bool cp_lexer_next_token_is
225 : : (cp_lexer *, enum cpp_ttype);
226 : : static bool cp_lexer_next_token_is_not
227 : : (cp_lexer *, enum cpp_ttype);
228 : : static bool cp_lexer_next_token_is_keyword
229 : : (cp_lexer *, enum rid);
230 : : static cp_token *cp_lexer_consume_token
231 : : (cp_lexer *);
232 : : static void cp_lexer_purge_token
233 : : (cp_lexer *);
234 : : static void cp_lexer_purge_tokens_after
235 : : (cp_lexer *, cp_token_position);
236 : : static void cp_lexer_save_tokens
237 : : (cp_lexer *);
238 : : static void cp_lexer_commit_tokens
239 : : (cp_lexer *);
240 : : static void cp_lexer_rollback_tokens
241 : : (cp_lexer *);
242 : : static void cp_lexer_print_token
243 : : (FILE *, cp_token *);
244 : : static inline bool cp_lexer_debugging_p
245 : : (cp_lexer *);
246 : : static void cp_lexer_start_debugging
247 : : (cp_lexer *) ATTRIBUTE_UNUSED;
248 : : static void cp_lexer_stop_debugging
249 : : (cp_lexer *) ATTRIBUTE_UNUSED;
250 : : static const cp_trait *cp_lexer_peek_trait
251 : : (cp_lexer *);
252 : : static const cp_trait *cp_lexer_peek_trait_expr
253 : : (cp_lexer *);
254 : : static const cp_trait *cp_lexer_peek_trait_type
255 : : (cp_lexer *);
256 : :
257 : : static cp_token_cache *cp_token_cache_new
258 : : (cp_token *, cp_token *);
259 : : static tree cp_parser_late_noexcept_specifier
260 : : (cp_parser *, tree);
261 : : static void noexcept_override_late_checks
262 : : (tree);
263 : :
264 : : static void cp_parser_initial_pragma
265 : : (cp_token *);
266 : :
267 : : static bool cp_parser_omp_declare_reduction_exprs
268 : : (tree, cp_parser *);
269 : : static void cp_finalize_oacc_routine
270 : : (cp_parser *, tree, bool);
271 : :
272 : : static void check_omp_intervening_code
273 : : (cp_parser *);
274 : :
275 : :
276 : : /* Manifest constants. */
277 : : #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
278 : : #define CP_SAVED_TOKEN_STACK 5
279 : :
280 : : /* Variables. */
281 : :
282 : : /* The stream to which debugging output should be written. */
283 : : static FILE *cp_lexer_debug_stream;
284 : :
285 : : /* Nonzero if we are parsing an unevaluated operand: an operand to
286 : : sizeof, typeof, or alignof. */
287 : : int cp_unevaluated_operand;
288 : :
289 : : /* Dump up to NUM tokens in BUFFER to FILE starting with token
290 : : START_TOKEN. If START_TOKEN is NULL, the dump starts with the
291 : : first token in BUFFER. If NUM is 0, dump all the tokens. If
292 : : CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
293 : : highlighted by surrounding it in [[ ]]. */
294 : :
295 : : static void
296 : 0 : cp_lexer_dump_tokens (FILE *file, vec<cp_token, va_gc> *buffer,
297 : : cp_token *start_token, unsigned num,
298 : : cp_token *curr_token)
299 : : {
300 : 0 : unsigned i, nprinted;
301 : 0 : cp_token *token;
302 : 0 : bool do_print;
303 : :
304 : 0 : fprintf (file, "%u tokens\n", vec_safe_length (buffer));
305 : :
306 : 0 : if (buffer == NULL)
307 : 0 : return;
308 : :
309 : 0 : if (num == 0)
310 : 0 : num = buffer->length ();
311 : :
312 : 0 : if (start_token == NULL)
313 : 0 : start_token = buffer->address ();
314 : :
315 : 0 : if (start_token > buffer->address ())
316 : : {
317 : 0 : cp_lexer_print_token (file, &(*buffer)[0]);
318 : 0 : fprintf (file, " ... ");
319 : : }
320 : :
321 : : do_print = false;
322 : : nprinted = 0;
323 : 0 : for (i = 0; buffer->iterate (i, &token) && nprinted < num; i++)
324 : : {
325 : 0 : if (token == start_token)
326 : : do_print = true;
327 : :
328 : 0 : if (!do_print)
329 : 0 : continue;
330 : :
331 : 0 : nprinted++;
332 : 0 : if (token == curr_token)
333 : 0 : fprintf (file, "[[");
334 : :
335 : 0 : cp_lexer_print_token (file, token);
336 : :
337 : 0 : if (token == curr_token)
338 : 0 : fprintf (file, "]]");
339 : :
340 : 0 : switch (token->type)
341 : : {
342 : 0 : case CPP_SEMICOLON:
343 : 0 : case CPP_OPEN_BRACE:
344 : 0 : case CPP_CLOSE_BRACE:
345 : 0 : case CPP_EOF:
346 : 0 : fputc ('\n', file);
347 : 0 : break;
348 : :
349 : 0 : default:
350 : 0 : fputc (' ', file);
351 : : }
352 : : }
353 : :
354 : 0 : if (i == num && i < buffer->length ())
355 : : {
356 : 0 : fprintf (file, " ... ");
357 : 0 : cp_lexer_print_token (file, &buffer->last ());
358 : : }
359 : :
360 : 0 : fprintf (file, "\n");
361 : : }
362 : :
363 : :
364 : : /* Dump all tokens in BUFFER to stderr. */
365 : :
366 : : void
367 : 0 : cp_lexer_debug_tokens (vec<cp_token, va_gc> *buffer)
368 : : {
369 : 0 : cp_lexer_dump_tokens (stderr, buffer, NULL, 0, NULL);
370 : 0 : }
371 : :
372 : : DEBUG_FUNCTION void
373 : 0 : debug (vec<cp_token, va_gc> &ref)
374 : : {
375 : 0 : cp_lexer_dump_tokens (stderr, &ref, NULL, 0, NULL);
376 : 0 : }
377 : :
378 : : DEBUG_FUNCTION void
379 : 0 : debug (vec<cp_token, va_gc> *ptr)
380 : : {
381 : 0 : if (ptr)
382 : 0 : debug (*ptr);
383 : : else
384 : 0 : fprintf (stderr, "<nil>\n");
385 : 0 : }
386 : :
387 : :
388 : : /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
389 : : description for T. */
390 : :
391 : : static void
392 : 0 : cp_debug_print_tree_if_set (FILE *file, const char *desc, tree t)
393 : : {
394 : 0 : if (t)
395 : : {
396 : 0 : fprintf (file, "%s: ", desc);
397 : 0 : print_node_brief (file, "", t, 0);
398 : : }
399 : 0 : }
400 : :
401 : :
402 : : /* Dump parser context C to FILE. */
403 : :
404 : : static void
405 : 0 : cp_debug_print_context (FILE *file, cp_parser_context *c)
406 : : {
407 : 0 : const char *status_s[] = { "OK", "ERROR", "COMMITTED" };
408 : 0 : fprintf (file, "{ status = %s, scope = ", status_s[c->status]);
409 : 0 : print_node_brief (file, "", c->object_type, 0);
410 : 0 : fprintf (file, "}\n");
411 : 0 : }
412 : :
413 : :
414 : : /* Print the stack of parsing contexts to FILE starting with FIRST. */
415 : :
416 : : static void
417 : 0 : cp_debug_print_context_stack (FILE *file, cp_parser_context *first)
418 : : {
419 : 0 : unsigned i;
420 : 0 : cp_parser_context *c;
421 : :
422 : 0 : fprintf (file, "Parsing context stack:\n");
423 : 0 : for (i = 0, c = first; c; c = c->next, i++)
424 : : {
425 : 0 : fprintf (file, "\t#%u: ", i);
426 : 0 : cp_debug_print_context (file, c);
427 : : }
428 : 0 : }
429 : :
430 : :
431 : : /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
432 : :
433 : : static void
434 : 0 : cp_debug_print_flag (FILE *file, const char *desc, bool flag)
435 : : {
436 : 0 : if (flag)
437 : 0 : fprintf (file, "%s: true\n", desc);
438 : 0 : }
439 : :
440 : :
441 : : /* Print an unparsed function entry UF to FILE. */
442 : :
443 : : static void
444 : 0 : cp_debug_print_unparsed_function (FILE *file, cp_unparsed_functions_entry *uf)
445 : : {
446 : 0 : unsigned i;
447 : 0 : cp_default_arg_entry *default_arg_fn;
448 : 0 : tree fn;
449 : :
450 : 0 : fprintf (file, "\tFunctions with default args:\n");
451 : 0 : for (i = 0;
452 : 0 : vec_safe_iterate (uf->funs_with_default_args, i, &default_arg_fn);
453 : : i++)
454 : : {
455 : 0 : fprintf (file, "\t\tClass type: ");
456 : 0 : print_node_brief (file, "", default_arg_fn->class_type, 0);
457 : 0 : fprintf (file, "\t\tDeclaration: ");
458 : 0 : print_node_brief (file, "", default_arg_fn->decl, 0);
459 : 0 : fprintf (file, "\n");
460 : : }
461 : :
462 : 0 : fprintf (file, "\n\tFunctions with definitions that require "
463 : : "post-processing\n\t\t");
464 : 0 : for (i = 0; vec_safe_iterate (uf->funs_with_definitions, i, &fn); i++)
465 : : {
466 : 0 : print_node_brief (file, "", fn, 0);
467 : 0 : fprintf (file, " ");
468 : : }
469 : 0 : fprintf (file, "\n");
470 : :
471 : 0 : fprintf (file, "\n\tNon-static data members with initializers that require "
472 : : "post-processing\n\t\t");
473 : 0 : for (i = 0; vec_safe_iterate (uf->nsdmis, i, &fn); i++)
474 : : {
475 : 0 : print_node_brief (file, "", fn, 0);
476 : 0 : fprintf (file, " ");
477 : : }
478 : 0 : fprintf (file, "\n");
479 : 0 : }
480 : :
481 : :
482 : : /* Print the stack of unparsed member functions S to FILE. */
483 : :
484 : : static void
485 : 0 : cp_debug_print_unparsed_queues (FILE *file,
486 : : vec<cp_unparsed_functions_entry, va_gc> *s)
487 : : {
488 : 0 : unsigned i;
489 : 0 : cp_unparsed_functions_entry *uf;
490 : :
491 : 0 : fprintf (file, "Unparsed functions\n");
492 : 0 : for (i = 0; vec_safe_iterate (s, i, &uf); i++)
493 : : {
494 : 0 : fprintf (file, "#%u:\n", i);
495 : 0 : cp_debug_print_unparsed_function (file, uf);
496 : : }
497 : 0 : }
498 : :
499 : :
500 : : /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
501 : : the given PARSER. If FILE is NULL, the output is printed on stderr. */
502 : :
503 : : static void
504 : 0 : cp_debug_parser_tokens (FILE *file, cp_parser *parser, int window_size)
505 : : {
506 : 0 : cp_token *next_token, *first_token, *start_token;
507 : :
508 : 0 : if (file == NULL)
509 : 0 : file = stderr;
510 : :
511 : 0 : next_token = parser->lexer->next_token;
512 : 0 : first_token = parser->lexer->buffer->address ();
513 : 0 : start_token = (next_token > first_token + window_size / 2)
514 : 0 : ? next_token - window_size / 2
515 : : : first_token;
516 : 0 : cp_lexer_dump_tokens (file, parser->lexer->buffer, start_token, window_size,
517 : : next_token);
518 : 0 : }
519 : :
520 : :
521 : : /* Dump debugging information for the given PARSER. If FILE is NULL,
522 : : the output is printed on stderr. */
523 : :
524 : : void
525 : 0 : cp_debug_parser (FILE *file, cp_parser *parser)
526 : : {
527 : 0 : const size_t window_size = 20;
528 : 0 : cp_token *token;
529 : 0 : expanded_location eloc;
530 : :
531 : 0 : if (file == NULL)
532 : 0 : file = stderr;
533 : :
534 : 0 : fprintf (file, "Parser state\n\n");
535 : 0 : fprintf (file, "Number of tokens: %u\n",
536 : 0 : vec_safe_length (parser->lexer->buffer));
537 : 0 : cp_debug_print_tree_if_set (file, "Lookup scope", parser->scope);
538 : 0 : cp_debug_print_tree_if_set (file, "Object scope",
539 : : parser->object_scope);
540 : 0 : cp_debug_print_tree_if_set (file, "Qualifying scope",
541 : : parser->qualifying_scope);
542 : 0 : cp_debug_print_context_stack (file, parser->context);
543 : 0 : cp_debug_print_flag (file, "Allow GNU extensions",
544 : 0 : parser->allow_gnu_extensions_p);
545 : 0 : cp_debug_print_flag (file, "'>' token is greater-than",
546 : 0 : parser->greater_than_is_operator_p);
547 : 0 : cp_debug_print_flag (file, "Default args allowed in current "
548 : 0 : "parameter list", parser->default_arg_ok_p);
549 : 0 : cp_debug_print_flag (file, "Parsing integral constant-expression",
550 : 0 : parser->integral_constant_expression_p);
551 : 0 : cp_debug_print_flag (file, "Allow non-constant expression in current "
552 : : "constant-expression",
553 : 0 : parser->allow_non_integral_constant_expression_p);
554 : 0 : cp_debug_print_flag (file, "Seen non-constant expression",
555 : 0 : parser->non_integral_constant_expression_p);
556 : 0 : cp_debug_print_flag (file, "Local names forbidden in current context",
557 : 0 : (parser->local_variables_forbidden_p
558 : 0 : & LOCAL_VARS_FORBIDDEN));
559 : 0 : cp_debug_print_flag (file, "'this' forbidden in current context",
560 : 0 : (parser->local_variables_forbidden_p
561 : : & THIS_FORBIDDEN));
562 : 0 : cp_debug_print_flag (file, "In unbraced linkage specification",
563 : 0 : parser->in_unbraced_linkage_specification_p);
564 : 0 : cp_debug_print_flag (file, "In unbraced export declaration",
565 : 0 : parser->in_unbraced_export_declaration_p);
566 : 0 : cp_debug_print_flag (file, "Parsing a declarator",
567 : 0 : parser->in_declarator_p);
568 : 0 : cp_debug_print_flag (file, "In template argument list",
569 : 0 : parser->in_template_argument_list_p);
570 : 0 : cp_debug_print_flag (file, "Parsing an iteration statement",
571 : 0 : parser->in_statement & IN_ITERATION_STMT);
572 : 0 : cp_debug_print_flag (file, "Parsing a switch statement",
573 : 0 : parser->in_statement & IN_SWITCH_STMT);
574 : 0 : cp_debug_print_flag (file, "Parsing a structured OpenMP block",
575 : 0 : parser->in_statement & IN_OMP_BLOCK);
576 : 0 : cp_debug_print_flag (file, "Parsing an OpenMP loop",
577 : 0 : parser->in_statement & IN_OMP_FOR);
578 : 0 : cp_debug_print_flag (file, "Parsing an if statement",
579 : 0 : parser->in_statement & IN_IF_STMT);
580 : 0 : cp_debug_print_flag (file, "Parsing a type-id in an expression "
581 : 0 : "context", parser->in_type_id_in_expr_p);
582 : 0 : cp_debug_print_flag (file, "String expressions should be translated "
583 : : "to execution character set",
584 : 0 : parser->translate_strings_p);
585 : 0 : cp_debug_print_flag (file, "Parsing function body outside of a "
586 : 0 : "local class", parser->in_function_body);
587 : 0 : cp_debug_print_flag (file, "Auto correct a colon to a scope operator",
588 : 0 : parser->colon_corrects_to_scope_p);
589 : 0 : cp_debug_print_flag (file, "Colon doesn't start a class definition",
590 : 0 : parser->colon_doesnt_start_class_def_p);
591 : 0 : cp_debug_print_flag (file, "Parsing an Objective-C++ message context",
592 : 0 : parser->objective_c_message_context_p);
593 : 0 : if (parser->type_definition_forbidden_message)
594 : 0 : fprintf (file, "Error message for forbidden type definitions: %s %s\n",
595 : : parser->type_definition_forbidden_message,
596 : 0 : parser->type_definition_forbidden_message_arg
597 : : ? parser->type_definition_forbidden_message_arg : "<none>");
598 : 0 : cp_debug_print_unparsed_queues (file, parser->unparsed_queues);
599 : 0 : fprintf (file, "Number of class definitions in progress: %u\n",
600 : : parser->num_classes_being_defined);
601 : 0 : fprintf (file, "Number of template parameter lists for the current "
602 : : "declaration: %u\n", parser->num_template_parameter_lists);
603 : 0 : cp_debug_parser_tokens (file, parser, window_size);
604 : 0 : token = parser->lexer->next_token;
605 : 0 : fprintf (file, "Next token to parse:\n");
606 : 0 : fprintf (file, "\tToken: ");
607 : 0 : cp_lexer_print_token (file, token);
608 : 0 : eloc = expand_location (token->location);
609 : 0 : fprintf (file, "\n\tFile: %s\n", eloc.file);
610 : 0 : fprintf (file, "\tLine: %d\n", eloc.line);
611 : 0 : fprintf (file, "\tColumn: %d\n", eloc.column);
612 : 0 : }
613 : :
614 : : DEBUG_FUNCTION void
615 : 0 : debug (cp_parser &ref)
616 : : {
617 : 0 : cp_debug_parser (stderr, &ref);
618 : 0 : }
619 : :
620 : : DEBUG_FUNCTION void
621 : 0 : debug (cp_parser *ptr)
622 : : {
623 : 0 : if (ptr)
624 : 0 : debug (*ptr);
625 : : else
626 : 0 : fprintf (stderr, "<nil>\n");
627 : 0 : }
628 : :
629 : : /* Allocate memory for a new lexer object and return it. */
630 : :
631 : : static cp_lexer *
632 : 93975 : cp_lexer_alloc (void)
633 : : {
634 : : /* Allocate the memory. */
635 : 93975 : cp_lexer *lexer = ggc_cleared_alloc<cp_lexer> ();
636 : :
637 : : /* Initially we are not debugging. */
638 : 93975 : lexer->debugging_p = false;
639 : :
640 : 93975 : lexer->saved_tokens.create (CP_SAVED_TOKEN_STACK);
641 : :
642 : : /* Create the buffer. */
643 : 93975 : vec_alloc (lexer->buffer, CP_LEXER_BUFFER_SIZE);
644 : :
645 : 93975 : return lexer;
646 : : }
647 : :
648 : : /* Return TRUE if token is the start of a module declaration that will be
649 : : terminated by a CPP_PRAGMA_EOL token. */
650 : : static inline bool
651 : 121643608 : cp_token_is_module_directive (cp_token *token)
652 : : {
653 : 121643608 : return token->keyword == RID__EXPORT
654 : 121643602 : || token->keyword == RID__MODULE
655 : 121641540 : || token->keyword == RID__IMPORT;
656 : : }
657 : :
658 : : /* Return TOKEN's pragma_kind if it is CPP_PRAGMA, otherwise
659 : : PRAGMA_NONE. */
660 : :
661 : : static enum pragma_kind
662 : 10365917 : cp_parser_pragma_kind (cp_token *token)
663 : : {
664 : 10365917 : if (token->type != CPP_PRAGMA)
665 : : return PRAGMA_NONE;
666 : : /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
667 : 10292190 : return (enum pragma_kind) TREE_INT_CST_LOW (token->u.value);
668 : : }
669 : :
670 : : /* Handle early pragmas such as #pragma GCC diagnostic, which needs to be done
671 : : during preprocessing for the case of preprocessing-related diagnostics. This
672 : : is called immediately after pushing the CPP_PRAGMA_EOL token onto
673 : : lexer->buffer. */
674 : :
675 : : static void
676 : 5114997 : cp_lexer_handle_early_pragma (cp_lexer *lexer)
677 : : {
678 : 5114997 : const auto first_token = lexer->buffer->address ();
679 : 5114997 : const auto last_token = first_token + lexer->buffer->length () - 1;
680 : :
681 : : /* Back up to the start of the pragma so pragma_lex () can parse it when
682 : : c-pragma lib asks it to. */
683 : 5114997 : auto begin = last_token;
684 : 5114997 : gcc_assert (begin->type == CPP_PRAGMA_EOL);
685 : 17752414 : while (begin->type != CPP_PRAGMA)
686 : : {
687 : 12641470 : if (cp_token_is_module_directive (begin))
688 : : return;
689 : 12637417 : gcc_assert (begin != first_token);
690 : 12637417 : --begin;
691 : : }
692 : 5110944 : gcc_assert (!lexer->next_token);
693 : 5110944 : gcc_assert (!lexer->last_token);
694 : 5110944 : lexer->next_token = begin;
695 : 5110944 : lexer->last_token = last_token;
696 : :
697 : : /* Dispatch it. */
698 : 5110944 : const unsigned int id
699 : 5110944 : = cp_parser_pragma_kind (cp_lexer_consume_token (lexer));
700 : 5110944 : if (id >= PRAGMA_FIRST_EXTERNAL)
701 : 5045254 : c_invoke_early_pragma_handler (id);
702 : :
703 : : /* Reset to normal state. */
704 : 5110944 : lexer->next_token = lexer->last_token = nullptr;
705 : : }
706 : :
707 : : /* The parser. */
708 : : static cp_parser *cp_parser_new (cp_lexer *);
709 : : static GTY (()) cp_parser *the_parser;
710 : :
711 : : /* Create a new main C++ lexer, the lexer that gets tokens from the
712 : : preprocessor, and also create the main parser. */
713 : :
714 : : static cp_lexer *
715 : 90780 : cp_lexer_new_main (void)
716 : : {
717 : 90780 : cp_token token;
718 : :
719 : : /* It's possible that parsing the first pragma will load a PCH file,
720 : : which is a GC collection point. So we have to do that before
721 : : allocating any memory. */
722 : 90780 : cp_lexer_get_preprocessor_token (C_LEX_STRING_NO_JOIN, &token);
723 : 90748 : cp_parser_initial_pragma (&token);
724 : 90748 : c_common_no_more_pch ();
725 : :
726 : 90748 : cp_lexer *lexer = cp_lexer_alloc ();
727 : : /* Put the first token in the buffer. */
728 : 90748 : cp_token *tok = lexer->buffer->quick_push (token);
729 : :
730 : 90748 : uintptr_t filter = 0;
731 : 90748 : if (modules_p ())
732 : 3770 : filter = module_token_cdtor (parse_in, filter);
733 : :
734 : : /* Create the parser now, so we can use it to handle early pragmas. */
735 : 90748 : gcc_assert (!the_parser);
736 : 90748 : the_parser = cp_parser_new (lexer);
737 : :
738 : : /* Get the remaining tokens from the preprocessor. */
739 : 7599840541 : while (tok->type != CPP_EOF)
740 : : {
741 : 7599749795 : if (filter)
742 : : /* Process the previous token. */
743 : 38799702 : module_token_lang (tok->type, tok->keyword, tok->u.value,
744 : : tok->location, filter);
745 : :
746 : : /* Check for early pragmas that need to be handled now. */
747 : 7599749795 : if (tok->type == CPP_PRAGMA_EOL)
748 : 5114997 : cp_lexer_handle_early_pragma (lexer);
749 : :
750 : 7599749795 : tok = vec_safe_push (lexer->buffer, cp_token ());
751 : 7599749795 : cp_lexer_get_preprocessor_token (C_LEX_STRING_NO_JOIN, tok);
752 : : }
753 : :
754 : 90746 : lexer->next_token = lexer->buffer->address ();
755 : 90746 : lexer->last_token = lexer->next_token
756 : 90746 : + lexer->buffer->length ()
757 : 90746 : - 1;
758 : :
759 : 90746 : if (lexer->buffer->length () != 1)
760 : : {
761 : : /* Set the EOF token's location to be the just after the previous
762 : : token's range. That way 'at-eof' diagnostics point at something
763 : : meaninful. */
764 : 90115 : auto range = get_range_from_loc (line_table, tok[-1].location);
765 : 90115 : tok[0].location
766 : 90115 : = linemap_position_for_loc_and_offset (line_table, range.m_finish, 1);
767 : : }
768 : :
769 : 90746 : if (filter)
770 : 3770 : module_token_cdtor (parse_in, filter);
771 : :
772 : : /* Subsequent preprocessor diagnostics should use compiler
773 : : diagnostic functions to get the compiler source location. */
774 : 90743 : override_libcpp_locations = true;
775 : :
776 : 90743 : maybe_check_all_macros (parse_in);
777 : :
778 : : /* If we processed any #pragma GCC target directives, we handled them early so
779 : : any macros they defined would be effective during preprocessing. Now, we
780 : : need to reset to the default state to begin compilation, and we will
781 : : process them again at the correct time as needed. */
782 : 90743 : c_reset_target_pragmas ();
783 : :
784 : 90743 : gcc_assert (!lexer->next_token->purged_p);
785 : 90743 : return lexer;
786 : : }
787 : :
788 : : /* Create a lexer and parser to be used during preprocess-only mode.
789 : : This will be filled with tokens to parse when needed by pragma_lex (). */
790 : : void
791 : 1256 : c_init_preprocess ()
792 : : {
793 : 1256 : gcc_assert (!the_parser);
794 : 1256 : the_parser = cp_parser_new (cp_lexer_alloc ());
795 : 1256 : }
796 : :
797 : : /* Create a new lexer whose token stream is primed with the tokens in
798 : : CACHE. When these tokens are exhausted, no new tokens will be read. */
799 : :
800 : : static cp_lexer *
801 : 73193314 : cp_lexer_new_from_tokens (cp_token_cache *cache)
802 : : {
803 : 73193314 : cp_token *first = cache->first;
804 : 73193314 : cp_token *last = cache->last;
805 : 73193314 : cp_lexer *lexer = ggc_cleared_alloc<cp_lexer> ();
806 : :
807 : : /* We do not own the buffer. */
808 : 73193314 : lexer->buffer = NULL;
809 : :
810 : : /* Insert an EOF token. */
811 : 73193314 : lexer->saved_type = last->type;
812 : 73193314 : lexer->saved_keyword = last->keyword;
813 : 73193314 : last->type = CPP_EOF;
814 : 73193314 : last->keyword = RID_MAX;
815 : :
816 : 73193314 : lexer->next_token = first;
817 : 73193314 : lexer->last_token = last;
818 : :
819 : 73193314 : lexer->saved_tokens.create (CP_SAVED_TOKEN_STACK);
820 : :
821 : : /* Initially we are not debugging. */
822 : 73193314 : lexer->debugging_p = false;
823 : :
824 : 73193314 : gcc_assert (!lexer->next_token->purged_p
825 : : && !lexer->last_token->purged_p);
826 : 73193314 : return lexer;
827 : : }
828 : :
829 : : /* Frees all resources associated with LEXER. */
830 : :
831 : : static void
832 : 73285716 : cp_lexer_destroy (cp_lexer *lexer)
833 : : {
834 : 73285716 : if (lexer->buffer)
835 : 92402 : vec_free (lexer->buffer);
836 : : else
837 : : {
838 : : /* Restore the token we overwrite with EOF. */
839 : 73193314 : lexer->last_token->type = lexer->saved_type;
840 : 73193314 : lexer->last_token->keyword = lexer->saved_keyword;
841 : : }
842 : 73285716 : lexer->saved_tokens.release ();
843 : 73285716 : ggc_free (lexer);
844 : 73285716 : }
845 : :
846 : : /* This needs to be set to TRUE before the lexer-debugging infrastructure can
847 : : be used. The point of this flag is to help the compiler to fold away calls
848 : : to cp_lexer_debugging_p within this source file at compile time, when the
849 : : lexer is not being debugged. */
850 : :
851 : : #define LEXER_DEBUGGING_ENABLED_P false
852 : :
853 : : /* Returns nonzero if debugging information should be output. */
854 : :
855 : : static inline bool
856 : : cp_lexer_debugging_p (cp_lexer *lexer)
857 : : {
858 : : if (!LEXER_DEBUGGING_ENABLED_P)
859 : : return false;
860 : :
861 : : return lexer->debugging_p;
862 : : }
863 : :
864 : :
865 : : static inline cp_token_position
866 : 1092871528 : cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
867 : : {
868 : 1092871528 : return lexer->next_token - previous_p;
869 : : }
870 : :
871 : : static inline cp_token *
872 : : cp_lexer_token_at (cp_lexer * /*lexer*/, cp_token_position pos)
873 : : {
874 : : return pos;
875 : : }
876 : :
877 : : static inline void
878 : 3153236 : cp_lexer_set_token_position (cp_lexer *lexer, cp_token_position pos)
879 : : {
880 : 3153236 : lexer->next_token = cp_lexer_token_at (lexer, pos);
881 : 2975845 : }
882 : :
883 : : static inline cp_token_position
884 : 1092857000 : cp_lexer_previous_token_position (cp_lexer *lexer)
885 : : {
886 : 1092857000 : return cp_lexer_token_position (lexer, true);
887 : : }
888 : :
889 : : static inline cp_token *
890 : 1092853582 : cp_lexer_previous_token (cp_lexer *lexer)
891 : : {
892 : 1092853582 : cp_token_position tp = cp_lexer_previous_token_position (lexer);
893 : :
894 : : /* Skip past purged tokens. */
895 : 1101517305 : while (tp->purged_p)
896 : : {
897 : 16072690 : gcc_assert (tp != vec_safe_address (lexer->buffer));
898 : 8663723 : tp--;
899 : : }
900 : :
901 : 1092853582 : return cp_lexer_token_at (lexer, tp);
902 : : }
903 : :
904 : : /* Same as above, but return NULL when the lexer doesn't own the token
905 : : buffer or if the next_token is at the start of the token
906 : : vector or if all previous tokens are purged. */
907 : :
908 : : static cp_token *
909 : 3477 : cp_lexer_safe_previous_token (cp_lexer *lexer)
910 : : {
911 : 3477 : if (lexer->buffer
912 : 3477 : && lexer->next_token != lexer->buffer->address ())
913 : : {
914 : 3328 : cp_token_position tp = cp_lexer_previous_token_position (lexer);
915 : :
916 : : /* Skip past purged tokens. */
917 : 3571 : while (tp->purged_p)
918 : : {
919 : 243 : if (tp == lexer->buffer->address ())
920 : : return NULL;
921 : 243 : tp--;
922 : : }
923 : : return cp_lexer_token_at (lexer, tp);
924 : : }
925 : :
926 : : return NULL;
927 : : }
928 : :
929 : : /* Overload for make_location, taking the lexer to mean the location of the
930 : : previous token. */
931 : :
932 : : static inline location_t
933 : 379868229 : make_location (location_t caret, location_t start, cp_lexer *lexer)
934 : : {
935 : 379868229 : cp_token *t = cp_lexer_previous_token (lexer);
936 : 379868229 : return make_location (caret, start, t->location);
937 : : }
938 : :
939 : : /* Overload for make_location taking tokens instead of locations. */
940 : :
941 : : static inline location_t
942 : 12 : make_location (cp_token *caret, cp_token *start, cp_token *end)
943 : : {
944 : 12 : return make_location (caret->location, start->location, end->location);
945 : : }
946 : :
947 : : /* Location for the whitespace between two tokens. */
948 : :
949 : : static location_t
950 : 65 : location_between (cp_token *stok, cp_token *etok)
951 : : {
952 : 65 : location_t s = get_finish (stok->location);
953 : 65 : s = linemap_position_for_loc_and_offset (line_table, s, 1);
954 : 65 : location_t e = get_start (etok->location);
955 : 65 : e = linemap_position_for_loc_and_offset (line_table, e, -1);
956 : 65 : return make_location (s, s, e);
957 : : }
958 : :
959 : : /* nonzero if we are presently saving tokens. */
960 : :
961 : : static inline int
962 : 372642424 : cp_lexer_saving_tokens (const cp_lexer* lexer)
963 : : {
964 : 745284848 : return lexer->saved_tokens.length () != 0;
965 : : }
966 : :
967 : : /* Store the next token from the preprocessor in *TOKEN. Return true
968 : : if we reach EOF. If LEXER is NULL, assume we are handling an
969 : : initial #pragma pch_preprocess, and thus want the lexer to return
970 : : processed strings.
971 : :
972 : : Diagnostics issued from this function must have their controlling option (if
973 : : any) in c.opt annotated as a libcpp option via the CppReason property. */
974 : :
975 : : static void
976 : 7599881566 : cp_lexer_get_preprocessor_token (unsigned flags, cp_token *token)
977 : : {
978 : 7599881566 : static int is_extern_c = 0;
979 : :
980 : : /* Get a new token from the preprocessor. */
981 : 7599881566 : token->type
982 : 7599881566 : = c_lex_with_flags (&token->u.value, &token->location, &token->flags,
983 : : flags);
984 : 7599881532 : token->keyword = RID_MAX;
985 : 7599881532 : token->purged_p = false;
986 : 7599881532 : token->error_reported = false;
987 : 7599881532 : token->tree_check_p = false;
988 : : /* Usually never see a zero, but just in case ... */
989 : 7599881532 : token->main_source_p = line_table->depth <= 1;
990 : :
991 : : /* On some systems, some header files are surrounded by an
992 : : implicit extern "C" block. Set a flag in the token if it
993 : : comes from such a header. */
994 : 7599881532 : is_extern_c += pending_lang_change;
995 : 7599881532 : pending_lang_change = 0;
996 : 7599881532 : token->implicit_extern_c = is_extern_c > 0;
997 : :
998 : : /* Check to see if this token is a keyword. */
999 : 7599881532 : if (token->type == CPP_NAME)
1000 : : {
1001 : 3533387732 : if (IDENTIFIER_KEYWORD_P (token->u.value))
1002 : : {
1003 : : /* Mark this token as a keyword. */
1004 : 1240985209 : token->type = CPP_KEYWORD;
1005 : : /* Record which keyword. */
1006 : 1240985209 : token->keyword = C_RID_CODE (token->u.value);
1007 : : }
1008 : : else
1009 : : {
1010 : 2292402523 : if (warn_cxx11_compat
1011 : 2171004 : && ((C_RID_CODE (token->u.value) >= RID_FIRST_CXX11
1012 : 2171004 : && C_RID_CODE (token->u.value) <= RID_LAST_CXX11)
1013 : : /* These are outside the CXX11 range. */
1014 : 2170992 : || C_RID_CODE (token->u.value) == RID_ALIGNOF
1015 : 2170990 : || C_RID_CODE (token->u.value) == RID_ALIGNAS
1016 : 2170988 : || C_RID_CODE (token->u.value)== RID_THREAD))
1017 : : {
1018 : : /* Warn about the C++11 keyword (but still treat it as
1019 : : an identifier). */
1020 : 18 : warning_at (token->location, OPT_Wc__11_compat,
1021 : : "identifier %qE is a keyword in C++11",
1022 : : token->u.value);
1023 : :
1024 : : /* Clear out the C_RID_CODE so we don't warn about this
1025 : : particular identifier-turned-keyword again. */
1026 : 18 : C_SET_RID_CODE (token->u.value, RID_MAX);
1027 : : }
1028 : 2292402523 : if (warn_cxx20_compat
1029 : 31050821 : && C_RID_CODE (token->u.value) >= RID_FIRST_CXX20
1030 : 27263 : && C_RID_CODE (token->u.value) <= RID_LAST_CXX20)
1031 : : {
1032 : : /* Warn about the C++20 keyword (but still treat it as
1033 : : an identifier). */
1034 : 17 : warning_at (token->location, OPT_Wc__20_compat,
1035 : : "identifier %qE is a keyword in C++20",
1036 : : token->u.value);
1037 : :
1038 : : /* Clear out the C_RID_CODE so we don't warn about this
1039 : : particular identifier-turned-keyword again. */
1040 : 17 : C_SET_RID_CODE (token->u.value, RID_MAX);
1041 : : }
1042 : :
1043 : 2292402523 : token->keyword = RID_MAX;
1044 : : }
1045 : : }
1046 : 4066493800 : else if (token->type == CPP_AT_NAME)
1047 : : {
1048 : : /* This only happens in Objective-C++; it must be a keyword. */
1049 : 0 : token->type = CPP_KEYWORD;
1050 : 0 : switch (C_RID_CODE (token->u.value))
1051 : : {
1052 : : /* Replace 'class' with '@class', 'private' with '@private',
1053 : : etc. This prevents confusion with the C++ keyword
1054 : : 'class', and makes the tokens consistent with other
1055 : : Objective-C 'AT' keywords. For example '@class' is
1056 : : reported as RID_AT_CLASS which is consistent with
1057 : : '@synchronized', which is reported as
1058 : : RID_AT_SYNCHRONIZED.
1059 : : */
1060 : 0 : case RID_CLASS: token->keyword = RID_AT_CLASS; break;
1061 : 0 : case RID_PRIVATE: token->keyword = RID_AT_PRIVATE; break;
1062 : 0 : case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
1063 : 0 : case RID_PUBLIC: token->keyword = RID_AT_PUBLIC; break;
1064 : 0 : case RID_THROW: token->keyword = RID_AT_THROW; break;
1065 : 0 : case RID_TRY: token->keyword = RID_AT_TRY; break;
1066 : 0 : case RID_CATCH: token->keyword = RID_AT_CATCH; break;
1067 : 0 : case RID_SYNCHRONIZED: token->keyword = RID_AT_SYNCHRONIZED; break;
1068 : 0 : default: token->keyword = C_RID_CODE (token->u.value);
1069 : : }
1070 : : }
1071 : 7599881532 : }
1072 : :
1073 : : /* Update the globals input_location and the input file stack from TOKEN. */
1074 : : static inline void
1075 : 13345516656 : cp_lexer_set_source_position_from_token (cp_token *token)
1076 : : {
1077 : 13345516656 : input_location = token->location;
1078 : 2049 : }
1079 : :
1080 : : /* Update the globals input_location and the input file stack from LEXER. */
1081 : : static inline void
1082 : 6271480 : cp_lexer_set_source_position (cp_lexer *lexer)
1083 : : {
1084 : 6271480 : cp_token *token = cp_lexer_peek_token (lexer);
1085 : 6271480 : cp_lexer_set_source_position_from_token (token);
1086 : : }
1087 : :
1088 : : /* Return a pointer to the next token in the token stream, but do not
1089 : : consume it. */
1090 : :
1091 : : static inline cp_token *
1092 : 88460459528 : cp_lexer_peek_token (cp_lexer *lexer)
1093 : : {
1094 : 88460459528 : if (cp_lexer_debugging_p (lexer))
1095 : : {
1096 : : fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream);
1097 : : cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
1098 : : putc ('\n', cp_lexer_debug_stream);
1099 : : }
1100 : 115 : return lexer->next_token;
1101 : : }
1102 : :
1103 : : /* Return true if the next token has the indicated TYPE. */
1104 : :
1105 : : static inline bool
1106 : 28390059603 : cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
1107 : : {
1108 : 30397639381 : return cp_lexer_peek_token (lexer)->type == type;
1109 : : }
1110 : :
1111 : : /* Return true if the next token does not have the indicated TYPE. */
1112 : :
1113 : : static inline bool
1114 : 5810892795 : cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
1115 : : {
1116 : 6176801452 : return !cp_lexer_next_token_is (lexer, type);
1117 : : }
1118 : :
1119 : : /* Return true if the next token is the indicated KEYWORD. */
1120 : :
1121 : : static inline bool
1122 : 3390068584 : cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
1123 : : {
1124 : 4681589755 : return cp_lexer_peek_token (lexer)->keyword == keyword;
1125 : : }
1126 : :
1127 : : static inline bool
1128 : 1115918439 : cp_lexer_nth_token_is (cp_lexer* lexer, size_t n, enum cpp_ttype type)
1129 : : {
1130 : 249 : return cp_lexer_peek_nth_token (lexer, n)->type == type;
1131 : : }
1132 : :
1133 : : static inline bool
1134 : 327460111 : cp_lexer_nth_token_is_keyword (cp_lexer* lexer, size_t n, enum rid keyword)
1135 : : {
1136 : 337226922 : return cp_lexer_peek_nth_token (lexer, n)->keyword == keyword;
1137 : : }
1138 : :
1139 : : /* Return true if KEYWORD can start a decl-specifier. */
1140 : :
1141 : : bool
1142 : 18248609 : cp_keyword_starts_decl_specifier_p (enum rid keyword)
1143 : : {
1144 : 18248609 : switch (keyword)
1145 : : {
1146 : : /* auto specifier: storage-class-specifier in C++,
1147 : : simple-type-specifier in C++0x. */
1148 : : case RID_AUTO:
1149 : : /* Storage classes. */
1150 : : case RID_REGISTER:
1151 : : case RID_STATIC:
1152 : : case RID_EXTERN:
1153 : : case RID_MUTABLE:
1154 : : case RID_THREAD:
1155 : : /* Elaborated type specifiers. */
1156 : : case RID_ENUM:
1157 : : case RID_CLASS:
1158 : : case RID_STRUCT:
1159 : : case RID_UNION:
1160 : : case RID_TYPENAME:
1161 : : /* Simple type specifiers. */
1162 : : case RID_CHAR:
1163 : : case RID_CHAR8:
1164 : : case RID_CHAR16:
1165 : : case RID_CHAR32:
1166 : : case RID_WCHAR:
1167 : : case RID_BOOL:
1168 : : case RID_SHORT:
1169 : : case RID_INT:
1170 : : case RID_LONG:
1171 : : case RID_SIGNED:
1172 : : case RID_UNSIGNED:
1173 : : case RID_FLOAT:
1174 : : case RID_DOUBLE:
1175 : : CASE_RID_FLOATN_NX:
1176 : : case RID_VOID:
1177 : : /* CV qualifiers. */
1178 : : case RID_CONST:
1179 : : case RID_VOLATILE:
1180 : : /* Function specifiers. */
1181 : : case RID_EXPLICIT:
1182 : : case RID_VIRTUAL:
1183 : : /* friend/typdef/inline specifiers. */
1184 : : case RID_FRIEND:
1185 : : case RID_TYPEDEF:
1186 : : case RID_INLINE:
1187 : : /* GNU extensions. */
1188 : : case RID_TYPEOF:
1189 : : /* C++11 extensions. */
1190 : : case RID_DECLTYPE:
1191 : : case RID_CONSTEXPR:
1192 : : /* C++20 extensions. */
1193 : : case RID_CONSTINIT:
1194 : : case RID_CONSTEVAL:
1195 : : return true;
1196 : :
1197 : 11314478 : default:
1198 : 11314478 : if (keyword >= RID_FIRST_INT_N
1199 : : && keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS
1200 : 0 : && int_n_enabled_p[keyword - RID_FIRST_INT_N])
1201 : : return true;
1202 : : return false;
1203 : : }
1204 : : }
1205 : :
1206 : : /* Peeks the corresponding built-in trait if the first token is
1207 : : a built-in trait and the second token is either `(' or `<' depending
1208 : : on the trait. Otherwise, returns nullptr. */
1209 : :
1210 : : static const cp_trait *
1211 : 3092895765 : cp_lexer_peek_trait (cp_lexer *lexer)
1212 : : {
1213 : 3092895765 : const cp_token *token1 = cp_lexer_peek_token (lexer);
1214 : 3092895765 : if (token1->type == CPP_NAME
1215 : 2179714008 : && UNLIKELY (IDENTIFIER_TRAIT_P (token1->u.value)))
1216 : : {
1217 : 5829284 : const cp_trait &trait = cp_traits[IDENTIFIER_CP_INDEX (token1->u.value)];
1218 : 5829284 : const bool is_pack_element = (trait.kind == CPTK_TYPE_PACK_ELEMENT);
1219 : :
1220 : : /* Check if the subsequent token is a `<' token to
1221 : : __type_pack_element or is a `(' token to everything else. */
1222 : 5829284 : const cp_token *token2 = cp_lexer_peek_nth_token (lexer, 2);
1223 : 5829284 : if (is_pack_element && token2->type != CPP_LESS)
1224 : : return nullptr;
1225 : 5816063 : if (!is_pack_element && token2->type != CPP_OPEN_PAREN)
1226 : : return nullptr;
1227 : :
1228 : 5563984 : return &trait;
1229 : : }
1230 : : return nullptr;
1231 : : }
1232 : :
1233 : : /* Similarly, but only if the token is an expression-yielding
1234 : : built-in trait. */
1235 : :
1236 : : static const cp_trait *
1237 : 512870677 : cp_lexer_peek_trait_expr (cp_lexer *lexer)
1238 : : {
1239 : 512870677 : const cp_trait *trait = cp_lexer_peek_trait (lexer);
1240 : 512870677 : if (trait && !trait->type)
1241 : 2205152 : return trait;
1242 : :
1243 : : return nullptr;
1244 : : }
1245 : :
1246 : : /* Similarly, but only if the token is a type-yielding
1247 : : built-in trait. */
1248 : :
1249 : : static const cp_trait *
1250 : 2580025088 : cp_lexer_peek_trait_type (cp_lexer *lexer)
1251 : : {
1252 : 2580025088 : const cp_trait *trait = cp_lexer_peek_trait (lexer);
1253 : 2580025088 : if (trait && trait->type)
1254 : 156645 : return trait;
1255 : :
1256 : : return nullptr;
1257 : : }
1258 : :
1259 : : /* Return true if the next token is a keyword for a decl-specifier. */
1260 : :
1261 : : static bool
1262 : 17809184 : cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
1263 : : {
1264 : 17809184 : cp_token *token;
1265 : :
1266 : 17809184 : if (cp_lexer_peek_trait_type (lexer))
1267 : : return true;
1268 : :
1269 : 17809184 : token = cp_lexer_peek_token (lexer);
1270 : 17809184 : return cp_keyword_starts_decl_specifier_p (token->keyword);
1271 : : }
1272 : :
1273 : : /* Returns TRUE iff the token T begins a decltype type. */
1274 : :
1275 : : static bool
1276 : 5045872142 : token_is_decltype (cp_token *t)
1277 : : {
1278 : 5045872142 : return (t->keyword == RID_DECLTYPE
1279 : 5045791312 : || t->type == CPP_DECLTYPE);
1280 : : }
1281 : :
1282 : : /* Returns TRUE iff the next token begins a decltype type. */
1283 : :
1284 : : static bool
1285 : 427531417 : cp_lexer_next_token_is_decltype (cp_lexer *lexer)
1286 : : {
1287 : 427531417 : cp_token *t = cp_lexer_peek_token (lexer);
1288 : 0 : return token_is_decltype (t);
1289 : : }
1290 : :
1291 : : /* Called when processing a token with tree_check_value; perform or defer the
1292 : : associated checks and return the value. */
1293 : :
1294 : : static tree
1295 : 439327732 : saved_checks_value (struct tree_check *check_value)
1296 : : {
1297 : : /* Perform any access checks that were deferred. */
1298 : 439327732 : vec<deferred_access_check, va_gc> *checks;
1299 : 439327732 : deferred_access_check *chk;
1300 : 439327732 : checks = check_value->checks;
1301 : 439327732 : if (checks)
1302 : : {
1303 : : int i;
1304 : 15903688 : FOR_EACH_VEC_SAFE_ELT (checks, i, chk)
1305 : 8519562 : perform_or_defer_access_check (chk->binfo,
1306 : : chk->decl,
1307 : : chk->diag_decl, tf_warning_or_error);
1308 : : }
1309 : : /* Return the stored value. */
1310 : 439327732 : return check_value->value;
1311 : : }
1312 : :
1313 : : /* Return a pointer to the Nth token in the token stream. If N is 1,
1314 : : then this is precisely equivalent to cp_lexer_peek_token (except
1315 : : that it is not inline). One would like to disallow that case, but
1316 : : there is one case (cp_parser_nth_token_starts_template_id) where
1317 : : the caller passes a variable for N and it might be 1. */
1318 : :
1319 : : static cp_token *
1320 : 19725372637 : cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
1321 : : {
1322 : 19725372637 : cp_token *token;
1323 : :
1324 : : /* N is 1-based, not zero-based. */
1325 : 19725372637 : gcc_assert (n > 0);
1326 : :
1327 : 19725372637 : if (cp_lexer_debugging_p (lexer))
1328 : : fprintf (cp_lexer_debug_stream,
1329 : : "cp_lexer: peeking ahead " HOST_SIZE_T_PRINT_DEC " at token: ",
1330 : : (fmt_size_t) n);
1331 : :
1332 : 19725372637 : --n;
1333 : 19725372637 : token = lexer->next_token;
1334 : 33927123998 : while (n && token->type != CPP_EOF)
1335 : : {
1336 : 14201751361 : ++token;
1337 : 14201751361 : if (!token->purged_p)
1338 : 12998510709 : --n;
1339 : : }
1340 : :
1341 : 19725372637 : if (cp_lexer_debugging_p (lexer))
1342 : : {
1343 : : cp_lexer_print_token (cp_lexer_debug_stream, token);
1344 : : putc ('\n', cp_lexer_debug_stream);
1345 : : }
1346 : :
1347 : 19725372637 : return token;
1348 : : }
1349 : :
1350 : : /* Return the next token, and advance the lexer's next_token pointer
1351 : : to point to the next non-purged token. */
1352 : :
1353 : : static cp_token *
1354 : 13192367388 : cp_lexer_consume_token (cp_lexer* lexer)
1355 : : {
1356 : 13192367388 : cp_token *token = lexer->next_token;
1357 : :
1358 : 15138533972 : do
1359 : : {
1360 : 15138533972 : gcc_assert (token->type != CPP_EOF);
1361 : 15138533972 : lexer->next_token++;
1362 : : }
1363 : 15138533972 : while (lexer->next_token->purged_p);
1364 : :
1365 : 13192367388 : cp_lexer_set_source_position_from_token (token);
1366 : :
1367 : : /* Provide debugging output. */
1368 : 13192367388 : if (cp_lexer_debugging_p (lexer))
1369 : : {
1370 : : fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream);
1371 : : cp_lexer_print_token (cp_lexer_debug_stream, token);
1372 : : putc ('\n', cp_lexer_debug_stream);
1373 : : }
1374 : :
1375 : 13192367388 : return token;
1376 : : }
1377 : :
1378 : : /* Permanently remove the next token from the token stream, and
1379 : : advance the next_token pointer to refer to the next non-purged
1380 : : token. */
1381 : :
1382 : : static void
1383 : 43 : cp_lexer_purge_token (cp_lexer *lexer)
1384 : : {
1385 : 43 : cp_token *tok = lexer->next_token;
1386 : :
1387 : 43 : gcc_assert (tok->type != CPP_EOF);
1388 : 43 : tok->purged_p = true;
1389 : 43 : tok->location = UNKNOWN_LOCATION;
1390 : 43 : tok->u.value = NULL_TREE;
1391 : 43 : tok->keyword = RID_MAX;
1392 : :
1393 : 43 : do
1394 : 43 : tok++;
1395 : 43 : while (tok->purged_p);
1396 : 43 : lexer->next_token = tok;
1397 : 43 : }
1398 : :
1399 : : /* Permanently remove all tokens after TOK, up to, but not
1400 : : including, the token that will be returned next by
1401 : : cp_lexer_peek_token. */
1402 : :
1403 : : static void
1404 : 322494338 : cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
1405 : : {
1406 : 322494338 : cp_token *peek = lexer->next_token;
1407 : :
1408 : 322494338 : gcc_assert (tok < peek);
1409 : :
1410 : 1672874342 : for (tok++; tok != peek; tok++)
1411 : : {
1412 : 1350380004 : tok->purged_p = true;
1413 : 1350380004 : tok->location = UNKNOWN_LOCATION;
1414 : 1350380004 : tok->u.value = NULL_TREE;
1415 : 1350380004 : tok->keyword = RID_MAX;
1416 : : }
1417 : 322494338 : }
1418 : :
1419 : : /* Begin saving tokens. All tokens consumed after this point will be
1420 : : preserved. */
1421 : :
1422 : : static void
1423 : 13911328119 : cp_lexer_save_tokens (cp_lexer* lexer)
1424 : : {
1425 : : /* Provide debugging output. */
1426 : 13911328119 : if (cp_lexer_debugging_p (lexer))
1427 : : fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n");
1428 : :
1429 : 0 : lexer->saved_tokens.safe_push (lexer->next_token);
1430 : 0 : }
1431 : :
1432 : : /* Commit to the portion of the token stream most recently saved. */
1433 : :
1434 : : static void
1435 : 3922864042 : cp_lexer_commit_tokens (cp_lexer* lexer)
1436 : : {
1437 : : /* Provide debugging output. */
1438 : 3922864042 : if (cp_lexer_debugging_p (lexer))
1439 : : fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n");
1440 : :
1441 : 0 : lexer->saved_tokens.pop ();
1442 : 3757858414 : }
1443 : :
1444 : : /* Return all tokens saved since the last call to cp_lexer_save_tokens
1445 : : to the token stream. Stop saving tokens. */
1446 : :
1447 : : static void
1448 : 9988464035 : cp_lexer_rollback_tokens (cp_lexer* lexer)
1449 : : {
1450 : : /* Provide debugging output. */
1451 : 9988464035 : if (cp_lexer_debugging_p (lexer))
1452 : : fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");
1453 : :
1454 : 0 : lexer->next_token = lexer->saved_tokens.pop ();
1455 : 6 : }
1456 : :
1457 : : /* Determines what saved_token_sentinel does when going out of scope. */
1458 : :
1459 : : enum saved_token_sentinel_mode {
1460 : : STS_COMMIT,
1461 : : STS_ROLLBACK,
1462 : : STS_DONOTHING
1463 : : };
1464 : :
1465 : : /* RAII wrapper around the above functions, with sanity checking (the token
1466 : : stream should be the same at the point of instantiation as it is at the
1467 : : point of destruction).
1468 : :
1469 : : Creating a variable saves tokens. MODE determines what happens when the
1470 : : object is destroyed. STS_COMMIT commits tokens (default),
1471 : : STS_ROLLBACK rolls-back and STS_DONOTHING does nothing. Calling
1472 : : rollback() will immediately roll-back tokens and set MODE to
1473 : : STS_DONOTHING. */
1474 : :
1475 : : struct saved_token_sentinel
1476 : : {
1477 : : cp_lexer *lexer;
1478 : : unsigned len;
1479 : : saved_token_sentinel_mode mode;
1480 : 288499368 : saved_token_sentinel (cp_lexer *_lexer,
1481 : : saved_token_sentinel_mode _mode = STS_COMMIT)
1482 : 288499368 : : lexer (_lexer), mode (_mode)
1483 : : {
1484 : 288499368 : len = lexer->saved_tokens.length ();
1485 : 288499368 : cp_lexer_save_tokens (lexer);
1486 : 288499368 : }
1487 : 480626 : void rollback ()
1488 : : {
1489 : 480626 : cp_lexer_rollback_tokens (lexer);
1490 : 480626 : cp_lexer_set_source_position_from_token
1491 : 480626 : (cp_lexer_previous_token (lexer));
1492 : 480626 : mode = STS_DONOTHING;
1493 : 480626 : }
1494 : 288499344 : ~saved_token_sentinel ()
1495 : : {
1496 : 288499344 : if (mode == STS_COMMIT)
1497 : 288018700 : cp_lexer_commit_tokens (lexer);
1498 : 480644 : else if (mode == STS_ROLLBACK)
1499 : 237420 : rollback ();
1500 : :
1501 : 576998688 : gcc_assert (lexer->saved_tokens.length () == len);
1502 : 288499344 : }
1503 : : };
1504 : :
1505 : : /* Print a representation of the TOKEN on the STREAM. */
1506 : :
1507 : : static void
1508 : 0 : cp_lexer_print_token (FILE * stream, cp_token *token)
1509 : : {
1510 : : /* We don't use cpp_type2name here because the parser defines
1511 : : a few tokens of its own. */
1512 : 0 : static const char *const token_names[] = {
1513 : : /* cpplib-defined token types */
1514 : : #define OP(e, s) #e,
1515 : : #define TK(e, s) #e,
1516 : : TTYPE_TABLE
1517 : : #undef OP
1518 : : #undef TK
1519 : : /* C++ parser token types - see "Manifest constants", above. */
1520 : : "KEYWORD",
1521 : : "TEMPLATE_ID",
1522 : : "NESTED_NAME_SPECIFIER",
1523 : : };
1524 : :
1525 : : /* For some tokens, print the associated data. */
1526 : 0 : switch (token->type)
1527 : : {
1528 : 0 : case CPP_KEYWORD:
1529 : : /* Some keywords have a value that is not an IDENTIFIER_NODE.
1530 : : For example, `struct' is mapped to an INTEGER_CST. */
1531 : 0 : if (!identifier_p (token->u.value))
1532 : : break;
1533 : : /* fall through */
1534 : 0 : case CPP_NAME:
1535 : 0 : fputs (IDENTIFIER_POINTER (token->u.value), stream);
1536 : 0 : break;
1537 : :
1538 : 0 : case CPP_STRING:
1539 : 0 : case CPP_STRING16:
1540 : 0 : case CPP_STRING32:
1541 : 0 : case CPP_WSTRING:
1542 : 0 : case CPP_UTF8STRING:
1543 : 0 : fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value));
1544 : 0 : break;
1545 : :
1546 : 0 : case CPP_NUMBER:
1547 : 0 : print_generic_expr (stream, token->u.value);
1548 : 0 : break;
1549 : :
1550 : 0 : default:
1551 : : /* If we have a name for the token, print it out. Otherwise, we
1552 : : simply give the numeric code. */
1553 : 0 : if (token->type < ARRAY_SIZE(token_names))
1554 : 0 : fputs (token_names[token->type], stream);
1555 : : else
1556 : 0 : fprintf (stream, "[%d]", token->type);
1557 : : break;
1558 : : }
1559 : 0 : }
1560 : :
1561 : : DEBUG_FUNCTION void
1562 : 0 : debug (cp_token &ref)
1563 : : {
1564 : 0 : cp_lexer_print_token (stderr, &ref);
1565 : 0 : fprintf (stderr, "\n");
1566 : 0 : }
1567 : :
1568 : : DEBUG_FUNCTION void
1569 : 0 : debug (cp_token *ptr)
1570 : : {
1571 : 0 : if (ptr)
1572 : 0 : debug (*ptr);
1573 : : else
1574 : 0 : fprintf (stderr, "<nil>\n");
1575 : 0 : }
1576 : :
1577 : :
1578 : : /* Start emitting debugging information. */
1579 : :
1580 : : static void
1581 : 0 : cp_lexer_start_debugging (cp_lexer* lexer)
1582 : : {
1583 : 0 : if (!LEXER_DEBUGGING_ENABLED_P)
1584 : 0 : fatal_error (input_location,
1585 : : "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true");
1586 : :
1587 : : lexer->debugging_p = true;
1588 : : cp_lexer_debug_stream = stderr;
1589 : : }
1590 : :
1591 : : /* Stop emitting debugging information. */
1592 : :
1593 : : static void
1594 : 0 : cp_lexer_stop_debugging (cp_lexer* lexer)
1595 : : {
1596 : 0 : if (!LEXER_DEBUGGING_ENABLED_P)
1597 : 0 : fatal_error (input_location,
1598 : : "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true");
1599 : :
1600 : : lexer->debugging_p = false;
1601 : : cp_lexer_debug_stream = NULL;
1602 : : }
1603 : :
1604 : : /* Create a new cp_token_cache, representing a range of tokens. */
1605 : :
1606 : : static cp_token_cache *
1607 : 73196622 : cp_token_cache_new (cp_token *first, cp_token *last)
1608 : : {
1609 : 0 : cp_token_cache *cache = ggc_alloc<cp_token_cache> ();
1610 : 73196622 : cache->first = first;
1611 : 73196622 : cache->last = last;
1612 : 73196622 : return cache;
1613 : : }
1614 : :
1615 : : /* Diagnose if #pragma omp declare simd isn't followed immediately
1616 : : by function declaration or definition. */
1617 : :
1618 : : static inline void
1619 : 34587905 : cp_ensure_no_omp_declare_simd (cp_parser *parser)
1620 : : {
1621 : 34587905 : if (parser->omp_declare_simd && !parser->omp_declare_simd->error_seen)
1622 : : {
1623 : 81 : error ("%<#pragma omp declare %s%> not immediately followed by "
1624 : : "function declaration or definition",
1625 : 81 : parser->omp_declare_simd->variant_p ? "variant" : "simd");
1626 : 81 : parser->omp_declare_simd = NULL;
1627 : : }
1628 : 34587905 : }
1629 : :
1630 : : /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1631 : : and put that into "omp declare simd" attribute. */
1632 : :
1633 : : static inline void
1634 : 263858009 : cp_finalize_omp_declare_simd (cp_parser *parser, tree fndecl)
1635 : : {
1636 : 263858009 : if (UNLIKELY (parser->omp_declare_simd != NULL))
1637 : : {
1638 : 2072 : if (fndecl == error_mark_node)
1639 : : {
1640 : 0 : parser->omp_declare_simd = NULL;
1641 : 0 : return;
1642 : : }
1643 : 2072 : if (TREE_CODE (fndecl) != FUNCTION_DECL)
1644 : : {
1645 : 36 : cp_ensure_no_omp_declare_simd (parser);
1646 : 36 : return;
1647 : : }
1648 : : }
1649 : : }
1650 : :
1651 : : /* Similarly, but for use in declaration parsing functions
1652 : : which call cp_parser_handle_directive_omp_attributes. */
1653 : :
1654 : : static inline void
1655 : 550375379 : cp_finalize_omp_declare_simd (cp_parser *parser, cp_omp_declare_simd_data *data)
1656 : : {
1657 : 550375379 : if (parser->omp_declare_simd != data)
1658 : : return;
1659 : :
1660 : 183 : if (!parser->omp_declare_simd->error_seen
1661 : 183 : && !parser->omp_declare_simd->fndecl_seen)
1662 : 3 : error_at (parser->omp_declare_simd->loc,
1663 : : "%<declare %s%> directive not immediately followed by "
1664 : : "function declaration or definition",
1665 : 3 : parser->omp_declare_simd->variant_p ? "variant" : "simd");
1666 : 183 : parser->omp_declare_simd = NULL;
1667 : : }
1668 : :
1669 : : /* Diagnose if #pragma acc routine isn't followed immediately by function
1670 : : declaration or definition. */
1671 : :
1672 : : static inline void
1673 : 29480053 : cp_ensure_no_oacc_routine (cp_parser *parser)
1674 : : {
1675 : 29480053 : if (parser->oacc_routine && !parser->oacc_routine->error_seen)
1676 : : {
1677 : 66 : error_at (parser->oacc_routine->loc,
1678 : : "%<#pragma acc routine%> not immediately followed by "
1679 : : "function declaration or definition");
1680 : 66 : parser->oacc_routine = NULL;
1681 : : }
1682 : 29480053 : }
1683 : :
1684 : : /* Decl-specifiers. */
1685 : :
1686 : : /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1687 : :
1688 : : static void
1689 : 1089713227 : clear_decl_specs (cp_decl_specifier_seq *decl_specs)
1690 : : {
1691 : 1089713227 : memset (decl_specs, 0, sizeof (cp_decl_specifier_seq));
1692 : 90743 : }
1693 : :
1694 : : /* Declarators. */
1695 : :
1696 : : /* Nothing other than the parser should be creating declarators;
1697 : : declarators are a semi-syntactic representation of C++ entities.
1698 : : Other parts of the front end that need to create entities (like
1699 : : VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1700 : :
1701 : : static cp_declarator *make_call_declarator
1702 : : (cp_declarator *, tree, cp_cv_quals, cp_virt_specifiers, cp_ref_qualifier,
1703 : : tree, tree, tree, tree, tree, location_t);
1704 : : static cp_declarator *make_array_declarator
1705 : : (cp_declarator *, tree, tree);
1706 : : static cp_declarator *make_pointer_declarator
1707 : : (cp_cv_quals, cp_declarator *, tree);
1708 : : static cp_declarator *make_reference_declarator
1709 : : (cp_cv_quals, cp_declarator *, bool, tree);
1710 : : static cp_declarator *make_ptrmem_declarator
1711 : : (cp_cv_quals, tree, cp_declarator *, tree);
1712 : :
1713 : : /* An erroneous declarator. */
1714 : : static cp_declarator *cp_error_declarator;
1715 : :
1716 : : /* The obstack on which declarators and related data structures are
1717 : : allocated. */
1718 : : static struct obstack declarator_obstack;
1719 : :
1720 : : /* Alloc BYTES from the declarator memory pool. */
1721 : :
1722 : : static inline void *
1723 : 1109013822 : alloc_declarator (size_t bytes)
1724 : : {
1725 : 1109013822 : return obstack_alloc (&declarator_obstack, bytes);
1726 : : }
1727 : :
1728 : : /* Allocate a declarator of the indicated KIND. Clear fields that are
1729 : : common to all declarators. */
1730 : :
1731 : : static cp_declarator *
1732 : 844805080 : make_declarator (cp_declarator_kind kind)
1733 : : {
1734 : 844805080 : cp_declarator *declarator;
1735 : :
1736 : 844805080 : declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator));
1737 : 844805080 : declarator->kind = kind;
1738 : 844805080 : declarator->parenthesized = UNKNOWN_LOCATION;
1739 : 844805080 : declarator->attributes = NULL_TREE;
1740 : 844805080 : declarator->std_attributes = NULL_TREE;
1741 : 844805080 : declarator->declarator = NULL;
1742 : 844805080 : declarator->parameter_pack_p = false;
1743 : 844805080 : declarator->id_loc = UNKNOWN_LOCATION;
1744 : 844805080 : declarator->init_loc = UNKNOWN_LOCATION;
1745 : :
1746 : 844805080 : return declarator;
1747 : : }
1748 : :
1749 : : /* Make a declarator for a generalized identifier. If
1750 : : QUALIFYING_SCOPE is non-NULL, the identifier is
1751 : : QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1752 : : UNQUALIFIED_NAME. SFK indicates the kind of special function this
1753 : : is, if any. */
1754 : :
1755 : : static cp_declarator *
1756 : 505657119 : make_id_declarator (tree qualifying_scope, tree unqualified_name,
1757 : : special_function_kind sfk, location_t id_location)
1758 : : {
1759 : 505657119 : cp_declarator *declarator;
1760 : :
1761 : : /* It is valid to write:
1762 : :
1763 : : class C { void f(); };
1764 : : typedef C D;
1765 : : void D::f();
1766 : :
1767 : : The standard is not clear about whether `typedef const C D' is
1768 : : legal; as of 2002-09-15 the committee is considering that
1769 : : question. EDG 3.0 allows that syntax. Therefore, we do as
1770 : : well. */
1771 : 505657119 : if (qualifying_scope && TYPE_P (qualifying_scope))
1772 : 9128447 : qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);
1773 : :
1774 : 505657119 : gcc_assert (identifier_p (unqualified_name)
1775 : : || TREE_CODE (unqualified_name) == BIT_NOT_EXPR
1776 : : || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR);
1777 : :
1778 : 505657119 : declarator = make_declarator (cdk_id);
1779 : 505657119 : declarator->u.id.qualifying_scope = qualifying_scope;
1780 : 505657119 : declarator->u.id.unqualified_name = unqualified_name;
1781 : 505657119 : declarator->u.id.sfk = sfk;
1782 : 505657119 : declarator->id_loc = id_location;
1783 : :
1784 : 505657119 : return declarator;
1785 : : }
1786 : :
1787 : : /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1788 : : of modifiers such as const or volatile to apply to the pointer
1789 : : type, represented as identifiers. ATTRIBUTES represent the attributes that
1790 : : appertain to the pointer or reference. */
1791 : :
1792 : : cp_declarator *
1793 : 57853187 : make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
1794 : : tree attributes)
1795 : : {
1796 : 57853187 : cp_declarator *declarator;
1797 : :
1798 : 57853187 : declarator = make_declarator (cdk_pointer);
1799 : 57853187 : declarator->declarator = target;
1800 : 57853187 : declarator->u.pointer.qualifiers = cv_qualifiers;
1801 : 57853187 : declarator->u.pointer.class_type = NULL_TREE;
1802 : 57853187 : if (target)
1803 : : {
1804 : 49173068 : declarator->id_loc = target->id_loc;
1805 : 49173068 : declarator->parameter_pack_p = target->parameter_pack_p;
1806 : 49173068 : target->parameter_pack_p = false;
1807 : : }
1808 : : else
1809 : 8680119 : declarator->parameter_pack_p = false;
1810 : :
1811 : 57853187 : declarator->std_attributes = attributes;
1812 : :
1813 : 57853187 : return declarator;
1814 : : }
1815 : :
1816 : : /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1817 : : represent the attributes that appertain to the pointer or
1818 : : reference. */
1819 : :
1820 : : cp_declarator *
1821 : 111318994 : make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
1822 : : bool rvalue_ref, tree attributes)
1823 : : {
1824 : 111318994 : cp_declarator *declarator;
1825 : :
1826 : 111318994 : declarator = make_declarator (cdk_reference);
1827 : 111318994 : declarator->declarator = target;
1828 : 111318994 : declarator->u.reference.qualifiers = cv_qualifiers;
1829 : 111318994 : declarator->u.reference.rvalue_ref = rvalue_ref;
1830 : 111318994 : if (target)
1831 : : {
1832 : 87140483 : declarator->id_loc = target->id_loc;
1833 : 87140483 : declarator->parameter_pack_p = target->parameter_pack_p;
1834 : 87140483 : target->parameter_pack_p = false;
1835 : : }
1836 : : else
1837 : 24178511 : declarator->parameter_pack_p = false;
1838 : :
1839 : 111318994 : declarator->std_attributes = attributes;
1840 : :
1841 : 111318994 : return declarator;
1842 : : }
1843 : :
1844 : : /* Like make_pointer_declarator -- but for a pointer to a non-static
1845 : : member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1846 : : appertain to the pointer or reference. */
1847 : :
1848 : : cp_declarator *
1849 : 1136982 : make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
1850 : : cp_declarator *pointee,
1851 : : tree attributes)
1852 : : {
1853 : 1136982 : cp_declarator *declarator;
1854 : :
1855 : 1136982 : declarator = make_declarator (cdk_ptrmem);
1856 : 1136982 : declarator->declarator = pointee;
1857 : 1136982 : declarator->u.pointer.qualifiers = cv_qualifiers;
1858 : 1136982 : declarator->u.pointer.class_type = class_type;
1859 : :
1860 : 1136982 : if (pointee)
1861 : : {
1862 : 364784 : declarator->parameter_pack_p = pointee->parameter_pack_p;
1863 : 364784 : pointee->parameter_pack_p = false;
1864 : : }
1865 : : else
1866 : 772198 : declarator->parameter_pack_p = false;
1867 : :
1868 : 1136982 : declarator->std_attributes = attributes;
1869 : :
1870 : 1136982 : return declarator;
1871 : : }
1872 : :
1873 : : /* Make a declarator for the function given by TARGET, with the
1874 : : indicated PARMS. The CV_QUALIFIERS apply to the function, as in
1875 : : "const"-qualified member function. The EXCEPTION_SPECIFICATION
1876 : : indicates what exceptions can be thrown. STD_ATTRS contains
1877 : : attributes that appertain to the function type. */
1878 : :
1879 : : cp_declarator *
1880 : 165530495 : make_call_declarator (cp_declarator *target,
1881 : : tree parms,
1882 : : cp_cv_quals cv_qualifiers,
1883 : : cp_virt_specifiers virt_specifiers,
1884 : : cp_ref_qualifier ref_qualifier,
1885 : : tree tx_qualifier,
1886 : : tree exception_specification,
1887 : : tree late_return_type,
1888 : : tree requires_clause,
1889 : : tree std_attrs,
1890 : : location_t parens_loc)
1891 : : {
1892 : 165530495 : cp_declarator *declarator;
1893 : :
1894 : 165530495 : declarator = make_declarator (cdk_function);
1895 : 165530495 : declarator->declarator = target;
1896 : 165530495 : declarator->u.function.parameters = parms;
1897 : 165530495 : declarator->u.function.qualifiers = cv_qualifiers;
1898 : 165530495 : declarator->u.function.virt_specifiers = virt_specifiers;
1899 : 165530495 : declarator->u.function.ref_qualifier = ref_qualifier;
1900 : 165530495 : declarator->u.function.tx_qualifier = tx_qualifier;
1901 : 165530495 : declarator->u.function.exception_specification = exception_specification;
1902 : 165530495 : declarator->u.function.late_return_type = late_return_type;
1903 : 165530495 : declarator->u.function.requires_clause = requires_clause;
1904 : 165530495 : declarator->u.function.parens_loc = parens_loc;
1905 : 165530495 : if (target)
1906 : : {
1907 : 165050650 : declarator->id_loc = target->id_loc;
1908 : 165050650 : declarator->parameter_pack_p = target->parameter_pack_p;
1909 : 165050650 : target->parameter_pack_p = false;
1910 : : }
1911 : : else
1912 : 479845 : declarator->parameter_pack_p = false;
1913 : :
1914 : 165530495 : declarator->std_attributes = std_attrs;
1915 : :
1916 : 165530495 : return declarator;
1917 : : }
1918 : :
1919 : : /* Make a declarator for an array of BOUNDS elements, each of which is
1920 : : defined by ELEMENT. STD_ATTRS contains attributes that appertain to
1921 : : the array type. */
1922 : :
1923 : : cp_declarator *
1924 : 3148688 : make_array_declarator (cp_declarator *element, tree bounds, tree std_attrs)
1925 : : {
1926 : 3148688 : cp_declarator *declarator;
1927 : :
1928 : 3148688 : declarator = make_declarator (cdk_array);
1929 : 3148688 : declarator->declarator = element;
1930 : 3148688 : declarator->u.array.bounds = bounds;
1931 : 3148688 : if (element)
1932 : : {
1933 : 2685752 : declarator->id_loc = element->id_loc;
1934 : 2685752 : declarator->parameter_pack_p = element->parameter_pack_p;
1935 : 2685752 : element->parameter_pack_p = false;
1936 : : }
1937 : : else
1938 : 462936 : declarator->parameter_pack_p = false;
1939 : :
1940 : 3148688 : declarator->std_attributes = std_attrs;
1941 : :
1942 : 3148688 : return declarator;
1943 : : }
1944 : :
1945 : : /* Determine whether the declarator we've seen so far can be a
1946 : : parameter pack, when followed by an ellipsis. */
1947 : : static bool
1948 : 1363355 : declarator_can_be_parameter_pack (cp_declarator *declarator)
1949 : : {
1950 : 1363355 : if (declarator && declarator->parameter_pack_p)
1951 : : /* We already saw an ellipsis. */
1952 : : return false;
1953 : :
1954 : : /* Search for a declarator name, or any other declarator that goes
1955 : : after the point where the ellipsis could appear in a parameter
1956 : : pack. If we find any of these, then this declarator cannot be
1957 : : made into a parameter pack. */
1958 : : bool found = false;
1959 : 1502965 : while (declarator && !found)
1960 : : {
1961 : 139610 : switch ((int)declarator->kind)
1962 : : {
1963 : : case cdk_id:
1964 : : case cdk_array:
1965 : : case cdk_decomp:
1966 : : found = true;
1967 : : break;
1968 : :
1969 : : case cdk_error:
1970 : : return true;
1971 : :
1972 : 139607 : default:
1973 : 139607 : declarator = declarator->declarator;
1974 : 139607 : break;
1975 : : }
1976 : : }
1977 : :
1978 : : return !found;
1979 : : }
1980 : :
1981 : : cp_parameter_declarator *no_parameters;
1982 : :
1983 : : /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1984 : : DECLARATOR and DEFAULT_ARGUMENT. */
1985 : :
1986 : : cp_parameter_declarator *
1987 : 264208742 : make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
1988 : : cp_declarator *declarator,
1989 : : tree default_argument,
1990 : : location_t loc,
1991 : : bool template_parameter_pack_p = false)
1992 : : {
1993 : 264208742 : cp_parameter_declarator *parameter;
1994 : :
1995 : 264208742 : parameter = ((cp_parameter_declarator *)
1996 : 264208742 : alloc_declarator (sizeof (cp_parameter_declarator)));
1997 : 264208742 : parameter->next = NULL;
1998 : 264208742 : if (decl_specifiers)
1999 : 264117999 : parameter->decl_specifiers = *decl_specifiers;
2000 : : else
2001 : 90743 : clear_decl_specs (¶meter->decl_specifiers);
2002 : 264208742 : parameter->declarator = declarator;
2003 : 264208742 : parameter->default_argument = default_argument;
2004 : 264208742 : parameter->template_parameter_pack_p = template_parameter_pack_p;
2005 : 264208742 : parameter->loc = loc;
2006 : :
2007 : 264208742 : return parameter;
2008 : : }
2009 : :
2010 : : /* Returns true iff DECLARATOR is a declaration for a function. */
2011 : :
2012 : : static bool
2013 : 407910769 : function_declarator_p (const cp_declarator *declarator)
2014 : : {
2015 : 458106592 : while (declarator)
2016 : : {
2017 : 458106592 : if (declarator->kind == cdk_function
2018 : 181370730 : && declarator->declarator->kind == cdk_id)
2019 : : return true;
2020 : 276962154 : if (declarator->kind == cdk_id
2021 : 50195823 : || declarator->kind == cdk_decomp
2022 : 50195823 : || declarator->kind == cdk_error)
2023 : : return false;
2024 : 50195823 : declarator = declarator->declarator;
2025 : : }
2026 : : return false;
2027 : : }
2028 : :
2029 : : /* The parser. */
2030 : :
2031 : : /* Overview
2032 : : --------
2033 : :
2034 : : A cp_parser parses the token stream as specified by the C++
2035 : : grammar. Its job is purely parsing, not semantic analysis. For
2036 : : example, the parser breaks the token stream into declarators,
2037 : : expressions, statements, and other similar syntactic constructs.
2038 : : It does not check that the types of the expressions on either side
2039 : : of an assignment-statement are compatible, or that a function is
2040 : : not declared with a parameter of type `void'.
2041 : :
2042 : : The parser invokes routines elsewhere in the compiler to perform
2043 : : semantic analysis and to build up the abstract syntax tree for the
2044 : : code processed.
2045 : :
2046 : : The parser (and the template instantiation code, which is, in a
2047 : : way, a close relative of parsing) are the only parts of the
2048 : : compiler that should be calling push_scope and pop_scope, or
2049 : : related functions. The parser (and template instantiation code)
2050 : : keeps track of what scope is presently active; everything else
2051 : : should simply honor that. (The code that generates static
2052 : : initializers may also need to set the scope, in order to check
2053 : : access control correctly when emitting the initializers.)
2054 : :
2055 : : Methodology
2056 : : -----------
2057 : :
2058 : : The parser is of the standard recursive-descent variety. Upcoming
2059 : : tokens in the token stream are examined in order to determine which
2060 : : production to use when parsing a non-terminal. Some C++ constructs
2061 : : require arbitrary look ahead to disambiguate. For example, it is
2062 : : impossible, in the general case, to tell whether a statement is an
2063 : : expression or declaration without scanning the entire statement.
2064 : : Therefore, the parser is capable of "parsing tentatively." When the
2065 : : parser is not sure what construct comes next, it enters this mode.
2066 : : Then, while we attempt to parse the construct, the parser queues up
2067 : : error messages, rather than issuing them immediately, and saves the
2068 : : tokens it consumes. If the construct is parsed successfully, the
2069 : : parser "commits", i.e., it issues any queued error messages and
2070 : : the tokens that were being preserved are permanently discarded.
2071 : : If, however, the construct is not parsed successfully, the parser
2072 : : rolls back its state completely so that it can resume parsing using
2073 : : a different alternative.
2074 : :
2075 : : Future Improvements
2076 : : -------------------
2077 : :
2078 : : The performance of the parser could probably be improved substantially.
2079 : : We could often eliminate the need to parse tentatively by looking ahead
2080 : : a little bit. In some places, this approach might not entirely eliminate
2081 : : the need to parse tentatively, but it might still speed up the average
2082 : : case. */
2083 : :
2084 : : /* Flags that are passed to some parsing functions. These values can
2085 : : be bitwise-ored together. */
2086 : :
2087 : : enum
2088 : : {
2089 : : /* No flags. */
2090 : : CP_PARSER_FLAGS_NONE = 0x0,
2091 : : /* The construct is optional. If it is not present, then no error
2092 : : should be issued. */
2093 : : CP_PARSER_FLAGS_OPTIONAL = 0x1,
2094 : : /* When parsing a type-specifier, treat user-defined type-names
2095 : : as non-type identifiers. */
2096 : : CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2,
2097 : : /* When parsing a type-specifier, do not try to parse a class-specifier
2098 : : or enum-specifier. */
2099 : : CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS = 0x4,
2100 : : /* When parsing a decl-specifier-seq, only allow type-specifier or
2101 : : constexpr. */
2102 : : CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR = 0x8,
2103 : : /* When parsing a decl-specifier-seq, only allow mutable, constexpr or
2104 : : for C++20 consteval or for C++23 static. */
2105 : : CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR = 0x10,
2106 : : /* When parsing a decl-specifier-seq, allow missing typename. */
2107 : : CP_PARSER_FLAGS_TYPENAME_OPTIONAL = 0x20,
2108 : : /* When parsing of the noexcept-specifier should be delayed. */
2109 : : CP_PARSER_FLAGS_DELAY_NOEXCEPT = 0x40,
2110 : : /* When parsing a consteval declarator. */
2111 : : CP_PARSER_FLAGS_CONSTEVAL = 0x80,
2112 : : /* When parsing a parameter declaration. */
2113 : : CP_PARSER_FLAGS_PARAMETER = 0x100
2114 : : };
2115 : :
2116 : : /* This type is used for parameters and variables which hold
2117 : : combinations of the above flags. */
2118 : : typedef int cp_parser_flags;
2119 : :
2120 : : /* The different kinds of declarators we want to parse. */
2121 : :
2122 : : enum cp_parser_declarator_kind
2123 : : {
2124 : : /* We want an abstract declarator. */
2125 : : CP_PARSER_DECLARATOR_ABSTRACT,
2126 : : /* We want a named declarator. */
2127 : : CP_PARSER_DECLARATOR_NAMED,
2128 : : /* We don't mind, but the name must be an unqualified-id. */
2129 : : CP_PARSER_DECLARATOR_EITHER
2130 : : };
2131 : :
2132 : : /* The precedence values used to parse binary expressions. The minimum value
2133 : : of PREC must be 1, because zero is reserved to quickly discriminate
2134 : : binary operators from other tokens. */
2135 : :
2136 : : enum cp_parser_prec
2137 : : {
2138 : : PREC_NOT_OPERATOR,
2139 : : PREC_LOGICAL_OR_EXPRESSION,
2140 : : PREC_LOGICAL_AND_EXPRESSION,
2141 : : PREC_INCLUSIVE_OR_EXPRESSION,
2142 : : PREC_EXCLUSIVE_OR_EXPRESSION,
2143 : : PREC_AND_EXPRESSION,
2144 : : PREC_EQUALITY_EXPRESSION,
2145 : : PREC_RELATIONAL_EXPRESSION,
2146 : : PREC_SPACESHIP_EXPRESSION,
2147 : : PREC_SHIFT_EXPRESSION,
2148 : : PREC_ADDITIVE_EXPRESSION,
2149 : : PREC_MULTIPLICATIVE_EXPRESSION,
2150 : : PREC_PM_EXPRESSION,
2151 : : NUM_PREC_VALUES = PREC_PM_EXPRESSION
2152 : : };
2153 : :
2154 : : /* A mapping from a token type to a corresponding tree node type, with a
2155 : : precedence value. */
2156 : :
2157 : : struct cp_parser_binary_operations_map_node
2158 : : {
2159 : : /* The token type. */
2160 : : enum cpp_ttype token_type;
2161 : : /* The corresponding tree code. */
2162 : : enum tree_code tree_type;
2163 : : /* The precedence of this operator. */
2164 : : enum cp_parser_prec prec;
2165 : : };
2166 : :
2167 : 9049501488 : struct cp_parser_expression_stack_entry
2168 : : {
2169 : : /* Left hand side of the binary operation we are currently
2170 : : parsing. */
2171 : : cp_expr lhs;
2172 : : /* Original tree code for left hand side, if it was a binary
2173 : : expression itself (used for -Wparentheses). */
2174 : : enum tree_code lhs_type;
2175 : : /* Tree code for the binary operation we are parsing. */
2176 : : enum tree_code tree_type;
2177 : : /* Precedence of the binary operation we are parsing. */
2178 : : enum cp_parser_prec prec;
2179 : : /* Location of the binary operation we are parsing. */
2180 : : location_t loc;
2181 : : /* Flags from the operator token. */
2182 : : unsigned char flags;
2183 : : };
2184 : :
2185 : : /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
2186 : : entries because precedence levels on the stack are monotonically
2187 : : increasing. */
2188 : : typedef struct cp_parser_expression_stack_entry
2189 : : cp_parser_expression_stack[NUM_PREC_VALUES];
2190 : :
2191 : : /* Used for parsing OMP for loops.
2192 : :
2193 : : Some notes on flags used for context:
2194 : : parser->omp_for_parse_state is non-null anywhere inside the OMP FOR
2195 : : construct, except for the final-loop-body.
2196 : : The want_nested_loop flag is true if inside a {} sequence where
2197 : : a loop-nest (or another {} sequence containing a loop-nest) is expected,
2198 : : but has not yet been seen. It's false when parsing intervening code
2199 : : statements or their substatements that cannot contain a loop-nest.
2200 : : The in_intervening_code flag is true when parsing any intervening code,
2201 : : including substatements, and whether or not want_nested_loop is true.
2202 : :
2203 : : And, about error handling:
2204 : : The saw_intervening_code flag is set if the loop is not perfectly
2205 : : nested, even in the usual case where this is not an error.
2206 : : perfect_nesting_fail is set if an error has been diagnosed because an
2207 : : imperfectly-nested loop was found where a perfectly-nested one is
2208 : : required (we diagnose this only once).
2209 : : fail is set if any kind of structural error in the loop nest
2210 : : has been found and diagnosed.
2211 : : */
2212 : : struct omp_for_parse_data {
2213 : : enum tree_code code;
2214 : : tree declv, condv, incrv, initv;
2215 : : tree pre_body;
2216 : : tree orig_declv;
2217 : : auto_vec<tree, 4> orig_inits;
2218 : : int count; /* Expected nesting depth. */
2219 : : int depth; /* Current nesting depth. */
2220 : : location_t for_loc;
2221 : : releasing_vec init_blockv;
2222 : : releasing_vec body_blockv;
2223 : : releasing_vec init_placeholderv;
2224 : : releasing_vec body_placeholderv;
2225 : : bool ordered : 1;
2226 : : bool inscan : 1;
2227 : : bool want_nested_loop : 1;
2228 : : bool in_intervening_code : 1;
2229 : : bool saw_intervening_code : 1;
2230 : : bool perfect_nesting_fail : 1;
2231 : : bool fail : 1;
2232 : : tree clauses;
2233 : : tree *cclauses;
2234 : : tree ordered_cl;
2235 : : };
2236 : :
2237 : : /* Prototypes. */
2238 : :
2239 : : /* Constructors and destructors. */
2240 : :
2241 : : static cp_parser_context *cp_parser_context_new
2242 : : (cp_parser_context *);
2243 : :
2244 : : /* Class variables. */
2245 : :
2246 : : static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;
2247 : :
2248 : : /* The operator-precedence table used by cp_parser_binary_expression.
2249 : : Transformed into an associative array (binops_by_token) by
2250 : : cp_parser_new. */
2251 : :
2252 : : static const cp_parser_binary_operations_map_node binops[] = {
2253 : : { CPP_DEREF_STAR, MEMBER_REF, PREC_PM_EXPRESSION },
2254 : : { CPP_DOT_STAR, DOTSTAR_EXPR, PREC_PM_EXPRESSION },
2255 : :
2256 : : { CPP_MULT, MULT_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
2257 : : { CPP_DIV, TRUNC_DIV_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
2258 : : { CPP_MOD, TRUNC_MOD_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
2259 : :
2260 : : { CPP_PLUS, PLUS_EXPR, PREC_ADDITIVE_EXPRESSION },
2261 : : { CPP_MINUS, MINUS_EXPR, PREC_ADDITIVE_EXPRESSION },
2262 : :
2263 : : { CPP_LSHIFT, LSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
2264 : : { CPP_RSHIFT, RSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
2265 : :
2266 : : { CPP_SPACESHIP, SPACESHIP_EXPR, PREC_SPACESHIP_EXPRESSION },
2267 : :
2268 : : { CPP_LESS, LT_EXPR, PREC_RELATIONAL_EXPRESSION },
2269 : : { CPP_GREATER, GT_EXPR, PREC_RELATIONAL_EXPRESSION },
2270 : : { CPP_LESS_EQ, LE_EXPR, PREC_RELATIONAL_EXPRESSION },
2271 : : { CPP_GREATER_EQ, GE_EXPR, PREC_RELATIONAL_EXPRESSION },
2272 : :
2273 : : { CPP_EQ_EQ, EQ_EXPR, PREC_EQUALITY_EXPRESSION },
2274 : : { CPP_NOT_EQ, NE_EXPR, PREC_EQUALITY_EXPRESSION },
2275 : :
2276 : : { CPP_AND, BIT_AND_EXPR, PREC_AND_EXPRESSION },
2277 : :
2278 : : { CPP_XOR, BIT_XOR_EXPR, PREC_EXCLUSIVE_OR_EXPRESSION },
2279 : :
2280 : : { CPP_OR, BIT_IOR_EXPR, PREC_INCLUSIVE_OR_EXPRESSION },
2281 : :
2282 : : { CPP_AND_AND, TRUTH_ANDIF_EXPR, PREC_LOGICAL_AND_EXPRESSION },
2283 : :
2284 : : { CPP_OR_OR, TRUTH_ORIF_EXPR, PREC_LOGICAL_OR_EXPRESSION }
2285 : : };
2286 : :
2287 : : /* The same as binops, but initialized by cp_parser_new so that
2288 : : binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
2289 : : for speed. */
2290 : : static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES];
2291 : :
2292 : : /* Constructors and destructors. */
2293 : :
2294 : : /* Construct a new context. The context below this one on the stack
2295 : : is given by NEXT. */
2296 : :
2297 : : static cp_parser_context *
2298 : 13512139861 : cp_parser_context_new (cp_parser_context* next)
2299 : : {
2300 : 13512139861 : cp_parser_context *context;
2301 : :
2302 : : /* Allocate the storage. */
2303 : 13512139861 : if (cp_parser_context_free_list != NULL)
2304 : : {
2305 : : /* Pull the first entry from the free list. */
2306 : 13508946185 : context = cp_parser_context_free_list;
2307 : 13508946185 : cp_parser_context_free_list = context->next;
2308 : 13508946185 : memset (context, 0, sizeof (*context));
2309 : : }
2310 : : else
2311 : 3193676 : context = ggc_cleared_alloc<cp_parser_context> ();
2312 : :
2313 : : /* No errors have occurred yet in this context. */
2314 : 13512139861 : context->status = CP_PARSER_STATUS_KIND_NO_ERROR;
2315 : : /* If this is not the bottommost context, copy information that we
2316 : : need from the previous context. */
2317 : 13512139861 : if (next)
2318 : : {
2319 : : /* If, in the NEXT context, we are parsing an `x->' or `x.'
2320 : : expression, then we are parsing one in this context, too. */
2321 : 13512047857 : context->object_type = next->object_type;
2322 : : /* Thread the stack. */
2323 : 13512047857 : context->next = next;
2324 : : }
2325 : :
2326 : 13512139861 : return context;
2327 : : }
2328 : :
2329 : : /* Managing the unparsed function queues. */
2330 : :
2331 : : #define unparsed_funs_with_default_args \
2332 : : parser->unparsed_queues->last ().funs_with_default_args
2333 : : #define unparsed_funs_with_definitions \
2334 : : parser->unparsed_queues->last ().funs_with_definitions
2335 : : #define unparsed_nsdmis \
2336 : : parser->unparsed_queues->last ().nsdmis
2337 : : #define unparsed_noexcepts \
2338 : : parser->unparsed_queues->last ().noexcepts
2339 : : #define unparsed_contracts \
2340 : : parser->unparsed_queues->last ().contracts
2341 : :
2342 : : static void
2343 : 88996186 : push_unparsed_function_queues (cp_parser *parser)
2344 : : {
2345 : 88996186 : cp_unparsed_functions_entry e
2346 : 88996186 : = { NULL, make_tree_vector (), NULL, NULL, NULL };
2347 : 88996186 : vec_safe_push (parser->unparsed_queues, e);
2348 : 88996186 : }
2349 : :
2350 : : static void
2351 : 88904182 : pop_unparsed_function_queues (cp_parser *parser)
2352 : : {
2353 : 88904182 : release_tree_vector (unparsed_funs_with_definitions);
2354 : 88904182 : parser->unparsed_queues->pop ();
2355 : 88904182 : }
2356 : :
2357 : : /* Prototypes. */
2358 : :
2359 : : /* Routines to parse various constructs.
2360 : :
2361 : : Those that return `tree' will return the error_mark_node (rather
2362 : : than NULL_TREE) if a parse error occurs, unless otherwise noted.
2363 : : Sometimes, they will return an ordinary node if error-recovery was
2364 : : attempted, even though a parse error occurred. So, to check
2365 : : whether or not a parse error occurred, you should always use
2366 : : cp_parser_error_occurred. If the construct is optional (indicated
2367 : : either by an `_opt' in the name of the function that does the
2368 : : parsing or via a FLAGS parameter), then NULL_TREE is returned if
2369 : : the construct is not present. */
2370 : :
2371 : : /* Lexical conventions [gram.lex] */
2372 : :
2373 : : static tree finish_userdef_string_literal
2374 : : (tree);
2375 : :
2376 : : /* Basic concepts [gram.basic] */
2377 : :
2378 : : static void cp_parser_translation_unit (cp_parser *);
2379 : :
2380 : : /* Expressions [gram.expr] */
2381 : :
2382 : : static cp_expr cp_parser_primary_expression
2383 : : (cp_parser *, bool, bool, bool, cp_id_kind *);
2384 : : static cp_expr cp_parser_id_expression
2385 : : (cp_parser *, bool, bool, bool *, bool, bool);
2386 : : static cp_expr cp_parser_unqualified_id
2387 : : (cp_parser *, bool, bool, bool, bool);
2388 : : static tree cp_parser_nested_name_specifier_opt
2389 : : (cp_parser *, bool, bool, bool, bool, bool = false);
2390 : : static tree cp_parser_nested_name_specifier
2391 : : (cp_parser *, bool, bool, bool, bool);
2392 : : static tree cp_parser_qualifying_entity
2393 : : (cp_parser *, bool, bool, bool, bool, bool);
2394 : : static cp_expr cp_parser_postfix_expression
2395 : : (cp_parser *, bool, bool, bool, bool, cp_id_kind *);
2396 : : static tree cp_parser_postfix_open_square_expression
2397 : : (cp_parser *, tree, bool, bool);
2398 : : static tree cp_parser_postfix_dot_deref_expression
2399 : : (cp_parser *, enum cpp_ttype, cp_expr, bool, cp_id_kind *, location_t);
2400 : : static vec<tree, va_gc> *cp_parser_parenthesized_expression_list
2401 : : (cp_parser *, int, bool, bool, bool *, location_t * = NULL,
2402 : : bool = false);
2403 : : /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
2404 : : enum { non_attr = 0, normal_attr = 1, id_attr = 2, assume_attr = 3,
2405 : : uneval_string_attr = 4 };
2406 : : static void cp_parser_pseudo_destructor_name
2407 : : (cp_parser *, tree, tree *, tree *);
2408 : : static cp_expr cp_parser_unary_expression
2409 : : (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false, bool = false);
2410 : : static enum tree_code cp_parser_unary_operator
2411 : : (cp_token *);
2412 : : static tree cp_parser_has_attribute_expression
2413 : : (cp_parser *);
2414 : : static tree cp_parser_new_expression
2415 : : (cp_parser *);
2416 : : static vec<tree, va_gc> *cp_parser_new_placement
2417 : : (cp_parser *);
2418 : : static tree cp_parser_new_type_id
2419 : : (cp_parser *, tree *);
2420 : : static cp_declarator *cp_parser_new_declarator_opt
2421 : : (cp_parser *);
2422 : : static cp_declarator *cp_parser_direct_new_declarator
2423 : : (cp_parser *);
2424 : : static vec<tree, va_gc> *cp_parser_new_initializer
2425 : : (cp_parser *);
2426 : : static tree cp_parser_delete_expression
2427 : : (cp_parser *);
2428 : : static cp_expr cp_parser_cast_expression
2429 : : (cp_parser *, bool, bool, bool, cp_id_kind *);
2430 : : static cp_expr cp_parser_binary_expression
2431 : : (cp_parser *, bool, bool, enum cp_parser_prec, cp_id_kind *);
2432 : : static tree cp_parser_question_colon_clause
2433 : : (cp_parser *, cp_expr);
2434 : : static cp_expr cp_parser_conditional_expression (cp_parser *);
2435 : : static cp_expr cp_parser_assignment_expression
2436 : : (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false);
2437 : : static enum tree_code cp_parser_assignment_operator_opt
2438 : : (cp_parser *);
2439 : : static cp_expr cp_parser_expression
2440 : : (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false, bool = false);
2441 : : static cp_expr cp_parser_constant_expression
2442 : : (cp_parser *, int = 0, bool * = NULL, bool = false);
2443 : : static cp_expr cp_parser_builtin_offsetof
2444 : : (cp_parser *);
2445 : : static cp_expr cp_parser_lambda_expression
2446 : : (cp_parser *);
2447 : : static void cp_parser_lambda_introducer
2448 : : (cp_parser *, tree);
2449 : : static bool cp_parser_lambda_declarator_opt
2450 : : (cp_parser *, tree);
2451 : : static void cp_parser_lambda_body
2452 : : (cp_parser *, tree);
2453 : :
2454 : : /* Statements [gram.stmt.stmt] */
2455 : :
2456 : : static void cp_parser_statement
2457 : : (cp_parser *, tree, bool, bool *, vec<tree> * = NULL, location_t * = NULL);
2458 : : static void cp_parser_label_for_labeled_statement
2459 : : (cp_parser *, tree);
2460 : : static tree cp_parser_expression_statement
2461 : : (cp_parser *, tree);
2462 : : static tree cp_parser_compound_statement
2463 : : (cp_parser *, tree, int, bool);
2464 : : static void cp_parser_statement_seq_opt
2465 : : (cp_parser *, tree);
2466 : : static tree cp_parser_selection_statement
2467 : : (cp_parser *, bool *, vec<tree> *);
2468 : : static tree cp_parser_condition
2469 : : (cp_parser *, enum rid);
2470 : : static tree cp_parser_iteration_statement
2471 : : (cp_parser *, bool *, bool, tree, bool);
2472 : : static bool cp_parser_init_statement
2473 : : (cp_parser *, tree *decl);
2474 : : static tree cp_parser_for
2475 : : (cp_parser *, bool, tree, bool);
2476 : : static tree cp_parser_c_for
2477 : : (cp_parser *, tree, tree, bool, tree, bool);
2478 : : static tree cp_parser_range_for
2479 : : (cp_parser *, tree, tree, tree, bool, tree, bool, bool);
2480 : : static void do_range_for_auto_deduction
2481 : : (tree, tree, cp_decomp *);
2482 : : static tree cp_parser_perform_range_for_lookup
2483 : : (tree, tree *, tree *);
2484 : : static tree cp_parser_range_for_member_function
2485 : : (tree, tree);
2486 : : static tree cp_parser_jump_statement
2487 : : (cp_parser *, tree &);
2488 : : static void cp_parser_declaration_statement
2489 : : (cp_parser *);
2490 : :
2491 : : static tree cp_parser_implicitly_scoped_statement
2492 : : (cp_parser *, bool *, const token_indent_info &, vec<tree> * = NULL);
2493 : : static void cp_parser_already_scoped_statement
2494 : : (cp_parser *, bool *, const token_indent_info &);
2495 : :
2496 : : /* State of module-declaration parsing. */
2497 : : enum module_parse
2498 : : {
2499 : : MP_NOT_MODULE, /* Not a module. */
2500 : :
2501 : : _MP_UNUSED,
2502 : :
2503 : : MP_FIRST, /* First declaration of TU. */
2504 : : MP_GLOBAL, /* Global Module Fragment. */
2505 : :
2506 : : MP_PURVIEW_IMPORTS, /* Imports of a module. */
2507 : : MP_PURVIEW, /* Purview of a named module. */
2508 : :
2509 : : MP_PRIVATE_IMPORTS, /* Imports of a Private Module Fragment. */
2510 : : MP_PRIVATE, /* Private Module Fragment. */
2511 : : };
2512 : :
2513 : : static module_parse cp_parser_module_declaration
2514 : : (cp_parser *parser, module_parse, bool exporting);
2515 : : static void cp_parser_import_declaration
2516 : : (cp_parser *parser, module_parse, bool exporting);
2517 : :
2518 : : /* Declarations [gram.dcl.dcl] */
2519 : :
2520 : : static void cp_parser_declaration_seq_opt
2521 : : (cp_parser *);
2522 : : static void cp_parser_declaration
2523 : : (cp_parser *, tree);
2524 : : static void cp_parser_toplevel_declaration
2525 : : (cp_parser *);
2526 : : static void cp_parser_block_declaration
2527 : : (cp_parser *, bool);
2528 : : static void cp_parser_simple_declaration
2529 : : (cp_parser *, bool, tree *);
2530 : : static void cp_parser_decl_specifier_seq
2531 : : (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *);
2532 : : static tree cp_parser_storage_class_specifier_opt
2533 : : (cp_parser *);
2534 : : static tree cp_parser_function_specifier_opt
2535 : : (cp_parser *, cp_decl_specifier_seq *);
2536 : : static tree cp_parser_type_specifier
2537 : : (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
2538 : : int *, bool *);
2539 : : static tree cp_parser_simple_type_specifier
2540 : : (cp_parser *, cp_decl_specifier_seq *, cp_parser_flags);
2541 : : static tree cp_parser_placeholder_type_specifier
2542 : : (cp_parser *, location_t, tree, bool);
2543 : : static tree cp_parser_type_name
2544 : : (cp_parser *, bool);
2545 : : static tree cp_parser_nonclass_name
2546 : : (cp_parser* parser);
2547 : : static tree cp_parser_elaborated_type_specifier
2548 : : (cp_parser *, bool, bool);
2549 : : static tree cp_parser_enum_specifier
2550 : : (cp_parser *);
2551 : : static void cp_parser_enumerator_list
2552 : : (cp_parser *, tree);
2553 : : static void cp_parser_enumerator_definition
2554 : : (cp_parser *, tree);
2555 : : static tree cp_parser_namespace_name
2556 : : (cp_parser *);
2557 : : static void cp_parser_namespace_definition
2558 : : (cp_parser *);
2559 : : static void cp_parser_namespace_body
2560 : : (cp_parser *);
2561 : : static tree cp_parser_qualified_namespace_specifier
2562 : : (cp_parser *);
2563 : : static void cp_parser_namespace_alias_definition
2564 : : (cp_parser *);
2565 : : static bool cp_parser_using_declaration
2566 : : (cp_parser *, bool);
2567 : : static void cp_parser_using_directive
2568 : : (cp_parser *);
2569 : : static void cp_parser_using_enum
2570 : : (cp_parser *);
2571 : : static tree cp_parser_alias_declaration
2572 : : (cp_parser *);
2573 : : static void cp_parser_asm_definition
2574 : : (cp_parser *);
2575 : : static void cp_parser_linkage_specification
2576 : : (cp_parser *, tree);
2577 : : static void cp_parser_static_assert
2578 : : (cp_parser *, bool);
2579 : : static tree cp_parser_decltype
2580 : : (cp_parser *);
2581 : : static tree cp_parser_decomposition_declaration
2582 : : (cp_parser *, cp_decl_specifier_seq *, tree *, location_t *, enum rid);
2583 : :
2584 : : /* Declarators [gram.dcl.decl] */
2585 : :
2586 : : static tree cp_parser_init_declarator
2587 : : (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *,
2588 : : vec<deferred_access_check, va_gc> *, bool, bool, int, bool *, tree *,
2589 : : location_t *, tree *);
2590 : : static cp_declarator *cp_parser_declarator
2591 : : (cp_parser *, cp_parser_declarator_kind, cp_parser_flags, int *, bool *,
2592 : : bool, bool, bool);
2593 : : static cp_declarator *cp_parser_direct_declarator
2594 : : (cp_parser *, cp_parser_declarator_kind, cp_parser_flags, int *, bool, bool,
2595 : : bool);
2596 : : static enum tree_code cp_parser_ptr_operator
2597 : : (cp_parser *, tree *, cp_cv_quals *, tree *);
2598 : : static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2599 : : (cp_parser *);
2600 : : static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2601 : : (cp_parser *);
2602 : : static cp_ref_qualifier cp_parser_ref_qualifier_opt
2603 : : (cp_parser *);
2604 : : static tree cp_parser_tx_qualifier_opt
2605 : : (cp_parser *);
2606 : : static tree cp_parser_late_return_type_opt
2607 : : (cp_parser *, cp_declarator *, tree &, tree);
2608 : : static tree cp_parser_declarator_id
2609 : : (cp_parser *, bool);
2610 : : static tree cp_parser_type_id
2611 : : (cp_parser *, cp_parser_flags = CP_PARSER_FLAGS_NONE, location_t * = NULL);
2612 : : static tree cp_parser_template_type_arg
2613 : : (cp_parser *);
2614 : : static tree cp_parser_trailing_type_id (cp_parser *);
2615 : : static tree cp_parser_type_id_1
2616 : : (cp_parser *, cp_parser_flags, bool, bool, location_t *);
2617 : : static void cp_parser_type_specifier_seq
2618 : : (cp_parser *, cp_parser_flags, bool, bool, cp_decl_specifier_seq *);
2619 : : static tree cp_parser_parameter_declaration_clause
2620 : : (cp_parser *, cp_parser_flags, bool);
2621 : : static tree cp_parser_parameter_declaration_list
2622 : : (cp_parser *, cp_parser_flags, auto_vec<tree> *);
2623 : : static cp_parameter_declarator *cp_parser_parameter_declaration
2624 : : (cp_parser *, cp_parser_flags, bool, bool *);
2625 : : static tree cp_parser_default_argument
2626 : : (cp_parser *, bool);
2627 : : static void cp_parser_function_body
2628 : : (cp_parser *, bool);
2629 : : static tree cp_parser_initializer
2630 : : (cp_parser *, bool * = nullptr, bool * = nullptr, bool = false);
2631 : : static cp_expr cp_parser_initializer_clause
2632 : : (cp_parser *, bool * = nullptr);
2633 : : static cp_expr cp_parser_braced_list
2634 : : (cp_parser*, bool * = nullptr);
2635 : : static vec<constructor_elt, va_gc> *cp_parser_initializer_list
2636 : : (cp_parser *, bool *, bool *);
2637 : :
2638 : : static void cp_parser_ctor_initializer_opt_and_function_body
2639 : : (cp_parser *, bool);
2640 : :
2641 : : static tree cp_parser_late_parsing_omp_declare_simd
2642 : : (cp_parser *, tree, tree);
2643 : :
2644 : : static tree cp_parser_late_parsing_oacc_routine
2645 : : (cp_parser *, tree);
2646 : :
2647 : : static tree synthesize_implicit_template_parm
2648 : : (cp_parser *, tree);
2649 : : static tree finish_fully_implicit_template
2650 : : (cp_parser *, tree);
2651 : : static void abort_fully_implicit_template
2652 : : (cp_parser *);
2653 : :
2654 : : /* Classes [gram.class] */
2655 : :
2656 : : static tree cp_parser_class_name
2657 : : (cp_parser *, bool, bool, enum tag_types, bool, bool, bool, bool = false);
2658 : : static tree cp_parser_class_specifier
2659 : : (cp_parser *);
2660 : : static tree cp_parser_class_head
2661 : : (cp_parser *, bool *);
2662 : : static enum tag_types cp_parser_class_key
2663 : : (cp_parser *);
2664 : : static void cp_parser_type_parameter_key
2665 : : (cp_parser* parser);
2666 : : static void cp_parser_member_specification_opt
2667 : : (cp_parser *);
2668 : : static void cp_parser_member_declaration
2669 : : (cp_parser *);
2670 : : static tree cp_parser_pure_specifier
2671 : : (cp_parser *);
2672 : : static tree cp_parser_constant_initializer
2673 : : (cp_parser *);
2674 : :
2675 : : /* Derived classes [gram.class.derived] */
2676 : :
2677 : : static tree cp_parser_base_clause
2678 : : (cp_parser *);
2679 : : static tree cp_parser_base_specifier
2680 : : (cp_parser *);
2681 : :
2682 : : /* Special member functions [gram.special] */
2683 : :
2684 : : static tree cp_parser_conversion_function_id
2685 : : (cp_parser *);
2686 : : static tree cp_parser_conversion_type_id
2687 : : (cp_parser *);
2688 : : static cp_declarator *cp_parser_conversion_declarator_opt
2689 : : (cp_parser *);
2690 : : static void cp_parser_ctor_initializer_opt
2691 : : (cp_parser *);
2692 : : static void cp_parser_mem_initializer_list
2693 : : (cp_parser *);
2694 : : static tree cp_parser_mem_initializer
2695 : : (cp_parser *);
2696 : : static tree cp_parser_mem_initializer_id
2697 : : (cp_parser *);
2698 : :
2699 : : /* Overloading [gram.over] */
2700 : :
2701 : : static cp_expr cp_parser_operator_function_id
2702 : : (cp_parser *);
2703 : : static cp_expr cp_parser_operator
2704 : : (cp_parser *, location_t);
2705 : :
2706 : : /* Templates [gram.temp] */
2707 : :
2708 : : static void cp_parser_template_declaration
2709 : : (cp_parser *, bool);
2710 : : static tree cp_parser_template_parameter_list
2711 : : (cp_parser *);
2712 : : static tree cp_parser_template_parameter
2713 : : (cp_parser *, bool *, bool *);
2714 : : static tree cp_parser_type_parameter
2715 : : (cp_parser *, bool *);
2716 : : static tree cp_parser_template_id
2717 : : (cp_parser *, bool, bool, enum tag_types, bool);
2718 : : static tree cp_parser_template_id_expr
2719 : : (cp_parser *, bool, bool, bool);
2720 : : static tree cp_parser_template_name
2721 : : (cp_parser *, bool, bool, bool, enum tag_types, bool *);
2722 : : static tree cp_parser_template_argument_list
2723 : : (cp_parser *);
2724 : : static tree cp_parser_template_argument
2725 : : (cp_parser *);
2726 : : static void cp_parser_explicit_instantiation
2727 : : (cp_parser *);
2728 : : static void cp_parser_explicit_specialization
2729 : : (cp_parser *);
2730 : :
2731 : : /* Exception handling [gram.except] */
2732 : :
2733 : : static tree cp_parser_try_block
2734 : : (cp_parser *);
2735 : : static void cp_parser_function_try_block
2736 : : (cp_parser *);
2737 : : static void cp_parser_handler_seq
2738 : : (cp_parser *);
2739 : : static void cp_parser_handler
2740 : : (cp_parser *);
2741 : : static tree cp_parser_exception_declaration
2742 : : (cp_parser *);
2743 : : static tree cp_parser_throw_expression
2744 : : (cp_parser *);
2745 : : static tree cp_parser_exception_specification_opt
2746 : : (cp_parser *, cp_parser_flags);
2747 : : static tree cp_parser_type_id_list
2748 : : (cp_parser *);
2749 : : static tree cp_parser_noexcept_specification_opt
2750 : : (cp_parser *, cp_parser_flags, bool, bool *, bool);
2751 : :
2752 : : /* GNU Extensions */
2753 : :
2754 : : static tree cp_parser_asm_specification_opt
2755 : : (cp_parser *);
2756 : : static tree cp_parser_asm_operand_list
2757 : : (cp_parser *);
2758 : : static tree cp_parser_asm_clobber_list
2759 : : (cp_parser *);
2760 : : static tree cp_parser_asm_label_list
2761 : : (cp_parser *);
2762 : : static bool cp_next_tokens_can_be_attribute_p
2763 : : (cp_parser *);
2764 : : static bool cp_next_tokens_can_be_gnu_attribute_p
2765 : : (cp_parser *);
2766 : : static bool cp_next_tokens_can_be_std_attribute_p
2767 : : (cp_parser *);
2768 : : static bool cp_nth_tokens_can_be_std_attribute_p
2769 : : (cp_parser *, size_t);
2770 : : static bool cp_nth_tokens_can_be_gnu_attribute_p
2771 : : (cp_parser *, size_t);
2772 : : static bool cp_nth_tokens_can_be_attribute_p
2773 : : (cp_parser *, size_t);
2774 : : static tree cp_parser_attributes_opt
2775 : : (cp_parser *);
2776 : : static tree cp_parser_gnu_attributes_opt
2777 : : (cp_parser *);
2778 : : static tree cp_parser_gnu_attribute_list
2779 : : (cp_parser *, bool = false);
2780 : : static tree cp_parser_std_attribute
2781 : : (cp_parser *, tree);
2782 : : static tree cp_parser_std_attribute_spec
2783 : : (cp_parser *);
2784 : : static tree cp_parser_std_attribute_spec_seq
2785 : : (cp_parser *);
2786 : : static size_t cp_parser_skip_std_attribute_spec_seq
2787 : : (cp_parser *, size_t);
2788 : : static size_t cp_parser_skip_attributes_opt
2789 : : (cp_parser *, size_t);
2790 : : static bool cp_parser_extension_opt
2791 : : (cp_parser *, int *);
2792 : : static void cp_parser_label_declaration
2793 : : (cp_parser *);
2794 : :
2795 : : /* Concept Extensions */
2796 : :
2797 : : static tree cp_parser_concept_definition
2798 : : (cp_parser *);
2799 : : static tree cp_parser_constraint_expression
2800 : : (cp_parser *);
2801 : : static tree cp_parser_requires_clause_opt
2802 : : (cp_parser *, bool);
2803 : : static tree cp_parser_requires_expression
2804 : : (cp_parser *);
2805 : : static tree cp_parser_requirement_parameter_list
2806 : : (cp_parser *);
2807 : : static tree cp_parser_requirement_body
2808 : : (cp_parser *);
2809 : : static tree cp_parser_requirement_seq
2810 : : (cp_parser *);
2811 : : static tree cp_parser_requirement
2812 : : (cp_parser *);
2813 : : static tree cp_parser_simple_requirement
2814 : : (cp_parser *);
2815 : : static tree cp_parser_compound_requirement
2816 : : (cp_parser *);
2817 : : static tree cp_parser_type_requirement
2818 : : (cp_parser *);
2819 : : static tree cp_parser_nested_requirement
2820 : : (cp_parser *);
2821 : :
2822 : : /* Transactional Memory Extensions */
2823 : :
2824 : : static tree cp_parser_transaction
2825 : : (cp_parser *, cp_token *);
2826 : : static tree cp_parser_transaction_expression
2827 : : (cp_parser *, enum rid);
2828 : : static void cp_parser_function_transaction
2829 : : (cp_parser *, enum rid);
2830 : : static tree cp_parser_transaction_cancel
2831 : : (cp_parser *);
2832 : :
2833 : : /* Coroutine extensions. */
2834 : :
2835 : : static tree cp_parser_yield_expression
2836 : : (cp_parser *);
2837 : :
2838 : : /* Contracts */
2839 : :
2840 : : static void cp_parser_late_contract_condition
2841 : : (cp_parser *, tree, tree);
2842 : :
2843 : : enum pragma_context {
2844 : : pragma_external,
2845 : : pragma_member,
2846 : : pragma_objc_icode,
2847 : : pragma_stmt,
2848 : : pragma_compound
2849 : : };
2850 : : static bool cp_parser_pragma
2851 : : (cp_parser *, enum pragma_context, bool *);
2852 : :
2853 : : /* Objective-C++ Productions */
2854 : :
2855 : : static tree cp_parser_objc_message_receiver
2856 : : (cp_parser *);
2857 : : static tree cp_parser_objc_message_args
2858 : : (cp_parser *);
2859 : : static tree cp_parser_objc_message_expression
2860 : : (cp_parser *);
2861 : : static cp_expr cp_parser_objc_encode_expression
2862 : : (cp_parser *);
2863 : : static tree cp_parser_objc_defs_expression
2864 : : (cp_parser *);
2865 : : static tree cp_parser_objc_protocol_expression
2866 : : (cp_parser *);
2867 : : static tree cp_parser_objc_selector_expression
2868 : : (cp_parser *);
2869 : : static cp_expr cp_parser_objc_expression
2870 : : (cp_parser *);
2871 : : static bool cp_parser_objc_selector_p
2872 : : (enum cpp_ttype);
2873 : : static tree cp_parser_objc_selector
2874 : : (cp_parser *);
2875 : : static tree cp_parser_objc_protocol_refs_opt
2876 : : (cp_parser *);
2877 : : static void cp_parser_objc_declaration
2878 : : (cp_parser *, tree);
2879 : : static tree cp_parser_objc_statement
2880 : : (cp_parser *);
2881 : : static bool cp_parser_objc_valid_prefix_attributes
2882 : : (cp_parser *, tree *);
2883 : : static void cp_parser_objc_at_property_declaration
2884 : : (cp_parser *) ;
2885 : : static void cp_parser_objc_at_synthesize_declaration
2886 : : (cp_parser *) ;
2887 : : static void cp_parser_objc_at_dynamic_declaration
2888 : : (cp_parser *) ;
2889 : : static tree cp_parser_objc_struct_declaration
2890 : : (cp_parser *) ;
2891 : :
2892 : : /* Utility Routines */
2893 : :
2894 : : static cp_expr cp_parser_lookup_name
2895 : : (cp_parser *, tree, enum tag_types, int, bool, bool, tree *, location_t);
2896 : : static tree cp_parser_lookup_name_simple
2897 : : (cp_parser *, tree, location_t);
2898 : : static tree cp_parser_maybe_treat_template_as_class
2899 : : (tree, bool);
2900 : : static bool cp_parser_check_declarator_template_parameters
2901 : : (cp_parser *, cp_declarator *, location_t);
2902 : : static bool cp_parser_check_template_parameters
2903 : : (cp_parser *, unsigned, bool, location_t, cp_declarator *);
2904 : : static cp_expr cp_parser_simple_cast_expression
2905 : : (cp_parser *);
2906 : : static tree cp_parser_global_scope_opt
2907 : : (cp_parser *, bool);
2908 : : static bool cp_parser_constructor_declarator_p
2909 : : (cp_parser *, cp_parser_flags, bool);
2910 : : static tree cp_parser_function_definition_from_specifiers_and_declarator
2911 : : (cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *);
2912 : : static tree cp_parser_function_definition_after_declarator
2913 : : (cp_parser *, bool);
2914 : : static bool cp_parser_template_declaration_after_export
2915 : : (cp_parser *, bool);
2916 : : static void cp_parser_perform_template_parameter_access_checks
2917 : : (vec<deferred_access_check, va_gc> *);
2918 : : static tree cp_parser_single_declaration
2919 : : (cp_parser *, vec<deferred_access_check, va_gc> *, bool, bool, bool *);
2920 : : static cp_expr cp_parser_functional_cast
2921 : : (cp_parser *, tree);
2922 : : static tree cp_parser_save_member_function_body
2923 : : (cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree);
2924 : : static tree cp_parser_save_nsdmi
2925 : : (cp_parser *);
2926 : : static tree cp_parser_enclosed_template_argument_list
2927 : : (cp_parser *);
2928 : : static void cp_parser_save_default_args
2929 : : (cp_parser *, tree);
2930 : : static void cp_parser_late_parsing_for_member
2931 : : (cp_parser *, tree);
2932 : : static tree cp_parser_late_parse_one_default_arg
2933 : : (cp_parser *, tree, tree, tree);
2934 : : static void cp_parser_late_parsing_nsdmi
2935 : : (cp_parser *, tree);
2936 : : static void cp_parser_late_parsing_default_args
2937 : : (cp_parser *, tree);
2938 : : static tree cp_parser_sizeof_operand
2939 : : (cp_parser *, enum rid);
2940 : : static cp_expr cp_parser_trait
2941 : : (cp_parser *, const cp_trait *);
2942 : : static bool cp_parser_declares_only_class_p
2943 : : (cp_parser *);
2944 : : static void cp_parser_set_storage_class
2945 : : (cp_parser *, cp_decl_specifier_seq *, enum rid, cp_token *);
2946 : : static void cp_parser_set_decl_spec_type
2947 : : (cp_decl_specifier_seq *, tree, cp_token *, bool);
2948 : : static void set_and_check_decl_spec_loc
2949 : : (cp_decl_specifier_seq *decl_specs,
2950 : : cp_decl_spec ds, cp_token *);
2951 : : static bool cp_parser_friend_p
2952 : : (const cp_decl_specifier_seq *);
2953 : : static void cp_parser_required_error
2954 : : (cp_parser *, required_token, bool, location_t);
2955 : : static cp_token *cp_parser_require
2956 : : (cp_parser *, enum cpp_ttype, required_token, location_t = UNKNOWN_LOCATION);
2957 : : static cp_token *cp_parser_require_keyword
2958 : : (cp_parser *, enum rid, required_token);
2959 : : static bool cp_parser_token_starts_function_definition_p
2960 : : (cp_token *);
2961 : : static bool cp_parser_next_token_starts_class_definition_p
2962 : : (cp_parser *);
2963 : : static bool cp_parser_next_token_ends_template_argument_p
2964 : : (cp_parser *);
2965 : : static bool cp_parser_nth_token_starts_template_argument_list_p
2966 : : (cp_parser *, size_t);
2967 : : static enum tag_types cp_parser_token_is_class_key
2968 : : (cp_token *);
2969 : : static enum tag_types cp_parser_token_is_type_parameter_key
2970 : : (cp_token *);
2971 : : static void cp_parser_maybe_warn_enum_key (cp_parser *, location_t, tree, rid);
2972 : : static void cp_parser_check_class_key
2973 : : (cp_parser *, location_t, enum tag_types, tree type, bool, bool);
2974 : : static void cp_parser_check_access_in_redeclaration
2975 : : (tree type, location_t location);
2976 : : static bool cp_parser_optional_template_keyword
2977 : : (cp_parser *);
2978 : : static void cp_parser_pre_parsed_nested_name_specifier
2979 : : (cp_parser *);
2980 : : static bool cp_parser_cache_group
2981 : : (cp_parser *, enum cpp_ttype, unsigned);
2982 : : static tree cp_parser_cache_defarg
2983 : : (cp_parser *parser, bool nsdmi);
2984 : : static void cp_parser_parse_tentatively
2985 : : (cp_parser *);
2986 : : static void cp_parser_commit_to_tentative_parse
2987 : : (cp_parser *);
2988 : : static void cp_parser_commit_to_topmost_tentative_parse
2989 : : (cp_parser *);
2990 : : static void cp_parser_abort_tentative_parse
2991 : : (cp_parser *);
2992 : : static bool cp_parser_parse_definitely
2993 : : (cp_parser *);
2994 : : static inline bool cp_parser_parsing_tentatively
2995 : : (cp_parser *);
2996 : : static bool cp_parser_uncommitted_to_tentative_parse_p
2997 : : (cp_parser *);
2998 : : static void cp_parser_error
2999 : : (cp_parser *, const char *);
3000 : : static void cp_parser_name_lookup_error
3001 : : (cp_parser *, tree, tree, name_lookup_error, location_t);
3002 : : static bool cp_parser_simulate_error
3003 : : (cp_parser *);
3004 : : static bool cp_parser_check_type_definition
3005 : : (cp_parser *);
3006 : : static void cp_parser_check_for_definition_in_return_type
3007 : : (cp_declarator *, tree, location_t type_location);
3008 : : static void cp_parser_check_for_invalid_template_id
3009 : : (cp_parser *, tree, enum tag_types, location_t location);
3010 : : static bool cp_parser_non_integral_constant_expression
3011 : : (cp_parser *, non_integral_constant);
3012 : : static void cp_parser_diagnose_invalid_type_name
3013 : : (cp_parser *, tree, location_t);
3014 : : static bool cp_parser_parse_and_diagnose_invalid_type_name
3015 : : (cp_parser *);
3016 : : static int cp_parser_skip_to_closing_parenthesis
3017 : : (cp_parser *, bool, bool, bool);
3018 : : static void cp_parser_skip_to_end_of_statement
3019 : : (cp_parser *);
3020 : : static void cp_parser_consume_semicolon_at_end_of_statement
3021 : : (cp_parser *);
3022 : : static void cp_parser_skip_to_end_of_block_or_statement
3023 : : (cp_parser *);
3024 : : static bool cp_parser_skip_to_closing_brace
3025 : : (cp_parser *);
3026 : : static bool cp_parser_skip_entire_template_parameter_list
3027 : : (cp_parser *);
3028 : : static void cp_parser_require_end_of_template_parameter_list
3029 : : (cp_parser *);
3030 : : static bool cp_parser_skip_to_end_of_template_parameter_list
3031 : : (cp_parser *);
3032 : : static void cp_parser_skip_to_pragma_eol
3033 : : (cp_parser*, cp_token *);
3034 : : static bool cp_parser_error_occurred
3035 : : (cp_parser *);
3036 : : static bool cp_parser_allow_gnu_extensions_p
3037 : : (cp_parser *);
3038 : : static bool cp_parser_is_pure_string_literal
3039 : : (cp_token *);
3040 : : static bool cp_parser_is_string_literal
3041 : : (cp_token *);
3042 : : static bool cp_parser_is_keyword
3043 : : (cp_token *, enum rid);
3044 : : static tree cp_parser_make_typename_type
3045 : : (cp_parser *, tree, location_t location);
3046 : : static cp_declarator * cp_parser_make_indirect_declarator
3047 : : (enum tree_code, tree, cp_cv_quals, cp_declarator *, tree);
3048 : : static bool cp_parser_compound_literal_p
3049 : : (cp_parser *);
3050 : : static bool cp_parser_array_designator_p
3051 : : (cp_parser *);
3052 : : static bool cp_parser_init_statement_p
3053 : : (cp_parser *);
3054 : : static bool cp_parser_skip_up_to_closing_square_bracket
3055 : : (cp_parser *);
3056 : : static bool cp_parser_skip_to_closing_square_bracket
3057 : : (cp_parser *);
3058 : : static size_t cp_parser_skip_balanced_tokens (cp_parser *, size_t);
3059 : : static bool cp_parser_next_tokens_can_be_canon_loop (cp_parser *,
3060 : : enum tree_code, bool);
3061 : : static tree cp_parser_omp_loop_nest (cp_parser *, bool *);
3062 : :
3063 : : // -------------------------------------------------------------------------- //
3064 : : // Unevaluated Operand Guard
3065 : : //
3066 : : // Implementation of an RAII helper for unevaluated operand parsing.
3067 : 96393003 : cp_unevaluated::cp_unevaluated ()
3068 : : {
3069 : 96393003 : ++cp_unevaluated_operand;
3070 : 96393003 : ++c_inhibit_evaluation_warnings;
3071 : 96393003 : }
3072 : :
3073 : 96387603 : cp_unevaluated::~cp_unevaluated ()
3074 : : {
3075 : 96387603 : --c_inhibit_evaluation_warnings;
3076 : 96387603 : --cp_unevaluated_operand;
3077 : 96387603 : }
3078 : :
3079 : : // -------------------------------------------------------------------------- //
3080 : : // Tentative Parsing
3081 : :
3082 : : /* Returns nonzero if we are parsing tentatively. */
3083 : :
3084 : : static inline bool
3085 : 37768378212 : cp_parser_parsing_tentatively (cp_parser* parser)
3086 : : {
3087 : 37768378212 : return parser->context->next != NULL;
3088 : : }
3089 : :
3090 : : /* Returns nonzero if TOKEN is a string literal. */
3091 : :
3092 : : static bool
3093 : 83442884 : cp_parser_is_pure_string_literal (cp_token* token)
3094 : : {
3095 : 54665643 : return (token->type == CPP_STRING ||
3096 : 54664945 : token->type == CPP_STRING16 ||
3097 : 54664224 : token->type == CPP_STRING32 ||
3098 : 137981325 : token->type == CPP_WSTRING ||
3099 : 83442884 : token->type == CPP_UTF8STRING);
3100 : : }
3101 : :
3102 : : /* Returns nonzero if TOKEN is a string literal
3103 : : of a user-defined string literal. */
3104 : :
3105 : : static bool
3106 : 43545026 : cp_parser_is_string_literal (cp_token* token)
3107 : : {
3108 : 62794847 : return (cp_parser_is_pure_string_literal (token) ||
3109 : 19249821 : token->type == CPP_STRING_USERDEF ||
3110 : 18708600 : token->type == CPP_STRING16_USERDEF ||
3111 : 18708472 : token->type == CPP_STRING32_USERDEF ||
3112 : 62253407 : token->type == CPP_WSTRING_USERDEF ||
3113 : 43545026 : token->type == CPP_UTF8STRING_USERDEF);
3114 : : }
3115 : :
3116 : : /* Returns nonzero if TOKEN is the indicated KEYWORD. */
3117 : :
3118 : : static bool
3119 : 542627125 : cp_parser_is_keyword (cp_token* token, enum rid keyword)
3120 : : {
3121 : 542627125 : return token->keyword == keyword;
3122 : : }
3123 : :
3124 : : /* Helper function for cp_parser_error.
3125 : : Having peeked a token of kind TOK1_KIND that might signify
3126 : : a conflict marker, peek successor tokens to determine
3127 : : if we actually do have a conflict marker.
3128 : : Specifically, we consider a run of 7 '<', '=' or '>' characters
3129 : : at the start of a line as a conflict marker.
3130 : : These come through the lexer as three pairs and a single,
3131 : : e.g. three CPP_LSHIFT tokens ("<<") and a CPP_LESS token ('<').
3132 : : If it returns true, *OUT_LOC is written to with the location/range
3133 : : of the marker. */
3134 : :
3135 : : static bool
3136 : 102 : cp_lexer_peek_conflict_marker (cp_lexer *lexer, enum cpp_ttype tok1_kind,
3137 : : location_t *out_loc)
3138 : : {
3139 : 102 : cp_token *token2 = cp_lexer_peek_nth_token (lexer, 2);
3140 : 102 : if (token2->type != tok1_kind)
3141 : : return false;
3142 : 87 : cp_token *token3 = cp_lexer_peek_nth_token (lexer, 3);
3143 : 87 : if (token3->type != tok1_kind)
3144 : : return false;
3145 : 78 : cp_token *token4 = cp_lexer_peek_nth_token (lexer, 4);
3146 : 78 : if (token4->type != conflict_marker_get_final_tok_kind (tok1_kind))
3147 : : return false;
3148 : :
3149 : : /* It must be at the start of the line. */
3150 : 57 : location_t start_loc = cp_lexer_peek_token (lexer)->location;
3151 : 57 : if (LOCATION_COLUMN (start_loc) != 1)
3152 : : return false;
3153 : :
3154 : : /* We have a conflict marker. Construct a location of the form:
3155 : : <<<<<<<
3156 : : ^~~~~~~
3157 : : with start == caret, finishing at the end of the marker. */
3158 : 48 : location_t finish_loc = get_finish (token4->location);
3159 : 48 : *out_loc = make_location (start_loc, start_loc, finish_loc);
3160 : :
3161 : 48 : return true;
3162 : : }
3163 : :
3164 : : /* Get a description of the matching symbol to TOKEN_DESC e.g. "(" for
3165 : : RT_CLOSE_PAREN. */
3166 : :
3167 : : static const char *
3168 : 168 : get_matching_symbol (required_token token_desc)
3169 : : {
3170 : 168 : switch (token_desc)
3171 : : {
3172 : 0 : default:
3173 : 0 : gcc_unreachable ();
3174 : : return "";
3175 : : case RT_CLOSE_BRACE:
3176 : : return "{";
3177 : 51 : case RT_CLOSE_PAREN:
3178 : 51 : return "(";
3179 : : }
3180 : : }
3181 : :
3182 : : /* Attempt to convert TOKEN_DESC from a required_token to an
3183 : : enum cpp_ttype, returning CPP_EOF if there is no good conversion. */
3184 : :
3185 : : static enum cpp_ttype
3186 : 2556 : get_required_cpp_ttype (required_token token_desc)
3187 : : {
3188 : 0 : switch (token_desc)
3189 : : {
3190 : : case RT_SEMICOLON:
3191 : : return CPP_SEMICOLON;
3192 : : case RT_OPEN_PAREN:
3193 : : return CPP_OPEN_PAREN;
3194 : : case RT_CLOSE_BRACE:
3195 : : return CPP_CLOSE_BRACE;
3196 : : case RT_OPEN_BRACE:
3197 : : return CPP_OPEN_BRACE;
3198 : : case RT_CLOSE_SQUARE:
3199 : : return CPP_CLOSE_SQUARE;
3200 : : case RT_OPEN_SQUARE:
3201 : : return CPP_OPEN_SQUARE;
3202 : : case RT_COMMA:
3203 : : return CPP_COMMA;
3204 : : case RT_COLON:
3205 : : return CPP_COLON;
3206 : : case RT_CLOSE_PAREN:
3207 : : return CPP_CLOSE_PAREN;
3208 : :
3209 : : default:
3210 : : /* Use CPP_EOF as a "no completions possible" code. */
3211 : : return CPP_EOF;
3212 : : }
3213 : : }
3214 : :
3215 : :
3216 : : /* Subroutine of cp_parser_error and cp_parser_required_error.
3217 : :
3218 : : Issue a diagnostic of the form
3219 : : FILE:LINE: MESSAGE before TOKEN
3220 : : where TOKEN is the next token in the input stream. MESSAGE
3221 : : (specified by the caller) is usually of the form "expected
3222 : : OTHER-TOKEN".
3223 : :
3224 : : This bypasses the check for tentative passing, and potentially
3225 : : adds material needed by cp_parser_required_error.
3226 : :
3227 : : If MISSING_TOKEN_DESC is not RT_NONE, then potentially add fix-it hints
3228 : : suggesting insertion of the missing token.
3229 : :
3230 : : Additionally, if MATCHING_LOCATION is not UNKNOWN_LOCATION, then we
3231 : : have an unmatched symbol at MATCHING_LOCATION; highlight this secondary
3232 : : location. */
3233 : :
3234 : : static void
3235 : 6436 : cp_parser_error_1 (cp_parser* parser, const char* gmsgid,
3236 : : required_token missing_token_desc,
3237 : : location_t matching_location)
3238 : : {
3239 : 6436 : cp_token *token = cp_lexer_peek_token (parser->lexer);
3240 : : /* This diagnostic makes more sense if it is tagged to the line
3241 : : of the token we just peeked at. */
3242 : 6436 : cp_lexer_set_source_position_from_token (token);
3243 : :
3244 : 6436 : if (token->type == CPP_PRAGMA)
3245 : : {
3246 : 18 : error_at (token->location,
3247 : : "%<#pragma%> is not allowed here");
3248 : 18 : cp_parser_skip_to_pragma_eol (parser, token);
3249 : 93 : return;
3250 : : }
3251 : :
3252 : 6418 : if (cp_token_is_module_directive (token))
3253 : : {
3254 : 9 : auto_diagnostic_group d;
3255 : 9 : error_at (token->location, "unexpected module directive");
3256 : 9 : if (token->keyword != RID__EXPORT)
3257 : 6 : inform (token->location, "perhaps insert a line break after"
3258 : : " %qs, or other disambiguation, to prevent this being"
3259 : : " considered a module control-line",
3260 : : (token->keyword == RID__MODULE) ? "module" : "import");
3261 : 9 : cp_parser_skip_to_pragma_eol (parser, token);
3262 : 9 : return;
3263 : 9 : }
3264 : :
3265 : : /* If this is actually a conflict marker, report it as such. */
3266 : 6409 : if (token->type == CPP_LSHIFT
3267 : 6409 : || token->type == CPP_RSHIFT
3268 : 6343 : || token->type == CPP_EQ_EQ)
3269 : : {
3270 : 102 : location_t loc;
3271 : 102 : if (cp_lexer_peek_conflict_marker (parser->lexer, token->type, &loc))
3272 : : {
3273 : 48 : error_at (loc, "version control conflict marker in file");
3274 : 48 : expanded_location token_exploc = expand_location (token->location);
3275 : : /* Consume tokens until the end of the source line. */
3276 : 492 : for (;;)
3277 : : {
3278 : 270 : cp_lexer_consume_token (parser->lexer);
3279 : 270 : cp_token *next = cp_lexer_peek_token (parser->lexer);
3280 : 270 : if (next->type == CPP_EOF)
3281 : : break;
3282 : 264 : if (next->location == UNKNOWN_LOCATION
3283 : 264 : || loc == UNKNOWN_LOCATION)
3284 : : break;
3285 : :
3286 : 264 : expanded_location next_exploc = expand_location (next->location);
3287 : 264 : if (next_exploc.file != token_exploc.file)
3288 : : break;
3289 : 264 : if (next_exploc.line != token_exploc.line)
3290 : : break;
3291 : 222 : }
3292 : 48 : return;
3293 : : }
3294 : : }
3295 : :
3296 : 6361 : auto_diagnostic_group d;
3297 : 6361 : gcc_rich_location richloc (input_location);
3298 : :
3299 : 6361 : bool added_matching_location = false;
3300 : :
3301 : 6361 : if (missing_token_desc != RT_NONE)
3302 : 2683 : if (cp_token *prev_token = cp_lexer_safe_previous_token (parser->lexer))
3303 : : {
3304 : : /* Potentially supply a fix-it hint, suggesting to add the
3305 : : missing token immediately after the *previous* token.
3306 : : This may move the primary location within richloc. */
3307 : 2556 : enum cpp_ttype ttype = get_required_cpp_ttype (missing_token_desc);
3308 : 2556 : location_t prev_token_loc = prev_token->location;
3309 : 2556 : maybe_suggest_missing_token_insertion (&richloc, ttype,
3310 : : prev_token_loc);
3311 : :
3312 : : /* If matching_location != UNKNOWN_LOCATION, highlight it.
3313 : : Attempt to consolidate diagnostics by printing it as a
3314 : : secondary range within the main diagnostic. */
3315 : 2556 : if (matching_location != UNKNOWN_LOCATION)
3316 : 997 : added_matching_location
3317 : 997 : = richloc.add_location_if_nearby (*global_dc,
3318 : : matching_location);
3319 : : }
3320 : :
3321 : : /* If we were parsing a string-literal and there is an unknown name
3322 : : token right after, then check to see if that could also have been
3323 : : a literal string by checking the name against a list of known
3324 : : standard string literal constants defined in header files. If
3325 : : there is one, then add that as an hint to the error message. */
3326 : 6361 : name_hint h;
3327 : 6361 : if (token->type == CPP_NAME)
3328 : 794 : if (cp_token *prev_token = cp_lexer_safe_previous_token (parser->lexer))
3329 : 772 : if (cp_parser_is_string_literal (prev_token))
3330 : : {
3331 : 19 : tree name = token->u.value;
3332 : 19 : const char *token_name = IDENTIFIER_POINTER (name);
3333 : 19 : const char *header_hint
3334 : 19 : = get_cp_stdlib_header_for_string_macro_name (token_name);
3335 : 19 : if (header_hint != NULL)
3336 : 16 : h = name_hint (NULL, new suggest_missing_header (token->location,
3337 : : token_name,
3338 : 16 : header_hint));
3339 : : }
3340 : :
3341 : : /* Actually emit the error. */
3342 : 6361 : c_parse_error (gmsgid,
3343 : : /* Because c_parser_error does not understand
3344 : : CPP_KEYWORD, keywords are treated like
3345 : : identifiers. */
3346 : 6361 : (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
3347 : 6361 : token->u.value, token->flags, &richloc);
3348 : :
3349 : 6361 : if (missing_token_desc != RT_NONE)
3350 : : {
3351 : : /* If we weren't able to consolidate matching_location, then
3352 : : print it as a secondary diagnostic. */
3353 : 2683 : if (matching_location != UNKNOWN_LOCATION
3354 : 2683 : && !added_matching_location)
3355 : 168 : inform (matching_location, "to match this %qs",
3356 : : get_matching_symbol (missing_token_desc));
3357 : : }
3358 : 6361 : }
3359 : :
3360 : : /* If not parsing tentatively, issue a diagnostic of the form
3361 : : FILE:LINE: MESSAGE before TOKEN
3362 : : where TOKEN is the next token in the input stream. MESSAGE
3363 : : (specified by the caller) is usually of the form "expected
3364 : : OTHER-TOKEN". */
3365 : :
3366 : : static void
3367 : 6812628750 : cp_parser_error (cp_parser* parser, const char* gmsgid)
3368 : : {
3369 : 13625257500 : if (!cp_parser_simulate_error (parser))
3370 : 3747 : cp_parser_error_1 (parser, gmsgid, RT_NONE, UNKNOWN_LOCATION);
3371 : 6812628750 : }
3372 : :
3373 : : /* Issue an error about name-lookup failing. NAME is the
3374 : : IDENTIFIER_NODE DECL is the result of
3375 : : the lookup (as returned from cp_parser_lookup_name). DESIRED is
3376 : : the thing that we hoped to find. */
3377 : :
3378 : : static void
3379 : 330 : cp_parser_name_lookup_error (cp_parser* parser,
3380 : : tree name,
3381 : : tree decl,
3382 : : name_lookup_error desired,
3383 : : location_t location)
3384 : : {
3385 : : /* If name lookup completely failed, tell the user that NAME was not
3386 : : declared. */
3387 : 330 : if (decl == error_mark_node)
3388 : : {
3389 : 287 : if (parser->scope && parser->scope != global_namespace)
3390 : : {
3391 : 42 : auto_diagnostic_group sentinel;
3392 : 42 : name_hint hint
3393 : : = suggest_alternative_in_explicit_scope (location, name,
3394 : 42 : parser->scope);;
3395 : 42 : if (const char *suggestion = hint.suggestion ())
3396 : : {
3397 : : /* Ideally we'd have a fix-it hint here, but LOCATION
3398 : : isn't necessarily that of the name. */
3399 : 3 : error_at (location,
3400 : : "%<%E::%E%> has not been declared;"
3401 : : " did you mean %<%E::%s%>?",
3402 : : parser->scope, name,
3403 : : parser->scope, suggestion);
3404 : : }
3405 : : else
3406 : 39 : error_at (location, "%<%E::%E%> has not been declared",
3407 : : parser->scope, name);
3408 : 42 : }
3409 : 245 : else if (parser->scope == global_namespace)
3410 : 0 : error_at (location, "%<::%E%> has not been declared", name);
3411 : 245 : else if (parser->object_scope
3412 : 245 : && !CLASS_TYPE_P (parser->object_scope))
3413 : 0 : error_at (location, "request for member %qE in non-class type %qT",
3414 : : name, parser->object_scope);
3415 : 245 : else if (parser->object_scope)
3416 : 0 : error_at (location, "%<%T::%E%> has not been declared",
3417 : : parser->object_scope, name);
3418 : : else
3419 : : {
3420 : 245 : auto_diagnostic_group d;
3421 : 245 : name_hint hint
3422 : 245 : = lookup_name_fuzzy (name, FUZZY_LOOKUP_TYPENAME, location);
3423 : 245 : if (const char *suggestion = hint.suggestion ())
3424 : : {
3425 : 34 : gcc_rich_location richloc (location);
3426 : 34 : richloc.add_fixit_replace (suggestion);
3427 : 34 : error_at (&richloc,
3428 : : "%qE has not been declared; did you mean %qs?",
3429 : : name, suggestion);
3430 : 34 : }
3431 : : else
3432 : 211 : error_at (location, "%qE has not been declared", name);
3433 : 245 : }
3434 : : }
3435 : 43 : else if (parser->scope && parser->scope != global_namespace)
3436 : : {
3437 : 17 : switch (desired)
3438 : : {
3439 : 17 : case NLE_TYPE:
3440 : 17 : error_at (location, "%<%E::%E%> is not a type",
3441 : : parser->scope, name);
3442 : 17 : break;
3443 : 0 : case NLE_CXX98:
3444 : 0 : error_at (location, "%<%E::%E%> is not a class or namespace",
3445 : : parser->scope, name);
3446 : 0 : break;
3447 : 0 : case NLE_NOT_CXX98:
3448 : 0 : error_at (location,
3449 : : "%<%E::%E%> is not a class, namespace, or enumeration",
3450 : : parser->scope, name);
3451 : 0 : break;
3452 : 0 : default:
3453 : 0 : gcc_unreachable ();
3454 : :
3455 : : }
3456 : : }
3457 : 26 : else if (parser->scope == global_namespace)
3458 : : {
3459 : 0 : switch (desired)
3460 : : {
3461 : 0 : case NLE_TYPE:
3462 : 0 : error_at (location, "%<::%E%> is not a type", name);
3463 : 0 : break;
3464 : 0 : case NLE_CXX98:
3465 : 0 : error_at (location, "%<::%E%> is not a class or namespace", name);
3466 : 0 : break;
3467 : 0 : case NLE_NOT_CXX98:
3468 : 0 : error_at (location,
3469 : : "%<::%E%> is not a class, namespace, or enumeration",
3470 : : name);
3471 : 0 : break;
3472 : 0 : default:
3473 : 0 : gcc_unreachable ();
3474 : : }
3475 : : }
3476 : : else
3477 : : {
3478 : 26 : switch (desired)
3479 : : {
3480 : 12 : case NLE_TYPE:
3481 : 12 : error_at (location, "%qE is not a type", name);
3482 : 12 : break;
3483 : 5 : case NLE_CXX98:
3484 : 5 : error_at (location, "%qE is not a class or namespace", name);
3485 : 5 : break;
3486 : 9 : case NLE_NOT_CXX98:
3487 : 9 : error_at (location,
3488 : : "%qE is not a class, namespace, or enumeration", name);
3489 : 9 : break;
3490 : 0 : default:
3491 : 0 : gcc_unreachable ();
3492 : : }
3493 : : }
3494 : 330 : }
3495 : :
3496 : : /* If we are parsing tentatively, remember that an error has occurred
3497 : : during this tentative parse. Returns true if the error was
3498 : : simulated; false if a message should be issued by the caller. */
3499 : :
3500 : : static bool
3501 : 11787396884 : cp_parser_simulate_error (cp_parser* parser)
3502 : : {
3503 : 3747 : if (cp_parser_uncommitted_to_tentative_parse_p (parser))
3504 : : {
3505 : 11787387134 : parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
3506 : 8835129207 : return true;
3507 : : }
3508 : : return false;
3509 : : }
3510 : :
3511 : : /* This function is called when a type is defined. If type
3512 : : definitions are forbidden at this point, an error message is
3513 : : issued. */
3514 : :
3515 : : static bool
3516 : 25229328 : cp_parser_check_type_definition (cp_parser* parser)
3517 : : {
3518 : : /* If types are forbidden here, issue a message. */
3519 : 0 : if (parser->type_definition_forbidden_message)
3520 : : {
3521 : : /* Don't use `%s' to print the string, because quotations (`%<', `%>')
3522 : : or %qs in the message need to be interpreted. */
3523 : 21 : error (parser->type_definition_forbidden_message,
3524 : : parser->type_definition_forbidden_message_arg);
3525 : 112 : return false;
3526 : : }
3527 : : return true;
3528 : : }
3529 : :
3530 : : /* This function is called when the DECLARATOR is processed. The TYPE
3531 : : was a type defined in the decl-specifiers. If it is invalid to
3532 : : define a type in the decl-specifiers for DECLARATOR, an error is
3533 : : issued. TYPE_LOCATION is the location of TYPE and is used
3534 : : for error reporting. */
3535 : :
3536 : : static void
3537 : 740847 : cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
3538 : : tree type, location_t type_location)
3539 : : {
3540 : : /* [dcl.fct] forbids type definitions in return types.
3541 : : Unfortunately, it's not easy to know whether or not we are
3542 : : processing a return type until after the fact. */
3543 : 740847 : while (declarator
3544 : 741373 : && (declarator->kind == cdk_pointer
3545 : : || declarator->kind == cdk_reference
3546 : 741373 : || declarator->kind == cdk_ptrmem))
3547 : 526 : declarator = declarator->declarator;
3548 : 740847 : if (declarator
3549 : 740847 : && declarator->kind == cdk_function)
3550 : : {
3551 : 24 : auto_diagnostic_group d;
3552 : 24 : error_at (type_location,
3553 : : "new types may not be defined in a return type");
3554 : 24 : inform (type_location,
3555 : : "(perhaps a semicolon is missing after the definition of %qT)",
3556 : : type);
3557 : 24 : }
3558 : 740847 : }
3559 : :
3560 : : /* A type-specifier (TYPE) has been parsed which cannot be followed by
3561 : : "<" in any valid C++ program. If the next token is indeed "<",
3562 : : issue a message warning the user about what appears to be an
3563 : : invalid attempt to form a template-id. LOCATION is the location
3564 : : of the type-specifier (TYPE) */
3565 : :
3566 : : static void
3567 : 914483288 : cp_parser_check_for_invalid_template_id (cp_parser* parser,
3568 : : tree type,
3569 : : enum tag_types tag_type,
3570 : : location_t location)
3571 : : {
3572 : 914483288 : cp_token_position start = 0;
3573 : :
3574 : 914483288 : if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3575 : : {
3576 : 101 : if (TREE_CODE (type) == TYPE_DECL)
3577 : 57 : type = TREE_TYPE (type);
3578 : 101 : if (TYPE_P (type) && !template_placeholder_p (type))
3579 : 63 : error_at (location, "%qT is not a template", type);
3580 : 38 : else if (identifier_p (type))
3581 : : {
3582 : 38 : if (tag_type != none_type)
3583 : 38 : error_at (location, "%qE is not a class template", type);
3584 : : else
3585 : 0 : error_at (location, "%qE is not a template", type);
3586 : : }
3587 : : else
3588 : 0 : error_at (location, "invalid template-id");
3589 : : /* Remember the location of the invalid "<". */
3590 : 267 : if (cp_parser_uncommitted_to_tentative_parse_p (parser))
3591 : 65 : start = cp_lexer_token_position (parser->lexer, true);
3592 : : /* Consume the "<". */
3593 : 101 : cp_lexer_consume_token (parser->lexer);
3594 : : /* Parse the template arguments. */
3595 : 101 : cp_parser_enclosed_template_argument_list (parser);
3596 : : /* Permanently remove the invalid template arguments so that
3597 : : this error message is not issued again. */
3598 : 101 : if (start)
3599 : 65 : cp_lexer_purge_tokens_after (parser->lexer, start);
3600 : : }
3601 : 914483288 : }
3602 : :
3603 : : /* If parsing an integral constant-expression, issue an error message
3604 : : about the fact that THING appeared and return true. Otherwise,
3605 : : return false. In either case, set
3606 : : PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
3607 : :
3608 : : static bool
3609 : 439022751 : cp_parser_non_integral_constant_expression (cp_parser *parser,
3610 : : non_integral_constant thing)
3611 : : {
3612 : 439022751 : parser->non_integral_constant_expression_p = true;
3613 : 439022751 : if (parser->integral_constant_expression_p)
3614 : : {
3615 : 81936792 : if (!parser->allow_non_integral_constant_expression_p)
3616 : : {
3617 : 57 : const char *msg = NULL;
3618 : 57 : switch (thing)
3619 : : {
3620 : 10 : case NIC_FLOAT:
3621 : 10 : pedwarn (input_location, OPT_Wpedantic,
3622 : : "ISO C++ forbids using a floating-point literal "
3623 : : "in a constant-expression");
3624 : 10 : return true;
3625 : 14 : case NIC_CAST:
3626 : 14 : error ("a cast to a type other than an integral or "
3627 : : "enumeration type cannot appear in a "
3628 : : "constant-expression");
3629 : 14 : return true;
3630 : 1 : case NIC_TYPEID:
3631 : 1 : error ("%<typeid%> operator "
3632 : : "cannot appear in a constant-expression");
3633 : 1 : return true;
3634 : 0 : case NIC_NCC:
3635 : 0 : error ("non-constant compound literals "
3636 : : "cannot appear in a constant-expression");
3637 : 0 : return true;
3638 : 4 : case NIC_FUNC_CALL:
3639 : 4 : error ("a function call "
3640 : : "cannot appear in a constant-expression");
3641 : 4 : return true;
3642 : 0 : case NIC_INC:
3643 : 0 : error ("an increment "
3644 : : "cannot appear in a constant-expression");
3645 : 0 : return true;
3646 : 0 : case NIC_DEC:
3647 : 0 : error ("an decrement "
3648 : : "cannot appear in a constant-expression");
3649 : 0 : return true;
3650 : 5 : case NIC_ARRAY_REF:
3651 : 5 : error ("an array reference "
3652 : : "cannot appear in a constant-expression");
3653 : 5 : return true;
3654 : 2 : case NIC_ADDR_LABEL:
3655 : 2 : error ("the address of a label "
3656 : : "cannot appear in a constant-expression");
3657 : 2 : return true;
3658 : 0 : case NIC_OVERLOADED:
3659 : 0 : error ("calls to overloaded operators "
3660 : : "cannot appear in a constant-expression");
3661 : 0 : return true;
3662 : 1 : case NIC_ASSIGNMENT:
3663 : 1 : error ("an assignment cannot appear in a constant-expression");
3664 : 1 : return true;
3665 : 2 : case NIC_COMMA:
3666 : 2 : error ("a comma operator "
3667 : : "cannot appear in a constant-expression");
3668 : 2 : return true;
3669 : 1 : case NIC_CONSTRUCTOR:
3670 : 1 : error ("a call to a constructor "
3671 : : "cannot appear in a constant-expression");
3672 : 1 : return true;
3673 : 0 : case NIC_TRANSACTION:
3674 : 0 : error ("a transaction expression "
3675 : : "cannot appear in a constant-expression");
3676 : 0 : return true;
3677 : : case NIC_THIS:
3678 : : msg = "this";
3679 : : break;
3680 : 1 : case NIC_FUNC_NAME:
3681 : 1 : msg = "__FUNCTION__";
3682 : 1 : break;
3683 : 1 : case NIC_PRETTY_FUNC:
3684 : 1 : msg = "__PRETTY_FUNCTION__";
3685 : 1 : break;
3686 : 1 : case NIC_C99_FUNC:
3687 : 1 : msg = "__func__";
3688 : 1 : break;
3689 : 0 : case NIC_VA_ARG:
3690 : 0 : msg = "va_arg";
3691 : 0 : break;
3692 : 1 : case NIC_ARROW:
3693 : 1 : msg = "->";
3694 : 1 : break;
3695 : 1 : case NIC_POINT:
3696 : 1 : msg = ".";
3697 : 1 : break;
3698 : 4 : case NIC_STAR:
3699 : 4 : msg = "*";
3700 : 4 : break;
3701 : 8 : case NIC_ADDR:
3702 : 8 : msg = "&";
3703 : 8 : break;
3704 : 0 : case NIC_PREINCREMENT:
3705 : 0 : msg = "++";
3706 : 0 : break;
3707 : 0 : case NIC_PREDECREMENT:
3708 : 0 : msg = "--";
3709 : 0 : break;
3710 : 0 : case NIC_NEW:
3711 : 0 : msg = "new";
3712 : 0 : break;
3713 : 0 : case NIC_DEL:
3714 : 0 : msg = "delete";
3715 : 0 : break;
3716 : 0 : default:
3717 : 0 : gcc_unreachable ();
3718 : : }
3719 : 17 : if (msg)
3720 : 17 : error ("%qs cannot appear in a constant-expression", msg);
3721 : 17 : return true;
3722 : : }
3723 : : }
3724 : : return false;
3725 : : }
3726 : :
3727 : : /* Emit a diagnostic for an invalid type name. This function commits
3728 : : to the current active tentative parse, if any. (Otherwise, the
3729 : : problematic construct might be encountered again later, resulting
3730 : : in duplicate error messages.) LOCATION is the location of ID. */
3731 : :
3732 : : static void
3733 : 775 : cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree id,
3734 : : location_t location)
3735 : : {
3736 : 775 : tree decl, ambiguous_decls;
3737 : 775 : cp_parser_commit_to_tentative_parse (parser);
3738 : : /* Try to lookup the identifier. */
3739 : 775 : decl = cp_parser_lookup_name (parser, id, none_type,
3740 : : /*is_template=*/false,
3741 : : /*is_namespace=*/false,
3742 : : /*check_dependency=*/true,
3743 : : &ambiguous_decls, location);
3744 : 775 : if (ambiguous_decls)
3745 : : /* If the lookup was ambiguous, an error will already have
3746 : : been issued. */
3747 : 18 : return;
3748 : : /* If the lookup found a template-name, it means that the user forgot
3749 : : to specify an argument list. Emit a useful error message. */
3750 : 757 : if (DECL_TYPE_TEMPLATE_P (decl))
3751 : : {
3752 : 35 : auto_diagnostic_group d;
3753 : 35 : error_at (location,
3754 : : "invalid use of template-name %qE without an argument list",
3755 : : decl);
3756 : 35 : if (DECL_CLASS_TEMPLATE_P (decl) && cxx_dialect < cxx17)
3757 : 27 : inform (location, "class template argument deduction is only available "
3758 : : "with %<-std=c++17%> or %<-std=gnu++17%>");
3759 : 35 : inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3760 : 35 : }
3761 : 722 : else if (TREE_CODE (id) == BIT_NOT_EXPR)
3762 : 3 : error_at (location, "invalid use of destructor %qD as a type", id);
3763 : 719 : else if (TREE_CODE (decl) == TYPE_DECL)
3764 : : /* Something like 'unsigned A a;' */
3765 : 2 : error_at (location, "invalid combination of multiple type-specifiers");
3766 : 717 : else if (!parser->scope)
3767 : : {
3768 : : /* Issue an error message. */
3769 : 399 : auto_diagnostic_group d;
3770 : 399 : name_hint hint;
3771 : 399 : if (TREE_CODE (id) == IDENTIFIER_NODE)
3772 : 396 : hint = lookup_name_fuzzy (id, FUZZY_LOOKUP_TYPENAME, location);
3773 : 399 : if (const char *suggestion = hint.suggestion ())
3774 : : {
3775 : 54 : gcc_rich_location richloc (location);
3776 : 54 : richloc.add_fixit_replace (suggestion);
3777 : 54 : error_at (&richloc,
3778 : : "%qE does not name a type; did you mean %qs?",
3779 : : id, suggestion);
3780 : 54 : }
3781 : : else
3782 : 345 : error_at (location, "%qE does not name a type", id);
3783 : : /* If we're in a template class, it's possible that the user was
3784 : : referring to a type from a base class. For example:
3785 : :
3786 : : template <typename T> struct A { typedef T X; };
3787 : : template <typename T> struct B : public A<T> { X x; };
3788 : :
3789 : : The user should have said "typename A<T>::X". */
3790 : 399 : if (cxx_dialect < cxx11 && id == ridpointers[(int)RID_CONSTEXPR])
3791 : 3 : inform (location, "C++11 %<constexpr%> only available with "
3792 : : "%<-std=c++11%> or %<-std=gnu++11%>");
3793 : 396 : else if (cxx_dialect < cxx11 && id == ridpointers[(int)RID_NOEXCEPT])
3794 : 1 : inform (location, "C++11 %<noexcept%> only available with "
3795 : : "%<-std=c++11%> or %<-std=gnu++11%>");
3796 : 395 : else if (TREE_CODE (id) == IDENTIFIER_NODE
3797 : 395 : && (id_equal (id, "module") || id_equal (id, "import")))
3798 : : {
3799 : 17 : if (modules_p ())
3800 : 15 : inform (location, "%qE is not recognized as a module control-line",
3801 : : id);
3802 : 2 : else if (cxx_dialect < cxx20)
3803 : 1 : inform (location, "C++20 %qE only available with %<-fmodules-ts%>",
3804 : : id);
3805 : : else
3806 : 1 : inform (location, "C++20 %qE only available with %<-fmodules-ts%>"
3807 : : ", which is not yet enabled with %<-std=c++20%>", id);
3808 : : }
3809 : 378 : else if (cxx_dialect < cxx11
3810 : 106 : && TREE_CODE (id) == IDENTIFIER_NODE
3811 : 484 : && id_equal (id, "thread_local"))
3812 : 0 : inform (location, "C++11 %<thread_local%> only available with "
3813 : : "%<-std=c++11%> or %<-std=gnu++11%>");
3814 : 378 : else if (cxx_dialect < cxx20 && id == ridpointers[(int)RID_CONSTINIT])
3815 : 4 : inform (location, "C++20 %<constinit%> only available with "
3816 : : "%<-std=c++20%> or %<-std=gnu++20%>");
3817 : 374 : else if (!flag_concepts && id == ridpointers[(int)RID_CONCEPT])
3818 : 3 : inform (location, "%<concept%> only available with %<-std=c++20%> or "
3819 : : "%<-fconcepts%>");
3820 : 371 : else if (!flag_concepts && id == ridpointers[(int)RID_REQUIRES])
3821 : 3 : inform (location, "%<requires%> only available with %<-std=c++20%> or "
3822 : : "%<-fconcepts%>");
3823 : 54 : else if (processing_template_decl && current_class_type
3824 : 407 : && TYPE_BINFO (current_class_type))
3825 : : {
3826 : 39 : for (tree b = TREE_CHAIN (TYPE_BINFO (current_class_type));
3827 : 45 : b; b = TREE_CHAIN (b))
3828 : : {
3829 : 21 : tree base_type = BINFO_TYPE (b);
3830 : 21 : if (CLASS_TYPE_P (base_type)
3831 : 42 : && dependent_type_p (base_type))
3832 : : {
3833 : : /* Go from a particular instantiation of the
3834 : : template (which will have an empty TYPE_FIELDs),
3835 : : to the main version. */
3836 : 21 : base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
3837 : 21 : for (tree field = TYPE_FIELDS (base_type);
3838 : 63 : field; field = DECL_CHAIN (field))
3839 : 57 : if (TREE_CODE (field) == TYPE_DECL
3840 : 57 : && DECL_NAME (field) == id)
3841 : : {
3842 : 30 : inform (location,
3843 : : "(perhaps %<typename %T::%E%> was intended)",
3844 : 15 : BINFO_TYPE (b), id);
3845 : 15 : goto found;
3846 : : }
3847 : : }
3848 : : }
3849 : 399 : found:;
3850 : : }
3851 : 399 : }
3852 : : /* Here we diagnose qualified-ids where the scope is actually correct,
3853 : : but the identifier does not resolve to a valid type name. */
3854 : 318 : else if (parser->scope != error_mark_node)
3855 : : {
3856 : 287 : if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
3857 : : {
3858 : 110 : auto_diagnostic_group d;
3859 : 110 : name_hint hint;
3860 : 110 : if (decl == error_mark_node)
3861 : 184 : hint = suggest_alternative_in_explicit_scope (location, id,
3862 : 92 : parser->scope);
3863 : 110 : const char *suggestion = hint.suggestion ();
3864 : 110 : gcc_rich_location richloc (location_of (id));
3865 : 110 : if (suggestion)
3866 : 4 : richloc.add_fixit_replace (suggestion);
3867 : 110 : if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3868 : : {
3869 : 54 : if (suggestion)
3870 : 0 : error_at (&richloc,
3871 : : "%qE in namespace %qE does not name a template"
3872 : : " type; did you mean %qs?",
3873 : : id, parser->scope, suggestion);
3874 : : else
3875 : 54 : error_at (&richloc,
3876 : : "%qE in namespace %qE does not name a template type",
3877 : : id, parser->scope);
3878 : : }
3879 : 56 : else if (TREE_CODE (id) == TEMPLATE_ID_EXPR)
3880 : : {
3881 : 0 : if (suggestion)
3882 : 0 : error_at (&richloc,
3883 : : "%qE in namespace %qE does not name a template"
3884 : : " type; did you mean %qs?",
3885 : 0 : TREE_OPERAND (id, 0), parser->scope, suggestion);
3886 : : else
3887 : 0 : error_at (&richloc,
3888 : : "%qE in namespace %qE does not name a template"
3889 : : " type",
3890 : 0 : TREE_OPERAND (id, 0), parser->scope);
3891 : : }
3892 : : else
3893 : : {
3894 : 56 : if (suggestion)
3895 : 4 : error_at (&richloc,
3896 : : "%qE in namespace %qE does not name a type"
3897 : : "; did you mean %qs?",
3898 : : id, parser->scope, suggestion);
3899 : : else
3900 : 52 : error_at (&richloc,
3901 : : "%qE in namespace %qE does not name a type",
3902 : : id, parser->scope);
3903 : : }
3904 : 110 : if (DECL_P (decl))
3905 : 15 : inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3906 : 110 : }
3907 : 134 : else if (CLASS_TYPE_P (parser->scope)
3908 : 311 : && constructor_name_p (id, parser->scope))
3909 : : {
3910 : : /* A<T>::A<T>() */
3911 : 15 : auto_diagnostic_group d;
3912 : 15 : error_at (location, "%<%T::%E%> names the constructor, not"
3913 : : " the type", parser->scope, id);
3914 : 15 : if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3915 : 12 : error_at (location, "and %qT has no template constructors",
3916 : : parser->scope);
3917 : 15 : }
3918 : 162 : else if (TYPE_P (parser->scope)
3919 : 162 : && dependent_scope_p (parser->scope))
3920 : : {
3921 : 69 : gcc_rich_location richloc (location);
3922 : 69 : richloc.add_fixit_insert_before ("typename ");
3923 : 69 : if (TREE_CODE (parser->scope) == TYPENAME_TYPE)
3924 : 6 : error_at (&richloc,
3925 : : "need %<typename%> before %<%T::%D::%E%> because "
3926 : : "%<%T::%D%> is a dependent scope",
3927 : 6 : TYPE_CONTEXT (parser->scope),
3928 : 6 : TYPENAME_TYPE_FULLNAME (parser->scope),
3929 : : id,
3930 : 6 : TYPE_CONTEXT (parser->scope),
3931 : 6 : TYPENAME_TYPE_FULLNAME (parser->scope));
3932 : : else
3933 : 63 : error_at (&richloc, "need %<typename%> before %<%T::%E%> because "
3934 : : "%qT is a dependent scope",
3935 : : parser->scope, id, parser->scope);
3936 : 69 : }
3937 : 93 : else if (TYPE_P (parser->scope))
3938 : : {
3939 : 93 : auto_diagnostic_group d;
3940 : 93 : if (!COMPLETE_TYPE_P (parser->scope)
3941 : 93 : && !currently_open_class (parser->scope))
3942 : 17 : cxx_incomplete_type_error (location_of (id), NULL_TREE,
3943 : 17 : parser->scope);
3944 : 76 : else if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3945 : 9 : error_at (location_of (id),
3946 : : "%qE in %q#T does not name a template type",
3947 : : id, parser->scope);
3948 : 67 : else if (TREE_CODE (id) == TEMPLATE_ID_EXPR)
3949 : 0 : error_at (location_of (id),
3950 : : "%qE in %q#T does not name a template type",
3951 : 0 : TREE_OPERAND (id, 0), parser->scope);
3952 : : else
3953 : 67 : error_at (location_of (id),
3954 : : "%qE in %q#T does not name a type",
3955 : : id, parser->scope);
3956 : 93 : if (DECL_P (decl))
3957 : 3 : inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3958 : 93 : }
3959 : : else
3960 : 0 : gcc_unreachable ();
3961 : : }
3962 : : }
3963 : :
3964 : : /* Check for a common situation where a type-name should be present,
3965 : : but is not, and issue a sensible error message. Returns true if an
3966 : : invalid type-name was detected.
3967 : :
3968 : : The situation handled by this function are variable declarations of the
3969 : : form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3970 : : Usually, `ID' should name a type, but if we got here it means that it
3971 : : does not. We try to emit the best possible error message depending on
3972 : : how exactly the id-expression looks like. */
3973 : :
3974 : : static bool
3975 : 25377869 : cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
3976 : : {
3977 : 25377869 : tree id;
3978 : 25377869 : cp_token *token = cp_lexer_peek_token (parser->lexer);
3979 : :
3980 : : /* Avoid duplicate error about ambiguous lookup. */
3981 : 25377869 : if (token->type == CPP_NESTED_NAME_SPECIFIER)
3982 : : {
3983 : 934472 : cp_token *next = cp_lexer_peek_nth_token (parser->lexer, 2);
3984 : 934472 : if (next->type == CPP_NAME && next->error_reported)
3985 : 0 : goto out;
3986 : : }
3987 : :
3988 : 25377869 : cp_parser_parse_tentatively (parser);
3989 : 25377869 : id = cp_parser_id_expression (parser,
3990 : : /*template_keyword_p=*/false,
3991 : : /*check_dependency_p=*/true,
3992 : : /*template_p=*/NULL,
3993 : : /*declarator_p=*/true,
3994 : : /*optional_p=*/false);
3995 : : /* If the next token is a (, this is a function with no explicit return
3996 : : type, i.e. constructor, destructor or conversion op. */
3997 : 25377869 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
3998 : 25377869 : || TREE_CODE (id) == TYPE_DECL)
3999 : : {
4000 : 25376463 : cp_parser_abort_tentative_parse (parser);
4001 : 25376463 : return false;
4002 : : }
4003 : 1406 : if (!cp_parser_parse_definitely (parser))
4004 : : return false;
4005 : :
4006 : : /* Emit a diagnostic for the invalid type. */
4007 : 663 : cp_parser_diagnose_invalid_type_name (parser, id, token->location);
4008 : 663 : out:
4009 : : /* If we aren't in the middle of a declarator (i.e. in a
4010 : : parameter-declaration-clause), skip to the end of the declaration;
4011 : : there's no point in trying to process it. */
4012 : 663 : if (!parser->in_declarator_p)
4013 : 543 : cp_parser_skip_to_end_of_block_or_statement (parser);
4014 : : return true;
4015 : : }
4016 : :
4017 : : /* Consume tokens up to, and including, the next non-nested closing `)'.
4018 : : Returns 1 iff we found a closing `)'. RECOVERING is true, if we
4019 : : are doing error recovery. Returns -1 if OR_TTYPE is not CPP_EOF and we
4020 : : found an unnested token of that type. */
4021 : :
4022 : : static int
4023 : 111976521 : cp_parser_skip_to_closing_parenthesis_1 (cp_parser *parser,
4024 : : bool recovering,
4025 : : cpp_ttype or_ttype,
4026 : : bool consume_paren)
4027 : : {
4028 : 111976521 : unsigned paren_depth = 0;
4029 : 111976521 : unsigned brace_depth = 0;
4030 : 111976521 : unsigned square_depth = 0;
4031 : 111976521 : unsigned condop_depth = 0;
4032 : :
4033 : 223953042 : if (recovering && or_ttype == CPP_EOF
4034 : 223953042 : && cp_parser_uncommitted_to_tentative_parse_p (parser))
4035 : : return 0;
4036 : :
4037 : 1028293935 : while (true)
4038 : : {
4039 : 1028293935 : cp_token * token = cp_lexer_peek_token (parser->lexer);
4040 : :
4041 : : /* Have we found what we're looking for before the closing paren? */
4042 : 1028293935 : if (token->type == or_ttype && or_ttype != CPP_EOF
4043 : 5295876 : && !brace_depth && !paren_depth && !square_depth && !condop_depth)
4044 : : return -1;
4045 : :
4046 : 1023045406 : switch (token->type)
4047 : : {
4048 : 231 : case CPP_PRAGMA_EOL:
4049 : 231 : if (!parser->lexer->in_pragma)
4050 : : break;
4051 : : /* FALLTHRU */
4052 : : case CPP_EOF:
4053 : : /* If we've run out of tokens, then there is no closing `)'. */
4054 : : return 0;
4055 : :
4056 : : /* This is good for lambda expression capture-lists. */
4057 : 5246077 : case CPP_OPEN_SQUARE:
4058 : 5246077 : ++square_depth;
4059 : 5246077 : break;
4060 : 5246160 : case CPP_CLOSE_SQUARE:
4061 : 5246160 : if (!square_depth--)
4062 : : return 0;
4063 : : break;
4064 : :
4065 : 6328180 : case CPP_SEMICOLON:
4066 : : /* This matches the processing in skip_to_end_of_statement. */
4067 : 6328180 : if (!brace_depth)
4068 : : return 0;
4069 : : break;
4070 : :
4071 : 527442 : case CPP_OPEN_BRACE:
4072 : 527442 : ++brace_depth;
4073 : 527442 : break;
4074 : 527466 : case CPP_CLOSE_BRACE:
4075 : 527466 : if (!brace_depth--)
4076 : : return 0;
4077 : : break;
4078 : :
4079 : 123523824 : case CPP_OPEN_PAREN:
4080 : 123523824 : if (!brace_depth)
4081 : 122497550 : ++paren_depth;
4082 : : break;
4083 : :
4084 : 225052504 : case CPP_CLOSE_PAREN:
4085 : 225052504 : if (!brace_depth && !paren_depth--)
4086 : : {
4087 : 101528674 : if (consume_paren)
4088 : 63109649 : cp_lexer_consume_token (parser->lexer);
4089 : 101528674 : return 1;
4090 : : }
4091 : : break;
4092 : :
4093 : 3794055 : case CPP_QUERY:
4094 : 3794055 : if (!brace_depth && !paren_depth && !square_depth)
4095 : 2727318 : ++condop_depth;
4096 : : break;
4097 : :
4098 : 4012092 : case CPP_COLON:
4099 : 4012092 : if (!brace_depth && !paren_depth && !square_depth && condop_depth > 0)
4100 : 2727306 : condop_depth--;
4101 : : break;
4102 : :
4103 : 43375244 : case CPP_KEYWORD:
4104 : 43375244 : if (!cp_token_is_module_directive (token))
4105 : : break;
4106 : : /* FALLTHROUGH */
4107 : :
4108 : 12 : case CPP_PRAGMA:
4109 : : /* We fell into a pragma. Skip it, and continue. */
4110 : 24 : cp_parser_skip_to_pragma_eol (parser, recovering ? token : nullptr);
4111 : 12 : continue;
4112 : :
4113 : : default:
4114 : : break;
4115 : : }
4116 : :
4117 : : /* Consume the token. */
4118 : 916317451 : cp_lexer_consume_token (parser->lexer);
4119 : : }
4120 : : }
4121 : :
4122 : : /* Consume tokens up to, and including, the next non-nested closing `)'.
4123 : : Returns 1 iff we found a closing `)'. RECOVERING is true, if we
4124 : : are doing error recovery. Returns -1 if OR_COMMA is true and we
4125 : : found an unnested token of that type. */
4126 : :
4127 : : static int
4128 : 63110424 : cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
4129 : : bool recovering,
4130 : : bool or_comma,
4131 : : bool consume_paren)
4132 : : {
4133 : 0 : cpp_ttype ttype = or_comma ? CPP_COMMA : CPP_EOF;
4134 : 0 : return cp_parser_skip_to_closing_parenthesis_1 (parser, recovering,
4135 : 457 : ttype, consume_paren);
4136 : : }
4137 : :
4138 : : /* Consume tokens until we reach the end of the current statement.
4139 : : Normally, that will be just before consuming a `;'. However, if a
4140 : : non-nested `}' comes first, then we stop before consuming that. */
4141 : :
4142 : : static void
4143 : 3656 : cp_parser_skip_to_end_of_statement (cp_parser* parser)
4144 : : {
4145 : 3656 : unsigned nesting_depth = 0;
4146 : :
4147 : : /* Unwind generic function template scope if necessary. */
4148 : 3656 : if (parser->fully_implicit_function_template_p)
4149 : 6 : abort_fully_implicit_template (parser);
4150 : :
4151 : 9975 : while (true)
4152 : : {
4153 : 9975 : cp_token *token = cp_lexer_peek_token (parser->lexer);
4154 : :
4155 : 9975 : switch (token->type)
4156 : : {
4157 : 0 : case CPP_PRAGMA_EOL:
4158 : 0 : if (!parser->lexer->in_pragma)
4159 : : break;
4160 : : /* FALLTHRU */
4161 : : case CPP_EOF:
4162 : : /* If we've run out of tokens, stop. */
4163 : : return;
4164 : :
4165 : 3065 : case CPP_SEMICOLON:
4166 : : /* If the next token is a `;', we have reached the end of the
4167 : : statement. */
4168 : 3065 : if (!nesting_depth)
4169 : : return;
4170 : : break;
4171 : :
4172 : 415 : case CPP_CLOSE_BRACE:
4173 : : /* If this is a non-nested '}', stop before consuming it.
4174 : : That way, when confronted with something like:
4175 : :
4176 : : { 3 + }
4177 : :
4178 : : we stop before consuming the closing '}', even though we
4179 : : have not yet reached a `;'. */
4180 : 415 : if (nesting_depth == 0)
4181 : : return;
4182 : :
4183 : : /* If it is the closing '}' for a block that we have
4184 : : scanned, stop -- but only after consuming the token.
4185 : : That way given:
4186 : :
4187 : : void f g () { ... }
4188 : : typedef int I;
4189 : :
4190 : : we will stop after the body of the erroneously declared
4191 : : function, but before consuming the following `typedef'
4192 : : declaration. */
4193 : 370 : if (--nesting_depth == 0)
4194 : : {
4195 : 358 : cp_lexer_consume_token (parser->lexer);
4196 : 358 : return;
4197 : : }
4198 : : break;
4199 : :
4200 : 373 : case CPP_OPEN_BRACE:
4201 : 373 : ++nesting_depth;
4202 : 373 : break;
4203 : :
4204 : 1098 : case CPP_KEYWORD:
4205 : 1098 : if (!cp_token_is_module_directive (token))
4206 : : break;
4207 : : /* FALLTHROUGH */
4208 : :
4209 : 24 : case CPP_PRAGMA:
4210 : : /* We fell into a pragma. Skip it, and continue or return. */
4211 : 24 : cp_parser_skip_to_pragma_eol (parser, token);
4212 : 24 : if (!nesting_depth)
4213 : : return;
4214 : 9 : continue;
4215 : :
4216 : : default:
4217 : : break;
4218 : : }
4219 : :
4220 : : /* Consume the token. */
4221 : 6310 : cp_lexer_consume_token (parser->lexer);
4222 : : }
4223 : : }
4224 : :
4225 : : /* This function is called at the end of a statement or declaration.
4226 : : If the next token is a semicolon, it is consumed; otherwise, error
4227 : : recovery is attempted. */
4228 : :
4229 : : static void
4230 : 100698944 : cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
4231 : : {
4232 : : /* Look for the trailing `;'. */
4233 : 100698944 : if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
4234 : : {
4235 : : /* If there is additional (erroneous) input, skip to the end of
4236 : : the statement. */
4237 : 145 : cp_parser_skip_to_end_of_statement (parser);
4238 : : /* If the next token is now a `;', consume it. */
4239 : 145 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
4240 : 88 : cp_lexer_consume_token (parser->lexer);
4241 : : }
4242 : 100698944 : }
4243 : :
4244 : : /* Skip tokens until we have consumed an entire block, or until we
4245 : : have consumed a non-nested `;'. */
4246 : :
4247 : : static void
4248 : 15663 : cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
4249 : : {
4250 : 15663 : int nesting_depth = 0;
4251 : :
4252 : : /* Unwind generic function template scope if necessary. */
4253 : 15663 : if (parser->fully_implicit_function_template_p)
4254 : 15 : abort_fully_implicit_template (parser);
4255 : :
4256 : 39487 : while (nesting_depth >= 0)
4257 : : {
4258 : 24050 : cp_token *token = cp_lexer_peek_token (parser->lexer);
4259 : :
4260 : 24050 : switch (token->type)
4261 : : {
4262 : 0 : case CPP_PRAGMA_EOL:
4263 : 0 : if (!parser->lexer->in_pragma)
4264 : : break;
4265 : : /* FALLTHRU */
4266 : : case CPP_EOF:
4267 : : /* If we've run out of tokens, stop. */
4268 : : return;
4269 : :
4270 : 14095 : case CPP_SEMICOLON:
4271 : : /* Stop if this is an unnested ';'. */
4272 : 14095 : if (!nesting_depth)
4273 : 15437 : nesting_depth = -1;
4274 : : break;
4275 : :
4276 : 1985 : case CPP_CLOSE_BRACE:
4277 : : /* Stop if this is an unnested '}', or closes the outermost
4278 : : nesting level. */
4279 : 1985 : nesting_depth--;
4280 : 1985 : if (nesting_depth < 0)
4281 : : return;
4282 : 1844 : if (!nesting_depth)
4283 : 15437 : nesting_depth = -1;
4284 : : break;
4285 : :
4286 : 1850 : case CPP_OPEN_BRACE:
4287 : : /* Nest. */
4288 : 1850 : nesting_depth++;
4289 : 1850 : break;
4290 : :
4291 : 974 : case CPP_KEYWORD:
4292 : 974 : if (!cp_token_is_module_directive (token))
4293 : : break;
4294 : : /* FALLTHROUGH */
4295 : :
4296 : 12 : case CPP_PRAGMA:
4297 : : /* Skip it, and continue or return. */
4298 : 12 : cp_parser_skip_to_pragma_eol (parser, token);
4299 : 12 : if (!nesting_depth)
4300 : : return;
4301 : 0 : continue;
4302 : :
4303 : : default:
4304 : : break;
4305 : : }
4306 : :
4307 : : /* Consume the token. */
4308 : 23824 : cp_lexer_consume_token (parser->lexer);
4309 : : }
4310 : : }
4311 : :
4312 : : /* Skip tokens until a non-nested closing curly brace is the next
4313 : : token, or there are no more tokens. Return true in the first case,
4314 : : false otherwise. */
4315 : :
4316 : : static bool
4317 : 181 : cp_parser_skip_to_closing_brace (cp_parser *parser)
4318 : : {
4319 : 181 : unsigned nesting_depth = 0;
4320 : :
4321 : 821 : while (true)
4322 : : {
4323 : 501 : cp_token *token = cp_lexer_peek_token (parser->lexer);
4324 : :
4325 : 501 : switch (token->type)
4326 : : {
4327 : 6 : case CPP_PRAGMA_EOL:
4328 : 6 : if (!parser->lexer->in_pragma)
4329 : : break;
4330 : : /* FALLTHRU */
4331 : : case CPP_EOF:
4332 : : /* If we've run out of tokens, stop. */
4333 : : return false;
4334 : :
4335 : 170 : case CPP_CLOSE_BRACE:
4336 : : /* If the next token is a non-nested `}', then we have reached
4337 : : the end of the current block. */
4338 : 170 : if (nesting_depth-- == 0)
4339 : : return true;
4340 : : break;
4341 : :
4342 : 4 : case CPP_OPEN_BRACE:
4343 : : /* If it the next token is a `{', then we are entering a new
4344 : : block. Consume the entire block. */
4345 : 4 : ++nesting_depth;
4346 : 4 : break;
4347 : :
4348 : : default:
4349 : : break;
4350 : : }
4351 : :
4352 : : /* Consume the token. */
4353 : 320 : cp_lexer_consume_token (parser->lexer);
4354 : 320 : }
4355 : : }
4356 : :
4357 : : /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
4358 : : parameter is the PRAGMA token, allowing us to purge the entire pragma
4359 : : sequence. PRAGMA_TOK can be NULL, if we're speculatively scanning
4360 : : forwards (not error recovery). */
4361 : :
4362 : : static void
4363 : 5104848 : cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
4364 : : {
4365 : 5108921 : cp_token *token;
4366 : :
4367 : 5108921 : do
4368 : : {
4369 : : /* The preprocessor makes sure that a PRAGMA_EOL token appears
4370 : : before an EOF token, even when the EOF is on the pragma line.
4371 : : We should never get here without being inside a deferred
4372 : : pragma. */
4373 : 5108921 : gcc_checking_assert (cp_lexer_next_token_is_not (parser->lexer, CPP_EOF));
4374 : 5108921 : token = cp_lexer_consume_token (parser->lexer);
4375 : : }
4376 : 5108921 : while (token->type != CPP_PRAGMA_EOL);
4377 : :
4378 : 5104848 : if (pragma_tok)
4379 : : {
4380 : 5104836 : parser->lexer->in_pragma = false;
4381 : 5104836 : if (parser->lexer->in_omp_attribute_pragma
4382 : 5104836 : && cp_lexer_next_token_is (parser->lexer, CPP_EOF))
4383 : : {
4384 : 1388 : parser->lexer = parser->lexer->next;
4385 : : /* Put the current source position back where it was before this
4386 : : lexer was pushed. */
4387 : 1388 : cp_lexer_set_source_position_from_token (parser->lexer->next_token);
4388 : : }
4389 : : }
4390 : 5104848 : }
4391 : :
4392 : : /* Require pragma end of line, resyncing with it as necessary. The
4393 : : arguments are as for cp_parser_skip_to_pragma_eol. */
4394 : :
4395 : : static void
4396 : 15428 : cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
4397 : : {
4398 : 15428 : parser->lexer->in_pragma = false;
4399 : 15428 : if (!cp_parser_require (parser, CPP_PRAGMA_EOL, RT_PRAGMA_EOL))
4400 : 142 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
4401 : 15286 : else if (parser->lexer->in_omp_attribute_pragma
4402 : 15286 : && cp_lexer_next_token_is (parser->lexer, CPP_EOF))
4403 : : {
4404 : 661 : parser->lexer = parser->lexer->next;
4405 : : /* Put the current source position back where it was before this
4406 : : lexer was pushed. */
4407 : 661 : cp_lexer_set_source_position_from_token (parser->lexer->next_token);
4408 : : }
4409 : 15428 : }
4410 : :
4411 : : /* This is a simple wrapper around make_typename_type. When the id is
4412 : : an unresolved identifier node, we can provide a superior diagnostic
4413 : : using cp_parser_diagnose_invalid_type_name. */
4414 : :
4415 : : static tree
4416 : 27034620 : cp_parser_make_typename_type (cp_parser *parser, tree id,
4417 : : location_t id_location)
4418 : : {
4419 : 27034620 : tree result;
4420 : 27034620 : if (identifier_p (id))
4421 : : {
4422 : 27034596 : result = make_typename_type (parser->scope, id, typename_type,
4423 : : /*complain=*/tf_none);
4424 : 27034596 : if (result == error_mark_node)
4425 : 43 : cp_parser_diagnose_invalid_type_name (parser, id, id_location);
4426 : 27034596 : return result;
4427 : : }
4428 : 24 : return make_typename_type (parser->scope, id, typename_type, tf_error);
4429 : : }
4430 : :
4431 : : /* This is a wrapper around the
4432 : : make_{pointer,ptrmem,reference}_declarator functions that decides
4433 : : which one to call based on the CODE and CLASS_TYPE arguments. The
4434 : : CODE argument should be one of the values returned by
4435 : : cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
4436 : : appertain to the pointer or reference. */
4437 : :
4438 : : static cp_declarator *
4439 : 170299474 : cp_parser_make_indirect_declarator (enum tree_code code, tree class_type,
4440 : : cp_cv_quals cv_qualifiers,
4441 : : cp_declarator *target,
4442 : : tree attributes)
4443 : : {
4444 : 170299474 : if (code == ERROR_MARK || target == cp_error_declarator)
4445 : 52 : return cp_error_declarator;
4446 : :
4447 : 170299422 : if (code == INDIRECT_REF)
4448 : 58990169 : if (class_type == NULL_TREE)
4449 : 57853187 : return make_pointer_declarator (cv_qualifiers, target, attributes);
4450 : : else
4451 : 1136982 : return make_ptrmem_declarator (cv_qualifiers, class_type,
4452 : 1136982 : target, attributes);
4453 : 111309253 : else if (code == ADDR_EXPR && class_type == NULL_TREE)
4454 : 95072630 : return make_reference_declarator (cv_qualifiers, target,
4455 : 95072630 : false, attributes);
4456 : 16236623 : else if (code == NON_LVALUE_EXPR && class_type == NULL_TREE)
4457 : 16236623 : return make_reference_declarator (cv_qualifiers, target,
4458 : 16236623 : true, attributes);
4459 : 0 : gcc_unreachable ();
4460 : : }
4461 : :
4462 : : /* Create a new C++ parser. */
4463 : :
4464 : : static cp_parser *
4465 : 92004 : cp_parser_new (cp_lexer *lexer)
4466 : : {
4467 : : /* Initialize the binops_by_token so that we can get the tree
4468 : : directly from the token. */
4469 : 2024088 : for (unsigned i = 0; i < ARRAY_SIZE (binops); i++)
4470 : 1932084 : binops_by_token[binops[i].token_type] = binops[i];
4471 : :
4472 : 92004 : cp_parser *parser = ggc_cleared_alloc<cp_parser> ();
4473 : 92004 : parser->lexer = lexer;
4474 : 92004 : parser->context = cp_parser_context_new (NULL);
4475 : :
4476 : : /* For now, we always accept GNU extensions. */
4477 : 92004 : parser->allow_gnu_extensions_p = 1;
4478 : :
4479 : : /* The `>' token is a greater-than operator, not the end of a
4480 : : template-id. */
4481 : 92004 : parser->greater_than_is_operator_p = true;
4482 : :
4483 : 92004 : parser->default_arg_ok_p = true;
4484 : :
4485 : : /* We are not parsing a constant-expression. */
4486 : 92004 : parser->integral_constant_expression_p = false;
4487 : 92004 : parser->allow_non_integral_constant_expression_p = false;
4488 : 92004 : parser->non_integral_constant_expression_p = false;
4489 : :
4490 : : /* Local variable names are not forbidden. */
4491 : 92004 : parser->local_variables_forbidden_p = 0;
4492 : :
4493 : : /* We are not processing an `extern "C"' declaration. */
4494 : 92004 : parser->in_unbraced_linkage_specification_p = false;
4495 : :
4496 : : /* We aren't parsing an export-declaration. */
4497 : 92004 : parser->in_unbraced_export_declaration_p = false;
4498 : :
4499 : : /* We are not processing a declarator. */
4500 : 92004 : parser->in_declarator_p = false;
4501 : :
4502 : : /* We are not processing a template-argument-list. */
4503 : 92004 : parser->in_template_argument_list_p = false;
4504 : :
4505 : : /* We are not in an iteration statement. */
4506 : 92004 : parser->in_statement = 0;
4507 : :
4508 : : /* We are not in a switch statement. */
4509 : 92004 : parser->in_switch_statement_p = false;
4510 : :
4511 : : /* We are not parsing a type-id inside an expression. */
4512 : 92004 : parser->in_type_id_in_expr_p = false;
4513 : :
4514 : : /* String literals should be translated to the execution character set. */
4515 : 92004 : parser->translate_strings_p = true;
4516 : :
4517 : : /* We are not parsing a function body. */
4518 : 92004 : parser->in_function_body = false;
4519 : :
4520 : : /* We can correct until told otherwise. */
4521 : 92004 : parser->colon_corrects_to_scope_p = true;
4522 : :
4523 : : /* The unparsed function queue is empty. */
4524 : 92004 : push_unparsed_function_queues (parser);
4525 : :
4526 : : /* There are no classes being defined. */
4527 : 92004 : parser->num_classes_being_defined = 0;
4528 : :
4529 : : /* No template parameters apply. */
4530 : 92004 : parser->num_template_parameter_lists = 0;
4531 : :
4532 : : /* Special parsing data structures. */
4533 : 92004 : parser->omp_declare_simd = NULL;
4534 : 92004 : parser->oacc_routine = NULL;
4535 : :
4536 : : /* Disallow OpenMP array sections in expressions. */
4537 : 92004 : parser->omp_array_section_p = false;
4538 : :
4539 : : /* Not declaring an implicit function template. */
4540 : 92004 : parser->auto_is_implicit_function_template_parm_p = false;
4541 : 92004 : parser->fully_implicit_function_template_p = false;
4542 : 92004 : parser->implicit_template_parms = 0;
4543 : 92004 : parser->implicit_template_scope = 0;
4544 : :
4545 : : /* Allow constrained-type-specifiers. */
4546 : 92004 : parser->prevent_constrained_type_specifiers = 0;
4547 : :
4548 : : /* We haven't yet seen an 'extern "C"'. */
4549 : 92004 : parser->innermost_linkage_specification_location = UNKNOWN_LOCATION;
4550 : :
4551 : 92004 : return parser;
4552 : : }
4553 : :
4554 : : /* Create a cp_lexer structure which will emit the tokens in CACHE
4555 : : and push it onto the parser's lexer stack. This is used for delayed
4556 : : parsing of in-class method bodies and default arguments, and should
4557 : : not be confused with tentative parsing. */
4558 : : static void
4559 : 73193314 : cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
4560 : : {
4561 : 73193314 : cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
4562 : 73193314 : lexer->next = parser->lexer;
4563 : 73193314 : parser->lexer = lexer;
4564 : :
4565 : : /* Move the current source position to that of the first token in the
4566 : : new lexer. */
4567 : 73193314 : cp_lexer_set_source_position_from_token (lexer->next_token);
4568 : 73193314 : }
4569 : :
4570 : : /* Pop the top lexer off the parser stack. This is never used for the
4571 : : "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
4572 : : static void
4573 : 73193314 : cp_parser_pop_lexer (cp_parser *parser)
4574 : : {
4575 : 73193314 : cp_lexer *lexer = parser->lexer;
4576 : 73193314 : parser->lexer = lexer->next;
4577 : 73193314 : cp_lexer_destroy (lexer);
4578 : :
4579 : : /* Put the current source position back where it was before this
4580 : : lexer was pushed. */
4581 : 73193314 : cp_lexer_set_source_position_from_token (parser->lexer->next_token);
4582 : 73193314 : }
4583 : :
4584 : : /* Lexical conventions [gram.lex] */
4585 : :
4586 : : /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
4587 : : identifier. */
4588 : :
4589 : : static cp_expr
4590 : 6020965999 : cp_parser_identifier (cp_parser* parser)
4591 : : {
4592 : 6020965999 : cp_token *token;
4593 : :
4594 : : /* Look for the identifier. */
4595 : 6020965999 : token = cp_parser_require (parser, CPP_NAME, RT_NAME);
4596 : : /* Return the value. */
4597 : 6020965999 : if (token)
4598 : 4806081617 : return cp_expr (token->u.value, token->location);
4599 : : else
4600 : 1214884382 : return error_mark_node;
4601 : : }
4602 : :
4603 : : /* Worker for cp_parser_string_literal, cp_parser_userdef_string_literal
4604 : : and cp_parser_unevaluated_string_literal.
4605 : : Do not call this directly; use either of the above.
4606 : :
4607 : : Parse a sequence of adjacent string constants. Return a
4608 : : TREE_STRING representing the combined, nul-terminated string
4609 : : constant. If TRANSLATE is true, translate the string to the
4610 : : execution character set. If WIDE_OK is true, a wide string is
4611 : : valid here. If UDL_OK is true, a string literal with user-defined
4612 : : suffix can be used in this context. If UNEVAL is true, diagnose
4613 : : numeric and conditional escape sequences in it if pedantic.
4614 : :
4615 : : C++98 [lex.string] says that if a narrow string literal token is
4616 : : adjacent to a wide string literal token, the behavior is undefined.
4617 : : However, C99 6.4.5p4 says that this results in a wide string literal.
4618 : : We follow C99 here, for consistency with the C front end.
4619 : :
4620 : : This code is largely lifted from lex_string() in c-lex.cc.
4621 : :
4622 : : FUTURE: ObjC++ will need to handle @-strings here. */
4623 : :
4624 : : static cp_expr
4625 : 18707477 : cp_parser_string_literal_common (cp_parser *parser, bool translate,
4626 : : bool wide_ok, bool udl_ok,
4627 : : bool lookup_udlit, bool uneval)
4628 : : {
4629 : 18707477 : tree value;
4630 : 18707477 : size_t count;
4631 : 18707477 : struct obstack str_ob;
4632 : 18707477 : struct obstack loc_ob;
4633 : 18707477 : cpp_string str, istr, *strs;
4634 : 18707477 : cp_token *tok;
4635 : 18707477 : enum cpp_ttype type, curr_type;
4636 : 18707477 : int have_suffix_p = 0;
4637 : 18707477 : tree string_tree;
4638 : 18707477 : tree suffix_id = NULL_TREE;
4639 : 18707477 : bool curr_tok_is_userdef_p = false;
4640 : :
4641 : 18707477 : tok = cp_lexer_peek_token (parser->lexer);
4642 : 18707477 : if (!cp_parser_is_string_literal (tok))
4643 : : {
4644 : 21 : cp_parser_error (parser, "expected string-literal");
4645 : 21 : return error_mark_node;
4646 : : }
4647 : :
4648 : 18707456 : location_t loc = tok->location;
4649 : :
4650 : 18707456 : if (cpp_userdef_string_p (tok->type))
4651 : : {
4652 : 541350 : if (!udl_ok)
4653 : : {
4654 : 4 : error_at (loc, "string literal with user-defined suffix "
4655 : : "is invalid in this context");
4656 : 4 : return error_mark_node;
4657 : : }
4658 : 541346 : string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
4659 : 541346 : curr_type = cpp_userdef_string_remove_type (tok->type);
4660 : 541346 : curr_tok_is_userdef_p = true;
4661 : : }
4662 : : else
4663 : : {
4664 : 18166106 : string_tree = tok->u.value;
4665 : 18166106 : curr_type = tok->type;
4666 : : }
4667 : 18707452 : type = curr_type;
4668 : :
4669 : : /* Try to avoid the overhead of creating and destroying an obstack
4670 : : for the common case of just one string. */
4671 : 37414904 : if (!cp_parser_is_string_literal
4672 : 18707452 : (cp_lexer_peek_nth_token (parser->lexer, 2)))
4673 : : {
4674 : 16751893 : cp_lexer_consume_token (parser->lexer);
4675 : :
4676 : 16751893 : str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
4677 : 16751893 : str.len = TREE_STRING_LENGTH (string_tree);
4678 : 16751893 : count = 1;
4679 : :
4680 : 16751893 : if (curr_tok_is_userdef_p)
4681 : : {
4682 : 541325 : suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
4683 : 541325 : have_suffix_p = 1;
4684 : 541325 : curr_type = cpp_userdef_string_remove_type (tok->type);
4685 : : }
4686 : : else
4687 : 18707450 : curr_type = tok->type;
4688 : :
4689 : : strs = &str;
4690 : : }
4691 : : else
4692 : : {
4693 : 1955559 : location_t last_tok_loc = tok->location;
4694 : 1955559 : gcc_obstack_init (&str_ob);
4695 : 1955559 : gcc_obstack_init (&loc_ob);
4696 : 1955559 : count = 0;
4697 : :
4698 : 5132451 : do
4699 : : {
4700 : 5132451 : cp_lexer_consume_token (parser->lexer);
4701 : 5132451 : count++;
4702 : 5132451 : str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
4703 : 5132451 : str.len = TREE_STRING_LENGTH (string_tree);
4704 : :
4705 : 5132451 : if (curr_tok_is_userdef_p)
4706 : : {
4707 : 116 : tree curr_suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
4708 : 116 : if (have_suffix_p == 0)
4709 : : {
4710 : : suffix_id = curr_suffix_id;
4711 : : have_suffix_p = 1;
4712 : : }
4713 : 15 : else if (have_suffix_p == 1
4714 : 15 : && curr_suffix_id != suffix_id)
4715 : : {
4716 : 9 : error ("inconsistent user-defined literal suffixes"
4717 : : " %qD and %qD in string literal",
4718 : : suffix_id, curr_suffix_id);
4719 : 9 : have_suffix_p = -1;
4720 : : }
4721 : 116 : curr_type = cpp_userdef_string_remove_type (tok->type);
4722 : : }
4723 : : else
4724 : 5132335 : curr_type = tok->type;
4725 : :
4726 : 5132451 : if (type != curr_type)
4727 : : {
4728 : 13025 : if (type == CPP_STRING)
4729 : : type = curr_type;
4730 : 12874 : else if (curr_type != CPP_STRING)
4731 : : {
4732 : 78 : rich_location rich_loc (line_table, tok->location);
4733 : 78 : rich_loc.add_range (last_tok_loc);
4734 : 78 : error_at (&rich_loc,
4735 : : "concatenation of string literals with "
4736 : : "conflicting encoding prefixes");
4737 : 78 : }
4738 : : }
4739 : :
4740 : 5132451 : obstack_grow (&str_ob, &str, sizeof (cpp_string));
4741 : 5132451 : obstack_grow (&loc_ob, &tok->location, sizeof (location_t));
4742 : :
4743 : 5132451 : last_tok_loc = tok->location;
4744 : :
4745 : 5132451 : tok = cp_lexer_peek_token (parser->lexer);
4746 : 5132451 : if (cpp_userdef_string_p (tok->type))
4747 : : {
4748 : 97 : if (!udl_ok)
4749 : : {
4750 : 2 : error_at (loc, "string literal with user-defined suffix "
4751 : : "is invalid in this context");
4752 : 2 : return error_mark_node;
4753 : : }
4754 : 95 : string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
4755 : 95 : curr_type = cpp_userdef_string_remove_type (tok->type);
4756 : 95 : curr_tok_is_userdef_p = true;
4757 : : }
4758 : : else
4759 : : {
4760 : 5132354 : string_tree = tok->u.value;
4761 : 5132354 : curr_type = tok->type;
4762 : 5132354 : curr_tok_is_userdef_p = false;
4763 : : }
4764 : : }
4765 : 5132449 : while (cp_parser_is_string_literal (tok));
4766 : :
4767 : : /* A string literal built by concatenation has its caret=start at
4768 : : the start of the initial string, and its finish at the finish of
4769 : : the final string literal. */
4770 : 1955557 : loc = make_location (loc, loc, get_finish (last_tok_loc));
4771 : :
4772 : 1955557 : strs = (cpp_string *) obstack_finish (&str_ob);
4773 : : }
4774 : :
4775 : 18707450 : if (type != CPP_STRING && !wide_ok)
4776 : : {
4777 : 74 : cp_parser_error (parser, "a wide string is invalid in this context");
4778 : 74 : type = CPP_STRING;
4779 : : }
4780 : 18707450 : if (uneval)
4781 : 539116 : type = CPP_UNEVAL_STRING;
4782 : :
4783 : 37414900 : if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
4784 : 18707450 : (parse_in, strs, count, &istr, type))
4785 : : {
4786 : 18707446 : value = build_string (istr.len, (const char *)istr.text);
4787 : 18707446 : free (CONST_CAST (unsigned char *, istr.text));
4788 : 18707446 : if (count > 1)
4789 : : {
4790 : 1955557 : location_t *locs = (location_t *)obstack_finish (&loc_ob);
4791 : 1955557 : gcc_assert (g_string_concat_db);
4792 : 1955557 : g_string_concat_db->record_string_concatenation (count, locs);
4793 : : }
4794 : :
4795 : 18707446 : switch (type)
4796 : : {
4797 : 18579831 : default:
4798 : 18579831 : case CPP_STRING:
4799 : 18579831 : TREE_TYPE (value) = char_array_type_node;
4800 : 18579831 : break;
4801 : 658 : case CPP_UTF8STRING:
4802 : 658 : if (flag_char8_t)
4803 : 278 : TREE_TYPE (value) = char8_array_type_node;
4804 : : else
4805 : 380 : TREE_TYPE (value) = char_array_type_node;
4806 : : break;
4807 : 640 : case CPP_STRING16:
4808 : 640 : TREE_TYPE (value) = char16_array_type_node;
4809 : 640 : break;
4810 : 697 : case CPP_STRING32:
4811 : 697 : TREE_TYPE (value) = char32_array_type_node;
4812 : 697 : break;
4813 : 125620 : case CPP_WSTRING:
4814 : 125620 : TREE_TYPE (value) = wchar_array_type_node;
4815 : 125620 : break;
4816 : : }
4817 : :
4818 : 18707446 : value = fix_string_type (value);
4819 : :
4820 : 18707446 : if (have_suffix_p)
4821 : : {
4822 : 541426 : tree literal = build_userdef_literal (suffix_id, value,
4823 : : OT_NONE, NULL_TREE);
4824 : 541426 : if (lookup_udlit)
4825 : 899 : value = finish_userdef_string_literal (literal);
4826 : : else
4827 : : value = literal;
4828 : : }
4829 : : }
4830 : : else
4831 : : /* cpp_interpret_string has issued an error. */
4832 : 4 : value = error_mark_node;
4833 : :
4834 : 18707450 : if (count > 1)
4835 : : {
4836 : 1955557 : obstack_free (&str_ob, 0);
4837 : 1955557 : obstack_free (&loc_ob, 0);
4838 : : }
4839 : :
4840 : 18707450 : return cp_expr (value, loc);
4841 : : }
4842 : :
4843 : : /* Parse a sequence of adjacent string constants. Return a TREE_STRING
4844 : : representing the combined, nul-terminated string constant. If
4845 : : TRANSLATE is true, translate the string to the execution character set.
4846 : : If WIDE_OK is true, a wide string is valid here.
4847 : :
4848 : : This function issues an error if a user defined string literal is
4849 : : encountered; use cp_parser_userdef_string_literal if UDLs are allowed. */
4850 : :
4851 : : static inline cp_expr
4852 : 11805483 : cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
4853 : : {
4854 : 15394890 : return cp_parser_string_literal_common (parser, translate, wide_ok,
4855 : : /*udl_ok=*/false,
4856 : : /*lookup_udlit=*/false,
4857 : : /*uneval=*/false);
4858 : : }
4859 : :
4860 : : /* Parse a string literal or user defined string literal.
4861 : :
4862 : : user-defined-string-literal :
4863 : : string-literal ud-suffix
4864 : :
4865 : : If LOOKUP_UDLIT, perform a lookup for a suitable template function. */
4866 : :
4867 : : static inline cp_expr
4868 : 6362857 : cp_parser_userdef_string_literal (cp_parser *parser, bool lookup_udlit)
4869 : : {
4870 : 6362857 : return cp_parser_string_literal_common (parser, /*translate=*/true,
4871 : : /*wide_ok=*/true, /*udl_ok=*/true,
4872 : 6362857 : lookup_udlit, /*uneval=*/false);
4873 : : }
4874 : :
4875 : : /* Parse an unevaluated string literal.
4876 : :
4877 : : unevaluated-string:
4878 : : string-literal */
4879 : :
4880 : : static inline cp_expr
4881 : 539137 : cp_parser_unevaluated_string_literal (cp_parser *parser)
4882 : : {
4883 : 539137 : return cp_parser_string_literal_common (parser, /*translate=*/false,
4884 : : /*wide_ok=*/false, /*udl_ok=*/false,
4885 : : /*lookup_udlit=*/false,
4886 : 539137 : /*uneval=*/true);
4887 : : }
4888 : :
4889 : : /* Look up a literal operator with the name and the exact arguments. */
4890 : :
4891 : : static tree
4892 : 258592 : lookup_literal_operator (tree name, vec<tree, va_gc> *args)
4893 : : {
4894 : 258592 : tree decl = lookup_name (name);
4895 : 258592 : if (!decl || !is_overloaded_fn (decl))
4896 : 94978 : return error_mark_node;
4897 : :
4898 : 621401 : for (lkp_iterator iter (decl); iter; ++iter)
4899 : : {
4900 : 516357 : tree fn = *iter;
4901 : :
4902 : 516357 : if (tree parmtypes = TYPE_ARG_TYPES (TREE_TYPE (fn)))
4903 : : {
4904 : : unsigned int ix;
4905 : : bool found = true;
4906 : :
4907 : : for (ix = 0;
4908 : 1460962 : found && ix < vec_safe_length (args) && parmtypes != NULL_TREE;
4909 : 402931 : ++ix, parmtypes = TREE_CHAIN (parmtypes))
4910 : : {
4911 : 402931 : tree tparm = TREE_VALUE (parmtypes);
4912 : 402931 : tree targ = TREE_TYPE ((*args)[ix]);
4913 : 402931 : bool ptr = TYPE_PTR_P (tparm);
4914 : 402931 : bool arr = TREE_CODE (targ) == ARRAY_TYPE;
4915 : 111060 : if ((ptr || arr || !same_type_p (tparm, targ))
4916 : 507891 : && (!ptr || !arr
4917 : 94738 : || !same_type_p (TREE_TYPE (tparm),
4918 : : TREE_TYPE (targ))))
4919 : : found = false;
4920 : : }
4921 : :
4922 : 516357 : if (found
4923 : 138743 : && ix == vec_safe_length (args)
4924 : : /* May be this should be sufficient_parms_p instead,
4925 : : depending on how exactly should user-defined literals
4926 : : work in presence of default arguments on the literal
4927 : : operator parameters. */
4928 : 655100 : && parmtypes == void_list_node)
4929 : 58570 : return decl;
4930 : : }
4931 : : }
4932 : :
4933 : 105044 : return error_mark_node;
4934 : : }
4935 : :
4936 : : /* Parse a user-defined char constant. Returns a call to a user-defined
4937 : : literal operator taking the character as an argument. */
4938 : :
4939 : : static cp_expr
4940 : 102 : cp_parser_userdef_char_literal (cp_parser *parser)
4941 : : {
4942 : 102 : cp_token *token = cp_lexer_consume_token (parser->lexer);
4943 : 102 : tree literal = token->u.value;
4944 : 102 : tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
4945 : 102 : tree value = USERDEF_LITERAL_VALUE (literal);
4946 : 102 : tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
4947 : 102 : tree decl, result;
4948 : :
4949 : : /* Build up a call to the user-defined operator */
4950 : : /* Lookup the name we got back from the id-expression. */
4951 : 102 : releasing_vec args;
4952 : 102 : vec_safe_push (args, value);
4953 : 102 : decl = lookup_literal_operator (name, args);
4954 : 102 : if (!decl || decl == error_mark_node)
4955 : : {
4956 : 62 : error ("unable to find character literal operator %qD with %qT argument",
4957 : 62 : name, TREE_TYPE (value));
4958 : 62 : return error_mark_node;
4959 : : }
4960 : 40 : result = finish_call_expr (decl, &args, false, true, tf_warning_or_error);
4961 : 40 : return result;
4962 : 102 : }
4963 : :
4964 : : /* A subroutine of cp_parser_userdef_numeric_literal to
4965 : : create a char... template parameter pack from a string node. */
4966 : :
4967 : : static tree
4968 : 52358 : make_char_string_pack (tree value)
4969 : : {
4970 : 52358 : tree charvec;
4971 : 52358 : tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
4972 : 52358 : const unsigned char *str
4973 : 52358 : = (const unsigned char *) TREE_STRING_POINTER (value);
4974 : 52358 : int i, len = TREE_STRING_LENGTH (value) - 1;
4975 : 52358 : tree argvec = make_tree_vec (1);
4976 : :
4977 : : /* Fill in CHARVEC with all of the parameters. */
4978 : 52358 : charvec = make_tree_vec (len);
4979 : 216922 : for (i = 0; i < len; ++i)
4980 : : {
4981 : 164564 : unsigned char s[3] = { '\'', str[i], '\'' };
4982 : 164564 : cpp_string in = { 3, s };
4983 : 164564 : cpp_string out = { 0, 0 };
4984 : 164564 : if (!cpp_interpret_string (parse_in, &in, 1, &out, CPP_STRING))
4985 : 0 : return NULL_TREE;
4986 : 164564 : gcc_assert (out.len == 2);
4987 : 164564 : TREE_VEC_ELT (charvec, i) = build_int_cst (char_type_node,
4988 : 164564 : out.text[0]);
4989 : : }
4990 : :
4991 : : /* Build the argument packs. */
4992 : 52358 : ARGUMENT_PACK_ARGS (argpack) = charvec;
4993 : :
4994 : 52358 : TREE_VEC_ELT (argvec, 0) = argpack;
4995 : :
4996 : 52358 : return argvec;
4997 : : }
4998 : :
4999 : : /* A subroutine of cp_parser_userdef_numeric_literal to
5000 : : create a char... template parameter pack from a string node. */
5001 : :
5002 : : static tree
5003 : 64 : make_string_pack (tree value)
5004 : : {
5005 : 64 : tree charvec;
5006 : 64 : tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
5007 : 64 : const unsigned char *str
5008 : 64 : = (const unsigned char *) TREE_STRING_POINTER (value);
5009 : 64 : int sz = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value))));
5010 : 64 : int len = TREE_STRING_LENGTH (value) / sz - 1;
5011 : 64 : tree argvec = make_tree_vec (2);
5012 : :
5013 : 64 : tree str_char_type_node = TREE_TYPE (TREE_TYPE (value));
5014 : 64 : str_char_type_node = TYPE_MAIN_VARIANT (str_char_type_node);
5015 : :
5016 : : /* First template parm is character type. */
5017 : 64 : TREE_VEC_ELT (argvec, 0) = str_char_type_node;
5018 : :
5019 : : /* Fill in CHARVEC with all of the parameters. */
5020 : 64 : charvec = make_tree_vec (len);
5021 : 256 : for (int i = 0; i < len; ++i)
5022 : 192 : TREE_VEC_ELT (charvec, i)
5023 : 384 : = double_int_to_tree (str_char_type_node,
5024 : 192 : double_int::from_buffer (str + i * sz, sz));
5025 : :
5026 : : /* Build the argument packs. */
5027 : 64 : ARGUMENT_PACK_ARGS (argpack) = charvec;
5028 : :
5029 : 64 : TREE_VEC_ELT (argvec, 1) = argpack;
5030 : :
5031 : 64 : return argvec;
5032 : : }
5033 : :
5034 : : /* Parse a user-defined numeric constant. returns a call to a user-defined
5035 : : literal operator. */
5036 : :
5037 : : static cp_expr
5038 : 89368 : cp_parser_userdef_numeric_literal (cp_parser *parser)
5039 : : {
5040 : 89368 : cp_token *token = cp_lexer_consume_token (parser->lexer);
5041 : 89368 : tree literal = token->u.value;
5042 : 89368 : tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
5043 : 89368 : tree value = USERDEF_LITERAL_VALUE (literal);
5044 : 89368 : int overflow = USERDEF_LITERAL_OVERFLOW (literal);
5045 : 89368 : tree num_string = USERDEF_LITERAL_NUM_STRING (literal);
5046 : 89368 : tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
5047 : 89368 : tree decl, result;
5048 : :
5049 : : /* Look for a literal operator taking the exact type of numeric argument
5050 : : as the literal value. */
5051 : 89368 : releasing_vec args;
5052 : 89368 : vec_safe_push (args, value);
5053 : 89368 : decl = lookup_literal_operator (name, args);
5054 : 89368 : if (decl && decl != error_mark_node)
5055 : : {
5056 : 5313 : result = finish_call_expr (decl, &args, false, true,
5057 : : tf_warning_or_error);
5058 : :
5059 : 5313 : if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE && overflow > 0)
5060 : : {
5061 : 3 : warning_at (token->location, OPT_Woverflow,
5062 : : "integer literal exceeds range of %qT type",
5063 : : long_long_unsigned_type_node);
5064 : : }
5065 : : else
5066 : : {
5067 : 5310 : if (overflow > 0)
5068 : 3 : warning_at (token->location, OPT_Woverflow,
5069 : : "floating literal exceeds range of %qT type",
5070 : : long_double_type_node);
5071 : 5307 : else if (overflow < 0)
5072 : 3 : warning_at (token->location, OPT_Woverflow,
5073 : : "floating literal truncated to zero");
5074 : : }
5075 : :
5076 : 5313 : return result;
5077 : : }
5078 : :
5079 : : /* If the numeric argument didn't work, look for a raw literal
5080 : : operator taking a const char* argument consisting of the number
5081 : : in string format. */
5082 : 84055 : args->truncate (0);
5083 : 84055 : vec_safe_push (args, num_string);
5084 : 84055 : decl = lookup_literal_operator (name, args);
5085 : 84055 : if (decl && decl != error_mark_node)
5086 : : {
5087 : 39 : result = finish_call_expr (decl, &args, false, true,
5088 : : tf_warning_or_error);
5089 : 39 : return result;
5090 : : }
5091 : :
5092 : : /* If the raw literal didn't work, look for a non-type template
5093 : : function with parameter pack char.... Call the function with
5094 : : template parameter characters representing the number. */
5095 : 84016 : args->truncate (0);
5096 : 84016 : decl = lookup_literal_operator (name, args);
5097 : 84016 : if (decl && decl != error_mark_node)
5098 : : {
5099 : 52358 : tree tmpl_args = make_char_string_pack (num_string);
5100 : 52358 : if (tmpl_args == NULL_TREE)
5101 : : {
5102 : 0 : error ("failed to translate literal to execution character set %qT",
5103 : : num_string);
5104 : 0 : return error_mark_node;
5105 : : }
5106 : 52358 : decl = lookup_template_function (decl, tmpl_args);
5107 : 52358 : result = finish_call_expr (decl, &args, false, true,
5108 : : tf_warning_or_error);
5109 : 52358 : return result;
5110 : : }
5111 : :
5112 : : /* In C++14 the standard library defines complex number suffixes that
5113 : : conflict with GNU extensions. Prefer them if <complex> is #included. */
5114 : 31658 : bool ext = cpp_get_options (parse_in)->ext_numeric_literals;
5115 : 31658 : bool i14 = (cxx_dialect > cxx11
5116 : 31658 : && (id_equal (suffix_id, "i")
5117 : 21054 : || id_equal (suffix_id, "if")
5118 : 10546 : || id_equal (suffix_id, "il")));
5119 : 31615 : diagnostic_t kind = DK_ERROR;
5120 : 31615 : int opt = 0;
5121 : :
5122 : 31615 : if (i14 && ext)
5123 : : {
5124 : 31611 : tree cxlit = lookup_qualified_name (std_node, "complex_literals",
5125 : : LOOK_want::NORMAL, false);
5126 : 31611 : if (cxlit == error_mark_node)
5127 : : {
5128 : : /* No <complex>, so pedwarn and use GNU semantics. */
5129 : 31658 : kind = DK_PEDWARN;
5130 : 31658 : opt = OPT_Wpedantic;
5131 : : }
5132 : : }
5133 : :
5134 : 31658 : {
5135 : 31658 : auto_diagnostic_group d;
5136 : 31658 : bool complained
5137 : 31658 : = emit_diagnostic (kind, input_location, opt,
5138 : : "unable to find numeric literal operator %qD", name);
5139 : :
5140 : 31658 : if (!complained)
5141 : : /* Don't inform either. */;
5142 : 62 : else if (i14)
5143 : : {
5144 : 19 : inform (token->location, "add %<using namespace std::complex_literals%> "
5145 : : "(from %<<complex>%>) to enable the C++14 user-defined literal "
5146 : : "suffixes");
5147 : 19 : if (ext)
5148 : 15 : inform (token->location, "or use %<j%> instead of %<i%> for the "
5149 : : "GNU built-in suffix");
5150 : : }
5151 : 43 : else if (!ext)
5152 : 36 : inform (token->location, "use %<-fext-numeric-literals%> "
5153 : : "to enable more built-in suffixes");
5154 : 31658 : }
5155 : :
5156 : 31658 : if (kind == DK_ERROR)
5157 : 50 : value = error_mark_node;
5158 : : else
5159 : : {
5160 : : /* Use the built-in semantics. */
5161 : 31608 : tree type;
5162 : 31608 : if (id_equal (suffix_id, "i"))
5163 : : {
5164 : 10582 : if (TREE_CODE (value) == INTEGER_CST)
5165 : 46 : type = integer_type_node;
5166 : : else
5167 : 10536 : type = double_type_node;
5168 : : }
5169 : 21026 : else if (id_equal (suffix_id, "if"))
5170 : 10508 : type = float_type_node;
5171 : : else /* if (id_equal (suffix_id, "il")) */
5172 : 10518 : type = long_double_type_node;
5173 : :
5174 : 31608 : value = fold_build2 (COMPLEX_EXPR, build_complex_type (type),
5175 : : build_zero_cst (type), fold_convert (type, value));
5176 : : }
5177 : :
5178 : 63349 : if (cp_parser_uncommitted_to_tentative_parse_p (parser))
5179 : : /* Avoid repeated diagnostics. */
5180 : 33 : token->u.value = value;
5181 : 31658 : return value;
5182 : 89368 : }
5183 : :
5184 : : /* Parse a user-defined string constant. Returns a call to a user-defined
5185 : : literal operator taking a character pointer and the length of the string
5186 : : as arguments. */
5187 : :
5188 : : static tree
5189 : 899 : finish_userdef_string_literal (tree literal)
5190 : : {
5191 : 899 : tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
5192 : 899 : tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
5193 : 899 : tree value = USERDEF_LITERAL_VALUE (literal);
5194 : 899 : int len = TREE_STRING_LENGTH (value)
5195 : 899 : / TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value)))) - 1;
5196 : 899 : tree decl;
5197 : :
5198 : : /* Build up a call to the user-defined operator. */
5199 : : /* Lookup the name we got back from the id-expression. */
5200 : 899 : releasing_vec args;
5201 : 899 : vec_safe_push (args, value);
5202 : 899 : vec_safe_push (args, build_int_cst (size_type_node, len));
5203 : 899 : decl = lookup_literal_operator (name, args);
5204 : :
5205 : 899 : if (decl && decl != error_mark_node)
5206 : 747 : return finish_call_expr (decl, &args, false, true,
5207 : 747 : tf_warning_or_error);
5208 : :
5209 : : /* Look for a suitable template function, either (C++20) with a single
5210 : : parameter of class type, or (N3599) with typename parameter CharT and
5211 : : parameter pack CharT... */
5212 : 152 : args->truncate (0);
5213 : 152 : decl = lookup_literal_operator (name, args);
5214 : 152 : if (decl && decl != error_mark_node)
5215 : : {
5216 : : /* Use resolve_nondeduced_context to try to choose one form of template
5217 : : or the other. */
5218 : 73 : tree tmpl_args = make_tree_vec (1);
5219 : 73 : TREE_VEC_ELT (tmpl_args, 0) = value;
5220 : 73 : decl = lookup_template_function (decl, tmpl_args);
5221 : 73 : tree res = resolve_nondeduced_context (decl, tf_none);
5222 : 73 : if (DECL_P (res))
5223 : : decl = res;
5224 : : else
5225 : : {
5226 : 64 : TREE_OPERAND (decl, 1) = make_string_pack (value);
5227 : 64 : res = resolve_nondeduced_context (decl, tf_none);
5228 : 64 : if (DECL_P (res))
5229 : 58 : decl = res;
5230 : : }
5231 : 73 : if (!DECL_P (decl) && cxx_dialect > cxx17)
5232 : 4 : TREE_OPERAND (decl, 1) = tmpl_args;
5233 : 73 : return finish_call_expr (decl, &args, false, true,
5234 : 73 : tf_warning_or_error);
5235 : : }
5236 : :
5237 : 79 : error ("unable to find string literal operator %qD with %qT, %qT arguments",
5238 : 79 : name, TREE_TYPE (value), size_type_node);
5239 : 79 : return error_mark_node;
5240 : 899 : }
5241 : :
5242 : :
5243 : : /* Basic concepts [gram.basic] */
5244 : :
5245 : : /* Parse a translation-unit.
5246 : :
5247 : : translation-unit:
5248 : : declaration-seq [opt] */
5249 : :
5250 : : static void
5251 : 90743 : cp_parser_translation_unit (cp_parser* parser)
5252 : : {
5253 : 90743 : gcc_checking_assert (!cp_error_declarator);
5254 : :
5255 : : /* Create the declarator obstack. */
5256 : 90743 : gcc_obstack_init (&declarator_obstack);
5257 : : /* Create the error declarator. */
5258 : 90743 : cp_error_declarator = make_declarator (cdk_error);
5259 : : /* Create the empty parameter list. */
5260 : 90743 : no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE,
5261 : : UNKNOWN_LOCATION);
5262 : : /* Remember where the base of the declarator obstack lies. */
5263 : 90743 : void *declarator_obstack_base = obstack_next_free (&declarator_obstack);
5264 : :
5265 : 90749 : push_deferring_access_checks (flag_access_control
5266 : : ? dk_no_deferred : dk_no_check);
5267 : :
5268 : 90743 : module_parse mp_state = MP_NOT_MODULE;
5269 : 90743 : if (modules_p () && !header_module_p ())
5270 : : mp_state = MP_FIRST;
5271 : :
5272 : : bool implicit_extern_c = false;
5273 : :
5274 : : /* Parse until EOF. */
5275 : 8964132 : for (;;)
5276 : : {
5277 : 8964132 : cp_token *token = cp_lexer_peek_token (parser->lexer);
5278 : :
5279 : : /* If we're entering or exiting a region that's implicitly
5280 : : extern "C", modify the lang context appropriately. This is
5281 : : so horrible. Please die. */
5282 : 8964132 : if (implicit_extern_c
5283 : 8964132 : != cp_lexer_peek_token (parser->lexer)->implicit_extern_c)
5284 : : {
5285 : 0 : implicit_extern_c = !implicit_extern_c;
5286 : 0 : if (implicit_extern_c)
5287 : 0 : push_lang_context (lang_name_c);
5288 : : else
5289 : 0 : pop_lang_context ();
5290 : : }
5291 : :
5292 : 8964132 : if (token->type == CPP_EOF)
5293 : : break;
5294 : :
5295 : 8873474 : if (modules_p ())
5296 : : {
5297 : : /* Top-level module declarations are ok, and change the
5298 : : portion of file we're in. Top-level import declarations
5299 : : are significant for the import portions. */
5300 : :
5301 : 51205 : cp_token *next = token;
5302 : 51205 : bool exporting = token->keyword == RID__EXPORT;
5303 : 51205 : if (exporting)
5304 : : {
5305 : 1618 : cp_lexer_consume_token (parser->lexer);
5306 : 1618 : next = cp_lexer_peek_token (parser->lexer);
5307 : : }
5308 : 51205 : if (next->keyword == RID__MODULE)
5309 : : {
5310 : 2035 : mp_state
5311 : 2035 : = cp_parser_module_declaration (parser, mp_state, exporting);
5312 : 2035 : continue;
5313 : : }
5314 : 49170 : else if (next->keyword == RID__IMPORT)
5315 : : {
5316 : 1979 : if (mp_state == MP_FIRST)
5317 : 951 : mp_state = MP_NOT_MODULE;
5318 : 1979 : cp_parser_import_declaration (parser, mp_state, exporting);
5319 : 1951 : continue;
5320 : : }
5321 : : else
5322 : 47191 : gcc_checking_assert (!exporting);
5323 : :
5324 : 47191 : if (mp_state == MP_GLOBAL && token->main_source_p)
5325 : : {
5326 : 184 : static bool warned = false;
5327 : 184 : if (!warned)
5328 : : {
5329 : 107 : warned = true;
5330 : 107 : pedwarn (token->location, OPT_Wglobal_module,
5331 : : "global module fragment contents must be"
5332 : : " from preprocessor inclusion");
5333 : : }
5334 : : }
5335 : : }
5336 : :
5337 : : /* This relies on the ordering of module_parse values. */
5338 : 8869460 : if (mp_state == MP_PURVIEW_IMPORTS || mp_state == MP_PRIVATE_IMPORTS)
5339 : : /* We're no longer in the import portion of a named module. */
5340 : 1462 : mp_state = module_parse (mp_state + 1);
5341 : 8867998 : else if (mp_state == MP_FIRST)
5342 : 300 : mp_state = MP_NOT_MODULE;
5343 : :
5344 : 8869460 : if (token->type == CPP_CLOSE_BRACE)
5345 : : {
5346 : 75 : cp_parser_error (parser, "expected declaration");
5347 : 75 : cp_lexer_consume_token (parser->lexer);
5348 : : /* If the next token is now a `;', consume it. */
5349 : 75 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
5350 : 12 : cp_lexer_consume_token (parser->lexer);
5351 : : }
5352 : : else
5353 : 8869385 : cp_parser_toplevel_declaration (parser);
5354 : : }
5355 : :
5356 : : /* Get rid of the token array; we don't need it any more. */
5357 : 90658 : cp_lexer_destroy (parser->lexer);
5358 : 90658 : parser->lexer = NULL;
5359 : :
5360 : : /* The EOF should have reset this. */
5361 : 90658 : gcc_checking_assert (!implicit_extern_c);
5362 : :
5363 : : /* Make sure the declarator obstack was fully cleaned up. */
5364 : 90658 : gcc_assert (obstack_next_free (&declarator_obstack)
5365 : : == declarator_obstack_base);
5366 : 90658 : }
5367 : :
5368 : : /* Return the appropriate tsubst flags for parsing, possibly in N3276
5369 : : decltype context. */
5370 : :
5371 : : static inline tsubst_flags_t
5372 : 411661068 : complain_flags (bool decltype_p)
5373 : : {
5374 : 411661068 : tsubst_flags_t complain = tf_warning_or_error;
5375 : 411661068 : if (decltype_p)
5376 : 4815301 : complain |= tf_decltype;
5377 : 411661068 : return complain;
5378 : : }
5379 : :
5380 : : /* We're about to parse a collection of statements. If we're currently
5381 : : parsing tentatively, set up a firewall so that any nested
5382 : : cp_parser_commit_to_tentative_parse won't affect the current context. */
5383 : :
5384 : : static cp_token_position
5385 : 627886 : cp_parser_start_tentative_firewall (cp_parser *parser)
5386 : : {
5387 : 1270226 : if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
5388 : : return 0;
5389 : :
5390 : 14454 : cp_parser_parse_tentatively (parser);
5391 : 14454 : cp_parser_commit_to_topmost_tentative_parse (parser);
5392 : 14454 : return cp_lexer_token_position (parser->lexer, false);
5393 : : }
5394 : :
5395 : : /* We've finished parsing the collection of statements. Wrap up the
5396 : : firewall and replace the relevant tokens with the parsed form. */
5397 : :
5398 : : static void
5399 : 627886 : cp_parser_end_tentative_firewall (cp_parser *parser, cp_token_position start,
5400 : : tree expr)
5401 : : {
5402 : 627886 : if (!start)
5403 : : return;
5404 : :
5405 : : /* Finish the firewall level. */
5406 : 14454 : cp_parser_parse_definitely (parser);
5407 : : /* And remember the result of the parse for when we try again. */
5408 : 14454 : cp_token *token = cp_lexer_token_at (parser->lexer, start);
5409 : 14454 : token->type = CPP_PREPARSED_EXPR;
5410 : 14454 : token->u.value = expr;
5411 : 14454 : token->keyword = RID_MAX;
5412 : 14454 : cp_lexer_purge_tokens_after (parser->lexer, start);
5413 : : }
5414 : :
5415 : : /* Like the above functions, but let the user modify the tokens. Used by
5416 : : CPP_DECLTYPE and CPP_TEMPLATE_ID, where we are saving the side-effects for
5417 : : later parses, so it makes sense to localize the effects of
5418 : : cp_parser_commit_to_tentative_parse. */
5419 : :
5420 : : struct tentative_firewall
5421 : : {
5422 : : cp_parser *parser;
5423 : : bool set;
5424 : :
5425 : 205664065 : tentative_firewall (cp_parser *p): parser(p)
5426 : : {
5427 : : /* If we're currently parsing tentatively, start a committed level as a
5428 : : firewall and then an inner tentative parse. */
5429 : 205664065 : if ((set = cp_parser_uncommitted_to_tentative_parse_p (parser)))
5430 : : {
5431 : 199496534 : cp_parser_parse_tentatively (parser);
5432 : 199496534 : cp_parser_commit_to_topmost_tentative_parse (parser);
5433 : 199496534 : cp_parser_parse_tentatively (parser);
5434 : : }
5435 : 205664065 : }
5436 : :
5437 : 205664062 : ~tentative_firewall()
5438 : : {
5439 : 205664062 : if (set)
5440 : : {
5441 : : /* Finish the inner tentative parse and the firewall, propagating any
5442 : : uncommitted error state to the outer tentative parse. */
5443 : 398993062 : bool err = cp_parser_error_occurred (parser);
5444 : 199496531 : cp_parser_parse_definitely (parser);
5445 : 199496531 : cp_parser_parse_definitely (parser);
5446 : 199496531 : if (err)
5447 : 217595410 : cp_parser_simulate_error (parser);
5448 : : }
5449 : 205664062 : }
5450 : : };
5451 : :
5452 : : /* Some tokens naturally come in pairs e.g.'(' and ')'.
5453 : : This class is for tracking such a matching pair of symbols.
5454 : : In particular, it tracks the location of the first token,
5455 : : so that if the second token is missing, we can highlight the
5456 : : location of the first token when notifying the user about the
5457 : : problem. */
5458 : :
5459 : : template <typename traits_t>
5460 : : class token_pair
5461 : : {
5462 : : public:
5463 : : /* token_pair's ctor. */
5464 : 865911754 : token_pair () : m_open_loc (UNKNOWN_LOCATION) {}
5465 : :
5466 : : /* If the next token is the opening symbol for this pair, consume it and
5467 : : return true.
5468 : : Otherwise, issue an error and return false.
5469 : : In either case, record the location of the opening token. */
5470 : :
5471 : 559859128 : bool require_open (cp_parser *parser)
5472 : : {
5473 : 559859128 : m_open_loc = cp_lexer_peek_token (parser->lexer)->location;
5474 : 559859128 : return cp_parser_require (parser, traits_t::open_token_type,
5475 : 559859128 : traits_t::required_token_open);
5476 : : }
5477 : :
5478 : : /* Consume the next token from PARSER, recording its location as
5479 : : that of the opening token within the pair. */
5480 : :
5481 : 306040867 : cp_token * consume_open (cp_parser *parser)
5482 : : {
5483 : 306040867 : cp_token *tok = cp_lexer_consume_token (parser->lexer);
5484 : 306040867 : gcc_assert (tok->type == traits_t::open_token_type);
5485 : 306040867 : m_open_loc = tok->location;
5486 : 306040867 : return tok;
5487 : : }
5488 : :
5489 : : /* If the next token is the closing symbol for this pair, consume it
5490 : : and return it.
5491 : : Otherwise, issue an error, highlighting the location of the
5492 : : corresponding opening token, and return NULL. */
5493 : :
5494 : 797686783 : cp_token *require_close (cp_parser *parser) const
5495 : : {
5496 : 797686783 : return cp_parser_require (parser, traits_t::close_token_type,
5497 : : traits_t::required_token_close,
5498 : 365529320 : m_open_loc);
5499 : : }
5500 : :
5501 : : location_t open_location () const { return m_open_loc; }
5502 : :
5503 : : private:
5504 : : location_t m_open_loc;
5505 : : };
5506 : :
5507 : : /* Traits for token_pair<T> for tracking matching pairs of parentheses. */
5508 : :
5509 : : struct matching_paren_traits
5510 : : {
5511 : : static const enum cpp_ttype open_token_type = CPP_OPEN_PAREN;
5512 : : static const enum required_token required_token_open = RT_OPEN_PAREN;
5513 : : static const enum cpp_ttype close_token_type = CPP_CLOSE_PAREN;
5514 : : static const enum required_token required_token_close = RT_CLOSE_PAREN;
5515 : : };
5516 : :
5517 : : /* "matching_parens" is a token_pair<T> class for tracking matching
5518 : : pairs of parentheses. */
5519 : :
5520 : : typedef token_pair<matching_paren_traits> matching_parens;
5521 : :
5522 : : /* Traits for token_pair<T> for tracking matching pairs of braces. */
5523 : :
5524 : : struct matching_brace_traits
5525 : : {
5526 : : static const enum cpp_ttype open_token_type = CPP_OPEN_BRACE;
5527 : : static const enum required_token required_token_open = RT_OPEN_BRACE;
5528 : : static const enum cpp_ttype close_token_type = CPP_CLOSE_BRACE;
5529 : : static const enum required_token required_token_close = RT_CLOSE_BRACE;
5530 : : };
5531 : :
5532 : : /* "matching_braces" is a token_pair<T> class for tracking matching
5533 : : pairs of braces. */
5534 : :
5535 : : typedef token_pair<matching_brace_traits> matching_braces;
5536 : :
5537 : :
5538 : : /* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
5539 : : enclosing parentheses. */
5540 : :
5541 : : static cp_expr
5542 : 28940 : cp_parser_statement_expr (cp_parser *parser)
5543 : : {
5544 : 28940 : cp_token_position start = cp_parser_start_tentative_firewall (parser);
5545 : 28940 : auto oas = make_temp_override (parser->omp_array_section_p, false);
5546 : :
5547 : : /* Consume the '('. */
5548 : 28940 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
5549 : 28940 : matching_parens parens;
5550 : 28940 : parens.consume_open (parser);
5551 : : /* Start the statement-expression. */
5552 : 28940 : tree expr = begin_stmt_expr ();
5553 : : /* Parse the compound-statement. */
5554 : 28940 : cp_parser_compound_statement (parser, expr, BCS_STMT_EXPR, false);
5555 : : /* Finish up. */
5556 : 28940 : expr = finish_stmt_expr (expr, false);
5557 : : /* Consume the ')'. */
5558 : 28940 : location_t finish_loc = cp_lexer_peek_token (parser->lexer)->location;
5559 : 28940 : if (!parens.require_close (parser))
5560 : 0 : cp_parser_skip_to_end_of_statement (parser);
5561 : :
5562 : 28940 : cp_parser_end_tentative_firewall (parser, start, expr);
5563 : 28940 : location_t combined_loc = make_location (start_loc, start_loc, finish_loc);
5564 : 28940 : return cp_expr (expr, combined_loc);
5565 : 28940 : }
5566 : :
5567 : : /* Expressions [gram.expr] */
5568 : :
5569 : : /* Parse a fold-operator.
5570 : :
5571 : : fold-operator:
5572 : : - * / % ^ & | = < > << >>
5573 : : = -= *= /= %= ^= &= |= <<= >>=
5574 : : == != <= >= && || , .* ->*
5575 : :
5576 : : This returns the tree code corresponding to the matched operator
5577 : : as an int. When the current token matches a compound assignment
5578 : : operator, the resulting tree code is the negative value of the
5579 : : non-assignment operator. */
5580 : :
5581 : : static int
5582 : 27380605 : cp_parser_fold_operator (cp_token *token)
5583 : : {
5584 : 26830915 : switch (token->type)
5585 : : {
5586 : : case CPP_PLUS: return PLUS_EXPR;
5587 : : case CPP_MINUS: return MINUS_EXPR;
5588 : : case CPP_MULT: return MULT_EXPR;
5589 : : case CPP_DIV: return TRUNC_DIV_EXPR;
5590 : : case CPP_MOD: return TRUNC_MOD_EXPR;
5591 : : case CPP_XOR: return BIT_XOR_EXPR;
5592 : : case CPP_AND: return BIT_AND_EXPR;
5593 : : case CPP_OR: return BIT_IOR_EXPR;
5594 : : case CPP_LSHIFT: return LSHIFT_EXPR;
5595 : : case CPP_RSHIFT: return RSHIFT_EXPR;
5596 : :
5597 : : case CPP_EQ: return -NOP_EXPR;
5598 : : case CPP_PLUS_EQ: return -PLUS_EXPR;
5599 : : case CPP_MINUS_EQ: return -MINUS_EXPR;
5600 : : case CPP_MULT_EQ: return -MULT_EXPR;
5601 : : case CPP_DIV_EQ: return -TRUNC_DIV_EXPR;
5602 : : case CPP_MOD_EQ: return -TRUNC_MOD_EXPR;
5603 : : case CPP_XOR_EQ: return -BIT_XOR_EXPR;
5604 : : case CPP_AND_EQ: return -BIT_AND_EXPR;
5605 : : case CPP_OR_EQ: return -BIT_IOR_EXPR;
5606 : : case CPP_LSHIFT_EQ: return -LSHIFT_EXPR;
5607 : : case CPP_RSHIFT_EQ: return -RSHIFT_EXPR;
5608 : :
5609 : : case CPP_EQ_EQ: return EQ_EXPR;
5610 : : case CPP_NOT_EQ: return NE_EXPR;
5611 : : case CPP_LESS: return LT_EXPR;
5612 : : case CPP_GREATER: return GT_EXPR;
5613 : : case CPP_LESS_EQ: return LE_EXPR;
5614 : : case CPP_GREATER_EQ: return GE_EXPR;
5615 : :
5616 : : case CPP_AND_AND: return TRUTH_ANDIF_EXPR;
5617 : : case CPP_OR_OR: return TRUTH_ORIF_EXPR;
5618 : :
5619 : : case CPP_COMMA: return COMPOUND_EXPR;
5620 : :
5621 : : case CPP_DOT_STAR: return DOTSTAR_EXPR;
5622 : : case CPP_DEREF_STAR: return MEMBER_REF;
5623 : :
5624 : : default: return ERROR_MARK;
5625 : : }
5626 : : }
5627 : :
5628 : : /* Returns true if CODE indicates a binary expression, which is not allowed in
5629 : : the LHS of a fold-expression. More codes will need to be added to use this
5630 : : function in other contexts. */
5631 : :
5632 : : static bool
5633 : 496087 : is_binary_op (tree_code code)
5634 : : {
5635 : 496087 : switch (code)
5636 : : {
5637 : : case PLUS_EXPR:
5638 : : case POINTER_PLUS_EXPR:
5639 : : case MINUS_EXPR:
5640 : : case MULT_EXPR:
5641 : : case TRUNC_DIV_EXPR:
5642 : : case TRUNC_MOD_EXPR:
5643 : : case BIT_XOR_EXPR:
5644 : : case BIT_AND_EXPR:
5645 : : case BIT_IOR_EXPR:
5646 : : case LSHIFT_EXPR:
5647 : : case RSHIFT_EXPR:
5648 : :
5649 : : case MODOP_EXPR:
5650 : :
5651 : : case EQ_EXPR:
5652 : : case NE_EXPR:
5653 : : case LE_EXPR:
5654 : : case GE_EXPR:
5655 : : case LT_EXPR:
5656 : : case GT_EXPR:
5657 : :
5658 : : case TRUTH_ANDIF_EXPR:
5659 : : case TRUTH_ORIF_EXPR:
5660 : :
5661 : : case COMPOUND_EXPR:
5662 : :
5663 : : case DOTSTAR_EXPR:
5664 : : case MEMBER_REF:
5665 : : return true;
5666 : :
5667 : 495997 : default:
5668 : 495997 : return false;
5669 : : }
5670 : : }
5671 : :
5672 : : /* If the next token is a suitable fold operator, consume it and return as
5673 : : the function above. */
5674 : :
5675 : : static int
5676 : 549690 : cp_parser_fold_operator (cp_parser *parser)
5677 : : {
5678 : 549690 : cp_token* token = cp_lexer_peek_token (parser->lexer);
5679 : 549690 : int code = cp_parser_fold_operator (token);
5680 : 549690 : if (code != ERROR_MARK)
5681 : 549690 : cp_lexer_consume_token (parser->lexer);
5682 : 549690 : return code;
5683 : : }
5684 : :
5685 : : /* Parse a fold-expression.
5686 : :
5687 : : fold-expression:
5688 : : ( ... folding-operator cast-expression)
5689 : : ( cast-expression folding-operator ... )
5690 : : ( cast-expression folding operator ... folding-operator cast-expression)
5691 : :
5692 : : Note that the '(' and ')' are matched in primary expression. */
5693 : :
5694 : : static cp_expr
5695 : 549699 : cp_parser_fold_expression (cp_parser *parser, tree expr1)
5696 : : {
5697 : 549699 : cp_id_kind pidk;
5698 : 549699 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
5699 : 549699 : const cp_token *token = nullptr;
5700 : :
5701 : : // Left fold.
5702 : 549699 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
5703 : : {
5704 : 1856 : if (expr1)
5705 : 9 : return error_mark_node;
5706 : 1847 : cp_lexer_consume_token (parser->lexer);
5707 : 1847 : token = cp_lexer_peek_token (parser->lexer);
5708 : 1847 : int op = cp_parser_fold_operator (parser);
5709 : 1847 : if (op == ERROR_MARK)
5710 : : {
5711 : 0 : cp_parser_error (parser, "expected binary operator");
5712 : 0 : return error_mark_node;
5713 : : }
5714 : :
5715 : 1847 : tree expr = cp_parser_cast_expression (parser, false, false,
5716 : : false, &pidk);
5717 : 1847 : if (expr == error_mark_node)
5718 : 0 : return error_mark_node;
5719 : 1847 : loc = make_location (token->location, loc, parser->lexer);
5720 : 1847 : return finish_left_unary_fold_expr (loc, expr, op);
5721 : : }
5722 : :
5723 : 547843 : token = cp_lexer_peek_token (parser->lexer);
5724 : 547843 : int op = cp_parser_fold_operator (parser);
5725 : 547843 : if (op == ERROR_MARK)
5726 : : {
5727 : 0 : cp_parser_error (parser, "expected binary operator");
5728 : 0 : return error_mark_node;
5729 : : }
5730 : :
5731 : 547843 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS))
5732 : : {
5733 : 0 : cp_parser_error (parser, "expected ...");
5734 : 0 : return error_mark_node;
5735 : : }
5736 : 547843 : cp_lexer_consume_token (parser->lexer);
5737 : :
5738 : : /* The operands of a fold-expression are cast-expressions, so binary or
5739 : : conditional expressions are not allowed. We check this here to avoid
5740 : : tentative parsing. */
5741 : 547843 : if (EXPR_P (expr1) && warning_suppressed_p (expr1, OPT_Wparentheses))
5742 : : /* OK, the expression was parenthesized. */;
5743 : 496087 : else if (is_binary_op (TREE_CODE (expr1)))
5744 : 90 : error_at (location_of (expr1),
5745 : : "binary expression in operand of fold-expression");
5746 : 495997 : else if (TREE_CODE (expr1) == COND_EXPR
5747 : 495997 : || (REFERENCE_REF_P (expr1)
5748 : 0 : && TREE_CODE (TREE_OPERAND (expr1, 0)) == COND_EXPR))
5749 : 3 : error_at (location_of (expr1),
5750 : : "conditional expression in operand of fold-expression");
5751 : :
5752 : : // Right fold.
5753 : 547843 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
5754 : : {
5755 : 535437 : loc = make_location (token->location, loc, parser->lexer);
5756 : 535437 : return finish_right_unary_fold_expr (loc, expr1, op);
5757 : : }
5758 : :
5759 : 12406 : if (cp_lexer_next_token_is_not (parser->lexer, token->type))
5760 : : {
5761 : 0 : cp_parser_error (parser, "mismatched operator in fold-expression");
5762 : 0 : return error_mark_node;
5763 : : }
5764 : 12406 : cp_lexer_consume_token (parser->lexer);
5765 : :
5766 : : // Binary left or right fold.
5767 : 12406 : tree expr2 = cp_parser_cast_expression (parser, false, false, false, &pidk);
5768 : 12406 : if (expr2 == error_mark_node)
5769 : 0 : return error_mark_node;
5770 : 12406 : loc = make_location (token->location, loc, parser->lexer);
5771 : 12406 : return finish_binary_fold_expr (loc, expr1, expr2, op);
5772 : : }
5773 : :
5774 : : /* Return true iff the next tokens (following a typedef-name or id-expression)
5775 : : start a pack index. */
5776 : :
5777 : : static bool
5778 : 1486178784 : cp_parser_next_tokens_are_pack_index_p (cp_parser *parser)
5779 : : {
5780 : 1486178784 : return (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
5781 : 1486178784 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_SQUARE));
5782 : : }
5783 : :
5784 : : /* Parse a pack-index-specifier:
5785 : :
5786 : : pack-index-specifier:
5787 : : typedef-name ... [ constant-expression ]
5788 : :
5789 : : or a pack-index-expression:
5790 : :
5791 : : pack-index-expression:
5792 : : id-expression ... [ constant-expression ]
5793 : :
5794 : : PACK is the parsed typedef-name or the id-expression. Returns either
5795 : : a PACK_INDEX_TYPE or PACK_INDEX_EXPR. */
5796 : :
5797 : : static tree
5798 : 242 : cp_parser_pack_index (cp_parser *parser, tree pack)
5799 : : {
5800 : 242 : if (cxx_dialect < cxx26)
5801 : 71 : pedwarn (cp_lexer_peek_token (parser->lexer)->location,
5802 : : OPT_Wc__26_extensions, "pack indexing only available with "
5803 : : "%<-std=c++2c%> or %<-std=gnu++2c%>");
5804 : : /* Consume the '...' token. */
5805 : 242 : cp_lexer_consume_token (parser->lexer);
5806 : : /* Consume the '['. */
5807 : 242 : cp_lexer_consume_token (parser->lexer);
5808 : :
5809 : 242 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
5810 : : {
5811 : 7 : error_at (cp_lexer_peek_token (parser->lexer)->location,
5812 : : "pack index missing");
5813 : 7 : cp_lexer_consume_token (parser->lexer);
5814 : 7 : return error_mark_node;
5815 : : }
5816 : :
5817 : 235 : tree index = cp_parser_constant_expression (parser,
5818 : : /*allow_non_constant_p=*/false,
5819 : : /*non_constant_p=*/nullptr,
5820 : : /*strict_p=*/true);
5821 : : /* Consume the ']'. */
5822 : 235 : cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
5823 : :
5824 : 235 : if (TREE_CODE (pack) == TYPE_DECL)
5825 : 134 : pack = TREE_TYPE (pack);
5826 : 235 : pack = make_pack_expansion (pack);
5827 : 235 : return make_pack_index (pack, index);
5828 : : }
5829 : :
5830 : : /* Parse a primary-expression.
5831 : :
5832 : : primary-expression:
5833 : : literal
5834 : : this
5835 : : ( expression )
5836 : : id-expression
5837 : : lambda-expression (C++11)
5838 : :
5839 : : GNU Extensions:
5840 : :
5841 : : primary-expression:
5842 : : ( compound-statement )
5843 : : __builtin_va_arg ( assignment-expression , type-id )
5844 : : __builtin_offsetof ( type-id , offsetof-expression )
5845 : :
5846 : : C++ Extensions:
5847 : : __has_nothrow_assign ( type-id )
5848 : : __has_nothrow_constructor ( type-id )
5849 : : __has_nothrow_copy ( type-id )
5850 : : __has_trivial_assign ( type-id )
5851 : : __has_trivial_constructor ( type-id )
5852 : : __has_trivial_copy ( type-id )
5853 : : __has_trivial_destructor ( type-id )
5854 : : __has_virtual_destructor ( type-id )
5855 : : __is_abstract ( type-id )
5856 : : __is_base_of ( type-id , type-id )
5857 : : __is_class ( type-id )
5858 : : __is_empty ( type-id )
5859 : : __is_enum ( type-id )
5860 : : __is_final ( type-id )
5861 : : __is_literal_type ( type-id )
5862 : : __is_pod ( type-id )
5863 : : __is_polymorphic ( type-id )
5864 : : __is_std_layout ( type-id )
5865 : : __is_trivial ( type-id )
5866 : : __is_union ( type-id )
5867 : :
5868 : : Objective-C++ Extension:
5869 : :
5870 : : primary-expression:
5871 : : objc-expression
5872 : :
5873 : : literal:
5874 : : __null
5875 : :
5876 : : ADDRESS_P is true iff this expression was immediately preceded by
5877 : : "&" and therefore might denote a pointer-to-member. CAST_P is true
5878 : : iff this expression is the target of a cast. TEMPLATE_ARG_P is
5879 : : true iff this expression is a template argument.
5880 : :
5881 : : Returns a representation of the expression. Upon return, *IDK
5882 : : indicates what kind of id-expression (if any) was present. */
5883 : :
5884 : : static cp_expr
5885 : 824118970 : cp_parser_primary_expression (cp_parser *parser,
5886 : : bool address_p,
5887 : : bool cast_p,
5888 : : bool template_arg_p,
5889 : : bool decltype_p,
5890 : : cp_id_kind *idk)
5891 : : {
5892 : 824118970 : cp_token *token = NULL;
5893 : :
5894 : : /* Assume the primary expression is not an id-expression. */
5895 : 824118970 : *idk = CP_ID_KIND_NONE;
5896 : :
5897 : : /* Peek at the next token. */
5898 : 824118970 : token = cp_lexer_peek_token (parser->lexer);
5899 : 824118970 : switch ((int) token->type)
5900 : : {
5901 : : /* literal:
5902 : : integer-literal
5903 : : character-literal
5904 : : floating-literal
5905 : : string-literal
5906 : : boolean-literal
5907 : : pointer-literal
5908 : : user-defined-literal */
5909 : 95106624 : case CPP_CHAR:
5910 : 95106624 : case CPP_CHAR16:
5911 : 95106624 : case CPP_CHAR32:
5912 : 95106624 : case CPP_WCHAR:
5913 : 95106624 : case CPP_UTF8CHAR:
5914 : 95106624 : case CPP_NUMBER:
5915 : 95106624 : case CPP_PREPARSED_EXPR:
5916 : 95106624 : if (TREE_CODE (token->u.value) == USERDEF_LITERAL)
5917 : 89368 : return cp_parser_userdef_numeric_literal (parser);
5918 : 95017256 : token = cp_lexer_consume_token (parser->lexer);
5919 : 95017256 : if (TREE_CODE (token->u.value) == FIXED_CST)
5920 : : {
5921 : 51 : error_at (token->location,
5922 : : "fixed-point types not supported in C++");
5923 : 51 : return error_mark_node;
5924 : : }
5925 : : /* Floating-point literals are only allowed in an integral
5926 : : constant expression if they are cast to an integral or
5927 : : enumeration type. */
5928 : 95017205 : if ((TREE_CODE (token->u.value) == REAL_CST
5929 : 91682739 : || (TREE_CODE (token->u.value) == EXCESS_PRECISION_EXPR
5930 : 220998 : && TREE_CODE (TREE_OPERAND (token->u.value, 0)) == REAL_CST))
5931 : 3555458 : && parser->integral_constant_expression_p
5932 : 96860658 : && pedantic)
5933 : : {
5934 : : /* CAST_P will be set even in invalid code like "int(2.7 +
5935 : : ...)". Therefore, we have to check that the next token
5936 : : is sure to end the cast. */
5937 : 21825 : if (cast_p)
5938 : : {
5939 : 7526 : cp_token *next_token;
5940 : :
5941 : 7526 : next_token = cp_lexer_peek_token (parser->lexer);
5942 : 7526 : if (/* The comma at the end of an
5943 : : enumerator-definition. */
5944 : 7526 : next_token->type != CPP_COMMA
5945 : : /* The curly brace at the end of an enum-specifier. */
5946 : : && next_token->type != CPP_CLOSE_BRACE
5947 : : /* The end of a statement. */
5948 : : && next_token->type != CPP_SEMICOLON
5949 : : /* The end of the cast-expression. */
5950 : : && next_token->type != CPP_CLOSE_PAREN
5951 : : /* The end of an array bound. */
5952 : : && next_token->type != CPP_CLOSE_SQUARE
5953 : : /* The closing ">" in a template-argument-list. */
5954 : : && (next_token->type != CPP_GREATER
5955 : 1 : || parser->greater_than_is_operator_p)
5956 : : /* C++0x only: A ">>" treated like two ">" tokens,
5957 : : in a template-argument-list. */
5958 : 27 : && (next_token->type != CPP_RSHIFT
5959 : 0 : || (cxx_dialect == cxx98)
5960 : 0 : || parser->greater_than_is_operator_p))
5961 : : cast_p = false;
5962 : : }
5963 : :
5964 : : /* If we are within a cast, then the constraint that the
5965 : : cast is to an integral or enumeration type will be
5966 : : checked at that point. If we are not within a cast, then
5967 : : this code is invalid. */
5968 : : if (!cast_p)
5969 : 14326 : cp_parser_non_integral_constant_expression (parser, NIC_FLOAT);
5970 : : }
5971 : 95017205 : return (cp_expr (token->u.value, token->location, token->flags & DECIMAL_INT)
5972 : 95017205 : .maybe_add_location_wrapper ());
5973 : :
5974 : 102 : case CPP_CHAR_USERDEF:
5975 : 102 : case CPP_CHAR16_USERDEF:
5976 : 102 : case CPP_CHAR32_USERDEF:
5977 : 102 : case CPP_WCHAR_USERDEF:
5978 : 102 : case CPP_UTF8CHAR_USERDEF:
5979 : 102 : return cp_parser_userdef_char_literal (parser);
5980 : :
5981 : 9411549 : case CPP_STRING:
5982 : 9411549 : case CPP_STRING16:
5983 : 9411549 : case CPP_STRING32:
5984 : 9411549 : case CPP_WSTRING:
5985 : 9411549 : case CPP_UTF8STRING:
5986 : 9411549 : case CPP_STRING_USERDEF:
5987 : 9411549 : case CPP_STRING16_USERDEF:
5988 : 9411549 : case CPP_STRING32_USERDEF:
5989 : 9411549 : case CPP_WSTRING_USERDEF:
5990 : 9411549 : case CPP_UTF8STRING_USERDEF:
5991 : : /* ??? Should wide strings be allowed when parser->translate_strings_p
5992 : : is false (i.e. in attributes)? If not, we can kill the third
5993 : : argument to cp_parser_string_literal. */
5994 : 9411549 : if (parser->translate_strings_p)
5995 : 5822142 : return (cp_parser_userdef_string_literal (parser,
5996 : : /*lookup_udlit=*/true)
5997 : 5822142 : .maybe_add_location_wrapper ());
5998 : : else
5999 : 3589407 : return (cp_parser_string_literal (parser,
6000 : : /*translate=*/false,
6001 : : /*wide_ok=*/true)
6002 : 3589407 : .maybe_add_location_wrapper ());
6003 : :
6004 : 26861718 : case CPP_OPEN_PAREN:
6005 : : /* If we see `( { ' then we are looking at the beginning of
6006 : : a GNU statement-expression. */
6007 : 26861718 : if (cp_parser_allow_gnu_extensions_p (parser)
6008 : 26861718 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_BRACE))
6009 : : {
6010 : : /* Statement-expressions are not allowed by the standard. */
6011 : 28947 : pedwarn (token->location, OPT_Wpedantic,
6012 : : "ISO C++ forbids braced-groups within expressions");
6013 : :
6014 : : /* And they're not allowed outside of a function-body; you
6015 : : cannot, for example, write:
6016 : :
6017 : : int i = ({ int j = 3; j + 1; });
6018 : :
6019 : : at class or namespace scope. */
6020 : 28947 : if (!parser->in_function_body
6021 : 28943 : || parser->in_template_argument_list_p)
6022 : : {
6023 : 7 : error_at (token->location,
6024 : : "statement-expressions are not allowed outside "
6025 : : "functions nor in template-argument lists");
6026 : 7 : cp_parser_skip_to_end_of_block_or_statement (parser);
6027 : 7 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
6028 : 7 : cp_lexer_consume_token (parser->lexer);
6029 : 7 : return error_mark_node;
6030 : : }
6031 : : else
6032 : 28940 : return cp_parser_statement_expr (parser);
6033 : : }
6034 : : /* Otherwise it's a normal parenthesized expression. */
6035 : 26832771 : {
6036 : 26832771 : cp_expr expr;
6037 : 26832771 : bool saved_greater_than_is_operator_p;
6038 : :
6039 : 26832771 : location_t open_paren_loc = token->location;
6040 : :
6041 : : /* Consume the `('. */
6042 : 26832771 : matching_parens parens;
6043 : 26832771 : parens.consume_open (parser);
6044 : : /* Within a parenthesized expression, a `>' token is always
6045 : : the greater-than operator. */
6046 : 26832771 : saved_greater_than_is_operator_p
6047 : 26832771 : = parser->greater_than_is_operator_p;
6048 : 26832771 : parser->greater_than_is_operator_p = true;
6049 : :
6050 : 26832771 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
6051 : : /* Left fold expression. */
6052 : 1847 : expr = NULL_TREE;
6053 : : else
6054 : : /* Parse the parenthesized expression. */
6055 : 26830924 : expr = cp_parser_expression (parser, idk, cast_p, decltype_p);
6056 : :
6057 : 26832771 : token = cp_lexer_peek_token (parser->lexer);
6058 : 53663493 : if (token->type == CPP_ELLIPSIS || cp_parser_fold_operator (token))
6059 : : {
6060 : 549699 : expr = cp_parser_fold_expression (parser, expr);
6061 : 549699 : if (expr != error_mark_node
6062 : 549699 : && cxx_dialect < cxx17)
6063 : 1 : pedwarn (input_location, OPT_Wc__17_extensions,
6064 : : "fold-expressions only available with %<-std=c++17%> "
6065 : : "or %<-std=gnu++17%>");
6066 : : }
6067 : : else
6068 : : /* Let the front end know that this expression was
6069 : : enclosed in parentheses. This matters in case, for
6070 : : example, the expression is of the form `A::B', since
6071 : : `&A::B' might be a pointer-to-member, but `&(A::B)' is
6072 : : not. */
6073 : 26283072 : expr = finish_parenthesized_expr (expr);
6074 : :
6075 : : /* DR 705: Wrapping an unqualified name in parentheses
6076 : : suppresses arg-dependent lookup. We want to pass back
6077 : : CP_ID_KIND_QUALIFIED for suppressing vtable lookup
6078 : : (c++/37862), but none of the others. */
6079 : 26832771 : if (*idk != CP_ID_KIND_QUALIFIED)
6080 : 26488502 : *idk = CP_ID_KIND_NONE;
6081 : :
6082 : : /* The `>' token might be the end of a template-id or
6083 : : template-parameter-list now. */
6084 : 26832771 : parser->greater_than_is_operator_p
6085 : 26832771 : = saved_greater_than_is_operator_p;
6086 : :
6087 : : /* Consume the `)'. */
6088 : 26832771 : token = cp_lexer_peek_token (parser->lexer);
6089 : 26832771 : location_t close_paren_loc = token->location;
6090 : 26832771 : bool no_wparens = warning_suppressed_p (expr, OPT_Wparentheses);
6091 : 26832771 : expr.set_range (open_paren_loc, close_paren_loc);
6092 : 26832771 : if (no_wparens)
6093 : 24697408 : suppress_warning (expr, OPT_Wparentheses);
6094 : 26832771 : if (!parens.require_close (parser)
6095 : 26832771 : && !cp_parser_uncommitted_to_tentative_parse_p (parser))
6096 : 104 : cp_parser_skip_to_end_of_statement (parser);
6097 : :
6098 : 26832771 : return expr;
6099 : : }
6100 : :
6101 : 598949 : case CPP_OPEN_SQUARE:
6102 : 598949 : {
6103 : 598949 : if (c_dialect_objc ())
6104 : : {
6105 : : /* We might have an Objective-C++ message. */
6106 : 0 : cp_parser_parse_tentatively (parser);
6107 : 0 : tree msg = cp_parser_objc_message_expression (parser);
6108 : : /* If that works out, we're done ... */
6109 : 0 : if (cp_parser_parse_definitely (parser))
6110 : 0 : return msg;
6111 : : /* ... else, fall though to see if it's a lambda. */
6112 : : }
6113 : 598949 : cp_expr lam = cp_parser_lambda_expression (parser);
6114 : : /* Don't warn about a failed tentative parse. */
6115 : 1197898 : if (cp_parser_error_occurred (parser))
6116 : 3 : return error_mark_node;
6117 : 598946 : maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR);
6118 : 598946 : return lam;
6119 : : }
6120 : :
6121 : 0 : case CPP_OBJC_STRING:
6122 : 0 : if (c_dialect_objc ())
6123 : : /* We have an Objective-C++ string literal. */
6124 : 0 : return cp_parser_objc_expression (parser);
6125 : 0 : cp_parser_error (parser, "expected primary-expression");
6126 : 0 : return error_mark_node;
6127 : :
6128 : 79832732 : case CPP_KEYWORD:
6129 : 79832732 : switch (token->keyword)
6130 : : {
6131 : : /* These two are the boolean literals. */
6132 : 33393135 : case RID_TRUE:
6133 : 33393135 : cp_lexer_consume_token (parser->lexer);
6134 : 33393135 : return cp_expr (boolean_true_node, token->location);
6135 : 12019035 : case RID_FALSE:
6136 : 12019035 : cp_lexer_consume_token (parser->lexer);
6137 : 12019035 : return cp_expr (boolean_false_node, token->location);
6138 : :
6139 : : /* The `__null' literal. */
6140 : 129207 : case RID_NULL:
6141 : 129207 : cp_lexer_consume_token (parser->lexer);
6142 : 129207 : return cp_expr (null_node, token->location);
6143 : :
6144 : : /* The `nullptr' literal. */
6145 : 3121025 : case RID_NULLPTR:
6146 : 3121025 : cp_lexer_consume_token (parser->lexer);
6147 : 3121025 : return cp_expr (nullptr_node, token->location);
6148 : :
6149 : : /* Recognize the `this' keyword. */
6150 : 30106600 : case RID_THIS:
6151 : 30106600 : cp_lexer_consume_token (parser->lexer);
6152 : 30106600 : if (parser->local_variables_forbidden_p & THIS_FORBIDDEN)
6153 : : {
6154 : 35 : error_at (token->location,
6155 : : "%<this%> may not be used in this context");
6156 : 35 : return error_mark_node;
6157 : : }
6158 : : /* Pointers cannot appear in constant-expressions. */
6159 : 30106565 : if (cp_parser_non_integral_constant_expression (parser, NIC_THIS))
6160 : 0 : return error_mark_node;
6161 : 30106565 : return cp_expr (finish_this_expr (), token->location);
6162 : :
6163 : : /* The `operator' keyword can be the beginning of an
6164 : : id-expression. */
6165 : 223963 : case RID_OPERATOR:
6166 : 223963 : goto id_expression;
6167 : :
6168 : 175551 : case RID_FUNCTION_NAME:
6169 : 175551 : case RID_PRETTY_FUNCTION_NAME:
6170 : 175551 : case RID_C99_FUNCTION_NAME:
6171 : 175551 : {
6172 : 175551 : non_integral_constant name;
6173 : :
6174 : : /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
6175 : : __func__ are the names of variables -- but they are
6176 : : treated specially. Therefore, they are handled here,
6177 : : rather than relying on the generic id-expression logic
6178 : : below. Grammatically, these names are id-expressions.
6179 : :
6180 : : Consume the token. */
6181 : 175551 : token = cp_lexer_consume_token (parser->lexer);
6182 : :
6183 : 175551 : switch (token->keyword)
6184 : : {
6185 : : case RID_FUNCTION_NAME:
6186 : : name = NIC_FUNC_NAME;
6187 : : break;
6188 : : case RID_PRETTY_FUNCTION_NAME:
6189 : : name = NIC_PRETTY_FUNC;
6190 : : break;
6191 : : case RID_C99_FUNCTION_NAME:
6192 : : name = NIC_C99_FUNC;
6193 : : break;
6194 : 0 : default:
6195 : 0 : gcc_unreachable ();
6196 : : }
6197 : :
6198 : 175551 : if (cp_parser_non_integral_constant_expression (parser, name))
6199 : 3 : return error_mark_node;
6200 : :
6201 : : /* Look up the name. */
6202 : 175548 : return finish_fname (token->u.value);
6203 : : }
6204 : :
6205 : 30936 : case RID_VA_ARG:
6206 : 30936 : {
6207 : 30936 : tree expression;
6208 : 30936 : tree type;
6209 : 30936 : location_t type_location;
6210 : 30936 : location_t start_loc
6211 : 30936 : = cp_lexer_peek_token (parser->lexer)->location;
6212 : : /* The `__builtin_va_arg' construct is used to handle
6213 : : `va_arg'. Consume the `__builtin_va_arg' token. */
6214 : 30936 : cp_lexer_consume_token (parser->lexer);
6215 : : /* Look for the opening `('. */
6216 : 30936 : matching_parens parens;
6217 : 30936 : parens.require_open (parser);
6218 : : /* Now, parse the assignment-expression. */
6219 : 30936 : expression = cp_parser_assignment_expression (parser);
6220 : : /* Look for the `,'. */
6221 : 30936 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
6222 : 30936 : type_location = cp_lexer_peek_token (parser->lexer)->location;
6223 : : /* Parse the type-id. */
6224 : 30936 : {
6225 : 30936 : type_id_in_expr_sentinel s (parser);
6226 : 30936 : type = cp_parser_type_id (parser);
6227 : 30936 : }
6228 : : /* Look for the closing `)'. */
6229 : 30936 : location_t finish_loc
6230 : 30936 : = cp_lexer_peek_token (parser->lexer)->location;
6231 : 30936 : parens.require_close (parser);
6232 : : /* Using `va_arg' in a constant-expression is not
6233 : : allowed. */
6234 : 30936 : if (cp_parser_non_integral_constant_expression (parser,
6235 : : NIC_VA_ARG))
6236 : 0 : return error_mark_node;
6237 : : /* Construct a location of the form:
6238 : : __builtin_va_arg (v, int)
6239 : : ~~~~~~~~~~~~~~~~~~~~~^~~~
6240 : : with the caret at the type, ranging from the start of the
6241 : : "__builtin_va_arg" token to the close paren. */
6242 : 30936 : location_t combined_loc
6243 : 30936 : = make_location (type_location, start_loc, finish_loc);
6244 : 30936 : return build_x_va_arg (combined_loc, expression, type);
6245 : : }
6246 : :
6247 : 2333 : case RID_OFFSETOF:
6248 : 2333 : return cp_parser_builtin_offsetof (parser);
6249 : :
6250 : : // C++ concepts
6251 : 630006 : case RID_REQUIRES:
6252 : 630006 : return cp_parser_requires_expression (parser);
6253 : :
6254 : : /* Objective-C++ expressions. */
6255 : 0 : case RID_AT_ENCODE:
6256 : 0 : case RID_AT_PROTOCOL:
6257 : 0 : case RID_AT_SELECTOR:
6258 : 0 : return cp_parser_objc_expression (parser);
6259 : :
6260 : 9 : case RID_OMP_ALL_MEMORY:
6261 : 9 : gcc_assert (flag_openmp);
6262 : 9 : cp_lexer_consume_token (parser->lexer);
6263 : 9 : error_at (token->location,
6264 : : "%<omp_all_memory%> may only be used in OpenMP "
6265 : : "%<depend%> clause");
6266 : 9 : return error_mark_node;
6267 : :
6268 : 13 : case RID_TEMPLATE:
6269 : 13 : if (parser->in_function_body
6270 : 13 : && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
6271 : : == CPP_LESS))
6272 : : {
6273 : 8 : error_at (token->location,
6274 : : "a template declaration cannot appear at block scope");
6275 : 8 : cp_parser_skip_to_end_of_block_or_statement (parser);
6276 : 8 : return error_mark_node;
6277 : : }
6278 : : /* FALLTHRU */
6279 : 924 : default:
6280 : 924 : cp_parser_error (parser, "expected primary-expression");
6281 : 924 : return error_mark_node;
6282 : : }
6283 : :
6284 : : /* An id-expression can start with either an identifier, a
6285 : : `::' as the beginning of a qualified-id, or the "operator"
6286 : : keyword. */
6287 : 512870677 : case CPP_NAME:
6288 : 512870677 : if (const cp_trait* trait = cp_lexer_peek_trait_expr (parser->lexer))
6289 : 2205152 : return cp_parser_trait (parser, trait);
6290 : : /* FALLTHRU */
6291 : 610132988 : case CPP_SCOPE:
6292 : 610132988 : case CPP_TEMPLATE_ID:
6293 : 610132988 : case CPP_NESTED_NAME_SPECIFIER:
6294 : 610132988 : {
6295 : 510665525 : id_expression:
6296 : 610132988 : cp_expr id_expression;
6297 : 610132988 : cp_expr decl;
6298 : 610132988 : const char *error_msg;
6299 : 610132988 : bool template_p;
6300 : 610132988 : bool done;
6301 : 610132988 : cp_token *id_expr_token;
6302 : :
6303 : : /* Parse the id-expression. */
6304 : 610132988 : id_expression
6305 : 610132988 : = cp_parser_id_expression (parser,
6306 : : /*template_keyword_p=*/false,
6307 : : /*check_dependency_p=*/true,
6308 : : &template_p,
6309 : : /*declarator_p=*/false,
6310 : : /*optional_p=*/false);
6311 : 610132988 : if (id_expression == error_mark_node)
6312 : 9214 : return error_mark_node;
6313 : 610123774 : id_expr_token = token;
6314 : 610123774 : token = cp_lexer_peek_token (parser->lexer);
6315 : 610123774 : done = (token->type != CPP_OPEN_SQUARE
6316 : : && token->type != CPP_OPEN_PAREN
6317 : : && token->type != CPP_DOT
6318 : : && token->type != CPP_DEREF
6319 : : && token->type != CPP_PLUS_PLUS
6320 : : && token->type != CPP_MINUS_MINUS);
6321 : : /* If we have a template-id, then no further lookup is
6322 : : required. If the template-id was for a template-class, we
6323 : : will sometimes have a TYPE_DECL at this point. */
6324 : 610123774 : if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
6325 : 610123774 : || TREE_CODE (id_expression) == TYPE_DECL)
6326 : 588220540 : decl = id_expression;
6327 : : /* Look up the name. */
6328 : : else
6329 : : {
6330 : 581530419 : tree ambiguous_decls;
6331 : :
6332 : : /* If we already know that this lookup is ambiguous, then
6333 : : we've already issued an error message; there's no reason
6334 : : to check again. */
6335 : 581530419 : if (id_expr_token->type == CPP_NAME
6336 : 508146861 : && id_expr_token->error_reported)
6337 : : {
6338 : 0 : cp_parser_simulate_error (parser);
6339 : 21903234 : return error_mark_node;
6340 : : }
6341 : :
6342 : 581530419 : decl = cp_parser_lookup_name (parser, id_expression,
6343 : : none_type,
6344 : : template_p,
6345 : : /*is_namespace=*/false,
6346 : : /*check_dependency=*/true,
6347 : : &ambiguous_decls,
6348 : : id_expression.get_location ());
6349 : : /* If the lookup was ambiguous, an error will already have
6350 : : been issued. */
6351 : 581530419 : if (ambiguous_decls)
6352 : 141 : return error_mark_node;
6353 : :
6354 : : /* In Objective-C++, we may have an Objective-C 2.0
6355 : : dot-syntax for classes here. */
6356 : 581530278 : if (c_dialect_objc ()
6357 : 0 : && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
6358 : 0 : && TREE_CODE (decl) == TYPE_DECL
6359 : 581530278 : && objc_is_class_name (decl))
6360 : : {
6361 : 0 : tree component;
6362 : 0 : cp_lexer_consume_token (parser->lexer);
6363 : 0 : component = cp_parser_identifier (parser);
6364 : 0 : if (component == error_mark_node)
6365 : 0 : return error_mark_node;
6366 : :
6367 : 0 : tree result = objc_build_class_component_ref (id_expression,
6368 : 0 : component);
6369 : : /* Build a location of the form:
6370 : : expr.component
6371 : : ~~~~~^~~~~~~~~
6372 : : with caret at the start of the component name (at
6373 : : input_location), ranging from the start of the id_expression
6374 : : to the end of the component name. */
6375 : 0 : location_t combined_loc
6376 : 0 : = make_location (input_location, id_expression.get_start (),
6377 : : get_finish (input_location));
6378 : 0 : protected_set_expr_location (result, combined_loc);
6379 : 0 : return result;
6380 : : }
6381 : :
6382 : : /* In Objective-C++, an instance variable (ivar) may be preferred
6383 : : to whatever cp_parser_lookup_name() found.
6384 : : Call objc_lookup_ivar. To avoid exposing cp_expr to the
6385 : : rest of c-family, we have to do a little extra work to preserve
6386 : : any location information in cp_expr "decl". Given that
6387 : : objc_lookup_ivar is implemented in "c-family" and "objc", we
6388 : : have a trip through the pure "tree" type, rather than cp_expr.
6389 : : Naively copying it back to "decl" would implicitly give the
6390 : : new cp_expr value an UNKNOWN_LOCATION for nodes that don't
6391 : : store an EXPR_LOCATION. Hence we only update "decl" (and
6392 : : hence its location_t) if we get back a different tree node. */
6393 : 581530278 : tree decl_tree = objc_lookup_ivar (decl.get_value (),
6394 : : id_expression);
6395 : 581530278 : if (decl_tree != decl.get_value ())
6396 : 0 : decl = cp_expr (decl_tree);
6397 : :
6398 : : /* If name lookup gives us a SCOPE_REF, then the
6399 : : qualifying scope was dependent. */
6400 : 581530278 : if (TREE_CODE (decl) == SCOPE_REF)
6401 : : {
6402 : : /* At this point, we do not know if DECL is a valid
6403 : : integral constant expression. We assume that it is
6404 : : in fact such an expression, so that code like:
6405 : :
6406 : : template <int N> struct A {
6407 : : int a[B<N>::i];
6408 : : };
6409 : :
6410 : : is accepted. At template-instantiation time, we
6411 : : will check that B<N>::i is actually a constant. */
6412 : 21903078 : return decl;
6413 : : }
6414 : : /* Check to see if DECL is a local variable in a context
6415 : : where that is forbidden. */
6416 : 559627200 : if ((parser->local_variables_forbidden_p & LOCAL_VARS_FORBIDDEN)
6417 : 2900512 : && local_variable_p (decl)
6418 : : /* DR 2082 permits local variables in unevaluated contexts
6419 : : within a default argument. */
6420 : 559627236 : && !cp_unevaluated_operand)
6421 : : {
6422 : 15 : const char *msg
6423 : 15 : = (TREE_CODE (decl) == PARM_DECL
6424 : 15 : ? G_("parameter %qD may not appear in this context")
6425 : 15 : : G_("local variable %qD may not appear in this context"));
6426 : 15 : error_at (id_expression.get_location (), msg,
6427 : : decl.get_value ());
6428 : 15 : return error_mark_node;
6429 : : }
6430 : : }
6431 : :
6432 : 588220540 : decl = (finish_id_expression
6433 : 1176441077 : (id_expression, decl, parser->scope,
6434 : : idk,
6435 : 588220540 : parser->integral_constant_expression_p,
6436 : 588220540 : parser->allow_non_integral_constant_expression_p,
6437 : : &parser->non_integral_constant_expression_p,
6438 : : template_p, done, address_p,
6439 : : template_arg_p,
6440 : : &error_msg,
6441 : : id_expression.get_location ()));
6442 : 588220537 : if (error_msg)
6443 : 968 : cp_parser_error (parser, error_msg);
6444 : : /* Build a location for an id-expression of the form:
6445 : : ::ns::id
6446 : : ~~~~~~^~
6447 : : or:
6448 : : id
6449 : : ^~
6450 : : i.e. from the start of the first token to the end of the final
6451 : : token, with the caret at the start of the unqualified-id. */
6452 : 588220537 : location_t caret_loc = get_pure_location (id_expression.get_location ());
6453 : 588220537 : location_t start_loc = get_start (id_expr_token->location);
6454 : 588220537 : location_t finish_loc = get_finish (id_expression.get_location ());
6455 : 588220537 : location_t combined_loc
6456 : 588220537 : = make_location (caret_loc, start_loc, finish_loc);
6457 : :
6458 : 588220537 : decl.set_location (combined_loc);
6459 : :
6460 : : /* "T...[constant-expression]" is a C++26 pack-index-expression. */
6461 : 588220537 : if (cp_parser_next_tokens_are_pack_index_p (parser))
6462 : 78 : decl = cp_parser_pack_index (parser, decl);
6463 : :
6464 : 588220537 : return decl;
6465 : : }
6466 : :
6467 : : /* Anything else is an error. */
6468 : 193119 : default:
6469 : 193119 : cp_parser_error (parser, "expected primary-expression");
6470 : 193119 : return error_mark_node;
6471 : : }
6472 : : }
6473 : :
6474 : : static inline cp_expr
6475 : 3811631 : cp_parser_primary_expression (cp_parser *parser,
6476 : : bool address_p,
6477 : : bool cast_p,
6478 : : bool template_arg_p,
6479 : : cp_id_kind *idk)
6480 : : {
6481 : 3811631 : return cp_parser_primary_expression (parser, address_p, cast_p, template_arg_p,
6482 : : /*decltype*/false, idk);
6483 : : }
6484 : :
6485 : : /* Complain about missing template keyword when naming a dependent
6486 : : member template. */
6487 : :
6488 : : static void
6489 : 15 : missing_template_diag (location_t loc, diagnostic_t diag_kind = DK_WARNING)
6490 : : {
6491 : 15 : if (warning_suppressed_at (loc, OPT_Wmissing_template_keyword))
6492 : 0 : return;
6493 : :
6494 : 15 : gcc_rich_location richloc (loc);
6495 : 15 : richloc.add_fixit_insert_before ("template");
6496 : 15 : emit_diagnostic (diag_kind, &richloc, OPT_Wmissing_template_keyword,
6497 : : "expected %qs keyword before dependent "
6498 : : "template name", "template");
6499 : 15 : suppress_warning_at (loc, OPT_Wmissing_template_keyword);
6500 : 15 : }
6501 : :
6502 : : /* Parse an id-expression.
6503 : :
6504 : : id-expression:
6505 : : unqualified-id
6506 : : qualified-id
6507 : : pack-index-expression
6508 : :
6509 : : qualified-id:
6510 : : :: [opt] nested-name-specifier template [opt] unqualified-id
6511 : : :: identifier
6512 : : :: operator-function-id
6513 : : :: template-id
6514 : :
6515 : : Return a representation of the unqualified portion of the
6516 : : identifier. Sets PARSER->SCOPE to the qualifying scope if there is
6517 : : a `::' or nested-name-specifier.
6518 : :
6519 : : Often, if the id-expression was a qualified-id, the caller will
6520 : : want to make a SCOPE_REF to represent the qualified-id. This
6521 : : function does not do this in order to avoid wastefully creating
6522 : : SCOPE_REFs when they are not required.
6523 : :
6524 : : If TEMPLATE_KEYWORD_P is true, then we have just seen the
6525 : : `template' keyword.
6526 : :
6527 : : If CHECK_DEPENDENCY_P is false, then names are looked up inside
6528 : : uninstantiated templates.
6529 : :
6530 : : If *TEMPLATE_P is non-NULL, it is set to true iff the
6531 : : `template' keyword is used to explicitly indicate that the entity
6532 : : named is a template.
6533 : :
6534 : : If DECLARATOR_P is true, the id-expression is appearing as part of
6535 : : a declarator, rather than as part of an expression. */
6536 : :
6537 : : static cp_expr
6538 : 1300367773 : cp_parser_id_expression (cp_parser *parser,
6539 : : bool template_keyword_p,
6540 : : bool check_dependency_p,
6541 : : bool *template_p,
6542 : : bool declarator_p,
6543 : : bool optional_p)
6544 : : {
6545 : 1300367773 : bool global_scope_p;
6546 : 1300367773 : bool nested_name_specifier_p;
6547 : :
6548 : : /* Assume the `template' keyword was not used. */
6549 : 1300367773 : if (template_p)
6550 : 762639124 : *template_p = template_keyword_p;
6551 : :
6552 : : /* Look for the optional `::' operator. */
6553 : 1300367773 : global_scope_p
6554 : 2600735546 : = (!template_keyword_p
6555 : 1300367773 : && (cp_parser_global_scope_opt (parser,
6556 : : /*current_scope_valid_p=*/false)
6557 : : != NULL_TREE));
6558 : :
6559 : : /* Look for the optional nested-name-specifier. */
6560 : 1300367773 : nested_name_specifier_p
6561 : 1300367773 : = (cp_parser_nested_name_specifier_opt (parser,
6562 : : /*typename_keyword_p=*/false,
6563 : : check_dependency_p,
6564 : : /*type_p=*/false,
6565 : : declarator_p,
6566 : : template_keyword_p)
6567 : : != NULL_TREE);
6568 : :
6569 : 1300367773 : cp_expr id = NULL_TREE;
6570 : 1300367773 : tree scope = parser->scope;
6571 : :
6572 : : /* Peek at the next token. */
6573 : 1300367773 : cp_token *token = cp_lexer_peek_token (parser->lexer);
6574 : :
6575 : : /* If there is a nested-name-specifier, then we are looking at
6576 : : the first qualified-id production. */
6577 : 1300367773 : if (nested_name_specifier_p)
6578 : : {
6579 : 103374609 : tree saved_object_scope;
6580 : 103374609 : tree saved_qualifying_scope;
6581 : :
6582 : : /* See if the next token is the `template' keyword. */
6583 : 103374609 : if (!template_p)
6584 : 11195814 : template_p = &template_keyword_p;
6585 : 103374609 : *template_p = cp_parser_optional_template_keyword (parser);
6586 : : /* Name lookup we do during the processing of the
6587 : : unqualified-id might obliterate SCOPE. */
6588 : 103374609 : saved_object_scope = parser->object_scope;
6589 : 103374609 : saved_qualifying_scope = parser->qualifying_scope;
6590 : : /* Process the final unqualified-id. */
6591 : 103374609 : id = cp_parser_unqualified_id (parser, *template_p,
6592 : : check_dependency_p,
6593 : : declarator_p,
6594 : : /*optional_p=*/false);
6595 : : /* Restore the SAVED_SCOPE for our caller. */
6596 : 103374609 : parser->scope = scope;
6597 : 103374609 : parser->object_scope = saved_object_scope;
6598 : 103374609 : parser->qualifying_scope = saved_qualifying_scope;
6599 : : }
6600 : : /* Otherwise, if we are in global scope, then we are looking at one
6601 : : of the other qualified-id productions. */
6602 : 1196993164 : else if (global_scope_p)
6603 : : {
6604 : : /* If it's an identifier, and the next token is not a "<", then
6605 : : we can avoid the template-id case. This is an optimization
6606 : : for this common case. */
6607 : 64732 : if (token->type == CPP_NAME
6608 : 87516 : && !cp_parser_nth_token_starts_template_argument_list_p
6609 : 22784 : (parser, 2))
6610 : 22784 : return cp_parser_identifier (parser);
6611 : :
6612 : 41948 : cp_parser_parse_tentatively (parser);
6613 : : /* Try a template-id. */
6614 : 83896 : id = cp_parser_template_id_expr (parser,
6615 : : /*template_keyword_p=*/false,
6616 : : /*check_dependency_p=*/true,
6617 : 41948 : declarator_p);
6618 : : /* If that worked, we're done. */
6619 : 41948 : if (cp_parser_parse_definitely (parser))
6620 : 18 : return id;
6621 : :
6622 : : /* Peek at the next token. (Changes in the token buffer may
6623 : : have invalidated the pointer obtained above.) */
6624 : 41930 : token = cp_lexer_peek_token (parser->lexer);
6625 : :
6626 : 41930 : switch (token->type)
6627 : : {
6628 : 0 : case CPP_NAME:
6629 : 0 : id = cp_parser_identifier (parser);
6630 : 0 : break;
6631 : :
6632 : 41891 : case CPP_KEYWORD:
6633 : 41891 : if (token->keyword == RID_OPERATOR)
6634 : : {
6635 : 23588 : id = cp_parser_operator_function_id (parser);
6636 : 23588 : break;
6637 : : }
6638 : : /* Fall through. */
6639 : :
6640 : 18342 : default:
6641 : 18342 : cp_parser_error (parser, "expected id-expression");
6642 : 18342 : return error_mark_node;
6643 : : }
6644 : : }
6645 : : else
6646 : : {
6647 : 1196928432 : if (!scope)
6648 : 1196928432 : scope = parser->context->object_type;
6649 : 1196928432 : id = cp_parser_unqualified_id (parser, template_keyword_p,
6650 : : /*check_dependency_p=*/true,
6651 : : declarator_p,
6652 : : optional_p);
6653 : : }
6654 : :
6655 : 1280276865 : if (id && TREE_CODE (id) == IDENTIFIER_NODE
6656 : 1231780721 : && warn_missing_template_keyword
6657 : 1231780712 : && !template_keyword_p
6658 : : /* Don't warn if we're looking inside templates. */
6659 : 1231780631 : && check_dependency_p
6660 : : /* In a template argument list a > could be closing
6661 : : the enclosing targs. */
6662 : 747213668 : && !parser->in_template_argument_list_p
6663 : 702670638 : && scope && dependentish_scope_p (scope)
6664 : : /* Don't confuse an ill-formed constructor declarator for a missing
6665 : : template keyword in a return type. */
6666 : 105335651 : && !(declarator_p && constructor_name_p (id, scope))
6667 : 104700195 : && cp_parser_nth_token_starts_template_argument_list_p (parser, 1)
6668 : 1300479943 : && warning_enabled_at (token->location,
6669 : : OPT_Wmissing_template_keyword))
6670 : : {
6671 : 150802 : saved_token_sentinel toks (parser->lexer, STS_ROLLBACK);
6672 : 150802 : if (cp_parser_skip_entire_template_parameter_list (parser)
6673 : : /* An operator after the > suggests that the > ends a
6674 : : template-id; a name or literal suggests that the > is an
6675 : : operator. */
6676 : 150802 : && (cp_lexer_peek_token (parser->lexer)->type
6677 : : <= CPP_LAST_PUNCTUATOR))
6678 : 15 : missing_template_diag (token->location);
6679 : 150802 : }
6680 : :
6681 : 1300326629 : return id;
6682 : : }
6683 : :
6684 : : /* Parse an unqualified-id.
6685 : :
6686 : : unqualified-id:
6687 : : identifier
6688 : : operator-function-id
6689 : : conversion-function-id
6690 : : literal-operator-id
6691 : : ~ type-name
6692 : : ~ computed-type-specifier
6693 : : template-id
6694 : :
6695 : : If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
6696 : : keyword, in a construct like `A::template ...'.
6697 : :
6698 : : Returns a representation of unqualified-id. For the `identifier'
6699 : : production, an IDENTIFIER_NODE is returned. For the `~ class-name'
6700 : : production a BIT_NOT_EXPR is returned; the operand of the
6701 : : BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
6702 : : other productions, see the documentation accompanying the
6703 : : corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
6704 : : names are looked up in uninstantiated templates. If DECLARATOR_P
6705 : : is true, the unqualified-id is appearing as part of a declarator,
6706 : : rather than as part of an expression. */
6707 : :
6708 : : static cp_expr
6709 : 1309141387 : cp_parser_unqualified_id (cp_parser* parser,
6710 : : bool template_keyword_p,
6711 : : bool check_dependency_p,
6712 : : bool declarator_p,
6713 : : bool optional_p)
6714 : : {
6715 : 1309141387 : cp_token *token;
6716 : :
6717 : : /* Peek at the next token. */
6718 : 1309141387 : token = cp_lexer_peek_token (parser->lexer);
6719 : :
6720 : 1309141387 : switch ((int) token->type)
6721 : : {
6722 : 1209107410 : case CPP_NAME:
6723 : 1209107410 : {
6724 : 1209107410 : tree id;
6725 : :
6726 : : /* We don't know yet whether or not this will be a
6727 : : template-id. */
6728 : 1209107410 : cp_parser_parse_tentatively (parser);
6729 : : /* Try a template-id. */
6730 : 1209107410 : id = cp_parser_template_id_expr (parser, template_keyword_p,
6731 : : check_dependency_p,
6732 : : declarator_p);
6733 : : /* If it worked, we're done. */
6734 : 1209107410 : if (cp_parser_parse_definitely (parser))
6735 : 0 : return id;
6736 : : /* Otherwise, it's an ordinary identifier. */
6737 : 1209107410 : return cp_parser_identifier (parser);
6738 : : }
6739 : :
6740 : 32664484 : case CPP_TEMPLATE_ID:
6741 : 32664484 : return cp_parser_template_id_expr (parser, template_keyword_p,
6742 : : check_dependency_p,
6743 : 32664484 : declarator_p);
6744 : :
6745 : 6474307 : case CPP_COMPL:
6746 : 6474307 : {
6747 : 6474307 : tree type_decl;
6748 : 6474307 : tree qualifying_scope;
6749 : 6474307 : tree object_scope;
6750 : 6474307 : tree scope;
6751 : 6474307 : bool done;
6752 : 6474307 : location_t tilde_loc = token->location;
6753 : :
6754 : : /* Consume the `~' token. */
6755 : 6474307 : cp_lexer_consume_token (parser->lexer);
6756 : : /* Parse the class-name. The standard, as written, seems to
6757 : : say that:
6758 : :
6759 : : template <typename T> struct S { ~S (); };
6760 : : template <typename T> S<T>::~S() {}
6761 : :
6762 : : is invalid, since `~' must be followed by a class-name, but
6763 : : `S<T>' is dependent, and so not known to be a class.
6764 : : That's not right; we need to look in uninstantiated
6765 : : templates. A further complication arises from:
6766 : :
6767 : : template <typename T> void f(T t) {
6768 : : t.T::~T();
6769 : : }
6770 : :
6771 : : Here, it is not possible to look up `T' in the scope of `T'
6772 : : itself. We must look in both the current scope, and the
6773 : : scope of the containing complete expression.
6774 : :
6775 : : Yet another issue is:
6776 : :
6777 : : struct S {
6778 : : int S;
6779 : : ~S();
6780 : : };
6781 : :
6782 : : S::~S() {}
6783 : :
6784 : : The standard does not seem to say that the `S' in `~S'
6785 : : should refer to the type `S' and not the data member
6786 : : `S::S'. */
6787 : :
6788 : : /* DR 244 says that we look up the name after the "~" in the
6789 : : same scope as we looked up the qualifying name. That idea
6790 : : isn't fully worked out; it's more complicated than that. */
6791 : 6474307 : scope = parser->scope;
6792 : 6474307 : object_scope = parser->object_scope;
6793 : 6474307 : qualifying_scope = parser->qualifying_scope;
6794 : :
6795 : : /* Check for invalid scopes. */
6796 : 6474307 : if (scope == error_mark_node)
6797 : : {
6798 : 3 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
6799 : 3 : cp_lexer_consume_token (parser->lexer);
6800 : 3 : return error_mark_node;
6801 : : }
6802 : 6474304 : if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
6803 : : {
6804 : 33 : if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
6805 : 9 : error_at (token->location,
6806 : : "scope %qT before %<~%> is not a class-name",
6807 : : scope);
6808 : 24 : cp_parser_simulate_error (parser);
6809 : 12 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
6810 : 12 : cp_lexer_consume_token (parser->lexer);
6811 : 12 : return error_mark_node;
6812 : : }
6813 : 6474292 : if (template_keyword_p)
6814 : : {
6815 : 9 : if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
6816 : 3 : error_at (tilde_loc, "%<template%> keyword not permitted in "
6817 : : "destructor name");
6818 : 6 : cp_parser_simulate_error (parser);
6819 : 3 : return error_mark_node;
6820 : : }
6821 : :
6822 : 6474289 : gcc_assert (!scope || TYPE_P (scope));
6823 : :
6824 : 6474289 : token = cp_lexer_peek_token (parser->lexer);
6825 : :
6826 : : /* Create a location with caret == start at the tilde,
6827 : : finishing at the end of the peeked token, e.g:
6828 : : ~token
6829 : : ^~~~~~. */
6830 : 6474289 : location_t loc
6831 : 6474289 : = make_location (tilde_loc, tilde_loc, token->location);
6832 : :
6833 : : /* If the name is of the form "X::~X" it's OK even if X is a
6834 : : typedef. */
6835 : :
6836 : 6474289 : if (scope
6837 : 499883 : && token->type == CPP_NAME
6838 : 499847 : && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
6839 : : != CPP_LESS)
6840 : 6974115 : && (token->u.value == TYPE_IDENTIFIER (scope)
6841 : 78 : || (CLASS_TYPE_P (scope)
6842 : 69 : && constructor_name_p (token->u.value, scope))))
6843 : : {
6844 : 499748 : cp_lexer_consume_token (parser->lexer);
6845 : 499748 : return build_min_nt_loc (loc, BIT_NOT_EXPR, scope);
6846 : : }
6847 : :
6848 : : /* ~auto means the destructor of whatever the object is. */
6849 : 5974541 : if (cp_parser_is_keyword (token, RID_AUTO))
6850 : : {
6851 : 3 : if (cxx_dialect < cxx14)
6852 : 0 : pedwarn (loc, OPT_Wc__14_extensions,
6853 : : "%<~auto%> only available with "
6854 : : "%<-std=c++14%> or %<-std=gnu++14%>");
6855 : 3 : cp_lexer_consume_token (parser->lexer);
6856 : 3 : return build_min_nt_loc (loc, BIT_NOT_EXPR, make_auto ());
6857 : : }
6858 : :
6859 : : /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
6860 : : declarator-id of a constructor or destructor. */
6861 : 5974538 : if (token->type == CPP_TEMPLATE_ID && declarator_p)
6862 : : {
6863 : 64 : auto_diagnostic_group d;
6864 : 64 : bool w = false;
6865 : 70 : if (cxx_dialect >= cxx20 && !cp_parser_simulate_error (parser))
6866 : 15 : w = pedwarn (tilde_loc, OPT_Wtemplate_id_cdtor,
6867 : : "template-id not allowed for destructor in C++20");
6868 : 49 : else if (cxx_dialect < cxx20
6869 : 49 : && !cp_parser_uncommitted_to_tentative_parse_p (parser))
6870 : 31 : w = warning_at (tilde_loc, OPT_Wtemplate_id_cdtor,
6871 : : "template-id not allowed for destructor in C++20");
6872 : 46 : if (w)
6873 : 20 : inform (tilde_loc, "remove the %qs", "< >");
6874 : 64 : }
6875 : :
6876 : : /* If there was an explicit qualification (S::~T), first look
6877 : : in the scope given by the qualification (i.e., S).
6878 : :
6879 : : Note: in the calls to cp_parser_class_name below we pass
6880 : : typename_type so that lookup finds the injected-class-name
6881 : : rather than the constructor. */
6882 : 5974538 : done = false;
6883 : 5974538 : type_decl = NULL_TREE;
6884 : 5974538 : if (scope)
6885 : : {
6886 : 135 : cp_parser_parse_tentatively (parser);
6887 : 135 : type_decl = cp_parser_class_name (parser,
6888 : : /*typename_keyword_p=*/false,
6889 : : /*template_keyword_p=*/false,
6890 : : typename_type,
6891 : : /*check_dependency=*/false,
6892 : : /*class_head_p=*/false,
6893 : : declarator_p);
6894 : 135 : if (cp_parser_parse_definitely (parser))
6895 : : done = true;
6896 : : }
6897 : : /* In "N::S::~S", look in "N" as well. */
6898 : 5974538 : if (!done && scope && qualifying_scope)
6899 : : {
6900 : 0 : cp_parser_parse_tentatively (parser);
6901 : 0 : parser->scope = qualifying_scope;
6902 : 0 : parser->object_scope = NULL_TREE;
6903 : 0 : parser->qualifying_scope = NULL_TREE;
6904 : 0 : type_decl
6905 : 0 : = cp_parser_class_name (parser,
6906 : : /*typename_keyword_p=*/false,
6907 : : /*template_keyword_p=*/false,
6908 : : typename_type,
6909 : : /*check_dependency=*/false,
6910 : : /*class_head_p=*/false,
6911 : : declarator_p);
6912 : 0 : if (cp_parser_parse_definitely (parser))
6913 : : done = true;
6914 : : }
6915 : : /* In "p->S::~T", look in the scope given by "*p" as well. */
6916 : 5974538 : else if (!done && object_scope)
6917 : : {
6918 : 21 : cp_parser_parse_tentatively (parser);
6919 : 21 : parser->scope = object_scope;
6920 : 21 : parser->object_scope = NULL_TREE;
6921 : 21 : parser->qualifying_scope = NULL_TREE;
6922 : 21 : type_decl
6923 : 21 : = cp_parser_class_name (parser,
6924 : : /*typename_keyword_p=*/false,
6925 : : /*template_keyword_p=*/false,
6926 : : typename_type,
6927 : : /*check_dependency=*/false,
6928 : : /*class_head_p=*/false,
6929 : : declarator_p);
6930 : 21 : if (cp_parser_parse_definitely (parser))
6931 : : done = true;
6932 : : }
6933 : : /* Look in the surrounding context. */
6934 : 5974538 : if (!done)
6935 : : {
6936 : 5974466 : parser->scope = NULL_TREE;
6937 : 5974466 : parser->object_scope = NULL_TREE;
6938 : 5974466 : parser->qualifying_scope = NULL_TREE;
6939 : 5974466 : if (processing_template_decl)
6940 : 3624192 : cp_parser_parse_tentatively (parser);
6941 : 5974466 : type_decl
6942 : 5974466 : = cp_parser_class_name (parser,
6943 : : /*typename_keyword_p=*/false,
6944 : : /*template_keyword_p=*/false,
6945 : : typename_type,
6946 : : /*check_dependency=*/false,
6947 : : /*class_head_p=*/false,
6948 : : declarator_p);
6949 : 5974466 : if (processing_template_decl
6950 : 5974466 : && ! cp_parser_parse_definitely (parser))
6951 : : {
6952 : : /* We couldn't find a type with this name. If we're parsing
6953 : : tentatively, fail and try something else. */
6954 : 24714 : if (cp_parser_uncommitted_to_tentative_parse_p (parser))
6955 : : {
6956 : 12333 : cp_parser_simulate_error (parser);
6957 : 12333 : return error_mark_node;
6958 : : }
6959 : : /* Otherwise, accept it and check for a match at instantiation
6960 : : time. */
6961 : 24 : type_decl = cp_parser_identifier (parser);
6962 : 24 : if (type_decl != error_mark_node)
6963 : 19 : type_decl = build_min_nt_loc (loc, BIT_NOT_EXPR, type_decl);
6964 : 24 : return type_decl;
6965 : : }
6966 : : }
6967 : : /* If an error occurred, assume that the name of the
6968 : : destructor is the same as the name of the qualifying
6969 : : class. That allows us to keep parsing after running
6970 : : into ill-formed destructor names. */
6971 : 5962181 : if (type_decl == error_mark_node && scope)
6972 : 9 : return build_min_nt_loc (loc, BIT_NOT_EXPR, scope);
6973 : 5962172 : else if (type_decl == error_mark_node)
6974 : 19 : return error_mark_node;
6975 : :
6976 : : /* Check that destructor name and scope match. */
6977 : 5962153 : if (declarator_p && scope && !check_dtor_name (scope, type_decl))
6978 : : {
6979 : 69 : if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
6980 : 9 : error_at (loc,
6981 : : "declaration of %<~%T%> as member of %qT",
6982 : : type_decl, scope);
6983 : 60 : cp_parser_simulate_error (parser);
6984 : 30 : return error_mark_node;
6985 : : }
6986 : :
6987 : : /* [class.dtor]
6988 : :
6989 : : A typedef-name that names a class shall not be used as the
6990 : : identifier in the declarator for a destructor declaration. */
6991 : 5962123 : if (declarator_p
6992 : 5629597 : && !DECL_IMPLICIT_TYPEDEF_P (type_decl)
6993 : 5629454 : && !DECL_SELF_REFERENCE_P (type_decl)
6994 : 5962123 : && !cp_parser_uncommitted_to_tentative_parse_p (parser))
6995 : 6 : error_at (loc,
6996 : : "typedef-name %qD used as destructor declarator",
6997 : : type_decl);
6998 : :
6999 : : /* "~T...[N]" is a C++26 pack-index-specifier. */
7000 : 5962123 : if (cp_parser_next_tokens_are_pack_index_p (parser))
7001 : : {
7002 : 1 : type_decl = cp_parser_pack_index (parser, type_decl);
7003 : 1 : return build_min_nt_loc (loc, BIT_NOT_EXPR, type_decl);
7004 : : }
7005 : :
7006 : 5962122 : return build_min_nt_loc (loc, BIT_NOT_EXPR, TREE_TYPE (type_decl));
7007 : : }
7008 : :
7009 : 36283922 : case CPP_KEYWORD:
7010 : 36283922 : if (token->keyword == RID_OPERATOR)
7011 : : {
7012 : 31327425 : cp_expr id;
7013 : :
7014 : : /* This could be a template-id, so we try that first. */
7015 : 31327425 : cp_parser_parse_tentatively (parser);
7016 : : /* Try a template-id. */
7017 : 62654850 : id = cp_parser_template_id_expr (parser, template_keyword_p,
7018 : : /*check_dependency_p=*/true,
7019 : 31327425 : declarator_p);
7020 : : /* If that worked, we're done. */
7021 : 31327425 : if (cp_parser_parse_definitely (parser))
7022 : 6166 : return id;
7023 : : /* We still don't know whether we're looking at an
7024 : : operator-function-id or a conversion-function-id. */
7025 : 31321259 : cp_parser_parse_tentatively (parser);
7026 : : /* Try an operator-function-id. */
7027 : 31321259 : id = cp_parser_operator_function_id (parser);
7028 : : /* If that didn't work, try a conversion-function-id. */
7029 : 31321259 : if (!cp_parser_parse_definitely (parser))
7030 : 1303924 : id = cp_parser_conversion_function_id (parser);
7031 : :
7032 : 31321259 : return id;
7033 : : }
7034 : : /* Fall through. */
7035 : :
7036 : 29567761 : default:
7037 : 29567761 : if (optional_p)
7038 : 20049764 : return NULL_TREE;
7039 : 9517997 : cp_parser_error (parser, "expected unqualified-id");
7040 : 9517997 : return error_mark_node;
7041 : : }
7042 : : }
7043 : :
7044 : : /* Check [temp.names]/5: A name prefixed by the keyword template shall
7045 : : be a template-id or the name shall refer to a class template or an
7046 : : alias template. */
7047 : :
7048 : : static void
7049 : 2823144 : check_template_keyword_in_nested_name_spec (tree name)
7050 : : {
7051 : 2617165 : if (CLASS_TYPE_P (name)
7052 : 5440309 : && ((CLASSTYPE_USE_TEMPLATE (name)
7053 : 2569497 : && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (name)))
7054 : 47668 : || CLASSTYPE_IS_TEMPLATE (name)))
7055 : : return;
7056 : :
7057 : 205982 : if (TREE_CODE (name) == TYPENAME_TYPE
7058 : 205982 : && TREE_CODE (TYPENAME_TYPE_FULLNAME (name)) == TEMPLATE_ID_EXPR)
7059 : : return;
7060 : : /* Alias templates are also OK. */
7061 : 3242 : else if (alias_template_specialization_p (name, nt_opaque))
7062 : : return;
7063 : :
7064 : 3 : permerror (input_location, TYPE_P (name)
7065 : : ? G_("%qT is not a template")
7066 : : : G_("%qD is not a template"),
7067 : : name);
7068 : : }
7069 : :
7070 : : /* Parse an (optional) nested-name-specifier.
7071 : :
7072 : : nested-name-specifier: [C++98]
7073 : : class-or-namespace-name :: nested-name-specifier [opt]
7074 : : class-or-namespace-name :: template nested-name-specifier [opt]
7075 : :
7076 : : nested-name-specifier: [C++11]
7077 : : type-name ::
7078 : : namespace-name ::
7079 : : computed-type-specifier ::
7080 : : nested-name-specifier identifier ::
7081 : : nested-name-specifier template [opt] simple-template-id ::
7082 : :
7083 : : PARSER->SCOPE should be set appropriately before this function is
7084 : : called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
7085 : : effect. TYPE_P is TRUE if we non-type bindings should be ignored
7086 : : in name lookups.
7087 : :
7088 : : Sets PARSER->SCOPE to the class (TYPE) or namespace
7089 : : (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
7090 : : it unchanged if there is no nested-name-specifier. Returns the new
7091 : : scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
7092 : :
7093 : : If CHECK_DEPENDENCY_P is FALSE, names are looked up in dependent scopes.
7094 : :
7095 : : If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
7096 : : part of a declaration and/or decl-specifier. */
7097 : :
7098 : : static tree
7099 : 4505773454 : cp_parser_nested_name_specifier_opt (cp_parser *parser,
7100 : : bool typename_keyword_p,
7101 : : bool check_dependency_p,
7102 : : bool type_p,
7103 : : bool is_declaration,
7104 : : bool template_keyword_p /* = false */)
7105 : : {
7106 : 4505773454 : bool success = false;
7107 : 4505773454 : cp_token_position start = 0;
7108 : 4505773454 : cp_token *token;
7109 : :
7110 : : /* Remember where the nested-name-specifier starts. */
7111 : 4505773454 : if (cp_parser_uncommitted_to_tentative_parse_p (parser)
7112 : 3393105763 : && cp_lexer_next_token_is_not (parser->lexer, CPP_NESTED_NAME_SPECIFIER))
7113 : : {
7114 : 3343089135 : start = cp_lexer_token_position (parser->lexer, false);
7115 : 3343089135 : push_deferring_access_checks (dk_deferred);
7116 : : }
7117 : :
7118 : 4816705230 : while (true)
7119 : : {
7120 : 4816705230 : tree new_scope;
7121 : 4816705230 : tree old_scope;
7122 : 4816705230 : tree saved_qualifying_scope;
7123 : :
7124 : : /* Spot cases that cannot be the beginning of a
7125 : : nested-name-specifier. */
7126 : 4816705230 : token = cp_lexer_peek_token (parser->lexer);
7127 : :
7128 : : /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
7129 : : the already parsed nested-name-specifier. */
7130 : 4816705230 : if (token->type == CPP_NESTED_NAME_SPECIFIER)
7131 : : {
7132 : : /* Grab the nested-name-specifier and continue the loop. */
7133 : 140242267 : cp_parser_pre_parsed_nested_name_specifier (parser);
7134 : : /* If we originally encountered this nested-name-specifier
7135 : : with CHECK_DEPENDENCY_P set to true, we will not have
7136 : : resolved TYPENAME_TYPEs, so we must do so here. */
7137 : 140242267 : if (is_declaration
7138 : 140242267 : && !check_dependency_p
7139 : 9413786 : && TREE_CODE (parser->scope) == TYPENAME_TYPE)
7140 : : {
7141 : 57604 : new_scope = resolve_typename_type (parser->scope,
7142 : : /*only_current_p=*/false);
7143 : 57604 : if (TREE_CODE (new_scope) != TYPENAME_TYPE)
7144 : 57577 : parser->scope = new_scope;
7145 : : }
7146 : 140242267 : success = true;
7147 : 140242267 : continue;
7148 : : }
7149 : :
7150 : : /* Spot cases that cannot be the beginning of a
7151 : : nested-name-specifier. On the second and subsequent times
7152 : : through the loop, we look for the `template' keyword. */
7153 : 4676462963 : if (success && token->keyword == RID_TEMPLATE)
7154 : : ;
7155 : : /* A template-id can start a nested-name-specifier. */
7156 : 4675407478 : else if (token->type == CPP_TEMPLATE_ID)
7157 : : ;
7158 : : /* DR 743: decltype can be used in a nested-name-specifier. */
7159 : 4618340725 : else if (token_is_decltype (token))
7160 : : ;
7161 : : else
7162 : : {
7163 : : /* If the next token is not an identifier, then it is
7164 : : definitely not a type-name or namespace-name. */
7165 : 4618300034 : if (token->type != CPP_NAME)
7166 : : break;
7167 : : /* If the following token is neither a `<' (to begin a
7168 : : template-id), a `...[' (to begin a pack-index-specifier),
7169 : : nor a `::', then we are not looking at a nested-name-specifier. */
7170 : 3512713144 : token = cp_lexer_peek_nth_token (parser->lexer, 2);
7171 : :
7172 : 3512713144 : if (token->type == CPP_COLON
7173 : 8813829 : && parser->colon_corrects_to_scope_p
7174 : 74 : && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_NAME
7175 : : /* name:name is a valid sequence in an Objective C message. */
7176 : 3512713188 : && !parser->objective_c_message_context_p)
7177 : : {
7178 : 44 : gcc_rich_location richloc (token->location);
7179 : 44 : richloc.add_fixit_replace ("::");
7180 : 44 : error_at (&richloc,
7181 : : "found %<:%> in nested-name-specifier, "
7182 : : "expected %<::%>");
7183 : 44 : token->type = CPP_SCOPE;
7184 : 44 : }
7185 : :
7186 : 3512713144 : if (token->type != CPP_SCOPE
7187 : : /* See if a pack-index-specifier follows. */
7188 : 3377048931 : && !(token->type == CPP_ELLIPSIS
7189 : 13056398 : && cp_lexer_peek_nth_token (parser->lexer, 3)->type
7190 : : == CPP_OPEN_SQUARE)
7191 : 6889761807 : && !cp_parser_nth_token_starts_template_argument_list_p
7192 : 3377048663 : (parser, 2))
7193 : : break;
7194 : : }
7195 : :
7196 : : /* The nested-name-specifier is optional, so we parse
7197 : : tentatively. */
7198 : 398517234 : cp_parser_parse_tentatively (parser);
7199 : :
7200 : : /* Look for the optional `template' keyword, if this isn't the
7201 : : first time through the loop. */
7202 : 398517234 : if (success)
7203 : : {
7204 : 63739019 : template_keyword_p = cp_parser_optional_template_keyword (parser);
7205 : : /* DR1710: "In a qualified-id used as the name in
7206 : : a typename-specifier, elaborated-type-specifier, using-declaration,
7207 : : or class-or-decltype, an optional keyword template appearing at
7208 : : the top level is ignored." */
7209 : 63739019 : if (!template_keyword_p
7210 : 63739019 : && typename_keyword_p
7211 : 63739019 : && cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
7212 : : template_keyword_p = true;
7213 : : }
7214 : :
7215 : : /* Save the old scope since the name lookup we are about to do
7216 : : might destroy it. */
7217 : 398517234 : old_scope = parser->scope;
7218 : 398517234 : saved_qualifying_scope = parser->qualifying_scope;
7219 : : /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
7220 : : look up names in "X<T>::I" in order to determine that "Y" is
7221 : : a template. So, if we have a typename at this point, we make
7222 : : an effort to look through it. */
7223 : 398517234 : if (is_declaration
7224 : 398517234 : && !check_dependency_p
7225 : 1800065 : && !typename_keyword_p
7226 : 1800065 : && parser->scope
7227 : 19726 : && TREE_CODE (parser->scope) == TYPENAME_TYPE)
7228 : 0 : parser->scope = resolve_typename_type (parser->scope,
7229 : : /*only_current_p=*/false);
7230 : : /* Parse the qualifying entity. */
7231 : 398517234 : new_scope
7232 : 398517234 : = cp_parser_qualifying_entity (parser,
7233 : : typename_keyword_p,
7234 : : template_keyword_p,
7235 : : check_dependency_p,
7236 : : type_p,
7237 : : is_declaration);
7238 : : /* Look for the `::' token. */
7239 : 398517231 : cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
7240 : :
7241 : : /* If we found what we wanted, we keep going; otherwise, we're
7242 : : done. */
7243 : 398517231 : if (!cp_parser_parse_definitely (parser))
7244 : : {
7245 : 227827719 : bool error_p = false;
7246 : :
7247 : : /* Restore the OLD_SCOPE since it was valid before the
7248 : : failed attempt at finding the last
7249 : : class-or-namespace-name. */
7250 : 227827719 : parser->scope = old_scope;
7251 : 227827719 : parser->qualifying_scope = saved_qualifying_scope;
7252 : :
7253 : : /* If the next token is a decltype, and the one after that is a
7254 : : `::', then the decltype has failed to resolve to a class or
7255 : : enumeration type. Give this error even when parsing
7256 : : tentatively since it can't possibly be valid--and we're going
7257 : : to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
7258 : : won't get another chance.*/
7259 : 227827719 : if (cp_lexer_next_token_is (parser->lexer, CPP_DECLTYPE)
7260 : 227827719 : && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
7261 : : == CPP_SCOPE))
7262 : : {
7263 : 9 : token = cp_lexer_consume_token (parser->lexer);
7264 : 9 : tree dtype = token->u.tree_check_value->value;
7265 : 9 : if (dtype != error_mark_node)
7266 : 9 : error_at (token->location, "%<decltype%> evaluates to %qT, "
7267 : : "which is not a class or enumeration type",
7268 : : dtype);
7269 : 9 : parser->scope = error_mark_node;
7270 : 9 : error_p = true;
7271 : : /* As below. */
7272 : 9 : success = true;
7273 : 9 : cp_lexer_consume_token (parser->lexer);
7274 : : }
7275 : :
7276 : 227827719 : if (cp_lexer_next_token_is (parser->lexer, CPP_TEMPLATE_ID)
7277 : 227827719 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_SCOPE))
7278 : : {
7279 : : /* If we have a non-type template-id followed by ::, it can't
7280 : : possibly be valid. */
7281 : 51 : token = cp_lexer_peek_token (parser->lexer);
7282 : 51 : tree tid = token->u.tree_check_value->value;
7283 : 51 : if (TREE_CODE (tid) == TEMPLATE_ID_EXPR
7284 : 51 : && TREE_CODE (TREE_OPERAND (tid, 0)) != IDENTIFIER_NODE)
7285 : : {
7286 : 15 : auto_diagnostic_group d;
7287 : 15 : tree tmpl = NULL_TREE;
7288 : 15 : if (is_overloaded_fn (tid))
7289 : : {
7290 : 6 : tree fns = get_fns (tid);
7291 : 6 : if (OVL_SINGLE_P (fns))
7292 : 6 : tmpl = OVL_FIRST (fns);
7293 : 6 : error_at (token->location, "function template-id "
7294 : : "%qD in nested-name-specifier", tid);
7295 : : }
7296 : : else
7297 : : {
7298 : 9 : tmpl = TREE_OPERAND (tid, 0);
7299 : 18 : if (concept_definition_p (tmpl))
7300 : 6 : error_at (token->location, "concept-id %qD "
7301 : : "in nested-name-specifier", tid);
7302 : : else
7303 : : {
7304 : : /* Variable template. */
7305 : 3 : gcc_assert (variable_template_p (tmpl));
7306 : 3 : error_at (token->location, "variable template-id "
7307 : : "%qD in nested-name-specifier", tid);
7308 : : }
7309 : : }
7310 : 15 : if (tmpl)
7311 : 15 : inform (DECL_SOURCE_LOCATION (tmpl),
7312 : : "%qD declared here", tmpl);
7313 : :
7314 : 15 : parser->scope = error_mark_node;
7315 : 15 : error_p = true;
7316 : : /* As below. */
7317 : 15 : success = true;
7318 : 15 : cp_lexer_consume_token (parser->lexer);
7319 : 15 : cp_lexer_consume_token (parser->lexer);
7320 : 15 : }
7321 : : }
7322 : :
7323 : 4787711367 : if (cp_parser_uncommitted_to_tentative_parse_p (parser))
7324 : : break;
7325 : : /* If the next token is an identifier, and the one after
7326 : : that is a `::', then any valid interpretation would have
7327 : : found a class-or-namespace-name. */
7328 : 54110200 : while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
7329 : 6982956 : && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
7330 : : == CPP_SCOPE)
7331 : 54110328 : && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
7332 : : != CPP_COMPL))
7333 : : {
7334 : 125 : token = cp_lexer_consume_token (parser->lexer);
7335 : 125 : if (!error_p)
7336 : : {
7337 : 120 : if (!token->error_reported)
7338 : : {
7339 : 120 : tree decl;
7340 : 120 : tree ambiguous_decls;
7341 : :
7342 : 120 : decl = cp_parser_lookup_name (parser, token->u.value,
7343 : : none_type,
7344 : : /*is_template=*/false,
7345 : : /*is_namespace=*/false,
7346 : : /*check_dependency=*/true,
7347 : : &ambiguous_decls,
7348 : : token->location);
7349 : 120 : if (TREE_CODE (decl) == TEMPLATE_DECL)
7350 : 9 : error_at (token->location,
7351 : : "%qD used without template arguments",
7352 : : decl);
7353 : 111 : else if (ambiguous_decls)
7354 : : {
7355 : : // cp_parser_lookup_name has the same diagnostic,
7356 : : // thus make sure to emit it at most once.
7357 : 9 : if (cp_parser_uncommitted_to_tentative_parse_p
7358 : 9 : (parser))
7359 : : {
7360 : 0 : error_at (token->location,
7361 : : "reference to %qD is ambiguous",
7362 : : token->u.value);
7363 : 0 : print_candidates (ambiguous_decls);
7364 : : }
7365 : 9 : decl = error_mark_node;
7366 : : }
7367 : : else
7368 : : {
7369 : 102 : if (cxx_dialect != cxx98)
7370 : 79 : cp_parser_name_lookup_error
7371 : 79 : (parser, token->u.value, decl, NLE_NOT_CXX98,
7372 : : token->location);
7373 : : else
7374 : 23 : cp_parser_name_lookup_error
7375 : 23 : (parser, token->u.value, decl, NLE_CXX98,
7376 : : token->location);
7377 : : }
7378 : : }
7379 : 120 : parser->scope = error_mark_node;
7380 : 120 : error_p = true;
7381 : : /* Treat this as a successful nested-name-specifier
7382 : : due to:
7383 : :
7384 : : [basic.lookup.qual]
7385 : :
7386 : : If the name found is not a class-name (clause
7387 : : _class_) or namespace-name (_namespace.def_), the
7388 : : program is ill-formed. */
7389 : 120 : success = true;
7390 : : }
7391 : 125 : cp_lexer_consume_token (parser->lexer);
7392 : : }
7393 : : break;
7394 : : }
7395 : : /* We've found one valid nested-name-specifier. */
7396 : 170689512 : success = true;
7397 : : /* Name lookup always gives us a DECL. */
7398 : 170689512 : if (TREE_CODE (new_scope) == TYPE_DECL)
7399 : 77015736 : new_scope = TREE_TYPE (new_scope);
7400 : : /* Uses of "template" must be followed by actual templates. */
7401 : 170689512 : if (template_keyword_p)
7402 : 2823144 : check_template_keyword_in_nested_name_spec (new_scope);
7403 : : /* If it is a class scope, try to complete it; we are about to
7404 : : be looking up names inside the class. */
7405 : 170689512 : if (TYPE_P (new_scope)
7406 : : /* Since checking types for dependency can be expensive,
7407 : : avoid doing it if the type is already complete. */
7408 : 77024692 : && !COMPLETE_TYPE_P (new_scope)
7409 : : /* Do not try to complete dependent types. */
7410 : 218826206 : && !dependent_type_p (new_scope))
7411 : : {
7412 : 649867 : new_scope = complete_type (new_scope);
7413 : : /* If it is a typedef to current class, use the current
7414 : : class instead, as the typedef won't have any names inside
7415 : : it yet. */
7416 : 649864 : if (!COMPLETE_TYPE_P (new_scope)
7417 : 649864 : && currently_open_class (new_scope))
7418 : 43808 : new_scope = TYPE_MAIN_VARIANT (new_scope);
7419 : : }
7420 : : /* Make sure we look in the right scope the next time through
7421 : : the loop. */
7422 : 170689509 : parser->scope = new_scope;
7423 : : }
7424 : :
7425 : : /* If parsing tentatively, replace the sequence of tokens that makes
7426 : : up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
7427 : : token. That way, should we re-parse the token stream, we will
7428 : : not have to repeat the effort required to do the parse, nor will
7429 : : we issue duplicate error messages. */
7430 : 4505773448 : if (success && start)
7431 : : {
7432 : 132839104 : cp_token *token;
7433 : :
7434 : 132839104 : token = cp_lexer_token_at (parser->lexer, start);
7435 : : /* Reset the contents of the START token. */
7436 : 132839104 : token->type = CPP_NESTED_NAME_SPECIFIER;
7437 : : /* Retrieve any deferred checks. Do not pop this access checks yet
7438 : : so the memory will not be reclaimed during token replacing below. */
7439 : 132839104 : token->u.tree_check_value = ggc_cleared_alloc<struct tree_check> ();
7440 : 132839104 : token->tree_check_p = true;
7441 : 132839104 : token->u.tree_check_value->value = parser->scope;
7442 : 132839104 : token->u.tree_check_value->checks = get_deferred_access_checks ();
7443 : 132839104 : token->u.tree_check_value->qualifying_scope =
7444 : 132839104 : parser->qualifying_scope;
7445 : 132839104 : token->keyword = RID_MAX;
7446 : :
7447 : : /* Purge all subsequent tokens. */
7448 : 132839104 : cp_lexer_purge_tokens_after (parser->lexer, start);
7449 : : }
7450 : :
7451 : 4505773448 : if (start)
7452 : 3343089129 : pop_to_parent_deferring_access_checks ();
7453 : :
7454 : 4505773448 : return success ? parser->scope : NULL_TREE;
7455 : : }
7456 : :
7457 : : /* Parse a nested-name-specifier. See
7458 : : cp_parser_nested_name_specifier_opt for details. This function
7459 : : behaves identically, except that it will an issue an error if no
7460 : : nested-name-specifier is present. */
7461 : :
7462 : : static tree
7463 : 974753901 : cp_parser_nested_name_specifier (cp_parser *parser,
7464 : : bool typename_keyword_p,
7465 : : bool check_dependency_p,
7466 : : bool type_p,
7467 : : bool is_declaration)
7468 : : {
7469 : 974753901 : tree scope;
7470 : :
7471 : : /* Look for the nested-name-specifier. */
7472 : 974753901 : scope = cp_parser_nested_name_specifier_opt (parser,
7473 : : typename_keyword_p,
7474 : : check_dependency_p,
7475 : : type_p,
7476 : : is_declaration);
7477 : : /* If it was not present, issue an error message. */
7478 : 974753901 : if (!scope)
7479 : : {
7480 : 933759889 : cp_parser_error (parser, "expected nested-name-specifier");
7481 : 933759889 : parser->scope = NULL_TREE;
7482 : : }
7483 : :
7484 : 974753901 : return scope;
7485 : : }
7486 : :
7487 : : /* Parse the qualifying entity in a nested-name-specifier. For C++98,
7488 : : this is either a class-name or a namespace-name (which corresponds
7489 : : to the class-or-namespace-name production in the grammar). For
7490 : : C++0x, it can also be a type-name that refers to an enumeration
7491 : : type or a simple-template-id.
7492 : :
7493 : : TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
7494 : : TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
7495 : : CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
7496 : : TYPE_P is TRUE iff the next name should be taken as a class-name,
7497 : : even the same name is declared to be another entity in the same
7498 : : scope.
7499 : :
7500 : : Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
7501 : : specified by the class-or-namespace-name. If neither is found the
7502 : : ERROR_MARK_NODE is returned. */
7503 : :
7504 : : static tree
7505 : 398517234 : cp_parser_qualifying_entity (cp_parser *parser,
7506 : : bool typename_keyword_p,
7507 : : bool template_keyword_p,
7508 : : bool check_dependency_p,
7509 : : bool type_p,
7510 : : bool is_declaration)
7511 : : {
7512 : 398517234 : tree saved_scope;
7513 : 398517234 : tree saved_qualifying_scope;
7514 : 398517234 : tree saved_object_scope;
7515 : 398517234 : tree scope;
7516 : 398517234 : bool only_class_p;
7517 : 398517234 : bool successful_parse_p;
7518 : :
7519 : : /* DR 743: decltype can appear in a nested-name-specifier. */
7520 : 398517234 : if (cp_lexer_next_token_is_decltype (parser->lexer))
7521 : : {
7522 : 40691 : scope = cp_parser_decltype (parser);
7523 : 40691 : if (TREE_CODE (scope) != ENUMERAL_TYPE
7524 : 229 : && !MAYBE_CLASS_TYPE_P (scope))
7525 : : {
7526 : 760 : cp_parser_simulate_error (parser);
7527 : 380 : return error_mark_node;
7528 : : }
7529 : 40311 : if (TYPE_NAME (scope))
7530 : 659 : scope = TYPE_NAME (scope);
7531 : 40311 : return scope;
7532 : : }
7533 : :
7534 : : /* Before we try to parse the class-name, we must save away the
7535 : : current PARSER->SCOPE since cp_parser_class_name will destroy
7536 : : it. */
7537 : 398476543 : saved_scope = parser->scope;
7538 : 398476543 : saved_qualifying_scope = parser->qualifying_scope;
7539 : 398476543 : saved_object_scope = parser->object_scope;
7540 : : /* Try for a class-name first. If the SAVED_SCOPE is a type, then
7541 : : there is no need to look for a namespace-name. */
7542 : 1191322821 : only_class_p = template_keyword_p
7543 : 398476543 : || (saved_scope && TYPE_P (saved_scope) && cxx_dialect == cxx98);
7544 : 394369735 : if (!only_class_p)
7545 : 394369735 : cp_parser_parse_tentatively (parser);
7546 : 398476543 : scope = cp_parser_class_name (parser,
7547 : : typename_keyword_p,
7548 : : template_keyword_p,
7549 : : type_p ? class_type : none_type,
7550 : : check_dependency_p,
7551 : : /*class_head_p=*/false,
7552 : : is_declaration,
7553 : 398476543 : /*enum_ok=*/cxx_dialect > cxx98);
7554 : 398476540 : successful_parse_p = only_class_p || cp_parser_parse_definitely (parser);
7555 : :
7556 : : /* "T...[constant-expression]" is a C++26 pack-index-specifier. */
7557 : 220500209 : if (successful_parse_p
7558 : 220500209 : && cp_parser_next_tokens_are_pack_index_p (parser))
7559 : 80 : scope = cp_parser_pack_index (parser, scope);
7560 : :
7561 : : /* If that didn't work, try for a namespace-name. */
7562 : 398476540 : if (!only_class_p && !successful_parse_p)
7563 : : {
7564 : : /* Restore the saved scope. */
7565 : 177976331 : parser->scope = saved_scope;
7566 : 177976331 : parser->qualifying_scope = saved_qualifying_scope;
7567 : 177976331 : parser->object_scope = saved_object_scope;
7568 : : /* If we are not looking at an identifier followed by the scope
7569 : : resolution operator, then this is not part of a
7570 : : nested-name-specifier. (Note that this function is only used
7571 : : to parse the components of a nested-name-specifier.) */
7572 : 177976331 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
7573 : 177976331 : || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
7574 : 84311211 : return error_mark_node;
7575 : 93665120 : scope = cp_parser_namespace_name (parser);
7576 : : }
7577 : :
7578 : : return scope;
7579 : : }
7580 : :
7581 : : /* Return true if we are looking at a compound-literal, false otherwise. */
7582 : :
7583 : : static bool
7584 : 29472421 : cp_parser_compound_literal_p (cp_parser *parser)
7585 : : {
7586 : 29472421 : cp_lexer_save_tokens (parser->lexer);
7587 : :
7588 : : /* Skip tokens until the next token is a closing parenthesis.
7589 : : If we find the closing `)', and the next token is a `{', then
7590 : : we are looking at a compound-literal. */
7591 : 29472421 : bool compound_literal_p
7592 : 29472421 : = (cp_parser_skip_to_closing_parenthesis (parser, false, false,
7593 : : /*consume_paren=*/true)
7594 : 29472421 : && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
7595 : :
7596 : : /* Roll back the tokens we skipped. */
7597 : 29472421 : cp_lexer_rollback_tokens (parser->lexer);
7598 : :
7599 : 29472421 : return compound_literal_p;
7600 : : }
7601 : :
7602 : : /* Return true if EXPR is the integer constant zero or a complex constant
7603 : : of zero, without any folding, but ignoring location wrappers. */
7604 : :
7605 : : bool
7606 : 217370 : literal_integer_zerop (const_tree expr)
7607 : : {
7608 : 217370 : return (location_wrapper_p (expr)
7609 : 217370 : && integer_zerop (TREE_OPERAND (expr, 0)));
7610 : : }
7611 : :
7612 : : /* Parse a postfix-expression.
7613 : :
7614 : : postfix-expression:
7615 : : primary-expression
7616 : : postfix-expression [ expression ]
7617 : : postfix-expression ( expression-list [opt] )
7618 : : simple-type-specifier ( expression-list [opt] )
7619 : : typename :: [opt] nested-name-specifier identifier
7620 : : ( expression-list [opt] )
7621 : : typename :: [opt] nested-name-specifier template [opt] template-id
7622 : : ( expression-list [opt] )
7623 : : postfix-expression . template [opt] id-expression
7624 : : postfix-expression -> template [opt] id-expression
7625 : : postfix-expression . pseudo-destructor-name
7626 : : postfix-expression -> pseudo-destructor-name
7627 : : postfix-expression ++
7628 : : postfix-expression --
7629 : : dynamic_cast < type-id > ( expression )
7630 : : static_cast < type-id > ( expression )
7631 : : reinterpret_cast < type-id > ( expression )
7632 : : const_cast < type-id > ( expression )
7633 : : typeid ( expression )
7634 : : typeid ( type-id )
7635 : :
7636 : : GNU Extension:
7637 : :
7638 : : postfix-expression:
7639 : : ( type-id ) { initializer-list , [opt] }
7640 : :
7641 : : This extension is a GNU version of the C99 compound-literal
7642 : : construct. (The C99 grammar uses `type-name' instead of `type-id',
7643 : : but they are essentially the same concept.)
7644 : :
7645 : : If ADDRESS_P is true, the postfix expression is the operand of the
7646 : : `&' operator. CAST_P is true if this expression is the target of a
7647 : : cast.
7648 : :
7649 : : If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
7650 : : class member access expressions [expr.ref].
7651 : :
7652 : : Returns a representation of the expression. */
7653 : :
7654 : : static cp_expr
7655 : 868432769 : cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
7656 : : bool member_access_only_p, bool decltype_p,
7657 : : cp_id_kind * pidk_return)
7658 : : {
7659 : 868432769 : cp_token *token;
7660 : 868432769 : location_t loc;
7661 : 868432769 : enum rid keyword;
7662 : 868432769 : cp_id_kind idk = CP_ID_KIND_NONE;
7663 : 868432769 : cp_expr postfix_expression = NULL_TREE;
7664 : 868432769 : bool is_member_access = false;
7665 : :
7666 : : /* Peek at the next token. */
7667 : 868432769 : token = cp_lexer_peek_token (parser->lexer);
7668 : 868432769 : loc = token->location;
7669 : 868432769 : location_t start_loc = get_range_from_loc (line_table, loc).m_start;
7670 : :
7671 : : /* Some of the productions are determined by keywords. */
7672 : 868432769 : keyword = token->keyword;
7673 : 868432769 : switch (keyword)
7674 : : {
7675 : 7554505 : case RID_DYNCAST:
7676 : 7554505 : case RID_STATCAST:
7677 : 7554505 : case RID_REINTCAST:
7678 : 7554505 : case RID_CONSTCAST:
7679 : 7554505 : {
7680 : 7554505 : tree type;
7681 : 7554505 : cp_expr expression;
7682 : 7554505 : const char *saved_message;
7683 : :
7684 : : /* All of these can be handled in the same way from the point
7685 : : of view of parsing. Begin by consuming the token
7686 : : identifying the cast. */
7687 : 7554505 : cp_lexer_consume_token (parser->lexer);
7688 : :
7689 : : /* New types cannot be defined in the cast. */
7690 : 7554505 : saved_message = parser->type_definition_forbidden_message;
7691 : 7554505 : parser->type_definition_forbidden_message
7692 : 7554505 : = G_("types may not be defined in casts");
7693 : :
7694 : : /* Look for the opening `<'. */
7695 : 7554505 : cp_parser_require (parser, CPP_LESS, RT_LESS);
7696 : : /* Parse the type to which we are casting. */
7697 : 7554505 : {
7698 : 7554505 : type_id_in_expr_sentinel s (parser);
7699 : 7554505 : type = cp_parser_type_id (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
7700 : : NULL);
7701 : 7554505 : }
7702 : : /* Look for the closing `>'. */
7703 : 7554505 : cp_parser_require_end_of_template_parameter_list (parser);
7704 : : /* Restore the old message. */
7705 : 7554505 : parser->type_definition_forbidden_message = saved_message;
7706 : :
7707 : 7554505 : bool saved_greater_than_is_operator_p
7708 : : = parser->greater_than_is_operator_p;
7709 : 7554505 : parser->greater_than_is_operator_p = true;
7710 : :
7711 : : /* And the expression which is being cast. */
7712 : 7554505 : matching_parens parens;
7713 : 7554505 : parens.require_open (parser);
7714 : 7554505 : expression = cp_parser_expression (parser, & idk, /*cast_p=*/true);
7715 : 7554505 : cp_token *close_paren = cp_parser_require (parser, CPP_CLOSE_PAREN,
7716 : : RT_CLOSE_PAREN);
7717 : 7554505 : location_t end_loc = close_paren ?
7718 : : close_paren->location : UNKNOWN_LOCATION;
7719 : :
7720 : 7554505 : parser->greater_than_is_operator_p
7721 : 7554505 : = saved_greater_than_is_operator_p;
7722 : :
7723 : : /* Only type conversions to integral or enumeration types
7724 : : can be used in constant-expressions. */
7725 : 7554505 : if (!cast_valid_in_integral_constant_expression_p (type)
7726 : 7554505 : && cp_parser_non_integral_constant_expression (parser, NIC_CAST))
7727 : : {
7728 : 2 : postfix_expression = error_mark_node;
7729 : 2 : break;
7730 : : }
7731 : :
7732 : : /* Construct a location e.g. :
7733 : : reinterpret_cast <int *> (expr)
7734 : : ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7735 : : ranging from the start of the "*_cast" token to the final closing
7736 : : paren, with the caret at the start. */
7737 : 7554503 : location_t cp_cast_loc = make_location (start_loc, start_loc, end_loc);
7738 : :
7739 : 7554503 : switch (keyword)
7740 : : {
7741 : 48671 : case RID_DYNCAST:
7742 : 48671 : postfix_expression
7743 : 48671 : = build_dynamic_cast (cp_cast_loc, type, expression,
7744 : 48671 : tf_warning_or_error);
7745 : 48671 : break;
7746 : 6645745 : case RID_STATCAST:
7747 : 6645745 : postfix_expression
7748 : 6645745 : = build_static_cast (cp_cast_loc, type, expression,
7749 : 6645745 : tf_warning_or_error);
7750 : 6645745 : break;
7751 : 465076 : case RID_REINTCAST:
7752 : 465076 : postfix_expression
7753 : 465076 : = build_reinterpret_cast (cp_cast_loc, type, expression,
7754 : 465076 : tf_warning_or_error);
7755 : 465076 : break;
7756 : 395011 : case RID_CONSTCAST:
7757 : 395011 : postfix_expression
7758 : 395011 : = build_const_cast (cp_cast_loc, type, expression,
7759 : 395011 : tf_warning_or_error);
7760 : 395011 : break;
7761 : : default:
7762 : : gcc_unreachable ();
7763 : : }
7764 : : }
7765 : 7554503 : break;
7766 : :
7767 : 131511 : case RID_TYPEID:
7768 : 131511 : {
7769 : 131511 : tree type;
7770 : 131511 : const char *saved_message;
7771 : :
7772 : : /* Consume the `typeid' token. */
7773 : 131511 : cp_lexer_consume_token (parser->lexer);
7774 : : /* Look for the `(' token. */
7775 : 131511 : matching_parens parens;
7776 : 131511 : parens.require_open (parser);
7777 : : /* Types cannot be defined in a `typeid' expression. */
7778 : 131511 : saved_message = parser->type_definition_forbidden_message;
7779 : 131511 : parser->type_definition_forbidden_message
7780 : 131511 : = G_("types may not be defined in a %<typeid%> expression");
7781 : : /* We can't be sure yet whether we're looking at a type-id or an
7782 : : expression. */
7783 : 131511 : cp_parser_parse_tentatively (parser);
7784 : : /* Try a type-id first. */
7785 : 131511 : {
7786 : 131511 : type_id_in_expr_sentinel s (parser);
7787 : 131511 : type = cp_parser_type_id (parser);
7788 : 131511 : }
7789 : : /* Look for the `)' token. Otherwise, we can't be sure that
7790 : : we're not looking at an expression: consider `typeid (int
7791 : : (3))', for example. */
7792 : 131511 : cp_token *close_paren = parens.require_close (parser);
7793 : : /* If all went well, simply lookup the type-id. */
7794 : 131511 : if (cp_parser_parse_definitely (parser))
7795 : 129273 : postfix_expression = get_typeid (type, tf_warning_or_error);
7796 : : /* Otherwise, fall back to the expression variant. */
7797 : : else
7798 : : {
7799 : 2238 : tree expression;
7800 : :
7801 : : /* Look for an expression. */
7802 : 2238 : expression = cp_parser_expression (parser, & idk);
7803 : : /* Compute its typeid. */
7804 : 2238 : postfix_expression = build_typeid (expression, tf_warning_or_error);
7805 : : /* Look for the `)' token. */
7806 : 2238 : close_paren = parens.require_close (parser);
7807 : : }
7808 : : /* Restore the saved message. */
7809 : 131511 : parser->type_definition_forbidden_message = saved_message;
7810 : : /* `typeid' may not appear in an integral constant expression. */
7811 : 131511 : if (cp_parser_non_integral_constant_expression (parser, NIC_TYPEID))
7812 : 1 : postfix_expression = error_mark_node;
7813 : :
7814 : : /* Construct a location e.g. :
7815 : : typeid (expr)
7816 : : ^~~~~~~~~~~~~
7817 : : ranging from the start of the "typeid" token to the final closing
7818 : : paren, with the caret at the start. */
7819 : 131511 : if (close_paren)
7820 : : {
7821 : 131500 : location_t typeid_loc
7822 : 131500 : = make_location (start_loc, start_loc, close_paren->location);
7823 : 131500 : postfix_expression.set_location (typeid_loc);
7824 : 131500 : postfix_expression.maybe_add_location_wrapper ();
7825 : : }
7826 : : }
7827 : 131511 : break;
7828 : :
7829 : 194986 : case RID_TYPENAME:
7830 : 194986 : {
7831 : 194986 : tree type;
7832 : : /* The syntax permitted here is the same permitted for an
7833 : : elaborated-type-specifier. */
7834 : 194986 : ++parser->prevent_constrained_type_specifiers;
7835 : 194986 : type = cp_parser_elaborated_type_specifier (parser,
7836 : : /*is_friend=*/false,
7837 : : /*is_declaration=*/false);
7838 : 194986 : --parser->prevent_constrained_type_specifiers;
7839 : 194986 : postfix_expression = cp_parser_functional_cast (parser, type);
7840 : : }
7841 : 194986 : break;
7842 : :
7843 : 334494 : case RID_ADDRESSOF:
7844 : 334494 : case RID_BUILTIN_SHUFFLE:
7845 : 334494 : case RID_BUILTIN_SHUFFLEVECTOR:
7846 : 334494 : case RID_BUILTIN_LAUNDER:
7847 : 334494 : case RID_BUILTIN_ASSOC_BARRIER:
7848 : 334494 : case RID_BUILTIN_OPERATOR_NEW:
7849 : 334494 : case RID_BUILTIN_OPERATOR_DELETE:
7850 : 334494 : {
7851 : 334494 : vec<tree, va_gc> *vec;
7852 : :
7853 : 334494 : cp_lexer_consume_token (parser->lexer);
7854 : 334494 : vec = cp_parser_parenthesized_expression_list (parser, non_attr,
7855 : : /*cast_p=*/false, /*allow_expansion_p=*/true,
7856 : : /*non_constant_p=*/NULL);
7857 : 334494 : if (vec == NULL)
7858 : : {
7859 : 0 : postfix_expression = error_mark_node;
7860 : 0 : break;
7861 : : }
7862 : :
7863 : 1261947 : for (tree p : *vec)
7864 : 927453 : mark_exp_read (p);
7865 : :
7866 : 334494 : switch (keyword)
7867 : : {
7868 : 166286 : case RID_ADDRESSOF:
7869 : 166286 : if (vec->length () == 1)
7870 : 166286 : postfix_expression
7871 : 166286 : = cp_build_addressof (loc, (*vec)[0], tf_warning_or_error);
7872 : : else
7873 : : {
7874 : 0 : error_at (loc, "wrong number of arguments to "
7875 : : "%<__builtin_addressof%>");
7876 : 0 : postfix_expression = error_mark_node;
7877 : : }
7878 : : break;
7879 : :
7880 : 12238 : case RID_BUILTIN_LAUNDER:
7881 : 12238 : if (vec->length () == 1)
7882 : 24458 : postfix_expression = finish_builtin_launder (loc, (*vec)[0],
7883 : 12229 : tf_warning_or_error);
7884 : : else
7885 : : {
7886 : 9 : error_at (loc, "wrong number of arguments to "
7887 : : "%<__builtin_launder%>");
7888 : 9 : postfix_expression = error_mark_node;
7889 : : }
7890 : : break;
7891 : :
7892 : 11 : case RID_BUILTIN_ASSOC_BARRIER:
7893 : 11 : if (vec->length () == 1)
7894 : 11 : postfix_expression = build1_loc (loc, PAREN_EXPR,
7895 : 11 : TREE_TYPE ((*vec)[0]),
7896 : 11 : (*vec)[0]);
7897 : : else
7898 : : {
7899 : 0 : error_at (loc, "wrong number of arguments to "
7900 : : "%<__builtin_assoc_barrier%>");
7901 : 0 : postfix_expression = error_mark_node;
7902 : : }
7903 : : break;
7904 : :
7905 : 14531 : case RID_BUILTIN_SHUFFLE:
7906 : 14531 : if (vec->length () == 2)
7907 : 13740 : postfix_expression
7908 : 13740 : = build_x_vec_perm_expr (loc, (*vec)[0], NULL_TREE,
7909 : 13740 : (*vec)[1], tf_warning_or_error);
7910 : 791 : else if (vec->length () == 3)
7911 : 791 : postfix_expression
7912 : 791 : = build_x_vec_perm_expr (loc, (*vec)[0], (*vec)[1],
7913 : 791 : (*vec)[2], tf_warning_or_error);
7914 : : else
7915 : : {
7916 : 0 : error_at (loc, "wrong number of arguments to "
7917 : : "%<__builtin_shuffle%>");
7918 : 0 : postfix_expression = error_mark_node;
7919 : : }
7920 : : break;
7921 : :
7922 : 33983 : case RID_BUILTIN_SHUFFLEVECTOR:
7923 : 33983 : if (vec->length () < 3)
7924 : : {
7925 : 0 : error_at (loc, "wrong number of arguments to "
7926 : : "%<__builtin_shufflevector%>");
7927 : 0 : postfix_expression = error_mark_node;
7928 : : }
7929 : : else
7930 : : {
7931 : 33983 : postfix_expression
7932 : 33983 : = build_x_shufflevector (loc, vec, tf_warning_or_error);
7933 : : }
7934 : : break;
7935 : :
7936 : 107445 : case RID_BUILTIN_OPERATOR_NEW:
7937 : 107445 : case RID_BUILTIN_OPERATOR_DELETE:
7938 : 107445 : tree fn;
7939 : 107445 : fn = ovl_op_identifier (keyword == RID_BUILTIN_OPERATOR_NEW
7940 : : ? NEW_EXPR : DELETE_EXPR);
7941 : 107445 : fn = lookup_qualified_name (global_namespace, fn);
7942 : 214890 : postfix_expression = finish_call_expr (fn, &vec, true, false,
7943 : 107445 : tf_warning_or_error);
7944 : 107445 : if (postfix_expression != error_mark_node)
7945 : : {
7946 : 107421 : tree call = extract_call_expr (postfix_expression);
7947 : 107421 : fn = cp_get_callee_fndecl_nofold (call);
7948 : 214842 : if (fn ? !DECL_IS_REPLACEABLE_OPERATOR (fn)
7949 : 63728 : : !processing_template_decl)
7950 : : {
7951 : 18 : auto_diagnostic_group d;
7952 : 18 : if (keyword == RID_BUILTIN_OPERATOR_NEW)
7953 : 12 : error_at (loc, "call to %<__builtin_operator_new%> "
7954 : : "does not select replaceable global "
7955 : : "allocation function");
7956 : : else
7957 : 6 : error_at (loc, "call to %<__builtin_operator_delete%> "
7958 : : "does not select replaceable global "
7959 : : "deallocation function");
7960 : 18 : if (fn)
7961 : 18 : inform (DECL_SOURCE_LOCATION (fn),
7962 : : "selected function declared here");
7963 : 18 : }
7964 : 107403 : else if (call && TREE_CODE (call) == CALL_EXPR)
7965 : 107403 : CALL_FROM_NEW_OR_DELETE_P (call) = 1;
7966 : : }
7967 : : break;
7968 : :
7969 : 0 : default:
7970 : 0 : gcc_unreachable ();
7971 : : }
7972 : : break;
7973 : : }
7974 : :
7975 : 158 : case RID_BUILTIN_CONVERTVECTOR:
7976 : 158 : {
7977 : 158 : tree expression;
7978 : 158 : tree type;
7979 : : /* Consume the `__builtin_convertvector' token. */
7980 : 158 : cp_lexer_consume_token (parser->lexer);
7981 : : /* Look for the opening `('. */
7982 : 158 : matching_parens parens;
7983 : 158 : parens.require_open (parser);
7984 : : /* Now, parse the assignment-expression. */
7985 : 158 : expression = cp_parser_assignment_expression (parser);
7986 : : /* Look for the `,'. */
7987 : 158 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
7988 : 158 : location_t type_location
7989 : 158 : = cp_lexer_peek_token (parser->lexer)->location;
7990 : : /* Parse the type-id. */
7991 : 158 : {
7992 : 158 : type_id_in_expr_sentinel s (parser);
7993 : 158 : type = cp_parser_type_id (parser);
7994 : 158 : }
7995 : : /* Look for the closing `)'. */
7996 : 158 : parens.require_close (parser);
7997 : 158 : postfix_expression
7998 : 158 : = cp_build_vec_convert (expression, type_location, type,
7999 : 158 : tf_warning_or_error);
8000 : 158 : break;
8001 : : }
8002 : :
8003 : 31630 : case RID_BUILTIN_BIT_CAST:
8004 : 31630 : {
8005 : 31630 : tree expression;
8006 : 31630 : tree type;
8007 : : /* Consume the `__builtin_bit_cast' token. */
8008 : 31630 : cp_lexer_consume_token (parser->lexer);
8009 : : /* Look for the opening `('. */
8010 : 31630 : matching_parens parens;
8011 : 31630 : parens.require_open (parser);
8012 : 31630 : location_t type_location
8013 : 31630 : = cp_lexer_peek_token (parser->lexer)->location;
8014 : : /* Parse the type-id. */
8015 : 31630 : {
8016 : 31630 : type_id_in_expr_sentinel s (parser);
8017 : 31630 : type = cp_parser_type_id (parser);
8018 : 31630 : }
8019 : : /* Look for the `,'. */
8020 : 31630 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
8021 : : /* Now, parse the assignment-expression. */
8022 : 31630 : expression = cp_parser_assignment_expression (parser);
8023 : : /* Look for the closing `)'. */
8024 : 31630 : parens.require_close (parser);
8025 : 31630 : postfix_expression
8026 : 31630 : = cp_build_bit_cast (type_location, type, expression,
8027 : 31630 : tf_warning_or_error);
8028 : 31630 : break;
8029 : : }
8030 : :
8031 : 860185485 : default:
8032 : 860185485 : {
8033 : 860185485 : tree type;
8034 : :
8035 : : /* If the next thing is a simple-type-specifier, we may be
8036 : : looking at a functional cast. We could also be looking at
8037 : : an id-expression. So, we try the functional cast, and if
8038 : : that doesn't work we fall back to the primary-expression. */
8039 : 860185485 : cp_parser_parse_tentatively (parser);
8040 : : /* Look for the simple-type-specifier. */
8041 : 860185485 : ++parser->prevent_constrained_type_specifiers;
8042 : 860185485 : type = cp_parser_simple_type_specifier (parser,
8043 : : /*decl_specs=*/NULL,
8044 : : CP_PARSER_FLAGS_NONE);
8045 : 860185485 : --parser->prevent_constrained_type_specifiers;
8046 : : /* Parse the cast itself. */
8047 : 1760217544 : if (!cp_parser_error_occurred (parser))
8048 : : {
8049 : 39846574 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
8050 : : /* This can only be a cast. */
8051 : 3390540 : cp_parser_commit_to_topmost_tentative_parse (parser);
8052 : 39846574 : postfix_expression
8053 : 39846574 : = cp_parser_functional_cast (parser, type);
8054 : : }
8055 : : /* If that worked, we're done. */
8056 : 860185485 : if (cp_parser_parse_definitely (parser))
8057 : : break;
8058 : :
8059 : : /* If the functional-cast didn't work out, try a
8060 : : compound-literal. */
8061 : 820339551 : if (cp_parser_allow_gnu_extensions_p (parser)
8062 : 820339551 : && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
8063 : : {
8064 : 26010253 : cp_expr initializer = NULL_TREE;
8065 : :
8066 : 26010253 : cp_parser_parse_tentatively (parser);
8067 : :
8068 : 26010253 : matching_parens parens;
8069 : 26010253 : parens.consume_open (parser);
8070 : :
8071 : : /* Avoid calling cp_parser_type_id pointlessly, see comment
8072 : : in cp_parser_cast_expression about c++/29234. */
8073 : 26010253 : if (!cp_parser_compound_literal_p (parser))
8074 : 51988259 : cp_parser_simulate_error (parser);
8075 : : else
8076 : : {
8077 : : /* Parse the type. */
8078 : 32247 : type_id_in_expr_sentinel s (parser);
8079 : 32247 : type = cp_parser_type_id (parser);
8080 : 32247 : parens.require_close (parser);
8081 : 32247 : }
8082 : :
8083 : : /* If things aren't going well, there's no need to
8084 : : keep going. */
8085 : 52052724 : if (!cp_parser_error_occurred (parser))
8086 : : /* Parse the brace-enclosed initializer list. */
8087 : 32218 : initializer = cp_parser_braced_list (parser);
8088 : : /* If that worked, we're definitely looking at a
8089 : : compound-literal expression. */
8090 : 26010253 : if (cp_parser_parse_definitely (parser))
8091 : : {
8092 : : /* Warn the user that a compound literal is not
8093 : : allowed in standard C++. */
8094 : 32212 : pedwarn (input_location, OPT_Wpedantic,
8095 : : "ISO C++ forbids compound-literals");
8096 : : /* For simplicity, we disallow compound literals in
8097 : : constant-expressions. We could
8098 : : allow compound literals of integer type, whose
8099 : : initializer was a constant, in constant
8100 : : expressions. Permitting that usage, as a further
8101 : : extension, would not change the meaning of any
8102 : : currently accepted programs. (Of course, as
8103 : : compound literals are not part of ISO C++, the
8104 : : standard has nothing to say.) */
8105 : 32212 : if (cp_parser_non_integral_constant_expression (parser,
8106 : : NIC_NCC))
8107 : : {
8108 : 0 : postfix_expression = error_mark_node;
8109 : 32212 : break;
8110 : : }
8111 : : /* Form the representation of the compound-literal. */
8112 : 32212 : postfix_expression
8113 : 32212 : = finish_compound_literal (type, initializer,
8114 : 32212 : tf_warning_or_error, fcl_c99);
8115 : 32212 : postfix_expression.set_location (initializer.get_location ());
8116 : 32212 : break;
8117 : : }
8118 : : }
8119 : :
8120 : : /* It must be a primary-expression. */
8121 : 820307339 : postfix_expression
8122 : 820307339 : = cp_parser_primary_expression (parser, address_p, cast_p,
8123 : : /*template_arg_p=*/false,
8124 : : decltype_p,
8125 : : &idk);
8126 : : }
8127 : 820307336 : break;
8128 : : }
8129 : :
8130 : : /* Note that we don't need to worry about calling build_cplus_new on a
8131 : : class-valued CALL_EXPR in decltype when it isn't the end of the
8132 : : postfix-expression; unary_complex_lvalue will take care of that for
8133 : : all these cases. */
8134 : :
8135 : : /* Keep looping until the postfix-expression is complete. */
8136 : 1188909598 : while (true)
8137 : : {
8138 : 1188909598 : if (idk == CP_ID_KIND_UNQUALIFIED
8139 : 168088294 : && identifier_p (postfix_expression)
8140 : 1188997327 : && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
8141 : : /* It is not a Koenig lookup function call. */
8142 : 1213 : postfix_expression
8143 : 1213 : = unqualified_name_lookup_error (postfix_expression);
8144 : :
8145 : : /* Peek at the next token. */
8146 : 1188909598 : token = cp_lexer_peek_token (parser->lexer);
8147 : :
8148 : 1188909598 : switch (token->type)
8149 : : {
8150 : 9970663 : case CPP_OPEN_SQUARE:
8151 : 9970663 : if (cp_next_tokens_can_be_std_attribute_p (parser))
8152 : : {
8153 : 10 : cp_parser_error (parser,
8154 : : "two consecutive %<[%> shall "
8155 : : "only introduce an attribute");
8156 : 10 : return error_mark_node;
8157 : : }
8158 : 9970653 : postfix_expression
8159 : 9970653 : = cp_parser_postfix_open_square_expression (parser,
8160 : : postfix_expression,
8161 : : false,
8162 : 9970653 : decltype_p);
8163 : 9970653 : postfix_expression.set_range (start_loc,
8164 : : postfix_expression.get_location ());
8165 : :
8166 : 9970653 : idk = CP_ID_KIND_NONE;
8167 : 9970653 : is_member_access = false;
8168 : 9970653 : break;
8169 : :
8170 : 190735125 : case CPP_OPEN_PAREN:
8171 : : /* postfix-expression ( expression-list [opt] ) */
8172 : 190735125 : {
8173 : 190735125 : bool koenig_p;
8174 : 190735125 : bool is_builtin_constant_p;
8175 : 190735125 : bool saved_integral_constant_expression_p = false;
8176 : 190735125 : bool saved_non_integral_constant_expression_p = false;
8177 : 190735125 : tsubst_flags_t complain = complain_flags (decltype_p);
8178 : 190735125 : vec<tree, va_gc> *args;
8179 : 190735125 : location_t close_paren_loc = UNKNOWN_LOCATION;
8180 : 190735125 : location_t combined_loc = UNKNOWN_LOCATION;
8181 : :
8182 : 190735125 : is_member_access = false;
8183 : :
8184 : 190735125 : tree stripped_expression
8185 : 190735125 : = tree_strip_any_location_wrapper (postfix_expression);
8186 : 190735125 : is_builtin_constant_p
8187 : 190735125 : = DECL_IS_BUILTIN_CONSTANT_P (stripped_expression);
8188 : 190735125 : if (is_builtin_constant_p)
8189 : : {
8190 : : /* The whole point of __builtin_constant_p is to allow
8191 : : non-constant expressions to appear as arguments. */
8192 : 69366 : saved_integral_constant_expression_p
8193 : 69366 : = parser->integral_constant_expression_p;
8194 : 69366 : saved_non_integral_constant_expression_p
8195 : 69366 : = parser->non_integral_constant_expression_p;
8196 : 69366 : parser->integral_constant_expression_p = false;
8197 : : }
8198 : 190665759 : else if (TREE_CODE (stripped_expression) == FUNCTION_DECL
8199 : 190665759 : && fndecl_built_in_p (stripped_expression,
8200 : : BUILT_IN_CLASSIFY_TYPE))
8201 : : {
8202 : : /* __builtin_classify_type (type) */
8203 : 406 : auto cl1 = make_temp_override
8204 : 406 : (parser->type_definition_forbidden_message,
8205 : : G_("types may not be defined in "
8206 : 406 : "%<__builtin_classify_type%> calls"));
8207 : 406 : auto cl2 = make_temp_override
8208 : 406 : (parser->type_definition_forbidden_message_arg,
8209 : 406 : NULL);
8210 : 406 : auto cl3 = make_temp_override (parser->in_type_id_in_expr_p,
8211 : 406 : true);
8212 : 406 : cp_unevaluated uev;
8213 : 406 : cp_parser_parse_tentatively (parser);
8214 : 406 : matching_parens parens;
8215 : 406 : parens.consume_open (parser);
8216 : 406 : tree type = cp_parser_type_id (parser);
8217 : 406 : parens.require_close (parser);
8218 : 406 : if (cp_parser_parse_definitely (parser))
8219 : : {
8220 : 258 : if (dependent_type_p (type))
8221 : : {
8222 : 99 : postfix_expression = build_vl_exp (CALL_EXPR, 4);
8223 : 99 : CALL_EXPR_FN (postfix_expression)
8224 : 99 : = stripped_expression;
8225 : 99 : CALL_EXPR_STATIC_CHAIN (postfix_expression) = type;
8226 : 99 : CALL_EXPR_ARG (postfix_expression, 0)
8227 : 99 : = build_min (SIZEOF_EXPR, size_type_node, type);
8228 : 99 : TREE_TYPE (postfix_expression) = integer_type_node;
8229 : : }
8230 : : else
8231 : : {
8232 : 159 : postfix_expression
8233 : 159 : = build_int_cst (integer_type_node,
8234 : 159 : type_to_class (type));
8235 : : }
8236 : 258 : break;
8237 : : }
8238 : 406 : }
8239 : 381469734 : args = (cp_parser_parenthesized_expression_list
8240 : 190734867 : (parser, non_attr,
8241 : : /*cast_p=*/false, /*allow_expansion_p=*/true,
8242 : : /*non_constant_p=*/NULL,
8243 : : /*close_paren_loc=*/&close_paren_loc,
8244 : : /*wrap_locations_p=*/true));
8245 : 190734867 : if (is_builtin_constant_p)
8246 : : {
8247 : 69366 : parser->integral_constant_expression_p
8248 : 69366 : = saved_integral_constant_expression_p;
8249 : 69366 : parser->non_integral_constant_expression_p
8250 : 69366 : = saved_non_integral_constant_expression_p;
8251 : : }
8252 : :
8253 : 190734867 : if (args == NULL)
8254 : : {
8255 : 29 : postfix_expression = error_mark_node;
8256 : 29 : break;
8257 : : }
8258 : :
8259 : : /* Function calls are not permitted in
8260 : : constant-expressions. */
8261 : 190734838 : if (! builtin_valid_in_constant_expr_p (postfix_expression)
8262 : 190734838 : && cp_parser_non_integral_constant_expression (parser,
8263 : : NIC_FUNC_CALL))
8264 : : {
8265 : 4 : postfix_expression = error_mark_node;
8266 : 4 : release_tree_vector (args);
8267 : 4 : break;
8268 : : }
8269 : :
8270 : 190734834 : koenig_p = false;
8271 : 190734834 : if (idk == CP_ID_KIND_UNQUALIFIED
8272 : 167047434 : || idk == CP_ID_KIND_TEMPLATE_ID)
8273 : : {
8274 : 27974396 : if (identifier_p (postfix_expression)
8275 : : /* In C++20, we may need to perform ADL for a template
8276 : : name. */
8277 : 27887888 : || (TREE_CODE (postfix_expression) == TEMPLATE_ID_EXPR
8278 : 1762915 : && identifier_p (TREE_OPERAND (postfix_expression, 0))))
8279 : : {
8280 : 86562 : if (!args->is_empty ())
8281 : : {
8282 : 86426 : koenig_p = true;
8283 : 86426 : if (!any_type_dependent_arguments_p (args))
8284 : 21130 : postfix_expression
8285 : 21130 : = perform_koenig_lookup (postfix_expression, args,
8286 : : complain);
8287 : : }
8288 : : else
8289 : 136 : postfix_expression
8290 : 136 : = unqualified_fn_lookup_error (postfix_expression);
8291 : : }
8292 : : /* We do not perform argument-dependent lookup if
8293 : : normal lookup finds a non-function, in accordance
8294 : : with the expected resolution of DR 218. */
8295 : 27887834 : else if (!args->is_empty ()
8296 : 27887834 : && is_overloaded_fn (postfix_expression))
8297 : : {
8298 : : /* Do not do argument dependent lookup if regular
8299 : : lookup finds a member function or a block-scope
8300 : : function declaration. [basic.lookup.argdep]/3 */
8301 : 21671324 : bool do_adl_p = true;
8302 : 21671324 : tree fns = get_fns (postfix_expression);
8303 : 64879848 : for (lkp_iterator iter (fns); iter; ++iter)
8304 : : {
8305 : 46083386 : tree fn = STRIP_TEMPLATE (*iter);
8306 : 46083386 : if ((TREE_CODE (fn) == USING_DECL
8307 : 9 : && DECL_DEPENDENT_P (fn))
8308 : 46083377 : || DECL_FUNCTION_MEMBER_P (fn)
8309 : 89296120 : || DECL_LOCAL_DECL_P (fn))
8310 : : {
8311 : : do_adl_p = false;
8312 : : break;
8313 : : }
8314 : : }
8315 : :
8316 : 21671324 : if (do_adl_p)
8317 : : {
8318 : 18796462 : koenig_p = true;
8319 : 18796462 : if (!any_type_dependent_arguments_p (args))
8320 : 10691403 : postfix_expression
8321 : 10691403 : = perform_koenig_lookup (postfix_expression, args,
8322 : : complain);
8323 : : }
8324 : : }
8325 : : }
8326 : :
8327 : : /* Temporarily set input_location to the combined location
8328 : : with call expression range, as e.g. build_out_target_exprs
8329 : : called from convert_default_arg relies on input_location,
8330 : : so updating it only when the call is fully built results
8331 : : in inconsistencies between location handling in templates
8332 : : and outside of templates. */
8333 : 190734834 : if (close_paren_loc != UNKNOWN_LOCATION)
8334 : 190734605 : combined_loc = make_location (token->location, start_loc,
8335 : : close_paren_loc);
8336 : 190734834 : iloc_sentinel ils (combined_loc);
8337 : :
8338 : 190734834 : if (TREE_CODE (postfix_expression) == OFFSET_REF
8339 : : || TREE_CODE (postfix_expression) == MEMBER_REF
8340 : : || TREE_CODE (postfix_expression) == DOTSTAR_EXPR)
8341 : 241027 : postfix_expression = (build_offset_ref_call_from_tree
8342 : : (postfix_expression, &args,
8343 : 241027 : complain));
8344 : : else
8345 : : /* All other function calls. */
8346 : : {
8347 : 190493807 : if (DECL_P (postfix_expression)
8348 : 8862420 : && parser->omp_for_parse_state
8349 : 691 : && parser->omp_for_parse_state->in_intervening_code
8350 : 190494203 : && omp_runtime_api_call (postfix_expression))
8351 : : {
8352 : 12 : error_at (loc, "calls to the OpenMP runtime API are "
8353 : : "not permitted in intervening code");
8354 : 12 : parser->omp_for_parse_state->fail = true;
8355 : : }
8356 : 190493807 : bool disallow_virtual = (idk == CP_ID_KIND_QUALIFIED);
8357 : 190493807 : postfix_expression
8358 : 190493792 : = finish_call_expr (postfix_expression, &args,
8359 : : disallow_virtual,
8360 : : koenig_p,
8361 : 190493807 : complain);
8362 : : }
8363 : :
8364 : 190734819 : if (close_paren_loc != UNKNOWN_LOCATION)
8365 : 190734590 : postfix_expression.set_location (combined_loc);
8366 : :
8367 : : /* The POSTFIX_EXPRESSION is certainly no longer an id. */
8368 : 190734819 : idk = CP_ID_KIND_NONE;
8369 : :
8370 : 190734819 : release_tree_vector (args);
8371 : 190734819 : }
8372 : 190734819 : break;
8373 : :
8374 : 117606937 : case CPP_DOT:
8375 : 117606937 : case CPP_DEREF:
8376 : : /* postfix-expression . template [opt] id-expression
8377 : : postfix-expression . pseudo-destructor-name
8378 : : postfix-expression -> template [opt] id-expression
8379 : : postfix-expression -> pseudo-destructor-name */
8380 : :
8381 : : /* Consume the `.' or `->' operator. */
8382 : 117606937 : cp_lexer_consume_token (parser->lexer);
8383 : :
8384 : 117606937 : postfix_expression
8385 : 235213871 : = cp_parser_postfix_dot_deref_expression (parser, token->type,
8386 : : postfix_expression,
8387 : 117606937 : false, &idk, loc);
8388 : :
8389 : 117606934 : is_member_access = true;
8390 : 117606934 : break;
8391 : :
8392 : 1758923 : case CPP_PLUS_PLUS:
8393 : : /* postfix-expression ++ */
8394 : : /* Consume the `++' token. */
8395 : 1758923 : cp_lexer_consume_token (parser->lexer);
8396 : : /* Generate a representation for the complete expression. */
8397 : 1758923 : postfix_expression
8398 : 1758923 : = finish_increment_expr (postfix_expression,
8399 : : POSTINCREMENT_EXPR);
8400 : : /* Increments may not appear in constant-expressions. */
8401 : 1758923 : if (cp_parser_non_integral_constant_expression (parser, NIC_INC))
8402 : 0 : postfix_expression = error_mark_node;
8403 : 1758923 : idk = CP_ID_KIND_NONE;
8404 : 1758923 : is_member_access = false;
8405 : 1758923 : break;
8406 : :
8407 : 405212 : case CPP_MINUS_MINUS:
8408 : : /* postfix-expression -- */
8409 : : /* Consume the `--' token. */
8410 : 405212 : cp_lexer_consume_token (parser->lexer);
8411 : : /* Generate a representation for the complete expression. */
8412 : 405212 : postfix_expression
8413 : 405212 : = finish_increment_expr (postfix_expression,
8414 : : POSTDECREMENT_EXPR);
8415 : : /* Decrements may not appear in constant-expressions. */
8416 : 405212 : if (cp_parser_non_integral_constant_expression (parser, NIC_DEC))
8417 : 0 : postfix_expression = error_mark_node;
8418 : 405212 : idk = CP_ID_KIND_NONE;
8419 : 405212 : is_member_access = false;
8420 : 405212 : break;
8421 : :
8422 : 868432738 : default:
8423 : 868432738 : if (pidk_return != NULL)
8424 : 33642543 : * pidk_return = idk;
8425 : 868432738 : if (member_access_only_p)
8426 : 2493801 : return is_member_access
8427 : 2493801 : ? postfix_expression
8428 : 2493801 : : cp_expr (error_mark_node);
8429 : : else
8430 : 865938937 : return postfix_expression;
8431 : : }
8432 : : }
8433 : : }
8434 : :
8435 : : /* Helper function for cp_parser_parenthesized_expression_list and
8436 : : cp_parser_postfix_open_square_expression. Parse a single element
8437 : : of parenthesized expression list. */
8438 : :
8439 : : static cp_expr
8440 : 286205915 : cp_parser_parenthesized_expression_list_elt (cp_parser *parser, bool cast_p,
8441 : : bool allow_expansion_p,
8442 : : bool *non_constant_p)
8443 : : {
8444 : 286205915 : cp_expr expr (NULL_TREE);
8445 : 286205915 : bool expr_non_constant_p;
8446 : :
8447 : : /* Parse the next assignment-expression. */
8448 : 286205915 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
8449 : : {
8450 : : /* A braced-init-list. */
8451 : 138067 : cp_lexer_set_source_position (parser->lexer);
8452 : 138067 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
8453 : 273521 : expr = cp_parser_braced_list (parser,
8454 : : (non_constant_p != nullptr
8455 : : ? &expr_non_constant_p
8456 : : : nullptr));
8457 : 138067 : if (non_constant_p && expr_non_constant_p)
8458 : 24 : *non_constant_p = true;
8459 : : }
8460 : 286067848 : else if (non_constant_p)
8461 : : {
8462 : 6146910 : expr = cp_parser_constant_expression (parser,
8463 : : /*allow_non_constant_p=*/true,
8464 : : &expr_non_constant_p);
8465 : 6146910 : if (expr_non_constant_p)
8466 : 2040180 : *non_constant_p = true;
8467 : : }
8468 : : else
8469 : 279920938 : expr = cp_parser_assignment_expression (parser, /*pidk=*/NULL, cast_p);
8470 : :
8471 : : /* If we have an ellipsis, then this is an expression expansion. */
8472 : 286205915 : if (allow_expansion_p
8473 : 286205915 : && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
8474 : : {
8475 : : /* Consume the `...'. */
8476 : 3069341 : cp_lexer_consume_token (parser->lexer);
8477 : :
8478 : : /* Build the argument pack. */
8479 : 3069341 : expr = make_pack_expansion (expr);
8480 : : }
8481 : 286205915 : return expr;
8482 : : }
8483 : :
8484 : : /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8485 : : by cp_parser_builtin_offsetof. We're looking for
8486 : :
8487 : : postfix-expression [ expression ]
8488 : : postfix-expression [ braced-init-list ] (C++11)
8489 : : postfix-expression [ expression-list[opt] ] (C++23)
8490 : :
8491 : : FOR_OFFSETOF is set if we're being called in that context, which
8492 : : changes how we deal with integer constant expressions. */
8493 : :
8494 : : static tree
8495 : 9971340 : cp_parser_postfix_open_square_expression (cp_parser *parser,
8496 : : tree postfix_expression,
8497 : : bool for_offsetof,
8498 : : bool decltype_p)
8499 : : {
8500 : 9971340 : tree index = NULL_TREE;
8501 : 9971340 : releasing_vec expression_list = NULL;
8502 : 9971340 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
8503 : 9971340 : bool saved_greater_than_is_operator_p;
8504 : 9971340 : bool saved_colon_corrects_to_scope_p;
8505 : :
8506 : : /* Consume the `[' token. */
8507 : 9971340 : cp_lexer_consume_token (parser->lexer);
8508 : :
8509 : 9971340 : saved_greater_than_is_operator_p = parser->greater_than_is_operator_p;
8510 : 9971340 : parser->greater_than_is_operator_p = true;
8511 : :
8512 : 9971340 : saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
8513 : 9971340 : if (parser->omp_array_section_p)
8514 : 2585 : parser->colon_corrects_to_scope_p = false;
8515 : :
8516 : : /* Parse the index expression. */
8517 : : /* ??? For offsetof, there is a question of what to allow here. If
8518 : : offsetof is not being used in an integral constant expression context,
8519 : : then we *could* get the right answer by computing the value at runtime.
8520 : : If we are in an integral constant expression context, then we might
8521 : : could accept any constant expression; hard to say without analysis.
8522 : : Rather than open the barn door too wide right away, allow only integer
8523 : : constant expressions here. */
8524 : 9971340 : if (for_offsetof)
8525 : 687 : index = cp_parser_constant_expression (parser);
8526 : 9970653 : else if (!parser->omp_array_section_p
8527 : 9970653 : || cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
8528 : : {
8529 : 9970199 : if (cxx_dialect >= cxx23
8530 : 9970199 : && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
8531 : 88 : *&expression_list = make_tree_vector ();
8532 : 9970111 : else if (cxx_dialect >= cxx23)
8533 : : {
8534 : 1396930 : while (true)
8535 : : {
8536 : : /* Handle #embed in the expression-list. */
8537 : 1396930 : if (cp_lexer_next_token_is (parser->lexer, CPP_EMBED))
8538 : : {
8539 : 2 : tree raw_data = cp_lexer_peek_token (parser->lexer)->u.value;
8540 : 2 : cp_lexer_consume_token (parser->lexer);
8541 : 2 : vec_safe_reserve (expression_list,
8542 : 2 : RAW_DATA_LENGTH (raw_data));
8543 : 268 : for (tree argument : raw_data_range (raw_data))
8544 : 266 : expression_list->quick_push (argument);
8545 : 2 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
8546 : 2 : continue;
8547 : 2 : }
8548 : :
8549 : 1396928 : cp_expr expr
8550 : 1396928 : = cp_parser_parenthesized_expression_list_elt (parser,
8551 : : /*cast_p=*/
8552 : : false,
8553 : : /*allow_exp_p=*/
8554 : : true,
8555 : : /*non_cst_p=*/
8556 : : NULL);
8557 : :
8558 : 1396928 : if (expr == error_mark_node)
8559 : : index = error_mark_node;
8560 : 1396926 : else if (expression_list.get () == NULL
8561 : 1396926 : && !PACK_EXPANSION_P (expr.get_value ()))
8562 : : index = expr.get_value ();
8563 : : else
8564 : 152 : vec_safe_push (expression_list, expr.get_value ());
8565 : :
8566 : : /* If the next token isn't a `,', then we are done. */
8567 : 1396928 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
8568 : : break;
8569 : :
8570 : 148 : if (expression_list.get () == NULL && index != error_mark_node)
8571 : : {
8572 : 110 : *&expression_list = make_tree_vector_single (index);
8573 : 110 : index = NULL_TREE;
8574 : : }
8575 : :
8576 : : /* Otherwise, consume the `,' and keep going. */
8577 : 148 : cp_lexer_consume_token (parser->lexer);
8578 : : }
8579 : 1396780 : if (expression_list.get () && index == error_mark_node)
8580 : 0 : expression_list.release ();
8581 : : }
8582 : 8573331 : else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
8583 : : {
8584 : 25 : cp_lexer_set_source_position (parser->lexer);
8585 : 25 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
8586 : 25 : index = cp_parser_braced_list (parser);
8587 : : }
8588 : : else
8589 : 8573306 : index = cp_parser_expression (parser, NULL, /*cast_p=*/false,
8590 : : /*decltype_p=*/false,
8591 : 8573306 : /*warn_comma_p=*/warn_comma_subscript);
8592 : : }
8593 : :
8594 : 9971340 : parser->greater_than_is_operator_p = saved_greater_than_is_operator_p;
8595 : :
8596 : 9971340 : if (cxx_dialect >= cxx23
8597 : 1397206 : && parser->omp_array_section_p
8598 : 427 : && expression_list.get () != NULL
8599 : 9971348 : && vec_safe_length (expression_list) > 1)
8600 : : {
8601 : 8 : error_at (loc, "cannot use multidimensional subscript in OpenMP array "
8602 : : "section");
8603 : 8 : index = error_mark_node;
8604 : : }
8605 : 9971340 : if (parser->omp_array_section_p
8606 : 9971340 : && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
8607 : : {
8608 : 2013 : cp_lexer_consume_token (parser->lexer);
8609 : 2013 : tree length = NULL_TREE;
8610 : 2013 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_SQUARE))
8611 : : {
8612 : 1801 : if (cxx_dialect >= cxx23)
8613 : : {
8614 : 313 : cp_expr expr
8615 : 313 : = cp_parser_parenthesized_expression_list_elt (parser,
8616 : : /*cast_p=*/
8617 : : false,
8618 : : /*allow_exp_p=*/
8619 : : true,
8620 : : /*non_cst_p=*/
8621 : : NULL);
8622 : :
8623 : 313 : if (expr == error_mark_node)
8624 : : length = error_mark_node;
8625 : : else
8626 : 313 : length = expr.get_value ();
8627 : :
8628 : 313 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
8629 : : {
8630 : 8 : error_at (loc, "cannot use multidimensional subscript in "
8631 : : "OpenMP array section");
8632 : 8 : length = error_mark_node;
8633 : : }
8634 : : }
8635 : : else
8636 : 1488 : length
8637 : 1488 : = cp_parser_expression (parser, NULL, /*cast_p=*/false,
8638 : : /*decltype_p=*/false,
8639 : 1488 : /*warn_comma_p=*/warn_comma_subscript);
8640 : : }
8641 : :
8642 : 2013 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
8643 : :
8644 : 2013 : if (index == error_mark_node || length == error_mark_node)
8645 : : {
8646 : 12 : cp_parser_skip_to_closing_square_bracket (parser);
8647 : 12 : return error_mark_node;
8648 : : }
8649 : : else
8650 : 2001 : cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
8651 : :
8652 : 2001 : return grok_omp_array_section (input_location, postfix_expression, index,
8653 : 2001 : length);
8654 : : }
8655 : :
8656 : 9969327 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
8657 : :
8658 : : /* Look for the closing `]'. */
8659 : 9969327 : cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
8660 : :
8661 : : /* Build the ARRAY_REF. */
8662 : 19938482 : postfix_expression = grok_array_decl (loc, postfix_expression,
8663 : : index, &expression_list,
8664 : : tf_warning_or_error
8665 : : | (decltype_p ? tf_decltype : 0));
8666 : :
8667 : : /* When not doing offsetof, array references are not permitted in
8668 : : constant-expressions. */
8669 : 9969327 : if (!for_offsetof
8670 : 9969327 : && (cp_parser_non_integral_constant_expression (parser, NIC_ARRAY_REF)))
8671 : 5 : postfix_expression = error_mark_node;
8672 : :
8673 : : return postfix_expression;
8674 : 9971340 : }
8675 : :
8676 : : /* A subroutine of cp_parser_postfix_dot_deref_expression. Handle dot
8677 : : dereference of incomplete type, returns true if error_mark_node should
8678 : : be returned from caller, otherwise adjusts *SCOPE, *POSTFIX_EXPRESSION
8679 : : and *DEPENDENT_P. */
8680 : :
8681 : : bool
8682 : 52 : cp_parser_dot_deref_incomplete (tree *scope, cp_expr *postfix_expression,
8683 : : bool *dependent_p)
8684 : : {
8685 : : /* In a template, be permissive by treating an object expression
8686 : : of incomplete type as dependent (after a pedwarn). */
8687 : 52 : diagnostic_t kind = (processing_template_decl
8688 : 52 : && MAYBE_CLASS_TYPE_P (*scope) ? DK_PEDWARN : DK_ERROR);
8689 : :
8690 : 52 : switch (TREE_CODE (*postfix_expression))
8691 : : {
8692 : : case CAST_EXPR:
8693 : : case REINTERPRET_CAST_EXPR:
8694 : : case CONST_CAST_EXPR:
8695 : : case STATIC_CAST_EXPR:
8696 : : case DYNAMIC_CAST_EXPR:
8697 : : case IMPLICIT_CONV_EXPR:
8698 : : case VIEW_CONVERT_EXPR:
8699 : : case NON_LVALUE_EXPR:
8700 : : kind = DK_ERROR;
8701 : : break;
8702 : : case OVERLOAD:
8703 : : /* Don't emit any diagnostic for OVERLOADs. */
8704 : 31 : kind = DK_IGNORED;
8705 : : break;
8706 : 28 : default:
8707 : : /* Avoid clobbering e.g. DECLs. */
8708 : 28 : if (!EXPR_P (*postfix_expression))
8709 : : kind = DK_ERROR;
8710 : : break;
8711 : : }
8712 : :
8713 : : if (kind == DK_IGNORED)
8714 : : return false;
8715 : :
8716 : 49 : location_t exploc = location_of (*postfix_expression);
8717 : 49 : cxx_incomplete_type_diagnostic (exploc, *postfix_expression, *scope, kind);
8718 : 49 : if (!MAYBE_CLASS_TYPE_P (*scope))
8719 : : return true;
8720 : 28 : if (kind == DK_ERROR)
8721 : 25 : *scope = *postfix_expression = error_mark_node;
8722 : 3 : else if (processing_template_decl)
8723 : : {
8724 : 3 : *dependent_p = true;
8725 : 3 : *scope = TREE_TYPE (*postfix_expression) = NULL_TREE;
8726 : : }
8727 : : return false;
8728 : : }
8729 : :
8730 : : /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8731 : : by cp_parser_builtin_offsetof. We're looking for
8732 : :
8733 : : postfix-expression . template [opt] id-expression
8734 : : postfix-expression . pseudo-destructor-name
8735 : : postfix-expression -> template [opt] id-expression
8736 : : postfix-expression -> pseudo-destructor-name
8737 : :
8738 : : FOR_OFFSETOF is set if we're being called in that context. That sorta
8739 : : limits what of the above we'll actually accept, but nevermind.
8740 : : TOKEN_TYPE is the "." or "->" token, which will already have been
8741 : : removed from the stream. */
8742 : :
8743 : : static tree
8744 : 117609948 : cp_parser_postfix_dot_deref_expression (cp_parser *parser,
8745 : : enum cpp_ttype token_type,
8746 : : cp_expr postfix_expression,
8747 : : bool for_offsetof, cp_id_kind *idk,
8748 : : location_t location)
8749 : : {
8750 : 117609948 : tree name;
8751 : 117609948 : bool dependent_p;
8752 : 117609948 : bool pseudo_destructor_p;
8753 : 117609948 : tree scope = NULL_TREE;
8754 : 117609948 : location_t start_loc = postfix_expression.get_start ();
8755 : :
8756 : : /* If this is a `->' operator, dereference the pointer. */
8757 : 117609948 : if (token_type == CPP_DEREF)
8758 : 32282653 : postfix_expression = build_x_arrow (location, postfix_expression,
8759 : 32282653 : tf_warning_or_error);
8760 : : /* Check to see whether or not the expression is type-dependent and
8761 : : not the current instantiation. */
8762 : 117609945 : dependent_p = type_dependent_object_expression_p (postfix_expression);
8763 : : /* The identifier following the `->' or `.' is not qualified. */
8764 : 117609945 : parser->scope = NULL_TREE;
8765 : 117609945 : parser->qualifying_scope = NULL_TREE;
8766 : 117609945 : parser->object_scope = NULL_TREE;
8767 : 117609945 : *idk = CP_ID_KIND_NONE;
8768 : :
8769 : : /* Enter the scope corresponding to the type of the object
8770 : : given by the POSTFIX_EXPRESSION. */
8771 : 117609945 : if (!dependent_p)
8772 : : {
8773 : 48642470 : scope = TREE_TYPE (postfix_expression);
8774 : : /* According to the standard, no expression should ever have
8775 : : reference type. Unfortunately, we do not currently match
8776 : : the standard in this respect in that our internal representation
8777 : : of an expression may have reference type even when the standard
8778 : : says it does not. Therefore, we have to manually obtain the
8779 : : underlying type here. */
8780 : 48642470 : scope = non_reference (scope);
8781 : : /* The type of the POSTFIX_EXPRESSION must be complete. */
8782 : : /* Unlike the object expression in other contexts, *this is not
8783 : : required to be of complete type for purposes of class member
8784 : : access (5.2.5) outside the member function body. */
8785 : 48642470 : if (postfix_expression != current_class_ref
8786 : 48423866 : && scope != error_mark_node
8787 : 97066148 : && !currently_open_class (scope))
8788 : : {
8789 : 11805053 : scope = complete_type (scope);
8790 : 11805053 : if (!COMPLETE_TYPE_P (scope)
8791 : 11805053 : && cp_parser_dot_deref_incomplete (&scope, &postfix_expression,
8792 : : &dependent_p))
8793 : 21 : return error_mark_node;
8794 : : }
8795 : :
8796 : 48642449 : if (!dependent_p)
8797 : : {
8798 : : /* Let the name lookup machinery know that we are processing a
8799 : : class member access expression. */
8800 : 48642446 : parser->context->object_type = scope;
8801 : : /* If something went wrong, we want to be able to discern that case,
8802 : : as opposed to the case where there was no SCOPE due to the type
8803 : : of expression being dependent. */
8804 : 48642446 : if (!scope)
8805 : 0 : scope = error_mark_node;
8806 : : /* If the SCOPE was erroneous, make the various semantic analysis
8807 : : functions exit quickly -- and without issuing additional error
8808 : : messages. */
8809 : 48642446 : if (scope == error_mark_node)
8810 : 213 : postfix_expression = error_mark_node;
8811 : : }
8812 : : }
8813 : :
8814 : 117609924 : if (dependent_p)
8815 : : {
8816 : 68967478 : tree type = TREE_TYPE (postfix_expression);
8817 : : /* If we don't have a (type-dependent) object of class type, use
8818 : : typeof to figure out the type of the object. */
8819 : 68967478 : if (type == NULL_TREE || is_auto (type))
8820 : 18545862 : type = finish_typeof (postfix_expression);
8821 : 68967478 : parser->context->object_type = type;
8822 : : }
8823 : :
8824 : : /* Assume this expression is not a pseudo-destructor access. */
8825 : 117609924 : pseudo_destructor_p = false;
8826 : :
8827 : : /* If the SCOPE is a scalar type, then, if this is a valid program,
8828 : : we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
8829 : : is type dependent, it can be pseudo-destructor-name or something else.
8830 : : Try to parse it as pseudo-destructor-name first. */
8831 : 117609924 : if ((scope && SCALAR_TYPE_P (scope)) || dependent_p)
8832 : : {
8833 : 68967611 : tree s;
8834 : 68967611 : tree type;
8835 : :
8836 : 68967611 : cp_parser_parse_tentatively (parser);
8837 : : /* Parse the pseudo-destructor-name. */
8838 : 68967611 : s = NULL_TREE;
8839 : 68967611 : cp_parser_pseudo_destructor_name (parser, postfix_expression,
8840 : : &s, &type);
8841 : 68967611 : if (dependent_p
8842 : 68967611 : && (cp_parser_error_occurred (parser)
8843 : 294801 : || !SCALAR_TYPE_P (type)))
8844 : 68967463 : cp_parser_abort_tentative_parse (parser);
8845 : 148 : else if (cp_parser_parse_definitely (parser))
8846 : : {
8847 : 102 : pseudo_destructor_p = true;
8848 : 102 : postfix_expression
8849 : 102 : = finish_pseudo_destructor_expr (postfix_expression,
8850 : 102 : s, type, location);
8851 : : }
8852 : : }
8853 : :
8854 : 68967611 : if (!pseudo_destructor_p)
8855 : : {
8856 : : /* If the SCOPE is not a scalar type, we are looking at an
8857 : : ordinary class member access expression, rather than a
8858 : : pseudo-destructor-name. */
8859 : 117609822 : bool template_p;
8860 : 117609822 : cp_token *token = cp_lexer_peek_token (parser->lexer);
8861 : : /* Parse the id-expression. */
8862 : 117609822 : name = (cp_parser_id_expression
8863 : 117609822 : (parser,
8864 : 117609822 : cp_parser_optional_template_keyword (parser),
8865 : : /*check_dependency_p=*/true,
8866 : : &template_p,
8867 : : /*declarator_p=*/false,
8868 : : /*optional_p=*/false));
8869 : : /* In general, build a SCOPE_REF if the member name is qualified.
8870 : : However, if the name was not dependent and has already been
8871 : : resolved; there is no need to build the SCOPE_REF. For example;
8872 : :
8873 : : struct X { void f(); };
8874 : : template <typename T> void f(T* t) { t->X::f(); }
8875 : :
8876 : : Even though "t" is dependent, "X::f" is not and has been resolved
8877 : : to a BASELINK; there is no need to include scope information. */
8878 : :
8879 : : /* But we do need to remember that there was an explicit scope for
8880 : : virtual function calls. */
8881 : 117609822 : if (parser->scope)
8882 : 111687 : *idk = CP_ID_KIND_QUALIFIED;
8883 : :
8884 : : /* If the name is a template-id that names a type, we will get a
8885 : : TYPE_DECL here. That is invalid code. */
8886 : 117609822 : if (TREE_CODE (name) == TYPE_DECL)
8887 : : {
8888 : 3 : error_at (token->location, "invalid use of %qD", name);
8889 : 3 : postfix_expression = error_mark_node;
8890 : : }
8891 : : else
8892 : : {
8893 : 117609819 : if (name != error_mark_node && !BASELINK_P (name) && parser->scope)
8894 : : {
8895 : 111633 : if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
8896 : : {
8897 : 12 : error_at (token->location, "%<%D::%D%> is not a class member",
8898 : : parser->scope, name);
8899 : 12 : postfix_expression = error_mark_node;
8900 : : }
8901 : : else
8902 : 111621 : name = build_qualified_name (/*type=*/NULL_TREE,
8903 : : parser->scope,
8904 : : name,
8905 : : template_p);
8906 : 111633 : parser->scope = NULL_TREE;
8907 : 111633 : parser->qualifying_scope = NULL_TREE;
8908 : 111633 : parser->object_scope = NULL_TREE;
8909 : : }
8910 : 117609819 : if (parser->scope && name && BASELINK_P (name))
8911 : 54 : adjust_result_of_qualified_name_lookup
8912 : 54 : (name, parser->scope, scope);
8913 : 117609819 : postfix_expression
8914 : 117609819 : = finish_class_member_access_expr (postfix_expression, name,
8915 : : template_p,
8916 : 117609819 : tf_warning_or_error);
8917 : : /* Build a location e.g.:
8918 : : ptr->access_expr
8919 : : ~~~^~~~~~~~~~~~~
8920 : : where the caret is at the deref token, ranging from
8921 : : the start of postfix_expression to the end of the access expr. */
8922 : 117609819 : location_t combined_loc
8923 : 117609819 : = make_location (input_location, start_loc, parser->lexer);
8924 : 117609819 : protected_set_expr_location (postfix_expression, combined_loc);
8925 : : }
8926 : : }
8927 : :
8928 : : /* We no longer need to look up names in the scope of the object on
8929 : : the left-hand side of the `.' or `->' operator. */
8930 : 117609924 : parser->context->object_type = NULL_TREE;
8931 : :
8932 : : /* Outside of offsetof, these operators may not appear in
8933 : : constant-expressions. */
8934 : 117609924 : if (!for_offsetof
8935 : 235217269 : && (cp_parser_non_integral_constant_expression
8936 : 202934373 : (parser, token_type == CPP_DEREF ? NIC_ARROW : NIC_POINT)))
8937 : 2 : postfix_expression = error_mark_node;
8938 : :
8939 : 117609924 : return postfix_expression;
8940 : : }
8941 : :
8942 : : /* Parse a parenthesized expression-list.
8943 : :
8944 : : expression-list:
8945 : : assignment-expression
8946 : : expression-list, assignment-expression
8947 : :
8948 : : attribute-list:
8949 : : expression-list
8950 : : identifier
8951 : : identifier, expression-list
8952 : :
8953 : : CAST_P is true if this expression is the target of a cast.
8954 : :
8955 : : ALLOW_EXPANSION_P is true if this expression allows expansion of an
8956 : : argument pack.
8957 : :
8958 : : WRAP_LOCATIONS_P is true if expressions within this list for which
8959 : : CAN_HAVE_LOCATION_P is false should be wrapped with nodes expressing
8960 : : their source locations.
8961 : :
8962 : : Returns a vector of trees. Each element is a representation of an
8963 : : assignment-expression. NULL is returned if the ( and or ) are
8964 : : missing. An empty, but allocated, vector is returned on no
8965 : : expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
8966 : : if we are parsing an attribute list for an attribute that wants a
8967 : : plain identifier argument, normal_attr for an attribute that wants
8968 : : an expression, or non_attr if we aren't parsing an attribute list. If
8969 : : NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
8970 : : not all of the expressions in the list were constant.
8971 : : If CLOSE_PAREN_LOC is non-NULL, and no errors occur, then *CLOSE_PAREN_LOC
8972 : : will be written to with the location of the closing parenthesis. If
8973 : : an error occurs, it may or may not be written to. */
8974 : :
8975 : : static vec<tree, va_gc> *
8976 : 264153390 : cp_parser_parenthesized_expression_list (cp_parser* parser,
8977 : : int is_attribute_list,
8978 : : bool cast_p,
8979 : : bool allow_expansion_p,
8980 : : bool *non_constant_p,
8981 : : location_t *close_paren_loc,
8982 : : bool wrap_locations_p)
8983 : : {
8984 : 264153390 : vec<tree, va_gc> *expression_list;
8985 : 264153390 : bool saved_greater_than_is_operator_p;
8986 : 264153390 : bool saved_omp_array_section_p;
8987 : :
8988 : : /* Assume all the expressions will be constant. */
8989 : 264153390 : if (non_constant_p)
8990 : 4811436 : *non_constant_p = false;
8991 : :
8992 : 264153390 : matching_parens parens;
8993 : 264153390 : if (!parens.require_open (parser))
8994 : : return NULL;
8995 : :
8996 : 263726650 : expression_list = make_tree_vector ();
8997 : :
8998 : : /* Within a parenthesized expression, a `>' token is always
8999 : : the greater-than operator. */
9000 : 263726650 : saved_greater_than_is_operator_p
9001 : 263726650 : = parser->greater_than_is_operator_p;
9002 : 263726650 : parser->greater_than_is_operator_p = true;
9003 : :
9004 : 263726650 : saved_omp_array_section_p = parser->omp_array_section_p;
9005 : 263726650 : parser->omp_array_section_p = false;
9006 : :
9007 : 263726650 : cp_expr expr (NULL_TREE);
9008 : :
9009 : : /* Consume expressions until there are no more. */
9010 : 263726650 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
9011 : 388734657 : while (true)
9012 : : {
9013 : : /* At the beginning of attribute lists, check to see if the
9014 : : next token is an identifier. */
9015 : 285565255 : if (is_attribute_list == id_attr
9016 : 285565255 : && cp_lexer_next_token_is (parser->lexer, CPP_NAME))
9017 : 733971 : expr = cp_lexer_consume_token (parser->lexer)->u.value;
9018 : 284831284 : else if (is_attribute_list == assume_attr)
9019 : 21227 : expr = cp_parser_conditional_expression (parser);
9020 : 284810057 : else if (is_attribute_list == uneval_string_attr)
9021 : 1365 : expr = cp_parser_unevaluated_string_literal (parser);
9022 : 284808692 : else if (cp_lexer_next_token_is (parser->lexer, CPP_EMBED))
9023 : : {
9024 : : /* Handle #embed in the argument list. */
9025 : 18 : tree raw_data = cp_lexer_peek_token (parser->lexer)->u.value;
9026 : 18 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
9027 : 18 : cp_lexer_consume_token (parser->lexer);
9028 : 18 : vec_safe_reserve (expression_list, RAW_DATA_LENGTH (raw_data));
9029 : 3063 : for (tree arg : raw_data_range (raw_data))
9030 : 3045 : if (wrap_locations_p)
9031 : 765 : expression_list->quick_push (maybe_wrap_with_location (arg,
9032 : : loc));
9033 : : else
9034 : 2280 : expression_list->quick_push (arg);
9035 : 18 : goto get_comma;
9036 : : }
9037 : : else
9038 : 284808674 : expr
9039 : 284808674 : = cp_parser_parenthesized_expression_list_elt (parser, cast_p,
9040 : : allow_expansion_p,
9041 : : non_constant_p);
9042 : :
9043 : 285565237 : if (wrap_locations_p)
9044 : 228536753 : expr.maybe_add_location_wrapper ();
9045 : :
9046 : : /* Add it to the list. We add error_mark_node
9047 : : expressions to the list, so that we can still tell if
9048 : : the correct form for a parenthesized expression-list
9049 : : is found. That gives better errors. */
9050 : 285565237 : vec_safe_push (expression_list, expr.get_value ());
9051 : :
9052 : 285565237 : if (expr == error_mark_node)
9053 : 749 : goto skip_comma;
9054 : :
9055 : : /* After the first item, attribute lists look the same as
9056 : : expression lists. */
9057 : : is_attribute_list = non_attr;
9058 : :
9059 : 285564566 : get_comma:;
9060 : : /* If the next token isn't a `,', then we are done. */
9061 : 285564566 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
9062 : : break;
9063 : :
9064 : : /* Otherwise, consume the `,' and keep going. */
9065 : 103169402 : cp_lexer_consume_token (parser->lexer);
9066 : 103169402 : }
9067 : :
9068 : 263725961 : if (close_paren_loc)
9069 : 190734636 : *close_paren_loc = cp_lexer_peek_token (parser->lexer)->location;
9070 : :
9071 : 263725961 : if (!parens.require_close (parser))
9072 : : {
9073 : 835 : int ending;
9074 : :
9075 : 86 : skip_comma:;
9076 : : /* We try and resync to an unnested comma, as that will give the
9077 : : user better diagnostics. */
9078 : 835 : ending = cp_parser_skip_to_closing_parenthesis (parser,
9079 : : /*recovering=*/true,
9080 : : /*or_comma=*/true,
9081 : : /*consume_paren=*/true);
9082 : 835 : if (ending < 0)
9083 : 60 : goto get_comma;
9084 : 775 : if (!ending)
9085 : : {
9086 : 117 : parser->greater_than_is_operator_p
9087 : 117 : = saved_greater_than_is_operator_p;
9088 : 117 : parser->omp_array_section_p = saved_omp_array_section_p;
9089 : 117 : return NULL;
9090 : : }
9091 : : }
9092 : :
9093 : 263726533 : parser->greater_than_is_operator_p
9094 : 263726533 : = saved_greater_than_is_operator_p;
9095 : 263726533 : parser->omp_array_section_p = saved_omp_array_section_p;
9096 : :
9097 : 263726533 : return expression_list;
9098 : : }
9099 : :
9100 : : /* Parse a pseudo-destructor-name.
9101 : :
9102 : : pseudo-destructor-name:
9103 : : :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
9104 : : :: [opt] nested-name-specifier template template-id :: ~ type-name
9105 : : :: [opt] nested-name-specifier [opt] ~ type-name
9106 : :
9107 : : If either of the first two productions is used, sets *SCOPE to the
9108 : : TYPE specified before the final `::'. Otherwise, *SCOPE is set to
9109 : : NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
9110 : : or ERROR_MARK_NODE if the parse fails. */
9111 : :
9112 : : static void
9113 : 68967611 : cp_parser_pseudo_destructor_name (cp_parser* parser,
9114 : : tree object,
9115 : : tree* scope,
9116 : : tree* type)
9117 : : {
9118 : 68967611 : bool nested_name_specifier_p;
9119 : :
9120 : : /* Handle ~auto. */
9121 : 68967611 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMPL)
9122 : 294874 : && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_AUTO)
9123 : 68967617 : && !type_dependent_expression_p (object))
9124 : : {
9125 : 3 : if (cxx_dialect < cxx14)
9126 : 0 : pedwarn (input_location, OPT_Wc__14_extensions,
9127 : : "%<~auto%> only available with "
9128 : : "%<-std=c++14%> or %<-std=gnu++14%>");
9129 : 3 : cp_lexer_consume_token (parser->lexer);
9130 : 3 : cp_lexer_consume_token (parser->lexer);
9131 : 3 : *scope = NULL_TREE;
9132 : 3 : *type = TREE_TYPE (object);
9133 : 3 : return;
9134 : : }
9135 : :
9136 : : /* Assume that things will not work out. */
9137 : 68967608 : *type = error_mark_node;
9138 : :
9139 : : /* Look for the optional `::' operator. */
9140 : 68967608 : cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/true);
9141 : : /* Look for the optional nested-name-specifier. */
9142 : 68967608 : nested_name_specifier_p
9143 : 68967608 : = (cp_parser_nested_name_specifier_opt (parser,
9144 : : /*typename_keyword_p=*/false,
9145 : : /*check_dependency_p=*/true,
9146 : : /*type_p=*/false,
9147 : : /*is_declaration=*/false)
9148 : : != NULL_TREE);
9149 : : /* Now, if we saw a nested-name-specifier, we might be doing the
9150 : : second production. */
9151 : 68967608 : if (nested_name_specifier_p
9152 : 68967608 : && cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
9153 : : {
9154 : : /* Consume the `template' keyword. */
9155 : 12 : cp_lexer_consume_token (parser->lexer);
9156 : : /* Parse the template-id. */
9157 : 12 : cp_parser_template_id (parser,
9158 : : /*template_keyword_p=*/true,
9159 : : /*check_dependency_p=*/false,
9160 : : class_type,
9161 : : /*is_declaration=*/true);
9162 : : /* Look for the `::' token. */
9163 : 12 : cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
9164 : : }
9165 : : /* If the next token is not a `~', then there might be some
9166 : : additional qualification. */
9167 : 68967596 : else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL))
9168 : : {
9169 : : /* At this point, we're looking for "type-name :: ~". The type-name
9170 : : must not be a class-name, since this is a pseudo-destructor. So,
9171 : : it must be either an enum-name, or a typedef-name -- both of which
9172 : : are just identifiers. So, we peek ahead to check that the "::"
9173 : : and "~" tokens are present; if they are not, then we can avoid
9174 : : calling type_name. */
9175 : 68672563 : if (cp_lexer_peek_token (parser->lexer)->type != CPP_NAME
9176 : 68395924 : || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE
9177 : 68672605 : || cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_COMPL)
9178 : : {
9179 : 68672521 : cp_parser_error (parser, "non-scalar type");
9180 : 68672521 : return;
9181 : : }
9182 : :
9183 : : /* Look for the type-name. */
9184 : 42 : *scope = TREE_TYPE (cp_parser_nonclass_name (parser));
9185 : 42 : if (*scope == error_mark_node)
9186 : : return;
9187 : :
9188 : : /* Look for the `::' token. */
9189 : 39 : cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
9190 : : }
9191 : : else
9192 : 295033 : *scope = NULL_TREE;
9193 : :
9194 : : /* Look for the `~'. */
9195 : 295084 : cp_parser_require (parser, CPP_COMPL, RT_COMPL);
9196 : :
9197 : : /* Once we see the ~, this has to be a pseudo-destructor. */
9198 : 295084 : if (!processing_template_decl && !cp_parser_error_occurred (parser))
9199 : 78 : cp_parser_commit_to_topmost_tentative_parse (parser);
9200 : :
9201 : : /* Look for the type-name again. We are not responsible for
9202 : : checking that it matches the first type-name. */
9203 : 295084 : *type = TREE_TYPE (cp_parser_nonclass_name (parser));
9204 : : }
9205 : :
9206 : : /* Parse a unary-expression.
9207 : :
9208 : : unary-expression:
9209 : : postfix-expression
9210 : : ++ cast-expression
9211 : : -- cast-expression
9212 : : await-expression
9213 : : unary-operator cast-expression
9214 : : sizeof unary-expression
9215 : : sizeof ( type-id )
9216 : : alignof ( type-id ) [C++0x]
9217 : : new-expression
9218 : : delete-expression
9219 : :
9220 : : GNU Extensions:
9221 : :
9222 : : unary-expression:
9223 : : __extension__ cast-expression
9224 : : __alignof__ unary-expression
9225 : : __alignof__ ( type-id )
9226 : : alignof unary-expression [C++0x]
9227 : : __real__ cast-expression
9228 : : __imag__ cast-expression
9229 : : && identifier
9230 : : sizeof ( type-id ) { initializer-list , [opt] }
9231 : : alignof ( type-id ) { initializer-list , [opt] } [C++0x]
9232 : : __alignof__ ( type-id ) { initializer-list , [opt] }
9233 : :
9234 : : ADDRESS_P is true iff the unary-expression is appearing as the
9235 : : operand of the `&' operator. CAST_P is true if this expression is
9236 : : the target of a cast.
9237 : :
9238 : : Returns a representation of the expression. */
9239 : :
9240 : : static cp_expr
9241 : 933910379 : cp_parser_unary_expression (cp_parser *parser, cp_id_kind * pidk,
9242 : : bool address_p, bool cast_p, bool decltype_p)
9243 : : {
9244 : 933910379 : cp_token *token;
9245 : 933910379 : enum tree_code unary_operator;
9246 : :
9247 : : /* Peek at the next token. */
9248 : 933910379 : token = cp_lexer_peek_token (parser->lexer);
9249 : : /* Some keywords give away the kind of expression. */
9250 : 933910379 : if (token->type == CPP_KEYWORD)
9251 : : {
9252 : 100452420 : enum rid keyword = token->keyword;
9253 : :
9254 : 100452420 : switch (keyword)
9255 : : {
9256 : 4480043 : case RID_ALIGNOF:
9257 : 4480043 : case RID_SIZEOF:
9258 : 4480043 : {
9259 : 4480043 : tree operand, ret;
9260 : 4480043 : enum tree_code op;
9261 : 4480043 : location_t start_loc = token->location;
9262 : :
9263 : 4480043 : op = keyword == RID_ALIGNOF ? ALIGNOF_EXPR : SIZEOF_EXPR;
9264 : 4480043 : bool std_alignof = id_equal (token->u.value, "alignof");
9265 : :
9266 : : /* Consume the token. */
9267 : 4480043 : cp_lexer_consume_token (parser->lexer);
9268 : : /* Parse the operand. */
9269 : 4480043 : operand = cp_parser_sizeof_operand (parser, keyword);
9270 : :
9271 : : /* Construct a location e.g. :
9272 : : alignof (expr)
9273 : : ^~~~~~~~~~~~~~
9274 : : with start == caret at the start of the "alignof"/"sizeof"
9275 : : token, with the endpoint at the final closing paren. */
9276 : 4480043 : location_t compound_loc
9277 : 4480043 : = make_location (start_loc, start_loc, parser->lexer);
9278 : :
9279 : 4480043 : if (TYPE_P (operand))
9280 : 3934199 : ret = cxx_sizeof_or_alignof_type (compound_loc, operand, op,
9281 : : std_alignof, true);
9282 : : else
9283 : : {
9284 : : /* ISO C++ defines alignof only with types, not with
9285 : : expressions. So pedwarn if alignof is used with a non-
9286 : : type expression. However, __alignof__ is ok. */
9287 : 545844 : if (std_alignof)
9288 : 40 : pedwarn (token->location, OPT_Wpedantic,
9289 : : "ISO C++ does not allow %<alignof%> "
9290 : : "with a non-type");
9291 : :
9292 : 545844 : ret = cxx_sizeof_or_alignof_expr (compound_loc, operand, op,
9293 : : std_alignof, true);
9294 : : }
9295 : : /* For SIZEOF_EXPR, just issue diagnostics, but keep
9296 : : SIZEOF_EXPR with the original operand. */
9297 : 4480043 : if (op == SIZEOF_EXPR && ret != error_mark_node)
9298 : : {
9299 : 3948001 : if (TREE_CODE (ret) != SIZEOF_EXPR || TYPE_P (operand))
9300 : : {
9301 : 3661147 : if (!processing_template_decl && TYPE_P (operand))
9302 : : {
9303 : 747601 : ret = build_min (SIZEOF_EXPR, size_type_node,
9304 : : build1 (NOP_EXPR, operand,
9305 : : error_mark_node));
9306 : 747601 : SIZEOF_EXPR_TYPE_P (ret) = 1;
9307 : : }
9308 : : else
9309 : 2913546 : ret = build_min (SIZEOF_EXPR, size_type_node, operand);
9310 : 3661147 : TREE_SIDE_EFFECTS (ret) = 0;
9311 : 3661147 : TREE_READONLY (ret) = 1;
9312 : 3661147 : SET_EXPR_LOCATION (ret, compound_loc);
9313 : : }
9314 : : }
9315 : :
9316 : 4480043 : cp_expr ret_expr (ret, compound_loc);
9317 : 4480043 : ret_expr = ret_expr.maybe_add_location_wrapper ();
9318 : 4480043 : return ret_expr;
9319 : : }
9320 : :
9321 : 2107 : case RID_BUILTIN_HAS_ATTRIBUTE:
9322 : 2107 : return cp_parser_has_attribute_expression (parser);
9323 : :
9324 : 495066 : case RID_NEW:
9325 : 495066 : return cp_parser_new_expression (parser);
9326 : :
9327 : 511928 : case RID_DELETE:
9328 : 511928 : return cp_parser_delete_expression (parser);
9329 : :
9330 : 64238 : case RID_EXTENSION:
9331 : 64238 : {
9332 : : /* The saved value of the PEDANTIC flag. */
9333 : 64238 : int saved_pedantic;
9334 : 64238 : tree expr;
9335 : :
9336 : : /* Save away the PEDANTIC flag. */
9337 : 64238 : cp_parser_extension_opt (parser, &saved_pedantic);
9338 : : /* Also suppress -Wconditionally-supported. */
9339 : 64238 : diagnostic_push_diagnostics (global_dc, input_location);
9340 : 64238 : diagnostic_classify_diagnostic
9341 : 64238 : (global_dc, OPT_Wconditionally_supported,
9342 : : DK_IGNORED, input_location);
9343 : : /* Parse the cast-expression. */
9344 : 64238 : expr = cp_parser_simple_cast_expression (parser);
9345 : : /* Restore the PEDANTIC flag. */
9346 : 64238 : diagnostic_pop_diagnostics (global_dc, input_location);
9347 : 64238 : pedantic = saved_pedantic;
9348 : :
9349 : 64238 : return expr;
9350 : : }
9351 : :
9352 : 166080 : case RID_REALPART:
9353 : 166080 : case RID_IMAGPART:
9354 : 166080 : {
9355 : 166080 : tree expression;
9356 : :
9357 : : /* Consume the `__real__' or `__imag__' token. */
9358 : 166080 : cp_lexer_consume_token (parser->lexer);
9359 : : /* Parse the cast-expression. */
9360 : 166080 : expression = cp_parser_simple_cast_expression (parser);
9361 : : /* Create the complete representation. */
9362 : 166080 : return build_x_unary_op (token->location,
9363 : : (keyword == RID_REALPART
9364 : : ? REALPART_EXPR : IMAGPART_EXPR),
9365 : : expression, NULL_TREE,
9366 : 249120 : tf_warning_or_error);
9367 : : }
9368 : 83 : break;
9369 : :
9370 : 83 : case RID_TRANSACTION_ATOMIC:
9371 : 83 : case RID_TRANSACTION_RELAXED:
9372 : 83 : return cp_parser_transaction_expression (parser, keyword);
9373 : :
9374 : 1530394 : case RID_NOEXCEPT:
9375 : 1530394 : {
9376 : 1530394 : tree expr;
9377 : 1530394 : const char *saved_message;
9378 : 1530394 : bool saved_integral_constant_expression_p;
9379 : 1530394 : bool saved_non_integral_constant_expression_p;
9380 : 1530394 : bool saved_greater_than_is_operator_p;
9381 : :
9382 : 1530394 : location_t start_loc = token->location;
9383 : :
9384 : 1530394 : cp_lexer_consume_token (parser->lexer);
9385 : 1530394 : matching_parens parens;
9386 : 1530394 : parens.require_open (parser);
9387 : :
9388 : 1530394 : saved_message = parser->type_definition_forbidden_message;
9389 : 1530394 : parser->type_definition_forbidden_message
9390 : 1530394 : = G_("types may not be defined in %<noexcept%> expressions");
9391 : :
9392 : 1530394 : saved_integral_constant_expression_p
9393 : 1530394 : = parser->integral_constant_expression_p;
9394 : 1530394 : saved_non_integral_constant_expression_p
9395 : 1530394 : = parser->non_integral_constant_expression_p;
9396 : 1530394 : parser->integral_constant_expression_p = false;
9397 : :
9398 : 1530394 : saved_greater_than_is_operator_p
9399 : 1530394 : = parser->greater_than_is_operator_p;
9400 : 1530394 : parser->greater_than_is_operator_p = true;
9401 : :
9402 : 1530394 : ++cp_unevaluated_operand;
9403 : 1530394 : ++c_inhibit_evaluation_warnings;
9404 : 1530394 : ++cp_noexcept_operand;
9405 : 1530394 : expr = cp_parser_expression (parser);
9406 : 1530394 : --cp_noexcept_operand;
9407 : 1530394 : --c_inhibit_evaluation_warnings;
9408 : 1530394 : --cp_unevaluated_operand;
9409 : :
9410 : 1530394 : parser->greater_than_is_operator_p
9411 : 1530394 : = saved_greater_than_is_operator_p;
9412 : :
9413 : 1530394 : parser->integral_constant_expression_p
9414 : 1530394 : = saved_integral_constant_expression_p;
9415 : 1530394 : parser->non_integral_constant_expression_p
9416 : 1530394 : = saved_non_integral_constant_expression_p;
9417 : :
9418 : 1530394 : parser->type_definition_forbidden_message = saved_message;
9419 : :
9420 : 1530394 : parens.require_close (parser);
9421 : :
9422 : : /* Construct a location of the form:
9423 : : noexcept (expr)
9424 : : ^~~~~~~~~~~~~~~
9425 : : with start == caret, finishing at the close-paren. */
9426 : 1530394 : location_t noexcept_loc
9427 : 1530394 : = make_location (start_loc, start_loc, parser->lexer);
9428 : :
9429 : 1530394 : return cp_expr (finish_noexcept_expr (expr, tf_warning_or_error),
9430 : 1530394 : noexcept_loc);
9431 : : }
9432 : :
9433 : 682 : case RID_CO_AWAIT:
9434 : 682 : {
9435 : 682 : tree expr;
9436 : 682 : location_t kw_loc = token->location;
9437 : :
9438 : : /* Consume the `co_await' token. */
9439 : 682 : cp_lexer_consume_token (parser->lexer);
9440 : : /* Parse its cast-expression. */
9441 : 682 : expr = cp_parser_simple_cast_expression (parser);
9442 : 682 : if (expr == error_mark_node)
9443 : 1 : return error_mark_node;
9444 : :
9445 : : /* ... but, we cannot use co_await in default arguments. */
9446 : 681 : if (parser->local_variables_forbidden_p & LOCAL_VARS_FORBIDDEN)
9447 : : {
9448 : 1 : error_at (kw_loc,
9449 : : "%<co_await%> cannot be used in default arguments");
9450 : 1 : return error_mark_node;
9451 : : }
9452 : :
9453 : : /* Handle [expr.await]. */
9454 : 680 : return cp_expr (finish_co_await_expr (kw_loc, expr));
9455 : : }
9456 : :
9457 : : default:
9458 : : break;
9459 : : }
9460 : : }
9461 : :
9462 : : /* Look for the `:: new' and `:: delete', which also signal the
9463 : : beginning of a new-expression, or delete-expression,
9464 : : respectively. If the next token is `::', then it might be one of
9465 : : these. */
9466 : 926659758 : if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
9467 : : {
9468 : 886150 : enum rid keyword;
9469 : :
9470 : : /* See if the token after the `::' is one of the keywords in
9471 : : which we're interested. */
9472 : 886150 : keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword;
9473 : : /* If it's `new', we have a new-expression. */
9474 : 886150 : if (keyword == RID_NEW)
9475 : 355874 : return cp_parser_new_expression (parser);
9476 : : /* Similarly, for `delete'. */
9477 : 530276 : else if (keyword == RID_DELETE)
9478 : 48 : return cp_parser_delete_expression (parser);
9479 : : }
9480 : :
9481 : : /* Look for a unary operator. */
9482 : 1852607696 : unary_operator = cp_parser_unary_operator (token);
9483 : : /* The `++' and `--' operators can be handled similarly, even though
9484 : : they are not technically unary-operators in the grammar. */
9485 : 46912686 : if (unary_operator == ERROR_MARK)
9486 : : {
9487 : 879391174 : if (token->type == CPP_PLUS_PLUS)
9488 : : unary_operator = PREINCREMENT_EXPR;
9489 : 867856159 : else if (token->type == CPP_MINUS_MINUS)
9490 : : unary_operator = PREDECREMENT_EXPR;
9491 : : /* Handle the GNU address-of-label extension. */
9492 : 865938935 : else if (cp_parser_allow_gnu_extensions_p (parser)
9493 : 865938935 : && token->type == CPP_AND_AND)
9494 : : {
9495 : 229 : tree identifier;
9496 : 229 : tree expression;
9497 : 229 : location_t start_loc = token->location;
9498 : :
9499 : : /* Consume the '&&' token. */
9500 : 229 : cp_lexer_consume_token (parser->lexer);
9501 : : /* Look for the identifier. */
9502 : 229 : identifier = cp_parser_identifier (parser);
9503 : : /* Construct a location of the form:
9504 : : &&label
9505 : : ^~~~~~~
9506 : : with caret==start at the "&&", finish at the end of the label. */
9507 : 229 : location_t combined_loc
9508 : 229 : = make_location (start_loc, start_loc, parser->lexer);
9509 : : /* Create an expression representing the address. */
9510 : 229 : expression = finish_label_address_expr (identifier, combined_loc);
9511 : 229 : if (TREE_CODE (expression) == ADDR_EXPR)
9512 : 220 : mark_label_addressed (identifier);
9513 : 229 : if (cp_parser_non_integral_constant_expression (parser,
9514 : : NIC_ADDR_LABEL))
9515 : 2 : expression = error_mark_node;
9516 : 229 : return expression;
9517 : : }
9518 : : }
9519 : 865938706 : if (unary_operator != ERROR_MARK)
9520 : : {
9521 : 60364901 : cp_expr cast_expression;
9522 : 60364901 : cp_expr expression = error_mark_node;
9523 : 60364901 : non_integral_constant non_constant_p = NIC_NONE;
9524 : 60364901 : location_t loc = token->location;
9525 : 60364901 : tsubst_flags_t complain = complain_flags (decltype_p);
9526 : :
9527 : : /* Consume the operator token. */
9528 : 60364901 : token = cp_lexer_consume_token (parser->lexer);
9529 : 60364901 : enum cpp_ttype op_ttype = cp_lexer_peek_token (parser->lexer)->type;
9530 : :
9531 : : /* Parse the cast-expression. */
9532 : 60364901 : cast_expression
9533 : 60364901 : = cp_parser_cast_expression (parser,
9534 : : unary_operator == ADDR_EXPR,
9535 : : /*cast_p=*/false,
9536 : : /*decltype*/false,
9537 : : pidk);
9538 : :
9539 : : /* Make a location:
9540 : : OP_TOKEN CAST_EXPRESSION
9541 : : ^~~~~~~~~~~~~~~~~~~~~~~~~
9542 : : with start==caret at the operator token, and
9543 : : extending to the end of the cast_expression. */
9544 : 60364901 : loc = make_location (loc, loc, cast_expression.get_finish ());
9545 : :
9546 : : /* Now, build an appropriate representation. */
9547 : 60364901 : switch (unary_operator)
9548 : : {
9549 : 22606032 : case INDIRECT_REF:
9550 : 22606032 : non_constant_p = NIC_STAR;
9551 : 22606032 : expression = build_x_indirect_ref (loc, cast_expression,
9552 : : RO_UNARY_STAR, NULL_TREE,
9553 : 22606032 : complain);
9554 : : /* TODO: build_x_indirect_ref does not always honor the
9555 : : location, so ensure it is set. */
9556 : 22606032 : expression.set_location (loc);
9557 : 22606032 : break;
9558 : :
9559 : 4393309 : case ADDR_EXPR:
9560 : 4393309 : non_constant_p = NIC_ADDR;
9561 : : /* Fall through. */
9562 : 5304683 : case BIT_NOT_EXPR:
9563 : 10609366 : expression = build_x_unary_op (loc, unary_operator,
9564 : : cast_expression,
9565 : 5304683 : NULL_TREE, complain);
9566 : : /* TODO: build_x_unary_op does not always honor the location,
9567 : : so ensure it is set. */
9568 : 5304683 : expression.set_location (loc);
9569 : 5304683 : break;
9570 : :
9571 : 13452239 : case PREINCREMENT_EXPR:
9572 : 13452239 : case PREDECREMENT_EXPR:
9573 : 13452239 : non_constant_p = unary_operator == PREINCREMENT_EXPR
9574 : 13452239 : ? NIC_PREINCREMENT : NIC_PREDECREMENT;
9575 : : /* Fall through. */
9576 : 18341645 : case NEGATE_EXPR:
9577 : : /* Immediately fold negation of a constant, unless the constant is 0
9578 : : (since -0 == 0) or it would overflow. */
9579 : 18341645 : if (unary_operator == NEGATE_EXPR && op_ttype == CPP_NUMBER)
9580 : : {
9581 : 2894033 : tree stripped_expr
9582 : 2894033 : = tree_strip_any_location_wrapper (cast_expression);
9583 : 2894033 : if (CONSTANT_CLASS_P (stripped_expr)
9584 : 2885849 : && !integer_zerop (stripped_expr)
9585 : 5779474 : && !TREE_OVERFLOW (stripped_expr))
9586 : : {
9587 : 2885441 : tree folded = fold_build1 (unary_operator,
9588 : : TREE_TYPE (stripped_expr),
9589 : : stripped_expr);
9590 : 2885441 : if (CONSTANT_CLASS_P (folded) && !TREE_OVERFLOW (folded))
9591 : : {
9592 : 2885441 : expression = maybe_wrap_with_location (folded, loc);
9593 : 2885441 : break;
9594 : : }
9595 : : }
9596 : : }
9597 : : /* Fall through. */
9598 : 29568745 : case UNARY_PLUS_EXPR:
9599 : 29568745 : case TRUTH_NOT_EXPR:
9600 : 29568745 : expression = finish_unary_op_expr (loc, unary_operator,
9601 : : cast_expression, complain);
9602 : 29568745 : break;
9603 : :
9604 : 0 : default:
9605 : 0 : gcc_unreachable ();
9606 : : }
9607 : :
9608 : 22606032 : if (non_constant_p != NIC_NONE
9609 : 60364901 : && cp_parser_non_integral_constant_expression (parser,
9610 : : non_constant_p))
9611 : 12 : expression = error_mark_node;
9612 : :
9613 : 60364901 : return expression;
9614 : : }
9615 : :
9616 : 865938706 : return cp_parser_postfix_expression (parser, address_p, cast_p,
9617 : : /*member_access_only_p=*/false,
9618 : : decltype_p,
9619 : 865938685 : pidk);
9620 : : }
9621 : :
9622 : : /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
9623 : : unary-operator, the corresponding tree code is returned. */
9624 : :
9625 : : static enum tree_code
9626 : 926303836 : cp_parser_unary_operator (cp_token* token)
9627 : : {
9628 : 926303836 : switch (token->type)
9629 : : {
9630 : : case CPP_MULT:
9631 : : return INDIRECT_REF;
9632 : :
9633 : : case CPP_AND:
9634 : : return ADDR_EXPR;
9635 : :
9636 : : case CPP_PLUS:
9637 : : return UNARY_PLUS_EXPR;
9638 : :
9639 : : case CPP_MINUS:
9640 : : return NEGATE_EXPR;
9641 : :
9642 : : case CPP_NOT:
9643 : : return TRUTH_NOT_EXPR;
9644 : :
9645 : : case CPP_COMPL:
9646 : : return BIT_NOT_EXPR;
9647 : :
9648 : : default:
9649 : : return ERROR_MARK;
9650 : : }
9651 : : }
9652 : :
9653 : : /* Parse a __builtin_has_attribute([expr|type], attribute-spec) expression.
9654 : : Returns a representation of the expression. */
9655 : :
9656 : : static tree
9657 : 2107 : cp_parser_has_attribute_expression (cp_parser *parser)
9658 : : {
9659 : 2107 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
9660 : :
9661 : : /* Consume the __builtin_has_attribute token. */
9662 : 2107 : cp_lexer_consume_token (parser->lexer);
9663 : :
9664 : 2107 : matching_parens parens;
9665 : 2107 : if (!parens.require_open (parser))
9666 : 0 : return error_mark_node;
9667 : :
9668 : : /* Types cannot be defined in a `sizeof' expression. Save away the
9669 : : old message. */
9670 : 2107 : const char *saved_message = parser->type_definition_forbidden_message;
9671 : 2107 : const char *saved_message_arg
9672 : : = parser->type_definition_forbidden_message_arg;
9673 : 2107 : parser->type_definition_forbidden_message
9674 : 2107 : = G_("types may not be defined in %qs expressions");
9675 : 2107 : parser->type_definition_forbidden_message_arg
9676 : 2107 : = IDENTIFIER_POINTER (ridpointers[RID_BUILTIN_HAS_ATTRIBUTE]);
9677 : :
9678 : : /* The restrictions on constant-expressions do not apply inside
9679 : : sizeof expressions. */
9680 : 2107 : bool saved_integral_constant_expression_p
9681 : : = parser->integral_constant_expression_p;
9682 : 2107 : bool saved_non_integral_constant_expression_p
9683 : : = parser->non_integral_constant_expression_p;
9684 : 2107 : parser->integral_constant_expression_p = false;
9685 : :
9686 : : /* Do not actually evaluate the expression. */
9687 : 2107 : ++cp_unevaluated_operand;
9688 : 2107 : ++c_inhibit_evaluation_warnings;
9689 : :
9690 : 2107 : tree oper = NULL_TREE;
9691 : :
9692 : : /* We can't be sure yet whether we're looking at a type-id or an
9693 : : expression. */
9694 : 2107 : cp_parser_parse_tentatively (parser);
9695 : :
9696 : 2107 : {
9697 : 2107 : type_id_in_expr_sentinel s (parser);
9698 : : /* Look for the type-id. */
9699 : 4214 : oper = cp_parser_type_id (parser);
9700 : 2107 : }
9701 : :
9702 : 2107 : cp_parser_parse_definitely (parser);
9703 : :
9704 : : /* If the type-id production did not work out, then we must be
9705 : : looking at an expression. */
9706 : 2107 : if (!oper || oper == error_mark_node)
9707 : 1675 : oper = cp_parser_assignment_expression (parser);
9708 : :
9709 : 2107 : STRIP_ANY_LOCATION_WRAPPER (oper);
9710 : :
9711 : : /* Go back to evaluating expressions. */
9712 : 2107 : --cp_unevaluated_operand;
9713 : 2107 : --c_inhibit_evaluation_warnings;
9714 : :
9715 : : /* And restore the old one. */
9716 : 2107 : parser->type_definition_forbidden_message = saved_message;
9717 : 2107 : parser->type_definition_forbidden_message_arg = saved_message_arg;
9718 : 2107 : parser->integral_constant_expression_p
9719 : 2107 : = saved_integral_constant_expression_p;
9720 : 2107 : parser->non_integral_constant_expression_p
9721 : 2107 : = saved_non_integral_constant_expression_p;
9722 : :
9723 : : /* Consume the comma if it's there. */
9724 : 2107 : if (!cp_parser_require (parser, CPP_COMMA, RT_COMMA))
9725 : : {
9726 : 12 : cp_parser_skip_to_closing_parenthesis (parser, false, false,
9727 : : /*consume_paren=*/true);
9728 : 12 : return error_mark_node;
9729 : : }
9730 : :
9731 : : /* Parse the attribute specification. */
9732 : 2095 : bool ret = false;
9733 : 2095 : location_t atloc = cp_lexer_peek_token (parser->lexer)->location;
9734 : 2095 : if (tree attr = cp_parser_gnu_attribute_list (parser, /*exactly_one=*/true))
9735 : : {
9736 : 2086 : if (oper == error_mark_node)
9737 : : /* Nothing. */;
9738 : 2083 : else if (processing_template_decl && uses_template_parms (oper))
9739 : 6 : sorry_at (atloc, "%<__builtin_has_attribute%> with dependent argument "
9740 : : "not supported yet");
9741 : : else
9742 : : {
9743 : : /* Fold constant expressions used in attributes first. */
9744 : 2077 : cp_check_const_attributes (attr);
9745 : :
9746 : : /* Finally, see if OPER has been declared with ATTR. */
9747 : 2077 : ret = has_attribute (atloc, oper, attr, default_conversion);
9748 : : }
9749 : :
9750 : 2086 : parens.require_close (parser);
9751 : : }
9752 : : else
9753 : : {
9754 : 9 : error_at (atloc, "expected identifier");
9755 : 9 : cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
9756 : : }
9757 : :
9758 : : /* Construct a location e.g. :
9759 : : __builtin_has_attribute (oper, attr)
9760 : : ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9761 : : with start == caret at the start of the built-in token,
9762 : : and with the endpoint at the final closing paren. */
9763 : 2095 : location_t compound_loc
9764 : 2095 : = make_location (start_loc, start_loc, parser->lexer);
9765 : :
9766 : 2095 : cp_expr ret_expr (ret ? boolean_true_node : boolean_false_node);
9767 : 2095 : ret_expr.set_location (compound_loc);
9768 : 2095 : ret_expr = ret_expr.maybe_add_location_wrapper ();
9769 : 2095 : return ret_expr;
9770 : : }
9771 : :
9772 : : /* Parse a new-expression.
9773 : :
9774 : : new-expression:
9775 : : :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
9776 : : :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
9777 : :
9778 : : Returns a representation of the expression. */
9779 : :
9780 : : static tree
9781 : 850940 : cp_parser_new_expression (cp_parser* parser)
9782 : : {
9783 : 850940 : bool global_scope_p;
9784 : 850940 : vec<tree, va_gc> *placement;
9785 : 850940 : tree type;
9786 : 850940 : vec<tree, va_gc> *initializer;
9787 : 850940 : tree nelts = NULL_TREE;
9788 : 850940 : tree ret;
9789 : :
9790 : 850940 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
9791 : :
9792 : : /* Look for the optional `::' operator. */
9793 : 850940 : global_scope_p
9794 : 850940 : = (cp_parser_global_scope_opt (parser,
9795 : : /*current_scope_valid_p=*/false)
9796 : : != NULL_TREE);
9797 : : /* Look for the `new' operator. */
9798 : 850940 : cp_parser_require_keyword (parser, RID_NEW, RT_NEW);
9799 : : /* There's no easy way to tell a new-placement from the
9800 : : `( type-id )' construct. */
9801 : 850940 : cp_parser_parse_tentatively (parser);
9802 : : /* Look for a new-placement. */
9803 : 850940 : placement = cp_parser_new_placement (parser);
9804 : : /* If that didn't work out, there's no new-placement. */
9805 : 850940 : if (!cp_parser_parse_definitely (parser))
9806 : : {
9807 : 426202 : if (placement != NULL)
9808 : 101 : release_tree_vector (placement);
9809 : 426202 : placement = NULL;
9810 : : }
9811 : :
9812 : : /* If the next token is a `(', then we have a parenthesized
9813 : : type-id. */
9814 : 850940 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
9815 : : {
9816 : 125 : cp_token *token;
9817 : 125 : const char *saved_message = parser->type_definition_forbidden_message;
9818 : :
9819 : : /* Consume the `('. */
9820 : 125 : matching_parens parens;
9821 : 125 : parens.consume_open (parser);
9822 : :
9823 : : /* Parse the type-id. */
9824 : 125 : parser->type_definition_forbidden_message
9825 : 125 : = G_("types may not be defined in a new-expression");
9826 : 125 : {
9827 : 125 : type_id_in_expr_sentinel s (parser);
9828 : 250 : type = cp_parser_type_id (parser);
9829 : 125 : }
9830 : 125 : parser->type_definition_forbidden_message = saved_message;
9831 : :
9832 : : /* Look for the closing `)'. */
9833 : 125 : parens.require_close (parser);
9834 : 125 : token = cp_lexer_peek_token (parser->lexer);
9835 : : /* There should not be a direct-new-declarator in this production,
9836 : : but GCC used to allowed this, so we check and emit a sensible error
9837 : : message for this case. */
9838 : 125 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
9839 : : {
9840 : 3 : {
9841 : 3 : auto_diagnostic_group d;
9842 : 3 : error_at (token->location,
9843 : : "array bound forbidden after parenthesized type-id");
9844 : 3 : inform (token->location,
9845 : : "try removing the parentheses around the type-id");
9846 : 3 : }
9847 : 3 : cp_parser_direct_new_declarator (parser);
9848 : : }
9849 : : }
9850 : : /* Otherwise, there must be a new-type-id. */
9851 : : else
9852 : 850815 : type = cp_parser_new_type_id (parser, &nelts);
9853 : :
9854 : : /* If the next token is a `(' or '{', then we have a new-initializer. */
9855 : 850940 : cp_token *token = cp_lexer_peek_token (parser->lexer);
9856 : 850940 : if (token->type == CPP_OPEN_PAREN
9857 : 288727 : || token->type == CPP_OPEN_BRACE)
9858 : 572632 : initializer = cp_parser_new_initializer (parser);
9859 : : else
9860 : 278308 : initializer = NULL;
9861 : :
9862 : : /* A new-expression may not appear in an integral constant
9863 : : expression. */
9864 : 850940 : if (cp_parser_non_integral_constant_expression (parser, NIC_NEW))
9865 : 0 : ret = error_mark_node;
9866 : : /* 5.3.4/2: "If the auto type-specifier appears in the type-specifier-seq
9867 : : of a new-type-id or type-id of a new-expression, the new-expression shall
9868 : : contain a new-initializer of the form ( assignment-expression )".
9869 : : Additionally, consistently with the spirit of DR 1467, we want to accept
9870 : : 'new auto { 2 }' too. */
9871 : 850940 : else if ((ret = type_uses_auto (type))
9872 : 88 : && !CLASS_PLACEHOLDER_TEMPLATE (ret)
9873 : 850989 : && (vec_safe_length (initializer) != 1
9874 : 42 : || (BRACE_ENCLOSED_INITIALIZER_P ((*initializer)[0])
9875 : 16 : && CONSTRUCTOR_NELTS ((*initializer)[0]) != 1)))
9876 : : {
9877 : 14 : error_at (token->location,
9878 : : "initialization of new-expression for type %<auto%> "
9879 : : "requires exactly one element");
9880 : 14 : ret = error_mark_node;
9881 : : }
9882 : : else
9883 : : {
9884 : : /* Construct a location e.g.:
9885 : : ptr = new int[100]
9886 : : ^~~~~~~~~~~~
9887 : : with caret == start at the start of the "new" token, and the end
9888 : : at the end of the final token we consumed. */
9889 : 850926 : location_t combined_loc = make_location (start_loc, start_loc,
9890 : : parser->lexer);
9891 : : /* Create a representation of the new-expression. */
9892 : 850926 : ret = build_new (combined_loc, &placement, type, nelts, &initializer,
9893 : : global_scope_p, tf_warning_or_error);
9894 : : }
9895 : :
9896 : 850940 : if (placement != NULL)
9897 : 564547 : release_tree_vector (placement);
9898 : 850940 : if (initializer != NULL)
9899 : 551079 : release_tree_vector (initializer);
9900 : :
9901 : 850940 : return ret;
9902 : : }
9903 : :
9904 : : /* Parse a new-placement.
9905 : :
9906 : : new-placement:
9907 : : ( expression-list )
9908 : :
9909 : : Returns the same representation as for an expression-list. */
9910 : :
9911 : : static vec<tree, va_gc> *
9912 : 850940 : cp_parser_new_placement (cp_parser* parser)
9913 : : {
9914 : 850940 : vec<tree, va_gc> *expression_list;
9915 : :
9916 : : /* Parse the expression-list. */
9917 : 850940 : expression_list = (cp_parser_parenthesized_expression_list
9918 : 850940 : (parser, non_attr, /*cast_p=*/false,
9919 : : /*allow_expansion_p=*/true,
9920 : : /*non_constant_p=*/NULL));
9921 : :
9922 : 850940 : if (expression_list && expression_list->is_empty ())
9923 : 3 : error ("expected expression-list or type-id");
9924 : :
9925 : 850940 : return expression_list;
9926 : : }
9927 : :
9928 : : /* Parse a new-type-id.
9929 : :
9930 : : new-type-id:
9931 : : type-specifier-seq new-declarator [opt]
9932 : :
9933 : : Returns the TYPE allocated. If the new-type-id indicates an array
9934 : : type, *NELTS is set to the number of elements in the last array
9935 : : bound; the TYPE will not include the last array bound. */
9936 : :
9937 : : static tree
9938 : 850815 : cp_parser_new_type_id (cp_parser* parser, tree *nelts)
9939 : : {
9940 : 850815 : cp_decl_specifier_seq type_specifier_seq;
9941 : 850815 : cp_declarator *new_declarator;
9942 : 850815 : cp_declarator *declarator;
9943 : 850815 : cp_declarator *outer_declarator;
9944 : 850815 : const char *saved_message;
9945 : :
9946 : : /* The type-specifier sequence must not contain type definitions.
9947 : : (It cannot contain declarations of new types either, but if they
9948 : : are not definitions we will catch that because they are not
9949 : : complete.) */
9950 : 850815 : saved_message = parser->type_definition_forbidden_message;
9951 : 850815 : parser->type_definition_forbidden_message
9952 : 850815 : = G_("types may not be defined in a new-type-id");
9953 : : /* Parse the type-specifier-seq. */
9954 : 850815 : cp_parser_type_specifier_seq (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
9955 : : /*is_declaration=*/false,
9956 : : /*is_trailing_return=*/false,
9957 : : &type_specifier_seq);
9958 : : /* Restore the old message. */
9959 : 850815 : parser->type_definition_forbidden_message = saved_message;
9960 : :
9961 : 850815 : if (type_specifier_seq.type == error_mark_node)
9962 : : return error_mark_node;
9963 : :
9964 : : /* Parse the new-declarator. */
9965 : 850802 : new_declarator = cp_parser_new_declarator_opt (parser);
9966 : :
9967 : : /* Determine the number of elements in the last array dimension, if
9968 : : any. */
9969 : 850802 : *nelts = NULL_TREE;
9970 : : /* Skip down to the last array dimension. */
9971 : 850802 : declarator = new_declarator;
9972 : 850802 : outer_declarator = NULL;
9973 : 850873 : while (declarator && (declarator->kind == cdk_pointer
9974 : 183474 : || declarator->kind == cdk_ptrmem))
9975 : : {
9976 : 71 : outer_declarator = declarator;
9977 : 71 : declarator = declarator->declarator;
9978 : : }
9979 : : while (declarator
9980 : 185495 : && declarator->kind == cdk_array
9981 : 185486 : && declarator->declarator
9982 : 852823 : && declarator->declarator->kind == cdk_array)
9983 : : {
9984 : : outer_declarator = declarator;
9985 : : declarator = declarator->declarator;
9986 : : }
9987 : :
9988 : 850802 : if (declarator && declarator->kind == cdk_array)
9989 : : {
9990 : 183465 : *nelts = declarator->u.array.bounds;
9991 : 183465 : if (*nelts == error_mark_node)
9992 : 18 : *nelts = integer_one_node;
9993 : :
9994 : : /* FIXME: Maybe build even the outermost array type and strip
9995 : : it, to diagnose the attributes on it. Problem is that VLAs aren't
9996 : : pedantically allowed except for this case. */
9997 : 183465 : if (*nelts
9998 : 183339 : && declarator->std_attributes
9999 : 183521 : && any_nonignored_attribute_p (declarator->std_attributes))
10000 : 56 : warning (OPT_Wattributes, "attributes ignored on outermost array "
10001 : : "type in new expression");
10002 : :
10003 : 183465 : if (*nelts == NULL_TREE)
10004 : : /* Leave [] in the declarator. */;
10005 : 183339 : else if (outer_declarator)
10006 : 1305 : outer_declarator->declarator = declarator->declarator;
10007 : : else
10008 : : new_declarator = NULL;
10009 : : }
10010 : :
10011 : 850802 : return groktypename (&type_specifier_seq, new_declarator, false);
10012 : : }
10013 : :
10014 : : /* Parse an (optional) new-declarator.
10015 : :
10016 : : new-declarator:
10017 : : ptr-operator new-declarator [opt]
10018 : : direct-new-declarator
10019 : :
10020 : : Returns the declarator. */
10021 : :
10022 : : static cp_declarator *
10023 : 850882 : cp_parser_new_declarator_opt (cp_parser* parser)
10024 : : {
10025 : 850882 : enum tree_code code;
10026 : 850882 : tree type, std_attributes = NULL_TREE;
10027 : 850882 : cp_cv_quals cv_quals;
10028 : :
10029 : : /* We don't know if there's a ptr-operator next, or not. */
10030 : 850882 : cp_parser_parse_tentatively (parser);
10031 : : /* Look for a ptr-operator. */
10032 : 850882 : code = cp_parser_ptr_operator (parser, &type, &cv_quals, &std_attributes);
10033 : : /* If that worked, look for more new-declarators. */
10034 : 850882 : if (cp_parser_parse_definitely (parser))
10035 : : {
10036 : 80 : cp_declarator *declarator;
10037 : :
10038 : : /* Parse another optional declarator. */
10039 : 80 : declarator = cp_parser_new_declarator_opt (parser);
10040 : :
10041 : 80 : declarator = cp_parser_make_indirect_declarator
10042 : 80 : (code, type, cv_quals, declarator, std_attributes);
10043 : :
10044 : 80 : return declarator;
10045 : : }
10046 : :
10047 : : /* If the next token is a `[', there is a direct-new-declarator. */
10048 : 850802 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
10049 : 183471 : return cp_parser_direct_new_declarator (parser);
10050 : :
10051 : : return NULL;
10052 : : }
10053 : :
10054 : : /* Parse a direct-new-declarator.
10055 : :
10056 : : direct-new-declarator:
10057 : : [ expression ] attribute-specifier-seq [opt]
10058 : : direct-new-declarator [constant-expression] attribute-specifier-seq [opt]
10059 : :
10060 : : */
10061 : :
10062 : : static cp_declarator *
10063 : 183474 : cp_parser_direct_new_declarator (cp_parser* parser)
10064 : : {
10065 : 183474 : cp_declarator *declarator = NULL;
10066 : 183474 : bool first_p = true;
10067 : :
10068 : 185495 : while (true)
10069 : : {
10070 : 185495 : tree expression;
10071 : 185495 : cp_token *token;
10072 : :
10073 : : /* Look for the opening `['. */
10074 : 185495 : cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
10075 : :
10076 : 185495 : token = cp_lexer_peek_token (parser->lexer);
10077 : 185495 : if (token->type == CPP_CLOSE_SQUARE && first_p)
10078 : : expression = NULL_TREE;
10079 : : else
10080 : 185369 : expression = cp_parser_expression (parser);
10081 : : /* The standard requires that the expression have integral
10082 : : type. DR 74 adds enumeration types. We believe that the
10083 : : real intent is that these expressions be handled like the
10084 : : expression in a `switch' condition, which also allows
10085 : : classes with a single conversion to integral or
10086 : : enumeration type. */
10087 : 185369 : if (expression && !processing_template_decl)
10088 : : {
10089 : 6139 : expression
10090 : 6139 : = build_expr_type_conversion (WANT_INT | WANT_ENUM,
10091 : : expression,
10092 : : /*complain=*/true);
10093 : 6139 : if (!expression)
10094 : : {
10095 : 15 : error_at (token->location,
10096 : : "expression in new-declarator must have integral "
10097 : : "or enumeration type");
10098 : 15 : expression = error_mark_node;
10099 : : }
10100 : : }
10101 : :
10102 : : /* Look for the closing `]'. */
10103 : 185495 : cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
10104 : :
10105 : 185495 : tree attrs = cp_parser_std_attribute_spec_seq (parser);
10106 : : /* Add this bound to the declarator. */
10107 : 185495 : declarator = make_array_declarator (declarator, expression, attrs);
10108 : :
10109 : : /* If the next token is not a `[', then there are no more
10110 : : bounds. */
10111 : 185495 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
10112 : : break;
10113 : : first_p = false;
10114 : : }
10115 : :
10116 : 183474 : return declarator;
10117 : : }
10118 : :
10119 : : /* Parse a new-initializer.
10120 : :
10121 : : new-initializer:
10122 : : ( expression-list [opt] )
10123 : : braced-init-list
10124 : :
10125 : : Returns a representation of the expression-list. */
10126 : :
10127 : : static vec<tree, va_gc> *
10128 : 572632 : cp_parser_new_initializer (cp_parser* parser)
10129 : : {
10130 : 572632 : vec<tree, va_gc> *expression_list;
10131 : :
10132 : 572632 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
10133 : : {
10134 : 10419 : cp_lexer_set_source_position (parser->lexer);
10135 : 10419 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
10136 : 10419 : tree t = cp_parser_braced_list (parser);
10137 : 10419 : CONSTRUCTOR_IS_DIRECT_INIT (t) = true;
10138 : 10419 : expression_list = make_tree_vector_single (t);
10139 : : }
10140 : : else
10141 : 562213 : expression_list = (cp_parser_parenthesized_expression_list
10142 : 562213 : (parser, non_attr, /*cast_p=*/false,
10143 : : /*allow_expansion_p=*/true,
10144 : : /*non_constant_p=*/NULL));
10145 : :
10146 : 572632 : return expression_list;
10147 : : }
10148 : :
10149 : : /* Parse a delete-expression.
10150 : :
10151 : : delete-expression:
10152 : : :: [opt] delete cast-expression
10153 : : :: [opt] delete [ ] cast-expression
10154 : :
10155 : : Returns a representation of the expression. */
10156 : :
10157 : : static tree
10158 : 511976 : cp_parser_delete_expression (cp_parser* parser)
10159 : : {
10160 : 511976 : bool global_scope_p;
10161 : 511976 : bool array_p;
10162 : 511976 : tree expression;
10163 : 511976 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
10164 : :
10165 : : /* Look for the optional `::' operator. */
10166 : 511976 : global_scope_p
10167 : 511976 : = (cp_parser_global_scope_opt (parser,
10168 : : /*current_scope_valid_p=*/false)
10169 : : != NULL_TREE);
10170 : : /* Look for the `delete' keyword. */
10171 : 511976 : cp_parser_require_keyword (parser, RID_DELETE, RT_DELETE);
10172 : : /* See if the array syntax is in use. */
10173 : 511976 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
10174 : : {
10175 : : /* Consume the `[' token. */
10176 : 300449 : cp_lexer_consume_token (parser->lexer);
10177 : : /* Look for the `]' token. */
10178 : 300449 : cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
10179 : : /* Remember that this is the `[]' construct. */
10180 : 300449 : array_p = true;
10181 : : }
10182 : : else
10183 : : array_p = false;
10184 : :
10185 : : /* Parse the cast-expression. */
10186 : 511976 : expression = cp_parser_simple_cast_expression (parser);
10187 : :
10188 : : /* A delete-expression may not appear in an integral constant
10189 : : expression. */
10190 : 511976 : if (cp_parser_non_integral_constant_expression (parser, NIC_DEL))
10191 : 0 : return error_mark_node;
10192 : :
10193 : : /* Construct a location e.g.:
10194 : : delete [ ] ptr
10195 : : ^~~~~~~~~~~~~~
10196 : : with caret == start at the start of the "delete" token, and
10197 : : the end at the end of the final token we consumed. */
10198 : 511976 : location_t combined_loc = make_location (start_loc, start_loc,
10199 : : parser->lexer);
10200 : 511976 : expression = delete_sanity (combined_loc, expression, NULL_TREE, array_p,
10201 : : global_scope_p, tf_warning_or_error);
10202 : :
10203 : 511976 : return expression;
10204 : : }
10205 : :
10206 : : /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
10207 : : neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
10208 : : 0 otherwise. */
10209 : :
10210 : : static int
10211 : 33634542 : cp_parser_tokens_start_cast_expression (cp_parser *parser)
10212 : : {
10213 : 33634542 : cp_token *token = cp_lexer_peek_token (parser->lexer);
10214 : 33634542 : switch (token->type)
10215 : : {
10216 : : case CPP_COMMA:
10217 : : case CPP_SEMICOLON:
10218 : : case CPP_QUERY:
10219 : : case CPP_COLON:
10220 : : case CPP_CLOSE_SQUARE:
10221 : : case CPP_CLOSE_PAREN:
10222 : : case CPP_CLOSE_BRACE:
10223 : : case CPP_OPEN_BRACE:
10224 : : case CPP_DOT:
10225 : : case CPP_DOT_STAR:
10226 : : case CPP_DEREF:
10227 : : case CPP_DEREF_STAR:
10228 : : case CPP_DIV:
10229 : : case CPP_MOD:
10230 : : case CPP_LSHIFT:
10231 : : case CPP_RSHIFT:
10232 : : case CPP_LESS:
10233 : : case CPP_GREATER:
10234 : : case CPP_LESS_EQ:
10235 : : case CPP_GREATER_EQ:
10236 : : case CPP_EQ_EQ:
10237 : : case CPP_NOT_EQ:
10238 : : case CPP_EQ:
10239 : : case CPP_MULT_EQ:
10240 : : case CPP_DIV_EQ:
10241 : : case CPP_MOD_EQ:
10242 : : case CPP_PLUS_EQ:
10243 : : case CPP_MINUS_EQ:
10244 : : case CPP_RSHIFT_EQ:
10245 : : case CPP_LSHIFT_EQ:
10246 : : case CPP_AND_EQ:
10247 : : case CPP_XOR_EQ:
10248 : : case CPP_OR_EQ:
10249 : : case CPP_XOR:
10250 : : case CPP_OR:
10251 : : case CPP_OR_OR:
10252 : : case CPP_EOF:
10253 : : case CPP_ELLIPSIS:
10254 : : return 0;
10255 : :
10256 : 2477633 : case CPP_OPEN_PAREN:
10257 : : /* In ((type ()) () the last () isn't a valid cast-expression,
10258 : : so the whole must be parsed as postfix-expression. */
10259 : 2477633 : return cp_lexer_peek_nth_token (parser->lexer, 2)->type
10260 : 2477633 : != CPP_CLOSE_PAREN;
10261 : :
10262 : 169365 : case CPP_OPEN_SQUARE:
10263 : : /* '[' may start a primary-expression in obj-c++ and in C++11,
10264 : : as a lambda-expression, eg, '(void)[]{}'. */
10265 : 169365 : if (cxx_dialect >= cxx11)
10266 : : return -1;
10267 : 1117 : return c_dialect_objc ();
10268 : :
10269 : : case CPP_PLUS_PLUS:
10270 : : case CPP_MINUS_MINUS:
10271 : : /* '++' and '--' may or may not start a cast-expression:
10272 : :
10273 : : struct T { void operator++(int); };
10274 : : void f() { (T())++; }
10275 : :
10276 : : vs
10277 : :
10278 : : int a;
10279 : : (int)++a; */
10280 : : return -1;
10281 : :
10282 : 8986156 : default:
10283 : 8986156 : return 1;
10284 : : }
10285 : : }
10286 : :
10287 : : /* Try to find a legal C++-style cast to DST_TYPE for ORIG_EXPR, trying them
10288 : : in the order: const_cast, static_cast, reinterpret_cast.
10289 : :
10290 : : Don't suggest dynamic_cast.
10291 : :
10292 : : Return the first legal cast kind found, or NULL otherwise. */
10293 : :
10294 : : static const char *
10295 : 27 : get_cast_suggestion (tree dst_type, tree orig_expr)
10296 : : {
10297 : 27 : tree trial;
10298 : :
10299 : : /* Reuse the parser logic by attempting to build the various kinds of
10300 : : cast, with "complain" disabled.
10301 : : Identify the first such cast that is valid. */
10302 : :
10303 : : /* Don't attempt to run such logic within template processing. */
10304 : 27 : if (processing_template_decl)
10305 : : return NULL;
10306 : :
10307 : : /* First try const_cast. */
10308 : 24 : trial = build_const_cast (input_location, dst_type, orig_expr, tf_none);
10309 : 24 : if (trial != error_mark_node)
10310 : : return "const_cast";
10311 : :
10312 : : /* If that fails, try static_cast. */
10313 : 18 : trial = build_static_cast (input_location, dst_type, orig_expr, tf_none);
10314 : 18 : if (trial != error_mark_node)
10315 : : return "static_cast";
10316 : :
10317 : : /* Finally, try reinterpret_cast. */
10318 : 12 : trial = build_reinterpret_cast (input_location, dst_type, orig_expr,
10319 : : tf_none);
10320 : 12 : if (trial != error_mark_node)
10321 : : return "reinterpret_cast";
10322 : :
10323 : : /* No such cast possible. */
10324 : : return NULL;
10325 : : }
10326 : :
10327 : : /* If -Wold-style-cast is enabled, add fix-its to RICHLOC,
10328 : : suggesting how to convert a C-style cast of the form:
10329 : :
10330 : : (DST_TYPE)ORIG_EXPR
10331 : :
10332 : : to a C++-style cast.
10333 : :
10334 : : The primary range of RICHLOC is asssumed to be that of the original
10335 : : expression. OPEN_PAREN_LOC and CLOSE_PAREN_LOC give the locations
10336 : : of the parens in the C-style cast. */
10337 : :
10338 : : static void
10339 : 27 : maybe_add_cast_fixit (rich_location *rich_loc, location_t open_paren_loc,
10340 : : location_t close_paren_loc, tree orig_expr,
10341 : : tree dst_type)
10342 : : {
10343 : : /* This function is non-trivial, so bail out now if the warning isn't
10344 : : going to be emitted. */
10345 : 27 : if (!warn_old_style_cast)
10346 : 9 : return;
10347 : :
10348 : : /* Try to find a legal C++ cast, trying them in order:
10349 : : const_cast, static_cast, reinterpret_cast. */
10350 : 27 : const char *cast_suggestion = get_cast_suggestion (dst_type, orig_expr);
10351 : 27 : if (!cast_suggestion)
10352 : : return;
10353 : :
10354 : : /* Replace the open paren with "CAST_SUGGESTION<". */
10355 : 18 : pretty_printer pp;
10356 : 18 : pp_string (&pp, cast_suggestion);
10357 : 18 : pp_less (&pp);
10358 : 18 : rich_loc->add_fixit_replace (open_paren_loc, pp_formatted_text (&pp));
10359 : :
10360 : : /* Replace the close paren with "> (". */
10361 : 18 : rich_loc->add_fixit_replace (close_paren_loc, "> (");
10362 : :
10363 : : /* Add a closing paren after the expr (the primary range of RICH_LOC). */
10364 : 18 : rich_loc->add_fixit_insert_after (")");
10365 : 18 : }
10366 : :
10367 : :
10368 : : /* Parse a cast-expression.
10369 : :
10370 : : cast-expression:
10371 : : unary-expression
10372 : : ( type-id ) cast-expression
10373 : :
10374 : : ADDRESS_P is true iff the unary-expression is appearing as the
10375 : : operand of the `&' operator. CAST_P is true if this expression is
10376 : : the target of a cast.
10377 : :
10378 : : Returns a representation of the expression. */
10379 : :
10380 : : static cp_expr
10381 : 941592158 : cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p,
10382 : : bool decltype_p, cp_id_kind * pidk)
10383 : : {
10384 : : /* If it's a `(', then we might be looking at a cast. */
10385 : 941592158 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
10386 : : {
10387 : 33634554 : tree type = NULL_TREE;
10388 : 33634554 : cp_expr expr (NULL_TREE);
10389 : 33634554 : int cast_expression = 0;
10390 : 33634554 : const char *saved_message;
10391 : :
10392 : : /* There's no way to know yet whether or not this is a cast.
10393 : : For example, `(int (3))' is a unary-expression, while `(int)
10394 : : 3' is a cast. So, we resort to parsing tentatively. */
10395 : 33634554 : cp_parser_parse_tentatively (parser);
10396 : : /* Types may not be defined in a cast. */
10397 : 33634554 : saved_message = parser->type_definition_forbidden_message;
10398 : 33634554 : parser->type_definition_forbidden_message
10399 : 33634554 : = G_("types may not be defined in casts");
10400 : : /* Consume the `('. */
10401 : 33634554 : matching_parens parens;
10402 : 33634554 : cp_token *open_paren = parens.consume_open (parser);
10403 : 33634554 : location_t open_paren_loc = open_paren->location;
10404 : 33634554 : location_t close_paren_loc = UNKNOWN_LOCATION;
10405 : :
10406 : : /* A very tricky bit is that `(struct S) { 3 }' is a
10407 : : compound-literal (which we permit in C++ as an extension).
10408 : : But, that construct is not a cast-expression -- it is a
10409 : : postfix-expression. (The reason is that `(struct S) { 3 }.i'
10410 : : is legal; if the compound-literal were a cast-expression,
10411 : : you'd need an extra set of parentheses.) But, if we parse
10412 : : the type-id, and it happens to be a class-specifier, then we
10413 : : will commit to the parse at that point, because we cannot
10414 : : undo the action that is done when creating a new class. So,
10415 : : then we cannot back up and do a postfix-expression.
10416 : :
10417 : : Another tricky case is the following (c++/29234):
10418 : :
10419 : : struct S { void operator () (); };
10420 : :
10421 : : void foo ()
10422 : : {
10423 : : ( S()() );
10424 : : }
10425 : :
10426 : : As a type-id we parse the parenthesized S()() as a function
10427 : : returning a function, groktypename complains and we cannot
10428 : : back up in this case either.
10429 : :
10430 : : Therefore, we scan ahead to the closing `)', and check to see
10431 : : if the tokens after the `)' can start a cast-expression. Otherwise
10432 : : we are dealing with an unary-expression, a postfix-expression
10433 : : or something else.
10434 : :
10435 : : Yet another tricky case, in C++11, is the following (c++/54891):
10436 : :
10437 : : (void)[]{};
10438 : :
10439 : : The issue is that usually, besides the case of lambda-expressions,
10440 : : the parenthesized type-id cannot be followed by '[', and, eg, we
10441 : : want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
10442 : : Thus, if cp_parser_tokens_start_cast_expression returns -1, below
10443 : : we don't commit, we try a cast-expression, then an unary-expression.
10444 : :
10445 : : Save tokens so that we can put them back. */
10446 : 33634554 : cp_lexer_save_tokens (parser->lexer);
10447 : :
10448 : : /* We may be looking at a cast-expression. */
10449 : 33634554 : if (cp_parser_skip_to_closing_parenthesis (parser, false, false,
10450 : : /*consume_paren=*/true))
10451 : 33634542 : cast_expression
10452 : 33634542 : = cp_parser_tokens_start_cast_expression (parser);
10453 : :
10454 : : /* Roll back the tokens we skipped. */
10455 : 33634554 : cp_lexer_rollback_tokens (parser->lexer);
10456 : : /* If we aren't looking at a cast-expression, simulate an error so
10457 : : that the call to cp_parser_error_occurred below returns true. */
10458 : 33634554 : if (!cast_expression)
10459 : 55302782 : cp_parser_simulate_error (parser);
10460 : : else
10461 : : {
10462 : 11966326 : type_id_in_expr_sentinel s (parser);
10463 : : /* Look for the type-id. */
10464 : 11966326 : type = cp_parser_type_id (parser);
10465 : : /* Look for the closing `)'. */
10466 : 11966326 : cp_token *close_paren = parens.require_close (parser);
10467 : 11966326 : if (close_paren)
10468 : 8292624 : close_paren_loc = close_paren->location;
10469 : 11966326 : }
10470 : :
10471 : : /* Restore the saved message. */
10472 : 33634554 : parser->type_definition_forbidden_message = saved_message;
10473 : :
10474 : : /* At this point this can only be either a cast or a
10475 : : parenthesized ctor such as `(T ())' that looks like a cast to
10476 : : function returning T. */
10477 : 67269108 : if (!cp_parser_error_occurred (parser))
10478 : : {
10479 : : /* Only commit if the cast-expression doesn't start with
10480 : : '++', '--', or '[' in C++11. */
10481 : 8292600 : if (cast_expression > 0)
10482 : 7803449 : cp_parser_commit_to_topmost_tentative_parse (parser);
10483 : :
10484 : 8292600 : expr = cp_parser_cast_expression (parser,
10485 : : /*address_p=*/false,
10486 : : /*cast_p=*/true,
10487 : : /*decltype_p=*/false,
10488 : : pidk);
10489 : :
10490 : 8292600 : if (cp_parser_parse_definitely (parser))
10491 : : {
10492 : : /* Warn about old-style casts, if so requested. */
10493 : 8292592 : if (warn_old_style_cast
10494 : 30 : && !in_system_header_at (input_location)
10495 : 30 : && !VOID_TYPE_P (type)
10496 : 8292619 : && current_lang_name != lang_name_c)
10497 : : {
10498 : 27 : gcc_rich_location rich_loc (input_location);
10499 : 27 : maybe_add_cast_fixit (&rich_loc, open_paren_loc, close_paren_loc,
10500 : : expr, type);
10501 : 27 : warning_at (&rich_loc, OPT_Wold_style_cast,
10502 : : "use of old-style cast to %q#T", type);
10503 : 27 : }
10504 : :
10505 : : /* Only type conversions to integral or enumeration types
10506 : : can be used in constant-expressions. */
10507 : 8292592 : if (!cast_valid_in_integral_constant_expression_p (type)
10508 : 8292592 : && cp_parser_non_integral_constant_expression (parser,
10509 : : NIC_CAST))
10510 : 8292592 : return error_mark_node;
10511 : :
10512 : : /* Perform the cast. */
10513 : : /* Make a location:
10514 : : (TYPE) EXPR
10515 : : ^~~~~~~~~~~
10516 : : with start==caret at the open paren, extending to the
10517 : : end of "expr". */
10518 : 8292580 : location_t cast_loc = make_location (open_paren_loc,
10519 : : open_paren_loc,
10520 : : expr.get_finish ());
10521 : 8292580 : expr = build_c_cast (cast_loc, type, expr);
10522 : 8292580 : return expr;
10523 : : }
10524 : : }
10525 : : else
10526 : 25341954 : cp_parser_abort_tentative_parse (parser);
10527 : : }
10528 : :
10529 : : /* If we get here, then it's not a cast, so it must be a
10530 : : unary-expression. */
10531 : 933299566 : return cp_parser_unary_expression (parser, pidk, address_p,
10532 : 933299545 : cast_p, decltype_p);
10533 : : }
10534 : :
10535 : : /* Parse a binary expression of the general form:
10536 : :
10537 : : pm-expression:
10538 : : cast-expression
10539 : : pm-expression .* cast-expression
10540 : : pm-expression ->* cast-expression
10541 : :
10542 : : multiplicative-expression:
10543 : : pm-expression
10544 : : multiplicative-expression * pm-expression
10545 : : multiplicative-expression / pm-expression
10546 : : multiplicative-expression % pm-expression
10547 : :
10548 : : additive-expression:
10549 : : multiplicative-expression
10550 : : additive-expression + multiplicative-expression
10551 : : additive-expression - multiplicative-expression
10552 : :
10553 : : shift-expression:
10554 : : additive-expression
10555 : : shift-expression << additive-expression
10556 : : shift-expression >> additive-expression
10557 : :
10558 : : relational-expression:
10559 : : shift-expression
10560 : : relational-expression < shift-expression
10561 : : relational-expression > shift-expression
10562 : : relational-expression <= shift-expression
10563 : : relational-expression >= shift-expression
10564 : :
10565 : : GNU Extension:
10566 : :
10567 : : relational-expression:
10568 : : relational-expression <? shift-expression
10569 : : relational-expression >? shift-expression
10570 : :
10571 : : equality-expression:
10572 : : relational-expression
10573 : : equality-expression == relational-expression
10574 : : equality-expression != relational-expression
10575 : :
10576 : : and-expression:
10577 : : equality-expression
10578 : : and-expression & equality-expression
10579 : :
10580 : : exclusive-or-expression:
10581 : : and-expression
10582 : : exclusive-or-expression ^ and-expression
10583 : :
10584 : : inclusive-or-expression:
10585 : : exclusive-or-expression
10586 : : inclusive-or-expression | exclusive-or-expression
10587 : :
10588 : : logical-and-expression:
10589 : : inclusive-or-expression
10590 : : logical-and-expression && inclusive-or-expression
10591 : :
10592 : : logical-or-expression:
10593 : : logical-and-expression
10594 : : logical-or-expression || logical-and-expression
10595 : :
10596 : : All these are implemented with a single function like:
10597 : :
10598 : : binary-expression:
10599 : : simple-cast-expression
10600 : : binary-expression <token> binary-expression
10601 : :
10602 : : CAST_P is true if this expression is the target of a cast.
10603 : :
10604 : : The binops_by_token map is used to get the tree codes for each <token> type.
10605 : : binary-expressions are associated according to a precedence table. */
10606 : :
10607 : : #define TOKEN_PRECEDENCE(token) \
10608 : : (((token->type == CPP_GREATER \
10609 : : || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
10610 : : && !parser->greater_than_is_operator_p) \
10611 : : ? PREC_NOT_OPERATOR \
10612 : : : binops_by_token[token->type].prec)
10613 : :
10614 : : static cp_expr
10615 : 754125124 : cp_parser_binary_expression (cp_parser* parser, bool cast_p,
10616 : : bool no_toplevel_fold_p,
10617 : : bool decltype_p,
10618 : : enum cp_parser_prec prec,
10619 : : cp_id_kind * pidk)
10620 : : {
10621 : 9803626612 : cp_parser_expression_stack stack;
10622 : 754125124 : cp_parser_expression_stack_entry *sp = &stack[0];
10623 : 754125124 : cp_parser_expression_stack_entry *disable_warnings_sp = NULL;
10624 : 754125124 : cp_parser_expression_stack_entry current;
10625 : 754125124 : cp_expr rhs;
10626 : 754125124 : cp_token *token;
10627 : 754125124 : enum tree_code rhs_type;
10628 : 754125124 : enum cp_parser_prec new_prec, lookahead_prec;
10629 : 754125124 : tree overload;
10630 : :
10631 : : /* Parse the first expression. */
10632 : 1508250248 : current.lhs_type = (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
10633 : 754125124 : ? TRUTH_NOT_EXPR : ERROR_MARK);
10634 : 754125124 : current.lhs = cp_parser_cast_expression (parser, /*address_p=*/false,
10635 : : cast_p, decltype_p, pidk);
10636 : 754125103 : current.prec = prec;
10637 : :
10638 : 1626300751 : if (cp_parser_error_occurred (parser))
10639 : 486 : return error_mark_node;
10640 : :
10641 : 872175162 : for (;;)
10642 : : {
10643 : : /* Get an operator token. */
10644 : 872175162 : token = cp_lexer_peek_token (parser->lexer);
10645 : :
10646 : 872175162 : if (warn_cxx11_compat
10647 : 804098 : && token->type == CPP_RSHIFT
10648 : 2482 : && !parser->greater_than_is_operator_p)
10649 : : {
10650 : 2 : auto_diagnostic_group d;
10651 : 2 : if (warning_at (token->location, OPT_Wc__11_compat,
10652 : : "%<>>%> operator is treated"
10653 : : " as two right angle brackets in C++11"))
10654 : 2 : inform (token->location,
10655 : : "suggest parentheses around %<>>%> expression");
10656 : 2 : }
10657 : :
10658 : 872175162 : new_prec = TOKEN_PRECEDENCE (token);
10659 : 856191545 : if (new_prec != PREC_NOT_OPERATOR
10660 : 856191545 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
10661 : : /* This is a fold-expression; handle it later. */
10662 : : new_prec = PREC_NOT_OPERATOR;
10663 : :
10664 : : /* Popping an entry off the stack means we completed a subexpression:
10665 : : - either we found a token which is not an operator (`>' where it is not
10666 : : an operator, or prec == PREC_NOT_OPERATOR), in which case popping
10667 : : will happen repeatedly;
10668 : : - or, we found an operator which has lower priority. This is the case
10669 : : where the recursive descent *ascends*, as in `3 * 4 + 5' after
10670 : : parsing `3 * 4'. */
10671 : 872175162 : if (new_prec <= current.prec)
10672 : : {
10673 : 764024744 : if (sp == stack)
10674 : : break;
10675 : : else
10676 : 9900130 : goto pop;
10677 : : }
10678 : :
10679 : 108150418 : get_rhs:
10680 : 118050548 : current.tree_type = binops_by_token[token->type].tree_type;
10681 : 118050548 : current.loc = token->location;
10682 : 118050548 : current.flags = token->flags;
10683 : :
10684 : : /* We used the operator token. */
10685 : 118050548 : cp_lexer_consume_token (parser->lexer);
10686 : :
10687 : : /* For "false && x" or "true || x", x will never be executed;
10688 : : disable warnings while evaluating it. */
10689 : 118050548 : if ((current.tree_type == TRUTH_ANDIF_EXPR
10690 : 11727416 : && cp_fully_fold (current.lhs) == truthvalue_false_node)
10691 : 129777585 : || (current.tree_type == TRUTH_ORIF_EXPR
10692 : 3418017 : && cp_fully_fold (current.lhs) == truthvalue_true_node))
10693 : : {
10694 : 1650 : disable_warnings_sp = sp;
10695 : 1650 : ++c_inhibit_evaluation_warnings;
10696 : : }
10697 : :
10698 : : /* Extract another operand. It may be the RHS of this expression
10699 : : or the LHS of a new, higher priority expression. */
10700 : 236101096 : rhs_type = (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
10701 : 118050548 : ? TRUTH_NOT_EXPR : ERROR_MARK);
10702 : 118050548 : rhs = cp_parser_simple_cast_expression (parser);
10703 : :
10704 : : /* Get another operator token. Look up its precedence to avoid
10705 : : building a useless (immediately popped) stack entry for common
10706 : : cases such as 3 + 4 + 5 or 3 * 4 + 5. */
10707 : 118050548 : token = cp_lexer_peek_token (parser->lexer);
10708 : 118050548 : lookahead_prec = TOKEN_PRECEDENCE (token);
10709 : 117449341 : if (lookahead_prec != PREC_NOT_OPERATOR
10710 : 117449341 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
10711 : : lookahead_prec = PREC_NOT_OPERATOR;
10712 : 118050548 : if (lookahead_prec > new_prec)
10713 : : {
10714 : : /* ... and prepare to parse the RHS of the new, higher priority
10715 : : expression. Since precedence levels on the stack are
10716 : : monotonically increasing, we do not have to care about
10717 : : stack overflows. */
10718 : 9900130 : *sp = current;
10719 : 9900130 : ++sp;
10720 : 9900130 : current.lhs = rhs;
10721 : 9900130 : current.lhs_type = rhs_type;
10722 : 9900130 : current.prec = new_prec;
10723 : 9900130 : new_prec = lookahead_prec;
10724 : 9900130 : goto get_rhs;
10725 : :
10726 : 9900130 : pop:
10727 : 9900130 : lookahead_prec = new_prec;
10728 : : /* If the stack is not empty, we have parsed into LHS the right side
10729 : : (`4' in the example above) of an expression we had suspended.
10730 : : We can use the information on the stack to recover the LHS (`3')
10731 : : from the stack together with the tree code (`MULT_EXPR'), and
10732 : : the precedence of the higher level subexpression
10733 : : (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
10734 : : which will be used to actually build the additive expression. */
10735 : 9900130 : rhs = current.lhs;
10736 : 9900130 : rhs_type = current.lhs_type;
10737 : 9900130 : --sp;
10738 : 9900130 : current = *sp;
10739 : : }
10740 : :
10741 : : /* Undo the disabling of warnings done above. */
10742 : 118050548 : if (sp == disable_warnings_sp)
10743 : : {
10744 : 1650 : disable_warnings_sp = NULL;
10745 : 1650 : --c_inhibit_evaluation_warnings;
10746 : : }
10747 : :
10748 : 118050548 : if (warn_logical_not_paren
10749 : 1228551 : && TREE_CODE_CLASS (current.tree_type) == tcc_comparison
10750 : 481299 : && current.lhs_type == TRUTH_NOT_EXPR
10751 : : /* Avoid warning for !!x == y. */
10752 : 405 : && (TREE_CODE (current.lhs) != NE_EXPR
10753 : 45 : || !integer_zerop (TREE_OPERAND (current.lhs, 1)))
10754 : 360 : && (TREE_CODE (current.lhs) != TRUTH_NOT_EXPR
10755 : 72 : || (TREE_CODE (TREE_OPERAND (current.lhs, 0)) != TRUTH_NOT_EXPR
10756 : : /* Avoid warning for !b == y where b is boolean. */
10757 : 66 : && (TREE_TYPE (TREE_OPERAND (current.lhs, 0)) == NULL_TREE
10758 : 63 : || (TREE_CODE (TREE_TYPE (TREE_OPERAND (current.lhs, 0)))
10759 : : != BOOLEAN_TYPE))))
10760 : : /* Avoid warning for !!b == y where b is boolean. */
10761 : 118050845 : && (!(DECL_P (tree_strip_any_location_wrapper (current.lhs))
10762 : 297 : || (TREE_CODE (current.lhs) == NON_LVALUE_EXPR
10763 : 18 : && DECL_P (tree_strip_any_location_wrapper
10764 : : (TREE_OPERAND (current.lhs, 0)))))
10765 : 18 : || TREE_TYPE (current.lhs) == NULL_TREE
10766 : 18 : || TREE_CODE (TREE_TYPE (current.lhs)) != BOOLEAN_TYPE))
10767 : 279 : warn_logical_not_parentheses (current.loc, current.tree_type,
10768 : : current.lhs, maybe_constant_value (rhs));
10769 : :
10770 : 118050548 : if (warn_xor_used_as_pow
10771 : 118050548 : && current.tree_type == BIT_XOR_EXPR
10772 : : /* Don't warn for named "xor" (as opposed to '^'). */
10773 : 493907 : && !(current.flags & NAMED_OP)
10774 : 493895 : && current.lhs.decimal_p ()
10775 : 118050976 : && rhs.decimal_p ())
10776 : 203 : check_for_xor_used_as_pow
10777 : 203 : (current.lhs.get_location (),
10778 : : tree_strip_any_location_wrapper (current.lhs),
10779 : : current.loc,
10780 : : rhs.get_location (),
10781 : : tree_strip_any_location_wrapper (rhs));
10782 : :
10783 : 118050548 : overload = NULL;
10784 : :
10785 : 118050548 : location_t combined_loc = make_location (current.loc,
10786 : : current.lhs.get_start (),
10787 : : rhs.get_finish ());
10788 : :
10789 : : /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
10790 : : ERROR_MARK for everything that is not a binary expression.
10791 : : This makes warn_about_parentheses miss some warnings that
10792 : : involve unary operators. For unary expressions we should
10793 : : pass the correct tree_code unless the unary expression was
10794 : : surrounded by parentheses.
10795 : : */
10796 : 118050548 : if (no_toplevel_fold_p
10797 : 744832 : && lookahead_prec <= current.prec
10798 : 382835 : && sp == stack)
10799 : : {
10800 : 378339 : if (current.lhs == error_mark_node || rhs == error_mark_node)
10801 : 10 : current.lhs = error_mark_node;
10802 : : else
10803 : : {
10804 : 378329 : current.lhs.maybe_add_location_wrapper ();
10805 : 378329 : rhs.maybe_add_location_wrapper ();
10806 : 378329 : current.lhs
10807 : 378329 : = build_min (current.tree_type,
10808 : 378329 : TREE_CODE_CLASS (current.tree_type)
10809 : : == tcc_comparison
10810 : 353058 : ? boolean_type_node : TREE_TYPE (current.lhs),
10811 : 731387 : current.lhs.get_value (), rhs.get_value ());
10812 : 378329 : SET_EXPR_LOCATION (current.lhs, combined_loc);
10813 : : }
10814 : : }
10815 : : else
10816 : : {
10817 : 117672209 : op_location_t op_loc (current.loc, combined_loc);
10818 : 117672209 : current.lhs = build_x_binary_op (op_loc, current.tree_type,
10819 : : current.lhs, current.lhs_type,
10820 : : rhs, rhs_type, NULL_TREE, &overload,
10821 : 117672209 : complain_flags (decltype_p));
10822 : : /* TODO: build_x_binary_op doesn't always honor the location. */
10823 : 117672206 : current.lhs.set_location (combined_loc);
10824 : : }
10825 : 118050545 : current.lhs_type = current.tree_type;
10826 : :
10827 : : /* If the binary operator required the use of an overloaded operator,
10828 : : then this expression cannot be an integral constant-expression.
10829 : : An overloaded operator can be used even if both operands are
10830 : : otherwise permissible in an integral constant-expression if at
10831 : : least one of the operands is of enumeration type. */
10832 : :
10833 : 118050545 : if (overload
10834 : 118050545 : && cp_parser_non_integral_constant_expression (parser,
10835 : : NIC_OVERLOADED))
10836 : 0 : return error_mark_node;
10837 : : }
10838 : :
10839 : 754124614 : return current.lhs;
10840 : : }
10841 : :
10842 : : static cp_expr
10843 : 683330 : cp_parser_binary_expression (cp_parser* parser, bool cast_p,
10844 : : bool no_toplevel_fold_p,
10845 : : enum cp_parser_prec prec,
10846 : : cp_id_kind * pidk)
10847 : : {
10848 : 0 : return cp_parser_binary_expression (parser, cast_p, no_toplevel_fold_p,
10849 : 0 : /*decltype*/false, prec, pidk);
10850 : : }
10851 : :
10852 : : /* Parse the `? expression : assignment-expression' part of a
10853 : : conditional-expression. The LOGICAL_OR_EXPR is the
10854 : : logical-or-expression that started the conditional-expression.
10855 : : Returns a representation of the entire conditional-expression.
10856 : :
10857 : : This routine is used by cp_parser_assignment_expression
10858 : : and cp_parser_conditional_expression.
10859 : :
10860 : : ? expression : assignment-expression
10861 : :
10862 : : GNU Extensions:
10863 : :
10864 : : ? : assignment-expression */
10865 : :
10866 : : static tree
10867 : 3705419 : cp_parser_question_colon_clause (cp_parser* parser, cp_expr logical_or_expr)
10868 : : {
10869 : 3705419 : tree expr, folded_logical_or_expr = cp_fully_fold (logical_or_expr);
10870 : 3705419 : cp_expr assignment_expr;
10871 : 3705419 : struct cp_token *token;
10872 : 3705419 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
10873 : :
10874 : : /* Consume the `?' token. */
10875 : 3705419 : cp_lexer_consume_token (parser->lexer);
10876 : 3705419 : token = cp_lexer_peek_token (parser->lexer);
10877 : 3705419 : if (cp_parser_allow_gnu_extensions_p (parser)
10878 : 3705419 : && token->type == CPP_COLON)
10879 : : {
10880 : 309 : pedwarn (token->location, OPT_Wpedantic,
10881 : : "ISO C++ does not allow %<?:%> with omitted middle operand");
10882 : : /* Implicit true clause. */
10883 : 309 : expr = NULL_TREE;
10884 : 309 : c_inhibit_evaluation_warnings +=
10885 : 309 : folded_logical_or_expr == truthvalue_true_node;
10886 : 309 : warn_for_omitted_condop (token->location, logical_or_expr);
10887 : : }
10888 : : else
10889 : : {
10890 : 3705110 : bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
10891 : 3705110 : parser->colon_corrects_to_scope_p = false;
10892 : : /* Parse the expression. */
10893 : 3705110 : c_inhibit_evaluation_warnings +=
10894 : 3705110 : folded_logical_or_expr == truthvalue_false_node;
10895 : 3705110 : expr = cp_parser_expression (parser);
10896 : 3705110 : c_inhibit_evaluation_warnings +=
10897 : 3705110 : ((folded_logical_or_expr == truthvalue_true_node)
10898 : 3705110 : - (folded_logical_or_expr == truthvalue_false_node));
10899 : 3705110 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
10900 : : }
10901 : :
10902 : : /* The next token should be a `:'. */
10903 : 3705419 : cp_parser_require (parser, CPP_COLON, RT_COLON);
10904 : : /* Parse the assignment-expression. */
10905 : 3705419 : assignment_expr = cp_parser_assignment_expression (parser);
10906 : 3705419 : c_inhibit_evaluation_warnings -=
10907 : 3705419 : folded_logical_or_expr == truthvalue_true_node;
10908 : :
10909 : : /* Make a location:
10910 : : LOGICAL_OR_EXPR ? EXPR : ASSIGNMENT_EXPR
10911 : : ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
10912 : : with the caret at the "?", ranging from the start of
10913 : : the logical_or_expr to the end of the assignment_expr. */
10914 : 3705419 : loc = make_location (loc,
10915 : : logical_or_expr.get_start (),
10916 : : assignment_expr.get_finish ());
10917 : :
10918 : : /* Build the conditional-expression. */
10919 : 3705419 : return build_x_conditional_expr (loc, logical_or_expr,
10920 : : expr,
10921 : : assignment_expr,
10922 : 3705419 : tf_warning_or_error);
10923 : : }
10924 : :
10925 : : /* Parse a conditional-expression.
10926 : :
10927 : : conditional-expression:
10928 : : logical-or-expression
10929 : : logical-or-expression ? expression : assignment-expression
10930 : :
10931 : : GNU Extensions:
10932 : :
10933 : : logical-or-expression ? : assignment-expression */
10934 : :
10935 : : static cp_expr
10936 : 370757 : cp_parser_conditional_expression (cp_parser *parser)
10937 : : {
10938 : 370757 : cp_expr expr = cp_parser_binary_expression (parser, false, false, false,
10939 : : PREC_NOT_OPERATOR, NULL);
10940 : : /* If the next token is a `?' then we're actually looking at
10941 : : a conditional-expression; otherwise we're done. */
10942 : 370757 : if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
10943 : 38 : return cp_parser_question_colon_clause (parser, expr);
10944 : 370719 : return expr;
10945 : : }
10946 : :
10947 : : /* Parse an assignment-expression.
10948 : :
10949 : : assignment-expression:
10950 : : conditional-expression
10951 : : logical-or-expression assignment-operator assignment_expression
10952 : : throw-expression
10953 : : yield-expression
10954 : :
10955 : : CAST_P is true if this expression is the target of a cast.
10956 : : DECLTYPE_P is true if this expression is the operand of decltype.
10957 : :
10958 : : Returns a representation for the expression. */
10959 : :
10960 : : static cp_expr
10961 : 754098492 : cp_parser_assignment_expression (cp_parser* parser, cp_id_kind * pidk,
10962 : : bool cast_p, bool decltype_p)
10963 : : {
10964 : 754098492 : cp_expr expr;
10965 : :
10966 : : /* If the next token is the `throw' keyword, then we're looking at
10967 : : a throw-expression. */
10968 : 754098492 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW))
10969 : 1026402 : expr = cp_parser_throw_expression (parser);
10970 : : /* If the next token is the `co_yield' keyword, then we're looking at
10971 : : a yield-expression. */
10972 : 753072090 : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CO_YIELD))
10973 : 1499 : expr = cp_parser_yield_expression (parser);
10974 : : /* Otherwise, it must be that we are looking at a
10975 : : logical-or-expression. */
10976 : : else
10977 : : {
10978 : : /* Parse the binary expressions (logical-or-expression). */
10979 : 753070591 : expr = cp_parser_binary_expression (parser, cast_p, false,
10980 : : decltype_p,
10981 : : PREC_NOT_OPERATOR, pidk);
10982 : : /* If the next token is a `?' then we're actually looking at a
10983 : : conditional-expression. */
10984 : 753070567 : if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
10985 : 3705381 : return cp_parser_question_colon_clause (parser, expr);
10986 : : else
10987 : : {
10988 : 749365186 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
10989 : :
10990 : : /* If it's an assignment-operator, we're using the second
10991 : : production. */
10992 : 749365186 : enum tree_code assignment_operator
10993 : 749365186 : = cp_parser_assignment_operator_opt (parser);
10994 : 749365186 : if (assignment_operator != ERROR_MARK)
10995 : : {
10996 : : /* Parse the right-hand side of the assignment. */
10997 : 40497190 : cp_expr rhs = cp_parser_initializer_clause (parser);
10998 : :
10999 : 40497190 : if (BRACE_ENCLOSED_INITIALIZER_P (rhs))
11000 : 66311 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
11001 : :
11002 : : /* An assignment may not appear in a
11003 : : constant-expression. */
11004 : 40497190 : if (cp_parser_non_integral_constant_expression (parser,
11005 : : NIC_ASSIGNMENT))
11006 : 1 : return error_mark_node;
11007 : : /* Build the assignment expression. Its default
11008 : : location:
11009 : : LHS = RHS
11010 : : ~~~~^~~~~
11011 : : is the location of the '=' token as the
11012 : : caret, ranging from the start of the lhs to the
11013 : : end of the rhs. */
11014 : 40497189 : loc = make_location (loc,
11015 : : expr.get_start (),
11016 : : rhs.get_finish ());
11017 : 40497576 : expr = build_x_modify_expr (loc, expr,
11018 : : assignment_operator,
11019 : : rhs, NULL_TREE,
11020 : : complain_flags (decltype_p));
11021 : : /* TODO: build_x_modify_expr doesn't honor the location,
11022 : : so we must set it here. */
11023 : 40497189 : expr.set_location (loc);
11024 : : }
11025 : : }
11026 : : }
11027 : :
11028 : 750393086 : return expr;
11029 : : }
11030 : :
11031 : : /* Parse an (optional) assignment-operator.
11032 : :
11033 : : assignment-operator: one of
11034 : : = *= /= %= += -= >>= <<= &= ^= |=
11035 : :
11036 : : GNU Extension:
11037 : :
11038 : : assignment-operator: one of
11039 : : <?= >?=
11040 : :
11041 : : If the next token is an assignment operator, the corresponding tree
11042 : : code is returned, and the token is consumed. For example, for
11043 : : `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
11044 : : NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
11045 : : TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
11046 : : operator, ERROR_MARK is returned. */
11047 : :
11048 : : static enum tree_code
11049 : 749365758 : cp_parser_assignment_operator_opt (cp_parser* parser)
11050 : : {
11051 : 749365758 : enum tree_code op;
11052 : 749365758 : cp_token *token;
11053 : :
11054 : : /* Peek at the next token. */
11055 : 749365758 : token = cp_lexer_peek_token (parser->lexer);
11056 : :
11057 : 749365758 : switch (token->type)
11058 : : {
11059 : : case CPP_EQ:
11060 : : op = NOP_EXPR;
11061 : : break;
11062 : :
11063 : 1029287 : case CPP_MULT_EQ:
11064 : 1029287 : op = MULT_EXPR;
11065 : 1029287 : break;
11066 : :
11067 : 608978 : case CPP_DIV_EQ:
11068 : 608978 : op = TRUNC_DIV_EXPR;
11069 : 608978 : break;
11070 : :
11071 : 170409 : case CPP_MOD_EQ:
11072 : 170409 : op = TRUNC_MOD_EXPR;
11073 : 170409 : break;
11074 : :
11075 : 2837102 : case CPP_PLUS_EQ:
11076 : 2837102 : op = PLUS_EXPR;
11077 : 2837102 : break;
11078 : :
11079 : 829862 : case CPP_MINUS_EQ:
11080 : 829862 : op = MINUS_EXPR;
11081 : 829862 : break;
11082 : :
11083 : 281942 : case CPP_RSHIFT_EQ:
11084 : 281942 : op = RSHIFT_EXPR;
11085 : 281942 : break;
11086 : :
11087 : 146849 : case CPP_LSHIFT_EQ:
11088 : 146849 : op = LSHIFT_EXPR;
11089 : 146849 : break;
11090 : :
11091 : 297351 : case CPP_AND_EQ:
11092 : 297351 : op = BIT_AND_EXPR;
11093 : 297351 : break;
11094 : :
11095 : 267785 : case CPP_XOR_EQ:
11096 : 267785 : op = BIT_XOR_EXPR;
11097 : 267785 : break;
11098 : :
11099 : 1349806 : case CPP_OR_EQ:
11100 : 1349806 : op = BIT_IOR_EXPR;
11101 : 1349806 : break;
11102 : :
11103 : : default:
11104 : : /* Nothing else is an assignment operator. */
11105 : : op = ERROR_MARK;
11106 : : }
11107 : :
11108 : : /* An operator followed by ... is a fold-expression, handled elsewhere. */
11109 : 7819371 : if (op != ERROR_MARK
11110 : 40498023 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
11111 : : op = ERROR_MARK;
11112 : :
11113 : : /* If it was an assignment operator, consume it. */
11114 : 749365497 : if (op != ERROR_MARK)
11115 : 40497762 : cp_lexer_consume_token (parser->lexer);
11116 : :
11117 : 749365758 : return op;
11118 : : }
11119 : :
11120 : : /* Parse an expression.
11121 : :
11122 : : expression:
11123 : : assignment-expression
11124 : : expression , assignment-expression
11125 : :
11126 : : CAST_P is true if this expression is the target of a cast.
11127 : : DECLTYPE_P is true if this expression is the immediate operand of decltype,
11128 : : except possibly parenthesized or on the RHS of a comma (N3276).
11129 : : WARN_COMMA_P is true if a comma should be diagnosed.
11130 : :
11131 : : Returns a representation of the expression. */
11132 : :
11133 : : static cp_expr
11134 : 275931582 : cp_parser_expression (cp_parser* parser, cp_id_kind * pidk,
11135 : : bool cast_p, bool decltype_p, bool warn_comma_p)
11136 : : {
11137 : 275931582 : cp_expr expression = NULL_TREE;
11138 : 275931582 : location_t loc = UNKNOWN_LOCATION;
11139 : :
11140 : 280714870 : while (true)
11141 : : {
11142 : 278323226 : cp_expr assignment_expression;
11143 : :
11144 : : /* Parse the next assignment-expression. */
11145 : 278323226 : if (cp_lexer_next_token_is (parser->lexer, CPP_EMBED))
11146 : : {
11147 : : /* Users aren't interested in milions of -Wunused-value
11148 : : warnings when using #embed inside of a comma expression,
11149 : : and one CPP_NUMBER plus CPP_COMMA before it and one
11150 : : CPP_COMMA plus CPP_NUMBER after it is guaranteed by
11151 : : the preprocessor. Thus, parse the whole CPP_EMBED just
11152 : : as a single INTEGER_CST, the last byte in it. */
11153 : 3 : tree raw_data = cp_lexer_peek_token (parser->lexer)->u.value;
11154 : 3 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
11155 : 3 : cp_lexer_consume_token (parser->lexer);
11156 : 3 : assignment_expression
11157 : 3 : = *raw_data_iterator (raw_data, RAW_DATA_LENGTH (raw_data) - 1);
11158 : 3 : assignment_expression.set_location (loc);
11159 : : }
11160 : : else
11161 : 278323223 : assignment_expression
11162 : 278323223 : = cp_parser_assignment_expression (parser, pidk, cast_p, decltype_p);
11163 : :
11164 : : /* We don't create a temporary for a call that is the immediate operand
11165 : : of decltype or on the RHS of a comma. But when we see a comma, we
11166 : : need to create a temporary for a call on the LHS. */
11167 : 2708895 : if (decltype_p && !processing_template_decl
11168 : 118334 : && TREE_CODE (assignment_expression) == CALL_EXPR
11169 : 3200 : && CLASS_TYPE_P (TREE_TYPE (assignment_expression))
11170 : 278323857 : && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
11171 : 6 : assignment_expression
11172 : 6 : = build_cplus_new (TREE_TYPE (assignment_expression),
11173 : 6 : assignment_expression, tf_warning_or_error);
11174 : :
11175 : : /* If this is the first assignment-expression, we can just
11176 : : save it away. */
11177 : 278323208 : if (!expression)
11178 : 275931564 : expression = assignment_expression;
11179 : : else
11180 : : {
11181 : : /* Create a location with caret at the comma, ranging
11182 : : from the start of the LHS to the end of the RHS. */
11183 : 2391644 : loc = make_location (loc,
11184 : : expression.get_start (),
11185 : : assignment_expression.get_finish ());
11186 : 2391644 : expression = build_x_compound_expr (loc, expression,
11187 : : assignment_expression, NULL_TREE,
11188 : 2391644 : complain_flags (decltype_p));
11189 : 2391644 : expression.set_location (loc);
11190 : : }
11191 : : /* If the next token is not a comma, or we're in a fold-expression, then
11192 : : we are done with the expression. */
11193 : 278323208 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
11194 : 278323208 : || cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
11195 : : break;
11196 : : /* Consume the `,'. */
11197 : 2391644 : loc = cp_lexer_peek_token (parser->lexer)->location;
11198 : 2391644 : if (warn_comma_p)
11199 : : {
11200 : : /* [depr.comma.subscript]: A comma expression appearing as
11201 : : the expr-or-braced-init-list of a subscripting expression
11202 : : is deprecated. A parenthesized comma expression is not
11203 : : deprecated. */
11204 : 38 : warning_at (loc, OPT_Wcomma_subscript,
11205 : : "top-level comma expression in array subscript "
11206 : : "is deprecated");
11207 : 38 : warn_comma_p = false;
11208 : : }
11209 : 2391644 : cp_lexer_consume_token (parser->lexer);
11210 : : /* A comma operator cannot appear in a constant-expression. */
11211 : 2391644 : if (cp_parser_non_integral_constant_expression (parser, NIC_COMMA))
11212 : 2 : expression = error_mark_node;
11213 : 2391644 : }
11214 : :
11215 : 275931564 : return expression;
11216 : : }
11217 : :
11218 : : /* Parse a constant-expression.
11219 : :
11220 : : constant-expression:
11221 : : conditional-expression
11222 : :
11223 : : If ALLOW_NON_CONSTANT_P a non-constant expression is silently
11224 : : accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
11225 : : constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
11226 : : is false, NON_CONSTANT_P should be NULL. If ALLOW_NON_CONSTANT_P is
11227 : : greater than 1, this isn't really a constant-expression, only a
11228 : : potentially constant-evaluated expression. If STRICT_P is true,
11229 : : only parse a conditional-expression, otherwise parse an
11230 : : assignment-expression. See below for rationale. */
11231 : :
11232 : : static cp_expr
11233 : 164924338 : cp_parser_constant_expression (cp_parser* parser,
11234 : : int allow_non_constant_p /* = 0 */,
11235 : : bool *non_constant_p /* = NULL */,
11236 : : bool strict_p /* = false */)
11237 : : {
11238 : : /* It might seem that we could simply parse the
11239 : : conditional-expression, and then check to see if it were
11240 : : TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
11241 : : one that the compiler can figure out is constant, possibly after
11242 : : doing some simplifications or optimizations. The standard has a
11243 : : precise definition of constant-expression, and we must honor
11244 : : that, even though it is somewhat more restrictive.
11245 : :
11246 : : For example:
11247 : :
11248 : : int i[(2, 3)];
11249 : :
11250 : : is not a legal declaration, because `(2, 3)' is not a
11251 : : constant-expression. The `,' operator is forbidden in a
11252 : : constant-expression. However, GCC's constant-folding machinery
11253 : : will fold this operation to an INTEGER_CST for `3'. */
11254 : :
11255 : : /* Save the old settings. */
11256 : 164924338 : bool saved_integral_constant_expression_p
11257 : : = parser->integral_constant_expression_p;
11258 : 164924338 : bool saved_allow_non_integral_constant_expression_p
11259 : : = parser->allow_non_integral_constant_expression_p;
11260 : 164924338 : bool saved_non_integral_constant_expression_p
11261 : : = parser->non_integral_constant_expression_p;
11262 : : /* We are now parsing a constant-expression. */
11263 : 164924338 : parser->integral_constant_expression_p = true;
11264 : 164924338 : parser->allow_non_integral_constant_expression_p
11265 : 164924338 : = (allow_non_constant_p || cxx_dialect >= cxx11);
11266 : 164924338 : parser->non_integral_constant_expression_p = false;
11267 : :
11268 : : /* A manifestly constant-evaluated expression is evaluated even in an
11269 : : unevaluated operand. */
11270 : 164924338 : cp_evaluated ev (/*reset if*/allow_non_constant_p <= 1);
11271 : :
11272 : : /* Although the grammar says "conditional-expression", when not STRICT_P,
11273 : : we parse an "assignment-expression", which also permits
11274 : : "throw-expression" and the use of assignment operators. In the case
11275 : : that ALLOW_NON_CONSTANT_P is false, we get better errors than we would
11276 : : otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
11277 : : actually essential that we look for an assignment-expression.
11278 : : For example, cp_parser_initializer_clauses uses this function to
11279 : : determine whether a particular assignment-expression is in fact
11280 : : constant. */
11281 : 164924338 : cp_expr expression;
11282 : 164924338 : if (strict_p)
11283 : 348448 : expression = cp_parser_conditional_expression (parser);
11284 : : else
11285 : 164575890 : expression = cp_parser_assignment_expression (parser);
11286 : : /* Restore the old settings. */
11287 : 164924332 : parser->integral_constant_expression_p
11288 : 164924332 : = saved_integral_constant_expression_p;
11289 : 164924332 : parser->allow_non_integral_constant_expression_p
11290 : 164924332 : = saved_allow_non_integral_constant_expression_p;
11291 : 164924332 : if (cxx_dialect >= cxx11
11292 : 164345993 : && (!allow_non_constant_p || non_constant_p))
11293 : : {
11294 : : /* Require an rvalue constant expression here; that's what our
11295 : : callers expect. Reference constant expressions are handled
11296 : : separately in e.g. cp_parser_template_argument. */
11297 : 94480299 : tree decay = expression;
11298 : 94480299 : if (TREE_TYPE (expression)
11299 : 94480299 : && TREE_CODE (TREE_TYPE (expression)) == ARRAY_TYPE)
11300 : 1527040 : decay = build_address (expression);
11301 : 94480299 : bool is_const = is_rvalue_constant_expression (decay);
11302 : 94480299 : parser->non_integral_constant_expression_p = !is_const;
11303 : 94480299 : if (!is_const && !allow_non_constant_p)
11304 : 216 : require_rvalue_constant_expression (decay);
11305 : : }
11306 : 164924332 : if (allow_non_constant_p && non_constant_p)
11307 : 88335183 : *non_constant_p = parser->non_integral_constant_expression_p;
11308 : 164924332 : parser->non_integral_constant_expression_p
11309 : 164924332 : = saved_non_integral_constant_expression_p;
11310 : :
11311 : 164924332 : return expression;
11312 : 164924332 : }
11313 : :
11314 : : /* Parse __builtin_offsetof.
11315 : :
11316 : : offsetof-expression:
11317 : : "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
11318 : :
11319 : : offsetof-member-designator:
11320 : : id-expression
11321 : : | offsetof-member-designator "." id-expression
11322 : : | offsetof-member-designator "[" expression "]"
11323 : : | offsetof-member-designator "->" id-expression */
11324 : :
11325 : : static cp_expr
11326 : 2333 : cp_parser_builtin_offsetof (cp_parser *parser)
11327 : : {
11328 : 2333 : int save_ice_p, save_non_ice_p;
11329 : 2333 : tree type;
11330 : 2333 : cp_expr expr;
11331 : 2333 : cp_id_kind dummy;
11332 : 2333 : cp_token *token;
11333 : 2333 : location_t finish_loc;
11334 : :
11335 : : /* We're about to accept non-integral-constant things, but will
11336 : : definitely yield an integral constant expression. Save and
11337 : : restore these values around our local parsing. */
11338 : 2333 : save_ice_p = parser->integral_constant_expression_p;
11339 : 2333 : save_non_ice_p = parser->non_integral_constant_expression_p;
11340 : :
11341 : 2333 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
11342 : :
11343 : : /* Consume the "__builtin_offsetof" token. */
11344 : 2333 : cp_lexer_consume_token (parser->lexer);
11345 : : /* Consume the opening `('. */
11346 : 2333 : matching_parens parens;
11347 : 2333 : parens.require_open (parser);
11348 : : /* Parse the type-id. */
11349 : 2333 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
11350 : 2333 : {
11351 : 2333 : const char *saved_message = parser->type_definition_forbidden_message;
11352 : 2333 : parser->type_definition_forbidden_message
11353 : 2333 : = G_("types may not be defined within %<__builtin_offsetof%>");
11354 : 2333 : type = cp_parser_type_id (parser);
11355 : 2333 : parser->type_definition_forbidden_message = saved_message;
11356 : : }
11357 : : /* Look for the `,'. */
11358 : 2333 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
11359 : 2333 : token = cp_lexer_peek_token (parser->lexer);
11360 : :
11361 : : /* Build the (type *)null that begins the traditional offsetof macro. */
11362 : 2333 : tree object_ptr
11363 : 2333 : = build_static_cast (input_location, build_pointer_type (type),
11364 : : null_pointer_node, tf_warning_or_error);
11365 : :
11366 : : /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
11367 : 2333 : expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DEREF, object_ptr,
11368 : 2333 : true, &dummy, token->location);
11369 : 3266 : while (true)
11370 : : {
11371 : 3266 : token = cp_lexer_peek_token (parser->lexer);
11372 : 3266 : switch (token->type)
11373 : : {
11374 : 687 : case CPP_OPEN_SQUARE:
11375 : : /* offsetof-member-designator "[" expression "]" */
11376 : 687 : expr = cp_parser_postfix_open_square_expression (parser, expr,
11377 : 687 : true, false);
11378 : 687 : break;
11379 : :
11380 : 9 : case CPP_DEREF:
11381 : : /* offsetof-member-designator "->" identifier */
11382 : 9 : expr = grok_array_decl (token->location, expr, integer_zero_node,
11383 : 9 : NULL, tf_warning_or_error);
11384 : : /* FALLTHRU */
11385 : :
11386 : 246 : case CPP_DOT:
11387 : : /* offsetof-member-designator "." identifier */
11388 : 246 : cp_lexer_consume_token (parser->lexer);
11389 : 492 : expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DOT,
11390 : : expr, true, &dummy,
11391 : 246 : token->location);
11392 : 246 : break;
11393 : :
11394 : 2333 : case CPP_CLOSE_PAREN:
11395 : : /* Consume the ")" token. */
11396 : 2333 : finish_loc = cp_lexer_peek_token (parser->lexer)->location;
11397 : 2333 : cp_lexer_consume_token (parser->lexer);
11398 : 2333 : goto success;
11399 : :
11400 : 0 : default:
11401 : : /* Error. We know the following require will fail, but
11402 : : that gives the proper error message. */
11403 : 0 : parens.require_close (parser);
11404 : 0 : cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
11405 : 0 : expr = error_mark_node;
11406 : 0 : goto failure;
11407 : : }
11408 : : }
11409 : :
11410 : 2333 : success:
11411 : : /* Make a location of the form:
11412 : : __builtin_offsetof (struct s, f)
11413 : : ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~
11414 : : with caret at the type-id, ranging from the start of the
11415 : : "_builtin_offsetof" token to the close paren. */
11416 : 2333 : loc = make_location (loc, start_loc, finish_loc);
11417 : : /* The result will be an INTEGER_CST, so we need to explicitly
11418 : : preserve the location. */
11419 : 2333 : expr = cp_expr (finish_offsetof (object_ptr, expr, loc), loc);
11420 : :
11421 : 2333 : failure:
11422 : 2333 : parser->integral_constant_expression_p = save_ice_p;
11423 : 2333 : parser->non_integral_constant_expression_p = save_non_ice_p;
11424 : :
11425 : 2333 : expr = expr.maybe_add_location_wrapper ();
11426 : 2333 : return expr;
11427 : : }
11428 : :
11429 : : /* Parse a builtin trait expression or type. */
11430 : :
11431 : : static cp_expr
11432 : 2361797 : cp_parser_trait (cp_parser* parser, const cp_trait* trait)
11433 : : {
11434 : 2361797 : const cp_trait_kind kind = trait->kind;
11435 : 2361797 : tree type1, type2 = NULL_TREE;
11436 : 2361797 : const bool binary = (trait->arity == 2);
11437 : 2361797 : const bool variadic = (trait->arity == -1);
11438 : 2361797 : const bool type = trait->type;
11439 : :
11440 : : /* Get location of initial token. */
11441 : 2361797 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
11442 : :
11443 : : /* Consume the token. */
11444 : 2361797 : cp_lexer_consume_token (parser->lexer);
11445 : :
11446 : 2361797 : matching_parens parens;
11447 : 2361797 : if (kind == CPTK_TYPE_PACK_ELEMENT)
11448 : 13221 : cp_parser_require (parser, CPP_LESS, RT_LESS);
11449 : : else
11450 : 2348576 : parens.require_open (parser);
11451 : :
11452 : 2361797 : if (kind == CPTK_IS_DEDUCIBLE)
11453 : : {
11454 : 0 : const cp_token* token = cp_lexer_peek_token (parser->lexer);
11455 : 0 : type1 = cp_parser_id_expression (parser,
11456 : : /*template_keyword_p=*/false,
11457 : : /*check_dependency_p=*/true,
11458 : : nullptr,
11459 : : /*declarator_p=*/false,
11460 : : /*optional_p=*/false);
11461 : 0 : type1 = cp_parser_lookup_name_simple (parser, type1, token->location);
11462 : : }
11463 : 2361797 : else if (kind == CPTK_TYPE_PACK_ELEMENT)
11464 : : /* __type_pack_element takes an expression as its first argument and uses
11465 : : template-id syntax instead of function call syntax (for consistency
11466 : : with Clang). We special case these properties of __type_pack_element
11467 : : here and elsewhere. */
11468 : 13221 : type1 = cp_parser_constant_expression (parser);
11469 : : else
11470 : : {
11471 : 2348576 : type_id_in_expr_sentinel s (parser);
11472 : 4697152 : type1 = cp_parser_type_id (parser);
11473 : 2348576 : }
11474 : :
11475 : 2361797 : if (type1 == error_mark_node)
11476 : 22 : return error_mark_node;
11477 : :
11478 : 2361775 : if (kind == CPTK_TYPE_PACK_ELEMENT)
11479 : : {
11480 : 13221 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
11481 : 13221 : tree trailing = cp_parser_enclosed_template_argument_list (parser);
11482 : 26469 : for (tree elt : tree_vec_range (trailing))
11483 : : {
11484 : 13248 : if (!TYPE_P (elt))
11485 : : {
11486 : 0 : error_at (cp_expr_loc_or_input_loc (elt),
11487 : : "trailing argument to %<__type_pack_element%> "
11488 : : "is not a type");
11489 : 0 : return error_mark_node;
11490 : : }
11491 : : }
11492 : 13221 : type2 = trailing;
11493 : : }
11494 : 2348554 : else if (binary)
11495 : : {
11496 : 756410 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
11497 : :
11498 : 756410 : {
11499 : 756410 : type_id_in_expr_sentinel s (parser);
11500 : 1512820 : type2 = cp_parser_type_id (parser);
11501 : 756410 : }
11502 : :
11503 : 756410 : if (type2 == error_mark_node)
11504 : 4 : return error_mark_node;
11505 : : }
11506 : 1592144 : else if (variadic)
11507 : : {
11508 : 270459 : auto_vec<tree, 4> trailing;
11509 : 500016 : while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
11510 : : {
11511 : 229557 : cp_lexer_consume_token (parser->lexer);
11512 : 459114 : tree elt = cp_parser_type_id (parser);
11513 : 229557 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
11514 : : {
11515 : 111737 : cp_lexer_consume_token (parser->lexer);
11516 : 111737 : elt = make_pack_expansion (elt);
11517 : : }
11518 : 229557 : if (elt == error_mark_node)
11519 : 0 : return error_mark_node;
11520 : 229557 : trailing.safe_push (elt);
11521 : : }
11522 : 270459 : type2 = make_tree_vec (trailing.length ());
11523 : 500016 : for (int i = 0; i < TREE_VEC_LENGTH (type2); ++i)
11524 : 229557 : TREE_VEC_ELT (type2, i) = trailing[i];
11525 : 270459 : }
11526 : :
11527 : 2361771 : location_t finish_loc = cp_lexer_peek_token (parser->lexer)->location;
11528 : 2361771 : if (kind == CPTK_TYPE_PACK_ELEMENT)
11529 : : /* cp_parser_enclosed_template_argument_list above already took care
11530 : : of parsing the closing '>'. */;
11531 : : else
11532 : 2348550 : parens.require_close (parser);
11533 : :
11534 : : /* Construct a location of the form:
11535 : : __is_trivially_copyable(_Tp)
11536 : : ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
11537 : : with start == caret, finishing at the close-paren. */
11538 : 2361771 : location_t trait_loc = make_location (start_loc, start_loc, finish_loc);
11539 : :
11540 : : /* Complete the trait expression, which may mean either processing
11541 : : the trait expr now or saving it for template instantiation. */
11542 : 2361771 : switch (kind)
11543 : : {
11544 : 14 : case CPTK_BASES:
11545 : 14 : return cp_expr (finish_bases (type1, false), trait_loc);
11546 : 14 : case CPTK_DIRECT_BASES:
11547 : 14 : return cp_expr (finish_bases (type1, true), trait_loc);
11548 : 2361743 : default:
11549 : 2361743 : if (type)
11550 : 156614 : return finish_trait_type (kind, type1, type2, tf_warning_or_error);
11551 : : else
11552 : 2205129 : return finish_trait_expr (trait_loc, kind, type1, type2);
11553 : : }
11554 : : }
11555 : :
11556 : : /* Parse a lambda expression.
11557 : :
11558 : : lambda-expression:
11559 : : lambda-introducer lambda-declarator [opt] compound-statement
11560 : : lambda-introducer < template-parameter-list > requires-clause [opt]
11561 : : lambda-declarator [opt] compound-statement
11562 : :
11563 : : Returns a representation of the expression. */
11564 : :
11565 : : static cp_expr
11566 : 598949 : cp_parser_lambda_expression (cp_parser* parser)
11567 : : {
11568 : 598949 : tree lambda_expr = build_lambda_expr ();
11569 : 598949 : tree type;
11570 : 598949 : bool ok = true;
11571 : 598949 : cp_token *token = cp_lexer_peek_token (parser->lexer);
11572 : 598949 : cp_token_position start = 0;
11573 : :
11574 : 598949 : LAMBDA_EXPR_LOCATION (lambda_expr) = token->location;
11575 : :
11576 : 598949 : if (cxx_dialect >= cxx20)
11577 : : {
11578 : : /* C++20 allows lambdas in unevaluated context, but one in the type of a
11579 : : non-type parameter is nonsensical.
11580 : :
11581 : : Distinguish a lambda in the parameter type from a lambda in the
11582 : : default argument by looking at local_variables_forbidden_p, which is
11583 : : only set in default arguments. */
11584 : 323856 : if (processing_template_parmlist && !parser->local_variables_forbidden_p)
11585 : : {
11586 : 3 : error_at (token->location,
11587 : : "lambda-expression in template parameter type");
11588 : 3 : token->error_reported = true;
11589 : 3 : ok = false;
11590 : : }
11591 : : }
11592 : 275093 : else if (cp_unevaluated_operand)
11593 : : {
11594 : 6 : if (!token->error_reported)
11595 : : {
11596 : 6 : error_at (LAMBDA_EXPR_LOCATION (lambda_expr),
11597 : : "lambda-expression in unevaluated context"
11598 : : " only available with %<-std=c++20%> or %<-std=gnu++20%>");
11599 : 6 : token->error_reported = true;
11600 : : }
11601 : : ok = false;
11602 : : }
11603 : 275087 : else if (parser->in_template_argument_list_p || processing_template_parmlist)
11604 : : {
11605 : 9 : if (!token->error_reported)
11606 : : {
11607 : 9 : error_at (token->location, "lambda-expression in template-argument"
11608 : : " only available with %<-std=c++20%> or %<-std=gnu++20%>");
11609 : 9 : token->error_reported = true;
11610 : : }
11611 : : ok = false;
11612 : : }
11613 : :
11614 : : /* We may be in the middle of deferred access check. Disable
11615 : : it now. */
11616 : 598949 : push_deferring_access_checks (dk_no_deferred);
11617 : :
11618 : 598949 : cp_parser_lambda_introducer (parser, lambda_expr);
11619 : 1197898 : if (cp_parser_error_occurred (parser))
11620 : 3 : return error_mark_node;
11621 : :
11622 : 598946 : type = begin_lambda_type (lambda_expr);
11623 : 598946 : if (type == error_mark_node)
11624 : 0 : return error_mark_node;
11625 : :
11626 : 598946 : record_lambda_scope (lambda_expr);
11627 : 598946 : record_lambda_scope_discriminator (lambda_expr);
11628 : :
11629 : : /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
11630 : 598946 : determine_visibility (TYPE_NAME (type));
11631 : :
11632 : : /* Now that we've started the type, add the capture fields for any
11633 : : explicit captures. */
11634 : 598946 : register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr));
11635 : :
11636 : 598946 : {
11637 : : /* Inside the class, surrounding template-parameter-lists do not apply. */
11638 : 598946 : unsigned int saved_num_template_parameter_lists
11639 : : = parser->num_template_parameter_lists;
11640 : 598946 : unsigned char in_statement = parser->in_statement;
11641 : 598946 : bool in_switch_statement_p = parser->in_switch_statement_p;
11642 : 598946 : bool fully_implicit_function_template_p
11643 : : = parser->fully_implicit_function_template_p;
11644 : 598946 : tree implicit_template_parms = parser->implicit_template_parms;
11645 : 598946 : cp_binding_level* implicit_template_scope = parser->implicit_template_scope;
11646 : 598946 : bool auto_is_implicit_function_template_parm_p
11647 : : = parser->auto_is_implicit_function_template_parm_p;
11648 : 598946 : bool saved_omp_array_section_p = parser->omp_array_section_p;
11649 : :
11650 : 598946 : parser->num_template_parameter_lists = 0;
11651 : 598946 : parser->in_statement = 0;
11652 : 598946 : parser->in_switch_statement_p = false;
11653 : 598946 : parser->fully_implicit_function_template_p = false;
11654 : 598946 : parser->implicit_template_parms = 0;
11655 : 598946 : parser->implicit_template_scope = 0;
11656 : 598946 : parser->auto_is_implicit_function_template_parm_p = false;
11657 : 598946 : parser->omp_array_section_p = false;
11658 : :
11659 : : /* The body of a lambda in a discarded statement is not discarded. */
11660 : 598946 : bool discarded = in_discarded_stmt;
11661 : 598946 : in_discarded_stmt = 0;
11662 : :
11663 : : /* Similarly the body of a lambda in immediate function context is not
11664 : : in immediate function context. */
11665 : 598946 : bool save_in_consteval_if_p = in_consteval_if_p;
11666 : 598946 : in_consteval_if_p = false;
11667 : :
11668 : : /* By virtue of defining a local class, a lambda expression has access to
11669 : : the private variables of enclosing classes. */
11670 : :
11671 : 598946 : if (cp_parser_start_tentative_firewall (parser))
11672 : 14177 : start = token;
11673 : :
11674 : 598946 : ok &= cp_parser_lambda_declarator_opt (parser, lambda_expr);
11675 : :
11676 : 598946 : if (ok && cp_parser_error_occurred (parser))
11677 : : ok = false;
11678 : :
11679 : 598946 : if (ok)
11680 : 598915 : cp_parser_lambda_body (parser, lambda_expr);
11681 : 31 : else if (cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
11682 : : {
11683 : 26 : if (cp_parser_skip_to_closing_brace (parser))
11684 : 26 : cp_lexer_consume_token (parser->lexer);
11685 : : }
11686 : :
11687 : : /* The capture list was built up in reverse order; fix that now. */
11688 : 598946 : LAMBDA_EXPR_CAPTURE_LIST (lambda_expr)
11689 : 598946 : = nreverse (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr));
11690 : :
11691 : 598946 : if (ok)
11692 : 598915 : maybe_add_lambda_conv_op (type);
11693 : :
11694 : 598946 : finish_struct (type, /*attributes=*/NULL_TREE);
11695 : :
11696 : 598946 : in_consteval_if_p = save_in_consteval_if_p;
11697 : 598946 : in_discarded_stmt = discarded;
11698 : :
11699 : 598946 : parser->num_template_parameter_lists = saved_num_template_parameter_lists;
11700 : 598946 : parser->in_statement = in_statement;
11701 : 598946 : parser->in_switch_statement_p = in_switch_statement_p;
11702 : 598946 : parser->fully_implicit_function_template_p
11703 : 598946 : = fully_implicit_function_template_p;
11704 : 598946 : parser->implicit_template_parms = implicit_template_parms;
11705 : 598946 : parser->implicit_template_scope = implicit_template_scope;
11706 : 598946 : parser->auto_is_implicit_function_template_parm_p
11707 : 598946 : = auto_is_implicit_function_template_parm_p;
11708 : 598946 : parser->omp_array_section_p = saved_omp_array_section_p;
11709 : : }
11710 : :
11711 : : /* This field is only used during parsing of the lambda. */
11712 : 598946 : LAMBDA_EXPR_THIS_CAPTURE (lambda_expr) = NULL_TREE;
11713 : :
11714 : : /* This lambda shouldn't have any proxies left at this point. */
11715 : 598946 : gcc_assert (LAMBDA_EXPR_PENDING_PROXIES (lambda_expr) == NULL);
11716 : : /* And now that we're done, push proxies for an enclosing lambda. */
11717 : 598946 : insert_pending_capture_proxies ();
11718 : :
11719 : : /* Update the lambda expression to a range. */
11720 : 598946 : LAMBDA_EXPR_LOCATION (lambda_expr) = make_location (token->location,
11721 : : token->location,
11722 : : parser->lexer);
11723 : :
11724 : 598946 : if (ok)
11725 : 598915 : lambda_expr = build_lambda_object (lambda_expr);
11726 : : else
11727 : 31 : lambda_expr = error_mark_node;
11728 : :
11729 : 598946 : cp_parser_end_tentative_firewall (parser, start, lambda_expr);
11730 : :
11731 : 598946 : pop_deferring_access_checks ();
11732 : :
11733 : 598946 : return lambda_expr;
11734 : : }
11735 : :
11736 : : /* Parse the beginning of a lambda expression.
11737 : :
11738 : : lambda-introducer:
11739 : : [ lambda-capture [opt] ]
11740 : :
11741 : : LAMBDA_EXPR is the current representation of the lambda expression. */
11742 : :
11743 : : static void
11744 : 598949 : cp_parser_lambda_introducer (cp_parser* parser, tree lambda_expr)
11745 : : {
11746 : : /* Need commas after the first capture. */
11747 : 598949 : bool first = true;
11748 : :
11749 : : /* Eat the leading `['. */
11750 : 598949 : cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
11751 : :
11752 : : /* Record default capture mode. "[&" "[=" "[&," "[=," */
11753 : 598949 : if (cp_lexer_next_token_is (parser->lexer, CPP_AND)
11754 : 222979 : && !cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS)
11755 : 222973 : && !cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME)
11756 : 767222 : && !cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_THIS))
11757 : 168270 : LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) = CPLD_REFERENCE;
11758 : 430679 : else if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
11759 : 38950 : LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) = CPLD_COPY;
11760 : :
11761 : 598949 : if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) != CPLD_NONE)
11762 : : {
11763 : 207220 : cp_lexer_consume_token (parser->lexer);
11764 : 207220 : first = false;
11765 : :
11766 : 207220 : if (!(at_function_scope_p () || parsing_nsdmi ()))
11767 : 15 : error ("non-local lambda expression cannot have a capture-default");
11768 : : }
11769 : :
11770 : 598949 : hash_set<tree, true> ids;
11771 : 598949 : tree first_capture_id = NULL_TREE;
11772 : 598949 : unsigned name_independent_cnt = 0;
11773 : 948114 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_SQUARE))
11774 : : {
11775 : 349187 : cp_token* capture_token;
11776 : 349187 : tree capture_id;
11777 : 349187 : tree capture_init_expr;
11778 : 349187 : cp_id_kind idk = CP_ID_KIND_NONE;
11779 : 349187 : bool explicit_init_p = false;
11780 : :
11781 : 349187 : enum capture_kind_type
11782 : : {
11783 : : BY_COPY,
11784 : : BY_REFERENCE
11785 : : };
11786 : 349187 : enum capture_kind_type capture_kind = BY_COPY;
11787 : :
11788 : 349187 : if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
11789 : : {
11790 : 3 : error ("expected end of capture-list");
11791 : 3 : return;
11792 : : }
11793 : :
11794 : 349184 : if (first)
11795 : : first = false;
11796 : : else
11797 : 111851 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
11798 : :
11799 : : /* Possibly capture `this'. */
11800 : 349184 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THIS))
11801 : : {
11802 : 131690 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
11803 : 58421 : if (cxx_dialect < cxx20 && pedantic
11804 : 131895 : && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_COPY)
11805 : 21 : pedwarn (loc, OPT_Wc__20_extensions,
11806 : : "explicit by-copy capture of %<this%> "
11807 : : "with by-copy capture default only available with "
11808 : : "%<-std=c++20%> or %<-std=gnu++20%>");
11809 : 131690 : cp_lexer_consume_token (parser->lexer);
11810 : 131690 : if (LAMBDA_EXPR_THIS_CAPTURE (lambda_expr))
11811 : 18 : pedwarn (input_location, 0,
11812 : : "already captured %qD in lambda expression",
11813 : : this_identifier);
11814 : : else
11815 : 131672 : add_capture (lambda_expr, /*id=*/this_identifier,
11816 : : /*initializer=*/finish_this_expr (),
11817 : : /*by_reference_p=*/true, explicit_init_p, NULL);
11818 : 131874 : continue;
11819 : 131690 : }
11820 : :
11821 : : /* Possibly capture `*this'. */
11822 : 217494 : if (cp_lexer_next_token_is (parser->lexer, CPP_MULT)
11823 : 217494 : && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_THIS))
11824 : : {
11825 : 130 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
11826 : 130 : if (cxx_dialect < cxx17)
11827 : 54 : pedwarn (loc, OPT_Wc__17_extensions,
11828 : : "%<*this%> capture only available with "
11829 : : "%<-std=c++17%> or %<-std=gnu++17%>");
11830 : 130 : cp_lexer_consume_token (parser->lexer);
11831 : 130 : cp_lexer_consume_token (parser->lexer);
11832 : 130 : if (LAMBDA_EXPR_THIS_CAPTURE (lambda_expr))
11833 : 15 : pedwarn (input_location, 0,
11834 : : "already captured %qD in lambda expression",
11835 : : this_identifier);
11836 : : else
11837 : 115 : add_capture (lambda_expr, /*id=*/this_identifier,
11838 : : /*initializer=*/finish_this_expr (),
11839 : : /*by_reference_p=*/false, explicit_init_p, NULL);
11840 : 130 : continue;
11841 : 130 : }
11842 : :
11843 : : /* But reject `&this'. */
11844 : 217370 : if (cp_lexer_next_token_is (parser->lexer, CPP_AND)
11845 : 217364 : && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_THIS))
11846 : : {
11847 : 6 : error_at (cp_lexer_peek_token (parser->lexer)->location,
11848 : : "%<this%> cannot be captured by reference");
11849 : 6 : cp_lexer_consume_token (parser->lexer);
11850 : 6 : cp_lexer_consume_token (parser->lexer);
11851 : 6 : continue;
11852 : : }
11853 : :
11854 : : /* Remember whether we want to capture as a reference or not. */
11855 : 217358 : if (cp_lexer_next_token_is (parser->lexer, CPP_AND))
11856 : : {
11857 : 127482 : capture_kind = BY_REFERENCE;
11858 : 127482 : cp_lexer_consume_token (parser->lexer);
11859 : : }
11860 : :
11861 : 217358 : bool init_pack_expansion = false;
11862 : 217358 : location_t ellipsis_loc = UNKNOWN_LOCATION;
11863 : 217358 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
11864 : : {
11865 : 44 : ellipsis_loc = cp_lexer_peek_token (parser->lexer)->location;
11866 : 44 : if (cxx_dialect < cxx20)
11867 : 0 : pedwarn (ellipsis_loc, OPT_Wc__20_extensions,
11868 : : "pack init-capture only available with "
11869 : : "%<-std=c++20%> or %<-std=gnu++20%>");
11870 : 44 : cp_lexer_consume_token (parser->lexer);
11871 : 44 : init_pack_expansion = true;
11872 : : }
11873 : :
11874 : : /* Early C++20 drafts had ...& instead of &...; be forgiving. */
11875 : 217358 : if (init_pack_expansion && capture_kind != BY_REFERENCE
11876 : 217358 : && cp_lexer_next_token_is (parser->lexer, CPP_AND))
11877 : : {
11878 : 3 : pedwarn (cp_lexer_peek_token (parser->lexer)->location,
11879 : : 0, "%<&%> should come before %<...%>");
11880 : 3 : capture_kind = BY_REFERENCE;
11881 : 3 : cp_lexer_consume_token (parser->lexer);
11882 : : }
11883 : :
11884 : : /* Get the identifier. */
11885 : 217358 : capture_token = cp_lexer_peek_token (parser->lexer);
11886 : 217358 : capture_id = cp_parser_identifier (parser);
11887 : :
11888 : 217358 : if (capture_id == error_mark_node)
11889 : : /* Would be nice to have a cp_parser_skip_to_closing_x for general
11890 : : delimiters, but I modified this to stop on unnested ']' as well. It
11891 : : was already changed to stop on unnested '}', so the
11892 : : "closing_parenthesis" name is no more misleading with my change. */
11893 : : {
11894 : 19 : cp_parser_skip_to_closing_parenthesis (parser,
11895 : : /*recovering=*/true,
11896 : : /*or_comma=*/true,
11897 : : /*consume_paren=*/true);
11898 : 19 : break;
11899 : : }
11900 : :
11901 : : /* Find the initializer for this capture. */
11902 : 217339 : if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)
11903 : : || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
11904 : : || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
11905 : : {
11906 : : /* An explicit initializer exists. */
11907 : 535 : if (cxx_dialect < cxx14)
11908 : 13 : pedwarn (input_location, OPT_Wc__14_extensions,
11909 : : "lambda capture initializers "
11910 : : "only available with %<-std=c++14%> or %<-std=gnu++14%>");
11911 : 535 : capture_init_expr = cp_parser_initializer (parser,
11912 : : /*direct_init=*/nullptr,
11913 : : /*non_constant=*/nullptr,
11914 : : /*subexpression_p=*/true);
11915 : 535 : explicit_init_p = true;
11916 : 535 : if (capture_init_expr == NULL_TREE)
11917 : : {
11918 : 3 : error ("empty initializer for lambda init-capture");
11919 : 3 : capture_init_expr = error_mark_node;
11920 : : }
11921 : 535 : if (init_pack_expansion)
11922 : 32 : capture_init_expr = make_pack_expansion (capture_init_expr);
11923 : : }
11924 : : else
11925 : : {
11926 : 216804 : const char* error_msg;
11927 : :
11928 : : /* Turn the identifier into an id-expression. */
11929 : 216804 : capture_init_expr
11930 : 216804 : = cp_parser_lookup_name_simple (parser, capture_id,
11931 : : capture_token->location);
11932 : :
11933 : 216804 : if (capture_init_expr == error_mark_node)
11934 : : {
11935 : 18 : unqualified_name_lookup_error (capture_id);
11936 : 48 : continue;
11937 : : }
11938 : 216786 : else if (!VAR_P (capture_init_expr)
11939 : 147126 : && TREE_CODE (capture_init_expr) != PARM_DECL)
11940 : : {
11941 : 15 : auto_diagnostic_group d;
11942 : 15 : error_at (capture_token->location,
11943 : : "capture of non-variable %qE",
11944 : : capture_init_expr);
11945 : 15 : if (DECL_P (capture_init_expr))
11946 : 6 : inform (DECL_SOURCE_LOCATION (capture_init_expr),
11947 : : "%q#D declared here", capture_init_expr);
11948 : 15 : continue;
11949 : 15 : }
11950 : 216771 : if (VAR_P (capture_init_expr)
11951 : 216771 : && decl_storage_duration (capture_init_expr) != dk_auto)
11952 : : {
11953 : 3 : auto_diagnostic_group d;
11954 : 3 : if (pedwarn (capture_token->location, 0, "capture of variable "
11955 : : "%qD with non-automatic storage duration",
11956 : : capture_init_expr))
11957 : 3 : inform (DECL_SOURCE_LOCATION (capture_init_expr),
11958 : : "%q#D declared here", capture_init_expr);
11959 : 3 : continue;
11960 : 3 : }
11961 : :
11962 : 216768 : capture_init_expr
11963 : : = finish_id_expression
11964 : 216768 : (capture_id,
11965 : : capture_init_expr,
11966 : : parser->scope,
11967 : : &idk,
11968 : : /*integral_constant_expression_p=*/false,
11969 : : /*allow_non_integral_constant_expression_p=*/false,
11970 : : /*non_integral_constant_expression_p=*/NULL,
11971 : : /*template_p=*/false,
11972 : : /*done=*/true,
11973 : : /*address_p=*/false,
11974 : : /*template_arg_p=*/false,
11975 : : &error_msg,
11976 : : capture_token->location);
11977 : :
11978 : 216768 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
11979 : : {
11980 : 51 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
11981 : 51 : cp_lexer_consume_token (parser->lexer);
11982 : 51 : capture_init_expr = make_pack_expansion (capture_init_expr);
11983 : 51 : if (init_pack_expansion)
11984 : : {
11985 : : /* If what follows is an initializer, the second '...' is
11986 : : invalid. But for cases like [...xs...], the first one
11987 : : is invalid. */
11988 : 12 : if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)
11989 : : || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
11990 : : || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
11991 : : ellipsis_loc = loc;
11992 : 12 : error_at (ellipsis_loc, "too many %<...%> in lambda capture");
11993 : 12 : continue;
11994 : : }
11995 : : }
11996 : : }
11997 : :
11998 : 217291 : if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) != CPLD_NONE
11999 : 217291 : && !explicit_init_p)
12000 : : {
12001 : 155 : if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_COPY
12002 : 155 : && capture_kind == BY_COPY)
12003 : 12 : pedwarn (capture_token->location, 0, "explicit by-copy capture "
12004 : : "of %qD redundant with by-copy capture default",
12005 : : capture_id);
12006 : 155 : if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_REFERENCE
12007 : 155 : && capture_kind == BY_REFERENCE)
12008 : 6 : pedwarn (capture_token->location, 0, "explicit by-reference "
12009 : : "capture of %qD redundant with by-reference capture "
12010 : : "default", capture_id);
12011 : : }
12012 : :
12013 : : /* Check for duplicates.
12014 : : Optimize for the zero or one explicit captures cases and only create
12015 : : the hash_set after adding second capture. */
12016 : 217291 : bool found = false;
12017 : 217291 : if (!ids.is_empty ())
12018 : 11618 : found = ids.add (capture_id);
12019 : 205673 : else if (first_capture_id == NULL_TREE)
12020 : 171482 : first_capture_id = capture_id;
12021 : 34191 : else if (capture_id == first_capture_id)
12022 : : found = true;
12023 : : else
12024 : : {
12025 : 34170 : ids.add (first_capture_id);
12026 : 34170 : ids.add (capture_id);
12027 : : }
12028 : 217291 : if (found && explicit_init_p && id_equal (capture_id, "_"))
12029 : : found = false;
12030 : 217273 : if (found)
12031 : 9 : pedwarn (input_location, 0,
12032 : : "already captured %qD in lambda expression", capture_id);
12033 : : else
12034 : 217282 : add_capture (lambda_expr, capture_id, capture_init_expr,
12035 : : /*by_reference_p=*/capture_kind == BY_REFERENCE,
12036 : : explicit_init_p, &name_independent_cnt);
12037 : :
12038 : : /* If there is any qualification still in effect, clear it
12039 : : now; we will be starting fresh with the next capture. */
12040 : 217291 : parser->scope = NULL_TREE;
12041 : 217291 : parser->qualifying_scope = NULL_TREE;
12042 : 217291 : parser->object_scope = NULL_TREE;
12043 : : }
12044 : :
12045 : 598946 : cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
12046 : 598949 : }
12047 : :
12048 : : /* Parse the (optional) middle of a lambda expression.
12049 : :
12050 : : lambda-declarator:
12051 : : ( parameter-declaration-clause ) lambda-specifiers requires-clause [opt]
12052 : : lambda-specifiers (C++23)
12053 : :
12054 : : lambda-specifiers:
12055 : : decl-specifier-seq [opt] noexcept-specifier [opt]
12056 : : attribute-specifier-seq [opt] trailing-return-type [opt]
12057 : :
12058 : : LAMBDA_EXPR is the current representation of the lambda expression. */
12059 : :
12060 : : static bool
12061 : 598946 : cp_parser_lambda_declarator_opt (cp_parser* parser, tree lambda_expr)
12062 : : {
12063 : : /* 5.1.1.4 of the standard says:
12064 : : If a lambda-expression does not include a lambda-declarator, it is as if
12065 : : the lambda-declarator were ().
12066 : : This means an empty parameter list, no attributes, and no exception
12067 : : specification. */
12068 : 598946 : tree param_list = void_list_node;
12069 : 598946 : tree std_attrs = NULL_TREE;
12070 : 598946 : tree gnu_attrs = NULL_TREE;
12071 : 598946 : tree exception_spec = NULL_TREE;
12072 : 598946 : tree template_param_list = NULL_TREE;
12073 : 598946 : tree tx_qual = NULL_TREE;
12074 : 598946 : tree return_type = NULL_TREE;
12075 : 598946 : tree trailing_requires_clause = NULL_TREE;
12076 : 598946 : bool has_param_list = false;
12077 : 598946 : location_t omitted_parms_loc = UNKNOWN_LOCATION;
12078 : 598946 : cp_decl_specifier_seq lambda_specs;
12079 : 598946 : clear_decl_specs (&lambda_specs);
12080 : : /* A lambda op() is const unless explicitly 'mutable'. */
12081 : 598946 : cp_cv_quals quals = TYPE_QUAL_CONST;
12082 : :
12083 : : /* The template-parameter-list is optional, but must begin with
12084 : : an opening angle if present. */
12085 : 598946 : if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
12086 : : {
12087 : 69502 : if (cxx_dialect < cxx20
12088 : 53 : && (pedantic || cxx_dialect < cxx14))
12089 : 30 : pedwarn (parser->lexer->next_token->location, OPT_Wc__20_extensions,
12090 : : "lambda templates are only available with "
12091 : : "%<-std=c++20%> or %<-std=gnu++20%>");
12092 : :
12093 : : /* Even though the whole lambda may be a default argument, its
12094 : : template-parameter-list is a context where it's OK to create
12095 : : new parameters. */
12096 : 69502 : auto lvf = make_temp_override (parser->local_variables_forbidden_p, 0u);
12097 : :
12098 : 69502 : cp_lexer_consume_token (parser->lexer);
12099 : :
12100 : 69502 : template_param_list = cp_parser_template_parameter_list (parser);
12101 : 69502 : cp_parser_require_end_of_template_parameter_list (parser);
12102 : :
12103 : : /* We may have a constrained generic lambda; parse the requires-clause
12104 : : immediately after the template-parameter-list and combine with any
12105 : : shorthand constraints present. */
12106 : 69502 : tree dreqs = cp_parser_requires_clause_opt (parser, true);
12107 : 69502 : if (flag_concepts)
12108 : : {
12109 : 69449 : tree reqs = get_shorthand_constraints (current_template_parms);
12110 : 69449 : if (dreqs)
12111 : 15 : reqs = combine_constraint_expressions (reqs, dreqs);
12112 : 69449 : TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = reqs;
12113 : : }
12114 : :
12115 : : /* We just processed one more parameter list. */
12116 : 69502 : ++parser->num_template_parameter_lists;
12117 : 69502 : }
12118 : :
12119 : : /* Committee discussion supports allowing attributes here. */
12120 : 598946 : lambda_specs.attributes = cp_parser_attributes_opt (parser);
12121 : :
12122 : : /* The parameter-declaration-clause is optional (unless
12123 : : template-parameter-list was given), but must begin with an
12124 : : opening parenthesis if present. */
12125 : 598946 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
12126 : : {
12127 : 501111 : matching_parens parens;
12128 : 501111 : parens.consume_open (parser);
12129 : :
12130 : 501111 : begin_scope (sk_function_parms, /*entity=*/NULL_TREE);
12131 : :
12132 : : /* Parse parameters. */
12133 : 501111 : param_list
12134 : : = cp_parser_parameter_declaration_clause
12135 : 501111 : (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL, /*lambda_p=*/true);
12136 : :
12137 : : /* Default arguments shall not be specified in the
12138 : : parameter-declaration-clause of a lambda-declarator. */
12139 : 501111 : if (pedantic && cxx_dialect < cxx14)
12140 : 1134 : for (tree t = param_list; t; t = TREE_CHAIN (t))
12141 : 738 : if (TREE_PURPOSE (t) && DECL_P (TREE_VALUE (t)))
12142 : 2 : pedwarn (DECL_SOURCE_LOCATION (TREE_VALUE (t)),
12143 : : OPT_Wc__14_extensions,
12144 : : "default argument specified for lambda parameter");
12145 : :
12146 : 501111 : parens.require_close (parser);
12147 : 501111 : has_param_list = true;
12148 : : }
12149 : 97835 : else if (cxx_dialect < cxx23)
12150 : 56751 : omitted_parms_loc = cp_lexer_peek_token (parser->lexer)->location;
12151 : :
12152 : : /* [expr.prim.lambda.general]
12153 : : lambda-specifier:
12154 : : consteval, constexpr, mutable, static
12155 : : [4] A lambda-specifier-seq shall contain at most one of each
12156 : : lambda-specifier and shall not contain both constexpr and consteval.
12157 : : The lambda-specifier-seq shall not contain both mutable and static. */
12158 : 598946 : int declares_class_or_enum;
12159 : 598946 : if (cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer))
12160 : 88350 : cp_parser_decl_specifier_seq (parser,
12161 : : CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR,
12162 : : &lambda_specs, &declares_class_or_enum);
12163 : :
12164 : 598946 : if (omitted_parms_loc && lambda_specs.any_specifiers_p)
12165 : : {
12166 : 30 : pedwarn (omitted_parms_loc, OPT_Wc__23_extensions,
12167 : : "parameter declaration before lambda declaration "
12168 : : "specifiers only optional with %<-std=c++2b%> or "
12169 : : "%<-std=gnu++2b%>");
12170 : 30 : omitted_parms_loc = UNKNOWN_LOCATION;
12171 : : }
12172 : : /* Peek at the params, see if we have an xobj parameter. */
12173 : 1197878 : if (param_list && TREE_PURPOSE (param_list) == this_identifier)
12174 : : {
12175 : 3376 : quals = TYPE_UNQUALIFIED;
12176 : : /* We still need grokdeclarator to see that this is an xobj function
12177 : : and finish the rest of the work, don't mutate it. */
12178 : 3376 : tree const xobj_param = TREE_VALUE (param_list);
12179 : 3376 : tree const param_type = TREE_TYPE (xobj_param);
12180 : : /* [expr.prim.lambda.closure-5]
12181 : : Given a lambda with a lambda-capture, the type of the explicit object
12182 : : parameter, if any, of the lambda's function call operator (possibly
12183 : : instantiated from a function call operator template) shall be either:
12184 : : -- the closure type,
12185 : : -- a class type derived from the closure type, or
12186 : : -- a reference to a possibly cv-qualified such type. */
12187 : 3376 : bool const unrelated_with_captures
12188 : 3376 : = (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) != CPLD_NONE
12189 : 1260 : || LAMBDA_EXPR_CAPTURE_LIST (lambda_expr))
12190 : : /* Since a lambda's type is anonymous, we can assume an xobj
12191 : : parameter is unrelated to the closure if it is non-dependent.
12192 : : If it is dependent we handle it at instantiation time. */
12193 : 4530 : && !WILDCARD_TYPE_P (non_reference (param_type));
12194 : 2 : if (unrelated_with_captures)
12195 : : {
12196 : 2 : error_at (DECL_SOURCE_LOCATION (xobj_param),
12197 : : "a lambda with captures may not have an explicit object "
12198 : : "parameter of an unrelated type");
12199 : 2 : LAMBDA_EXPR_CAPTURE_LIST (lambda_expr) = NULL_TREE;
12200 : : }
12201 : :
12202 : : /* [expr.prim.lambda.general-4]
12203 : : If the lambda-declarator contains an explicit object parameter
12204 : : ([dcl.fct]), then no lambda-specifier in the lambda-specifier-seq
12205 : : shall be mutable or static. */
12206 : 3376 : if (lambda_specs.storage_class == sc_mutable)
12207 : : {
12208 : 16 : auto_diagnostic_group d;
12209 : 16 : error_at (lambda_specs.locations[ds_storage_class],
12210 : : "%<mutable%> lambda specifier "
12211 : : "with explicit object parameter");
12212 : : /* Tell the user how to do what they probably meant, maybe fixits
12213 : : would be appropriate later? */
12214 : 16 : if (unrelated_with_captures)
12215 : : /* The following hints don't make sense when we already have an
12216 : : unrelated type with captures, don't emit them. */;
12217 : 16 : else if (!TYPE_REF_P (param_type))
12218 : 4 : inform (DECL_SOURCE_LOCATION (xobj_param),
12219 : : "the passed in closure object will not be mutated because "
12220 : : "it is taken by value");
12221 : 12 : else if (TYPE_READONLY (TREE_TYPE (param_type)))
12222 : 4 : inform (DECL_SOURCE_LOCATION (xobj_param),
12223 : : "declare the explicit object parameter as non-const "
12224 : : "reference instead");
12225 : : else
12226 : 8 : inform (DECL_SOURCE_LOCATION (xobj_param),
12227 : : "explicit object parameter is already a mutable "
12228 : : "reference");
12229 : 16 : }
12230 : 3360 : else if (lambda_specs.storage_class == sc_static)
12231 : : {
12232 : 16 : auto_diagnostic_group d;
12233 : 16 : error_at (lambda_specs.locations[ds_storage_class],
12234 : : "%<static%> lambda specifier "
12235 : : "with explicit object parameter");
12236 : 16 : inform (DECL_SOURCE_LOCATION (xobj_param),
12237 : : "explicit object parameter declared here");
12238 : 16 : }
12239 : : }
12240 : 595570 : else if (lambda_specs.storage_class == sc_mutable)
12241 : : {
12242 : : quals = TYPE_UNQUALIFIED;
12243 : : }
12244 : 509220 : else if (lambda_specs.storage_class == sc_static)
12245 : : {
12246 : : /* [expr.prim.lambda.general-4]
12247 : : If the lambda-specifier-seq contains static, there shall be no
12248 : : lambda-capture. */
12249 : 34 : if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) != CPLD_NONE
12250 : 34 : || LAMBDA_EXPR_CAPTURE_LIST (lambda_expr))
12251 : 9 : error_at (lambda_specs.locations[ds_storage_class],
12252 : : "%<static%> lambda specifier with lambda capture");
12253 : : else
12254 : : {
12255 : 25 : LAMBDA_EXPR_STATIC_P (lambda_expr) = 1;
12256 : 25 : quals = TYPE_UNQUALIFIED;
12257 : : }
12258 : : }
12259 : :
12260 : 598946 : tx_qual = cp_parser_tx_qualifier_opt (parser);
12261 : 598946 : if (omitted_parms_loc && tx_qual)
12262 : : {
12263 : 0 : pedwarn (omitted_parms_loc, OPT_Wc__23_extensions,
12264 : : "parameter declaration before lambda transaction "
12265 : : "qualifier only optional with %<-std=c++2b%> or "
12266 : : "%<-std=gnu++2b%>");
12267 : 0 : omitted_parms_loc = UNKNOWN_LOCATION;
12268 : : }
12269 : :
12270 : : /* Parse optional exception specification. */
12271 : 598946 : exception_spec
12272 : 598946 : = cp_parser_exception_specification_opt (parser, CP_PARSER_FLAGS_NONE);
12273 : :
12274 : 598946 : if (omitted_parms_loc && exception_spec)
12275 : : {
12276 : 30 : pedwarn (omitted_parms_loc, OPT_Wc__23_extensions,
12277 : : "parameter declaration before lambda exception "
12278 : : "specification only optional with %<-std=c++2b%> or "
12279 : : "%<-std=gnu++2b%>");
12280 : 30 : omitted_parms_loc = UNKNOWN_LOCATION;
12281 : : }
12282 : :
12283 : : /* GCC 8 accepted attributes here, and this is the place for standard C++11
12284 : : attributes that appertain to the function type. */
12285 : 598946 : if (cp_next_tokens_can_be_gnu_attribute_p (parser))
12286 : 3198 : gnu_attrs = cp_parser_gnu_attributes_opt (parser);
12287 : : else
12288 : 595748 : std_attrs = cp_parser_std_attribute_spec_seq (parser);
12289 : :
12290 : : /* Parse optional trailing return type. */
12291 : 598946 : if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
12292 : : {
12293 : 136431 : if (omitted_parms_loc)
12294 : 3 : pedwarn (omitted_parms_loc, OPT_Wc__23_extensions,
12295 : : "parameter declaration before lambda trailing "
12296 : : "return type only optional with %<-std=c++2b%> or "
12297 : : "%<-std=gnu++2b%>");
12298 : 136431 : cp_lexer_consume_token (parser->lexer);
12299 : 136431 : return_type = cp_parser_trailing_type_id (parser);
12300 : : }
12301 : :
12302 : : /* Also allow GNU attributes at the very end of the declaration, the usual
12303 : : place for GNU attributes. */
12304 : 598946 : if (cp_next_tokens_can_be_gnu_attribute_p (parser))
12305 : 3 : gnu_attrs = chainon (gnu_attrs, cp_parser_gnu_attributes_opt (parser));
12306 : :
12307 : 598946 : if (has_param_list)
12308 : : {
12309 : : /* Parse optional trailing requires clause. */
12310 : 501111 : trailing_requires_clause = cp_parser_requires_clause_opt (parser, false);
12311 : :
12312 : : /* The function parameters must be in scope all the way until after the
12313 : : trailing-return-type in case of decltype. */
12314 : 501111 : pop_bindings_and_leave_scope ();
12315 : : }
12316 : :
12317 : : /* Create the function call operator.
12318 : :
12319 : : Messing with declarators like this is no uglier than building up the
12320 : : FUNCTION_DECL by hand, and this is less likely to get out of sync with
12321 : : other code. */
12322 : 598946 : {
12323 : 598946 : cp_decl_specifier_seq return_type_specs;
12324 : 598946 : cp_declarator* declarator;
12325 : 598946 : tree fco;
12326 : 598946 : void *p;
12327 : :
12328 : 598946 : clear_decl_specs (&return_type_specs);
12329 : 598946 : return_type_specs.type = make_auto ();
12330 : :
12331 : 598946 : if (lambda_specs.locations[ds_constexpr])
12332 : : {
12333 : 1934 : if (cxx_dialect >= cxx17)
12334 : 1917 : return_type_specs.locations[ds_constexpr]
12335 : 1917 : = lambda_specs.locations[ds_constexpr];
12336 : : else
12337 : 17 : error_at (lambda_specs.locations[ds_constexpr], "%<constexpr%> "
12338 : : "lambda only available with %<-std=c++17%> or "
12339 : : "%<-std=gnu++17%>");
12340 : : }
12341 : 598946 : if (lambda_specs.locations[ds_consteval])
12342 : 8 : return_type_specs.locations[ds_consteval]
12343 : 8 : = lambda_specs.locations[ds_consteval];
12344 : 598946 : if (LAMBDA_EXPR_STATIC_P (lambda_expr))
12345 : : {
12346 : 25 : return_type_specs.storage_class = sc_static;
12347 : 25 : return_type_specs.locations[ds_storage_class]
12348 : 25 : = lambda_specs.locations[ds_storage_class];
12349 : : }
12350 : :
12351 : 598946 : p = obstack_alloc (&declarator_obstack, 0);
12352 : :
12353 : 598946 : declarator = make_id_declarator (NULL_TREE, call_op_identifier, sfk_none,
12354 : 598946 : LAMBDA_EXPR_LOCATION (lambda_expr));
12355 : :
12356 : 598946 : declarator = make_call_declarator (declarator, param_list, quals,
12357 : : VIRT_SPEC_UNSPECIFIED,
12358 : : REF_QUAL_NONE,
12359 : : tx_qual,
12360 : : exception_spec,
12361 : : return_type,
12362 : : trailing_requires_clause,
12363 : : std_attrs,
12364 : : UNKNOWN_LOCATION);
12365 : :
12366 : 598946 : fco = grokmethod (&return_type_specs,
12367 : : declarator,
12368 : : chainon (gnu_attrs, lambda_specs.attributes));
12369 : 598946 : if (fco != error_mark_node)
12370 : : {
12371 : 598933 : DECL_INITIALIZED_IN_CLASS_P (fco) = 1;
12372 : 598933 : DECL_ARTIFICIAL (fco) = 1;
12373 : 598933 : if (DECL_IOBJ_MEMBER_FUNCTION_P (fco))
12374 : : /* Give the object parameter a different name. */
12375 : 595532 : DECL_NAME (DECL_ARGUMENTS (fco)) = closure_identifier;
12376 : 598933 : DECL_SET_LAMBDA_FUNCTION (fco, true);
12377 : : }
12378 : 598946 : if (template_param_list)
12379 : : {
12380 : 69502 : fco = finish_member_template_decl (fco);
12381 : 69502 : finish_template_decl (template_param_list);
12382 : 69502 : --parser->num_template_parameter_lists;
12383 : : }
12384 : 529444 : else if (parser->fully_implicit_function_template_p)
12385 : 205786 : fco = finish_fully_implicit_template (parser, fco);
12386 : :
12387 : 598946 : finish_member_declaration (fco);
12388 : 598946 : record_lambda_scope_sig_discriminator (lambda_expr, fco);
12389 : :
12390 : 598946 : obstack_free (&declarator_obstack, p);
12391 : :
12392 : 598946 : return (fco != error_mark_node);
12393 : : }
12394 : : }
12395 : :
12396 : : /* Parse the body of a lambda expression, which is simply
12397 : :
12398 : : compound-statement
12399 : :
12400 : : but which requires special handling.
12401 : : LAMBDA_EXPR is the current representation of the lambda expression. */
12402 : :
12403 : : static void
12404 : 598915 : cp_parser_lambda_body (cp_parser* parser, tree lambda_expr)
12405 : : {
12406 : 598915 : bool nested = (current_function_decl != NULL_TREE);
12407 : 598915 : unsigned char local_variables_forbidden_p
12408 : : = parser->local_variables_forbidden_p;
12409 : 598915 : bool in_function_body = parser->in_function_body;
12410 : :
12411 : : /* The body of a lambda-expression is not a subexpression of the enclosing
12412 : : expression. */
12413 : 598915 : cp_evaluated ev;
12414 : :
12415 : 598915 : if (nested)
12416 : 595256 : push_function_context ();
12417 : : else
12418 : : /* Still increment function_depth so that we don't GC in the
12419 : : middle of an expression. */
12420 : 3659 : ++function_depth;
12421 : :
12422 : 598915 : auto odsd = make_temp_override (parser->omp_declare_simd, NULL);
12423 : 598915 : auto ord = make_temp_override (parser->oacc_routine, NULL);
12424 : 598915 : auto oafp = make_temp_override (parser->omp_attrs_forbidden_p, false);
12425 : 598915 : vec<tree> omp_privatization_save;
12426 : 598915 : save_omp_privatization_clauses (omp_privatization_save);
12427 : : /* Clear this in case we're in the middle of a default argument. */
12428 : 598915 : parser->local_variables_forbidden_p = 0;
12429 : 598915 : parser->in_function_body = true;
12430 : :
12431 : 598915 : {
12432 : 598915 : local_specialization_stack s (lss_copy);
12433 : 598915 : tree fco = lambda_function (lambda_expr);
12434 : 598915 : tree body = start_lambda_function (fco, lambda_expr);
12435 : :
12436 : : /* Originally C++11 required us to peek for 'return expr'; and
12437 : : process it specially here to deduce the return type. N3638
12438 : : removed the need for that. */
12439 : 1197830 : cp_parser_function_body (parser, false);
12440 : :
12441 : 598915 : finish_lambda_function (body);
12442 : 598915 : }
12443 : :
12444 : 598915 : restore_omp_privatization_clauses (omp_privatization_save);
12445 : 598915 : parser->local_variables_forbidden_p = local_variables_forbidden_p;
12446 : 598915 : parser->in_function_body = in_function_body;
12447 : 598915 : if (nested)
12448 : 595256 : pop_function_context();
12449 : : else
12450 : 3659 : --function_depth;
12451 : 598915 : }
12452 : :
12453 : : /* Statements [gram.stmt.stmt] */
12454 : :
12455 : : /* Build and add a DEBUG_BEGIN_STMT statement with location LOC. */
12456 : :
12457 : : static void
12458 : 288261948 : add_debug_begin_stmt (location_t loc)
12459 : : {
12460 : 288261948 : if (!MAY_HAVE_DEBUG_MARKER_STMTS)
12461 : : return;
12462 : :
12463 : 277330315 : tree stmt = build0 (DEBUG_BEGIN_STMT, void_type_node);
12464 : 277330315 : SET_EXPR_LOCATION (stmt, loc);
12465 : 277330315 : add_stmt (stmt);
12466 : : }
12467 : :
12468 : : struct cp_omp_attribute_data
12469 : : {
12470 : : cp_token_cache *tokens;
12471 : : const c_omp_directive *dir;
12472 : : c_omp_directive_kind kind;
12473 : : };
12474 : :
12475 : : /* Handle omp::directive and omp::sequence attributes in ATTRS
12476 : : (if any) at the start of a statement or in attribute-declaration. */
12477 : :
12478 : : static tree
12479 : 27469 : cp_parser_handle_statement_omp_attributes (cp_parser *parser, tree attrs)
12480 : : {
12481 : 27469 : if (!flag_openmp && !flag_openmp_simd)
12482 : 4478 : return attrs;
12483 : :
12484 : 22991 : auto_vec<cp_omp_attribute_data, 16> vec;
12485 : 22991 : int cnt = 0;
12486 : 22991 : int tokens = 0;
12487 : 22991 : bool bad = false;
12488 : 25080 : for (tree *pa = &attrs; *pa; )
12489 : 2089 : if (get_attribute_namespace (*pa) == omp_identifier
12490 : 2089 : && is_attribute_p ("directive", get_attribute_name (*pa)))
12491 : : {
12492 : 1765 : cnt++;
12493 : 3957 : for (tree a = TREE_VALUE (*pa); a; a = TREE_CHAIN (a))
12494 : : {
12495 : 2192 : tree d = TREE_VALUE (a);
12496 : 2192 : gcc_assert (TREE_CODE (d) == DEFERRED_PARSE);
12497 : 2192 : cp_token *first = DEFPARSE_TOKENS (d)->first;
12498 : 2192 : cp_token *last = DEFPARSE_TOKENS (d)->last;
12499 : 2192 : if (parser->omp_attrs_forbidden_p)
12500 : : {
12501 : 39 : error_at (first->location,
12502 : : "mixing OpenMP directives with attribute and pragma "
12503 : : "syntax on the same statement");
12504 : 39 : parser->omp_attrs_forbidden_p = false;
12505 : 39 : bad = true;
12506 : : }
12507 : 2153 : else if (TREE_PUBLIC (d))
12508 : : {
12509 : 9 : error_at (first->location,
12510 : : "OpenMP %<omp::decl%> attribute on a statement");
12511 : 9 : bad = true;
12512 : : }
12513 : 2192 : const char *directive[3] = {};
12514 : 6406 : for (int i = 0; i < 3; i++)
12515 : : {
12516 : 5870 : tree id = NULL_TREE;
12517 : 5870 : if (first + i == last)
12518 : : break;
12519 : 5117 : if (first[i].type == CPP_NAME)
12520 : 3757 : id = first[i].u.value;
12521 : 1360 : else if (first[i].type == CPP_KEYWORD)
12522 : 457 : id = ridpointers[(int) first[i].keyword];
12523 : : else
12524 : : break;
12525 : 4214 : directive[i] = IDENTIFIER_POINTER (id);
12526 : : }
12527 : 2192 : const c_omp_directive *dir = NULL;
12528 : 2192 : if (directive[0])
12529 : 2192 : dir = c_omp_categorize_directive (directive[0], directive[1],
12530 : : directive[2]);
12531 : 2192 : if (dir == NULL)
12532 : : {
12533 : 3 : error_at (first->location,
12534 : : "unknown OpenMP directive name in %qs attribute "
12535 : : "argument",
12536 : 3 : TREE_PUBLIC (d) ? "omp::decl" : "omp::directive");
12537 : 3 : continue;
12538 : : }
12539 : 2189 : c_omp_directive_kind kind = dir->kind;
12540 : 2189 : if (dir->id == PRAGMA_OMP_ORDERED)
12541 : : {
12542 : : /* ordered is C_OMP_DIR_CONSTRUCT only if it doesn't contain
12543 : : depend/doacross clause. */
12544 : 24 : if (directive[1]
12545 : 12 : && (strcmp (directive[1], "depend") == 0
12546 : 6 : || strcmp (directive[1], "doacross") == 0))
12547 : : kind = C_OMP_DIR_STANDALONE;
12548 : 18 : else if (first + 2 < last
12549 : 12 : && first[1].type == CPP_COMMA
12550 : 12 : && first[2].type == CPP_NAME
12551 : 30 : && (strcmp (IDENTIFIER_POINTER (first[2].u.value),
12552 : : "depend") == 0
12553 : 6 : || strcmp (IDENTIFIER_POINTER (first[2].u.value),
12554 : : "doacross") == 0))
12555 : : kind = C_OMP_DIR_STANDALONE;
12556 : : }
12557 : 2165 : else if (dir->id == PRAGMA_OMP_ERROR)
12558 : : {
12559 : : /* error with at(execution) clause is C_OMP_DIR_STANDALONE. */
12560 : : int paren_depth = 0;
12561 : 297 : for (int i = 1; first + i < last; i++)
12562 : 252 : if (first[i].type == CPP_OPEN_PAREN)
12563 : 54 : paren_depth++;
12564 : 198 : else if (first[i].type == CPP_CLOSE_PAREN)
12565 : 54 : paren_depth--;
12566 : 144 : else if (paren_depth == 0
12567 : 90 : && first + i + 2 < last
12568 : 90 : && first[i].type == CPP_NAME
12569 : 63 : && first[i + 1].type == CPP_OPEN_PAREN
12570 : 63 : && first[i + 2].type == CPP_NAME
12571 : 45 : && !strcmp (IDENTIFIER_POINTER (first[i].u.value),
12572 : : "at")
12573 : 171 : && !strcmp (IDENTIFIER_POINTER (first[i
12574 : : + 2].u.value),
12575 : : "execution"))
12576 : : {
12577 : : kind = C_OMP_DIR_STANDALONE;
12578 : : break;
12579 : : }
12580 : : }
12581 : 2189 : cp_omp_attribute_data v = { DEFPARSE_TOKENS (d), dir, kind };
12582 : 2189 : vec.safe_push (v);
12583 : 2189 : if (flag_openmp || dir->simd)
12584 : 2189 : tokens += (last - first) + 1;
12585 : : }
12586 : 1765 : cp_omp_attribute_data v = {};
12587 : 1765 : vec.safe_push (v);
12588 : 1765 : *pa = TREE_CHAIN (*pa);
12589 : : }
12590 : : else
12591 : 324 : pa = &TREE_CHAIN (*pa);
12592 : :
12593 : 22991 : if (bad)
12594 : 48 : return attrs;
12595 : :
12596 : : unsigned int i;
12597 : : cp_omp_attribute_data *v;
12598 : : cp_omp_attribute_data *construct_seen = nullptr;
12599 : : cp_omp_attribute_data *standalone_seen = nullptr;
12600 : : cp_omp_attribute_data *prev_standalone_seen = nullptr;
12601 : 26798 : FOR_EACH_VEC_ELT (vec, i, v)
12602 : 3855 : if (v->tokens)
12603 : : {
12604 : 2138 : if (v->kind == C_OMP_DIR_CONSTRUCT && !construct_seen)
12605 : : construct_seen = v;
12606 : 1011 : else if (v->kind == C_OMP_DIR_STANDALONE && !standalone_seen)
12607 : 222 : standalone_seen = v;
12608 : : }
12609 : : else
12610 : : {
12611 : 1717 : if (standalone_seen && !prev_standalone_seen)
12612 : : {
12613 : 3855 : prev_standalone_seen = standalone_seen;
12614 : 3855 : standalone_seen = nullptr;
12615 : : }
12616 : : }
12617 : :
12618 : 22943 : if (cnt > 1 && construct_seen)
12619 : : {
12620 : 12 : error_at (construct_seen->tokens->first->location,
12621 : : "OpenMP construct among %<omp::directive%> attributes"
12622 : : " requires all %<omp::directive%> attributes on the"
12623 : : " same statement to be in the same %<omp::sequence%>");
12624 : 12 : return attrs;
12625 : : }
12626 : 22931 : if (cnt > 1 && standalone_seen && prev_standalone_seen)
12627 : : {
12628 : 6 : error_at (standalone_seen->tokens->first->location,
12629 : : "multiple OpenMP standalone directives among"
12630 : : " %<omp::directive%> attributes must be all within the"
12631 : : " same %<omp::sequence%>");
12632 : 6 : return attrs;
12633 : : }
12634 : :
12635 : 22925 : if (prev_standalone_seen)
12636 : : standalone_seen = prev_standalone_seen;
12637 : 22715 : if (standalone_seen
12638 : 22925 : && !cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
12639 : : {
12640 : 6 : error_at (standalone_seen->tokens->first->location,
12641 : : "standalone OpenMP directives in %<omp::directive%> attribute"
12642 : : " can only appear on an empty statement");
12643 : 6 : return attrs;
12644 : : }
12645 : 22919 : if (cnt && cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
12646 : : {
12647 : 12 : cp_token *token = cp_lexer_peek_token (parser->lexer);
12648 : 12 : enum pragma_kind kind = cp_parser_pragma_kind (token);
12649 : 12 : if (kind >= PRAGMA_OMP__START_ && kind <= PRAGMA_OMP__LAST_)
12650 : : {
12651 : 12 : error_at (token->location,
12652 : : "mixing OpenMP directives with attribute and pragma "
12653 : : "syntax on the same statement");
12654 : 12 : return attrs;
12655 : : }
12656 : : }
12657 : :
12658 : 22907 : if (!tokens)
12659 : 21265 : return attrs;
12660 : 1642 : tokens++;
12661 : 1642 : cp_lexer *lexer = cp_lexer_alloc ();
12662 : 1642 : lexer->debugging_p = parser->lexer->debugging_p;
12663 : 1642 : vec_safe_reserve (lexer->buffer, tokens, true);
12664 : 5368 : FOR_EACH_VEC_ELT (vec, i, v)
12665 : : {
12666 : 3726 : if (!v->tokens)
12667 : 1642 : continue;
12668 : 2084 : if (!flag_openmp && !v->dir->simd)
12669 : 0 : continue;
12670 : 2084 : cp_token *first = v->tokens->first;
12671 : 2084 : cp_token *last = v->tokens->last;
12672 : 2084 : cp_token tok = {};
12673 : 2084 : tok.type = CPP_PRAGMA;
12674 : 2084 : tok.keyword = RID_MAX;
12675 : 2084 : tok.u.value = build_int_cst (NULL, v->dir->id);
12676 : 2084 : tok.location = first->location;
12677 : 2084 : lexer->buffer->quick_push (tok);
12678 : 50319 : while (++first < last)
12679 : 46151 : lexer->buffer->quick_push (*first);
12680 : 2084 : tok = {};
12681 : 2084 : tok.type = CPP_PRAGMA_EOL;
12682 : 2084 : tok.keyword = RID_MAX;
12683 : 2084 : tok.location = last->location;
12684 : 2084 : lexer->buffer->quick_push (tok);
12685 : : }
12686 : 1642 : cp_token tok = {};
12687 : 1642 : tok.type = CPP_EOF;
12688 : 1642 : tok.keyword = RID_MAX;
12689 : 1642 : tok.location = lexer->buffer->last ().location;
12690 : 1642 : lexer->buffer->quick_push (tok);
12691 : 1642 : lexer->next = parser->lexer;
12692 : 1642 : lexer->next_token = lexer->buffer->address ();
12693 : 1642 : lexer->last_token = lexer->next_token
12694 : 1642 : + lexer->buffer->length ()
12695 : 1642 : - 1;
12696 : 1642 : lexer->in_omp_attribute_pragma = true;
12697 : 1642 : parser->lexer = lexer;
12698 : : /* Move the current source position to that of the first token in the
12699 : : new lexer. */
12700 : 1642 : cp_lexer_set_source_position_from_token (lexer->next_token);
12701 : 1642 : return attrs;
12702 : 22991 : }
12703 : :
12704 : : /* True if and only if the name is one of the contract types. */
12705 : :
12706 : : static bool
12707 : 12690578 : contract_attribute_p (const_tree id)
12708 : : {
12709 : 12690578 : return is_attribute_p ("assert", id)
12710 : 12690258 : || is_attribute_p ("pre", id)
12711 : 25379698 : || is_attribute_p ("post", id);
12712 : : }
12713 : :
12714 : : /* Handle omp::directive and omp::sequence attributes in *PATTRS
12715 : : (if any) at the start or after declaration-id of a declaration. */
12716 : :
12717 : : static void
12718 : 26479 : cp_parser_handle_directive_omp_attributes (cp_parser *parser, tree *pattrs,
12719 : : cp_omp_declare_simd_data *data,
12720 : : bool start)
12721 : : {
12722 : 26479 : if (!flag_openmp && !flag_openmp_simd)
12723 : : return;
12724 : :
12725 : 26479 : int cnt = 0;
12726 : 26479 : bool bad = false;
12727 : 26479 : bool variant_p = false;
12728 : 26479 : location_t loc = UNKNOWN_LOCATION;
12729 : 64697 : for (tree pa = *pattrs; pa; pa = TREE_CHAIN (pa))
12730 : 38218 : if (get_attribute_namespace (pa) == omp_identifier
12731 : 38218 : && is_attribute_p ("directive", get_attribute_name (pa)))
12732 : : {
12733 : 1006 : for (tree a = TREE_VALUE (pa); a; a = TREE_CHAIN (a))
12734 : : {
12735 : 509 : tree d = TREE_VALUE (a);
12736 : 509 : gcc_assert (TREE_CODE (d) == DEFERRED_PARSE);
12737 : 509 : cp_token *first = DEFPARSE_TOKENS (d)->first;
12738 : 509 : cp_token *last = DEFPARSE_TOKENS (d)->last;
12739 : 509 : const char *directive[3] = {};
12740 : 1504 : for (int i = 0; i < 3; i++)
12741 : : {
12742 : 1394 : tree id = NULL_TREE;
12743 : 1394 : if (first + i == last)
12744 : : break;
12745 : 1213 : if (first[i].type == CPP_NAME)
12746 : 992 : id = first[i].u.value;
12747 : 221 : else if (first[i].type == CPP_KEYWORD)
12748 : 3 : id = ridpointers[(int) first[i].keyword];
12749 : : else
12750 : : break;
12751 : 995 : directive[i] = IDENTIFIER_POINTER (id);
12752 : : }
12753 : 509 : const c_omp_directive *dir = NULL;
12754 : 509 : if (directive[0])
12755 : 509 : dir = c_omp_categorize_directive (directive[0], directive[1],
12756 : : directive[2]);
12757 : 509 : if (dir == NULL)
12758 : 27 : continue;
12759 : 482 : if (dir->id == PRAGMA_OMP_DECLARE
12760 : 331 : && (strcmp (directive[1], "simd") == 0
12761 : 58 : || strcmp (directive[1], "variant") == 0))
12762 : : {
12763 : 303 : if (cnt++ == 0)
12764 : : {
12765 : 243 : variant_p = strcmp (directive[1], "variant") == 0;
12766 : 243 : loc = first->location;
12767 : : }
12768 : 303 : if (start && parser->omp_declare_simd && !bad)
12769 : : {
12770 : 6 : error_at (first->location,
12771 : : "mixing OpenMP directives with attribute and "
12772 : : "pragma syntax on the same declaration");
12773 : 6 : bad = true;
12774 : : }
12775 : : }
12776 : : }
12777 : : }
12778 : :
12779 : 26479 : if (bad)
12780 : : {
12781 : 12 : for (tree *pa = pattrs; *pa; )
12782 : 6 : if (get_attribute_namespace (*pa) == omp_identifier
12783 : 6 : && is_attribute_p ("directive", get_attribute_name (*pa)))
12784 : 6 : *pa = TREE_CHAIN (*pa);
12785 : : else
12786 : 0 : pa = &TREE_CHAIN (*pa);
12787 : : return;
12788 : : }
12789 : 26473 : if (cnt == 0)
12790 : : return;
12791 : :
12792 : 237 : if (parser->omp_declare_simd == NULL)
12793 : : {
12794 : 219 : data->error_seen = false;
12795 : 219 : data->fndecl_seen = false;
12796 : 219 : data->variant_p = variant_p;
12797 : 219 : data->loc = loc;
12798 : 219 : data->tokens = vNULL;
12799 : 219 : data->attribs[0] = NULL;
12800 : 219 : data->attribs[1] = NULL;
12801 : 219 : parser->omp_declare_simd = data;
12802 : : }
12803 : 237 : parser->omp_declare_simd->attribs[!start] = pattrs;
12804 : : }
12805 : :
12806 : : /* Parse a statement.
12807 : :
12808 : : statement:
12809 : : labeled-statement
12810 : : expression-statement
12811 : : compound-statement
12812 : : selection-statement
12813 : : iteration-statement
12814 : : jump-statement
12815 : : declaration-statement
12816 : : try-block
12817 : :
12818 : : C++11:
12819 : :
12820 : : statement:
12821 : : labeled-statement
12822 : : attribute-specifier-seq (opt) expression-statement
12823 : : attribute-specifier-seq (opt) compound-statement
12824 : : attribute-specifier-seq (opt) selection-statement
12825 : : attribute-specifier-seq (opt) iteration-statement
12826 : : attribute-specifier-seq (opt) jump-statement
12827 : : declaration-statement
12828 : : attribute-specifier-seq (opt) try-block
12829 : :
12830 : : init-statement:
12831 : : expression-statement
12832 : : simple-declaration
12833 : : alias-declaration
12834 : :
12835 : : TM Extension:
12836 : :
12837 : : statement:
12838 : : atomic-statement
12839 : :
12840 : : IN_COMPOUND is true when the statement is nested inside a
12841 : : cp_parser_compound_statement.
12842 : :
12843 : : If IF_P is not NULL, *IF_P is set to indicate whether the statement
12844 : : is a (possibly labeled) if statement which is not enclosed in braces
12845 : : and has an else clause. This is used to implement -Wparentheses.
12846 : :
12847 : : CHAIN is a vector of if-else-if conditions.
12848 : :
12849 : : Note that this version of parsing restricts assertions to be attached to
12850 : : empty statements. */
12851 : :
12852 : : static void
12853 : 286722282 : cp_parser_statement (cp_parser* parser, tree in_statement_expr,
12854 : : const bool in_compound, bool *if_p, vec<tree> *chain,
12855 : : location_t *loc_after_labels)
12856 : : {
12857 : 286722282 : tree statement, std_attrs = NULL_TREE;
12858 : 286722282 : cp_token *token;
12859 : 286722282 : location_t statement_location, attrs_loc;
12860 : 286722282 : bool in_omp_attribute_pragma = parser->lexer->in_omp_attribute_pragma;
12861 : 286722282 : bool has_std_attrs;
12862 : : /* A copy of IN_COMPOUND which is set to false after seeing a label.
12863 : : This matters for certain pragmas. */
12864 : 286722282 : bool in_compound_for_pragma = in_compound;
12865 : :
12866 : 288261948 : restart:
12867 : 288261948 : if (if_p != NULL)
12868 : 25948405 : *if_p = false;
12869 : : /* There is no statement yet. */
12870 : 288261948 : statement = NULL_TREE;
12871 : :
12872 : 518769079 : saved_token_sentinel saved_tokens (parser->lexer);
12873 : 288261948 : token = cp_lexer_peek_token (parser->lexer);
12874 : 288261948 : attrs_loc = token->location;
12875 : 288261948 : if (c_dialect_objc ())
12876 : : /* In obj-c++, seeing '[[' might be the either the beginning of
12877 : : c++11 attributes, or a nested objc-message-expression. So
12878 : : let's parse the c++11 attributes tentatively. */
12879 : 0 : cp_parser_parse_tentatively (parser);
12880 : 288261948 : std_attrs = cp_parser_std_attribute_spec_seq (parser);
12881 : 288261948 : if (std_attrs)
12882 : 586131 : attrs_loc = make_location (attrs_loc, attrs_loc, parser->lexer);
12883 : 288261948 : if (c_dialect_objc ())
12884 : : {
12885 : 0 : if (!cp_parser_parse_definitely (parser))
12886 : 0 : std_attrs = NULL_TREE;
12887 : : }
12888 : 288261948 : has_std_attrs = cp_lexer_peek_token (parser->lexer) != token;
12889 : :
12890 : : /* Peek at the next token. */
12891 : 288261948 : token = cp_lexer_peek_token (parser->lexer);
12892 : :
12893 : : /* If we have contracts, check that they're valid in this context. */
12894 : 288261948 : if (std_attrs != error_mark_node)
12895 : : {
12896 : 288261924 : if (tree pre = lookup_attribute ("pre", std_attrs))
12897 : 0 : error_at (EXPR_LOCATION (TREE_VALUE (pre)),
12898 : : "preconditions cannot be statements");
12899 : 288261924 : else if (tree post = lookup_attribute ("post", std_attrs))
12900 : 0 : error_at (EXPR_LOCATION (TREE_VALUE (post)),
12901 : : "postconditions cannot be statements");
12902 : :
12903 : : /* Check that assertions are null statements. */
12904 : 288261924 : if (cp_contract_assertion_p (std_attrs))
12905 : 152 : if (token->type != CPP_SEMICOLON)
12906 : 1 : error_at (token->location, "assertions must be followed by %<;%>");
12907 : : }
12908 : :
12909 : 288261948 : bool omp_attrs_forbidden_p;
12910 : 288261948 : omp_attrs_forbidden_p = parser->omp_attrs_forbidden_p;
12911 : :
12912 : 288261948 : if (std_attrs && (flag_openmp || flag_openmp_simd))
12913 : : {
12914 : 1846 : bool handle_omp_attribs = false;
12915 : 1846 : if (token->type == CPP_KEYWORD)
12916 : 1015 : switch (token->keyword)
12917 : : {
12918 : : case RID_IF:
12919 : : case RID_SWITCH:
12920 : : case RID_WHILE:
12921 : : case RID_DO:
12922 : : case RID_FOR:
12923 : : case RID_BREAK:
12924 : : case RID_CONTINUE:
12925 : : case RID_RETURN:
12926 : : case RID_CO_RETURN:
12927 : : case RID_GOTO:
12928 : : case RID_AT_TRY:
12929 : : case RID_AT_CATCH:
12930 : : case RID_AT_FINALLY:
12931 : : case RID_AT_SYNCHRONIZED:
12932 : : case RID_AT_THROW:
12933 : : case RID_TRY:
12934 : : case RID_TRANSACTION_ATOMIC:
12935 : : case RID_TRANSACTION_RELAXED:
12936 : : case RID_SYNCHRONIZED:
12937 : : case RID_ATOMIC_NOEXCEPT:
12938 : : case RID_ATOMIC_CANCEL:
12939 : : case RID_TRANSACTION_CANCEL:
12940 : : handle_omp_attribs = true;
12941 : : break;
12942 : : default:
12943 : : break;
12944 : : }
12945 : 831 : else if (token->type == CPP_SEMICOLON
12946 : 374 : || token->type == CPP_OPEN_BRACE
12947 : 217 : || token->type == CPP_PRAGMA)
12948 : : handle_omp_attribs = true;
12949 : : if (handle_omp_attribs)
12950 : : {
12951 : 1495 : std_attrs = cp_parser_handle_statement_omp_attributes (parser,
12952 : : std_attrs);
12953 : 1495 : token = cp_lexer_peek_token (parser->lexer);
12954 : : }
12955 : : }
12956 : 288261948 : parser->omp_attrs_forbidden_p = false;
12957 : :
12958 : : /* Remember the location of the first token in the statement. */
12959 : 288261948 : cp_token *statement_token = token;
12960 : 288261948 : statement_location = token->location;
12961 : 288261948 : add_debug_begin_stmt (statement_location);
12962 : : /* If this is a keyword, then that will often determine what kind of
12963 : : statement we have. */
12964 : 288261948 : if (token->type == CPP_KEYWORD)
12965 : : {
12966 : 181471824 : enum rid keyword = token->keyword;
12967 : :
12968 : 181471824 : switch (keyword)
12969 : : {
12970 : 1537900 : case RID_CASE:
12971 : 1537900 : case RID_DEFAULT:
12972 : : /* Looks like a labeled-statement with a case label.
12973 : : Parse the label, and then use tail recursion to parse
12974 : : the statement. */
12975 : 1537900 : cp_parser_label_for_labeled_statement (parser, std_attrs);
12976 : 1537900 : in_compound_for_pragma = false;
12977 : 1537900 : in_omp_attribute_pragma = parser->lexer->in_omp_attribute_pragma;
12978 : 1539666 : goto restart;
12979 : :
12980 : 38285912 : case RID_IF:
12981 : 38285912 : case RID_SWITCH:
12982 : 38285912 : std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc);
12983 : 38285912 : statement = cp_parser_selection_statement (parser, if_p, chain);
12984 : 38285912 : break;
12985 : :
12986 : 12486989 : case RID_WHILE:
12987 : 12486989 : case RID_DO:
12988 : 12486989 : case RID_FOR:
12989 : 12486989 : std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc);
12990 : 12486989 : statement = cp_parser_iteration_statement (parser, if_p, false,
12991 : : NULL_TREE, false);
12992 : 12486989 : break;
12993 : :
12994 : 83730308 : case RID_BREAK:
12995 : 83730308 : case RID_CONTINUE:
12996 : 83730308 : case RID_RETURN:
12997 : 83730308 : case RID_CO_RETURN:
12998 : 83730308 : case RID_GOTO:
12999 : 83730308 : std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc);
13000 : 83730308 : statement = cp_parser_jump_statement (parser, std_attrs);
13001 : 83730308 : break;
13002 : :
13003 : : /* Objective-C++ exception-handling constructs. */
13004 : 0 : case RID_AT_TRY:
13005 : 0 : case RID_AT_CATCH:
13006 : 0 : case RID_AT_FINALLY:
13007 : 0 : case RID_AT_SYNCHRONIZED:
13008 : 0 : case RID_AT_THROW:
13009 : 0 : std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc);
13010 : 0 : statement = cp_parser_objc_statement (parser);
13011 : 0 : break;
13012 : :
13013 : 983533 : case RID_TRY:
13014 : 983533 : std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc);
13015 : 983533 : statement = cp_parser_try_block (parser);
13016 : 983533 : break;
13017 : :
13018 : 102180 : case RID_NAMESPACE:
13019 : : /* This must be a namespace alias definition. */
13020 : 102180 : if (has_std_attrs)
13021 : : {
13022 : : /* Attributes should be parsed as part of the
13023 : : declaration, so let's un-parse them. */
13024 : 9 : saved_tokens.rollback();
13025 : 9 : std_attrs = NULL_TREE;
13026 : : }
13027 : 102180 : cp_parser_declaration_statement (parser);
13028 : 56317307 : return;
13029 : :
13030 : 235 : case RID_TRANSACTION_ATOMIC:
13031 : 235 : case RID_TRANSACTION_RELAXED:
13032 : 235 : case RID_SYNCHRONIZED:
13033 : 235 : case RID_ATOMIC_NOEXCEPT:
13034 : 235 : case RID_ATOMIC_CANCEL:
13035 : 235 : std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc);
13036 : 235 : statement = cp_parser_transaction (parser, token);
13037 : 235 : break;
13038 : 12 : case RID_TRANSACTION_CANCEL:
13039 : 12 : std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc);
13040 : 12 : statement = cp_parser_transaction_cancel (parser);
13041 : 12 : break;
13042 : :
13043 : : default:
13044 : : /* It might be a keyword like `int' that can start a
13045 : : declaration-statement. */
13046 : : break;
13047 : : }
13048 : : }
13049 : : else if (token->type == CPP_NAME)
13050 : : {
13051 : : /* If the next token is a `:', then we are looking at a
13052 : : labeled-statement. */
13053 : 91591947 : token = cp_lexer_peek_nth_token (parser->lexer, 2);
13054 : 91591947 : if (token->type == CPP_COLON)
13055 : : {
13056 : : /* Looks like a labeled-statement with an ordinary label.
13057 : : Parse the label, and then use tail recursion to parse
13058 : : the statement. */
13059 : :
13060 : 1660 : cp_parser_label_for_labeled_statement (parser, std_attrs);
13061 : :
13062 : : /* If there's no statement, it's not a labeled-statement, just
13063 : : a label. That's allowed in C++23, but only if we're at the
13064 : : end of a compound-statement. */
13065 : 1660 : if (in_compound
13066 : 1660 : && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
13067 : : {
13068 : 29 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
13069 : 29 : if (cxx_dialect < cxx23)
13070 : 29 : pedwarn (loc, OPT_Wc__23_extensions,
13071 : : "label at end of compound statement only available "
13072 : : "with %<-std=c++2b%> or %<-std=gnu++2b%>");
13073 : 29 : return;
13074 : : }
13075 : 1631 : in_compound_for_pragma = false;
13076 : 1631 : in_omp_attribute_pragma = parser->lexer->in_omp_attribute_pragma;
13077 : 1631 : goto restart;
13078 : : }
13079 : : }
13080 : : /* Anything that starts with a `{' must be a compound-statement. */
13081 : : else if (token->type == CPP_OPEN_BRACE)
13082 : : {
13083 : 393256 : std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc);
13084 : 393256 : statement = cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
13085 : : }
13086 : : /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
13087 : : a statement all its own. */
13088 : : else if (token->type == CPP_PRAGMA)
13089 : : {
13090 : 399455 : do_pragma:;
13091 : 399455 : cp_lexer *lexer = parser->lexer;
13092 : 399455 : bool do_restart = false;
13093 : : /* Only certain OpenMP pragmas are attached to statements, and thus
13094 : : are considered statements themselves. All others are not. In
13095 : : the context of a compound, accept the pragma as a "statement" and
13096 : : return so that we can check for a close brace. Otherwise we
13097 : : require a real statement and must go back and read one. */
13098 : 399455 : if (in_compound_for_pragma)
13099 : : {
13100 : 395075 : if (cp_parser_pragma (parser, pragma_compound, if_p)
13101 : 395075 : && parser->omp_for_parse_state)
13102 : 6 : check_omp_intervening_code (parser);
13103 : : }
13104 : 4380 : else if (!cp_parser_pragma (parser, pragma_stmt, if_p))
13105 : : do_restart = true;
13106 : 4245 : else if (parser->omp_for_parse_state)
13107 : 3 : check_omp_intervening_code (parser);
13108 : 399455 : if (parser->lexer != lexer
13109 : 1412 : && lexer->in_omp_attribute_pragma
13110 : 1412 : && (!in_omp_attribute_pragma || lexer->orphan_p))
13111 : : {
13112 : 1286 : if (saved_tokens.lexer == lexer)
13113 : : {
13114 : 18 : if (saved_tokens.mode == STS_COMMIT)
13115 : 18 : cp_lexer_commit_tokens (lexer);
13116 : 36 : gcc_assert (lexer->saved_tokens.length () == saved_tokens.len);
13117 : 18 : saved_tokens.lexer = parser->lexer;
13118 : 18 : saved_tokens.mode = STS_DONOTHING;
13119 : 36 : saved_tokens.len = parser->lexer->saved_tokens.length ();
13120 : : }
13121 : 1286 : cp_lexer_destroy (lexer);
13122 : 1286 : lexer = parser->lexer;
13123 : : }
13124 : 399455 : if (do_restart)
13125 : 135 : goto restart;
13126 : 399320 : if (parser->lexer == lexer
13127 : 399197 : && lexer->in_omp_attribute_pragma
13128 : 15 : && !in_omp_attribute_pragma)
13129 : 15 : parser->lexer->orphan_p = true;
13130 : 399320 : return;
13131 : : }
13132 : : else if (token->type == CPP_EOF)
13133 : : {
13134 : 6 : cp_parser_error (parser, "expected statement");
13135 : 6 : return;
13136 : : }
13137 : :
13138 : : /* Everything else must be a declaration-statement or an
13139 : : expression-statement. Try for the declaration-statement
13140 : : first, unless we are looking at a `;', in which case we know that
13141 : : we have an expression-statement. */
13142 : 135880242 : if (!statement)
13143 : : {
13144 : 150340568 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
13145 : : {
13146 : 145709975 : if (has_std_attrs)
13147 : : /* Attributes should be parsed as part of the declaration,
13148 : : so let's un-parse them. */
13149 : 243197 : saved_tokens.rollback();
13150 : :
13151 : 145709975 : parser->omp_attrs_forbidden_p = omp_attrs_forbidden_p;
13152 : 145709975 : cp_parser_parse_tentatively (parser);
13153 : : /* Try to parse the declaration-statement. */
13154 : 145709975 : cp_parser_declaration_statement (parser);
13155 : 145709972 : parser->omp_attrs_forbidden_p = false;
13156 : : /* If that worked, we're done. */
13157 : 145709972 : if (cp_parser_parse_definitely (parser))
13158 : : return;
13159 : : /* It didn't work, restore the post-attribute position. */
13160 : 89996380 : if (has_std_attrs)
13161 : : {
13162 : 177301 : cp_lexer_set_token_position (parser->lexer, statement_token);
13163 : 177301 : if (flag_openmp || flag_openmp_simd)
13164 : : {
13165 : : size_t i = 1;
13166 : 220 : bool handle_omp_attribs = true;
13167 : 440 : while (cp_lexer_peek_nth_token (parser->lexer, i)->keyword
13168 : 220 : == RID_EXTENSION)
13169 : 3 : i++;
13170 : 217 : switch (cp_lexer_peek_nth_token (parser->lexer, i)->keyword)
13171 : : {
13172 : : case RID_ASM:
13173 : : case RID_NAMESPACE:
13174 : : case RID_USING:
13175 : : case RID_LABEL:
13176 : : case RID_STATIC_ASSERT:
13177 : : /* Don't handle OpenMP attribs on keywords that
13178 : : always start a declaration statement but don't
13179 : : accept attribute before it and therefore
13180 : : the tentative cp_parser_declaration_statement
13181 : : fails to parse because of that. */
13182 : : handle_omp_attribs = false;
13183 : : break;
13184 : : default:
13185 : : break;
13186 : : }
13187 : :
13188 : 205 : if (handle_omp_attribs)
13189 : : {
13190 : 205 : parser->omp_attrs_forbidden_p = omp_attrs_forbidden_p;
13191 : 205 : std_attrs
13192 : 205 : = cp_parser_handle_statement_omp_attributes
13193 : 205 : (parser, std_attrs);
13194 : 205 : parser->omp_attrs_forbidden_p = false;
13195 : 205 : token = cp_lexer_peek_token (parser->lexer);
13196 : 205 : if (token->type == CPP_PRAGMA)
13197 : 66 : goto do_pragma;
13198 : : }
13199 : : }
13200 : : }
13201 : : }
13202 : : /* All preceding labels have been parsed at this point. */
13203 : 94626907 : if (loc_after_labels != NULL)
13204 : 21737207 : *loc_after_labels = statement_location;
13205 : :
13206 : 94626907 : std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc);
13207 : :
13208 : : /* Look for an expression-statement instead. */
13209 : 94626907 : statement = cp_parser_expression_statement (parser, in_statement_expr);
13210 : :
13211 : 94626889 : std_attrs = process_stmt_assume_attribute (std_attrs, statement,
13212 : : attrs_loc);
13213 : :
13214 : : /* Handle [[fallthrough]];. */
13215 : 94626889 : if (attribute_fallthrough_p (std_attrs))
13216 : : {
13217 : : /* The next token after the fallthrough attribute is ';'. */
13218 : 15429 : if (statement == NULL_TREE)
13219 : : {
13220 : : /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
13221 : 15429 : statement = build_call_expr_internal_loc (statement_location,
13222 : : IFN_FALLTHROUGH,
13223 : : void_type_node, 0);
13224 : 15429 : finish_expr_stmt (statement);
13225 : : }
13226 : : else
13227 : 0 : warning_at (statement_location, OPT_Wattributes,
13228 : : "%<fallthrough%> attribute not followed by %<;%>");
13229 : 15429 : std_attrs = NULL_TREE;
13230 : : }
13231 : :
13232 : : /* Handle [[assert: ...]]; */
13233 : 94626889 : if (cp_contract_assertion_p (std_attrs))
13234 : : {
13235 : : /* Add the assertion as a statement in the current block. */
13236 : 152 : if (!statement)
13237 : 151 : emit_assertion (std_attrs);
13238 : : /* We already checked that the contract assertion is followed by
13239 : : a semicolon. */
13240 : 151 : std_attrs = NULL_TREE;
13241 : : }
13242 : : }
13243 : :
13244 : : /* Set the line number for the statement. */
13245 : 230507131 : if (statement && STATEMENT_CODE_P (TREE_CODE (statement)))
13246 : 136424672 : SET_EXPR_LOCATION (statement, statement_location);
13247 : :
13248 : : /* Allow "[[fallthrough]];" or "[[assume(cond)]];", but warn otherwise. */
13249 : 230507131 : if (std_attrs != NULL_TREE && any_nonignored_attribute_p (std_attrs))
13250 : 225 : warning_at (attrs_loc, OPT_Wattributes,
13251 : : "attributes at the beginning of statement are ignored");
13252 : : }
13253 : :
13254 : : /* Append ATTR to attribute list ATTRS. */
13255 : :
13256 : : tree
13257 : 537242481 : attr_chainon (tree attrs, tree attr)
13258 : : {
13259 : 537242481 : if (attrs == error_mark_node)
13260 : : return error_mark_node;
13261 : 537242466 : if (attr == error_mark_node)
13262 : : return error_mark_node;
13263 : 537242390 : return chainon (attrs, attr);
13264 : : }
13265 : :
13266 : : /* Parse the label for a labeled-statement, i.e.
13267 : :
13268 : : label:
13269 : : attribute-specifier-seq[opt] identifier :
13270 : : attribute-specifier-seq[opt] case constant-expression :
13271 : : attribute-specifier-seq[opt] default :
13272 : :
13273 : : labeled-statement:
13274 : : label statement
13275 : :
13276 : : GNU Extension:
13277 : : case constant-expression ... constant-expression : statement
13278 : :
13279 : : When a label is parsed without errors, the label is added to the
13280 : : parse tree by the finish_* functions, so this function doesn't
13281 : : have to return the label. */
13282 : :
13283 : : static void
13284 : 1539560 : cp_parser_label_for_labeled_statement (cp_parser* parser, tree attributes)
13285 : : {
13286 : 1539560 : cp_token *token;
13287 : 1539560 : tree label = NULL_TREE;
13288 : 1539560 : bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
13289 : :
13290 : : /* The next token should be an identifier. */
13291 : 1539560 : token = cp_lexer_peek_token (parser->lexer);
13292 : 1539560 : if (token->type != CPP_NAME
13293 : 1537900 : && token->type != CPP_KEYWORD)
13294 : : {
13295 : 0 : cp_parser_error (parser, "expected labeled-statement");
13296 : 0 : return;
13297 : : }
13298 : :
13299 : : /* Remember whether this case or a user-defined label is allowed to fall
13300 : : through to. */
13301 : 1539560 : bool fallthrough_p = token->flags & PREV_FALLTHROUGH;
13302 : :
13303 : 1539560 : parser->colon_corrects_to_scope_p = false;
13304 : 1539560 : switch (token->keyword)
13305 : : {
13306 : 1436333 : case RID_CASE:
13307 : 1436333 : {
13308 : 1436333 : tree expr, expr_hi;
13309 : 1436333 : cp_token *ellipsis;
13310 : :
13311 : : /* Consume the `case' token. */
13312 : 1436333 : cp_lexer_consume_token (parser->lexer);
13313 : : /* Parse the constant-expression. */
13314 : 1436333 : expr = cp_parser_constant_expression (parser);
13315 : 1436333 : if (check_for_bare_parameter_packs (expr))
13316 : 3 : expr = error_mark_node;
13317 : :
13318 : 1436333 : ellipsis = cp_lexer_peek_token (parser->lexer);
13319 : 1436333 : if (ellipsis->type == CPP_ELLIPSIS)
13320 : : {
13321 : : /* Consume the `...' token. */
13322 : 126 : cp_lexer_consume_token (parser->lexer);
13323 : 126 : expr_hi = cp_parser_constant_expression (parser);
13324 : 126 : if (check_for_bare_parameter_packs (expr_hi))
13325 : 3 : expr_hi = error_mark_node;
13326 : :
13327 : : /* We don't need to emit warnings here, as the common code
13328 : : will do this for us. */
13329 : : }
13330 : : else
13331 : : expr_hi = NULL_TREE;
13332 : :
13333 : 1436333 : if (parser->in_switch_statement_p)
13334 : : {
13335 : 1436327 : tree l = finish_case_label (token->location, expr, expr_hi);
13336 : 1436327 : if (l && TREE_CODE (l) == CASE_LABEL_EXPR)
13337 : : {
13338 : 1436161 : label = CASE_LABEL (l);
13339 : 1436161 : FALLTHROUGH_LABEL_P (label) = fallthrough_p;
13340 : : }
13341 : : }
13342 : : else
13343 : 6 : error_at (token->location,
13344 : : "case label %qE not within a switch statement",
13345 : : expr);
13346 : : }
13347 : : break;
13348 : :
13349 : 101567 : case RID_DEFAULT:
13350 : : /* Consume the `default' token. */
13351 : 101567 : cp_lexer_consume_token (parser->lexer);
13352 : :
13353 : 101567 : if (parser->in_switch_statement_p)
13354 : : {
13355 : 101567 : tree l = finish_case_label (token->location, NULL_TREE, NULL_TREE);
13356 : 101567 : if (l && TREE_CODE (l) == CASE_LABEL_EXPR)
13357 : : {
13358 : 101531 : label = CASE_LABEL (l);
13359 : 101531 : FALLTHROUGH_LABEL_P (label) = fallthrough_p;
13360 : : }
13361 : : }
13362 : : else
13363 : 0 : error_at (token->location, "case label not within a switch statement");
13364 : : break;
13365 : :
13366 : 1660 : default:
13367 : : /* Anything else must be an ordinary label. */
13368 : 1660 : label = finish_label_stmt (cp_parser_identifier (parser));
13369 : 1660 : if (label && TREE_CODE (label) == LABEL_DECL)
13370 : : {
13371 : 1654 : FALLTHROUGH_LABEL_P (label) = fallthrough_p;
13372 : 1654 : if (!warning_enabled_at (input_location, OPT_Wunused_label))
13373 : 1526 : suppress_warning (label, OPT_Wunused_label);
13374 : : }
13375 : : break;
13376 : : }
13377 : :
13378 : : /* Require the `:' token. */
13379 : 1539560 : cp_parser_require (parser, CPP_COLON, RT_COLON);
13380 : :
13381 : : /* An ordinary label may optionally be followed by attributes.
13382 : : However, this is only permitted if the attributes are then
13383 : : followed by a semicolon. This is because, for backward
13384 : : compatibility, when parsing
13385 : : lab: __attribute__ ((unused)) int i;
13386 : : we want the attribute to attach to "i", not "lab". */
13387 : 1539560 : if (label != NULL_TREE
13388 : 1539560 : && cp_next_tokens_can_be_gnu_attribute_p (parser))
13389 : : {
13390 : 55 : tree attrs;
13391 : 55 : cp_parser_parse_tentatively (parser);
13392 : 55 : attrs = cp_parser_gnu_attributes_opt (parser);
13393 : 55 : if (attrs == NULL_TREE
13394 : : /* And fallthrough always binds to the expression-statement. */
13395 : 55 : || attribute_fallthrough_p (attrs)
13396 : 98 : || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
13397 : 18 : cp_parser_abort_tentative_parse (parser);
13398 : 37 : else if (!cp_parser_parse_definitely (parser))
13399 : : ;
13400 : : else
13401 : 37 : attributes = attr_chainon (attributes, attrs);
13402 : : }
13403 : :
13404 : 1539560 : if (attributes != NULL_TREE)
13405 : 169 : cplus_decl_attributes (&label, attributes, 0);
13406 : :
13407 : 1539560 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
13408 : : }
13409 : :
13410 : : /* Parse an expression-statement.
13411 : :
13412 : : expression-statement:
13413 : : expression [opt] ;
13414 : :
13415 : : Returns the new EXPR_STMT -- or NULL_TREE if the expression
13416 : : statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
13417 : : indicates whether this expression-statement is part of an
13418 : : expression statement. */
13419 : :
13420 : : static tree
13421 : 96466897 : cp_parser_expression_statement (cp_parser* parser, tree in_statement_expr)
13422 : : {
13423 : 96466897 : tree statement = NULL_TREE;
13424 : 96466897 : cp_token *token = cp_lexer_peek_token (parser->lexer);
13425 : 96466897 : location_t loc = token->location;
13426 : :
13427 : : /* There might be attribute fallthrough. */
13428 : 96466897 : tree attr = cp_parser_gnu_attributes_opt (parser);
13429 : :
13430 : : /* If the next token is a ';', then there is no expression
13431 : : statement. */
13432 : 96466897 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
13433 : : {
13434 : 90294597 : statement = cp_parser_expression (parser);
13435 : 90294582 : if (statement == error_mark_node
13436 : 90294582 : && !cp_parser_uncommitted_to_tentative_parse_p (parser))
13437 : : {
13438 : : /* If we ran into a problem, make sure we complained. */
13439 : 10280 : gcc_assert (seen_error ());
13440 : :
13441 : 10280 : cp_parser_skip_to_end_of_block_or_statement (parser);
13442 : 10280 : return error_mark_node;
13443 : : }
13444 : : }
13445 : :
13446 : 96456602 : attr = process_stmt_assume_attribute (attr, statement, loc);
13447 : :
13448 : : /* Handle [[fallthrough]];. */
13449 : 96456602 : if (attribute_fallthrough_p (attr))
13450 : : {
13451 : : /* The next token after the fallthrough attribute is ';'. */
13452 : 181 : if (statement == NULL_TREE)
13453 : : /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
13454 : 178 : statement = build_call_expr_internal_loc (loc, IFN_FALLTHROUGH,
13455 : : void_type_node, 0);
13456 : : else
13457 : 3 : warning_at (loc, OPT_Wattributes,
13458 : : "%<fallthrough%> attribute not followed by %<;%>");
13459 : : attr = NULL_TREE;
13460 : : }
13461 : :
13462 : : /* Allow "[[fallthrough]];", but warn otherwise. */
13463 : 96456421 : if (attr != NULL_TREE && any_nonignored_attribute_p (attr))
13464 : 9 : warning_at (loc, OPT_Wattributes,
13465 : : "attributes at the beginning of statement are ignored");
13466 : :
13467 : : /* Give a helpful message for "A<T>::type t;" and the like. */
13468 : 96456602 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
13469 : 96456602 : && !cp_parser_uncommitted_to_tentative_parse_p (parser))
13470 : : {
13471 : 111 : bool has_errored = true;
13472 : 111 : if (TREE_CODE (statement) == SCOPE_REF)
13473 : 54 : error_at (token->location, "need %<typename%> before %qE because "
13474 : : "%qT is a dependent scope",
13475 : 27 : statement, TREE_OPERAND (statement, 0));
13476 : 84 : else if (is_overloaded_fn (statement)
13477 : 93 : && DECL_CONSTRUCTOR_P (get_first_fn (statement)))
13478 : : /* A::A a; */
13479 : 6 : error_at (token->location, "%qE names the constructor, not the type",
13480 : : get_first_fn (statement));
13481 : : else
13482 : : has_errored = false;
13483 : 33 : if (has_errored)
13484 : : {
13485 : 33 : cp_parser_skip_to_end_of_statement (parser);
13486 : 33 : return error_mark_node;
13487 : : }
13488 : : }
13489 : :
13490 : : /* Consume the final `;'. */
13491 : 96456569 : cp_parser_consume_semicolon_at_end_of_statement (parser);
13492 : :
13493 : 96456569 : if (in_statement_expr
13494 : 96456569 : && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
13495 : : /* This is the final expression statement of a statement
13496 : : expression. */
13497 : 15328 : statement = finish_stmt_expr_expr (statement, in_statement_expr);
13498 : 96441241 : else if (statement)
13499 : 90269134 : statement = finish_expr_stmt (statement);
13500 : :
13501 : : return statement;
13502 : : }
13503 : :
13504 : : /* Parse a compound-statement.
13505 : :
13506 : : compound-statement:
13507 : : { statement-seq [opt] label-seq [opt] }
13508 : :
13509 : : label-seq:
13510 : : label
13511 : : label-seq label
13512 : :
13513 : : GNU extension:
13514 : :
13515 : : compound-statement:
13516 : : { label-declaration-seq [opt] statement-seq [opt] }
13517 : :
13518 : : label-declaration-seq:
13519 : : label-declaration
13520 : : label-declaration-seq label-declaration
13521 : :
13522 : : Returns a tree representing the statement. */
13523 : :
13524 : : static tree
13525 : 124234220 : cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
13526 : : int bcs_flags, bool function_body)
13527 : : {
13528 : 124234220 : tree compound_stmt;
13529 : 124234220 : matching_braces braces;
13530 : :
13531 : : /* Consume the `{'. */
13532 : 124234220 : if (!braces.require_open (parser))
13533 : 59 : return error_mark_node;
13534 : 124234161 : if (DECL_DECLARED_CONSTEXPR_P (current_function_decl)
13535 : 124234161 : && !function_body && cxx_dialect < cxx14)
13536 : 35 : pedwarn (input_location, OPT_Wpedantic,
13537 : : "compound-statement in %<constexpr%> function");
13538 : : /* Begin the compound-statement. */
13539 : 124234161 : compound_stmt = begin_compound_stmt (bcs_flags);
13540 : : /* If the next keyword is `__label__' we have a label declaration. */
13541 : 248468409 : while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
13542 : 87 : cp_parser_label_declaration (parser);
13543 : : /* Parse an (optional) statement-seq. */
13544 : 124234161 : cp_parser_statement_seq_opt (parser, in_statement_expr);
13545 : :
13546 : : /* Consume the `}'. */
13547 : 124234137 : braces.require_close (parser);
13548 : :
13549 : : /* Finish the compound-statement. */
13550 : 124234137 : finish_compound_stmt (compound_stmt);
13551 : :
13552 : 124234137 : return compound_stmt;
13553 : : }
13554 : :
13555 : : /* Diagnose errors related to imperfectly nested loops in an OMP
13556 : : loop construct. This function is called when such code is seen.
13557 : : Only issue one such diagnostic no matter how much invalid
13558 : : intervening code there is in the loop.
13559 : : FIXME: maybe the location associated with the diagnostic should
13560 : : be the current parser token instead of the location of the outer loop
13561 : : nest. */
13562 : :
13563 : : static void
13564 : 826 : check_omp_intervening_code (cp_parser *parser)
13565 : : {
13566 : 826 : struct omp_for_parse_data *omp_for_parse_state
13567 : : = parser->omp_for_parse_state;
13568 : 826 : gcc_assert (omp_for_parse_state);
13569 : :
13570 : 826 : if (!omp_for_parse_state->in_intervening_code)
13571 : : return;
13572 : 738 : omp_for_parse_state->saw_intervening_code = true;
13573 : :
13574 : : /* Only diagnose errors related to perfect nesting once. */
13575 : 738 : if (!omp_for_parse_state->perfect_nesting_fail)
13576 : : {
13577 : 687 : if (omp_for_parse_state->code == OACC_LOOP)
13578 : : {
13579 : 0 : error_at (omp_for_parse_state->for_loc,
13580 : : "inner loops must be perfectly nested in "
13581 : : "%<#pragma acc loop%>");
13582 : 0 : omp_for_parse_state->perfect_nesting_fail = true;
13583 : : }
13584 : 687 : else if (omp_for_parse_state->ordered)
13585 : : {
13586 : 36 : error_at (omp_for_parse_state->for_loc,
13587 : : "inner loops must be perfectly nested with "
13588 : : "%<ordered%> clause");
13589 : 36 : omp_for_parse_state->perfect_nesting_fail = true;
13590 : : }
13591 : 651 : else if (omp_for_parse_state->inscan)
13592 : : {
13593 : 9 : error_at (omp_for_parse_state->for_loc,
13594 : : "inner loops must be perfectly nested with "
13595 : : "%<reduction%> %<inscan%> clause");
13596 : 9 : omp_for_parse_state->perfect_nesting_fail = true;
13597 : : }
13598 : 642 : else if (omp_for_parse_state->code == OMP_TILE)
13599 : : {
13600 : 25 : error_at (omp_for_parse_state->for_loc,
13601 : : "inner loops must be perfectly nested "
13602 : : "with %<tile%> directive");
13603 : 25 : omp_for_parse_state->perfect_nesting_fail = true;
13604 : : }
13605 : 687 : if (omp_for_parse_state->perfect_nesting_fail)
13606 : 70 : omp_for_parse_state->fail = true;
13607 : : }
13608 : : }
13609 : :
13610 : : /* Parse an (optional) statement-seq.
13611 : :
13612 : : statement-seq:
13613 : : statement
13614 : : statement-seq [opt] statement */
13615 : :
13616 : : static void
13617 : 128453590 : cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr)
13618 : : {
13619 : 128453590 : struct omp_for_parse_data *omp_for_parse_state
13620 : : = parser->omp_for_parse_state;
13621 : 128453590 : bool in_omp_loop_block
13622 : 128453590 : = omp_for_parse_state ? omp_for_parse_state->want_nested_loop : false;
13623 : :
13624 : : /* Scan statements until there aren't any more. */
13625 : 374925791 : while (true)
13626 : : {
13627 : 374925791 : cp_token *token = cp_lexer_peek_token (parser->lexer);
13628 : :
13629 : : /* If we are looking at a `}', then we have run out of
13630 : : statements; the same is true if we have reached the end
13631 : : of file, or have stumbled upon a stray '@end'. */
13632 : 374925791 : if (token->type == CPP_CLOSE_BRACE
13633 : 246472267 : || token->type == CPP_EOF
13634 : 246472228 : || token->type == CPP_PRAGMA_EOL
13635 : 246472228 : || (token->type == CPP_KEYWORD && token->keyword == RID_AT_END))
13636 : : break;
13637 : :
13638 : : /* If we are in a compound statement and find 'else' then
13639 : : something went wrong. */
13640 : 246472228 : else if (token->type == CPP_KEYWORD && token->keyword == RID_ELSE)
13641 : : {
13642 : 6 : if (parser->in_statement & IN_IF_STMT)
13643 : : break;
13644 : : else
13645 : : {
13646 : 3 : token = cp_lexer_consume_token (parser->lexer);
13647 : 3 : error_at (token->location, "%<else%> without a previous %<if%>");
13648 : : }
13649 : : }
13650 : :
13651 : : /* Handle special cases for OMP FOR canonical loop syntax. */
13652 : 246472222 : else if (in_omp_loop_block)
13653 : : {
13654 : 1252 : bool want_nested_loop = omp_for_parse_state->want_nested_loop;
13655 : 1252 : tree_code code = omp_for_parse_state->code;
13656 : 1252 : if (want_nested_loop
13657 : 1252 : && cp_parser_next_tokens_can_be_canon_loop (parser, code, false))
13658 : : {
13659 : : /* Found the nested loop. */
13660 : 357 : omp_for_parse_state->depth++;
13661 : 357 : add_stmt (cp_parser_omp_loop_nest (parser, NULL));
13662 : 357 : omp_for_parse_state->depth--;
13663 : : }
13664 : 895 : else if (token->type == CPP_SEMICOLON)
13665 : : {
13666 : : /* Prior to implementing the OpenMP 5.1 syntax for canonical
13667 : : loop form, GCC used to accept an empty statements as not
13668 : : being intervening code. Continue to do that, as an
13669 : : extension. */
13670 : : /* FIXME: Maybe issue a warning or something here? */
13671 : 18 : cp_lexer_consume_token (parser->lexer);
13672 : : }
13673 : 877 : else if (want_nested_loop && token->type == CPP_OPEN_BRACE)
13674 : : /* The nested compound statement may contain the next loop, or
13675 : : it might just be intervening code. */
13676 : : {
13677 : 63 : cp_parser_statement (parser, in_statement_expr, true, NULL);
13678 : 63 : if (omp_for_parse_state->want_nested_loop)
13679 : 27 : check_omp_intervening_code (parser);
13680 : : }
13681 : : else
13682 : : {
13683 : : /* This must be intervening code. */
13684 : 814 : omp_for_parse_state->want_nested_loop = false;
13685 : : /* Defer calling check_omp_intervening_code on pragmas until
13686 : : cp_parser_statement, because we can't know until we parse
13687 : : it whether or not the pragma is a statement. */
13688 : 814 : if (token->type != CPP_PRAGMA)
13689 : 790 : check_omp_intervening_code (parser);
13690 : 814 : cp_parser_statement (parser, in_statement_expr, true, NULL);
13691 : 814 : omp_for_parse_state->want_nested_loop = want_nested_loop;
13692 : : }
13693 : 1252 : continue;
13694 : 1252 : }
13695 : :
13696 : : /* Parse the statement. */
13697 : 246470973 : cp_parser_statement (parser, in_statement_expr, true, NULL);
13698 : : }
13699 : 128453566 : }
13700 : :
13701 : : /* Return true if this is the C++20 version of range-based-for with
13702 : : init-statement. */
13703 : :
13704 : : static bool
13705 : 5390761 : cp_parser_range_based_for_with_init_p (cp_parser *parser)
13706 : : {
13707 : 5390761 : bool r = false;
13708 : :
13709 : : /* Save tokens so that we can put them back. */
13710 : 5390761 : cp_lexer_save_tokens (parser->lexer);
13711 : :
13712 : : /* There has to be an unnested ; followed by an unnested :. */
13713 : 5390761 : if (cp_parser_skip_to_closing_parenthesis_1 (parser,
13714 : : /*recovering=*/false,
13715 : : CPP_SEMICOLON,
13716 : : /*consume_paren=*/false) != -1)
13717 : 208507 : goto out;
13718 : :
13719 : : /* We found the semicolon, eat it now. */
13720 : 5182254 : cp_lexer_consume_token (parser->lexer);
13721 : :
13722 : : /* Now look for ':' that is not nested in () or {}. */
13723 : 5182254 : r = (cp_parser_skip_to_closing_parenthesis_1 (parser,
13724 : : /*recovering=*/false,
13725 : : CPP_COLON,
13726 : : /*consume_paren=*/false) == -1);
13727 : :
13728 : 5390761 : out:
13729 : : /* Roll back the tokens we skipped. */
13730 : 5390761 : cp_lexer_rollback_tokens (parser->lexer);
13731 : :
13732 : 5390761 : return r;
13733 : : }
13734 : :
13735 : : /* Return true if we're looking at (init; cond), false otherwise. */
13736 : :
13737 : : static bool
13738 : 38276017 : cp_parser_init_statement_p (cp_parser *parser)
13739 : : {
13740 : : /* Save tokens so that we can put them back. */
13741 : 38276017 : cp_lexer_save_tokens (parser->lexer);
13742 : :
13743 : : /* Look for ';' that is not nested in () or {}. */
13744 : 38276017 : int ret = cp_parser_skip_to_closing_parenthesis_1 (parser,
13745 : : /*recovering=*/false,
13746 : : CPP_SEMICOLON,
13747 : : /*consume_paren=*/false);
13748 : :
13749 : : /* Roll back the tokens we skipped. */
13750 : 38276017 : cp_lexer_rollback_tokens (parser->lexer);
13751 : :
13752 : 38276017 : return ret == -1;
13753 : : }
13754 : :
13755 : : /* Parse a selection-statement.
13756 : :
13757 : : selection-statement:
13758 : : if ( init-statement [opt] condition ) statement
13759 : : if ( init-statement [opt] condition ) statement else statement
13760 : : switch ( init-statement [opt] condition ) statement
13761 : :
13762 : : Returns the new IF_STMT or SWITCH_STMT.
13763 : :
13764 : : If IF_P is not NULL, *IF_P is set to indicate whether the statement
13765 : : is a (possibly labeled) if statement which is not enclosed in
13766 : : braces and has an else clause. This is used to implement
13767 : : -Wparentheses.
13768 : :
13769 : : CHAIN is a vector of if-else-if conditions. This is used to implement
13770 : : -Wduplicated-cond. */
13771 : :
13772 : : static tree
13773 : 38285912 : cp_parser_selection_statement (cp_parser* parser, bool *if_p,
13774 : : vec<tree> *chain)
13775 : : {
13776 : 38285912 : cp_token *token;
13777 : 38285912 : enum rid keyword;
13778 : 38285912 : token_indent_info guard_tinfo;
13779 : :
13780 : 38285912 : if (if_p != NULL)
13781 : 534264 : *if_p = false;
13782 : :
13783 : : /* Peek at the next token. */
13784 : 38285912 : token = cp_parser_require (parser, CPP_KEYWORD, RT_SELECT);
13785 : 38285912 : guard_tinfo = get_token_indent_info (token);
13786 : :
13787 : : /* See what kind of keyword it is. */
13788 : 38285912 : keyword = token->keyword;
13789 : 38285912 : switch (keyword)
13790 : : {
13791 : 38285912 : case RID_IF:
13792 : 38285912 : case RID_SWITCH:
13793 : 38285912 : {
13794 : 38285912 : tree statement;
13795 : 38285912 : tree condition;
13796 : :
13797 : 38285912 : bool cx = false;
13798 : 38285912 : if (keyword == RID_IF
13799 : 38285912 : && cp_lexer_next_token_is_keyword (parser->lexer,
13800 : : RID_CONSTEXPR))
13801 : : {
13802 : 4278135 : cx = true;
13803 : 4278135 : cp_token *tok = cp_lexer_consume_token (parser->lexer);
13804 : 4278135 : if (cxx_dialect < cxx17)
13805 : 8399 : pedwarn (tok->location, OPT_Wc__17_extensions,
13806 : : "%<if constexpr%> only available with "
13807 : : "%<-std=c++17%> or %<-std=gnu++17%>");
13808 : : }
13809 : 38285912 : int ce = 0;
13810 : 38285912 : if (keyword == RID_IF && !cx)
13811 : : {
13812 : 33844181 : if (cp_lexer_next_token_is_keyword (parser->lexer,
13813 : : RID_CONSTEVAL))
13814 : : ce = 1;
13815 : 33835980 : else if (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
13816 : 33835980 : && cp_lexer_nth_token_is_keyword (parser->lexer, 2,
13817 : : RID_CONSTEVAL))
13818 : : {
13819 : 1688 : ce = -1;
13820 : 1688 : cp_lexer_consume_token (parser->lexer);
13821 : : }
13822 : : }
13823 : 1688 : if (ce)
13824 : : {
13825 : 9889 : cp_token *tok = cp_lexer_consume_token (parser->lexer);
13826 : 9889 : if (cxx_dialect < cxx23)
13827 : 48 : pedwarn (tok->location, OPT_Wc__23_extensions,
13828 : : "%<if consteval%> only available with "
13829 : : "%<-std=c++2b%> or %<-std=gnu++2b%>");
13830 : :
13831 : 9889 : bool save_in_consteval_if_p = in_consteval_if_p;
13832 : 9889 : statement = begin_if_stmt ();
13833 : 9889 : IF_STMT_CONSTEVAL_P (statement) = true;
13834 : 9889 : condition = finish_if_stmt_cond (boolean_false_node, statement);
13835 : :
13836 : 9889 : gcc_rich_location richloc (tok->location);
13837 : 9889 : bool non_compound_stmt_p = false;
13838 : 9889 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
13839 : : {
13840 : 9 : non_compound_stmt_p = true;
13841 : 9 : richloc.add_fixit_insert_after (tok->location, "{");
13842 : : }
13843 : :
13844 : 9889 : in_consteval_if_p |= ce > 0;
13845 : 9889 : cp_parser_implicitly_scoped_statement (parser, NULL, guard_tinfo);
13846 : :
13847 : 9889 : if (non_compound_stmt_p)
13848 : : {
13849 : 9 : location_t before_loc
13850 : 9 : = cp_lexer_peek_token (parser->lexer)->location;
13851 : 9 : richloc.add_fixit_insert_before (before_loc, "}");
13852 : 9 : error_at (&richloc,
13853 : : "%<if consteval%> requires compound statement");
13854 : 9 : non_compound_stmt_p = false;
13855 : : }
13856 : :
13857 : 9889 : finish_then_clause (statement);
13858 : :
13859 : : /* If the next token is `else', parse the else-clause. */
13860 : 9889 : if (cp_lexer_next_token_is_keyword (parser->lexer,
13861 : : RID_ELSE))
13862 : : {
13863 : 4621 : cp_token *else_tok = cp_lexer_peek_token (parser->lexer);
13864 : 4621 : gcc_rich_location else_richloc (else_tok->location);
13865 : 4621 : guard_tinfo = get_token_indent_info (else_tok);
13866 : : /* Consume the `else' keyword. */
13867 : 4621 : cp_lexer_consume_token (parser->lexer);
13868 : :
13869 : 4621 : begin_else_clause (statement);
13870 : :
13871 : 4621 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
13872 : : {
13873 : 9 : non_compound_stmt_p = true;
13874 : 9 : else_richloc.add_fixit_insert_after (else_tok->location,
13875 : : "{");
13876 : : }
13877 : :
13878 : 4621 : in_consteval_if_p = save_in_consteval_if_p | (ce < 0);
13879 : 4621 : cp_parser_implicitly_scoped_statement (parser, NULL,
13880 : : guard_tinfo);
13881 : :
13882 : 4621 : if (non_compound_stmt_p)
13883 : : {
13884 : 9 : location_t before_loc
13885 : 9 : = cp_lexer_peek_token (parser->lexer)->location;
13886 : 9 : else_richloc.add_fixit_insert_before (before_loc, "}");
13887 : 9 : error_at (&else_richloc,
13888 : : "%<if consteval%> requires compound statement");
13889 : : }
13890 : :
13891 : 4621 : finish_else_clause (statement);
13892 : 4621 : }
13893 : :
13894 : 9889 : in_consteval_if_p = save_in_consteval_if_p;
13895 : 9889 : if (ce < 0)
13896 : : {
13897 : 1688 : std::swap (THEN_CLAUSE (statement), ELSE_CLAUSE (statement));
13898 : 1688 : if (THEN_CLAUSE (statement) == NULL_TREE)
13899 : 1655 : THEN_CLAUSE (statement) = build_empty_stmt (tok->location);
13900 : : }
13901 : :
13902 : 9889 : finish_if_stmt (statement);
13903 : 9889 : return statement;
13904 : 9889 : }
13905 : :
13906 : : /* Look for the `('. */
13907 : 38276023 : matching_parens parens;
13908 : 38276023 : if (!parens.require_open (parser))
13909 : : {
13910 : 6 : cp_parser_skip_to_end_of_statement (parser);
13911 : 6 : return error_mark_node;
13912 : : }
13913 : :
13914 : : /* Begin the selection-statement. */
13915 : 38276017 : if (keyword == RID_IF)
13916 : : {
13917 : 38112421 : statement = begin_if_stmt ();
13918 : 38112421 : IF_STMT_CONSTEXPR_P (statement) = cx;
13919 : : }
13920 : : else
13921 : 163596 : statement = begin_switch_stmt ();
13922 : :
13923 : : /* Parse the optional init-statement. */
13924 : 38276017 : if (cp_parser_init_statement_p (parser))
13925 : : {
13926 : 65608 : tree decl;
13927 : 65608 : if (cxx_dialect < cxx17)
13928 : 27 : pedwarn (cp_lexer_peek_token (parser->lexer)->location,
13929 : : OPT_Wc__17_extensions,
13930 : : "init-statement in selection statements only available "
13931 : : "with %<-std=c++17%> or %<-std=gnu++17%>");
13932 : 65608 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
13933 : : /* A non-empty init-statement can have arbitrary side
13934 : : effects. */
13935 : 65605 : vec_free (chain);
13936 : 65608 : cp_parser_init_statement (parser, &decl);
13937 : : }
13938 : :
13939 : : /* Parse the condition. */
13940 : 38276017 : condition = cp_parser_condition (parser, keyword);
13941 : : /* Look for the `)'. */
13942 : 38276017 : if (!parens.require_close (parser))
13943 : 12 : cp_parser_skip_to_closing_parenthesis (parser, true, false,
13944 : : /*consume_paren=*/true);
13945 : :
13946 : 38276017 : if (keyword == RID_IF)
13947 : : {
13948 : 38112421 : bool nested_if;
13949 : 38112421 : unsigned char in_statement;
13950 : :
13951 : : /* Add the condition. */
13952 : 38112421 : condition = finish_if_stmt_cond (condition, statement);
13953 : :
13954 : 38112421 : if (warn_duplicated_cond)
13955 : 249 : warn_duplicated_cond_add_or_warn (token->location, condition,
13956 : : &chain);
13957 : :
13958 : : /* Parse the then-clause. */
13959 : 38112421 : in_statement = parser->in_statement;
13960 : 38112421 : parser->in_statement |= IN_IF_STMT;
13961 : :
13962 : : /* Outside a template, the non-selected branch of a constexpr
13963 : : if is a 'discarded statement', i.e. unevaluated. */
13964 : 38112421 : bool was_discarded = in_discarded_stmt;
13965 : 4278135 : bool discard_then = (cx && !processing_template_decl
13966 : 38146342 : && integer_zerop (condition));
13967 : 1914 : if (discard_then)
13968 : : {
13969 : 1914 : in_discarded_stmt = true;
13970 : 1914 : ++c_inhibit_evaluation_warnings;
13971 : : }
13972 : :
13973 : 38112421 : cp_parser_implicitly_scoped_statement (parser, &nested_if,
13974 : : guard_tinfo);
13975 : :
13976 : 38112421 : parser->in_statement = in_statement;
13977 : :
13978 : 38112421 : finish_then_clause (statement);
13979 : :
13980 : 38112421 : if (discard_then)
13981 : : {
13982 : 1914 : THEN_CLAUSE (statement) = NULL_TREE;
13983 : 1914 : in_discarded_stmt = was_discarded;
13984 : 1914 : --c_inhibit_evaluation_warnings;
13985 : : }
13986 : :
13987 : : /* If the next token is `else', parse the else-clause. */
13988 : 38112421 : if (cp_lexer_next_token_is_keyword (parser->lexer,
13989 : : RID_ELSE))
13990 : : {
13991 : 2824906 : bool discard_else = (cx && !processing_template_decl
13992 : 13223011 : && integer_nonzerop (condition));
13993 : 31938 : if (discard_else)
13994 : : {
13995 : 31938 : in_discarded_stmt = true;
13996 : 31938 : ++c_inhibit_evaluation_warnings;
13997 : : }
13998 : :
13999 : 13189201 : guard_tinfo
14000 : 13189201 : = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
14001 : : /* Consume the `else' keyword. */
14002 : 13189201 : cp_lexer_consume_token (parser->lexer);
14003 : 13189201 : if (warn_duplicated_cond)
14004 : : {
14005 : 165 : if (cp_lexer_next_token_is_keyword (parser->lexer,
14006 : : RID_IF)
14007 : 165 : && chain == NULL)
14008 : : {
14009 : : /* We've got "if (COND) else if (COND2)". Start
14010 : : the condition chain and add COND as the first
14011 : : element. */
14012 : 87 : chain = new vec<tree> ();
14013 : 87 : if (!CONSTANT_CLASS_P (condition)
14014 : 87 : && !TREE_SIDE_EFFECTS (condition))
14015 : : {
14016 : : /* Wrap it in a NOP_EXPR so that we can set the
14017 : : location of the condition. */
14018 : 69 : tree e = build1 (NOP_EXPR, TREE_TYPE (condition),
14019 : 69 : condition);
14020 : 69 : SET_EXPR_LOCATION (e, token->location);
14021 : 69 : chain->safe_push (e);
14022 : : }
14023 : : }
14024 : 78 : else if (!cp_lexer_next_token_is_keyword (parser->lexer,
14025 : : RID_IF))
14026 : : /* This is if-else without subsequent if. Zap the
14027 : : condition chain; we would have already warned at
14028 : : this point. */
14029 : 12 : vec_free (chain);
14030 : : }
14031 : 13189201 : begin_else_clause (statement);
14032 : : /* Parse the else-clause. */
14033 : 13189201 : cp_parser_implicitly_scoped_statement (parser, NULL,
14034 : : guard_tinfo, chain);
14035 : :
14036 : 13189201 : finish_else_clause (statement);
14037 : :
14038 : : /* If we are currently parsing a then-clause, then
14039 : : IF_P will not be NULL. We set it to true to
14040 : : indicate that this if statement has an else clause.
14041 : : This may trigger the Wparentheses warning below
14042 : : when we get back up to the parent if statement. */
14043 : 13189201 : if (if_p != NULL)
14044 : 78897 : *if_p = true;
14045 : :
14046 : 13189201 : if (discard_else)
14047 : : {
14048 : 31938 : ELSE_CLAUSE (statement) = NULL_TREE;
14049 : 31938 : in_discarded_stmt = was_discarded;
14050 : 31938 : --c_inhibit_evaluation_warnings;
14051 : : }
14052 : : }
14053 : : else
14054 : : {
14055 : : /* This if statement does not have an else clause. If
14056 : : NESTED_IF is true, then the then-clause has an if
14057 : : statement which does have an else clause. We warn
14058 : : about the potential ambiguity. */
14059 : 24923220 : if (nested_if)
14060 : 341 : warning_at (EXPR_LOCATION (statement), OPT_Wdangling_else,
14061 : : "suggest explicit braces to avoid ambiguous"
14062 : : " %<else%>");
14063 : 24923220 : if (warn_duplicated_cond)
14064 : : /* We don't need the condition chain anymore. */
14065 : 84 : vec_free (chain);
14066 : : }
14067 : :
14068 : : /* Now we're all done with the if-statement. */
14069 : 38112421 : finish_if_stmt (statement);
14070 : : }
14071 : : else
14072 : : {
14073 : 163596 : bool in_switch_statement_p;
14074 : 163596 : unsigned char in_statement;
14075 : :
14076 : : /* Add the condition. */
14077 : 163596 : finish_switch_cond (condition, statement);
14078 : :
14079 : : /* Parse the body of the switch-statement. */
14080 : 163596 : in_switch_statement_p = parser->in_switch_statement_p;
14081 : 163596 : in_statement = parser->in_statement;
14082 : 163596 : parser->in_switch_statement_p = true;
14083 : 163596 : parser->in_statement |= IN_SWITCH_STMT;
14084 : 163596 : cp_parser_implicitly_scoped_statement (parser, if_p,
14085 : : guard_tinfo);
14086 : 163596 : parser->in_switch_statement_p = in_switch_statement_p;
14087 : 163596 : parser->in_statement = in_statement;
14088 : :
14089 : : /* Now we're all done with the switch-statement. */
14090 : 163596 : finish_switch_stmt (statement);
14091 : : }
14092 : :
14093 : : return statement;
14094 : : }
14095 : 0 : break;
14096 : :
14097 : 0 : default:
14098 : 0 : cp_parser_error (parser, "expected selection-statement");
14099 : 0 : return error_mark_node;
14100 : : }
14101 : : }
14102 : :
14103 : : /* Helper function for cp_parser_condition and cp_parser_simple_declaration.
14104 : : If we have seen at least one decl-specifier, and the next token is not
14105 : : a parenthesis (after "int (" we might be looking at a functional cast)
14106 : : neither we are dealing with a concept-check expression then we must be
14107 : : looking at a declaration. */
14108 : :
14109 : : static void
14110 : 152216306 : cp_parser_maybe_commit_to_declaration (cp_parser* parser,
14111 : : cp_decl_specifier_seq *decl_specs)
14112 : : {
14113 : 152216306 : if (decl_specs->any_specifiers_p
14114 : 152209924 : && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)
14115 : 141982282 : && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
14116 : 257944658 : && !cp_parser_error_occurred (parser)
14117 : 304206299 : && !(decl_specs->type
14118 : 104281116 : && TREE_CODE (decl_specs->type) == TYPE_DECL
14119 : 46261641 : && is_constrained_auto (TREE_TYPE (decl_specs->type))))
14120 : 105728095 : cp_parser_commit_to_tentative_parse (parser);
14121 : 152216306 : }
14122 : :
14123 : : /* Helper function for cp_parser_condition. Enforces [stmt.stmt]/2:
14124 : : The declarator shall not specify a function or an array. Returns
14125 : : TRUE if the declarator is valid, FALSE otherwise. */
14126 : :
14127 : : static bool
14128 : 530397 : cp_parser_check_condition_declarator (cp_parser* parser,
14129 : : cp_declarator *declarator,
14130 : : location_t loc)
14131 : : {
14132 : 530397 : if (declarator == cp_error_declarator
14133 : 530388 : || function_declarator_p (declarator)
14134 : 1060737 : || declarator->kind == cdk_array)
14135 : : {
14136 : 78 : if (declarator == cp_error_declarator)
14137 : : /* Already complained. */;
14138 : 69 : else if (declarator->kind == cdk_array)
14139 : 21 : error_at (loc, "condition declares an array");
14140 : : else
14141 : 48 : error_at (loc, "condition declares a function");
14142 : 78 : if (parser->fully_implicit_function_template_p)
14143 : 0 : abort_fully_implicit_template (parser);
14144 : 78 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
14145 : : /*or_comma=*/false,
14146 : : /*consume_paren=*/false);
14147 : 78 : return false;
14148 : : }
14149 : : else
14150 : : return true;
14151 : : }
14152 : :
14153 : : /* Parse a condition.
14154 : :
14155 : : condition:
14156 : : expression
14157 : : type-specifier-seq declarator = initializer-clause
14158 : : type-specifier-seq declarator braced-init-list
14159 : : structured-binding-declaration initializer (C++26)
14160 : :
14161 : : GNU Extension:
14162 : :
14163 : : condition:
14164 : : type-specifier-seq declarator asm-specification [opt]
14165 : : attributes [opt] = assignment-expression
14166 : :
14167 : : Returns the expression that should be tested. */
14168 : :
14169 : : static tree
14170 : 46575847 : cp_parser_condition (cp_parser* parser, enum rid keyword)
14171 : : {
14172 : 46575847 : cp_decl_specifier_seq type_specifiers;
14173 : 46575847 : const char *saved_message;
14174 : 46575847 : int declares_class_or_enum;
14175 : :
14176 : : /* Try the declaration first. */
14177 : 46575847 : cp_parser_parse_tentatively (parser);
14178 : : /* New types are not allowed in the type-specifier-seq for a
14179 : : condition. */
14180 : 46575847 : saved_message = parser->type_definition_forbidden_message;
14181 : 46575847 : parser->type_definition_forbidden_message
14182 : 46575847 : = G_("types may not be defined in conditions");
14183 : : /* Parse the type-specifier-seq. */
14184 : 46575847 : cp_parser_decl_specifier_seq (parser,
14185 : : CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
14186 : : &type_specifiers,
14187 : : &declares_class_or_enum);
14188 : : /* Restore the saved message. */
14189 : 46575847 : parser->type_definition_forbidden_message = saved_message;
14190 : :
14191 : : /* Gather the attributes that were provided with the
14192 : : decl-specifiers. */
14193 : 46575847 : tree prefix_attributes = type_specifiers.attributes;
14194 : :
14195 : 46575847 : cp_parser_maybe_commit_to_declaration (parser, &type_specifiers);
14196 : :
14197 : : /* If all is well, we might be looking at a declaration. */
14198 : 93151694 : if (!cp_parser_error_occurred (parser))
14199 : : {
14200 : 766711 : tree decl;
14201 : 766711 : tree asm_specification;
14202 : 766711 : tree attributes;
14203 : 766711 : cp_declarator *declarator;
14204 : 766711 : tree initializer = NULL_TREE;
14205 : 766711 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
14206 : :
14207 : : /* Look for C++26 structured binding declaration. */
14208 : 766711 : for (size_t n = 1; ; n++)
14209 : 770002 : if (cp_lexer_nth_token_is (parser->lexer, n, CPP_AND)
14210 : 770002 : || cp_lexer_nth_token_is (parser->lexer, n, CPP_AND_AND))
14211 : 3291 : continue;
14212 : 766711 : else if (cp_lexer_nth_token_is (parser->lexer, n, CPP_OPEN_SQUARE)
14213 : 210 : && !cp_lexer_nth_token_is (parser->lexer, n + 1,
14214 : : CPP_OPEN_SQUARE)
14215 : 210 : && type_specifiers.any_specifiers_p
14216 : 766921 : && cp_parser_parse_definitely (parser))
14217 : : {
14218 : 210 : location_t init_loc;
14219 : 210 : tree decl
14220 : 210 : = cp_parser_decomposition_declaration (parser, &type_specifiers,
14221 : : NULL, &init_loc, keyword);
14222 : 210 : return decl;
14223 : : }
14224 : : else
14225 : 3291 : break;
14226 : :
14227 : : /* Parse the declarator. */
14228 : 766501 : declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
14229 : : CP_PARSER_FLAGS_NONE,
14230 : : /*ctor_dtor_or_conv_p=*/NULL,
14231 : : /*parenthesized_p=*/NULL,
14232 : : /*member_p=*/false,
14233 : : /*friend_p=*/false,
14234 : : /*static_p=*/false);
14235 : : /* Parse the attributes. */
14236 : 766501 : attributes = cp_parser_attributes_opt (parser);
14237 : : /* Parse the asm-specification. */
14238 : 766501 : asm_specification = cp_parser_asm_specification_opt (parser);
14239 : : /* If the next token is not an `=' or '{', then we might still be
14240 : : looking at an expression. For example:
14241 : :
14242 : : if (A(a).x)
14243 : :
14244 : : looks like a decl-specifier-seq and a declarator -- but then
14245 : : there is no `=', so this is an expression. */
14246 : 766501 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
14247 : 766501 : && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
14248 : 982093 : cp_parser_simulate_error (parser);
14249 : :
14250 : : /* If we did see an `=' or '{', then we are looking at a declaration
14251 : : for sure. */
14252 : 766501 : if (cp_parser_parse_definitely (parser))
14253 : : {
14254 : 530397 : tree pushed_scope;
14255 : 530397 : bool non_constant_p = false;
14256 : 530397 : int flags = LOOKUP_ONLYCONVERTING;
14257 : :
14258 : 530397 : if (!cp_parser_check_condition_declarator (parser, declarator, loc))
14259 : 78 : return error_mark_node;
14260 : :
14261 : : /* Create the declaration. */
14262 : 530319 : decl = start_decl (declarator, &type_specifiers,
14263 : : /*initialized_p=*/true,
14264 : : attributes, prefix_attributes,
14265 : : &pushed_scope);
14266 : :
14267 : 530319 : declarator->init_loc = cp_lexer_peek_token (parser->lexer)->location;
14268 : : /* Parse the initializer. */
14269 : 530319 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
14270 : : {
14271 : 18715 : initializer = cp_parser_braced_list (parser, &non_constant_p);
14272 : 18715 : CONSTRUCTOR_IS_DIRECT_INIT (initializer) = 1;
14273 : 18715 : flags = 0;
14274 : : }
14275 : 511604 : else if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
14276 : : {
14277 : : /* Consume the `='. */
14278 : 511589 : cp_lexer_consume_token (parser->lexer);
14279 : 511589 : initializer = cp_parser_initializer_clause (parser,
14280 : : &non_constant_p);
14281 : : }
14282 : : else
14283 : : {
14284 : 15 : cp_parser_error (parser, "expected initializer");
14285 : 15 : initializer = error_mark_node;
14286 : : }
14287 : 530319 : if (BRACE_ENCLOSED_INITIALIZER_P (initializer))
14288 : 18718 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
14289 : :
14290 : : /* Process the initializer. */
14291 : 530319 : cp_finish_decl (decl,
14292 : 530319 : initializer, !non_constant_p,
14293 : : asm_specification,
14294 : : flags);
14295 : :
14296 : 530319 : if (pushed_scope)
14297 : 0 : pop_scope (pushed_scope);
14298 : :
14299 : 530319 : return convert_from_reference (decl);
14300 : : }
14301 : : }
14302 : : /* If we didn't even get past the declarator successfully, we are
14303 : : definitely not looking at a declaration. */
14304 : : else
14305 : 45809136 : cp_parser_abort_tentative_parse (parser);
14306 : :
14307 : : /* Otherwise, we are looking at an expression. */
14308 : 46045240 : return cp_parser_expression (parser);
14309 : : }
14310 : :
14311 : : /* Parses a for-statement or range-for-statement until the closing ')',
14312 : : not included. */
14313 : :
14314 : : static tree
14315 : 5390761 : cp_parser_for (cp_parser *parser, bool ivdep, tree unroll, bool novector)
14316 : : {
14317 : 5390761 : tree init, scope, decl;
14318 : 5390761 : bool is_range_for;
14319 : :
14320 : : /* Begin the for-statement. */
14321 : 5390761 : scope = begin_for_scope (&init);
14322 : :
14323 : : /* Maybe parse the optional init-statement in a range-based for loop. */
14324 : 5390761 : if (cp_parser_range_based_for_with_init_p (parser)
14325 : : /* Checked for diagnostic purposes only. */
14326 : 5390761 : && cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
14327 : : {
14328 : 68 : tree dummy;
14329 : 68 : cp_parser_init_statement (parser, &dummy);
14330 : 68 : if (cxx_dialect < cxx20)
14331 : : {
14332 : 4 : pedwarn (cp_lexer_peek_token (parser->lexer)->location,
14333 : : OPT_Wc__20_extensions,
14334 : : "range-based %<for%> loops with initializer only "
14335 : : "available with %<-std=c++20%> or %<-std=gnu++20%>");
14336 : 4 : decl = error_mark_node;
14337 : : }
14338 : : }
14339 : :
14340 : : /* Parse the initialization. */
14341 : 5390761 : is_range_for = cp_parser_init_statement (parser, &decl);
14342 : :
14343 : 5390761 : if (is_range_for)
14344 : 208569 : return cp_parser_range_for (parser, scope, init, decl, ivdep, unroll,
14345 : 208569 : novector, false);
14346 : : else
14347 : 5182192 : return cp_parser_c_for (parser, scope, init, ivdep, unroll, novector);
14348 : : }
14349 : :
14350 : : static tree
14351 : 5182192 : cp_parser_c_for (cp_parser *parser, tree scope, tree init, bool ivdep,
14352 : : tree unroll, bool novector)
14353 : : {
14354 : : /* Normal for loop */
14355 : 5182192 : tree condition = NULL_TREE;
14356 : 5182192 : tree expression = NULL_TREE;
14357 : 5182192 : tree stmt;
14358 : :
14359 : 5182192 : stmt = begin_for_stmt (scope, init);
14360 : : /* The init-statement has already been parsed in
14361 : : cp_parser_init_statement, so no work is needed here. */
14362 : 5182192 : finish_init_stmt (stmt);
14363 : :
14364 : : /* If there's a condition, process it. */
14365 : 5182192 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
14366 : 4974000 : condition = cp_parser_condition (parser, RID_FOR);
14367 : 208192 : else if (ivdep)
14368 : : {
14369 : 3 : cp_parser_error (parser, "missing loop condition in loop with "
14370 : : "%<GCC ivdep%> pragma");
14371 : 3 : condition = error_mark_node;
14372 : : }
14373 : 208189 : else if (unroll)
14374 : : {
14375 : 0 : cp_parser_error (parser, "missing loop condition in loop with "
14376 : : "%<GCC unroll%> pragma");
14377 : 0 : condition = error_mark_node;
14378 : : }
14379 : 5182192 : finish_for_cond (condition, stmt, ivdep, unroll, novector);
14380 : : /* Look for the `;'. */
14381 : 5182192 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
14382 : :
14383 : : /* If there's an expression, process it. */
14384 : 5182192 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
14385 : 4886315 : expression = cp_parser_expression (parser);
14386 : 5182192 : finish_for_expr (expression, stmt);
14387 : :
14388 : 5182192 : return stmt;
14389 : : }
14390 : :
14391 : : /* Tries to parse a range-based for-statement:
14392 : :
14393 : : range-based-for:
14394 : : decl-specifier-seq declarator : expression
14395 : :
14396 : : The decl-specifier-seq declarator and the `:' are already parsed by
14397 : : cp_parser_init_statement. If processing_template_decl it returns a
14398 : : newly created RANGE_FOR_STMT; if not, it is converted to a
14399 : : regular FOR_STMT. */
14400 : :
14401 : : static tree
14402 : 208847 : cp_parser_range_for (cp_parser *parser, tree scope, tree init, tree range_decl,
14403 : : bool ivdep, tree unroll, bool novector, bool is_omp)
14404 : : {
14405 : 208847 : tree stmt, range_expr;
14406 : 208847 : auto_vec <cxx_binding *, 16> bindings;
14407 : 208847 : auto_vec <tree, 16> names;
14408 : 208847 : cp_decomp decomp_d, *decomp = NULL;
14409 : :
14410 : : /* Get the range declaration momentarily out of the way so that
14411 : : the range expression doesn't clash with it. */
14412 : 208847 : if (range_decl != error_mark_node)
14413 : : {
14414 : 208833 : if (DECL_HAS_VALUE_EXPR_P (range_decl))
14415 : : {
14416 : 171 : tree v = DECL_VALUE_EXPR (range_decl);
14417 : : /* For decomposition declaration get all of the corresponding
14418 : : declarations out of the way. */
14419 : 171 : if (TREE_CODE (v) == ARRAY_REF
14420 : 171 : && DECL_DECOMPOSITION_P (TREE_OPERAND (v, 0)))
14421 : : {
14422 : 171 : tree d = range_decl;
14423 : 171 : range_decl = TREE_OPERAND (v, 0);
14424 : 171 : decomp = &decomp_d;
14425 : 171 : decomp->count = tree_to_uhwi (TREE_OPERAND (v, 1)) + 1;
14426 : 171 : decomp->decl = d;
14427 : 677 : for (unsigned int i = 0; i < decomp->count;
14428 : 506 : i++, d = DECL_CHAIN (d))
14429 : : {
14430 : 506 : tree name = DECL_NAME (d);
14431 : 506 : names.safe_push (name);
14432 : 506 : bindings.safe_push (IDENTIFIER_BINDING (name));
14433 : 1012 : IDENTIFIER_BINDING (name)
14434 : 506 : = IDENTIFIER_BINDING (name)->previous;
14435 : : }
14436 : : }
14437 : : }
14438 : 208833 : if (names.is_empty ())
14439 : : {
14440 : 208662 : tree name = DECL_NAME (range_decl);
14441 : 208662 : names.safe_push (name);
14442 : 208662 : bindings.safe_push (IDENTIFIER_BINDING (name));
14443 : 208662 : IDENTIFIER_BINDING (name) = IDENTIFIER_BINDING (name)->previous;
14444 : : }
14445 : : }
14446 : :
14447 : 208847 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
14448 : 154 : range_expr = cp_parser_braced_list (parser);
14449 : : else
14450 : 208693 : range_expr = cp_parser_expression (parser);
14451 : :
14452 : : /* Put the range declaration(s) back into scope. */
14453 : 418015 : for (unsigned int i = 0; i < names.length (); i++)
14454 : : {
14455 : 209168 : cxx_binding *binding = bindings[i];
14456 : 209168 : binding->previous = IDENTIFIER_BINDING (names[i]);
14457 : 209168 : IDENTIFIER_BINDING (names[i]) = binding;
14458 : : }
14459 : :
14460 : : /* finish_omp_for has its own code for the following, so just
14461 : : return the range_expr instead. */
14462 : 208847 : if (is_omp)
14463 : : return range_expr;
14464 : :
14465 : : /* If in template, STMT is converted to a normal for-statement
14466 : : at instantiation. If not, it is done just ahead. */
14467 : 208569 : if (processing_template_decl)
14468 : : {
14469 : 205950 : if (check_for_bare_parameter_packs (range_expr))
14470 : 3 : range_expr = error_mark_node;
14471 : 205950 : stmt = begin_range_for_stmt (scope, init);
14472 : 205950 : if (ivdep)
14473 : 1 : RANGE_FOR_IVDEP (stmt) = 1;
14474 : 205950 : if (unroll)
14475 : 57 : RANGE_FOR_UNROLL (stmt) = unroll;
14476 : 205950 : if (novector)
14477 : 0 : RANGE_FOR_NOVECTOR (stmt) = 1;
14478 : 205950 : finish_range_for_decl (stmt, range_decl, range_expr);
14479 : 205950 : if (!type_dependent_expression_p (range_expr)
14480 : : /* do_auto_deduction doesn't mess with template init-lists. */
14481 : 205950 : && !BRACE_ENCLOSED_INITIALIZER_P (range_expr))
14482 : 47030 : do_range_for_auto_deduction (range_decl, range_expr, decomp);
14483 : : }
14484 : : else
14485 : : {
14486 : 2619 : stmt = begin_for_stmt (scope, init);
14487 : 2619 : stmt = cp_convert_range_for (stmt, range_decl, range_expr, decomp,
14488 : : ivdep, unroll, novector);
14489 : : }
14490 : : return stmt;
14491 : 208847 : }
14492 : :
14493 : : /* Subroutine of cp_convert_range_for: given the initializer expression,
14494 : : builds up the range temporary. */
14495 : :
14496 : : static tree
14497 : 99955 : build_range_temp (tree range_expr)
14498 : : {
14499 : : /* Find out the type deduced by the declaration
14500 : : `auto &&__range = range_expr'. */
14501 : 99955 : tree auto_node = make_auto ();
14502 : 99955 : tree range_type = cp_build_reference_type (auto_node, true);
14503 : 99955 : range_type = do_auto_deduction (range_type, range_expr, auto_node);
14504 : :
14505 : : /* Create the __range variable. */
14506 : 99955 : tree range_temp = build_decl (input_location, VAR_DECL,
14507 : : for_range__identifier, range_type);
14508 : 99955 : TREE_USED (range_temp) = 1;
14509 : 99955 : DECL_ARTIFICIAL (range_temp) = 1;
14510 : :
14511 : 99955 : return range_temp;
14512 : : }
14513 : :
14514 : : /* Used by cp_parser_range_for in template context: we aren't going to
14515 : : do a full conversion yet, but we still need to resolve auto in the
14516 : : type of the for-range-declaration if present. This is basically
14517 : : a shortcut version of cp_convert_range_for. */
14518 : :
14519 : : static void
14520 : 47144 : do_range_for_auto_deduction (tree decl, tree range_expr, cp_decomp *decomp)
14521 : : {
14522 : 47144 : tree auto_node = type_uses_auto (TREE_TYPE (decl));
14523 : 47144 : if (auto_node)
14524 : : {
14525 : 47034 : tree begin_dummy, end_dummy, range_temp, iter_type, iter_decl;
14526 : 47034 : range_temp = convert_from_reference (build_range_temp (range_expr));
14527 : 47034 : iter_type = (cp_parser_perform_range_for_lookup
14528 : 47034 : (range_temp, &begin_dummy, &end_dummy));
14529 : 47034 : if (iter_type)
14530 : : {
14531 : 47028 : iter_decl = build_decl (input_location, VAR_DECL, NULL_TREE,
14532 : : iter_type);
14533 : 47028 : iter_decl = build_x_indirect_ref (input_location, iter_decl,
14534 : : RO_UNARY_STAR, NULL_TREE,
14535 : : tf_warning_or_error);
14536 : 47028 : TREE_TYPE (decl) = do_auto_deduction (TREE_TYPE (decl),
14537 : : iter_decl, auto_node,
14538 : : tf_warning_or_error,
14539 : : adc_variable_type);
14540 : 47028 : if (DECL_DECOMPOSITION_P (decl))
14541 : 45 : cp_finish_decomp (decl, decomp);
14542 : : }
14543 : : }
14544 : 47144 : }
14545 : :
14546 : : /* Warns when the loop variable should be changed to a reference type to
14547 : : avoid unnecessary copying. I.e., from
14548 : :
14549 : : for (const auto x : range)
14550 : :
14551 : : where range returns a reference, to
14552 : :
14553 : : for (const auto &x : range)
14554 : :
14555 : : if this version doesn't make a copy.
14556 : :
14557 : : This function also warns when the loop variable is initialized with
14558 : : a value of a different type resulting in a copy:
14559 : :
14560 : : int arr[10];
14561 : : for (const double &x : arr)
14562 : :
14563 : : DECL is the RANGE_DECL; EXPR is the *__for_begin expression.
14564 : : This function is never called when processing_template_decl is on. */
14565 : :
14566 : : static void
14567 : 52679 : warn_for_range_copy (tree decl, tree expr)
14568 : : {
14569 : 52679 : if (!warn_range_loop_construct
14570 : 1895 : || decl == error_mark_node)
14571 : : return;
14572 : :
14573 : 1895 : location_t loc = DECL_SOURCE_LOCATION (decl);
14574 : 1895 : tree type = TREE_TYPE (decl);
14575 : :
14576 : 1895 : if (from_macro_expansion_at (loc))
14577 : : return;
14578 : :
14579 : 1403 : if (TYPE_REF_P (type))
14580 : : {
14581 : 1000 : if (glvalue_p (expr)
14582 : 1000 : && ref_conv_binds_to_temporary (type, expr).is_true ())
14583 : : {
14584 : 78 : auto_diagnostic_group d;
14585 : 78 : if (warning_at (loc, OPT_Wrange_loop_construct,
14586 : : "loop variable %qD of type %qT binds to a temporary "
14587 : : "constructed from type %qT", decl, type,
14588 : 78 : TREE_TYPE (expr)))
14589 : : {
14590 : 78 : tree ref = cp_build_qualified_type (TREE_TYPE (expr),
14591 : : TYPE_QUAL_CONST);
14592 : 78 : ref = cp_build_reference_type (ref, /*rval*/false);
14593 : 78 : inform (loc, "use non-reference type %qT to make the copy "
14594 : : "explicit or %qT to prevent copying",
14595 : : non_reference (type), ref);
14596 : : }
14597 : 78 : }
14598 : 1000 : return;
14599 : : }
14600 : 403 : else if (!CP_TYPE_CONST_P (type))
14601 : : return;
14602 : :
14603 : : /* Since small trivially constructible types are cheap to construct, we
14604 : : suppress the warning for them. 64B is a common size of a cache line. */
14605 : 170 : tree vec = make_tree_vec (1);
14606 : 170 : TREE_VEC_ELT (vec, 0) = TREE_TYPE (expr);
14607 : 170 : if (TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
14608 : 170 : || (tree_to_uhwi (TYPE_SIZE_UNIT (type)) <= 64
14609 : 83 : && is_trivially_xible (INIT_EXPR, type, vec)))
14610 : 62 : return;
14611 : :
14612 : : /* If we can initialize a reference directly, suggest that to avoid the
14613 : : copy. */
14614 : 108 : tree rtype = cp_build_reference_type (type, /*rval*/false);
14615 : 108 : if (ref_conv_binds_to_temporary (rtype, expr).is_false ())
14616 : : {
14617 : 45 : auto_diagnostic_group d;
14618 : 45 : if (warning_at (loc, OPT_Wrange_loop_construct,
14619 : : "loop variable %qD creates a copy from type %qT",
14620 : : decl, type))
14621 : : {
14622 : 45 : gcc_rich_location richloc (loc);
14623 : 45 : richloc.add_fixit_insert_before ("&");
14624 : 45 : inform (&richloc, "use reference type to prevent copying");
14625 : 45 : }
14626 : 45 : }
14627 : : }
14628 : :
14629 : : /* Converts a range-based for-statement into a normal
14630 : : for-statement, as per the definition.
14631 : :
14632 : : for (RANGE_DECL : RANGE_EXPR)
14633 : : BLOCK
14634 : :
14635 : : should be equivalent to:
14636 : :
14637 : : {
14638 : : auto &&__range = RANGE_EXPR;
14639 : : for (auto __begin = BEGIN_EXPR, __end = END_EXPR;
14640 : : __begin != __end;
14641 : : ++__begin)
14642 : : {
14643 : : RANGE_DECL = *__begin;
14644 : : BLOCK
14645 : : }
14646 : : }
14647 : :
14648 : : If RANGE_EXPR is an array:
14649 : : BEGIN_EXPR = __range
14650 : : END_EXPR = __range + ARRAY_SIZE(__range)
14651 : : Else if RANGE_EXPR has a member 'begin' or 'end':
14652 : : BEGIN_EXPR = __range.begin()
14653 : : END_EXPR = __range.end()
14654 : : Else:
14655 : : BEGIN_EXPR = begin(__range)
14656 : : END_EXPR = end(__range);
14657 : :
14658 : : If __range has a member 'begin' but not 'end', or vice versa, we must
14659 : : still use the second alternative (it will surely fail, however).
14660 : : When calling begin()/end() in the third alternative we must use
14661 : : argument dependent lookup, but always considering 'std' as an associated
14662 : : namespace. */
14663 : :
14664 : : tree
14665 : 52679 : cp_convert_range_for (tree statement, tree range_decl, tree range_expr,
14666 : : cp_decomp *decomp, bool ivdep, tree unroll,
14667 : : bool novector)
14668 : : {
14669 : 52679 : tree begin, end;
14670 : 52679 : tree iter_type, begin_expr, end_expr;
14671 : 52679 : tree condition, expression;
14672 : :
14673 : 52679 : range_expr = mark_lvalue_use (range_expr);
14674 : :
14675 : 52679 : if (range_decl == error_mark_node || range_expr == error_mark_node)
14676 : : /* If an error happened previously do nothing or else a lot of
14677 : : unhelpful errors would be issued. */
14678 : 28 : begin_expr = end_expr = iter_type = error_mark_node;
14679 : : else
14680 : : {
14681 : 52651 : tree range_temp;
14682 : :
14683 : 52651 : if (VAR_P (range_expr)
14684 : 52651 : && array_of_runtime_bound_p (TREE_TYPE (range_expr)))
14685 : : /* Can't bind a reference to an array of runtime bound. */
14686 : : range_temp = range_expr;
14687 : : else
14688 : : {
14689 : 52651 : range_temp = build_range_temp (range_expr);
14690 : 52651 : pushdecl (range_temp);
14691 : 52651 : if (flag_range_for_ext_temps)
14692 : : {
14693 : : /* P2718R0 - put the range_temp declaration and everything
14694 : : until end of the range for body into an extra STATEMENT_LIST
14695 : : which will have CLEANUP_POINT_EXPR around it, so that all
14696 : : temporaries are destroyed at the end of it. */
14697 : 52019 : gcc_assert (FOR_INIT_STMT (statement) == NULL_TREE);
14698 : 52019 : FOR_INIT_STMT (statement) = push_stmt_list ();
14699 : : }
14700 : 52651 : cp_finish_decl (range_temp, range_expr,
14701 : : /*is_constant_init*/false, NULL_TREE,
14702 : : LOOKUP_ONLYCONVERTING);
14703 : 52651 : range_temp = convert_from_reference (range_temp);
14704 : : }
14705 : 52651 : iter_type = cp_parser_perform_range_for_lookup (range_temp,
14706 : : &begin_expr, &end_expr);
14707 : : }
14708 : :
14709 : : /* The new for initialization statement. */
14710 : 52679 : begin = build_decl (input_location, VAR_DECL, for_begin__identifier,
14711 : : iter_type);
14712 : 52679 : TREE_USED (begin) = 1;
14713 : 52679 : DECL_ARTIFICIAL (begin) = 1;
14714 : 52679 : pushdecl (begin);
14715 : 52679 : cp_finish_decl (begin, begin_expr,
14716 : : /*is_constant_init*/false, NULL_TREE,
14717 : : LOOKUP_ONLYCONVERTING);
14718 : :
14719 : 52679 : if (cxx_dialect >= cxx17)
14720 : 52193 : iter_type = cv_unqualified (TREE_TYPE (end_expr));
14721 : 52679 : end = build_decl (input_location, VAR_DECL, for_end__identifier, iter_type);
14722 : 52679 : TREE_USED (end) = 1;
14723 : 52679 : DECL_ARTIFICIAL (end) = 1;
14724 : 52679 : pushdecl (end);
14725 : 52679 : cp_finish_decl (end, end_expr,
14726 : : /*is_constant_init*/false, NULL_TREE,
14727 : : LOOKUP_ONLYCONVERTING);
14728 : :
14729 : 52679 : finish_init_stmt (statement);
14730 : :
14731 : : /* The new for condition. */
14732 : 52679 : condition = build_x_binary_op (input_location, NE_EXPR,
14733 : : begin, ERROR_MARK,
14734 : : end, ERROR_MARK,
14735 : : NULL_TREE, NULL, tf_warning_or_error);
14736 : 52679 : finish_for_cond (condition, statement, ivdep, unroll, novector);
14737 : :
14738 : : /* The new increment expression. */
14739 : 52679 : expression = finish_unary_op_expr (input_location,
14740 : : PREINCREMENT_EXPR, begin,
14741 : : tf_warning_or_error);
14742 : 52679 : finish_for_expr (expression, statement);
14743 : :
14744 : : /* The declaration is initialized with *__begin inside the loop body. */
14745 : 52679 : tree deref_begin = build_x_indirect_ref (input_location, begin, RO_UNARY_STAR,
14746 : : NULL_TREE, tf_warning_or_error);
14747 : 52679 : cp_finish_decl (range_decl, deref_begin,
14748 : : /*is_constant_init*/false, NULL_TREE,
14749 : : LOOKUP_ONLYCONVERTING, decomp);
14750 : :
14751 : 52679 : warn_for_range_copy (range_decl, deref_begin);
14752 : :
14753 : 52679 : return statement;
14754 : : }
14755 : :
14756 : : /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
14757 : : We need to solve both at the same time because the method used
14758 : : depends on the existence of members begin or end.
14759 : : Returns the type deduced for the iterator expression. */
14760 : :
14761 : : static tree
14762 : 99955 : cp_parser_perform_range_for_lookup (tree range, tree *begin, tree *end)
14763 : : {
14764 : 99955 : if (error_operand_p (range))
14765 : : {
14766 : 3 : *begin = *end = error_mark_node;
14767 : 3 : return error_mark_node;
14768 : : }
14769 : :
14770 : 99952 : if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (range))))
14771 : : {
14772 : 12 : error ("range-based %<for%> expression of type %qT "
14773 : 12 : "has incomplete type", TREE_TYPE (range));
14774 : 12 : *begin = *end = error_mark_node;
14775 : 12 : return error_mark_node;
14776 : : }
14777 : 99940 : if (TREE_CODE (TREE_TYPE (range)) == ARRAY_TYPE)
14778 : : {
14779 : : /* If RANGE is an array, we will use pointer arithmetic. */
14780 : 18475 : *begin = decay_conversion (range, tf_warning_or_error);
14781 : 18475 : *end = build_binary_op (input_location, PLUS_EXPR,
14782 : : range,
14783 : 18475 : array_type_nelts_top (TREE_TYPE (range)),
14784 : : false);
14785 : 18475 : return TREE_TYPE (*begin);
14786 : : }
14787 : : else
14788 : : {
14789 : : /* If it is not an array, we must do a bit of magic. */
14790 : 81465 : tree id_begin, id_end;
14791 : 81465 : tree member_begin, member_end;
14792 : :
14793 : 81465 : *begin = *end = error_mark_node;
14794 : :
14795 : 81465 : id_begin = get_identifier ("begin");
14796 : 81465 : id_end = get_identifier ("end");
14797 : 81465 : member_begin = lookup_member (TREE_TYPE (range), id_begin,
14798 : : /*protect=*/2, /*want_type=*/false,
14799 : : tf_warning_or_error);
14800 : 81465 : member_end = lookup_member (TREE_TYPE (range), id_end,
14801 : : /*protect=*/2, /*want_type=*/false,
14802 : : tf_warning_or_error);
14803 : :
14804 : 81465 : if (member_begin != NULL_TREE && member_end != NULL_TREE)
14805 : : {
14806 : : /* Use the member functions. */
14807 : 81150 : *begin = cp_parser_range_for_member_function (range, id_begin);
14808 : 81150 : *end = cp_parser_range_for_member_function (range, id_end);
14809 : : }
14810 : : else
14811 : : {
14812 : : /* Use global functions with ADL. */
14813 : 315 : releasing_vec vec;
14814 : :
14815 : 315 : vec_safe_push (vec, range);
14816 : :
14817 : 315 : member_begin = perform_koenig_lookup (id_begin, vec,
14818 : : tf_warning_or_error);
14819 : 315 : *begin = finish_call_expr (member_begin, &vec, false, true,
14820 : : tf_warning_or_error);
14821 : 315 : member_end = perform_koenig_lookup (id_end, vec,
14822 : : tf_warning_or_error);
14823 : 315 : *end = finish_call_expr (member_end, &vec, false, true,
14824 : : tf_warning_or_error);
14825 : 315 : }
14826 : :
14827 : : /* Last common checks. */
14828 : 81465 : if (*begin == error_mark_node || *end == error_mark_node)
14829 : : {
14830 : : /* If one of the expressions is an error do no more checks. */
14831 : 27 : *begin = *end = error_mark_node;
14832 : 27 : return error_mark_node;
14833 : : }
14834 : 81438 : else if (type_dependent_expression_p (*begin)
14835 : 81438 : || type_dependent_expression_p (*end))
14836 : : /* Can happen, when, eg, in a template context, Koenig lookup
14837 : : can't resolve begin/end (c++/58503). */
14838 : 6 : return NULL_TREE;
14839 : : else
14840 : : {
14841 : 81432 : tree iter_type = cv_unqualified (TREE_TYPE (*begin));
14842 : : /* The unqualified type of the __begin and __end temporaries should
14843 : : be the same, as required by the multiple auto declaration. */
14844 : 81432 : if (!same_type_p (iter_type, cv_unqualified (TREE_TYPE (*end))))
14845 : : {
14846 : 63 : if (cxx_dialect >= cxx17
14847 : 123 : && (build_x_binary_op (input_location, NE_EXPR,
14848 : : *begin, ERROR_MARK,
14849 : : *end, ERROR_MARK,
14850 : : NULL_TREE, NULL, tf_none)
14851 : 62 : != error_mark_node))
14852 : : /* P0184R0 allows __begin and __end to have different types,
14853 : : but make sure they are comparable so we can give a better
14854 : : diagnostic. */;
14855 : : else
14856 : 3 : error ("inconsistent begin/end types in range-based %<for%> "
14857 : : "statement: %qT and %qT",
14858 : 3 : TREE_TYPE (*begin), TREE_TYPE (*end));
14859 : : }
14860 : 81432 : return iter_type;
14861 : : }
14862 : : }
14863 : : }
14864 : :
14865 : : /* Helper function for cp_parser_perform_range_for_lookup.
14866 : : Builds a tree for RANGE.IDENTIFIER(). */
14867 : :
14868 : : static tree
14869 : 162300 : cp_parser_range_for_member_function (tree range, tree identifier)
14870 : : {
14871 : 162300 : tree member, res;
14872 : :
14873 : 162300 : member = finish_class_member_access_expr (range, identifier,
14874 : : false, tf_warning_or_error);
14875 : 162300 : if (member == error_mark_node)
14876 : : return error_mark_node;
14877 : :
14878 : 162291 : releasing_vec vec;
14879 : 162291 : res = finish_call_expr (member, &vec,
14880 : : /*disallow_virtual=*/false,
14881 : : /*koenig_p=*/false,
14882 : : tf_warning_or_error);
14883 : 162291 : return res;
14884 : 162291 : }
14885 : :
14886 : : /* Parse an iteration-statement.
14887 : :
14888 : : iteration-statement:
14889 : : while ( condition ) statement
14890 : : do statement while ( expression ) ;
14891 : : for ( init-statement condition [opt] ; expression [opt] )
14892 : : statement
14893 : :
14894 : : Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
14895 : :
14896 : : static tree
14897 : 12499819 : cp_parser_iteration_statement (cp_parser* parser, bool *if_p, bool ivdep,
14898 : : tree unroll, bool novector)
14899 : : {
14900 : 12499819 : cp_token *token;
14901 : 12499819 : enum rid keyword;
14902 : 12499819 : tree statement;
14903 : 12499819 : unsigned char in_statement;
14904 : 12499819 : token_indent_info guard_tinfo;
14905 : :
14906 : : /* Peek at the next token. */
14907 : 12499819 : token = cp_parser_require (parser, CPP_KEYWORD, RT_ITERATION);
14908 : 12499819 : if (!token)
14909 : 0 : return error_mark_node;
14910 : :
14911 : 12499819 : guard_tinfo = get_token_indent_info (token);
14912 : :
14913 : : /* Remember whether or not we are already within an iteration
14914 : : statement. */
14915 : 12499819 : in_statement = parser->in_statement;
14916 : :
14917 : : /* Special case for OMP loop intervening code. Parsing of permitted
14918 : : collapsed loop nests is handled elsewhere. */
14919 : 12499819 : if (parser->omp_for_parse_state)
14920 : : {
14921 : 48 : error_at (token->location,
14922 : : "loop not permitted in intervening code in OpenMP loop body");
14923 : 48 : parser->omp_for_parse_state->fail = true;
14924 : : }
14925 : :
14926 : : /* See what kind of keyword it is. */
14927 : 12499819 : keyword = token->keyword;
14928 : 12499819 : switch (keyword)
14929 : : {
14930 : 3325830 : case RID_WHILE:
14931 : 3325830 : {
14932 : 3325830 : tree condition;
14933 : :
14934 : : /* Begin the while-statement. */
14935 : 3325830 : statement = begin_while_stmt ();
14936 : : /* Look for the `('. */
14937 : 3325830 : matching_parens parens;
14938 : 3325830 : parens.require_open (parser);
14939 : : /* Parse the condition. */
14940 : 3325830 : condition = cp_parser_condition (parser, RID_WHILE);
14941 : 3325830 : finish_while_stmt_cond (condition, statement, ivdep, unroll, novector);
14942 : : /* Look for the `)'. */
14943 : 3325830 : parens.require_close (parser);
14944 : : /* Parse the dependent statement. */
14945 : 3325830 : parser->in_statement = IN_ITERATION_STMT;
14946 : 3325830 : bool prev = note_iteration_stmt_body_start ();
14947 : 3325830 : cp_parser_already_scoped_statement (parser, if_p, guard_tinfo);
14948 : 3325830 : note_iteration_stmt_body_end (prev);
14949 : 3325830 : parser->in_statement = in_statement;
14950 : : /* We're done with the while-statement. */
14951 : 3325830 : finish_while_stmt (statement);
14952 : : }
14953 : 3325830 : break;
14954 : :
14955 : 3783228 : case RID_DO:
14956 : 3783228 : {
14957 : 3783228 : tree expression;
14958 : :
14959 : : /* Begin the do-statement. */
14960 : 3783228 : statement = begin_do_stmt ();
14961 : : /* Parse the body of the do-statement. */
14962 : 3783228 : parser->in_statement = IN_ITERATION_STMT;
14963 : 3783228 : bool prev = note_iteration_stmt_body_start ();
14964 : 3783228 : cp_parser_implicitly_scoped_statement (parser, NULL, guard_tinfo);
14965 : 3783228 : note_iteration_stmt_body_end (prev);
14966 : 3783228 : parser->in_statement = in_statement;
14967 : 3783228 : finish_do_body (statement);
14968 : : /* Look for the `while' keyword. */
14969 : 3783228 : cp_parser_require_keyword (parser, RID_WHILE, RT_WHILE);
14970 : : /* Look for the `('. */
14971 : 3783228 : matching_parens parens;
14972 : 3783228 : parens.require_open (parser);
14973 : : /* Parse the expression. */
14974 : 3783228 : expression = cp_parser_expression (parser);
14975 : : /* We're done with the do-statement. */
14976 : 3783228 : finish_do_stmt (expression, statement, ivdep, unroll, novector);
14977 : : /* Look for the `)'. */
14978 : 3783228 : parens.require_close (parser);
14979 : : /* Look for the `;'. */
14980 : 3783228 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
14981 : : }
14982 : 3783228 : break;
14983 : :
14984 : 5390761 : case RID_FOR:
14985 : 5390761 : {
14986 : : /* Look for the `('. */
14987 : 5390761 : matching_parens parens;
14988 : 5390761 : parens.require_open (parser);
14989 : :
14990 : 5390761 : statement = cp_parser_for (parser, ivdep, unroll, novector);
14991 : :
14992 : : /* Look for the `)'. */
14993 : 5390761 : parens.require_close (parser);
14994 : :
14995 : : /* Parse the body of the for-statement. */
14996 : 5390761 : parser->in_statement = IN_ITERATION_STMT;
14997 : 5390761 : bool prev = note_iteration_stmt_body_start ();
14998 : 5390761 : cp_parser_already_scoped_statement (parser, if_p, guard_tinfo);
14999 : 5390761 : note_iteration_stmt_body_end (prev);
15000 : 5390761 : parser->in_statement = in_statement;
15001 : :
15002 : : /* We're done with the for-statement. */
15003 : 5390761 : finish_for_stmt (statement);
15004 : : }
15005 : 5390761 : break;
15006 : :
15007 : 0 : default:
15008 : 0 : cp_parser_error (parser, "expected iteration-statement");
15009 : 0 : statement = error_mark_node;
15010 : 0 : break;
15011 : : }
15012 : :
15013 : : return statement;
15014 : : }
15015 : :
15016 : : /* Parse an init-statement or the declarator of a range-based-for.
15017 : : Returns true if a range-based-for declaration is seen.
15018 : :
15019 : : init-statement:
15020 : : expression-statement
15021 : : simple-declaration
15022 : : alias-declaration */
15023 : :
15024 : : static bool
15025 : 5456437 : cp_parser_init_statement (cp_parser *parser, tree *decl)
15026 : : {
15027 : : /* If the next token is a `;', then we have an empty
15028 : : expression-statement. Grammatically, this is also a
15029 : : simple-declaration, but an invalid one, because it does not
15030 : : declare anything. Therefore, if we did not handle this case
15031 : : specially, we would issue an error message about an invalid
15032 : : declaration. */
15033 : 5456437 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
15034 : : {
15035 : 3925184 : bool is_range_for = false;
15036 : 3925184 : bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
15037 : :
15038 : : /* A colon is used in range-based for. */
15039 : 3925184 : parser->colon_corrects_to_scope_p = false;
15040 : :
15041 : : /* We're going to speculatively look for a declaration, falling back
15042 : : to an expression, if necessary. */
15043 : 3925184 : cp_parser_parse_tentatively (parser);
15044 : 3925184 : bool expect_semicolon_p = true;
15045 : 3925184 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
15046 : : {
15047 : 27 : cp_parser_alias_declaration (parser);
15048 : 27 : expect_semicolon_p = false;
15049 : 27 : if (cxx_dialect < cxx23
15050 : 27 : && !cp_parser_uncommitted_to_tentative_parse_p (parser))
15051 : 5 : pedwarn (cp_lexer_peek_token (parser->lexer)->location,
15052 : : OPT_Wc__23_extensions,
15053 : : "alias-declaration in init-statement only "
15054 : : "available with %<-std=c++23%> or %<-std=gnu++23%>");
15055 : : }
15056 : : else
15057 : : /* Parse the declaration. */
15058 : 3925157 : cp_parser_simple_declaration (parser,
15059 : : /*function_definition_allowed_p=*/false,
15060 : : decl);
15061 : 3925184 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
15062 : 3925184 : if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
15063 : : {
15064 : : /* It is a range-for, consume the ':'. */
15065 : 208569 : cp_lexer_consume_token (parser->lexer);
15066 : 208569 : is_range_for = true;
15067 : 208569 : if (cxx_dialect < cxx11)
15068 : 1 : pedwarn (cp_lexer_peek_token (parser->lexer)->location,
15069 : : OPT_Wc__11_extensions,
15070 : : "range-based %<for%> loops only available with "
15071 : : "%<-std=c++11%> or %<-std=gnu++11%>");
15072 : : }
15073 : 3716615 : else if (expect_semicolon_p)
15074 : : /* The ';' is not consumed yet because we told
15075 : : cp_parser_simple_declaration not to. */
15076 : 3716588 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
15077 : :
15078 : 3925184 : if (cp_parser_parse_definitely (parser))
15079 : : return is_range_for;
15080 : : /* If the tentative parse failed, then we shall need to look for an
15081 : : expression-statement. */
15082 : : }
15083 : : /* If we are here, it is an expression-statement. */
15084 : 1839990 : cp_parser_expression_statement (parser, NULL_TREE);
15085 : 1839990 : return false;
15086 : : }
15087 : :
15088 : : /* Parse a jump-statement.
15089 : :
15090 : : jump-statement:
15091 : : break ;
15092 : : continue ;
15093 : : return expression [opt] ;
15094 : : return braced-init-list ;
15095 : : coroutine-return-statement;
15096 : : goto identifier ;
15097 : :
15098 : : GNU extension:
15099 : :
15100 : : jump-statement:
15101 : : goto * expression ;
15102 : :
15103 : : STD_ATTRS are the statement attributes. They can be modified.
15104 : : Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
15105 : :
15106 : : static tree
15107 : 83730308 : cp_parser_jump_statement (cp_parser* parser, tree &std_attrs)
15108 : : {
15109 : 83730308 : tree statement = error_mark_node;
15110 : 83730308 : cp_token *token;
15111 : 83730308 : enum rid keyword;
15112 : 83730308 : unsigned char in_statement;
15113 : :
15114 : : /* Peek at the next token. */
15115 : 83730308 : token = cp_parser_require (parser, CPP_KEYWORD, RT_JUMP);
15116 : 83730308 : if (!token)
15117 : 0 : return error_mark_node;
15118 : :
15119 : : /* See what kind of keyword it is. */
15120 : 83730308 : keyword = token->keyword;
15121 : 83730308 : switch (keyword)
15122 : : {
15123 : 2262312 : case RID_BREAK:
15124 : 2262312 : in_statement = parser->in_statement & ~IN_IF_STMT;
15125 : 2262312 : switch (in_statement)
15126 : : {
15127 : 9 : case 0:
15128 : 9 : error_at (token->location, "break statement not within loop or switch");
15129 : 9 : break;
15130 : 2262270 : default:
15131 : 2262270 : gcc_assert ((in_statement & IN_SWITCH_STMT)
15132 : : || in_statement == IN_ITERATION_STMT);
15133 : 2262270 : statement = finish_break_stmt ();
15134 : 2262270 : if (in_statement == IN_ITERATION_STMT)
15135 : 1314396 : break_maybe_infinite_loop ();
15136 : : break;
15137 : 18 : case IN_OMP_BLOCK:
15138 : 18 : error_at (token->location, "invalid exit from OpenMP structured block");
15139 : 18 : break;
15140 : 15 : case IN_OMP_FOR:
15141 : 15 : error_at (token->location, "break statement used with OpenMP for loop");
15142 : 15 : break;
15143 : : }
15144 : 2262312 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
15145 : 2262312 : break;
15146 : :
15147 : 153949 : case RID_CONTINUE:
15148 : 153949 : switch (parser->in_statement & ~(IN_SWITCH_STMT | IN_IF_STMT))
15149 : : {
15150 : 3 : case 0:
15151 : 3 : error_at (token->location, "continue statement not within a loop");
15152 : 3 : break;
15153 : : /* Fall through. */
15154 : 153922 : case IN_ITERATION_STMT:
15155 : 153922 : case IN_OMP_FOR:
15156 : 153922 : statement = finish_continue_stmt ();
15157 : 153922 : break;
15158 : 24 : case IN_OMP_BLOCK:
15159 : 24 : error_at (token->location, "invalid exit from OpenMP structured block");
15160 : 24 : break;
15161 : 0 : default:
15162 : 0 : gcc_unreachable ();
15163 : : }
15164 : 153949 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
15165 : 153949 : break;
15166 : :
15167 : 81312723 : case RID_CO_RETURN:
15168 : 81312723 : case RID_RETURN:
15169 : 81312723 : {
15170 : 81312723 : tree expr;
15171 : :
15172 : 81312723 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
15173 : : {
15174 : 1099543 : cp_lexer_set_source_position (parser->lexer);
15175 : 1099543 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
15176 : 1099543 : expr = cp_parser_braced_list (parser);
15177 : : }
15178 : 80213180 : else if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
15179 : 79076370 : expr = cp_parser_expression (parser);
15180 : : else
15181 : : /* If the next token is a `;', then there is no
15182 : : expression. */
15183 : : expr = NULL_TREE;
15184 : :
15185 : 81312720 : if (keyword == RID_RETURN)
15186 : : {
15187 : 81311292 : bool musttail_p = false;
15188 : 81311292 : if (lookup_attribute ("gnu", "musttail", std_attrs))
15189 : : {
15190 : 55 : musttail_p = true;
15191 : 55 : std_attrs = remove_attribute ("gnu", "musttail", std_attrs);
15192 : : }
15193 : : /* Support this for compatibility. */
15194 : 81311292 : if (lookup_attribute ("clang", "musttail", std_attrs))
15195 : : {
15196 : 9 : musttail_p = true;
15197 : 9 : std_attrs = remove_attribute ("clang", "musttail", std_attrs);
15198 : : }
15199 : :
15200 : 81311292 : tree ret_expr = expr;
15201 : 81311292 : if (ret_expr && TREE_CODE (ret_expr) == TARGET_EXPR)
15202 : 1358285 : ret_expr = TARGET_EXPR_INITIAL (ret_expr);
15203 : 80174820 : if (ret_expr && TREE_CODE (ret_expr) == AGGR_INIT_EXPR)
15204 : 805688 : AGGR_INIT_EXPR_MUST_TAIL (ret_expr) = musttail_p;
15205 : : else
15206 : 80505604 : set_musttail_on_return (expr, token->location, musttail_p);
15207 : : }
15208 : :
15209 : : /* Build the return-statement, check co-return first, since type
15210 : : deduction is not valid there. */
15211 : 81312720 : if (keyword == RID_CO_RETURN)
15212 : 1428 : statement = finish_co_return_stmt (token->location, expr);
15213 : 81311292 : else if (FNDECL_USED_AUTO (current_function_decl) && in_discarded_stmt)
15214 : : /* Don't deduce from a discarded return statement. */;
15215 : : else
15216 : 81311287 : statement = finish_return_stmt (expr);
15217 : : /* Look for the final `;'. */
15218 : 81312720 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
15219 : : }
15220 : 81312720 : break;
15221 : :
15222 : 1324 : case RID_GOTO:
15223 : 1324 : if (parser->in_function_body
15224 : 1324 : && DECL_DECLARED_CONSTEXPR_P (current_function_decl)
15225 : 1350 : && cxx_dialect < cxx23)
15226 : : {
15227 : 24 : error ("%<goto%> in %<constexpr%> function only available with "
15228 : : "%<-std=c++2b%> or %<-std=gnu++2b%>");
15229 : 24 : cp_function_chain->invalid_constexpr = true;
15230 : : }
15231 : :
15232 : : /* Create the goto-statement. */
15233 : 1324 : if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
15234 : : {
15235 : : /* Issue a warning about this use of a GNU extension. */
15236 : 99 : pedwarn (token->location, OPT_Wpedantic, "ISO C++ forbids computed gotos");
15237 : : /* Consume the '*' token. */
15238 : 99 : cp_lexer_consume_token (parser->lexer);
15239 : : /* Parse the dependent expression. */
15240 : 99 : finish_goto_stmt (cp_parser_expression (parser));
15241 : : }
15242 : : else
15243 : 1225 : finish_goto_stmt (cp_parser_identifier (parser));
15244 : : /* Look for the final `;'. */
15245 : 1324 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
15246 : 1324 : break;
15247 : :
15248 : 0 : default:
15249 : 0 : cp_parser_error (parser, "expected jump-statement");
15250 : 0 : break;
15251 : : }
15252 : :
15253 : : return statement;
15254 : : }
15255 : :
15256 : : /* Parse a declaration-statement.
15257 : :
15258 : : declaration-statement:
15259 : : block-declaration */
15260 : :
15261 : : static void
15262 : 145812194 : cp_parser_declaration_statement (cp_parser* parser)
15263 : : {
15264 : 145812194 : void *p;
15265 : :
15266 : : /* Get the high-water mark for the DECLARATOR_OBSTACK. */
15267 : 145812194 : p = obstack_alloc (&declarator_obstack, 0);
15268 : :
15269 : : /* Parse the block-declaration. */
15270 : 145812194 : cp_parser_block_declaration (parser, /*statement_p=*/true);
15271 : :
15272 : : /* Free any declarators allocated. */
15273 : 145812191 : obstack_free (&declarator_obstack, p);
15274 : 145812191 : }
15275 : :
15276 : : /* Some dependent statements (like `if (cond) statement'), are
15277 : : implicitly in their own scope. In other words, if the statement is
15278 : : a single statement (as opposed to a compound-statement), it is
15279 : : none-the-less treated as if it were enclosed in braces. Any
15280 : : declarations appearing in the dependent statement are out of scope
15281 : : after control passes that point. This function parses a statement,
15282 : : but ensures that is in its own scope, even if it is not a
15283 : : compound-statement.
15284 : :
15285 : : If IF_P is not NULL, *IF_P is set to indicate whether the statement
15286 : : is a (possibly labeled) if statement which is not enclosed in
15287 : : braces and has an else clause. This is used to implement
15288 : : -Wparentheses.
15289 : :
15290 : : CHAIN is a vector of if-else-if conditions. This is used to implement
15291 : : -Wduplicated-cond.
15292 : :
15293 : : Returns the new statement. */
15294 : :
15295 : : static tree
15296 : 55262956 : cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p,
15297 : : const token_indent_info &guard_tinfo,
15298 : : vec<tree> *chain)
15299 : : {
15300 : 55262956 : tree statement;
15301 : 55262956 : location_t body_loc = cp_lexer_peek_token (parser->lexer)->location;
15302 : 55262956 : location_t body_loc_after_labels = UNKNOWN_LOCATION;
15303 : 55262956 : token_indent_info body_tinfo
15304 : 55262956 : = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
15305 : :
15306 : 55262956 : if (if_p != NULL)
15307 : 38116992 : *if_p = false;
15308 : :
15309 : : /* Mark if () ; with a special NOP_EXPR. */
15310 : 55262956 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
15311 : : {
15312 : 10630 : cp_lexer_consume_token (parser->lexer);
15313 : 10630 : statement = add_stmt (build_empty_stmt (body_loc));
15314 : :
15315 : 10630 : if (guard_tinfo.keyword == RID_IF
15316 : 10630 : && !cp_lexer_next_token_is_keyword (parser->lexer, RID_ELSE))
15317 : 910 : warning_at (body_loc, OPT_Wempty_body,
15318 : : "suggest braces around empty body in an %<if%> statement");
15319 : 9720 : else if (guard_tinfo.keyword == RID_ELSE)
15320 : 21 : warning_at (body_loc, OPT_Wempty_body,
15321 : : "suggest braces around empty body in an %<else%> statement");
15322 : : }
15323 : : /* if a compound is opened, we simply parse the statement directly. */
15324 : 55252326 : else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
15325 : 19533795 : statement = cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
15326 : : /* If the token is not a `{', then we must take special action. */
15327 : : else
15328 : : {
15329 : : /* Create a compound-statement. */
15330 : 35718531 : statement = begin_compound_stmt (0);
15331 : : /* Parse the dependent-statement. */
15332 : 35718531 : cp_parser_statement (parser, NULL_TREE, false, if_p, chain,
15333 : : &body_loc_after_labels);
15334 : : /* Finish the dummy compound-statement. */
15335 : 35718531 : finish_compound_stmt (statement);
15336 : : }
15337 : :
15338 : 55262956 : token_indent_info next_tinfo
15339 : 55262956 : = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
15340 : 55262956 : warn_for_misleading_indentation (guard_tinfo, body_tinfo, next_tinfo);
15341 : :
15342 : 55262956 : if (body_loc_after_labels != UNKNOWN_LOCATION
15343 : 18255877 : && next_tinfo.type != CPP_SEMICOLON)
15344 : 18243535 : warn_for_multistatement_macros (body_loc_after_labels, next_tinfo.location,
15345 : 18243535 : guard_tinfo.location, guard_tinfo.keyword);
15346 : :
15347 : : /* Return the statement. */
15348 : 55262956 : return statement;
15349 : : }
15350 : :
15351 : : /* For some dependent statements (like `while (cond) statement'), we
15352 : : have already created a scope. Therefore, even if the dependent
15353 : : statement is a compound-statement, we do not want to create another
15354 : : scope. */
15355 : :
15356 : : static void
15357 : 8716591 : cp_parser_already_scoped_statement (cp_parser* parser, bool *if_p,
15358 : : const token_indent_info &guard_tinfo)
15359 : : {
15360 : : /* If the token is a `{', then we must take special action. */
15361 : 8716591 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
15362 : : {
15363 : 4497162 : token_indent_info body_tinfo
15364 : 4497162 : = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
15365 : 4497162 : location_t loc_after_labels = UNKNOWN_LOCATION;
15366 : :
15367 : 4497162 : cp_parser_statement (parser, NULL_TREE, false, if_p, NULL,
15368 : : &loc_after_labels);
15369 : 4497162 : token_indent_info next_tinfo
15370 : 4497162 : = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
15371 : 4497162 : warn_for_misleading_indentation (guard_tinfo, body_tinfo, next_tinfo);
15372 : :
15373 : 4497162 : if (loc_after_labels != UNKNOWN_LOCATION
15374 : 3481330 : && next_tinfo.type != CPP_SEMICOLON)
15375 : 3471926 : warn_for_multistatement_macros (loc_after_labels, next_tinfo.location,
15376 : 3471926 : guard_tinfo.location,
15377 : 3471926 : guard_tinfo.keyword);
15378 : : }
15379 : : else
15380 : : {
15381 : : /* Avoid calling cp_parser_compound_statement, so that we
15382 : : don't create a new scope. Do everything else by hand. */
15383 : 4219429 : matching_braces braces;
15384 : 4219429 : braces.require_open (parser);
15385 : : /* If the next keyword is `__label__' we have a label declaration. */
15386 : 8438864 : while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
15387 : 6 : cp_parser_label_declaration (parser);
15388 : : /* Parse an (optional) statement-seq. */
15389 : 4219429 : cp_parser_statement_seq_opt (parser, NULL_TREE);
15390 : 4219429 : braces.require_close (parser);
15391 : : }
15392 : 8716591 : }
15393 : :
15394 : : /* Modules */
15395 : :
15396 : : /* Parse a module-name or module-partition.
15397 : :
15398 : : module-name:
15399 : : module-name-qualifier [opt] identifier
15400 : :
15401 : : module-partition:
15402 : : : module-name-qualifier [opt] identifier
15403 : :
15404 : : module-name-qualifier:
15405 : : identifier .
15406 : : module-name-qualifier identifier .
15407 : :
15408 : : Returns a pointer to the module object, or NULL on failure.
15409 : : For PARTITION_P, PARENT is the module this is a partition of. */
15410 : :
15411 : : static module_state *
15412 : 3064 : cp_parser_module_name (cp_parser *parser, bool partition_p = false,
15413 : : module_state *parent = NULL)
15414 : : {
15415 : 3064 : if (partition_p
15416 : 3064 : && cp_lexer_consume_token (parser->lexer)->type != CPP_COLON)
15417 : : return NULL;
15418 : :
15419 : 3536 : for (;;)
15420 : : {
15421 : 3300 : if (cp_lexer_peek_token (parser->lexer)->type != CPP_NAME)
15422 : : {
15423 : 6 : if (partition_p)
15424 : 0 : cp_parser_error (parser, "expected module-partition");
15425 : : else
15426 : 6 : cp_parser_error (parser, "expected module-name");
15427 : 6 : return NULL;
15428 : : }
15429 : :
15430 : 3294 : tree name = cp_lexer_consume_token (parser->lexer)->u.value;
15431 : 3294 : parent = get_module (name, parent, partition_p);
15432 : 3294 : if (cp_lexer_peek_token (parser->lexer)->type != CPP_DOT)
15433 : : break;
15434 : :
15435 : 236 : cp_lexer_consume_token (parser->lexer);
15436 : 236 : }
15437 : :
15438 : : return parent;
15439 : : }
15440 : :
15441 : : /* Parse a module-partition. Defers to cp_parser_module_name. */
15442 : :
15443 : : static module_state *
15444 : 326 : cp_parser_module_partition (cp_parser *parser, module_state *parent = NULL)
15445 : : {
15446 : 0 : return cp_parser_module_name (parser, /*partition_p=*/true, parent);
15447 : : }
15448 : :
15449 : : /* Named module-declaration
15450 : : __module ; PRAGMA_EOL
15451 : : __module : private ; PRAGMA_EOL (unimplemented)
15452 : : [__export] __module module-name module-partition [opt]
15453 : : attr-spec-seq-opt ; PRAGMA_EOL
15454 : : */
15455 : :
15456 : : static module_parse
15457 : 2041 : cp_parser_module_declaration (cp_parser *parser, module_parse mp_state,
15458 : : bool exporting)
15459 : : {
15460 : : /* We're a pseudo pragma. */
15461 : 2041 : parser->lexer->in_pragma = true;
15462 : 2041 : cp_token *token = cp_lexer_consume_token (parser->lexer);
15463 : :
15464 : 2041 : tree scope = current_scope ();
15465 : 2041 : if (flag_header_unit)
15466 : : {
15467 : 3 : error_at (token->location,
15468 : : "module-declaration not permitted in header-unit");
15469 : 3 : goto skip_eol;
15470 : : }
15471 : 2038 : else if (scope != global_namespace)
15472 : : {
15473 : 6 : auto_diagnostic_group d;
15474 : 6 : error_at (token->location, "module-declaration must be at global scope");
15475 : 6 : inform (DECL_SOURCE_LOCATION (scope), "scope opened here");
15476 : 6 : goto skip_eol;
15477 : 6 : }
15478 : 2032 : else if (mp_state == MP_FIRST && !exporting
15479 : 2032 : && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
15480 : : {
15481 : : /* Start global module fragment. */
15482 : 297 : cp_lexer_consume_token (parser->lexer);
15483 : 297 : module_kind = MK_NAMED;
15484 : 297 : mp_state = MP_GLOBAL;
15485 : 297 : cp_parser_require_pragma_eol (parser, token);
15486 : : }
15487 : 1735 : else if (!exporting
15488 : 281 : && cp_lexer_next_token_is (parser->lexer, CPP_COLON)
15489 : 24 : && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_PRIVATE)
15490 : 1756 : && cp_lexer_nth_token_is (parser->lexer, 3, CPP_SEMICOLON))
15491 : : {
15492 : 21 : cp_lexer_consume_token (parser->lexer);
15493 : 21 : cp_lexer_consume_token (parser->lexer);
15494 : 21 : cp_lexer_consume_token (parser->lexer);
15495 : 21 : cp_parser_require_pragma_eol (parser, token);
15496 : :
15497 : 21 : if ((mp_state == MP_PURVIEW || mp_state == MP_PURVIEW_IMPORTS)
15498 : 21 : && module_has_cmi_p ())
15499 : : {
15500 : 15 : mp_state = MP_PRIVATE_IMPORTS;
15501 : 15 : sorry_at (token->location, "private module fragment");
15502 : : }
15503 : : else
15504 : 6 : error_at (token->location,
15505 : : "private module fragment only permitted in purview"
15506 : : " of module interface or partition");
15507 : : }
15508 : 1714 : else if (!(mp_state == MP_FIRST || mp_state == MP_GLOBAL))
15509 : : {
15510 : : /* Neither the first declaration, nor in a GMF. */
15511 : 12 : error_at (token->location, "module-declaration only permitted as first"
15512 : : " declaration, or ending a global module fragment");
15513 : 33 : skip_eol:
15514 : 33 : cp_parser_skip_to_pragma_eol (parser, token);
15515 : : }
15516 : : else
15517 : : {
15518 : 1702 : module_state *mod = cp_parser_module_name (parser);
15519 : 1702 : if (mod && cp_lexer_peek_token (parser->lexer)->type == CPP_COLON)
15520 : 157 : mod = cp_parser_module_partition (parser, mod);
15521 : 1702 : tree attrs = cp_parser_attributes_opt (parser);
15522 : :
15523 : 1702 : if (mod)
15524 : 1696 : mp_state = MP_PURVIEW_IMPORTS;
15525 : 1696 : if (!mod || !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
15526 : 12 : goto skip_eol;
15527 : :
15528 : 1690 : declare_module (mod, token->location, exporting, attrs, parse_in);
15529 : 1690 : cp_parser_require_pragma_eol (parser, token);
15530 : : }
15531 : :
15532 : 2041 : return mp_state;
15533 : : }
15534 : :
15535 : : /* Import-declaration
15536 : : __import module-name attr-spec-seq-opt ; PRAGMA_EOL
15537 : : __import module-partition attr-spec-seq-opt ; PRAGMA_EOL
15538 : : __import header-name attr-spec-seq-opt ; PRAGMA_EOL
15539 : : */
15540 : :
15541 : : static void
15542 : 2000 : cp_parser_import_declaration (cp_parser *parser, module_parse mp_state,
15543 : : bool exporting)
15544 : : {
15545 : : /* We're a pseudo pragma. */
15546 : 2000 : parser->lexer->in_pragma = true;
15547 : 2000 : cp_token *token = cp_lexer_consume_token (parser->lexer);
15548 : :
15549 : 2000 : if (mp_state == MP_PURVIEW || mp_state == MP_PRIVATE)
15550 : : {
15551 : 15 : auto_diagnostic_group d;
15552 : 15 : error_at (token->location, "post-module-declaration"
15553 : : " imports must be contiguous");
15554 : 15 : inform (token->location, "perhaps insert a line break after"
15555 : : " %<import%>, or other disambiguation, to prevent this"
15556 : : " being considered a module control-line");
15557 : 15 : cp_parser_skip_to_pragma_eol (parser, token);
15558 : 15 : }
15559 : 1985 : else if (current_scope () != global_namespace)
15560 : : {
15561 : 0 : auto_diagnostic_group d;
15562 : 0 : error_at (token->location, "import-declaration must be at global scope");
15563 : 0 : inform (token->location, "perhaps insert a line break after"
15564 : : " %<import%>, or other disambiguation, to prevent this"
15565 : : " being considered a module control-line");
15566 : 0 : cp_parser_skip_to_pragma_eol (parser, token);
15567 : 0 : }
15568 : : else
15569 : : {
15570 : 1985 : module_state *mod = NULL;
15571 : 1985 : cp_token *next = cp_lexer_peek_token (parser->lexer);
15572 : 1985 : if (next->type == CPP_HEADER_NAME)
15573 : : {
15574 : 777 : cp_lexer_consume_token (parser->lexer);
15575 : 777 : mod = get_module (next->u.value);
15576 : : }
15577 : 1208 : else if (next->type == CPP_COLON)
15578 : : {
15579 : : /* An import specifying a module-partition shall only appear after the
15580 : : module-declaration in a module unit: [module.import]/4. */
15581 : 172 : if (named_module_p ()
15582 : 172 : && (mp_state == MP_PURVIEW_IMPORTS
15583 : 172 : || mp_state == MP_PRIVATE_IMPORTS))
15584 : 169 : mod = cp_parser_module_partition (parser);
15585 : : else
15586 : 3 : error_at (next->location, "import specifying a module-partition"
15587 : : " must appear after a named module-declaration");
15588 : : }
15589 : : else
15590 : 1036 : mod = cp_parser_module_name (parser);
15591 : 1985 : tree attrs = cp_parser_attributes_opt (parser);
15592 : :
15593 : 1985 : if (!mod || !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
15594 : : {
15595 : 12 : cp_parser_skip_to_pragma_eol (parser, token);
15596 : 12 : return;
15597 : : }
15598 : 1973 : cp_parser_require_pragma_eol (parser, token);
15599 : :
15600 : 1973 : if (mp_state == MP_PURVIEW_IMPORTS || mp_state == MP_PRIVATE_IMPORTS)
15601 : : {
15602 : : /* Module-purview imports must not be from source inclusion
15603 : : [cpp.import]/7 */
15604 : 428 : if (attrs
15605 : 428 : && private_lookup_attribute ("__translated",
15606 : : strlen ("__translated"), attrs))
15607 : 3 : error_at (token->location, "post-module-declaration imports"
15608 : : " must not be include-translated");
15609 : 425 : else if (!token->main_source_p)
15610 : 3 : error_at (token->location, "post-module-declaration imports"
15611 : : " must not be from header inclusion");
15612 : : }
15613 : :
15614 : 1973 : import_module (mod, token->location, exporting, attrs, parse_in);
15615 : : }
15616 : : }
15617 : :
15618 : : /* export-declaration.
15619 : :
15620 : : export name-declaration
15621 : : export { declaration-seq-opt } */
15622 : :
15623 : : static void
15624 : 1811 : cp_parser_module_export (cp_parser *parser)
15625 : : {
15626 : 1811 : gcc_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT));
15627 : 1811 : cp_token *token = cp_lexer_consume_token (parser->lexer);
15628 : :
15629 : 1811 : if (!module_interface_p ())
15630 : 15 : error_at (token->location,
15631 : : "%qE may only occur after a module interface declaration",
15632 : : token->u.value);
15633 : :
15634 : 1811 : bool braced = cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE);
15635 : :
15636 : 1811 : unsigned mk = module_kind;
15637 : 1811 : if (module_exporting_p ())
15638 : 12 : error_at (token->location,
15639 : : "%qE may only occur once in an export declaration",
15640 : : token->u.value);
15641 : 1811 : module_kind |= MK_EXPORTING;
15642 : :
15643 : 1811 : if (braced)
15644 : : {
15645 : 36 : cp_ensure_no_omp_declare_simd (parser);
15646 : 36 : cp_ensure_no_oacc_routine (parser);
15647 : :
15648 : 36 : cp_lexer_consume_token (parser->lexer);
15649 : 36 : cp_parser_declaration_seq_opt (parser);
15650 : 36 : cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
15651 : : }
15652 : : else
15653 : : {
15654 : : /* Explicitly check if the next tokens might be a
15655 : : module-directive line, so we can give a clearer error message
15656 : : about why the directive will be rejected. */
15657 : 1775 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID__MODULE)
15658 : 1775 : || cp_lexer_next_token_is_keyword (parser->lexer, RID__IMPORT)
15659 : 3547 : || cp_lexer_next_token_is_keyword (parser->lexer, RID__EXPORT))
15660 : 3 : error_at (token->location, "%<export%> not part of following"
15661 : : " module-directive");
15662 : :
15663 : 1775 : bool saved_in_unbraced_export_declaration_p
15664 : : = parser->in_unbraced_export_declaration_p;
15665 : 1775 : parser->in_unbraced_export_declaration_p = true;
15666 : 1775 : cp_parser_declaration (parser, NULL_TREE);
15667 : 1775 : parser->in_unbraced_export_declaration_p
15668 : 1775 : = saved_in_unbraced_export_declaration_p;
15669 : : }
15670 : :
15671 : 1811 : module_kind = mk;
15672 : 1811 : }
15673 : :
15674 : : /* Used for maybe_warn_extra_semi. */
15675 : :
15676 : : enum class extra_semi_kind { decl, member, in_class_fn_def };
15677 : :
15678 : : /* Warn about an extra semicolon. KIND says in which context the extra
15679 : : semicolon occurs. */
15680 : :
15681 : : static void
15682 : 103149 : maybe_warn_extra_semi (location_t loc, extra_semi_kind kind)
15683 : : {
15684 : : /* -Wno-extra-semi suppresses all. */
15685 : 103149 : if (warn_extra_semi == 0)
15686 : 78 : return;
15687 : :
15688 : 103071 : gcc_rich_location richloc (loc);
15689 : 103071 : richloc.add_fixit_remove ();
15690 : :
15691 : 103071 : switch (kind)
15692 : : {
15693 : 77644 : case extra_semi_kind::decl:
15694 : : /* If -Wextra-semi wasn't specified, warn only when -pedantic is in
15695 : : effect in C++98. DR 569 says that spurious semicolons at namespace
15696 : : scope should be allowed. */
15697 : 77644 : if (pedantic && cxx_dialect < cxx11)
15698 : 49 : pedwarn (&richloc, OPT_Wextra_semi,
15699 : : "extra %<;%> outside of a function only allowed in C++11");
15700 : 77595 : else if (warn_extra_semi > 0)
15701 : 48 : warning_at (&richloc, OPT_Wextra_semi,
15702 : : "extra %<;%> outside of a function");
15703 : : break;
15704 : :
15705 : 130 : case extra_semi_kind::member:
15706 : : /* If -Wextra-semi wasn't specified, warn only when -pedantic is in
15707 : : effect in C++98. DR 1693 added "empty-declaration" to the syntax for
15708 : : "member-declaration". */
15709 : 130 : if (pedantic && cxx_dialect < cxx11)
15710 : 27 : pedwarn (&richloc, OPT_Wextra_semi,
15711 : : "extra %<;%> inside a struct only allowed in C++11");
15712 : 103 : else if (warn_extra_semi > 0)
15713 : 25 : warning_at (&richloc, OPT_Wextra_semi, "extra %<;%> inside a struct");
15714 : : break;
15715 : :
15716 : 25297 : case extra_semi_kind::in_class_fn_def:
15717 : : /* A single semicolon is valid after a member function definition
15718 : : so this is just a warning. */
15719 : 25297 : if (warn_extra_semi > 0)
15720 : 12 : warning_at (&richloc, OPT_Wextra_semi,
15721 : : "extra %<;%> after in-class function definition");
15722 : : break;
15723 : :
15724 : 0 : default:
15725 : 0 : gcc_unreachable ();
15726 : : }
15727 : 103071 : }
15728 : :
15729 : : /* Declarations [gram.dcl.dcl] */
15730 : :
15731 : : /* Parse an optional declaration-sequence. TOP_LEVEL is true, if this
15732 : : is the top-level declaration sequence. That affects whether we
15733 : : deal with module-preamble.
15734 : :
15735 : : declaration-seq:
15736 : : declaration
15737 : : declaration-seq declaration */
15738 : :
15739 : : static void
15740 : 5834232 : cp_parser_declaration_seq_opt (cp_parser* parser)
15741 : : {
15742 : 5834232 : bool saved_in_unbraced_linkage_specification_p
15743 : : = parser->in_unbraced_linkage_specification_p;
15744 : 5834232 : bool saved_in_unbraced_export_declaration_p
15745 : : = parser->in_unbraced_export_declaration_p;
15746 : :
15747 : : /* We're not in an unbraced linkage-specification
15748 : : or export-declaration anymore. */
15749 : 5834232 : parser->in_unbraced_linkage_specification_p = false;
15750 : 5834232 : parser->in_unbraced_export_declaration_p = false;
15751 : :
15752 : 246574011 : while (true)
15753 : : {
15754 : 126204117 : cp_token *token = cp_lexer_peek_token (parser->lexer);
15755 : :
15756 : 126204117 : if (token->type == CPP_CLOSE_BRACE
15757 : 120369921 : || token->type == CPP_EOF)
15758 : : break;
15759 : : else
15760 : 120369894 : cp_parser_toplevel_declaration (parser);
15761 : 120369885 : }
15762 : :
15763 : 5834223 : parser->in_unbraced_linkage_specification_p
15764 : 5834223 : = saved_in_unbraced_linkage_specification_p;
15765 : 5834223 : parser->in_unbraced_export_declaration_p
15766 : 5834223 : = saved_in_unbraced_export_declaration_p;
15767 : 5834223 : }
15768 : :
15769 : : /* Parse a declaration. The distinction between name-declaration
15770 : : and special-declaration is only since C++20.
15771 : :
15772 : : declaration:
15773 : : name-declaration
15774 : : special-declaration
15775 : :
15776 : : name-declaration:
15777 : : block-declaration
15778 : : nodeclspec-function-declaration
15779 : : function-definition
15780 : : template-declaration
15781 : : deduction-guide (C++17)
15782 : : linkage-specification
15783 : : namespace-definition
15784 : : empty-declaration
15785 : : attribute-declaration
15786 : : module-import-declaration (modules)
15787 : :
15788 : : special-declaration:
15789 : : explicit-instantiation
15790 : : explicit-specialization
15791 : : export-declaration (modules)
15792 : :
15793 : : GNU extension:
15794 : :
15795 : : declaration:
15796 : : __extension__ declaration */
15797 : :
15798 : : static void
15799 : 126710816 : cp_parser_declaration (cp_parser* parser, tree prefix_attrs)
15800 : : {
15801 : 126710816 : int saved_pedantic;
15802 : :
15803 : : /* Check for the `__extension__' keyword. */
15804 : 126710816 : if (cp_parser_extension_opt (parser, &saved_pedantic))
15805 : : {
15806 : : /* Parse the qualified declaration. */
15807 : 869376 : cp_parser_declaration (parser, prefix_attrs);
15808 : : /* Restore the PEDANTIC flag. */
15809 : 869376 : pedantic = saved_pedantic;
15810 : :
15811 : 947449 : return;
15812 : : }
15813 : :
15814 : : /* P2615: Determine if we're parsing a name-declaration specifically,
15815 : : or if special-declarations are OK too. */
15816 : 251682880 : bool require_name_decl_p
15817 : 125841440 : = (parser->in_unbraced_export_declaration_p
15818 : 125841440 : || (parser->in_unbraced_linkage_specification_p
15819 : 335455 : && cxx_dialect >= cxx20));
15820 : :
15821 : : /* Try to figure out what kind of declaration is present. */
15822 : 125841440 : cp_token *token1 = cp_lexer_peek_token (parser->lexer);
15823 : 125841440 : cp_token *token2 = (token1->type == CPP_EOF
15824 : 125841440 : ? token1 : cp_lexer_peek_nth_token (parser->lexer, 2));
15825 : :
15826 : 125841440 : if (token1->type == CPP_SEMICOLON)
15827 : : {
15828 : 77704 : location_t semicolon_loc
15829 : 77704 : = cp_lexer_consume_token (parser->lexer)->location;
15830 : : /* A declaration consisting of a single semicolon is invalid
15831 : : before C++11. Allow it unless we're being pedantic. */
15832 : 77704 : maybe_warn_extra_semi (semicolon_loc, extra_semi_kind::decl);
15833 : 77704 : return;
15834 : : }
15835 : 125763736 : else if (cp_lexer_nth_token_is (parser->lexer,
15836 : : cp_parser_skip_std_attribute_spec_seq (parser,
15837 : : 1),
15838 : : CPP_SEMICOLON))
15839 : : {
15840 : 369 : location_t attrs_loc = token1->location;
15841 : 369 : tree std_attrs = cp_parser_std_attribute_spec_seq (parser);
15842 : :
15843 : 369 : if (std_attrs && (flag_openmp || flag_openmp_simd))
15844 : : {
15845 : 257 : gcc_assert (!parser->lexer->in_omp_attribute_pragma);
15846 : 257 : std_attrs = cp_parser_handle_statement_omp_attributes (parser,
15847 : : std_attrs);
15848 : 257 : if (parser->lexer->in_omp_attribute_pragma)
15849 : : {
15850 : : cp_lexer *lexer = parser->lexer;
15851 : 511 : while (parser->lexer->in_omp_attribute_pragma)
15852 : : {
15853 : 257 : gcc_assert (cp_lexer_next_token_is (parser->lexer,
15854 : : CPP_PRAGMA));
15855 : 257 : cp_parser_pragma (parser, pragma_external, NULL);
15856 : : }
15857 : 254 : cp_lexer_destroy (lexer);
15858 : : }
15859 : : }
15860 : :
15861 : 333 : if (std_attrs != NULL_TREE && any_nonignored_attribute_p (std_attrs))
15862 : 61 : warning_at (make_location (attrs_loc, attrs_loc, parser->lexer),
15863 : : OPT_Wattributes, "attribute ignored");
15864 : 369 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
15865 : 369 : cp_lexer_consume_token (parser->lexer);
15866 : 369 : return;
15867 : : }
15868 : :
15869 : : /* Get the high-water mark for the DECLARATOR_OBSTACK. */
15870 : 125763367 : void *p = obstack_alloc (&declarator_obstack, 0);
15871 : :
15872 : 125763367 : tree attributes = NULL_TREE;
15873 : :
15874 : : /* Conditionally, allow attributes to precede a linkage specification. */
15875 : 125763367 : if (token1->keyword == RID_ATTRIBUTE)
15876 : : {
15877 : 319075 : cp_lexer_save_tokens (parser->lexer);
15878 : 319075 : attributes = cp_parser_attributes_opt (parser);
15879 : 319075 : cp_token *t1 = cp_lexer_peek_token (parser->lexer);
15880 : 319075 : cp_token *t2 = (t1->type == CPP_EOF
15881 : 319075 : ? t1 : cp_lexer_peek_nth_token (parser->lexer, 2));
15882 : 319075 : if (t1->keyword == RID_EXTERN
15883 : 319075 : && cp_parser_is_pure_string_literal (t2))
15884 : : {
15885 : 0 : cp_lexer_commit_tokens (parser->lexer);
15886 : : /* We might have already been here. */
15887 : 0 : if (!c_dialect_objc ())
15888 : : {
15889 : 0 : location_t where = get_finish (t2->location);
15890 : 0 : auto_diagnostic_group d;
15891 : 0 : warning_at (token1->location, OPT_Wattributes, "attributes are"
15892 : : " not permitted in this position");
15893 : 0 : where = linemap_position_for_loc_and_offset (line_table,
15894 : : where, 1);
15895 : 0 : inform (where, "attributes may be inserted here");
15896 : 0 : attributes = NULL_TREE;
15897 : 0 : }
15898 : : token1 = t1;
15899 : : token2 = t2;
15900 : : }
15901 : : else
15902 : : {
15903 : 319075 : cp_lexer_rollback_tokens (parser->lexer);
15904 : 319075 : attributes = NULL_TREE;
15905 : : }
15906 : : }
15907 : : /* If we already had some attributes, and we've added more, then prepend.
15908 : : Otherwise attributes just contains any that we just read. */
15909 : 125763367 : if (prefix_attrs)
15910 : : {
15911 : 0 : if (attributes)
15912 : 0 : TREE_CHAIN (prefix_attrs) = attributes;
15913 : 0 : attributes = prefix_attrs;
15914 : : }
15915 : :
15916 : : /* If the next token is `extern' and the following token is a string
15917 : : literal, then we have a linkage specification. */
15918 : 125763367 : if (token1->keyword == RID_EXTERN
15919 : 125763367 : && cp_parser_is_pure_string_literal (token2))
15920 : 1043510 : cp_parser_linkage_specification (parser, attributes);
15921 : : /* If the next token is `template', then we have either a template
15922 : : declaration, an explicit instantiation, or an explicit
15923 : : specialization. */
15924 : 124719857 : else if (token1->keyword == RID_TEMPLATE)
15925 : : {
15926 : : /* `template <>' indicates a template specialization. */
15927 : 59099622 : if (token2->type == CPP_LESS
15928 : 59099622 : && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
15929 : : {
15930 : 4810827 : if (require_name_decl_p)
15931 : : {
15932 : 4 : auto_diagnostic_group d;
15933 : 4 : cp_token *token3 = cp_lexer_peek_nth_token (parser->lexer, 3);
15934 : 4 : location_t loc = make_location (token1, token1, token3);
15935 : 4 : error_at (loc, "explicit specializations are not permitted here");
15936 : 4 : if (parser->in_unbraced_export_declaration_p)
15937 : 3 : inform (loc, "a specialization is always exported alongside "
15938 : : "its primary template");
15939 : 4 : }
15940 : 4810827 : cp_parser_explicit_specialization (parser);
15941 : : }
15942 : : /* `template <' indicates a template declaration. */
15943 : 54288795 : else if (token2->type == CPP_LESS)
15944 : 54283114 : cp_parser_template_declaration (parser, /*member_p=*/false);
15945 : : /* Anything else must be an explicit instantiation. */
15946 : : else
15947 : : {
15948 : 5681 : if (require_name_decl_p)
15949 : 5 : error_at (token1->location,
15950 : : "explicit instantiations are not permitted here");
15951 : 5681 : cp_parser_explicit_instantiation (parser);
15952 : : }
15953 : : }
15954 : : /* If the next token is `export', it's new-style modules or
15955 : : old-style template. */
15956 : 65620235 : else if (token1->keyword == RID_EXPORT)
15957 : : {
15958 : 1831 : if (!modules_p ())
15959 : 20 : cp_parser_template_declaration (parser, /*member_p=*/false);
15960 : : else
15961 : : {
15962 : : /* We check for nested exports in cp_parser_module_export. */
15963 : 1811 : if (require_name_decl_p
15964 : 8 : && !parser->in_unbraced_export_declaration_p)
15965 : 2 : error_at (token1->location,
15966 : : "export-declarations are not permitted here");
15967 : 1811 : cp_parser_module_export (parser);
15968 : : }
15969 : : }
15970 : 65618404 : else if (cp_token_is_module_directive (token1))
15971 : : {
15972 : 27 : bool exporting = token1->keyword == RID__EXPORT;
15973 : 27 : cp_token *next = exporting ? token2 : token1;
15974 : 3 : if (exporting)
15975 : 3 : cp_lexer_consume_token (parser->lexer);
15976 : : // In module purview this will be ill-formed.
15977 : 27 : auto state = (!named_module_p () ? MP_NOT_MODULE
15978 : 9 : : module_purview_p () ? MP_PURVIEW
15979 : 27 : : MP_GLOBAL);
15980 : 27 : if (next->keyword == RID__MODULE)
15981 : 6 : cp_parser_module_declaration (parser, state, exporting);
15982 : : else
15983 : 21 : cp_parser_import_declaration (parser, state, exporting);
15984 : : }
15985 : : /* If the next token is `extern', 'static' or 'inline' and the one
15986 : : after that is `template', we have a GNU extended explicit
15987 : : instantiation directive. */
15988 : 65618377 : else if (cp_parser_allow_gnu_extensions_p (parser)
15989 : 65618377 : && token2->keyword == RID_TEMPLATE
15990 : 65618377 : && (token1->keyword == RID_EXTERN
15991 : : || token1->keyword == RID_STATIC
15992 : : || token1->keyword == RID_INLINE))
15993 : 2738510 : cp_parser_explicit_instantiation (parser);
15994 : : /* If the next token is `namespace', check for a named or unnamed
15995 : : namespace definition. */
15996 : 62879867 : else if (token1->keyword == RID_NAMESPACE
15997 : 62879867 : && (/* A named namespace definition. */
15998 : 4916449 : (token2->type == CPP_NAME
15999 : 4914687 : && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
16000 : : != CPP_EQ))
16001 : 6748 : || (token2->type == CPP_OPEN_SQUARE
16002 : 104 : && cp_lexer_peek_nth_token (parser->lexer, 3)->type
16003 : : == CPP_OPEN_SQUARE)
16004 : : /* An unnamed namespace definition. */
16005 : 6644 : || token2->type == CPP_OPEN_BRACE
16006 : 5016 : || token2->keyword == RID_ATTRIBUTE))
16007 : 4911445 : cp_parser_namespace_definition (parser);
16008 : : /* An inline (associated) namespace definition. */
16009 : 57968422 : else if (token2->keyword == RID_NAMESPACE
16010 : 245108 : && token1->keyword == RID_INLINE)
16011 : 214777 : cp_parser_namespace_definition (parser);
16012 : : /* Objective-C++ declaration/definition. */
16013 : 57753645 : else if (c_dialect_objc () && OBJC_IS_AT_KEYWORD (token1->keyword))
16014 : 0 : cp_parser_objc_declaration (parser, attributes);
16015 : 57753645 : else if (c_dialect_objc ()
16016 : 0 : && token1->keyword == RID_ATTRIBUTE
16017 : 57753645 : && cp_parser_objc_valid_prefix_attributes (parser, &attributes))
16018 : 0 : cp_parser_objc_declaration (parser, attributes);
16019 : : /* At this point we may have a template declared by a concept
16020 : : introduction. */
16021 : 57753645 : else if (flag_concepts
16022 : 57753645 : && cp_parser_template_declaration_after_export (parser,
16023 : : /*member_p=*/false))
16024 : : /* We did. */;
16025 : : else
16026 : : /* Try to parse a block-declaration, or a function-definition. */
16027 : 57753645 : cp_parser_block_declaration (parser, /*statement_p=*/false);
16028 : :
16029 : : /* Free any declarators allocated. */
16030 : 125763301 : obstack_free (&declarator_obstack, p);
16031 : : }
16032 : :
16033 : : /* Parse a namespace-scope declaration. */
16034 : :
16035 : : static void
16036 : 129239279 : cp_parser_toplevel_declaration (cp_parser* parser)
16037 : : {
16038 : 129239279 : cp_token *token = cp_lexer_peek_token (parser->lexer);
16039 : :
16040 : 129239279 : if (token->type == CPP_PRAGMA)
16041 : : /* A top-level declaration can consist solely of a #pragma. A
16042 : : nested declaration cannot, so this is done here and not in
16043 : : cp_parser_declaration. (A #pragma at block scope is
16044 : : handled in cp_parser_statement.) */
16045 : 3737367 : cp_parser_pragma (parser, pragma_external, NULL);
16046 : : else
16047 : : /* Parse the declaration itself. */
16048 : 125501912 : cp_parser_declaration (parser, NULL_TREE);
16049 : 129239213 : }
16050 : :
16051 : : /* Parse a block-declaration.
16052 : :
16053 : : block-declaration:
16054 : : simple-declaration
16055 : : asm-definition
16056 : : namespace-alias-definition
16057 : : using-declaration
16058 : : using-directive
16059 : :
16060 : : GNU Extension:
16061 : :
16062 : : block-declaration:
16063 : : __extension__ block-declaration
16064 : :
16065 : : C++0x Extension:
16066 : :
16067 : : block-declaration:
16068 : : static_assert-declaration
16069 : :
16070 : : If STATEMENT_P is TRUE, then this block-declaration is occurring as
16071 : : part of a declaration-statement. */
16072 : :
16073 : : static void
16074 : 203565916 : cp_parser_block_declaration (cp_parser *parser,
16075 : : bool statement_p)
16076 : : {
16077 : 203565916 : int saved_pedantic;
16078 : :
16079 : : /* Check for the `__extension__' keyword. */
16080 : 203565916 : if (cp_parser_extension_opt (parser, &saved_pedantic))
16081 : : {
16082 : : /* Parse the qualified declaration. */
16083 : 77 : cp_parser_block_declaration (parser, statement_p);
16084 : : /* Restore the PEDANTIC flag. */
16085 : 77 : pedantic = saved_pedantic;
16086 : :
16087 : 77 : return;
16088 : : }
16089 : :
16090 : : /* Peek at the next token to figure out which kind of declaration is
16091 : : present. */
16092 : 203565839 : cp_token *token1 = cp_lexer_peek_token (parser->lexer);
16093 : :
16094 : : /* If the next keyword is `asm', we have an asm-definition. */
16095 : 203565839 : if (token1->keyword == RID_ASM)
16096 : : {
16097 : 23523 : if (statement_p)
16098 : 10825 : cp_parser_commit_to_tentative_parse (parser);
16099 : 23523 : cp_parser_asm_definition (parser);
16100 : : }
16101 : : /* If the next keyword is `namespace', we have a
16102 : : namespace-alias-definition. */
16103 : 203542316 : else if (token1->keyword == RID_NAMESPACE)
16104 : 107175 : cp_parser_namespace_alias_definition (parser);
16105 : : /* If the next keyword is `using', we have a
16106 : : using-declaration, a using-directive, or an alias-declaration. */
16107 : 203435141 : else if (token1->keyword == RID_USING)
16108 : : {
16109 : 10051637 : cp_token *token2;
16110 : :
16111 : 10051637 : if (statement_p)
16112 : 3736229 : cp_parser_commit_to_tentative_parse (parser);
16113 : : /* If the token after `using' is `namespace', then we have a
16114 : : using-directive. */
16115 : 10051637 : token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
16116 : 10051637 : if (token2->keyword == RID_NAMESPACE)
16117 : 99396 : cp_parser_using_directive (parser);
16118 : 9952241 : else if (token2->keyword == RID_ENUM)
16119 : 13898 : cp_parser_using_enum (parser);
16120 : : /* If the second token after 'using' is '=', then we have an
16121 : : alias-declaration. */
16122 : 9938343 : else if (cxx_dialect >= cxx11
16123 : 9877719 : && token2->type == CPP_NAME
16124 : 14576231 : && ((cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_EQ)
16125 : 906900 : || (cp_nth_tokens_can_be_attribute_p (parser, 3))))
16126 : 3731074 : cp_parser_alias_declaration (parser);
16127 : : /* Otherwise, it's a using-declaration. */
16128 : : else
16129 : 6207269 : cp_parser_using_declaration (parser,
16130 : : /*access_declaration_p=*/false);
16131 : : }
16132 : : /* If the next keyword is `__label__' we have a misplaced label
16133 : : declaration. */
16134 : 193383504 : else if (token1->keyword == RID_LABEL)
16135 : : {
16136 : 18 : cp_lexer_consume_token (parser->lexer);
16137 : 18 : error_at (token1->location, "%<__label__%> not at the beginning of a block");
16138 : 18 : cp_parser_skip_to_end_of_statement (parser);
16139 : : /* If the next token is now a `;', consume it. */
16140 : 18 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
16141 : 18 : cp_lexer_consume_token (parser->lexer);
16142 : : }
16143 : : /* If the next token is `static_assert' we have a static assertion. */
16144 : 193383486 : else if (token1->keyword == RID_STATIC_ASSERT)
16145 : 1694132 : cp_parser_static_assert (parser, /*member_p=*/false);
16146 : : else
16147 : : {
16148 : 191689354 : size_t attr_idx = cp_parser_skip_std_attribute_spec_seq (parser, 1);
16149 : 191689354 : cp_token *after_attr = NULL;
16150 : 191689354 : if (attr_idx != 1)
16151 : 1970053 : after_attr = cp_lexer_peek_nth_token (parser->lexer, attr_idx);
16152 : : /* If the next tokens after attributes is `using namespace', then we have
16153 : : a using-directive. */
16154 : 1970053 : if (after_attr
16155 : 1970053 : && after_attr->keyword == RID_USING
16156 : 1970117 : && cp_lexer_nth_token_is_keyword (parser->lexer, attr_idx + 1,
16157 : : RID_NAMESPACE))
16158 : : {
16159 : 55 : if (statement_p)
16160 : 18 : cp_parser_commit_to_tentative_parse (parser);
16161 : 55 : cp_parser_using_directive (parser);
16162 : : }
16163 : : /* If the next token after attributes is `asm', then we have
16164 : : an asm-definition. */
16165 : 191689299 : else if (after_attr && after_attr->keyword == RID_ASM)
16166 : : {
16167 : 70 : if (statement_p)
16168 : 64 : cp_parser_commit_to_tentative_parse (parser);
16169 : 70 : cp_parser_asm_definition (parser);
16170 : : }
16171 : : /* Anything else must be a simple-declaration. */
16172 : : else
16173 : 191689229 : cp_parser_simple_declaration (parser, !statement_p,
16174 : : /*maybe_range_for_decl*/NULL);
16175 : : }
16176 : : }
16177 : :
16178 : : /* Parse a simple-declaration.
16179 : :
16180 : : simple-declaration:
16181 : : decl-specifier-seq [opt] init-declarator-list [opt] ;
16182 : : decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
16183 : : brace-or-equal-initializer ;
16184 : :
16185 : : init-declarator-list:
16186 : : init-declarator
16187 : : init-declarator-list , init-declarator
16188 : :
16189 : : If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
16190 : : function-definition as a simple-declaration.
16191 : :
16192 : : If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
16193 : : parsed declaration if it is an uninitialized single declarator not followed
16194 : : by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
16195 : : if present, will not be consumed. */
16196 : :
16197 : : static void
16198 : 195614664 : cp_parser_simple_declaration (cp_parser* parser,
16199 : : bool function_definition_allowed_p,
16200 : : tree *maybe_range_for_decl)
16201 : : {
16202 : 195614664 : cp_decl_specifier_seq decl_specifiers;
16203 : 195614664 : int declares_class_or_enum;
16204 : 195614664 : bool saw_declarator;
16205 : 195614664 : location_t comma_loc = UNKNOWN_LOCATION;
16206 : 195614664 : location_t init_loc = UNKNOWN_LOCATION;
16207 : :
16208 : 195614664 : if (maybe_range_for_decl)
16209 : 3925435 : *maybe_range_for_decl = NULL_TREE;
16210 : :
16211 : : /* Defer access checks until we know what is being declared; the
16212 : : checks for names appearing in the decl-specifier-seq should be
16213 : : done as if we were in the scope of the thing being declared. */
16214 : 195614664 : push_deferring_access_checks (dk_deferred);
16215 : :
16216 : : /* Parse the decl-specifier-seq. We have to keep track of whether
16217 : : or not the decl-specifier-seq declares a named class or
16218 : : enumeration type, since that is the only case in which the
16219 : : init-declarator-list is allowed to be empty.
16220 : :
16221 : : [dcl.dcl]
16222 : :
16223 : : In a simple-declaration, the optional init-declarator-list can be
16224 : : omitted only when declaring a class or enumeration, that is when
16225 : : the decl-specifier-seq contains either a class-specifier, an
16226 : : elaborated-type-specifier, or an enum-specifier. */
16227 : 195614664 : cp_parser_decl_specifier_seq (parser,
16228 : : CP_PARSER_FLAGS_OPTIONAL,
16229 : : &decl_specifiers,
16230 : : &declares_class_or_enum);
16231 : : /* We no longer need to defer access checks. */
16232 : 195614646 : stop_deferring_access_checks ();
16233 : :
16234 : 195614646 : cp_omp_declare_simd_data odsd;
16235 : 195614646 : if (decl_specifiers.attributes && (flag_openmp || flag_openmp_simd))
16236 : 10940 : cp_parser_handle_directive_omp_attributes (parser,
16237 : : &decl_specifiers.attributes,
16238 : : &odsd, true);
16239 : :
16240 : : /* In a block scope, a valid declaration must always have a
16241 : : decl-specifier-seq. By not trying to parse declarators, we can
16242 : : resolve the declaration/expression ambiguity more quickly. */
16243 : 195614646 : if (!function_definition_allowed_p
16244 : 144224830 : && !decl_specifiers.any_specifiers_p)
16245 : : {
16246 : 89973874 : cp_parser_error (parser, "expected declaration");
16247 : 89973874 : goto done;
16248 : : }
16249 : :
16250 : : /* If the next two tokens are both identifiers, the code is
16251 : : erroneous. The usual cause of this situation is code like:
16252 : :
16253 : : T t;
16254 : :
16255 : : where "T" should name a type -- but does not. */
16256 : 105640772 : if (!decl_specifiers.any_type_specifiers_p
16257 : 105640772 : && cp_parser_parse_and_diagnose_invalid_type_name (parser))
16258 : : {
16259 : : /* If parsing tentatively, we should commit; we really are
16260 : : looking at a declaration. */
16261 : 313 : cp_parser_commit_to_tentative_parse (parser);
16262 : : /* Give up. */
16263 : 313 : goto done;
16264 : : }
16265 : :
16266 : 105640459 : cp_parser_maybe_commit_to_declaration (parser, &decl_specifiers);
16267 : :
16268 : : /* Look for C++17 decomposition declaration. */
16269 : 105640459 : for (size_t n = 1; ; n++)
16270 : 108442989 : if (cp_lexer_nth_token_is (parser->lexer, n, CPP_AND)
16271 : 108442989 : || cp_lexer_nth_token_is (parser->lexer, n, CPP_AND_AND))
16272 : 2802530 : continue;
16273 : 105640459 : else if (cp_lexer_nth_token_is (parser->lexer, n, CPP_OPEN_SQUARE)
16274 : 68717 : && !cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_SQUARE)
16275 : 105709129 : && decl_specifiers.any_specifiers_p)
16276 : : {
16277 : 68670 : tree decl
16278 : 68670 : = cp_parser_decomposition_declaration (parser, &decl_specifiers,
16279 : : maybe_range_for_decl,
16280 : : &init_loc, RID_MAX);
16281 : :
16282 : : /* The next token should be either a `,' or a `;'. */
16283 : 68670 : cp_token *token = cp_lexer_peek_token (parser->lexer);
16284 : : /* If it's a `;', we are done. */
16285 : 68670 : if (token->type == CPP_SEMICOLON)
16286 : 68484 : goto finish;
16287 : 186 : else if (maybe_range_for_decl)
16288 : : {
16289 : 174 : if (*maybe_range_for_decl == NULL_TREE)
16290 : 3 : *maybe_range_for_decl = error_mark_node;
16291 : 174 : goto finish;
16292 : : }
16293 : : /* Anything else is an error. */
16294 : : else
16295 : : {
16296 : : /* If we have already issued an error message we don't need
16297 : : to issue another one. */
16298 : 12 : if ((decl != error_mark_node
16299 : 12 : && DECL_INITIAL (decl) != error_mark_node)
16300 : 12 : || cp_parser_uncommitted_to_tentative_parse_p (parser))
16301 : 12 : cp_parser_error (parser, "expected %<;%>");
16302 : : /* Skip tokens until we reach the end of the statement. */
16303 : 12 : cp_parser_skip_to_end_of_statement (parser);
16304 : : /* If the next token is now a `;', consume it. */
16305 : 12 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
16306 : 12 : cp_lexer_consume_token (parser->lexer);
16307 : 12 : goto done;
16308 : : }
16309 : : }
16310 : : else
16311 : 2802530 : break;
16312 : :
16313 : 105571789 : tree last_type;
16314 : 105571789 : bool auto_specifier_p;
16315 : : /* NULL_TREE if both variable and function declaration are allowed,
16316 : : error_mark_node if function declaration are not allowed and
16317 : : a FUNCTION_DECL that should be diagnosed if it is followed by
16318 : : variable declarations. */
16319 : 105571789 : tree auto_function_declaration;
16320 : :
16321 : 105571789 : last_type = NULL_TREE;
16322 : 105571789 : auto_specifier_p
16323 : 105571789 : = decl_specifiers.type && type_uses_auto (decl_specifiers.type);
16324 : 105571789 : auto_function_declaration = NULL_TREE;
16325 : :
16326 : : /* Keep going until we hit the `;' at the end of the simple
16327 : : declaration. */
16328 : 105571789 : saw_declarator = false;
16329 : 106794371 : while (cp_lexer_next_token_is_not (parser->lexer,
16330 : : CPP_SEMICOLON))
16331 : : {
16332 : 101747505 : cp_token *token;
16333 : 101747505 : bool function_definition_p;
16334 : 101747505 : tree decl;
16335 : 101747505 : tree auto_result = NULL_TREE;
16336 : :
16337 : 101747505 : if (saw_declarator)
16338 : : {
16339 : : /* If we are processing next declarator, comma is expected */
16340 : 1222582 : token = cp_lexer_peek_token (parser->lexer);
16341 : 1222582 : gcc_assert (token->type == CPP_COMMA);
16342 : 1222582 : cp_lexer_consume_token (parser->lexer);
16343 : 1222582 : if (maybe_range_for_decl)
16344 : : {
16345 : 49943 : *maybe_range_for_decl = error_mark_node;
16346 : 49943 : if (comma_loc == UNKNOWN_LOCATION)
16347 : 49920 : comma_loc = token->location;
16348 : : }
16349 : : }
16350 : : else
16351 : : saw_declarator = true;
16352 : :
16353 : : /* Parse the init-declarator. */
16354 : 101747505 : decl = cp_parser_init_declarator (parser,
16355 : : CP_PARSER_FLAGS_NONE,
16356 : : &decl_specifiers,
16357 : : /*checks=*/NULL,
16358 : : function_definition_allowed_p,
16359 : : /*member_p=*/false,
16360 : : declares_class_or_enum,
16361 : : &function_definition_p,
16362 : : maybe_range_for_decl,
16363 : : &init_loc,
16364 : : &auto_result);
16365 : 101747475 : const bool fndecl_p = TREE_CODE (decl) == FUNCTION_DECL;
16366 : : /* If an error occurred while parsing tentatively, exit quickly.
16367 : : (That usually happens when in the body of a function; each
16368 : : statement is treated as a declaration-statement until proven
16369 : : otherwise.) */
16370 : 203494950 : if (cp_parser_error_occurred (parser))
16371 : 332242 : goto done;
16372 : :
16373 : 101416240 : if (auto_specifier_p && cxx_dialect >= cxx14)
16374 : : {
16375 : : /* If the init-declarator-list contains more than one
16376 : : init-declarator, they shall all form declarations of
16377 : : variables. */
16378 : 6429199 : if (auto_function_declaration == NULL_TREE)
16379 : 6373124 : auto_function_declaration = fndecl_p ? decl : error_mark_node;
16380 : 56075 : else if (fndecl_p || auto_function_declaration != error_mark_node)
16381 : : {
16382 : 12 : error_at (decl_specifiers.locations[ds_type_spec],
16383 : : "non-variable %qD in declaration with more than one "
16384 : : "declarator with placeholder type",
16385 : : fndecl_p ? decl : auto_function_declaration);
16386 : 12 : auto_function_declaration = error_mark_node;
16387 : : }
16388 : : }
16389 : :
16390 : 101416240 : if (auto_result
16391 : 101416240 : && (!processing_template_decl || !type_uses_auto (auto_result)))
16392 : : {
16393 : 900398 : if (last_type
16394 : 5918 : && last_type != error_mark_node
16395 : 906316 : && !same_type_p (auto_result, last_type))
16396 : : {
16397 : : /* If the list of declarators contains more than one declarator,
16398 : : the type of each declared variable is determined as described
16399 : : above. If the type deduced for the template parameter U is not
16400 : : the same in each deduction, the program is ill-formed. */
16401 : 3 : error_at (decl_specifiers.locations[ds_type_spec],
16402 : : "inconsistent deduction for %qT: %qT and then %qT",
16403 : : decl_specifiers.type, last_type, auto_result);
16404 : 3 : last_type = error_mark_node;
16405 : : }
16406 : : else
16407 : : last_type = auto_result;
16408 : : }
16409 : :
16410 : : /* Handle function definitions specially. */
16411 : 101416240 : if (function_definition_p)
16412 : : {
16413 : : /* If the next token is a `,', then we are probably
16414 : : processing something like:
16415 : :
16416 : : void f() {}, *p;
16417 : :
16418 : : which is erroneous. */
16419 : 9779596 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
16420 : : {
16421 : 0 : cp_token *token = cp_lexer_peek_token (parser->lexer);
16422 : 0 : error_at (token->location,
16423 : : "mixing"
16424 : : " declarations and function-definitions is forbidden");
16425 : : }
16426 : : /* Otherwise, we're done with the list of declarators. */
16427 : : else
16428 : : {
16429 : 9779596 : pop_deferring_access_checks ();
16430 : 9779596 : cp_finalize_omp_declare_simd (parser, &odsd);
16431 : 9779596 : return;
16432 : : }
16433 : : }
16434 : 91636644 : if (maybe_range_for_decl && *maybe_range_for_decl == NULL_TREE)
16435 : 208970 : *maybe_range_for_decl = decl;
16436 : : /* The next token should be either a `,' or a `;'. */
16437 : 91636644 : token = cp_lexer_peek_token (parser->lexer);
16438 : : /* If it's a `,', there are more declarators to come. */
16439 : 91636644 : if (token->type == CPP_COMMA)
16440 : : /* will be consumed next time around */;
16441 : : /* If it's a `;', we are done. */
16442 : 90414062 : else if (token->type == CPP_SEMICOLON)
16443 : : break;
16444 : 209683 : else if (maybe_range_for_decl)
16445 : : {
16446 : 208676 : if ((declares_class_or_enum & 2) && token->type == CPP_COLON)
16447 : 9 : permerror (decl_specifiers.locations[ds_type_spec],
16448 : : "types may not be defined in a for-range-declaration");
16449 : : break;
16450 : : }
16451 : : /* Anything else is an error. */
16452 : : else
16453 : : {
16454 : : /* If we have already issued an error message we don't need
16455 : : to issue another one. */
16456 : 1007 : if ((decl != error_mark_node
16457 : : /* grokfndecl sets DECL_INITIAL to error_mark_node for
16458 : : functions. */
16459 : 97 : && (fndecl_p || DECL_INITIAL (decl) != error_mark_node))
16460 : 1007 : || cp_parser_uncommitted_to_tentative_parse_p (parser))
16461 : 88 : cp_parser_error (parser, "expected %<,%> or %<;%>");
16462 : : /* Skip tokens until we reach the end of the statement. */
16463 : 1007 : cp_parser_skip_to_end_of_statement (parser);
16464 : : /* If the next token is now a `;', consume it. */
16465 : 1007 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
16466 : 719 : cp_lexer_consume_token (parser->lexer);
16467 : 1007 : goto done;
16468 : : }
16469 : : /* After the first time around, a function-definition is not
16470 : : allowed -- even if it was OK at first. For example:
16471 : :
16472 : : int i, f() {}
16473 : :
16474 : : is not valid. */
16475 : 1222582 : function_definition_allowed_p = false;
16476 : : }
16477 : :
16478 : : /* Issue an error message if no declarators are present, and the
16479 : : decl-specifier-seq does not itself declare a class or
16480 : : enumeration: [dcl.dcl]/3. */
16481 : 95459921 : if (!saw_declarator)
16482 : : {
16483 : 15140598 : if (cp_parser_declares_only_class_p (parser))
16484 : : {
16485 : 5046866 : if (!declares_class_or_enum
16486 : 119 : && decl_specifiers.type
16487 : 5046979 : && OVERLOAD_TYPE_P (decl_specifiers.type))
16488 : : /* Ensure an error is issued anyway when finish_decltype_type,
16489 : : called via cp_parser_decl_specifier_seq, returns a class or
16490 : : an enumeration (c++/51786). */
16491 : 6 : decl_specifiers.type = NULL_TREE;
16492 : 5046866 : shadow_tag (&decl_specifiers);
16493 : : }
16494 : : /* Perform any deferred access checks. */
16495 : 5046866 : perform_deferred_access_checks (tf_warning_or_error);
16496 : : }
16497 : :
16498 : : /* Consume the `;'. */
16499 : 95528579 : finish:
16500 : 95528579 : if (!maybe_range_for_decl)
16501 : 91911873 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
16502 : 3616706 : else if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
16503 : : {
16504 : 208847 : if (init_loc != UNKNOWN_LOCATION)
16505 : 8 : error_at (init_loc, "initializer in range-based %<for%> loop");
16506 : 208847 : if (comma_loc != UNKNOWN_LOCATION)
16507 : 6 : error_at (comma_loc,
16508 : : "multiple declarations in range-based %<for%> loop");
16509 : : }
16510 : :
16511 : 3407859 : done:
16512 : 185835020 : pop_deferring_access_checks ();
16513 : 185835020 : cp_finalize_omp_declare_simd (parser, &odsd);
16514 : : }
16515 : :
16516 : : /* Helper of cp_parser_simple_declaration, parse a decomposition declaration.
16517 : : decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
16518 : : initializer ; */
16519 : :
16520 : : static tree
16521 : 68880 : cp_parser_decomposition_declaration (cp_parser *parser,
16522 : : cp_decl_specifier_seq *decl_specifiers,
16523 : : tree *maybe_range_for_decl,
16524 : : location_t *init_loc, enum rid keyword)
16525 : : {
16526 : 68880 : cp_ref_qualifier ref_qual = cp_parser_ref_qualifier_opt (parser);
16527 : 68880 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
16528 : 68880 : cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
16529 : :
16530 : : /* Parse the identifier-list. */
16531 : 68880 : auto_vec<cp_expr, 10> v;
16532 : 68880 : bool attr_diagnosed = false;
16533 : 68880 : int first_attr = -1;
16534 : 68880 : unsigned int cnt = 0;
16535 : 68880 : if (!cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
16536 : 207665 : while (true)
16537 : : {
16538 : 138272 : cp_expr e = cp_parser_identifier (parser);
16539 : 138272 : if (e.get_value () == error_mark_node)
16540 : : break;
16541 : 138267 : tree attr = NULL_TREE;
16542 : 138267 : if (cp_next_tokens_can_be_std_attribute_p (parser))
16543 : : {
16544 : 45 : if (cxx_dialect >= cxx17 && cxx_dialect < cxx26 && !attr_diagnosed)
16545 : : {
16546 : 7 : pedwarn (cp_lexer_peek_token (parser->lexer)->location,
16547 : : OPT_Wc__26_extensions,
16548 : : "structured bindings with attributed identifiers "
16549 : : "only available with %<-std=c++2c%> or "
16550 : : "%<-std=gnu++2c%>");
16551 : 7 : attr_diagnosed = true;
16552 : : }
16553 : 45 : attr = cp_parser_std_attribute_spec_seq (parser);
16554 : 45 : if (attr == error_mark_node)
16555 : 0 : attr = NULL_TREE;
16556 : 45 : if (attr && first_attr == -1)
16557 : 36 : first_attr = v.length ();
16558 : : }
16559 : 138267 : v.safe_push (e);
16560 : 138267 : ++cnt;
16561 : 138267 : if (first_attr != -1)
16562 : 42 : v.safe_push (attr);
16563 : 138267 : if (!cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
16564 : : break;
16565 : 69393 : cp_lexer_consume_token (parser->lexer);
16566 : 69393 : }
16567 : :
16568 : 68880 : location_t end_loc = cp_lexer_peek_token (parser->lexer)->location;
16569 : 68880 : if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
16570 : : {
16571 : 8 : end_loc = UNKNOWN_LOCATION;
16572 : 8 : cp_parser_skip_to_closing_parenthesis_1 (parser, true, CPP_CLOSE_SQUARE,
16573 : : false);
16574 : 8 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
16575 : 0 : cp_lexer_consume_token (parser->lexer);
16576 : : else
16577 : : {
16578 : 8 : cp_parser_skip_to_end_of_statement (parser);
16579 : 8 : return error_mark_node;
16580 : : }
16581 : : }
16582 : :
16583 : 68872 : if (keyword != RID_MAX && cxx_dialect < cxx26)
16584 : 204 : pedwarn (loc, OPT_Wc__26_extensions,
16585 : : "structured bindings in conditions only available with "
16586 : : "%<-std=c++2c%> or %<-std=gnu++2c%>");
16587 : 68668 : else if (cxx_dialect < cxx17)
16588 : 387 : pedwarn (loc, OPT_Wc__17_extensions,
16589 : : "structured bindings only available with "
16590 : : "%<-std=c++17%> or %<-std=gnu++17%>");
16591 : :
16592 : 68872 : tree pushed_scope;
16593 : 68872 : cp_declarator *declarator = make_declarator (cdk_decomp);
16594 : 68872 : loc = end_loc == UNKNOWN_LOCATION ? loc : make_location (loc, loc, end_loc);
16595 : 68872 : declarator->id_loc = loc;
16596 : 68872 : if (ref_qual != REF_QUAL_NONE)
16597 : 9741 : declarator = make_reference_declarator (TYPE_UNQUALIFIED, declarator,
16598 : : ref_qual == REF_QUAL_RVALUE,
16599 : : NULL_TREE);
16600 : 68872 : tree decl = start_decl (declarator, decl_specifiers, SD_INITIALIZED,
16601 : : NULL_TREE, decl_specifiers->attributes,
16602 : : &pushed_scope);
16603 : 68872 : tree orig_decl = decl;
16604 : :
16605 : 68872 : unsigned int i;
16606 : 68872 : cp_expr e;
16607 : 68872 : cp_decl_specifier_seq decl_specs;
16608 : 68872 : clear_decl_specs (&decl_specs);
16609 : 68872 : decl_specs.type = make_auto ();
16610 : 68872 : if (decl_specifiers->storage_class == sc_static)
16611 : 92 : decl_specs.storage_class = sc_static;
16612 : : tree prev = decl;
16613 : 207136 : FOR_EACH_VEC_ELT (v, i, e)
16614 : : {
16615 : 138264 : if (i == 0)
16616 : 68871 : declarator = make_id_declarator (NULL_TREE, e.get_value (),
16617 : : sfk_none, e.get_location ());
16618 : : else
16619 : : {
16620 : 69393 : declarator->u.id.unqualified_name = e.get_value ();
16621 : 69393 : declarator->id_loc = e.get_location ();
16622 : : }
16623 : 138264 : tree elt_pushed_scope;
16624 : 138264 : tree attr = NULL_TREE;
16625 : 138264 : if (first_attr != -1 && i >= (unsigned) first_attr)
16626 : 42 : attr = v[++i].get_value ();
16627 : 138264 : tree decl2 = start_decl (declarator, &decl_specs, SD_DECOMPOSITION,
16628 : : NULL_TREE, attr, &elt_pushed_scope);
16629 : 138264 : if (decl2 == error_mark_node)
16630 : : decl = error_mark_node;
16631 : 138243 : else if (decl != error_mark_node && DECL_CHAIN (decl2) != prev)
16632 : : {
16633 : : /* Ensure we've diagnosed redeclaration if we aren't creating
16634 : : a new VAR_DECL. */
16635 : 0 : gcc_assert (errorcount);
16636 : : decl = error_mark_node;
16637 : : }
16638 : : else
16639 : : prev = decl2;
16640 : 138264 : if (elt_pushed_scope)
16641 : 135 : pop_scope (elt_pushed_scope);
16642 : : }
16643 : :
16644 : 68872 : if (v.is_empty ())
16645 : : {
16646 : 1 : error_at (loc, "empty structured binding declaration");
16647 : 1 : decl = error_mark_node;
16648 : : }
16649 : :
16650 : 68872 : if (maybe_range_for_decl == NULL
16651 : 68872 : || cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
16652 : : {
16653 : 68701 : bool non_constant_p = false, is_direct_init = false;
16654 : 68701 : *init_loc = cp_lexer_peek_token (parser->lexer)->location;
16655 : 68701 : tree initializer = cp_parser_initializer (parser, &is_direct_init,
16656 : : &non_constant_p);
16657 : 68701 : if (initializer == NULL_TREE
16658 : 68698 : || (TREE_CODE (initializer) == TREE_LIST
16659 : 39 : && TREE_CHAIN (initializer))
16660 : 137393 : || (is_direct_init
16661 : 78 : && BRACE_ENCLOSED_INITIALIZER_P (initializer)
16662 : 45 : && CONSTRUCTOR_NELTS (initializer) != 1))
16663 : : {
16664 : 15 : error_at (loc, "invalid initializer for structured binding "
16665 : : "declaration");
16666 : 15 : initializer = error_mark_node;
16667 : : }
16668 : :
16669 : 68701 : if (decl != error_mark_node)
16670 : : {
16671 : 68685 : cp_decomp decomp = { prev, cnt };
16672 : 68685 : if (keyword != RID_MAX)
16673 : 210 : DECL_DECOMP_BASE (decl)
16674 : 420 : = keyword == RID_SWITCH ? integer_one_node : integer_zero_node;
16675 : 137284 : cp_finish_decl (decl, initializer, non_constant_p, NULL_TREE,
16676 : : (is_direct_init ? LOOKUP_NORMAL : LOOKUP_IMPLICIT),
16677 : : &decomp);
16678 : : }
16679 : : }
16680 : 171 : else if (decl != error_mark_node)
16681 : : {
16682 : 171 : *maybe_range_for_decl = prev;
16683 : 171 : cp_decomp decomp = { prev, cnt };
16684 : : /* Ensure DECL_VALUE_EXPR is created for all the decls but
16685 : : the underlying DECL. */
16686 : 171 : cp_finish_decomp (decl, &decomp);
16687 : : }
16688 : :
16689 : 68872 : if (pushed_scope)
16690 : 45 : pop_scope (pushed_scope);
16691 : :
16692 : 68872 : if (decl == error_mark_node && DECL_P (orig_decl))
16693 : : {
16694 : 16 : if (DECL_NAMESPACE_SCOPE_P (orig_decl))
16695 : 6 : SET_DECL_ASSEMBLER_NAME (orig_decl, get_identifier ("<decomp>"));
16696 : : }
16697 : :
16698 : : return decl;
16699 : 68880 : }
16700 : :
16701 : : /* Names of storage classes. */
16702 : :
16703 : : static const char *const
16704 : : cp_storage_class_name[] = {
16705 : : "", "auto", "register", "static", "extern", "mutable"
16706 : : };
16707 : :
16708 : : /* Parse a decl-specifier-seq.
16709 : :
16710 : : decl-specifier-seq:
16711 : : decl-specifier-seq [opt] decl-specifier
16712 : : decl-specifier attribute-specifier-seq [opt] (C++11)
16713 : :
16714 : : decl-specifier:
16715 : : storage-class-specifier
16716 : : type-specifier
16717 : : function-specifier
16718 : : friend
16719 : : typedef
16720 : :
16721 : : GNU Extension:
16722 : :
16723 : : decl-specifier:
16724 : : attributes
16725 : :
16726 : : Concepts Extension:
16727 : :
16728 : : decl-specifier:
16729 : : concept
16730 : :
16731 : : Set *DECL_SPECS to a representation of the decl-specifier-seq.
16732 : :
16733 : : The parser flags FLAGS is used to control type-specifier parsing.
16734 : :
16735 : : *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
16736 : : flags:
16737 : :
16738 : : 1: one of the decl-specifiers is an elaborated-type-specifier
16739 : : (i.e., a type declaration)
16740 : : 2: one of the decl-specifiers is an enum-specifier or a
16741 : : class-specifier (i.e., a type definition)
16742 : :
16743 : : */
16744 : :
16745 : : static void
16746 : 703184073 : cp_parser_decl_specifier_seq (cp_parser* parser,
16747 : : cp_parser_flags flags,
16748 : : cp_decl_specifier_seq *decl_specs,
16749 : : int* declares_class_or_enum)
16750 : : {
16751 : 703184073 : bool constructor_possible_p = !parser->in_declarator_p;
16752 : 703184073 : bool found_decl_spec = false;
16753 : 703184073 : cp_token *start_token = NULL;
16754 : 703184073 : cp_decl_spec ds;
16755 : :
16756 : : /* Clear DECL_SPECS. */
16757 : 703184073 : clear_decl_specs (decl_specs);
16758 : :
16759 : : /* Assume no class or enumeration type is declared. */
16760 : 703184073 : *declares_class_or_enum = 0;
16761 : :
16762 : : /* Keep a token that additionally will be used for diagnostics. */
16763 : 703184073 : cp_token *first_specifier = NULL;
16764 : : /* Keep reading specifiers until there are no more to read. */
16765 : 1572601368 : while (true)
16766 : : {
16767 : 1572601368 : bool constructor_p;
16768 : 1572601368 : cp_token *token;
16769 : 1572601368 : ds = ds_last;
16770 : :
16771 : : /* Peek at the next token. */
16772 : 1572601368 : token = cp_lexer_peek_token (parser->lexer);
16773 : :
16774 : : /* Save the first token of the decl spec list for error
16775 : : reporting. */
16776 : 1572601368 : if (!start_token)
16777 : : start_token = token;
16778 : : /* Handle attributes. */
16779 : 1572601368 : if ((flags & CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR) == 0
16780 : 1572601368 : && cp_next_tokens_can_be_attribute_p (parser))
16781 : : {
16782 : : /* Parse the attributes. */
16783 : 16397558 : tree attrs = cp_parser_attributes_opt (parser);
16784 : :
16785 : : /* In a sequence of declaration specifiers, c++11 attributes
16786 : : appertain to the type that precede them. In that case
16787 : : [dcl.spec]/1 says:
16788 : :
16789 : : The attribute-specifier-seq affects the type only for
16790 : : the declaration it appears in, not other declarations
16791 : : involving the same type.
16792 : :
16793 : : But for now let's force the user to position the
16794 : : attribute either at the beginning of the declaration or
16795 : : after the declarator-id, which would clearly mean that it
16796 : : applies to the declarator. */
16797 : 16397558 : if (cxx11_attribute_p (attrs))
16798 : : {
16799 : 11769425 : if (!found_decl_spec)
16800 : : /* The c++11 attribute is at the beginning of the
16801 : : declaration. It appertains to the entity being
16802 : : declared. */;
16803 : : else
16804 : : {
16805 : 560 : if (find_contract (attrs))
16806 : : {
16807 : 3 : diagnose_misapplied_contracts (attrs);
16808 : 3 : attrs = NULL_TREE;
16809 : : }
16810 : 557 : else if (decl_specs->type
16811 : 495 : && decl_specs->type_definition_p
16812 : 616 : && OVERLOAD_TYPE_P (decl_specs->type))
16813 : : {
16814 : : /* This is an attribute following a class-specifier. */
16815 : 59 : warn_misplaced_attr_for_class_type (token->location,
16816 : : decl_specs->type);
16817 : 59 : attrs = NULL_TREE;
16818 : : }
16819 : : else
16820 : : {
16821 : 498 : decl_specs->std_attributes
16822 : 498 : = attr_chainon (decl_specs->std_attributes, attrs);
16823 : 498 : if (decl_specs->locations[ds_std_attribute] == 0)
16824 : 498 : decl_specs->locations[ds_std_attribute] = token->location;
16825 : : }
16826 : 560 : continue;
16827 : : }
16828 : : }
16829 : :
16830 : 16396998 : decl_specs->attributes
16831 : 16396998 : = attr_chainon (decl_specs->attributes, attrs);
16832 : 16396998 : if (decl_specs->locations[ds_attribute] == 0)
16833 : 16281605 : decl_specs->locations[ds_attribute] = token->location;
16834 : 16396998 : continue;
16835 : 16396998 : }
16836 : : /* We know by this point that the token is not part of an attribute. */
16837 : 1556203810 : if (!first_specifier)
16838 : 703184073 : first_specifier = token;
16839 : : /* Special case for "this" specifier, indicating a parm is an xobj parm.
16840 : : The "this" specifier must be the first specifier in the declaration,
16841 : : after any attributes. */
16842 : 1556203810 : if (token->keyword == RID_THIS && (flags & CP_PARSER_FLAGS_PARAMETER))
16843 : : {
16844 : 220009 : cp_lexer_consume_token (parser->lexer);
16845 : 220009 : if (token != first_specifier)
16846 : : {
16847 : : /* Don't emit diagnostics if we have already seen "this",
16848 : : leave it for set_and_check_decl_spec_loc. */
16849 : 0 : if (decl_specs->locations[ds_this] == 0)
16850 : : {
16851 : 0 : auto_diagnostic_group d;
16852 : 0 : gcc_rich_location richloc (token->location);
16853 : : /* Works, need to add tests for it though. */
16854 : 0 : richloc.add_fixit_remove ();
16855 : 0 : richloc.add_fixit_insert_before (first_specifier->location,
16856 : : "this ");
16857 : 0 : error_at (&richloc,
16858 : : "%<this%> must be the first specifier "
16859 : : "in a parameter declaration");
16860 : 0 : }
16861 : : }
16862 : 220009 : set_and_check_decl_spec_loc (decl_specs, ds_this, token);
16863 : 220009 : continue;
16864 : 220009 : }
16865 : :
16866 : : /* Assume we will find a decl-specifier keyword. */
16867 : 1555983801 : found_decl_spec = true;
16868 : : /* If the next token is an appropriate keyword, we can simply
16869 : : add it to the list. */
16870 : 1555983801 : switch (token->keyword)
16871 : : {
16872 : : /* decl-specifier:
16873 : : friend
16874 : : constexpr
16875 : : constinit */
16876 : 5165805 : case RID_FRIEND:
16877 : 5165805 : if (!at_class_scope_p ())
16878 : : {
16879 : 16 : gcc_rich_location richloc (token->location);
16880 : 16 : richloc.add_fixit_remove ();
16881 : 16 : error_at (&richloc, "%<friend%> used outside of class");
16882 : 16 : cp_lexer_purge_token (parser->lexer);
16883 : 16 : }
16884 : : else
16885 : : {
16886 : 5165789 : ds = ds_friend;
16887 : : /* Consume the token. */
16888 : 5165789 : cp_lexer_consume_token (parser->lexer);
16889 : : }
16890 : : break;
16891 : :
16892 : 39943804 : case RID_CONSTEXPR:
16893 : 39943804 : ds = ds_constexpr;
16894 : 39943804 : cp_lexer_consume_token (parser->lexer);
16895 : 39943804 : break;
16896 : :
16897 : 392 : case RID_CONSTINIT:
16898 : 392 : ds = ds_constinit;
16899 : 392 : cp_lexer_consume_token (parser->lexer);
16900 : 392 : break;
16901 : :
16902 : 82281 : case RID_CONSTEVAL:
16903 : 82281 : ds = ds_consteval;
16904 : 82281 : cp_lexer_consume_token (parser->lexer);
16905 : 82281 : break;
16906 : :
16907 : 118 : case RID_CONCEPT:
16908 : 118 : ds = ds_concept;
16909 : 118 : cp_lexer_consume_token (parser->lexer);
16910 : :
16911 : 118 : if (flags & CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR)
16912 : : break;
16913 : :
16914 : : /* Warn for concept as a decl-specifier. We'll rewrite these as
16915 : : concept declarations later. */
16916 : 117 : {
16917 : 117 : cp_token *next = cp_lexer_peek_token (parser->lexer);
16918 : 117 : if (next->keyword == RID_BOOL)
16919 : 24 : permerror (next->location, "the %<bool%> keyword is not "
16920 : : "allowed in a C++20 concept definition");
16921 : : else
16922 : 93 : error_at (token->location, "C++20 concept definition syntax "
16923 : : "is %<concept <name> = <expr>%>");
16924 : : }
16925 : :
16926 : : /* In C++20 a concept definition is just 'concept name = expr;'
16927 : : Support that syntax as a TS extension by pretending we've seen
16928 : : the 'bool' specifier. */
16929 : 117 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
16930 : 30 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_EQ)
16931 : 135 : && !decl_specs->any_type_specifiers_p)
16932 : : {
16933 : 15 : cp_parser_set_decl_spec_type (decl_specs, boolean_type_node,
16934 : : token, /*type_definition*/false);
16935 : 15 : decl_specs->any_type_specifiers_p = true;
16936 : : }
16937 : : break;
16938 : :
16939 : : /* function-specifier:
16940 : : inline
16941 : : virtual
16942 : : explicit */
16943 : 35967483 : case RID_INLINE:
16944 : 35967483 : case RID_VIRTUAL:
16945 : 35967483 : case RID_EXPLICIT:
16946 : 35967483 : cp_parser_function_specifier_opt (parser, decl_specs);
16947 : 35967483 : break;
16948 : :
16949 : : /* decl-specifier:
16950 : : typedef */
16951 : 25736256 : case RID_TYPEDEF:
16952 : 25736256 : ds = ds_typedef;
16953 : : /* Consume the token. */
16954 : 25736256 : cp_lexer_consume_token (parser->lexer);
16955 : :
16956 : 25736256 : if (flags & CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR)
16957 : : break;
16958 : :
16959 : : /* A constructor declarator cannot appear in a typedef. */
16960 : 25736253 : constructor_possible_p = false;
16961 : : /* The "typedef" keyword can only occur in a declaration; we
16962 : : may as well commit at this point. */
16963 : 25736253 : cp_parser_commit_to_tentative_parse (parser);
16964 : :
16965 : 25736253 : if (decl_specs->storage_class != sc_none)
16966 : : {
16967 : 9 : if (decl_specs->conflicting_specifiers_p)
16968 : : break;
16969 : 9 : gcc_rich_location richloc (token->location);
16970 : 9 : location_t oloc = decl_specs->locations[ds_storage_class];
16971 : 9 : richloc.add_location_if_nearby (*global_dc, oloc);
16972 : 9 : error_at (&richloc,
16973 : : "%<typedef%> specifier conflicts with %qs",
16974 : 9 : cp_storage_class_name[decl_specs->storage_class]);
16975 : 9 : decl_specs->conflicting_specifiers_p = true;
16976 : 9 : }
16977 : : break;
16978 : :
16979 : : /* storage-class-specifier:
16980 : : auto
16981 : : register
16982 : : static
16983 : : extern
16984 : : mutable
16985 : :
16986 : : GNU Extension:
16987 : : thread */
16988 : 9731211 : case RID_AUTO:
16989 : 9731211 : if (cxx_dialect == cxx98)
16990 : : {
16991 : : /* Consume the token. */
16992 : 16 : cp_lexer_consume_token (parser->lexer);
16993 : :
16994 : : /* Complain about `auto' as a storage specifier, if
16995 : : we're complaining about C++0x compatibility. */
16996 : 16 : gcc_rich_location richloc (token->location);
16997 : 16 : richloc.add_fixit_remove ();
16998 : 16 : warning_at (&richloc, OPT_Wc__11_compat,
16999 : : "%<auto%> changes meaning in C++11; "
17000 : : "please remove it");
17001 : :
17002 : : /* Set the storage class anyway. */
17003 : 16 : cp_parser_set_storage_class (parser, decl_specs, RID_AUTO,
17004 : : token);
17005 : 16 : }
17006 : : else
17007 : : /* C++0x auto type-specifier. */
17008 : : found_decl_spec = false;
17009 : : break;
17010 : :
17011 : 47454253 : case RID_REGISTER:
17012 : 47454253 : case RID_STATIC:
17013 : 47454253 : case RID_EXTERN:
17014 : 47454253 : case RID_MUTABLE:
17015 : : /* Consume the token. */
17016 : 47454253 : cp_lexer_consume_token (parser->lexer);
17017 : 47454253 : cp_parser_set_storage_class (parser, decl_specs, token->keyword,
17018 : : token);
17019 : 47454253 : break;
17020 : 19470 : case RID_THREAD:
17021 : : /* Consume the token. */
17022 : 19470 : ds = ds_thread;
17023 : 19470 : cp_lexer_consume_token (parser->lexer);
17024 : 19470 : break;
17025 : :
17026 : : default:
17027 : : /* We did not yet find a decl-specifier yet. */
17028 : : found_decl_spec = false;
17029 : : break;
17030 : : }
17031 : :
17032 : 128633528 : if (found_decl_spec
17033 : 154369878 : && (flags & CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR)
17034 : 15 : && token->keyword != RID_CONSTEXPR)
17035 : 6 : error ("%qD invalid in condition", ridpointers[token->keyword]);
17036 : :
17037 : 154369878 : if (found_decl_spec
17038 : 154369878 : && (flags & CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR)
17039 : 88383 : && token->keyword != RID_MUTABLE
17040 : 2008 : && token->keyword != RID_CONSTEXPR
17041 : 71 : && token->keyword != RID_CONSTEVAL)
17042 : : {
17043 : 63 : if (token->keyword != RID_STATIC)
17044 : 7 : error_at (token->location, "%qD invalid in lambda",
17045 : 7 : ridpointers[token->keyword]);
17046 : 56 : else if (cxx_dialect < cxx23)
17047 : 35 : pedwarn (token->location, OPT_Wc__23_extensions,
17048 : : "%qD only valid in lambda with %<-std=c++23%> or "
17049 : 35 : "%<-std=gnu++23%>", ridpointers[token->keyword]);
17050 : : }
17051 : :
17052 : 1555983801 : if (ds != ds_last)
17053 : 70948110 : set_and_check_decl_spec_loc (decl_specs, ds, token);
17054 : :
17055 : : /* Constructors are a special case. The `S' in `S()' is not a
17056 : : decl-specifier; it is the beginning of the declarator. */
17057 : 1555983801 : constructor_p
17058 : 3947709813 : = (!found_decl_spec
17059 : 1555983801 : && constructor_possible_p
17060 : 1976906448 : && (cp_parser_constructor_declarator_p
17061 : 420922650 : (parser, flags, decl_spec_seq_has_spec_p (decl_specs,
17062 : : ds_friend))));
17063 : :
17064 : : /* If we don't have a DECL_SPEC yet, then we must be looking at
17065 : : a type-specifier. */
17066 : 1534172088 : if (!found_decl_spec && !constructor_p)
17067 : : {
17068 : 1379802210 : int decl_spec_declares_class_or_enum;
17069 : 1379802210 : bool is_cv_qualifier;
17070 : 1379802210 : tree type_spec;
17071 : :
17072 : 1379802210 : if (flags & CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR)
17073 : 88371 : flags |= CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS;
17074 : :
17075 : 1379802210 : type_spec
17076 : 1379802210 : = cp_parser_type_specifier (parser, flags,
17077 : : decl_specs,
17078 : : /*is_declaration=*/true,
17079 : : &decl_spec_declares_class_or_enum,
17080 : : &is_cv_qualifier);
17081 : 1379802186 : *declares_class_or_enum |= decl_spec_declares_class_or_enum;
17082 : :
17083 : : /* If this type-specifier referenced a user-defined type
17084 : : (a typedef, class-name, etc.), then we can't allow any
17085 : : more such type-specifiers henceforth.
17086 : :
17087 : : [dcl.spec]
17088 : :
17089 : : The longest sequence of decl-specifiers that could
17090 : : possibly be a type name is taken as the
17091 : : decl-specifier-seq of a declaration. The sequence shall
17092 : : be self-consistent as described below.
17093 : :
17094 : : [dcl.type]
17095 : :
17096 : : As a general rule, at most one type-specifier is allowed
17097 : : in the complete decl-specifier-seq of a declaration. The
17098 : : only exceptions are the following:
17099 : :
17100 : : -- const or volatile can be combined with any other
17101 : : type-specifier.
17102 : :
17103 : : -- signed or unsigned can be combined with char, long,
17104 : : short, or int.
17105 : :
17106 : : -- ..
17107 : :
17108 : : Example:
17109 : :
17110 : : typedef char* Pc;
17111 : : void g (const int Pc);
17112 : :
17113 : : Here, Pc is *not* part of the decl-specifier seq; it's
17114 : : the declarator. Therefore, once we see a type-specifier
17115 : : (other than a cv-qualifier), we forbid any additional
17116 : : user-defined types. We *do* still allow things like `int
17117 : : int' to be considered a decl-specifier-seq, and issue the
17118 : : error message later. */
17119 : 1379802186 : if (type_spec && !is_cv_qualifier)
17120 : 610279502 : flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
17121 : : /* A constructor declarator cannot follow a type-specifier. */
17122 : 681372336 : if (type_spec)
17123 : : {
17124 : 698429850 : constructor_possible_p = false;
17125 : 698429850 : found_decl_spec = true;
17126 : 698429850 : if (!is_cv_qualifier)
17127 : 610279502 : decl_specs->any_type_specifiers_p = true;
17128 : :
17129 : 698429850 : if ((flags & CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR) != 0)
17130 : 21 : error_at (token->location, "type-specifier invalid in lambda");
17131 : : }
17132 : : }
17133 : :
17134 : : /* If we still do not have a DECL_SPEC, then there are no more
17135 : : decl-specifiers. */
17136 : 1555983774 : if (!found_decl_spec)
17137 : : break;
17138 : :
17139 : 852799728 : if (decl_specs->std_attributes)
17140 : : {
17141 : 62 : auto_diagnostic_group d;
17142 : 62 : error_at (decl_specs->locations[ds_std_attribute],
17143 : : "standard attributes in middle of decl-specifiers");
17144 : 62 : inform (decl_specs->locations[ds_std_attribute],
17145 : : "standard attributes must precede the decl-specifiers to "
17146 : : "apply to the declaration, or follow them to apply to "
17147 : : "the type");
17148 : 62 : }
17149 : :
17150 : 852799728 : decl_specs->any_specifiers_p = true;
17151 : : /* After we see one decl-specifier, further decl-specifiers are
17152 : : always optional. */
17153 : 852799728 : flags |= CP_PARSER_FLAGS_OPTIONAL;
17154 : : }
17155 : :
17156 : : /* Don't allow a friend specifier with a class definition. */
17157 : 703184046 : if (decl_spec_seq_has_spec_p (decl_specs, ds_friend)
17158 : 703184046 : && (*declares_class_or_enum & 2))
17159 : 6 : error_at (decl_specs->locations[ds_friend],
17160 : : "class definition may not be declared a friend");
17161 : 703184046 : }
17162 : :
17163 : : /* Parse an (optional) storage-class-specifier.
17164 : :
17165 : : storage-class-specifier:
17166 : : auto
17167 : : register
17168 : : static
17169 : : extern
17170 : : mutable
17171 : :
17172 : : GNU Extension:
17173 : :
17174 : : storage-class-specifier:
17175 : : thread
17176 : :
17177 : : Returns an IDENTIFIER_NODE corresponding to the keyword used. */
17178 : :
17179 : : static tree
17180 : 2744191 : cp_parser_storage_class_specifier_opt (cp_parser* parser)
17181 : : {
17182 : 2744191 : switch (cp_lexer_peek_token (parser->lexer)->keyword)
17183 : : {
17184 : 0 : case RID_AUTO:
17185 : 0 : if (cxx_dialect != cxx98)
17186 : : return NULL_TREE;
17187 : : /* Fall through for C++98. */
17188 : 2738482 : gcc_fallthrough ();
17189 : :
17190 : 2738482 : case RID_REGISTER:
17191 : 2738482 : case RID_STATIC:
17192 : 2738482 : case RID_EXTERN:
17193 : 2738482 : case RID_MUTABLE:
17194 : 2738482 : case RID_THREAD:
17195 : : /* Consume the token. */
17196 : 2738482 : return cp_lexer_consume_token (parser->lexer)->u.value;
17197 : :
17198 : : default:
17199 : : return NULL_TREE;
17200 : : }
17201 : : }
17202 : :
17203 : : /* Parse an (optional) function-specifier.
17204 : :
17205 : : function-specifier:
17206 : : inline
17207 : : virtual
17208 : : explicit
17209 : :
17210 : : C++20 Extension:
17211 : : explicit(constant-expression)
17212 : :
17213 : : Returns an IDENTIFIER_NODE corresponding to the keyword used.
17214 : : Updates DECL_SPECS, if it is non-NULL. */
17215 : :
17216 : : static tree
17217 : 35973192 : cp_parser_function_specifier_opt (cp_parser* parser,
17218 : : cp_decl_specifier_seq *decl_specs)
17219 : : {
17220 : 35973192 : cp_token *token = cp_lexer_peek_token (parser->lexer);
17221 : 35973192 : switch (token->keyword)
17222 : : {
17223 : 26810653 : case RID_INLINE:
17224 : 26810653 : set_and_check_decl_spec_loc (decl_specs, ds_inline, token);
17225 : 26810653 : break;
17226 : :
17227 : 3895729 : case RID_VIRTUAL:
17228 : : /* 14.5.2.3 [temp.mem]
17229 : :
17230 : : A member function template shall not be virtual. */
17231 : 3895729 : if (PROCESSING_REAL_TEMPLATE_DECL_P ()
17232 : 3895747 : && current_class_type)
17233 : 9 : error_at (token->location, "templates may not be %<virtual%>");
17234 : : else
17235 : 3895720 : set_and_check_decl_spec_loc (decl_specs, ds_virtual, token);
17236 : : break;
17237 : :
17238 : 5261129 : case RID_EXPLICIT:
17239 : 5261129 : {
17240 : 5261129 : tree id = cp_lexer_consume_token (parser->lexer)->u.value;
17241 : : /* If we see '(', it's C++20 explicit(bool). */
17242 : 5261129 : tree expr;
17243 : 5261129 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
17244 : : {
17245 : 117438 : matching_parens parens;
17246 : 117438 : parens.consume_open (parser);
17247 : :
17248 : : /* New types are not allowed in an explicit-specifier. */
17249 : 117438 : const char *saved_message
17250 : : = parser->type_definition_forbidden_message;
17251 : 117438 : parser->type_definition_forbidden_message
17252 : 117438 : = G_("types may not be defined in explicit-specifier");
17253 : :
17254 : 117438 : if (cxx_dialect < cxx20)
17255 : 8 : pedwarn (token->location, OPT_Wc__20_extensions,
17256 : : "%<explicit(bool)%> only available with %<-std=c++20%> "
17257 : : "or %<-std=gnu++20%>");
17258 : :
17259 : : /* Parse the constant-expression. */
17260 : 117438 : expr = cp_parser_constant_expression (parser);
17261 : :
17262 : : /* Restore the saved message. */
17263 : 117438 : parser->type_definition_forbidden_message = saved_message;
17264 : 117438 : parens.require_close (parser);
17265 : : }
17266 : : else
17267 : : /* The explicit-specifier explicit without a constant-expression is
17268 : : equivalent to the explicit-specifier explicit(true). */
17269 : 5143691 : expr = boolean_true_node;
17270 : :
17271 : : /* [dcl.fct.spec]
17272 : : "the constant-expression, if supplied, shall be a contextually
17273 : : converted constant expression of type bool." */
17274 : 5261129 : expr = build_explicit_specifier (expr, tf_warning_or_error);
17275 : : /* We could evaluate it -- mark the decl as appropriate. */
17276 : 5261129 : if (expr == boolean_true_node)
17277 : 5143723 : set_and_check_decl_spec_loc (decl_specs, ds_explicit, token);
17278 : 117406 : else if (expr == boolean_false_node)
17279 : : /* Don't mark the decl as explicit. */;
17280 : 117392 : else if (decl_specs)
17281 : : /* The expression was value-dependent. Remember it so that we can
17282 : : substitute it later. */
17283 : 117392 : decl_specs->explicit_specifier = expr;
17284 : : return id;
17285 : : }
17286 : :
17287 : : default:
17288 : : return NULL_TREE;
17289 : : }
17290 : :
17291 : : /* Consume the token. */
17292 : 30706382 : return cp_lexer_consume_token (parser->lexer)->u.value;
17293 : : }
17294 : :
17295 : : /* Parse a linkage-specification.
17296 : :
17297 : : linkage-specification:
17298 : : extern string-literal { declaration-seq [opt] }
17299 : : extern string-literal name-declaration */
17300 : :
17301 : : static void
17302 : 1043510 : cp_parser_linkage_specification (cp_parser* parser, tree prefix_attr)
17303 : : {
17304 : : /* Look for the `extern' keyword. */
17305 : 1043510 : cp_token *extern_token
17306 : 1043510 : = cp_parser_require_keyword (parser, RID_EXTERN, RT_EXTERN);
17307 : :
17308 : : /* Look for the string-literal. */
17309 : 1043510 : cp_token *string_token = cp_lexer_peek_token (parser->lexer);
17310 : 1043510 : tree linkage;
17311 : 1043510 : if (cxx_dialect >= cxx26)
17312 : 115621 : linkage = cp_parser_unevaluated_string_literal (parser);
17313 : : else
17314 : 927889 : linkage = cp_parser_string_literal (parser, /*translate=*/false,
17315 : : /*wide_ok=*/false);
17316 : :
17317 : : /* Transform the literal into an identifier. If the literal is a
17318 : : wide-character string, or contains embedded NULs, then we can't
17319 : : handle it as the user wants. */
17320 : 1043510 : if (linkage == error_mark_node
17321 : 1043510 : || strlen (TREE_STRING_POINTER (linkage))
17322 : 1043508 : != (size_t) (TREE_STRING_LENGTH (linkage) - 1))
17323 : : {
17324 : 2 : cp_parser_error (parser, "invalid linkage-specification");
17325 : : /* Assume C++ linkage. */
17326 : 2 : linkage = lang_name_cplusplus;
17327 : : }
17328 : : else
17329 : 1043508 : linkage = get_identifier (TREE_STRING_POINTER (linkage));
17330 : :
17331 : : /* We're now using the new linkage. */
17332 : 1043510 : unsigned saved_module = module_kind;
17333 : 1043510 : module_kind &= ~MK_ATTACH;
17334 : 1043510 : push_lang_context (linkage);
17335 : :
17336 : : /* Preserve the location of the innermost linkage specification,
17337 : : tracking the locations of nested specifications via a local. */
17338 : 1043510 : location_t saved_location
17339 : : = parser->innermost_linkage_specification_location;
17340 : : /* Construct a location ranging from the start of the "extern" to
17341 : : the end of the string-literal, with the caret at the start, e.g.:
17342 : : extern "C" {
17343 : : ^~~~~~~~~~
17344 : : */
17345 : 1043510 : parser->innermost_linkage_specification_location
17346 : 1043510 : = make_location (extern_token->location,
17347 : : extern_token->location,
17348 : : get_finish (string_token->location));
17349 : :
17350 : : /* If the next token is a `{', then we're using the first
17351 : : production. */
17352 : 1043510 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
17353 : : {
17354 : 708019 : cp_ensure_no_omp_declare_simd (parser);
17355 : 708019 : cp_ensure_no_oacc_routine (parser);
17356 : :
17357 : : /* Consume the `{' token. */
17358 : 708019 : matching_braces braces;
17359 : 708019 : braces.consume_open (parser);
17360 : : /* Parse the declarations. */
17361 : 708019 : cp_parser_declaration_seq_opt (parser);
17362 : : /* Look for the closing `}'. */
17363 : 708019 : braces.require_close (parser);
17364 : : }
17365 : : /* Otherwise, there's just one declaration. */
17366 : : else
17367 : : {
17368 : 335491 : bool saved_in_unbraced_linkage_specification_p;
17369 : :
17370 : 335491 : saved_in_unbraced_linkage_specification_p
17371 : 335491 : = parser->in_unbraced_linkage_specification_p;
17372 : 335491 : parser->in_unbraced_linkage_specification_p = true;
17373 : 335491 : cp_parser_declaration (parser, prefix_attr);
17374 : 335491 : parser->in_unbraced_linkage_specification_p
17375 : 335491 : = saved_in_unbraced_linkage_specification_p;
17376 : : }
17377 : :
17378 : : /* We're done with the linkage-specification. */
17379 : 1043510 : pop_lang_context ();
17380 : 1043510 : module_kind = saved_module;
17381 : :
17382 : : /* Restore location of parent linkage specification, if any. */
17383 : 1043510 : parser->innermost_linkage_specification_location = saved_location;
17384 : 1043510 : }
17385 : :
17386 : : /* Parse a static_assert-declaration.
17387 : :
17388 : : static_assert-declaration:
17389 : : static_assert ( constant-expression , string-literal ) ;
17390 : : static_assert ( constant-expression ) ; (C++17)
17391 : : static_assert ( constant-expression, conditional-expression ) ; (C++26)
17392 : :
17393 : : If MEMBER_P, this static_assert is a class member. */
17394 : :
17395 : : static void
17396 : 3782662 : cp_parser_static_assert (cp_parser *parser, bool member_p)
17397 : : {
17398 : 3782662 : cp_expr condition;
17399 : 3782662 : location_t token_loc;
17400 : 3782662 : tree message;
17401 : :
17402 : : /* Peek at the `static_assert' token so we can keep track of exactly
17403 : : where the static assertion started. */
17404 : 3782662 : token_loc = cp_lexer_peek_token (parser->lexer)->location;
17405 : :
17406 : : /* Look for the `static_assert' keyword. */
17407 : 3782662 : if (!cp_parser_require_keyword (parser, RID_STATIC_ASSERT,
17408 : : RT_STATIC_ASSERT))
17409 : 0 : return;
17410 : :
17411 : : /* We know we are in a static assertion; commit to any tentative
17412 : : parse. */
17413 : 3782662 : if (cp_parser_parsing_tentatively (parser))
17414 : 3752007 : cp_parser_commit_to_tentative_parse (parser);
17415 : :
17416 : : /* Parse the `(' starting the static assertion condition. */
17417 : 3782662 : matching_parens parens;
17418 : 3782662 : parens.require_open (parser);
17419 : :
17420 : : /* Parse the constant-expression. Allow a non-constant expression
17421 : : here in order to give better diagnostics in finish_static_assert. */
17422 : 3782662 : condition
17423 : 3782662 : = cp_parser_constant_expression (parser,
17424 : : /*allow_non_constant_p=*/true,
17425 : : /*non_constant_p=*/nullptr);
17426 : :
17427 : 3782662 : if (cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
17428 : : {
17429 : 513675 : if (pedantic && cxx_dialect < cxx17)
17430 : 3 : pedwarn (input_location, OPT_Wc__17_extensions,
17431 : : "%<static_assert%> without a message "
17432 : : "only available with %<-std=c++17%> or %<-std=gnu++17%>");
17433 : : /* Eat the ')' */
17434 : 513675 : cp_lexer_consume_token (parser->lexer);
17435 : 513675 : message = build_string (1, "");
17436 : 513675 : TREE_TYPE (message) = char_array_type_node;
17437 : 513675 : fix_string_type (message);
17438 : : }
17439 : : else
17440 : : {
17441 : : /* Parse the separating `,'. */
17442 : 3268987 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
17443 : :
17444 : : /* Parse the message expression. */
17445 : 3268987 : bool string_lit = true;
17446 : 3268987 : for (unsigned int i = 1; ; ++i)
17447 : : {
17448 : 6835424 : cp_token *tok = cp_lexer_peek_nth_token (parser->lexer, i);
17449 : 6835424 : if (cp_parser_is_pure_string_literal (tok))
17450 : 3566437 : continue;
17451 : 3268987 : else if (tok->type == CPP_CLOSE_PAREN)
17452 : : break;
17453 : 248 : string_lit = false;
17454 : 248 : break;
17455 : 3566437 : }
17456 : 3268987 : if (!string_lit)
17457 : : {
17458 : 248 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
17459 : 248 : if (cxx_dialect < cxx26)
17460 : 247 : pedwarn (loc, OPT_Wc__26_extensions,
17461 : : "%<static_assert%> with non-string message only "
17462 : : "available with %<-std=c++2c%> or %<-std=gnu++2c%>");
17463 : :
17464 : 248 : message = cp_parser_conditional_expression (parser);
17465 : 248 : if (TREE_CODE (message) == STRING_CST)
17466 : 0 : message = build1_loc (loc, PAREN_EXPR, TREE_TYPE (message),
17467 : : message);
17468 : : }
17469 : 3268739 : else if (cxx_dialect >= cxx26)
17470 : 421818 : message = cp_parser_unevaluated_string_literal (parser);
17471 : : else
17472 : 2846921 : message = cp_parser_string_literal (parser, /*translate=*/false,
17473 : : /*wide_ok=*/true);
17474 : :
17475 : : /* A `)' completes the static assertion. */
17476 : 3268987 : if (!parens.require_close (parser))
17477 : 0 : cp_parser_skip_to_closing_parenthesis (parser,
17478 : : /*recovering=*/true,
17479 : : /*or_comma=*/false,
17480 : : /*consume_paren=*/true);
17481 : : }
17482 : :
17483 : : /* A semicolon terminates the declaration. */
17484 : 3782662 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
17485 : :
17486 : : /* Get the location for the static assertion. Use that of the
17487 : : condition if available, otherwise, use that of the "static_assert"
17488 : : token. */
17489 : 3782662 : location_t assert_loc = condition.get_location ();
17490 : 3782662 : if (assert_loc == UNKNOWN_LOCATION)
17491 : 16 : assert_loc = token_loc;
17492 : :
17493 : : /* Complete the static assertion, which may mean either processing
17494 : : the static assert now or saving it for template instantiation. */
17495 : 3782662 : finish_static_assert (condition, message, assert_loc, member_p,
17496 : : /*show_expr_p=*/false);
17497 : : }
17498 : :
17499 : : /* Parse the expression in decltype ( expression ). */
17500 : :
17501 : : static tree
17502 : 2726009 : cp_parser_decltype_expr (cp_parser *parser,
17503 : : bool &id_expression_or_member_access_p)
17504 : : {
17505 : 2726009 : cp_token *id_expr_start_token;
17506 : 2726009 : tree expr;
17507 : :
17508 : : /* First, try parsing an id-expression. */
17509 : 2726009 : id_expr_start_token = cp_lexer_peek_token (parser->lexer);
17510 : 2726009 : cp_parser_parse_tentatively (parser);
17511 : 2726009 : expr = cp_parser_id_expression (parser,
17512 : : /*template_keyword_p=*/false,
17513 : : /*check_dependency_p=*/true,
17514 : : /*template_p=*/NULL,
17515 : : /*declarator_p=*/false,
17516 : : /*optional_p=*/false);
17517 : :
17518 : 2321716 : if (!cp_parser_error_occurred (parser) && expr != error_mark_node)
17519 : : {
17520 : 2321713 : bool non_integral_constant_expression_p = false;
17521 : 2321713 : tree id_expression = expr;
17522 : 2321713 : cp_id_kind idk;
17523 : 2321713 : const char *error_msg;
17524 : 2321713 : const bool pack_index_p = cp_parser_next_tokens_are_pack_index_p (parser);
17525 : 2321713 : const bool have_id_expr_p
17526 : : = (pack_index_p
17527 : 2321713 : || cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN);
17528 : :
17529 : 2321713 : if (identifier_p (expr))
17530 : : /* Lookup the name we got back from the id-expression. */
17531 : 1329968 : expr = cp_parser_lookup_name_simple (parser, expr,
17532 : : id_expr_start_token->location);
17533 : :
17534 : 2321713 : if (expr
17535 : 2321713 : && expr != error_mark_node
17536 : 2308088 : && TREE_CODE (expr) != TYPE_DECL
17537 : 1999240 : && (TREE_CODE (expr) != BIT_NOT_EXPR
17538 : 15 : || !TYPE_P (TREE_OPERAND (expr, 0)))
17539 : 4320938 : && have_id_expr_p)
17540 : : {
17541 : : /* Complete lookup of the id-expression. */
17542 : 232181 : expr = (finish_id_expression
17543 : 232181 : (id_expression, expr, parser->scope, &idk,
17544 : : /*integral_constant_expression_p=*/false,
17545 : : /*allow_non_integral_constant_expression_p=*/true,
17546 : : &non_integral_constant_expression_p,
17547 : : /*template_p=*/false,
17548 : : /*done=*/true,
17549 : : /*address_p=*/false,
17550 : : /*template_arg_p=*/false,
17551 : : &error_msg,
17552 : : id_expr_start_token->location));
17553 : :
17554 : 232181 : if (error_msg)
17555 : : {
17556 : : /* We found an id-expression, but it was something that we
17557 : : should not have found. This is an error, not something
17558 : : we can recover from, so report the error we found and
17559 : : we'll recover as gracefully as possible. */
17560 : 9 : cp_parser_parse_definitely (parser);
17561 : 9 : cp_parser_error (parser, error_msg);
17562 : 9 : id_expression_or_member_access_p = true;
17563 : 9 : return error_mark_node;
17564 : : }
17565 : : }
17566 : :
17567 : 2321704 : if (expr && expr != error_mark_node && have_id_expr_p)
17568 : : {
17569 : : /* We have an id-expression. */
17570 : 232199 : id_expression_or_member_access_p = true;
17571 : 232199 : if (pack_index_p)
17572 : 23 : expr = cp_parser_pack_index (parser, expr);
17573 : : }
17574 : : }
17575 : :
17576 : 2726000 : if (!id_expression_or_member_access_p)
17577 : : {
17578 : : /* Abort the id-expression parse. */
17579 : 2493801 : cp_parser_abort_tentative_parse (parser);
17580 : :
17581 : : /* Parsing tentatively, again. */
17582 : 2493801 : cp_parser_parse_tentatively (parser);
17583 : :
17584 : : /* Parse a class member access. */
17585 : 2493801 : expr = cp_parser_postfix_expression (parser, /*address_p=*/false,
17586 : : /*cast_p=*/false, /*decltype*/true,
17587 : : /*member_access_only_p=*/true, NULL);
17588 : :
17589 : 2493801 : if (expr
17590 : 2493801 : && expr != error_mark_node
17591 : 2493941 : && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
17592 : : /* We have an id-expression. */
17593 : 119 : id_expression_or_member_access_p = true;
17594 : : }
17595 : :
17596 : 2726000 : if (id_expression_or_member_access_p)
17597 : : /* We have parsed the complete id-expression or member access. */
17598 : 232318 : cp_parser_parse_definitely (parser);
17599 : : else
17600 : : {
17601 : : /* Abort our attempt to parse an id-expression or member access
17602 : : expression. */
17603 : 2493682 : cp_parser_abort_tentative_parse (parser);
17604 : :
17605 : : /* Parse a full expression. */
17606 : 2493682 : expr = cp_parser_expression (parser, /*pidk=*/NULL, /*cast_p=*/false,
17607 : : /*decltype_p=*/true);
17608 : : }
17609 : :
17610 : : return expr;
17611 : : }
17612 : :
17613 : : /* Parse a `decltype' type. Returns the type.
17614 : :
17615 : : decltype-specifier:
17616 : : decltype ( expression )
17617 : : C++14:
17618 : : decltype ( auto ) */
17619 : :
17620 : : static tree
17621 : 3044528 : cp_parser_decltype (cp_parser *parser)
17622 : : {
17623 : 3044528 : bool id_expression_or_member_access_p = false;
17624 : 3044528 : cp_token *start_token = cp_lexer_peek_token (parser->lexer);
17625 : :
17626 : 3044528 : if (start_token->type == CPP_DECLTYPE)
17627 : : {
17628 : : /* Already parsed. */
17629 : 28268 : cp_lexer_consume_token (parser->lexer);
17630 : 28268 : return saved_checks_value (start_token->u.tree_check_value);
17631 : : }
17632 : :
17633 : : /* Look for the `decltype' token. */
17634 : 3016260 : if (!cp_parser_require_keyword (parser, RID_DECLTYPE, RT_DECLTYPE))
17635 : 0 : return error_mark_node;
17636 : :
17637 : : /* Parse the opening `('. */
17638 : 3016260 : matching_parens parens;
17639 : 3016260 : if (!parens.require_open (parser))
17640 : 44 : return error_mark_node;
17641 : :
17642 : : /* Since we're going to preserve any side-effects from this parse, set up a
17643 : : firewall to protect our callers from cp_parser_commit_to_tentative_parse
17644 : : in the expression. */
17645 : 3016216 : tentative_firewall firewall (parser);
17646 : :
17647 : : /* If in_declarator_p, a reparse as an expression might succeed (60361).
17648 : : Otherwise, commit now for better diagnostics. */
17649 : 6662930 : if (cp_parser_uncommitted_to_tentative_parse_p (parser)
17650 : 630498 : && !parser->in_declarator_p)
17651 : 602475 : cp_parser_commit_to_topmost_tentative_parse (parser);
17652 : :
17653 : 3016216 : push_deferring_access_checks (dk_deferred);
17654 : :
17655 : 3016216 : tree expr = NULL_TREE;
17656 : :
17657 : 3016216 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO)
17658 : 3016216 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_CLOSE_PAREN))
17659 : : {
17660 : : /* decltype (auto) */
17661 : 290207 : cp_lexer_consume_token (parser->lexer);
17662 : 290207 : if (cxx_dialect < cxx14)
17663 : : {
17664 : 2 : error_at (start_token->location,
17665 : : "%<decltype(auto)%> type specifier only available with "
17666 : : "%<-std=c++14%> or %<-std=gnu++14%>");
17667 : 2 : expr = error_mark_node;
17668 : : }
17669 : : }
17670 : : else
17671 : : {
17672 : : /* decltype (expression) */
17673 : :
17674 : : /* Types cannot be defined in a `decltype' expression. Save away the
17675 : : old message and set the new one. */
17676 : 2726009 : const char *saved_message = parser->type_definition_forbidden_message;
17677 : 2726009 : parser->type_definition_forbidden_message
17678 : 2726009 : = G_("types may not be defined in %<decltype%> expressions");
17679 : :
17680 : : /* The restrictions on constant-expressions do not apply inside
17681 : : decltype expressions. */
17682 : 2726009 : bool saved_integral_constant_expression_p
17683 : : = parser->integral_constant_expression_p;
17684 : 2726009 : bool saved_non_integral_constant_expression_p
17685 : : = parser->non_integral_constant_expression_p;
17686 : 2726009 : parser->integral_constant_expression_p = false;
17687 : :
17688 : : /* Within a parenthesized expression, a `>' token is always
17689 : : the greater-than operator. */
17690 : 2726009 : bool saved_greater_than_is_operator_p
17691 : : = parser->greater_than_is_operator_p;
17692 : 2726009 : parser->greater_than_is_operator_p = true;
17693 : :
17694 : : /* Don't synthesize an implicit template type parameter here. This
17695 : : could happen with C++23 code like
17696 : :
17697 : : void f(decltype(new auto{0}));
17698 : :
17699 : : where we want to deduce the auto right away so that the parameter
17700 : : is of type 'int *'. */
17701 : 2726009 : auto cleanup = make_temp_override
17702 : 2726009 : (parser->auto_is_implicit_function_template_parm_p, false);
17703 : :
17704 : : /* Do not actually evaluate the expression. */
17705 : 2726009 : ++cp_unevaluated_operand;
17706 : :
17707 : : /* Do not warn about problems with the expression. */
17708 : 2726009 : ++c_inhibit_evaluation_warnings;
17709 : :
17710 : 2726009 : expr = cp_parser_decltype_expr (parser, id_expression_or_member_access_p);
17711 : 2726009 : STRIP_ANY_LOCATION_WRAPPER (expr);
17712 : :
17713 : : /* Go back to evaluating expressions. */
17714 : 2726009 : --cp_unevaluated_operand;
17715 : 2726009 : --c_inhibit_evaluation_warnings;
17716 : :
17717 : : /* The `>' token might be the end of a template-id or
17718 : : template-parameter-list now. */
17719 : 2726009 : parser->greater_than_is_operator_p
17720 : 2726009 : = saved_greater_than_is_operator_p;
17721 : :
17722 : : /* Restore the old message and the integral constant expression
17723 : : flags. */
17724 : 2726009 : parser->type_definition_forbidden_message = saved_message;
17725 : 2726009 : parser->integral_constant_expression_p
17726 : 2726009 : = saved_integral_constant_expression_p;
17727 : 2726009 : parser->non_integral_constant_expression_p
17728 : 2726009 : = saved_non_integral_constant_expression_p;
17729 : 2726009 : }
17730 : :
17731 : : /* Parse to the closing `)'. */
17732 : 6031554 : if (expr == error_mark_node || !parens.require_close (parser))
17733 : : {
17734 : 890 : cp_parser_skip_to_closing_parenthesis (parser, true, false,
17735 : : /*consume_paren=*/true);
17736 : 890 : expr = error_mark_node;
17737 : : }
17738 : :
17739 : : /* If we got a parse error while tentative, bail out now. */
17740 : 6032432 : if (cp_parser_error_occurred (parser))
17741 : : {
17742 : 30 : pop_deferring_access_checks ();
17743 : 30 : return error_mark_node;
17744 : : }
17745 : :
17746 : 3016186 : if (!expr)
17747 : : /* Build auto. */
17748 : 290205 : expr = make_decltype_auto ();
17749 : : else
17750 : 2725981 : expr = finish_decltype_type (expr, id_expression_or_member_access_p,
17751 : : tf_warning_or_error);
17752 : :
17753 : : /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
17754 : : it again. */
17755 : 3016186 : start_token->type = CPP_DECLTYPE;
17756 : 3016186 : start_token->u.tree_check_value = ggc_cleared_alloc<struct tree_check> ();
17757 : 3016186 : start_token->tree_check_p = true;
17758 : 3016186 : start_token->u.tree_check_value->value = expr;
17759 : 3016186 : start_token->u.tree_check_value->checks = get_deferred_access_checks ();
17760 : 3016186 : start_token->keyword = RID_MAX;
17761 : :
17762 : 3016186 : location_t loc = start_token->location;
17763 : 3016186 : loc = make_location (loc, loc, parser->lexer);
17764 : 3016186 : start_token->location = loc;
17765 : :
17766 : 3016186 : cp_lexer_purge_tokens_after (parser->lexer, start_token);
17767 : :
17768 : 3016186 : pop_to_parent_deferring_access_checks ();
17769 : :
17770 : 3016186 : return expr;
17771 : 3016216 : }
17772 : :
17773 : : /* Special member functions [gram.special] */
17774 : :
17775 : : /* Parse a conversion-function-id.
17776 : :
17777 : : conversion-function-id:
17778 : : operator conversion-type-id
17779 : :
17780 : : Returns an IDENTIFIER_NODE representing the operator. */
17781 : :
17782 : : static tree
17783 : 1303924 : cp_parser_conversion_function_id (cp_parser* parser)
17784 : : {
17785 : 1303924 : tree type;
17786 : 1303924 : tree saved_scope;
17787 : 1303924 : tree saved_qualifying_scope;
17788 : 1303924 : tree saved_object_scope;
17789 : 1303924 : tree pushed_scope = NULL_TREE;
17790 : :
17791 : : /* Look for the `operator' token. */
17792 : 1303924 : if (!cp_parser_require_keyword (parser, RID_OPERATOR, RT_OPERATOR))
17793 : 0 : return error_mark_node;
17794 : : /* When we parse the conversion-type-id, the current scope will be
17795 : : reset. However, we need that information in able to look up the
17796 : : conversion function later, so we save it here. */
17797 : 1303924 : saved_scope = parser->scope;
17798 : 1303924 : saved_qualifying_scope = parser->qualifying_scope;
17799 : 1303924 : saved_object_scope = parser->object_scope;
17800 : : /* We must enter the scope of the class so that the names of
17801 : : entities declared within the class are available in the
17802 : : conversion-type-id. For example, consider:
17803 : :
17804 : : struct S {
17805 : : typedef int I;
17806 : : operator I();
17807 : : };
17808 : :
17809 : : S::operator I() { ... }
17810 : :
17811 : : In order to see that `I' is a type-name in the definition, we
17812 : : must be in the scope of `S'. */
17813 : 1303924 : if (saved_scope
17814 : : /* In A<T>::operator I(), we don't want to enter A<T> if we're
17815 : : in an expression rather than declaration context. */
17816 : 1303924 : && adjust_type_for_entering_scope (saved_scope) == saved_scope)
17817 : 136495 : pushed_scope = push_scope (saved_scope);
17818 : : /* Parse the conversion-type-id. */
17819 : 1303924 : type = cp_parser_conversion_type_id (parser);
17820 : : /* Leave the scope of the class, if any. */
17821 : 1303924 : if (pushed_scope)
17822 : 136495 : pop_scope (pushed_scope);
17823 : : /* Restore the saved scope. */
17824 : 1303924 : parser->scope = saved_scope;
17825 : 1303924 : parser->qualifying_scope = saved_qualifying_scope;
17826 : 1303924 : parser->object_scope = saved_object_scope;
17827 : : /* If the TYPE is invalid, indicate failure. */
17828 : 1303924 : if (type == error_mark_node)
17829 : : return error_mark_node;
17830 : 1303889 : return make_conv_op_name (type);
17831 : : }
17832 : :
17833 : : /* Parse a conversion-type-id:
17834 : :
17835 : : conversion-type-id:
17836 : : type-specifier-seq conversion-declarator [opt]
17837 : :
17838 : : Returns the TYPE specified. */
17839 : :
17840 : : static tree
17841 : 1303924 : cp_parser_conversion_type_id (cp_parser* parser)
17842 : : {
17843 : 1303924 : tree attributes;
17844 : 1303924 : cp_decl_specifier_seq type_specifiers;
17845 : 1303924 : cp_declarator *declarator;
17846 : 1303924 : tree type_specified;
17847 : 1303924 : const char *saved_message;
17848 : :
17849 : : /* Parse the attributes. */
17850 : 1303924 : attributes = cp_parser_attributes_opt (parser);
17851 : :
17852 : 1303924 : saved_message = parser->type_definition_forbidden_message;
17853 : 1303924 : parser->type_definition_forbidden_message
17854 : 1303924 : = G_("types may not be defined in a conversion-type-id");
17855 : :
17856 : : /* Parse the type-specifiers. DR 2413 clarifies that `typename' is
17857 : : optional in conversion-type-id. */
17858 : 1303924 : cp_parser_type_specifier_seq (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
17859 : : /*is_declaration=*/false,
17860 : : /*is_trailing_return=*/false,
17861 : : &type_specifiers);
17862 : :
17863 : 1303924 : parser->type_definition_forbidden_message = saved_message;
17864 : :
17865 : : /* If that didn't work, stop. */
17866 : 1303924 : if (type_specifiers.type == error_mark_node)
17867 : : return error_mark_node;
17868 : : /* Parse the conversion-declarator. */
17869 : 1303896 : declarator = cp_parser_conversion_declarator_opt (parser);
17870 : :
17871 : 1303896 : type_specified = grokdeclarator (declarator, &type_specifiers, TYPENAME,
17872 : : /*initialized=*/0, &attributes);
17873 : 1303896 : if (attributes)
17874 : 12 : cplus_decl_attributes (&type_specified, attributes, /*flags=*/0);
17875 : :
17876 : : /* Don't give this error when parsing tentatively. This happens to
17877 : : work because we always parse this definitively once. */
17878 : 3328019 : if (! cp_parser_uncommitted_to_tentative_parse_p (parser)
17879 : 720234 : && type_uses_auto (type_specified))
17880 : : {
17881 : 55 : if (cxx_dialect < cxx14)
17882 : : {
17883 : 7 : error ("invalid use of %<auto%> in conversion operator");
17884 : 7 : return error_mark_node;
17885 : : }
17886 : 48 : else if (template_parm_scope_p ())
17887 : 3 : warning (0, "use of %<auto%> in member template "
17888 : : "conversion operator can never be deduced");
17889 : : }
17890 : :
17891 : 1303889 : return type_specified;
17892 : : }
17893 : :
17894 : : /* Parse an (optional) conversion-declarator.
17895 : :
17896 : : conversion-declarator:
17897 : : ptr-operator conversion-declarator [opt]
17898 : :
17899 : : */
17900 : :
17901 : : static cp_declarator *
17902 : 1388976 : cp_parser_conversion_declarator_opt (cp_parser* parser)
17903 : : {
17904 : 1388976 : enum tree_code code;
17905 : 1388976 : tree class_type, std_attributes = NULL_TREE;
17906 : 1388976 : cp_cv_quals cv_quals;
17907 : :
17908 : : /* We don't know if there's a ptr-operator next, or not. */
17909 : 1388976 : cp_parser_parse_tentatively (parser);
17910 : : /* Try the ptr-operator. */
17911 : 1388976 : code = cp_parser_ptr_operator (parser, &class_type, &cv_quals,
17912 : : &std_attributes);
17913 : : /* If it worked, look for more conversion-declarators. */
17914 : 1388976 : if (cp_parser_parse_definitely (parser))
17915 : : {
17916 : 85080 : cp_declarator *declarator;
17917 : :
17918 : : /* Parse another optional declarator. */
17919 : 85080 : declarator = cp_parser_conversion_declarator_opt (parser);
17920 : :
17921 : 85080 : declarator = cp_parser_make_indirect_declarator
17922 : 85080 : (code, class_type, cv_quals, declarator, std_attributes);
17923 : :
17924 : 85080 : return declarator;
17925 : : }
17926 : :
17927 : : return NULL;
17928 : : }
17929 : :
17930 : : /* Parse an (optional) ctor-initializer.
17931 : :
17932 : : ctor-initializer:
17933 : : : mem-initializer-list */
17934 : :
17935 : : static void
17936 : 101264897 : cp_parser_ctor_initializer_opt (cp_parser* parser)
17937 : : {
17938 : : /* If the next token is not a `:', then there is no
17939 : : ctor-initializer. */
17940 : 101264897 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
17941 : : {
17942 : : /* Do default initialization of any bases and members. */
17943 : 176175720 : if (DECL_CONSTRUCTOR_P (current_function_decl))
17944 : 1229495 : finish_mem_initializers (NULL_TREE);
17945 : 88087860 : return;
17946 : : }
17947 : :
17948 : : /* Consume the `:' token. */
17949 : 13177037 : cp_lexer_consume_token (parser->lexer);
17950 : : /* And the mem-initializer-list. */
17951 : 13177037 : cp_parser_mem_initializer_list (parser);
17952 : : }
17953 : :
17954 : : /* Parse a mem-initializer-list.
17955 : :
17956 : : mem-initializer-list:
17957 : : mem-initializer ... [opt]
17958 : : mem-initializer ... [opt] , mem-initializer-list */
17959 : :
17960 : : static void
17961 : 13177037 : cp_parser_mem_initializer_list (cp_parser* parser)
17962 : : {
17963 : 13177037 : tree mem_initializer_list = NULL_TREE;
17964 : 13177037 : tree target_ctor = error_mark_node;
17965 : 13177037 : cp_token *token = cp_lexer_peek_token (parser->lexer);
17966 : :
17967 : : /* Let the semantic analysis code know that we are starting the
17968 : : mem-initializer-list. */
17969 : 26354074 : if (!DECL_CONSTRUCTOR_P (current_function_decl))
17970 : 9 : error_at (token->location,
17971 : : "only constructors take member initializers");
17972 : :
17973 : : /* Loop through the list. */
17974 : 27621335 : while (true)
17975 : : {
17976 : 20399186 : tree mem_initializer;
17977 : :
17978 : 20399186 : token = cp_lexer_peek_token (parser->lexer);
17979 : : /* Parse the mem-initializer. */
17980 : 20399186 : mem_initializer = cp_parser_mem_initializer (parser);
17981 : : /* If the next token is a `...', we're expanding member initializers. */
17982 : 20399186 : bool ellipsis = cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS);
17983 : 20399186 : if (ellipsis
17984 : 20399186 : || (mem_initializer != error_mark_node
17985 : 20399103 : && check_for_bare_parameter_packs (TREE_PURPOSE
17986 : : (mem_initializer))))
17987 : : {
17988 : : /* Consume the `...'. */
17989 : 36 : if (ellipsis)
17990 : 33 : cp_lexer_consume_token (parser->lexer);
17991 : :
17992 : : /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
17993 : : can be expanded but members cannot. */
17994 : 36 : if (mem_initializer != error_mark_node
17995 : 72 : && !TYPE_P (TREE_PURPOSE (mem_initializer)))
17996 : : {
17997 : 3 : error_at (token->location,
17998 : : "cannot expand initializer for member %qD",
17999 : 3 : TREE_PURPOSE (mem_initializer));
18000 : 3 : mem_initializer = error_mark_node;
18001 : : }
18002 : :
18003 : : /* Construct the pack expansion type. */
18004 : 36 : if (mem_initializer != error_mark_node)
18005 : 33 : mem_initializer = make_pack_expansion (mem_initializer);
18006 : : }
18007 : 20399186 : if (target_ctor != error_mark_node
18008 : 6 : && mem_initializer != error_mark_node)
18009 : : {
18010 : 6 : error ("mem-initializer for %qD follows constructor delegation",
18011 : 6 : TREE_PURPOSE (mem_initializer));
18012 : 6 : mem_initializer = error_mark_node;
18013 : : }
18014 : : /* Look for a target constructor. */
18015 : 20399186 : if (mem_initializer != error_mark_node
18016 : 20399127 : && CLASS_TYPE_P (TREE_PURPOSE (mem_initializer))
18017 : 25367733 : && same_type_p (TREE_PURPOSE (mem_initializer), current_class_type))
18018 : : {
18019 : 1386271 : maybe_warn_cpp0x (CPP0X_DELEGATING_CTORS);
18020 : 1386271 : if (mem_initializer_list)
18021 : : {
18022 : 6 : error ("constructor delegation follows mem-initializer for %qD",
18023 : 6 : TREE_PURPOSE (mem_initializer_list));
18024 : 6 : mem_initializer = error_mark_node;
18025 : : }
18026 : : target_ctor = mem_initializer;
18027 : : }
18028 : : /* Add it to the list, unless it was erroneous. */
18029 : 20399186 : if (mem_initializer != error_mark_node)
18030 : : {
18031 : 20399121 : TREE_CHAIN (mem_initializer) = mem_initializer_list;
18032 : 20399121 : mem_initializer_list = mem_initializer;
18033 : : }
18034 : : /* If the next token is not a `,', we're done. */
18035 : 20399186 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
18036 : : break;
18037 : : /* Consume the `,' token. */
18038 : 7222149 : cp_lexer_consume_token (parser->lexer);
18039 : 7222149 : }
18040 : :
18041 : : /* Perform semantic analysis. */
18042 : 26354074 : if (DECL_CONSTRUCTOR_P (current_function_decl))
18043 : 13177028 : finish_mem_initializers (mem_initializer_list);
18044 : 13177037 : }
18045 : :
18046 : : /* Parse a mem-initializer.
18047 : :
18048 : : mem-initializer:
18049 : : mem-initializer-id ( expression-list [opt] )
18050 : : mem-initializer-id braced-init-list
18051 : :
18052 : : GNU extension:
18053 : :
18054 : : mem-initializer:
18055 : : ( expression-list [opt] )
18056 : :
18057 : : Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
18058 : : class) or FIELD_DECL (for a non-static data member) to initialize;
18059 : : the TREE_VALUE is the expression-list. An empty initialization
18060 : : list is represented by void_list_node. */
18061 : :
18062 : : static tree
18063 : 20399186 : cp_parser_mem_initializer (cp_parser* parser)
18064 : : {
18065 : 20399186 : tree mem_initializer_id;
18066 : 20399186 : tree expression_list;
18067 : 20399186 : tree member;
18068 : 20399186 : cp_token *token = cp_lexer_peek_token (parser->lexer);
18069 : :
18070 : : /* Find out what is being initialized. */
18071 : 20399186 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
18072 : : {
18073 : 6 : permerror (token->location,
18074 : : "anachronistic old-style base class initializer");
18075 : 6 : mem_initializer_id = NULL_TREE;
18076 : : }
18077 : : else
18078 : : {
18079 : 20399180 : mem_initializer_id = cp_parser_mem_initializer_id (parser);
18080 : 20399180 : if (mem_initializer_id == error_mark_node)
18081 : : return mem_initializer_id;
18082 : : }
18083 : 20399175 : member = expand_member_init (mem_initializer_id);
18084 : 20399175 : if (member && !DECL_P (member))
18085 : 5916134 : in_base_initializer = 1;
18086 : :
18087 : 20399175 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
18088 : : {
18089 : 349104 : cp_lexer_set_source_position (parser->lexer);
18090 : 349104 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
18091 : 349104 : expression_list = cp_parser_braced_list (parser);
18092 : 349104 : CONSTRUCTOR_IS_DIRECT_INIT (expression_list) = 1;
18093 : 349104 : expression_list = build_tree_list (NULL_TREE, expression_list);
18094 : : }
18095 : : else
18096 : : {
18097 : 20050071 : vec<tree, va_gc> *vec;
18098 : 20050071 : vec = cp_parser_parenthesized_expression_list (parser, non_attr,
18099 : : /*cast_p=*/false,
18100 : : /*allow_expansion_p=*/true,
18101 : : /*non_constant_p=*/NULL,
18102 : : /*close_paren_loc=*/NULL,
18103 : : /*wrap_locations_p=*/true);
18104 : 20050071 : if (vec == NULL)
18105 : 3 : return error_mark_node;
18106 : 20050068 : expression_list = build_tree_list_vec (vec);
18107 : 20050068 : release_tree_vector (vec);
18108 : : }
18109 : :
18110 : 20399172 : if (expression_list == error_mark_node)
18111 : : return error_mark_node;
18112 : 20399172 : if (!expression_list)
18113 : 2254687 : expression_list = void_type_node;
18114 : :
18115 : 20399172 : in_base_initializer = 0;
18116 : :
18117 : 20399172 : if (!member)
18118 : : return error_mark_node;
18119 : 20399136 : tree node = build_tree_list (member, expression_list);
18120 : :
18121 : : /* We can't attach the source location of this initializer directly to
18122 : : the list node, so we instead attach it to a dummy EMPTY_CLASS_EXPR
18123 : : within the TREE_TYPE of the list node. */
18124 : 20399136 : location_t loc
18125 : 20399136 : = make_location (token->location, token->location, parser->lexer);
18126 : 20399136 : tree dummy = build0 (EMPTY_CLASS_EXPR, NULL_TREE);
18127 : 20399136 : SET_EXPR_LOCATION (dummy, loc);
18128 : 20399136 : TREE_TYPE (node) = dummy;
18129 : :
18130 : 20399136 : return node;
18131 : : }
18132 : :
18133 : : /* Parse a mem-initializer-id.
18134 : :
18135 : : mem-initializer-id:
18136 : : class-or-decltype
18137 : : identifier
18138 : :
18139 : : class-or-decltype:
18140 : : nested-name-specifier [opt] type-name
18141 : : nested-name-specifier template simple-template-id
18142 : : computed-type-specifier
18143 : :
18144 : : Returns a TYPE indicating the class to be initialized for the first
18145 : : production. Returns an IDENTIFIER_NODE indicating the data member to
18146 : : be initialized for the second production. */
18147 : :
18148 : : static tree
18149 : 20399180 : cp_parser_mem_initializer_id (cp_parser* parser)
18150 : : {
18151 : 20399180 : bool global_scope_p;
18152 : 20399180 : bool nested_name_specifier_p;
18153 : 20399180 : bool template_p = false;
18154 : 20399180 : tree id;
18155 : :
18156 : 20399180 : cp_token *token = cp_lexer_peek_token (parser->lexer);
18157 : :
18158 : : /* `typename' is not allowed in this context ([temp.res]). */
18159 : 20399180 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
18160 : : {
18161 : 3 : error_at (token->location,
18162 : : "keyword %<typename%> not allowed in this context (a qualified "
18163 : : "member initializer is implicitly a type)");
18164 : 3 : cp_lexer_consume_token (parser->lexer);
18165 : : }
18166 : : /* Look for the optional `::' operator. */
18167 : 20399180 : global_scope_p
18168 : 20399180 : = (cp_parser_global_scope_opt (parser,
18169 : : /*current_scope_valid_p=*/false)
18170 : : != NULL_TREE);
18171 : : /* Look for the optional nested-name-specifier. The simplest way to
18172 : : implement:
18173 : :
18174 : : [temp.res]
18175 : :
18176 : : The keyword `typename' is not permitted in a base-specifier or
18177 : : mem-initializer; in these contexts a qualified name that
18178 : : depends on a template-parameter is implicitly assumed to be a
18179 : : type name.
18180 : :
18181 : : is to assume that we have seen the `typename' keyword at this
18182 : : point. */
18183 : 20399180 : nested_name_specifier_p
18184 : 20399180 : = (cp_parser_nested_name_specifier_opt (parser,
18185 : : /*typename_keyword_p=*/true,
18186 : : /*check_dependency_p=*/true,
18187 : : /*type_p=*/true,
18188 : : /*is_declaration=*/true)
18189 : : != NULL_TREE);
18190 : 20399180 : if (nested_name_specifier_p)
18191 : 24280 : template_p = cp_parser_optional_template_keyword (parser);
18192 : : /* If there is a `::' operator or a nested-name-specifier, then we
18193 : : are definitely looking for a class-name. */
18194 : 20399180 : if (global_scope_p || nested_name_specifier_p)
18195 : 24280 : return cp_parser_class_name (parser,
18196 : : /*typename_keyword_p=*/true,
18197 : : /*template_keyword_p=*/template_p,
18198 : : typename_type,
18199 : : /*check_dependency_p=*/true,
18200 : : /*class_head_p=*/false,
18201 : 24280 : /*is_declaration=*/true);
18202 : : /* Otherwise, we could also be looking for an ordinary identifier. */
18203 : 20374900 : cp_parser_parse_tentatively (parser);
18204 : 20374900 : if (cp_lexer_next_token_is_decltype (parser->lexer))
18205 : : /* Try a decltype-specifier. */
18206 : 6 : id = cp_parser_decltype (parser);
18207 : : else
18208 : : /* Otherwise, try a class-name. */
18209 : 20374894 : id = cp_parser_class_name (parser,
18210 : : /*typename_keyword_p=*/true,
18211 : : /*template_keyword_p=*/false,
18212 : : none_type,
18213 : : /*check_dependency_p=*/true,
18214 : : /*class_head_p=*/false,
18215 : : /*is_declaration=*/true);
18216 : : /* If we found one, we're done. */
18217 : 20374900 : if (!cp_parser_parse_definitely (parser))
18218 : : /* Otherwise, look for an ordinary identifier. */
18219 : 14483043 : id = cp_parser_identifier (parser);
18220 : :
18221 : : /* ": T...[N]" is a C++26 pack-index-specifier. */
18222 : 20374900 : if (cp_parser_next_tokens_are_pack_index_p (parser))
18223 : 1 : id = cp_parser_pack_index (parser, id);
18224 : :
18225 : : return id;
18226 : : }
18227 : :
18228 : : /* Overloading [gram.over] */
18229 : :
18230 : : /* Parse an operator-function-id.
18231 : :
18232 : : operator-function-id:
18233 : : operator operator
18234 : :
18235 : : Returns an IDENTIFIER_NODE for the operator which is a
18236 : : human-readable spelling of the identifier, e.g., `operator +'. */
18237 : :
18238 : : static cp_expr
18239 : 64266925 : cp_parser_operator_function_id (cp_parser* parser)
18240 : : {
18241 : 64266925 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
18242 : : /* Look for the `operator' keyword. */
18243 : 64266925 : if (!cp_parser_require_keyword (parser, RID_OPERATOR, RT_OPERATOR))
18244 : 0 : return error_mark_node;
18245 : : /* And then the name of the operator itself. */
18246 : 64266925 : return cp_parser_operator (parser, start_loc);
18247 : : }
18248 : :
18249 : : /* Return an identifier node for a user-defined literal operator.
18250 : : The suffix identifier is chained to the operator name identifier. */
18251 : :
18252 : : tree
18253 : 630900 : cp_literal_operator_id (const char* name)
18254 : : {
18255 : 630900 : tree identifier;
18256 : 630900 : char *buffer = XNEWVEC (char, strlen (UDLIT_OP_ANSI_PREFIX)
18257 : : + strlen (name) + 10);
18258 : 630900 : sprintf (buffer, UDLIT_OP_ANSI_FORMAT, name);
18259 : 630900 : identifier = get_identifier (buffer);
18260 : 630900 : XDELETEVEC (buffer);
18261 : :
18262 : 630900 : return identifier;
18263 : : }
18264 : :
18265 : : /* Parse an operator.
18266 : :
18267 : : operator:
18268 : : new delete new[] delete[] + - * / % ^ & | ~ ! = < >
18269 : : += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
18270 : : || ++ -- , ->* -> () []
18271 : :
18272 : : GNU Extensions:
18273 : :
18274 : : operator:
18275 : : <? >? <?= >?=
18276 : :
18277 : : Returns an IDENTIFIER_NODE for the operator which is a
18278 : : human-readable spelling of the identifier, e.g., `operator +'. */
18279 : :
18280 : : static cp_expr
18281 : 64266925 : cp_parser_operator (cp_parser* parser, location_t start_loc)
18282 : : {
18283 : 64266925 : tree id = NULL_TREE;
18284 : 64266925 : cp_token *token;
18285 : 64266925 : bool utf8 = false;
18286 : :
18287 : : /* Peek at the next token. */
18288 : 64266925 : token = cp_lexer_peek_token (parser->lexer);
18289 : :
18290 : 64266925 : location_t end_loc = token->location;
18291 : :
18292 : : /* Figure out which operator we have. */
18293 : 64266925 : enum tree_code op = ERROR_MARK;
18294 : 64266925 : bool assop = false;
18295 : 64266925 : bool consumed = false;
18296 : 64266925 : switch (token->type)
18297 : : {
18298 : 2236714 : case CPP_KEYWORD:
18299 : 2236714 : {
18300 : : /* The keyword should be either `new', `delete' or `co_await'. */
18301 : 2236714 : if (token->keyword == RID_NEW)
18302 : : op = NEW_EXPR;
18303 : : else if (token->keyword == RID_DELETE)
18304 : : op = DELETE_EXPR;
18305 : : else if (token->keyword == RID_CO_AWAIT)
18306 : : op = CO_AWAIT_EXPR;
18307 : : else
18308 : : break;
18309 : :
18310 : : /* Consume the `new', `delete' or co_await token. */
18311 : 776423 : end_loc = cp_lexer_consume_token (parser->lexer)->location;
18312 : :
18313 : : /* Peek at the next token. */
18314 : 776423 : token = cp_lexer_peek_token (parser->lexer);
18315 : : /* If it's a `[' token then this is the array variant of the
18316 : : operator. */
18317 : 776423 : if (token->type == CPP_OPEN_SQUARE
18318 : 301944 : && op != CO_AWAIT_EXPR)
18319 : : {
18320 : : /* Consume the `[' token. */
18321 : 301944 : cp_lexer_consume_token (parser->lexer);
18322 : : /* Look for the `]' token. */
18323 : 603888 : if (cp_token *close_token
18324 : 301944 : = cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
18325 : 301929 : end_loc = close_token->location;
18326 : 301944 : op = op == NEW_EXPR ? VEC_NEW_EXPR : VEC_DELETE_EXPR;
18327 : : }
18328 : : consumed = true;
18329 : : break;
18330 : : }
18331 : :
18332 : : case CPP_PLUS:
18333 : : op = PLUS_EXPR;
18334 : : break;
18335 : :
18336 : : case CPP_MINUS:
18337 : : op = MINUS_EXPR;
18338 : : break;
18339 : :
18340 : : case CPP_MULT:
18341 : : op = MULT_EXPR;
18342 : : break;
18343 : :
18344 : : case CPP_DIV:
18345 : : op = TRUNC_DIV_EXPR;
18346 : : break;
18347 : :
18348 : : case CPP_MOD:
18349 : : op = TRUNC_MOD_EXPR;
18350 : : break;
18351 : :
18352 : : case CPP_XOR:
18353 : : op = BIT_XOR_EXPR;
18354 : : break;
18355 : :
18356 : : case CPP_AND:
18357 : : op = BIT_AND_EXPR;
18358 : : break;
18359 : :
18360 : : case CPP_OR:
18361 : : op = BIT_IOR_EXPR;
18362 : : break;
18363 : :
18364 : : case CPP_COMPL:
18365 : : op = BIT_NOT_EXPR;
18366 : : break;
18367 : :
18368 : : case CPP_NOT:
18369 : : op = TRUTH_NOT_EXPR;
18370 : : break;
18371 : :
18372 : : case CPP_EQ:
18373 : : assop = true;
18374 : : op = NOP_EXPR;
18375 : : break;
18376 : :
18377 : : case CPP_LESS:
18378 : : op = LT_EXPR;
18379 : : break;
18380 : :
18381 : : case CPP_GREATER:
18382 : : op = GT_EXPR;
18383 : : break;
18384 : :
18385 : : case CPP_PLUS_EQ:
18386 : : assop = true;
18387 : : op = PLUS_EXPR;
18388 : : break;
18389 : :
18390 : : case CPP_MINUS_EQ:
18391 : : assop = true;
18392 : : op = MINUS_EXPR;
18393 : : break;
18394 : :
18395 : : case CPP_MULT_EQ:
18396 : : assop = true;
18397 : : op = MULT_EXPR;
18398 : : break;
18399 : :
18400 : : case CPP_DIV_EQ:
18401 : : assop = true;
18402 : : op = TRUNC_DIV_EXPR;
18403 : : break;
18404 : :
18405 : : case CPP_MOD_EQ:
18406 : : assop = true;
18407 : : op = TRUNC_MOD_EXPR;
18408 : : break;
18409 : :
18410 : : case CPP_XOR_EQ:
18411 : : assop = true;
18412 : : op = BIT_XOR_EXPR;
18413 : : break;
18414 : :
18415 : : case CPP_AND_EQ:
18416 : : assop = true;
18417 : : op = BIT_AND_EXPR;
18418 : : break;
18419 : :
18420 : : case CPP_OR_EQ:
18421 : : assop = true;
18422 : : op = BIT_IOR_EXPR;
18423 : : break;
18424 : :
18425 : : case CPP_LSHIFT:
18426 : : op = LSHIFT_EXPR;
18427 : : break;
18428 : :
18429 : : case CPP_RSHIFT:
18430 : : op = RSHIFT_EXPR;
18431 : : break;
18432 : :
18433 : : case CPP_LSHIFT_EQ:
18434 : : assop = true;
18435 : : op = LSHIFT_EXPR;
18436 : : break;
18437 : :
18438 : : case CPP_RSHIFT_EQ:
18439 : : assop = true;
18440 : : op = RSHIFT_EXPR;
18441 : : break;
18442 : :
18443 : : case CPP_EQ_EQ:
18444 : : op = EQ_EXPR;
18445 : : break;
18446 : :
18447 : : case CPP_NOT_EQ:
18448 : : op = NE_EXPR;
18449 : : break;
18450 : :
18451 : : case CPP_LESS_EQ:
18452 : : op = LE_EXPR;
18453 : : break;
18454 : :
18455 : : case CPP_GREATER_EQ:
18456 : : op = GE_EXPR;
18457 : : break;
18458 : :
18459 : : case CPP_SPACESHIP:
18460 : : op = SPACESHIP_EXPR;
18461 : : break;
18462 : :
18463 : : case CPP_AND_AND:
18464 : : op = TRUTH_ANDIF_EXPR;
18465 : : break;
18466 : :
18467 : : case CPP_OR_OR:
18468 : : op = TRUTH_ORIF_EXPR;
18469 : : break;
18470 : :
18471 : : case CPP_PLUS_PLUS:
18472 : : op = POSTINCREMENT_EXPR;
18473 : : break;
18474 : :
18475 : : case CPP_MINUS_MINUS:
18476 : : op = PREDECREMENT_EXPR;
18477 : : break;
18478 : :
18479 : : case CPP_COMMA:
18480 : : op = COMPOUND_EXPR;
18481 : : break;
18482 : :
18483 : : case CPP_DEREF_STAR:
18484 : : op = MEMBER_REF;
18485 : : break;
18486 : :
18487 : : case CPP_DEREF:
18488 : : op = COMPONENT_REF;
18489 : : break;
18490 : :
18491 : 12 : case CPP_QUERY:
18492 : 12 : op = COND_EXPR;
18493 : : /* Consume the `?'. */
18494 : 12 : cp_lexer_consume_token (parser->lexer);
18495 : : /* Look for the matching `:'. */
18496 : 12 : cp_parser_require (parser, CPP_COLON, RT_COLON);
18497 : 12 : consumed = true;
18498 : 12 : break;
18499 : :
18500 : 8415709 : case CPP_OPEN_PAREN:
18501 : 8415709 : {
18502 : : /* Consume the `('. */
18503 : 8415709 : matching_parens parens;
18504 : 8415709 : parens.consume_open (parser);
18505 : : /* Look for the matching `)'. */
18506 : 8415709 : token = parens.require_close (parser);
18507 : 8415709 : if (token)
18508 : 8415703 : end_loc = token->location;
18509 : 8415709 : op = CALL_EXPR;
18510 : 8415709 : consumed = true;
18511 : 8415709 : break;
18512 : : }
18513 : :
18514 : 1818966 : case CPP_OPEN_SQUARE:
18515 : : /* Consume the `['. */
18516 : 1818966 : cp_lexer_consume_token (parser->lexer);
18517 : : /* Look for the matching `]'. */
18518 : 1818966 : token = cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
18519 : 1818966 : if (token)
18520 : 1818966 : end_loc = token->location;
18521 : : op = ARRAY_REF;
18522 : : consumed = true;
18523 : : break;
18524 : :
18525 : 25 : case CPP_UTF8STRING:
18526 : 25 : case CPP_UTF8STRING_USERDEF:
18527 : 25 : utf8 = true;
18528 : : /* FALLTHRU */
18529 : 540715 : case CPP_STRING:
18530 : 540715 : case CPP_WSTRING:
18531 : 540715 : case CPP_STRING16:
18532 : 540715 : case CPP_STRING32:
18533 : 540715 : case CPP_STRING_USERDEF:
18534 : 540715 : case CPP_WSTRING_USERDEF:
18535 : 540715 : case CPP_STRING16_USERDEF:
18536 : 540715 : case CPP_STRING32_USERDEF:
18537 : 540715 : {
18538 : 540715 : tree string_tree;
18539 : 540715 : int sz, len;
18540 : :
18541 : 540715 : if (cxx_dialect == cxx98)
18542 : 4 : maybe_warn_cpp0x (CPP0X_USER_DEFINED_LITERALS);
18543 : :
18544 : 540715 : token = cp_lexer_peek_token (parser->lexer);
18545 : :
18546 : : /* Consume the string. */
18547 : 540715 : cp_expr str = cp_parser_userdef_string_literal (parser,
18548 : : /*lookup_udlit=*/false);
18549 : 540715 : if (str == error_mark_node)
18550 : 0 : return error_mark_node;
18551 : 540715 : else if (TREE_CODE (str) == USERDEF_LITERAL)
18552 : : {
18553 : 540527 : string_tree = USERDEF_LITERAL_VALUE (str.get_value ());
18554 : 540527 : id = USERDEF_LITERAL_SUFFIX_ID (str.get_value ());
18555 : 540527 : end_loc = str.get_location ();
18556 : : }
18557 : : else
18558 : : {
18559 : 188 : string_tree = str;
18560 : : /* Look for the suffix identifier. */
18561 : 188 : cp_token *id_tok = cp_lexer_peek_token (parser->lexer);
18562 : 188 : if (id_tok->type == CPP_NAME)
18563 : : {
18564 : 176 : id = cp_parser_identifier (parser);
18565 : 176 : end_loc = id_tok->location;
18566 : :
18567 : : /* Deprecated by CWG2521 in C++23. */
18568 : 176 : if (warn_deprecated_literal_operator)
18569 : : {
18570 : 65 : gcc_rich_location
18571 : 65 : space (location_between (token, id_tok));
18572 : 65 : space.add_fixit_remove ();
18573 : 65 : warning_at (&space, OPT_Wdeprecated_literal_operator,
18574 : : "space between quotes and suffix is "
18575 : : "deprecated in C++23");
18576 : 65 : }
18577 : : }
18578 : 12 : else if (id_tok->type == CPP_KEYWORD)
18579 : : {
18580 : 3 : error ("unexpected keyword;"
18581 : : " remove space between quotes and suffix identifier");
18582 : 3 : return error_mark_node;
18583 : : }
18584 : : else
18585 : : {
18586 : 9 : error ("expected suffix identifier");
18587 : 9 : return error_mark_node;
18588 : : }
18589 : : }
18590 : 540703 : sz = TREE_INT_CST_LOW (TYPE_SIZE_UNIT
18591 : : (TREE_TYPE (TREE_TYPE (string_tree))));
18592 : 540703 : len = TREE_STRING_LENGTH (string_tree) / sz - 1;
18593 : 540703 : if (len != 0)
18594 : : {
18595 : 48 : error ("expected empty string after %<operator%> keyword");
18596 : 48 : return error_mark_node;
18597 : : }
18598 : 540655 : if (utf8 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string_tree)))
18599 : 540633 : != char_type_node)
18600 : : {
18601 : 124 : error ("invalid encoding prefix in literal operator");
18602 : 124 : return error_mark_node;
18603 : : }
18604 : 540531 : if (id != error_mark_node)
18605 : : {
18606 : 540531 : const char *name = IDENTIFIER_POINTER (id);
18607 : 540531 : id = cp_literal_operator_id (name);
18608 : : }
18609 : : /* Generate a location of the form:
18610 : : "" _suffix_identifier
18611 : : ^~~~~~~~~~~~~~~~~~~~~
18612 : : with caret == start at the start token, finish at the end of the
18613 : : suffix identifier. */
18614 : 540531 : location_t combined_loc
18615 : 540531 : = make_location (start_loc, start_loc, parser->lexer);
18616 : 540531 : return cp_expr (id, combined_loc);
18617 : : }
18618 : :
18619 : : default:
18620 : : /* Anything else is an error. */
18621 : : break;
18622 : : }
18623 : :
18624 : : /* If we have selected an identifier, we need to consume the
18625 : : operator token. */
18626 : 8415721 : if (op != ERROR_MARK)
18627 : : {
18628 : 60285037 : id = ovl_op_identifier (assop, op);
18629 : 60285037 : if (!consumed)
18630 : 49273927 : cp_lexer_consume_token (parser->lexer);
18631 : : }
18632 : : /* Otherwise, no valid operator name was present. */
18633 : : else
18634 : : {
18635 : 3441173 : cp_parser_error (parser, "expected operator");
18636 : 3441173 : id = error_mark_node;
18637 : : }
18638 : :
18639 : 63726210 : start_loc = make_location (start_loc, start_loc, get_finish (end_loc));
18640 : 63726210 : return cp_expr (id, start_loc);
18641 : : }
18642 : :
18643 : : /* Parse a template-declaration.
18644 : :
18645 : : template-declaration:
18646 : : export [opt] template < template-parameter-list > declaration
18647 : :
18648 : : If MEMBER_P is TRUE, this template-declaration occurs within a
18649 : : class-specifier.
18650 : :
18651 : : The grammar rule given by the standard isn't correct. What
18652 : : is really meant is:
18653 : :
18654 : : template-declaration:
18655 : : export [opt] template-parameter-list-seq
18656 : : decl-specifier-seq [opt] init-declarator [opt] ;
18657 : : export [opt] template-parameter-list-seq
18658 : : function-definition
18659 : :
18660 : : template-parameter-list-seq:
18661 : : template-parameter-list-seq [opt]
18662 : : template < template-parameter-list >
18663 : :
18664 : : Concept Extensions:
18665 : :
18666 : : template-parameter-list-seq:
18667 : : template < template-parameter-list > requires-clause [opt]
18668 : :
18669 : : requires-clause:
18670 : : requires logical-or-expression */
18671 : :
18672 : : static void
18673 : 74291797 : cp_parser_template_declaration (cp_parser* parser, bool member_p)
18674 : : {
18675 : : /* Check for `export'. */
18676 : 74291797 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT))
18677 : : {
18678 : : /* Consume the `export' token. */
18679 : 20 : cp_lexer_consume_token (parser->lexer);
18680 : : /* Warn that this use of export is deprecated. */
18681 : 20 : if (cxx_dialect < cxx11)
18682 : 6 : warning (0, "keyword %<export%> not implemented, and will be ignored");
18683 : 14 : else if (cxx_dialect < cxx20)
18684 : 7 : warning (0, "keyword %<export%> is deprecated, and is ignored");
18685 : : else
18686 : 7 : warning (0, "keyword %<export%> is enabled with %<-fmodules-ts%>");
18687 : : }
18688 : :
18689 : 74291797 : cp_parser_template_declaration_after_export (parser, member_p);
18690 : 74291788 : }
18691 : :
18692 : : /* Parse a template-parameter-list.
18693 : :
18694 : : template-parameter-list:
18695 : : template-parameter
18696 : : template-parameter-list , template-parameter
18697 : :
18698 : : Returns a TREE_LIST. Each node represents a template parameter.
18699 : : The nodes are connected via their TREE_CHAINs. */
18700 : :
18701 : : static tree
18702 : 76598227 : cp_parser_template_parameter_list (cp_parser* parser)
18703 : : {
18704 : 76598227 : tree parameter_list = NULL_TREE;
18705 : :
18706 : : /* Don't create wrapper nodes within a template-parameter-list,
18707 : : since we don't want to have different types based on the
18708 : : spelling location of constants and decls within them. */
18709 : 76598227 : auto_suppress_location_wrappers sentinel;
18710 : :
18711 : 76598227 : begin_template_parm_list ();
18712 : :
18713 : : /* The loop below parses the template parms. We first need to know
18714 : : the total number of template parms to be able to compute proper
18715 : : canonical types of each dependent type. So after the loop, when
18716 : : we know the total number of template parms,
18717 : : end_template_parm_list computes the proper canonical types and
18718 : : fixes up the dependent types accordingly. */
18719 : 213075249 : while (true)
18720 : : {
18721 : 144836738 : tree parameter;
18722 : 144836738 : bool is_non_type;
18723 : 144836738 : bool is_parameter_pack;
18724 : 144836738 : location_t parm_loc;
18725 : :
18726 : : /* Parse the template-parameter. */
18727 : 144836738 : parm_loc = cp_lexer_peek_token (parser->lexer)->location;
18728 : 144836738 : parameter = cp_parser_template_parameter (parser,
18729 : : &is_non_type,
18730 : : &is_parameter_pack);
18731 : : /* Add it to the list. */
18732 : 144836738 : if (parameter != error_mark_node)
18733 : 144836572 : parameter_list = process_template_parm (parameter_list,
18734 : : parm_loc,
18735 : : parameter,
18736 : : is_non_type,
18737 : : is_parameter_pack);
18738 : : else
18739 : : {
18740 : 166 : tree err_parm = build_tree_list (parameter, parameter);
18741 : 166 : parameter_list = chainon (parameter_list, err_parm);
18742 : : }
18743 : :
18744 : : /* If the next token is not a `,', we're done. */
18745 : 144836738 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
18746 : : break;
18747 : : /* Otherwise, consume the `,' token. */
18748 : 68238511 : cp_lexer_consume_token (parser->lexer);
18749 : 68238511 : }
18750 : :
18751 : 76598227 : return end_template_parm_list (parameter_list);
18752 : : }
18753 : :
18754 : : /* Given a declarator, get the declarator-id part, or NULL_TREE if this
18755 : : is an abstract declarator. */
18756 : :
18757 : : static inline cp_declarator*
18758 : 2033252 : get_id_declarator (cp_declarator *declarator)
18759 : : {
18760 : 2033252 : cp_declarator *d = declarator;
18761 : 3845648 : while (d && d->kind != cdk_id)
18762 : 915375 : d = d->declarator;
18763 : 2930273 : return d;
18764 : : }
18765 : :
18766 : : /* Get the unqualified-id from the DECLARATOR or NULL_TREE if this
18767 : : is an abstract declarator. */
18768 : :
18769 : : static inline tree
18770 : 2033252 : get_unqualified_id (cp_declarator *declarator)
18771 : : {
18772 : 2033252 : declarator = get_id_declarator (declarator);
18773 : 2033252 : if (declarator)
18774 : 2033185 : return declarator->u.id.unqualified_name;
18775 : : else
18776 : : return NULL_TREE;
18777 : : }
18778 : :
18779 : : /* Check that the type parameter is only a declarator-id, and that its
18780 : : type is not cv-qualified. */
18781 : :
18782 : : static bool
18783 : 2014931 : cp_parser_check_constrained_type_parm (cp_parser *parser,
18784 : : cp_parameter_declarator *parm)
18785 : : {
18786 : 2014931 : if (!parm->declarator)
18787 : : return true;
18788 : :
18789 : 2014867 : if (parm->declarator->kind != cdk_id)
18790 : : {
18791 : 18 : cp_parser_error (parser, "invalid constrained type parameter");
18792 : 18 : return false;
18793 : : }
18794 : :
18795 : : /* Don't allow cv-qualified type parameters. */
18796 : 2014849 : if (decl_spec_seq_has_spec_p (&parm->decl_specifiers, ds_const)
18797 : 2014849 : || decl_spec_seq_has_spec_p (&parm->decl_specifiers, ds_volatile))
18798 : : {
18799 : 6 : cp_parser_error (parser, "cv-qualified type parameter");
18800 : 6 : return false;
18801 : : }
18802 : :
18803 : : return true;
18804 : : }
18805 : :
18806 : : /* Finish parsing/processing a template type parameter and checking
18807 : : various restrictions. */
18808 : :
18809 : : static inline tree
18810 : 2014931 : cp_parser_constrained_type_template_parm (cp_parser *parser,
18811 : : tree id,
18812 : : cp_parameter_declarator* parmdecl)
18813 : : {
18814 : 2014931 : if (cp_parser_check_constrained_type_parm (parser, parmdecl))
18815 : 2014907 : return finish_template_type_parm (class_type_node, id);
18816 : : else
18817 : 24 : return error_mark_node;
18818 : : }
18819 : :
18820 : : /* Create a new non-type template parameter from the given PARM
18821 : : declarator. */
18822 : :
18823 : : static tree
18824 : 0 : cp_parser_constrained_non_type_template_parm (bool *is_non_type,
18825 : : cp_parameter_declarator *parm)
18826 : : {
18827 : 0 : *is_non_type = true;
18828 : 0 : cp_declarator *decl = parm->declarator;
18829 : 0 : cp_decl_specifier_seq *specs = &parm->decl_specifiers;
18830 : 0 : specs->type = TREE_TYPE (DECL_INITIAL (specs->type));
18831 : 0 : return grokdeclarator (decl, specs, TPARM, 0, NULL);
18832 : : }
18833 : :
18834 : : /* Build a constrained template parameter based on the PARMDECL
18835 : : declarator. The type of PARMDECL is the constrained type, which
18836 : : refers to the prototype template parameter that ultimately
18837 : : specifies the type of the declared parameter. */
18838 : :
18839 : : static tree
18840 : 2014931 : finish_constrained_parameter (cp_parser *parser,
18841 : : cp_parameter_declarator *parmdecl,
18842 : : bool *is_non_type)
18843 : : {
18844 : 2014931 : tree decl = parmdecl->decl_specifiers.type;
18845 : 2014931 : tree id = get_unqualified_id (parmdecl->declarator);
18846 : 2014931 : tree def = parmdecl->default_argument;
18847 : 2014931 : tree proto = DECL_INITIAL (decl);
18848 : :
18849 : : /* Build the parameter. Return an error if the declarator was invalid. */
18850 : 2014931 : tree parm;
18851 : 2014931 : if (TREE_CODE (proto) == TYPE_DECL)
18852 : 2014931 : parm = cp_parser_constrained_type_template_parm (parser, id, parmdecl);
18853 : : else
18854 : 0 : parm = cp_parser_constrained_non_type_template_parm (is_non_type, parmdecl);
18855 : 2014931 : if (parm == error_mark_node)
18856 : : return error_mark_node;
18857 : :
18858 : : /* Finish the parameter decl and create a node attaching the
18859 : : default argument and constraint. */
18860 : 2014907 : parm = build_tree_list (def, parm);
18861 : 2014907 : TEMPLATE_PARM_CONSTRAINTS (parm) = decl;
18862 : :
18863 : 2014907 : return parm;
18864 : : }
18865 : :
18866 : : /* Returns true if the TYPE would declare a constrained type
18867 : : template-parameter. */
18868 : :
18869 : : static bool
18870 : 17098031 : declares_constrained_type_template_parameter (tree type)
18871 : : {
18872 : 17098031 : return (type
18873 : 16415310 : && TREE_CODE (type) == TYPE_DECL
18874 : 10891837 : && CONSTRAINED_PARM_CONCEPT (type)
18875 : 2216392 : && DECL_P (CONSTRAINED_PARM_CONCEPT (type))
18876 : 19257626 : && TREE_CODE (TREE_TYPE (type)) == TEMPLATE_TYPE_PARM);
18877 : : }
18878 : :
18879 : : /* Returns true if PARM declares a constrained type template-parameter. */
18880 : :
18881 : : static bool
18882 : 13397432 : declares_constrained_type_template_parameter (cp_parameter_declarator *parm)
18883 : : {
18884 : 13397432 : tree type = parm->decl_specifiers.type;
18885 : 0 : return declares_constrained_type_template_parameter (type);
18886 : : }
18887 : :
18888 : : /* Parse a default argument for a type template-parameter.
18889 : : Note that diagnostics are handled in cp_parser_template_parameter. */
18890 : :
18891 : : static tree
18892 : 7795655 : cp_parser_default_type_template_argument (cp_parser *parser)
18893 : : {
18894 : 7795655 : gcc_assert (cp_lexer_next_token_is (parser->lexer, CPP_EQ));
18895 : :
18896 : : /* Consume the `=' token. */
18897 : 7795655 : cp_lexer_consume_token (parser->lexer);
18898 : :
18899 : 7795655 : cp_token *token = cp_lexer_peek_token (parser->lexer);
18900 : :
18901 : : /* Tell cp_parser_lambda_expression this is a default argument. */
18902 : 7795655 : auto lvf = make_temp_override (parser->local_variables_forbidden_p);
18903 : 7795655 : parser->local_variables_forbidden_p = LOCAL_VARS_AND_THIS_FORBIDDEN;
18904 : :
18905 : : /* Parse the default-argument. */
18906 : 7795655 : push_deferring_access_checks (dk_no_deferred);
18907 : 15591310 : tree default_argument = cp_parser_type_id (parser,
18908 : : CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
18909 : : NULL);
18910 : 7795655 : pop_deferring_access_checks ();
18911 : :
18912 : 7795655 : if (flag_concepts && type_uses_auto (default_argument))
18913 : : {
18914 : 2 : error_at (token->location,
18915 : : "invalid use of %<auto%> in default template argument");
18916 : 2 : return error_mark_node;
18917 : : }
18918 : :
18919 : : return default_argument;
18920 : 7795655 : }
18921 : :
18922 : : /* Parse a default argument for a template template-parameter. */
18923 : :
18924 : : static tree
18925 : 835 : cp_parser_default_template_template_argument (cp_parser *parser)
18926 : : {
18927 : 835 : gcc_assert (cp_lexer_next_token_is (parser->lexer, CPP_EQ));
18928 : :
18929 : 835 : bool is_template;
18930 : :
18931 : : /* Consume the `='. */
18932 : 835 : cp_lexer_consume_token (parser->lexer);
18933 : : /* Parse the id-expression. */
18934 : 835 : push_deferring_access_checks (dk_no_deferred);
18935 : : /* save token before parsing the id-expression, for error
18936 : : reporting */
18937 : 835 : const cp_token* token = cp_lexer_peek_token (parser->lexer);
18938 : 835 : tree default_argument
18939 : 835 : = cp_parser_id_expression (parser,
18940 : : /*template_keyword_p=*/false,
18941 : : /*check_dependency_p=*/true,
18942 : : /*template_p=*/&is_template,
18943 : : /*declarator_p=*/false,
18944 : : /*optional_p=*/false);
18945 : 835 : if (TREE_CODE (default_argument) == TYPE_DECL)
18946 : : /* If the id-expression was a template-id that refers to
18947 : : a template-class, we already have the declaration here,
18948 : : so no further lookup is needed. */
18949 : : ;
18950 : : else
18951 : : /* Look up the name. */
18952 : 832 : default_argument
18953 : 832 : = cp_parser_lookup_name (parser, default_argument,
18954 : : none_type,
18955 : : /*is_template=*/is_template,
18956 : : /*is_namespace=*/false,
18957 : : /*check_dependency=*/true,
18958 : : /*ambiguous_decls=*/NULL,
18959 : 832 : token->location);
18960 : : /* See if the default argument is valid. */
18961 : 835 : default_argument = check_template_template_default_arg (default_argument);
18962 : 835 : pop_deferring_access_checks ();
18963 : 835 : return default_argument;
18964 : : }
18965 : :
18966 : : /* Parse a template-parameter.
18967 : :
18968 : : template-parameter:
18969 : : type-parameter
18970 : : parameter-declaration
18971 : :
18972 : : If all goes well, returns a TREE_LIST. The TREE_VALUE represents
18973 : : the parameter. The TREE_PURPOSE is the default value, if any.
18974 : : Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
18975 : : iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
18976 : : set to true iff this parameter is a parameter pack. */
18977 : :
18978 : : static tree
18979 : 144836738 : cp_parser_template_parameter (cp_parser* parser, bool *is_non_type,
18980 : : bool *is_parameter_pack)
18981 : : {
18982 : 144836738 : cp_token *token;
18983 : 144836738 : cp_parameter_declarator *parameter_declarator;
18984 : 144836738 : tree parm;
18985 : :
18986 : : /* Assume it is a type parameter or a template parameter. */
18987 : 144836738 : *is_non_type = false;
18988 : : /* Assume it not a parameter pack. */
18989 : 144836738 : *is_parameter_pack = false;
18990 : : /* Peek at the next token. */
18991 : 144836738 : token = cp_lexer_peek_token (parser->lexer);
18992 : : /* If it is `template', we have a type-parameter. */
18993 : 144836738 : if (token->keyword == RID_TEMPLATE)
18994 : 305651 : return cp_parser_type_parameter (parser, is_parameter_pack);
18995 : : /* If it is `class' or `typename' we do not know yet whether it is a
18996 : : type parameter or a non-type parameter. Consider:
18997 : :
18998 : : template <typename T, typename T::X X> ...
18999 : :
19000 : : or:
19001 : :
19002 : : template <class C, class D*> ...
19003 : :
19004 : : Here, the first parameter is a type parameter, and the second is
19005 : : a non-type parameter. We can tell by looking at the token after
19006 : : the identifier -- if it is a `,', `=', or `>' then we have a type
19007 : : parameter. */
19008 : 144531087 : if (token->keyword == RID_TYPENAME || token->keyword == RID_CLASS)
19009 : : {
19010 : : /* Peek at the token after `class' or `typename'. */
19011 : 131237334 : token = cp_lexer_peek_nth_token (parser->lexer, 2);
19012 : : /* If it's an ellipsis, we have a template type parameter
19013 : : pack. */
19014 : 131237334 : if (token->type == CPP_ELLIPSIS)
19015 : 7626914 : return cp_parser_type_parameter (parser, is_parameter_pack);
19016 : : /* If it's an identifier, skip it. */
19017 : 123610420 : if (token->type == CPP_NAME)
19018 : 118641087 : token = cp_lexer_peek_nth_token (parser->lexer, 3);
19019 : : /* Now, see if the token looks like the end of a template
19020 : : parameter. */
19021 : 123610420 : if (token->type == CPP_COMMA
19022 : : || token->type == CPP_EQ
19023 : : || token->type == CPP_GREATER)
19024 : 123506741 : return cp_parser_type_parameter (parser, is_parameter_pack);
19025 : : }
19026 : :
19027 : : /* Otherwise, it is a non-type parameter or a constrained parameter.
19028 : :
19029 : : [temp.param]
19030 : :
19031 : : When parsing a default template-argument for a non-type
19032 : : template-parameter, the first non-nested `>' is taken as the end
19033 : : of the template parameter-list rather than a greater-than
19034 : : operator. */
19035 : 13397432 : parameter_declarator
19036 : 13397432 : = cp_parser_parameter_declaration (parser,
19037 : : CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
19038 : : /*template_parm_p=*/true,
19039 : : /*parenthesized_p=*/NULL);
19040 : :
19041 : 13397432 : if (!parameter_declarator)
19042 : 0 : return error_mark_node;
19043 : :
19044 : : /* If the parameter declaration is marked as a parameter pack, set
19045 : : *IS_PARAMETER_PACK to notify the caller. */
19046 : 13397432 : if (parameter_declarator->template_parameter_pack_p)
19047 : 607632 : *is_parameter_pack = true;
19048 : :
19049 : 13397432 : if (parameter_declarator->default_argument)
19050 : : {
19051 : : /* Can happen in some cases of erroneous input (c++/34892). */
19052 : 2126562 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
19053 : : /* Consume the `...' for better error recovery. */
19054 : 3 : cp_lexer_consume_token (parser->lexer);
19055 : : }
19056 : :
19057 : : /* The parameter may have been constrained type parameter. */
19058 : 13397432 : if (declares_constrained_type_template_parameter (parameter_declarator))
19059 : 2014931 : return finish_constrained_parameter (parser,
19060 : : parameter_declarator,
19061 : 2014931 : is_non_type);
19062 : :
19063 : : // Now we're sure that the parameter is a non-type parameter.
19064 : 11382501 : *is_non_type = true;
19065 : :
19066 : 11382501 : parm = grokdeclarator (parameter_declarator->declarator,
19067 : : ¶meter_declarator->decl_specifiers,
19068 : : TPARM, /*initialized=*/0,
19069 : : /*attrlist=*/NULL);
19070 : 11382501 : if (parm == error_mark_node)
19071 : : return error_mark_node;
19072 : :
19073 : 11382359 : return build_tree_list (parameter_declarator->default_argument, parm);
19074 : : }
19075 : :
19076 : : /* Parse a type-parameter.
19077 : :
19078 : : type-parameter:
19079 : : class identifier [opt]
19080 : : class identifier [opt] = type-id
19081 : : typename identifier [opt]
19082 : : typename identifier [opt] = type-id
19083 : : template < template-parameter-list > class identifier [opt]
19084 : : template < template-parameter-list > class identifier [opt]
19085 : : = id-expression
19086 : :
19087 : : GNU Extension (variadic templates):
19088 : :
19089 : : type-parameter:
19090 : : class ... identifier [opt]
19091 : : typename ... identifier [opt]
19092 : :
19093 : : Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
19094 : : TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
19095 : : the declaration of the parameter.
19096 : :
19097 : : Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
19098 : :
19099 : : static tree
19100 : 131439306 : cp_parser_type_parameter (cp_parser* parser, bool *is_parameter_pack)
19101 : : {
19102 : 131439306 : cp_token *token;
19103 : 131439306 : tree parameter;
19104 : :
19105 : : /* Look for a keyword to tell us what kind of parameter this is. */
19106 : 131439306 : token = cp_parser_require (parser, CPP_KEYWORD, RT_CLASS_TYPENAME_TEMPLATE);
19107 : 131439306 : if (!token)
19108 : 0 : return error_mark_node;
19109 : :
19110 : 131439306 : switch (token->keyword)
19111 : : {
19112 : 131133655 : case RID_CLASS:
19113 : 131133655 : case RID_TYPENAME:
19114 : 131133655 : {
19115 : 131133655 : tree identifier;
19116 : 131133655 : tree default_argument;
19117 : :
19118 : : /* If the next token is an ellipsis, we have a template
19119 : : argument pack. */
19120 : 131133655 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
19121 : : {
19122 : : /* Consume the `...' token. */
19123 : 7626914 : cp_lexer_consume_token (parser->lexer);
19124 : 7626914 : maybe_warn_variadic_templates ();
19125 : :
19126 : 7626914 : *is_parameter_pack = true;
19127 : : }
19128 : :
19129 : : /* If the next token is an identifier, then it names the
19130 : : parameter. */
19131 : 131133655 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
19132 : 125784256 : identifier = cp_parser_identifier (parser);
19133 : : else
19134 : : identifier = NULL_TREE;
19135 : :
19136 : : /* Create the parameter. */
19137 : 131133655 : parameter = finish_template_type_parm (class_type_node, identifier);
19138 : :
19139 : : /* If the next token is an `=', we have a default argument. */
19140 : 131133655 : if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
19141 : : {
19142 : 7650991 : default_argument
19143 : 7650991 : = cp_parser_default_type_template_argument (parser);
19144 : :
19145 : : /* Template parameter packs cannot have default
19146 : : arguments. */
19147 : 7650991 : if (*is_parameter_pack)
19148 : : {
19149 : 9 : if (identifier)
19150 : 6 : error_at (token->location,
19151 : : "template parameter pack %qD cannot have a "
19152 : : "default argument", identifier);
19153 : : else
19154 : 3 : error_at (token->location,
19155 : : "template parameter packs cannot have "
19156 : : "default arguments");
19157 : : default_argument = NULL_TREE;
19158 : : }
19159 : 7650982 : else if (check_for_bare_parameter_packs (default_argument))
19160 : 9 : default_argument = error_mark_node;
19161 : : }
19162 : : else
19163 : : default_argument = NULL_TREE;
19164 : :
19165 : : /* Create the combined representation of the parameter and the
19166 : : default argument. */
19167 : 131133655 : parameter = build_tree_list (default_argument, parameter);
19168 : : }
19169 : 131133655 : break;
19170 : :
19171 : 305651 : case RID_TEMPLATE:
19172 : 305651 : {
19173 : 305651 : tree identifier;
19174 : 305651 : tree default_argument;
19175 : :
19176 : : /* Look for the `<'. */
19177 : 305651 : cp_parser_require (parser, CPP_LESS, RT_LESS);
19178 : : /* Parse the template-parameter-list. */
19179 : 305651 : cp_parser_template_parameter_list (parser);
19180 : : /* Look for the `>'. */
19181 : 305651 : cp_parser_require (parser, CPP_GREATER, RT_GREATER);
19182 : :
19183 : : /* If template requirements are present, parse them. */
19184 : 305651 : if (flag_concepts)
19185 : : {
19186 : 89500 : tree reqs = get_shorthand_constraints (current_template_parms);
19187 : 89500 : if (tree dreqs = cp_parser_requires_clause_opt (parser, false))
19188 : 21 : reqs = combine_constraint_expressions (reqs, dreqs);
19189 : 89500 : TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = reqs;
19190 : : }
19191 : :
19192 : : /* Look for the `class' or 'typename' keywords. */
19193 : 305651 : cp_parser_type_parameter_key (parser);
19194 : : /* If the next token is an ellipsis, we have a template
19195 : : argument pack. */
19196 : 305651 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
19197 : : {
19198 : : /* Consume the `...' token. */
19199 : 137 : cp_lexer_consume_token (parser->lexer);
19200 : 137 : maybe_warn_variadic_templates ();
19201 : :
19202 : 137 : *is_parameter_pack = true;
19203 : : }
19204 : : /* If the next token is an `=', then there is a
19205 : : default-argument. If the next token is a `>', we are at
19206 : : the end of the parameter-list. If the next token is a `,',
19207 : : then we are at the end of this parameter. */
19208 : 305651 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
19209 : 305613 : && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)
19210 : 611027 : && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
19211 : : {
19212 : 305318 : identifier = cp_parser_identifier (parser);
19213 : : /* Treat invalid names as if the parameter were nameless. */
19214 : 305318 : if (identifier == error_mark_node)
19215 : 339 : identifier = NULL_TREE;
19216 : : }
19217 : : else
19218 : : identifier = NULL_TREE;
19219 : :
19220 : : /* Create the template parameter. */
19221 : 305651 : parameter = finish_template_template_parm (class_type_node,
19222 : : identifier);
19223 : :
19224 : : /* If the next token is an `=', then there is a
19225 : : default-argument. */
19226 : 305651 : if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
19227 : : {
19228 : 835 : default_argument
19229 : 835 : = cp_parser_default_template_template_argument (parser);
19230 : :
19231 : : /* Template parameter packs cannot have default
19232 : : arguments. */
19233 : 835 : if (*is_parameter_pack)
19234 : : {
19235 : 0 : if (identifier)
19236 : 0 : error_at (token->location,
19237 : : "template parameter pack %qD cannot "
19238 : : "have a default argument",
19239 : : identifier);
19240 : : else
19241 : 0 : error_at (token->location, "template parameter packs cannot "
19242 : : "have default arguments");
19243 : : default_argument = NULL_TREE;
19244 : : }
19245 : : }
19246 : : else
19247 : : default_argument = NULL_TREE;
19248 : :
19249 : : /* Create the combined representation of the parameter and the
19250 : : default argument. */
19251 : 305651 : parameter = build_tree_list (default_argument, parameter);
19252 : : }
19253 : 305651 : break;
19254 : :
19255 : 0 : default:
19256 : 0 : gcc_unreachable ();
19257 : : break;
19258 : : }
19259 : :
19260 : : return parameter;
19261 : : }
19262 : :
19263 : : /* Parse a template-id.
19264 : :
19265 : : template-id:
19266 : : template-name < template-argument-list [opt] >
19267 : :
19268 : : If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
19269 : : `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
19270 : : returned. Otherwise, if the template-name names a function, or set
19271 : : of functions, returns a TEMPLATE_ID_EXPR. If the template-name
19272 : : names a class, returns a TYPE_DECL for the specialization.
19273 : :
19274 : : If CHECK_DEPENDENCY_P is FALSE, names are looked up in
19275 : : uninstantiated templates. */
19276 : :
19277 : : static tree
19278 : 3332273067 : cp_parser_template_id (cp_parser *parser,
19279 : : bool template_keyword_p,
19280 : : bool check_dependency_p,
19281 : : enum tag_types tag_type,
19282 : : bool is_declaration)
19283 : : {
19284 : 3332273067 : tree templ;
19285 : 3332273067 : tree arguments;
19286 : 3332273067 : tree template_id;
19287 : 3332273067 : cp_token_position start_of_id = 0;
19288 : 3332273067 : cp_token *next_token = NULL, *next_token_2 = NULL;
19289 : 3332273067 : bool is_identifier;
19290 : :
19291 : : /* If the next token corresponds to a template-id, there is no need
19292 : : to reparse it. */
19293 : 3332273067 : cp_token *token = cp_lexer_peek_token (parser->lexer);
19294 : :
19295 : 3332273067 : if (token->type == CPP_TEMPLATE_ID)
19296 : : {
19297 : 296078139 : cp_lexer_consume_token (parser->lexer);
19298 : 296078139 : return saved_checks_value (token->u.tree_check_value);
19299 : : }
19300 : :
19301 : : /* Avoid performing name lookup if there is no possibility of
19302 : : finding a template-id. */
19303 : 718170475 : if ((token->type != CPP_NAME && token->keyword != RID_OPERATOR)
19304 : 3069117006 : || (token->type == CPP_NAME
19305 : 2318024453 : && !cp_parser_nth_token_starts_template_argument_list_p
19306 : 2318024453 : (parser, 2)))
19307 : : {
19308 : 2767210853 : cp_parser_error (parser, "expected template-id");
19309 : 2767210853 : return error_mark_node;
19310 : : }
19311 : :
19312 : : /* Remember where the template-id starts. */
19313 : 537968150 : if (cp_parser_uncommitted_to_tentative_parse_p (parser))
19314 : 268984075 : start_of_id = cp_lexer_token_position (parser->lexer, false);
19315 : :
19316 : 268984075 : push_deferring_access_checks (dk_deferred);
19317 : :
19318 : : /* Parse the template-name. */
19319 : 268984075 : is_identifier = false;
19320 : 268984075 : templ = cp_parser_template_name (parser, template_keyword_p,
19321 : : check_dependency_p,
19322 : : is_declaration,
19323 : : tag_type,
19324 : : &is_identifier);
19325 : :
19326 : : /* Push any access checks inside the firewall we're about to create. */
19327 : 268984075 : vec<deferred_access_check, va_gc> *checks = get_deferred_access_checks ();
19328 : 268984075 : pop_deferring_access_checks ();
19329 : 268984075 : if (templ == error_mark_node || is_identifier)
19330 : : return templ;
19331 : :
19332 : : /* Since we're going to preserve any side-effects from this parse, set up a
19333 : : firewall to protect our callers from cp_parser_commit_to_tentative_parse
19334 : : in the template arguments. */
19335 : 198555675 : tentative_firewall firewall (parser);
19336 : 198555675 : reopen_deferring_access_checks (checks);
19337 : :
19338 : : /* If we find the sequence `[:' after a template-name, it's probably
19339 : : a digraph-typo for `< ::'. Substitute the tokens and check if we can
19340 : : parse correctly the argument list. */
19341 : 198555675 : if (((next_token = cp_lexer_peek_token (parser->lexer))->type
19342 : : == CPP_OPEN_SQUARE)
19343 : 215329 : && next_token->flags & DIGRAPH
19344 : 1 : && ((next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2))->type
19345 : : == CPP_COLON)
19346 : 198555676 : && !(next_token_2->flags & PREV_WHITE))
19347 : : {
19348 : 1 : cp_parser_parse_tentatively (parser);
19349 : : /* Change `:' into `::'. */
19350 : 1 : next_token_2->type = CPP_SCOPE;
19351 : : /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
19352 : : CPP_LESS. */
19353 : 1 : cp_lexer_consume_token (parser->lexer);
19354 : :
19355 : : /* Parse the arguments. */
19356 : 1 : arguments = cp_parser_enclosed_template_argument_list (parser);
19357 : 1 : if (!cp_parser_parse_definitely (parser))
19358 : : {
19359 : : /* If we couldn't parse an argument list, then we revert our changes
19360 : : and return simply an error. Maybe this is not a template-id
19361 : : after all. */
19362 : 0 : next_token_2->type = CPP_COLON;
19363 : 0 : cp_parser_error (parser, "expected %<<%>");
19364 : 0 : pop_deferring_access_checks ();
19365 : 0 : return error_mark_node;
19366 : : }
19367 : : /* Otherwise, emit an error about the invalid digraph, but continue
19368 : : parsing because we got our argument list. */
19369 : 1 : auto_diagnostic_group d;
19370 : 1 : if (permerror (next_token->location,
19371 : : "%<<::%> cannot begin a template-argument list"))
19372 : : {
19373 : 1 : static bool hint = false;
19374 : 1 : inform (next_token->location,
19375 : : "%<<:%> is an alternate spelling for %<[%>."
19376 : : " Insert whitespace between %<<%> and %<::%>");
19377 : 1 : if (!hint && !flag_permissive)
19378 : : {
19379 : 0 : inform (next_token->location, "(if you use %<-fpermissive%> "
19380 : : "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
19381 : : "accept your code)");
19382 : 0 : hint = true;
19383 : : }
19384 : : }
19385 : 1 : }
19386 : : else
19387 : : {
19388 : : /* Look for the `<' that starts the template-argument-list. */
19389 : 198555674 : if (!cp_parser_require (parser, CPP_LESS, RT_LESS))
19390 : : {
19391 : 11930882 : pop_deferring_access_checks ();
19392 : 11930882 : return error_mark_node;
19393 : : }
19394 : : /* Parse the arguments. */
19395 : 186624792 : arguments = cp_parser_enclosed_template_argument_list (parser);
19396 : :
19397 : 186624792 : if ((cxx_dialect > cxx17)
19398 : 56533913 : && (TREE_CODE (templ) == FUNCTION_DECL || identifier_p (templ))
19399 : 125834 : && !template_keyword_p
19400 : 186624792 : && (cp_parser_error_occurred (parser)
19401 : 294 : || cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)))
19402 : : {
19403 : : /* This didn't go well. */
19404 : 250 : if (TREE_CODE (templ) == FUNCTION_DECL)
19405 : : {
19406 : : /* C++20 says that "function-name < a;" is now ill-formed. */
19407 : 18 : if (cp_parser_error_occurred (parser))
19408 : : {
19409 : 8 : auto_diagnostic_group d;
19410 : 8 : error_at (token->location, "invalid template-argument-list");
19411 : 8 : inform (token->location, "function name as the left hand "
19412 : : "operand of %<<%> is ill-formed in C++20; wrap the "
19413 : : "function name in %<()%>");
19414 : 8 : }
19415 : : else
19416 : : /* We expect "f<targs>" to be followed by "(args)". */
19417 : 1 : error_at (cp_lexer_peek_token (parser->lexer)->location,
19418 : : "expected %<(%> after template-argument-list");
19419 : 9 : if (start_of_id)
19420 : : /* Purge all subsequent tokens. */
19421 : 9 : cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
19422 : : }
19423 : : else
19424 : 491 : cp_parser_simulate_error (parser);
19425 : 250 : pop_deferring_access_checks ();
19426 : 250 : return error_mark_node;
19427 : : }
19428 : : }
19429 : :
19430 : : /* Set the location to be of the form:
19431 : : template-name < template-argument-list [opt] >
19432 : : ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
19433 : : with caret == start at the start of the template-name,
19434 : : ranging until the closing '>'. */
19435 : 186624543 : location_t combined_loc
19436 : 186624543 : = make_location (token->location, token->location, parser->lexer);
19437 : :
19438 : : /* Build a representation of the specialization. */
19439 : 186624543 : if (identifier_p (templ))
19440 : 619768 : template_id = build_min_nt_loc (combined_loc,
19441 : : TEMPLATE_ID_EXPR,
19442 : : templ, arguments);
19443 : 168012076 : else if (DECL_TYPE_TEMPLATE_P (templ)
19444 : 197820116 : || DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
19445 : : {
19446 : : /* In "template <typename T> ... A<T>::", A<T> is the abstract A
19447 : : template (rather than some instantiation thereof) only if
19448 : : is not nested within some other construct. For example, in
19449 : : "template <typename T> void f(T) { A<T>::", A<T> is just an
19450 : : instantiation of A. */
19451 : 156196735 : bool entering_scope
19452 : 156196735 : = (template_parm_scope_p ()
19453 : 156196735 : && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE));
19454 : 156196735 : template_id
19455 : 156196735 : = finish_template_type (templ, arguments, entering_scope);
19456 : : }
19457 : 41623381 : else if (concept_definition_p (templ))
19458 : : {
19459 : : /* The caller will decide whether this is a concept check or type
19460 : : constraint. */
19461 : 5249998 : template_id = build2_loc (combined_loc, TEMPLATE_ID_EXPR,
19462 : : boolean_type_node, templ, arguments);
19463 : : }
19464 : 24558042 : else if (variable_template_p (templ))
19465 : : {
19466 : 6565343 : template_id = lookup_template_variable (templ, arguments, tf_warning_or_error);
19467 : 6565343 : if (TREE_CODE (template_id) == TEMPLATE_ID_EXPR)
19468 : 6565305 : SET_EXPR_LOCATION (template_id, combined_loc);
19469 : : }
19470 : 17992699 : else if (TREE_CODE (templ) == TYPE_DECL
19471 : 17992699 : && TREE_CODE (TREE_TYPE (templ)) == TYPENAME_TYPE)
19472 : : {
19473 : : /* Some type template in dependent scope. */
19474 : 21 : tree &name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (templ));
19475 : 21 : name = build_min_nt_loc (combined_loc,
19476 : : TEMPLATE_ID_EXPR,
19477 : : name, arguments);
19478 : 21 : template_id = templ;
19479 : : }
19480 : : else
19481 : : {
19482 : : /* If it's not a class-template or a template-template, it should be
19483 : : a function-template. */
19484 : 17992678 : gcc_assert (OVL_P (templ) || BASELINK_P (templ));
19485 : :
19486 : 17992678 : template_id = lookup_template_function (templ, arguments);
19487 : 17992678 : if (TREE_CODE (template_id) == TEMPLATE_ID_EXPR)
19488 : 17684977 : SET_EXPR_LOCATION (template_id, combined_loc);
19489 : : }
19490 : :
19491 : : /* If parsing tentatively, replace the sequence of tokens that makes
19492 : : up the template-id with a CPP_TEMPLATE_ID token. That way,
19493 : : should we re-parse the token stream, we will not have to repeat
19494 : : the effort required to do the parse, nor will we issue duplicate
19495 : : error messages about problems during instantiation of the
19496 : : template. */
19497 : 186624540 : if (start_of_id
19498 : : /* Don't do this if we had a parse error in a declarator; re-parsing
19499 : : might succeed if a name changes meaning (60361). */
19500 : 186624540 : && !(cp_parser_error_occurred (parser)
19501 : 187 : && cp_parser_parsing_tentatively (parser)
19502 : 187 : && parser->in_declarator_p))
19503 : : {
19504 : : /* Reset the contents of the START_OF_ID token. */
19505 : 186624511 : token->type = CPP_TEMPLATE_ID;
19506 : 186624511 : token->location = combined_loc;
19507 : :
19508 : : /* Retrieve any deferred checks. Do not pop this access checks yet
19509 : : so the memory will not be reclaimed during token replacing below. */
19510 : 186624511 : token->u.tree_check_value = ggc_cleared_alloc<struct tree_check> ();
19511 : 186624511 : token->tree_check_p = true;
19512 : 186624511 : token->u.tree_check_value->value = template_id;
19513 : 186624511 : token->u.tree_check_value->checks = get_deferred_access_checks ();
19514 : 186624511 : token->keyword = RID_MAX;
19515 : :
19516 : : /* Purge all subsequent tokens. */
19517 : 186624511 : cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
19518 : :
19519 : : /* ??? Can we actually assume that, if template_id ==
19520 : : error_mark_node, we will have issued a diagnostic to the
19521 : : user, as opposed to simply marking the tentative parse as
19522 : : failed? */
19523 : 170 : if (cp_parser_error_occurred (parser) && template_id != error_mark_node)
19524 : 61 : error_at (token->location, "parse error in template argument list");
19525 : : }
19526 : :
19527 : 186624540 : pop_to_parent_deferring_access_checks ();
19528 : 186624540 : return template_id;
19529 : 198555672 : }
19530 : :
19531 : : /* Like cp_parser_template_id, called in non-type context. */
19532 : :
19533 : : static tree
19534 : 1273141267 : cp_parser_template_id_expr (cp_parser *parser,
19535 : : bool template_keyword_p,
19536 : : bool check_dependency_p,
19537 : : bool is_declaration)
19538 : : {
19539 : 1273141267 : tree x = cp_parser_template_id (parser, template_keyword_p, check_dependency_p,
19540 : : none_type, is_declaration);
19541 : 1273141267 : if (TREE_CODE (x) == TEMPLATE_ID_EXPR
19542 : 1273141267 : && concept_check_p (x))
19543 : : /* We didn't check the arguments in cp_parser_template_id; do that now. */
19544 : 4331631 : return build_concept_id (x);
19545 : : return x;
19546 : : }
19547 : :
19548 : : /* Parse a template-name.
19549 : :
19550 : : template-name:
19551 : : identifier
19552 : :
19553 : : The standard should actually say:
19554 : :
19555 : : template-name:
19556 : : identifier
19557 : : operator-function-id
19558 : :
19559 : : A defect report has been filed about this issue.
19560 : :
19561 : : A conversion-function-id cannot be a template name because they cannot
19562 : : be part of a template-id. In fact, looking at this code:
19563 : :
19564 : : a.operator K<int>()
19565 : :
19566 : : the conversion-function-id is "operator K<int>", and K<int> is a type-id.
19567 : : It is impossible to call a templated conversion-function-id with an
19568 : : explicit argument list, since the only allowed template parameter is
19569 : : the type to which it is converting.
19570 : :
19571 : : If TEMPLATE_KEYWORD_P is true, then we have just seen the
19572 : : `template' keyword, in a construction like:
19573 : :
19574 : : T::template f<3>()
19575 : :
19576 : : In that case `f' is taken to be a template-name, even though there
19577 : : is no way of knowing for sure.
19578 : :
19579 : : Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
19580 : : name refers to a set of overloaded functions, at least one of which
19581 : : is a template, or an IDENTIFIER_NODE with the name of the template,
19582 : : if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
19583 : : names are looked up inside uninstantiated templates. */
19584 : :
19585 : : static tree
19586 : 291957761 : cp_parser_template_name (cp_parser* parser,
19587 : : bool template_keyword_p,
19588 : : bool check_dependency_p,
19589 : : bool is_declaration,
19590 : : enum tag_types tag_type,
19591 : : bool *is_identifier)
19592 : : {
19593 : 291957761 : tree identifier;
19594 : 291957761 : tree decl;
19595 : 291957761 : cp_token *token = cp_lexer_peek_token (parser->lexer);
19596 : :
19597 : : /* If the next token is `operator', then we have either an
19598 : : operator-function-id or a conversion-function-id. */
19599 : 291957761 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR))
19600 : : {
19601 : : /* We don't know whether we're looking at an
19602 : : operator-function-id or a conversion-function-id. */
19603 : 32922078 : cp_parser_parse_tentatively (parser);
19604 : : /* Try an operator-function-id. */
19605 : 32922078 : identifier = cp_parser_operator_function_id (parser);
19606 : : /* If that didn't work, try a conversion-function-id. */
19607 : 32922078 : if (!cp_parser_parse_definitely (parser))
19608 : : {
19609 : 2137270 : cp_parser_error (parser, "expected template-name");
19610 : 2137270 : return error_mark_node;
19611 : : }
19612 : : }
19613 : : /* Look for the identifier. */
19614 : : else
19615 : 259035683 : identifier = cp_parser_identifier (parser);
19616 : :
19617 : : /* If we didn't find an identifier, we don't have a template-id. */
19618 : 289820491 : if (identifier == error_mark_node)
19619 : : return error_mark_node;
19620 : :
19621 : : /* If the name immediately followed the `template' keyword, then it
19622 : : is a template-name. However, if the next token is not `<', then
19623 : : we do not treat it as a template-name, since it is not being used
19624 : : as part of a template-id. This enables us to handle constructs
19625 : : like:
19626 : :
19627 : : template <typename T> struct S { S(); };
19628 : : template <typename T> S<T>::S();
19629 : :
19630 : : correctly. We would treat `S' as a template -- if it were `S<T>'
19631 : : -- but we do not if there is no `<'. */
19632 : :
19633 : 289076371 : if (processing_template_decl
19634 : 289076371 : && cp_parser_nth_token_starts_template_argument_list_p (parser, 1))
19635 : : {
19636 : : /* In a declaration, in a dependent context, we pretend that the
19637 : : "template" keyword was present in order to improve error
19638 : : recovery. For example, given:
19639 : :
19640 : : template <typename T> void f(T::X<int>);
19641 : :
19642 : : we want to treat "X<int>" as a template-id. */
19643 : 217877831 : if (is_declaration
19644 : 217877831 : && !template_keyword_p
19645 : 14612163 : && parser->scope && TYPE_P (parser->scope)
19646 : 147 : && check_dependency_p
19647 : 42 : && dependent_scope_p (parser->scope)
19648 : : /* Do not do this for dtors (or ctors), since they never
19649 : : need the template keyword before their name. */
19650 : 217877858 : && !constructor_name_p (identifier, parser->scope))
19651 : : {
19652 : 9 : cp_token_position start = 0;
19653 : :
19654 : : /* Explain what went wrong. */
19655 : 9 : {
19656 : 9 : auto_diagnostic_group d;
19657 : 9 : error_at (token->location, "non-template %qD used as template",
19658 : : identifier);
19659 : 9 : inform (token->location, "use %<%T::template %D%> to indicate "
19660 : : "that it is a template", parser->scope, identifier);
19661 : 9 : }
19662 : : /* If parsing tentatively, find the location of the "<" token. */
19663 : 27 : if (cp_parser_simulate_error (parser))
19664 : 9 : start = cp_lexer_token_position (parser->lexer, true);
19665 : : /* Parse the template arguments so that we can issue error
19666 : : messages about them. */
19667 : 9 : cp_lexer_consume_token (parser->lexer);
19668 : 9 : cp_parser_enclosed_template_argument_list (parser);
19669 : : /* Skip tokens until we find a good place from which to
19670 : : continue parsing. */
19671 : 9 : cp_parser_skip_to_closing_parenthesis (parser,
19672 : : /*recovering=*/true,
19673 : : /*or_comma=*/true,
19674 : : /*consume_paren=*/false);
19675 : : /* If parsing tentatively, permanently remove the
19676 : : template argument list. That will prevent duplicate
19677 : : error messages from being issued about the missing
19678 : : "template" keyword. */
19679 : 9 : if (start)
19680 : 9 : cp_lexer_purge_tokens_after (parser->lexer, start);
19681 : 9 : if (is_identifier)
19682 : 9 : *is_identifier = true;
19683 : 9 : parser->context->object_type = NULL_TREE;
19684 : 9 : return identifier;
19685 : : }
19686 : :
19687 : : /* If the "template" keyword is present, then there is generally
19688 : : no point in doing name-lookup, so we just return IDENTIFIER.
19689 : : But, if the qualifying scope is non-dependent then we can
19690 : : (and must) do name-lookup normally. */
19691 : 217877822 : if (template_keyword_p)
19692 : : {
19693 : 3431442 : tree scope = (parser->scope ? parser->scope
19694 : 67701 : : parser->context->object_type);
19695 : 3431442 : if (scope && TYPE_P (scope)
19696 : 4092871 : && (!CLASS_TYPE_P (scope)
19697 : 597213 : || (check_dependency_p && dependent_scope_p (scope))))
19698 : : {
19699 : : /* We're optimizing away the call to cp_parser_lookup_name, but
19700 : : we still need to do this. */
19701 : 610331 : parser->object_scope = parser->context->object_type;
19702 : 610331 : parser->context->object_type = NULL_TREE;
19703 : 610331 : return identifier;
19704 : : }
19705 : : }
19706 : : }
19707 : :
19708 : : /* cp_parser_lookup_name clears OBJECT_TYPE. */
19709 : 288466031 : tree scope = (parser->scope ? parser->scope
19710 : 249371509 : : parser->context->object_type);
19711 : :
19712 : : /* Look up the name. */
19713 : 288466031 : decl = cp_parser_lookup_name (parser, identifier,
19714 : : tag_type,
19715 : : /*is_template=*/1 + template_keyword_p,
19716 : : /*is_namespace=*/false,
19717 : : check_dependency_p,
19718 : : /*ambiguous_decls=*/NULL,
19719 : : token->location);
19720 : :
19721 : : /* 13.3 [temp.names] A < is interpreted as the delimiter of a
19722 : : template-argument-list if it follows a name that is not a
19723 : : conversion-function-id and
19724 : : - that follows the keyword template or a ~ after a nested-name-specifier or
19725 : : in a class member access expression, or
19726 : : - for which name lookup finds the injected-class-name of a class template
19727 : : or finds any declaration of a template, or
19728 : : - that is an unqualified name for which name lookup either finds one or
19729 : : more functions or finds nothing, or
19730 : : - that is a terminal name in a using-declarator (9.9), in a declarator-id
19731 : : (9.3.4), or in a type-only context other than a nested-name-specifier
19732 : : (13.8). */
19733 : :
19734 : : /* Handle injected-class-name. */
19735 : 288466031 : decl = maybe_get_template_decl_from_type_decl (decl);
19736 : :
19737 : : /* If DECL is a template, then the name was a template-name. */
19738 : 288466031 : if (TREE_CODE (decl) == TEMPLATE_DECL)
19739 : : {
19740 : 170207756 : if ((TREE_DEPRECATED (decl) || TREE_UNAVAILABLE (decl))
19741 : 1202093 : && deprecated_state != UNAVAILABLE_DEPRECATED_SUPPRESS)
19742 : : {
19743 : 1202093 : tree d = DECL_TEMPLATE_RESULT (decl);
19744 : 1202093 : tree attr;
19745 : 1202093 : if (TREE_CODE (d) == TYPE_DECL)
19746 : 1202093 : attr = TYPE_ATTRIBUTES (TREE_TYPE (d));
19747 : : else
19748 : 0 : attr = DECL_ATTRIBUTES (d);
19749 : 1202093 : if (TREE_UNAVAILABLE (decl))
19750 : : {
19751 : 3 : attr = lookup_attribute ("unavailable", attr);
19752 : 3 : error_unavailable_use (decl, attr);
19753 : : }
19754 : 1202090 : else if (TREE_DEPRECATED (decl)
19755 : 1202090 : && deprecated_state != DEPRECATED_SUPPRESS)
19756 : : {
19757 : 1202090 : attr = lookup_attribute ("deprecated", attr);
19758 : 1202090 : warn_deprecated_use (decl, attr);
19759 : : }
19760 : : }
19761 : : }
19762 : : else
19763 : : {
19764 : : /* Look through an overload set for any templates. */
19765 : 118258275 : bool found = false;
19766 : :
19767 : 236516550 : for (lkp_iterator iter (MAYBE_BASELINK_FUNCTIONS (decl));
19768 : 248552866 : !found && iter; ++iter)
19769 : 130294591 : if (TREE_CODE (*iter) == TEMPLATE_DECL)
19770 : 29923536 : found = true;
19771 : :
19772 : : /* "an unqualified name for which name lookup either finds one or more
19773 : : functions or finds nothing". */
19774 : 118258275 : if (!found
19775 : 88334739 : && (cxx_dialect > cxx17)
19776 : 22873015 : && !scope
19777 : 21661150 : && cp_lexer_next_token_is (parser->lexer, CPP_LESS)
19778 : 130575502 : && tag_type == none_type)
19779 : : {
19780 : : /* The "more functions" case. Just use the OVERLOAD as normally.
19781 : : We don't use is_overloaded_fn here to avoid considering
19782 : : BASELINKs. */
19783 : 12317193 : if (TREE_CODE (decl) == OVERLOAD
19784 : : /* Name lookup found one function. */
19785 : 12317182 : || TREE_CODE (decl) == FUNCTION_DECL
19786 : : /* Name lookup found nothing. */
19787 : 12317161 : || decl == error_mark_node)
19788 : 350 : found = true;
19789 : : }
19790 : :
19791 : : /* "that follows the keyword template"..."in a type-only context" */
19792 : 118258275 : if (!found && scope
19793 : 4536656 : && (template_keyword_p || tag_type != none_type)
19794 : 9478 : && dependentish_scope_p (scope)
19795 : 118267669 : && cp_parser_nth_token_starts_template_argument_list_p (parser, 1))
19796 : : found = true;
19797 : :
19798 : 118248881 : if (!found)
19799 : : {
19800 : : /* The name does not name a template. */
19801 : 88324995 : cp_parser_error (parser, "expected template-name");
19802 : 88324995 : return error_mark_node;
19803 : : }
19804 : 29933238 : else if ((!DECL_P (decl) && !is_overloaded_fn (decl))
19805 : 29923592 : || TREE_CODE (decl) == USING_DECL
19806 : : /* cp_parser_template_id can only handle some TYPE_DECLs. */
19807 : 59856872 : || (TREE_CODE (decl) == TYPE_DECL
19808 : 21 : && TREE_CODE (TREE_TYPE (decl)) != TYPENAME_TYPE))
19809 : : /* Repeat the lookup at instantiation time. */
19810 : : decl = identifier;
19811 : : }
19812 : :
19813 : : return decl;
19814 : : }
19815 : :
19816 : : /* Parse a template-argument-list.
19817 : :
19818 : : template-argument-list:
19819 : : template-argument ... [opt]
19820 : : template-argument-list , template-argument ... [opt]
19821 : :
19822 : : Returns a TREE_VEC containing the arguments. */
19823 : :
19824 : : static tree
19825 : 186146073 : cp_parser_template_argument_list (cp_parser* parser)
19826 : : {
19827 : 186146073 : bool saved_in_template_argument_list_p;
19828 : 186146073 : bool saved_ice_p;
19829 : 186146073 : bool saved_non_ice_p;
19830 : :
19831 : : /* Don't create location wrapper nodes within a template-argument-list. */
19832 : 186146073 : auto_suppress_location_wrappers sentinel;
19833 : :
19834 : 186146073 : saved_in_template_argument_list_p = parser->in_template_argument_list_p;
19835 : 186146073 : parser->in_template_argument_list_p = true;
19836 : : /* Even if the template-id appears in an integral
19837 : : constant-expression, the contents of the argument list do
19838 : : not. */
19839 : 186146073 : saved_ice_p = parser->integral_constant_expression_p;
19840 : 186146073 : parser->integral_constant_expression_p = false;
19841 : 186146073 : saved_non_ice_p = parser->non_integral_constant_expression_p;
19842 : 186146073 : parser->non_integral_constant_expression_p = false;
19843 : :
19844 : : /* Parse the arguments. */
19845 : 186146073 : auto_vec<tree, 10> args;
19846 : 303400554 : do
19847 : : {
19848 : 303400554 : if (!args.is_empty ())
19849 : : /* Consume the comma. */
19850 : 117254481 : cp_lexer_consume_token (parser->lexer);
19851 : :
19852 : : /* Handle #embed in the argument list. */
19853 : 303400554 : if (cp_lexer_next_token_is (parser->lexer, CPP_EMBED))
19854 : : {
19855 : 6 : tree raw_data = cp_lexer_peek_token (parser->lexer)->u.value;
19856 : 6 : cp_lexer_consume_token (parser->lexer);
19857 : 6 : args.reserve (RAW_DATA_LENGTH (raw_data), false);
19858 : 1950 : for (tree argument : raw_data_range (raw_data))
19859 : 1944 : args.quick_push (argument);
19860 : 6 : continue;
19861 : 6 : }
19862 : :
19863 : : /* Parse the template-argument. */
19864 : 303400548 : tree argument = cp_parser_template_argument (parser);
19865 : :
19866 : : /* If the next token is an ellipsis, we're expanding a template
19867 : : argument pack. */
19868 : 303400548 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
19869 : : {
19870 : 9172861 : if (argument == error_mark_node)
19871 : : {
19872 : 9 : cp_token *token = cp_lexer_peek_token (parser->lexer);
19873 : 9 : error_at (token->location,
19874 : : "expected parameter pack before %<...%>");
19875 : : }
19876 : : /* Consume the `...' token. */
19877 : 9172861 : cp_lexer_consume_token (parser->lexer);
19878 : :
19879 : : /* Make the argument into a TYPE_PACK_EXPANSION or
19880 : : EXPR_PACK_EXPANSION. */
19881 : 9172861 : argument = make_pack_expansion (argument);
19882 : : }
19883 : :
19884 : 303400548 : args.safe_push (argument);
19885 : : }
19886 : 303400554 : while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
19887 : :
19888 : 186146073 : int n_args = args.length ();
19889 : 186146073 : tree vec = make_tree_vec (n_args);
19890 : :
19891 : 489548565 : for (int i = 0; i < n_args; i++)
19892 : 303402492 : TREE_VEC_ELT (vec, i) = args[i];
19893 : :
19894 : 186146073 : parser->non_integral_constant_expression_p = saved_non_ice_p;
19895 : 186146073 : parser->integral_constant_expression_p = saved_ice_p;
19896 : 186146073 : parser->in_template_argument_list_p = saved_in_template_argument_list_p;
19897 : 186146073 : if (CHECKING_P)
19898 : 186146073 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
19899 : 186146073 : return vec;
19900 : 186146073 : }
19901 : :
19902 : : /* Parse a template-argument.
19903 : :
19904 : : template-argument:
19905 : : assignment-expression
19906 : : type-id
19907 : : id-expression
19908 : :
19909 : : The representation is that of an assignment-expression, type-id, or
19910 : : id-expression -- except that the qualified id-expression is
19911 : : evaluated, so that the value returned is either a DECL or an
19912 : : OVERLOAD.
19913 : :
19914 : : Although the standard says "assignment-expression", it forbids
19915 : : throw-expressions or assignments in the template argument.
19916 : : Therefore, we use "conditional-expression" instead. */
19917 : :
19918 : : static tree
19919 : 303400548 : cp_parser_template_argument (cp_parser* parser)
19920 : : {
19921 : 303400548 : tree argument;
19922 : 303400548 : bool template_p;
19923 : 303400548 : bool address_p;
19924 : 303400548 : bool maybe_type_id = false;
19925 : 303400548 : cp_token *token = NULL, *argument_start_token = NULL;
19926 : 303400548 : location_t loc = 0;
19927 : 303400548 : cp_id_kind idk;
19928 : :
19929 : : /* There's really no way to know what we're looking at, so we just
19930 : : try each alternative in order.
19931 : :
19932 : : [temp.arg]
19933 : :
19934 : : In a template-argument, an ambiguity between a type-id and an
19935 : : expression is resolved to a type-id, regardless of the form of
19936 : : the corresponding template-parameter.
19937 : :
19938 : : Therefore, we try a type-id first. */
19939 : 303400548 : cp_parser_parse_tentatively (parser);
19940 : 303400548 : argument = cp_parser_template_type_arg (parser);
19941 : : /* If there was no error parsing the type-id but the next token is a
19942 : : '>>', our behavior depends on which dialect of C++ we're
19943 : : parsing. In C++98, we probably found a typo for '> >'. But there
19944 : : are type-id which are also valid expressions. For instance:
19945 : :
19946 : : struct X { int operator >> (int); };
19947 : : template <int V> struct Foo {};
19948 : : Foo<X () >> 5> r;
19949 : :
19950 : : Here 'X()' is a valid type-id of a function type, but the user just
19951 : : wanted to write the expression "X() >> 5". Thus, we remember that we
19952 : : found a valid type-id, but we still try to parse the argument as an
19953 : : expression to see what happens.
19954 : :
19955 : : In C++0x, the '>>' will be considered two separate '>'
19956 : : tokens. */
19957 : 875369651 : if (!cp_parser_error_occurred (parser)
19958 : 268568573 : && ((cxx_dialect == cxx98
19959 : 770669 : && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
19960 : : /* Similarly for >= which
19961 : : cp_parser_next_token_ends_template_argument_p treats for
19962 : : diagnostics purposes as mistyped > =, but can be valid
19963 : : after a type-id. */
19964 : 268568563 : || cp_lexer_next_token_is (parser->lexer, CPP_GREATER_EQ)))
19965 : : {
19966 : 18 : maybe_type_id = true;
19967 : 18 : cp_parser_abort_tentative_parse (parser);
19968 : : }
19969 : : else
19970 : : {
19971 : : /* If the next token isn't a `,' or a `>', then this argument wasn't
19972 : : really finished. This means that the argument is not a valid
19973 : : type-id. */
19974 : 303400530 : if (!cp_parser_next_token_ends_template_argument_p (parser))
19975 : 27550544 : cp_parser_error (parser, "expected template-argument");
19976 : : /* If that worked, we're done. */
19977 : 303400530 : if (cp_parser_parse_definitely (parser))
19978 : : return argument;
19979 : : }
19980 : : /* We're still not sure what the argument will be. */
19981 : 34894154 : cp_parser_parse_tentatively (parser);
19982 : : /* Try a template. */
19983 : 34894154 : argument_start_token = cp_lexer_peek_token (parser->lexer);
19984 : 34894154 : argument = cp_parser_id_expression (parser,
19985 : : /*template_keyword_p=*/false,
19986 : : /*check_dependency_p=*/true,
19987 : : &template_p,
19988 : : /*declarator_p=*/false,
19989 : : /*optional_p=*/false);
19990 : : /* If the next token isn't a `,' or a `>', then this argument wasn't
19991 : : really finished. */
19992 : 34894154 : if (!cp_parser_next_token_ends_template_argument_p (parser))
19993 : 10413422 : cp_parser_error (parser, "expected template-argument");
19994 : 94269028 : if (!cp_parser_error_occurred (parser))
19995 : : {
19996 : : /* Figure out what is being referred to. If the id-expression
19997 : : was for a class template specialization, then we will have a
19998 : : TYPE_DECL at this point. There is no need to do name lookup
19999 : : at this point in that case. */
20000 : 24480720 : if (TREE_CODE (argument) != TYPE_DECL)
20001 : 24480720 : argument = cp_parser_lookup_name (parser, argument,
20002 : : none_type,
20003 : : /*is_template=*/template_p,
20004 : : /*is_namespace=*/false,
20005 : : /*check_dependency=*/true,
20006 : : /*ambiguous_decls=*/NULL,
20007 : : argument_start_token->location);
20008 : 24480720 : if (TREE_CODE (argument) != TEMPLATE_DECL
20009 : 17018322 : && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
20010 : 17011557 : cp_parser_error (parser, "expected template-name");
20011 : : }
20012 : 34894154 : if (cp_parser_parse_definitely (parser))
20013 : : {
20014 : 7469163 : if (TREE_UNAVAILABLE (argument))
20015 : 3 : error_unavailable_use (argument, NULL_TREE);
20016 : 7469160 : else if (TREE_DEPRECATED (argument))
20017 : 3 : warn_deprecated_use (argument, NULL_TREE);
20018 : 7469163 : return argument;
20019 : : }
20020 : : /* It must be a non-type argument. In C++17 any constant-expression is
20021 : : allowed. */
20022 : 27424991 : if (cxx_dialect > cxx14)
20023 : 27260385 : goto general_expr;
20024 : :
20025 : : /* Otherwise, the permitted cases are given in [temp.arg.nontype]:
20026 : :
20027 : : -- an integral constant-expression of integral or enumeration
20028 : : type; or
20029 : :
20030 : : -- the name of a non-type template-parameter; or
20031 : :
20032 : : -- the name of an object or function with external (or internal,
20033 : : since C++11) linkage...
20034 : :
20035 : : -- the address of an object or function with external (or internal,
20036 : : since C++11) linkage...
20037 : :
20038 : : -- a pointer to member... */
20039 : : /* Look for a non-type template parameter. */
20040 : 164606 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
20041 : : {
20042 : 65860 : cp_parser_parse_tentatively (parser);
20043 : 65860 : argument = cp_parser_primary_expression (parser,
20044 : : /*address_p=*/false,
20045 : : /*cast_p=*/false,
20046 : : /*template_arg_p=*/true,
20047 : : &idk);
20048 : 65860 : if (TREE_CODE (argument) != TEMPLATE_PARM_INDEX
20049 : 65860 : || !cp_parser_next_token_ends_template_argument_p (parser))
20050 : 87049 : cp_parser_simulate_error (parser);
20051 : 65860 : if (cp_parser_parse_definitely (parser))
20052 : : return argument;
20053 : : }
20054 : :
20055 : : /* If the next token is "&", the argument must be the address of an
20056 : : object or function with external linkage. */
20057 : 119935 : address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);
20058 : 119935 : if (address_p)
20059 : : {
20060 : 281 : loc = cp_lexer_peek_token (parser->lexer)->location;
20061 : 281 : cp_lexer_consume_token (parser->lexer);
20062 : : }
20063 : : /* See if we might have an id-expression. */
20064 : 119935 : token = cp_lexer_peek_token (parser->lexer);
20065 : 119935 : if (token->type == CPP_NAME
20066 : 98466 : || token->keyword == RID_OPERATOR
20067 : 98466 : || token->type == CPP_SCOPE
20068 : 98458 : || token->type == CPP_TEMPLATE_ID
20069 : 97038 : || token->type == CPP_NESTED_NAME_SPECIFIER)
20070 : : {
20071 : 57428 : cp_parser_parse_tentatively (parser);
20072 : 57428 : argument = cp_parser_primary_expression (parser,
20073 : : address_p,
20074 : : /*cast_p=*/false,
20075 : : /*template_arg_p=*/true,
20076 : : &idk);
20077 : 122417 : if (cp_parser_error_occurred (parser)
20078 : 57037 : || !cp_parser_next_token_ends_template_argument_p (parser))
20079 : 7952 : cp_parser_abort_tentative_parse (parser);
20080 : : else
20081 : : {
20082 : 49476 : tree probe;
20083 : :
20084 : 49476 : if (INDIRECT_REF_P (argument))
20085 : : {
20086 : : /* Strip the dereference temporarily. */
20087 : 14 : gcc_assert (REFERENCE_REF_P (argument));
20088 : 14 : argument = TREE_OPERAND (argument, 0);
20089 : : }
20090 : :
20091 : : /* If we're in a template, we represent a qualified-id referring
20092 : : to a static data member as a SCOPE_REF even if the scope isn't
20093 : : dependent so that we can check access control later. */
20094 : 49476 : probe = argument;
20095 : 49476 : if (TREE_CODE (probe) == SCOPE_REF)
20096 : 29951 : probe = TREE_OPERAND (probe, 1);
20097 : 49476 : if (VAR_P (probe))
20098 : : {
20099 : : /* A variable without valid linkage might still be a
20100 : : valid constant-expression, so no error is issued here
20101 : : if the external-linkage check fails. */
20102 : 4568 : if (!address_p)
20103 : : {
20104 : 4508 : linkage_kind linkage = decl_linkage (probe);
20105 : 4508 : if (linkage != lk_external
20106 : 2763 : && (cxx_dialect < cxx11 || linkage != lk_internal))
20107 : 52195 : cp_parser_simulate_error (parser);
20108 : : }
20109 : : }
20110 : 44908 : else if (is_overloaded_fn (argument))
20111 : : /* All overloaded functions are allowed; if the external
20112 : : linkage test does not pass, an error will be issued
20113 : : later. */
20114 : : ;
20115 : 44685 : else if (address_p
20116 : 86 : && (TREE_CODE (argument) == OFFSET_REF
20117 : 30 : || TREE_CODE (argument) == SCOPE_REF))
20118 : : /* A pointer-to-member. */
20119 : : ;
20120 : 44600 : else if (TREE_CODE (argument) == TEMPLATE_PARM_INDEX)
20121 : : ;
20122 : : else
20123 : 94063 : cp_parser_simulate_error (parser);
20124 : :
20125 : 49476 : if (cp_parser_parse_definitely (parser))
20126 : : {
20127 : 2170 : if (address_p)
20128 : 271 : argument = build_x_unary_op (loc, ADDR_EXPR, argument,
20129 : : NULL_TREE, tf_warning_or_error);
20130 : : else
20131 : 1899 : argument = convert_from_reference (argument);
20132 : 2170 : return argument;
20133 : : }
20134 : : }
20135 : : }
20136 : : /* If the argument started with "&", there are no other valid
20137 : : alternatives at this point. */
20138 : 117765 : if (address_p)
20139 : : {
20140 : 10 : cp_parser_error (parser, "invalid non-type template argument");
20141 : 10 : return error_mark_node;
20142 : : }
20143 : :
20144 : 117755 : general_expr:
20145 : : /* If the argument wasn't successfully parsed as a type-id followed
20146 : : by '>>', the argument can only be a constant expression now.
20147 : : Otherwise, we try parsing the constant-expression tentatively,
20148 : : because the argument could really be a type-id. */
20149 : 27378140 : if (maybe_type_id)
20150 : 18 : cp_parser_parse_tentatively (parser);
20151 : :
20152 : 27378140 : if (cxx_dialect <= cxx14)
20153 : 117755 : argument = cp_parser_constant_expression (parser);
20154 : : else
20155 : : {
20156 : : /* In C++20, we can encounter a braced-init-list. */
20157 : 27260385 : if (cxx_dialect >= cxx20
20158 : 27260385 : && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
20159 : 74 : return cp_parser_braced_list (parser);
20160 : :
20161 : : /* With C++17 generalized non-type template arguments we need to handle
20162 : : lvalue constant expressions, too. */
20163 : 27260311 : argument = cp_parser_assignment_expression (parser);
20164 : 27260311 : require_potential_constant_expression (argument);
20165 : : }
20166 : :
20167 : 27378066 : if (!maybe_type_id)
20168 : : return argument;
20169 : 18 : if (!cp_parser_next_token_ends_template_argument_p (parser))
20170 : 14 : cp_parser_error (parser, "expected template-argument");
20171 : 18 : if (cp_parser_parse_definitely (parser))
20172 : : return argument;
20173 : : /* We did our best to parse the argument as a non type-id, but that
20174 : : was the only alternative that matched (albeit with a '>' after
20175 : : it). We can assume it's just a typo from the user, and a
20176 : : diagnostic will then be issued. */
20177 : 14 : return cp_parser_template_type_arg (parser);
20178 : : }
20179 : :
20180 : : /* Parse an explicit-instantiation.
20181 : :
20182 : : explicit-instantiation:
20183 : : template declaration
20184 : :
20185 : : Although the standard says `declaration', what it really means is:
20186 : :
20187 : : explicit-instantiation:
20188 : : template decl-specifier-seq [opt] declarator [opt] ;
20189 : :
20190 : : Things like `template int S<int>::i = 5, int S<double>::j;' are not
20191 : : supposed to be allowed. A defect report has been filed about this
20192 : : issue.
20193 : :
20194 : : GNU Extension:
20195 : :
20196 : : explicit-instantiation:
20197 : : storage-class-specifier template
20198 : : decl-specifier-seq [opt] declarator [opt] ;
20199 : : function-specifier template
20200 : : decl-specifier-seq [opt] declarator [opt] ; */
20201 : :
20202 : : static void
20203 : 2744191 : cp_parser_explicit_instantiation (cp_parser* parser)
20204 : : {
20205 : 2744191 : int declares_class_or_enum;
20206 : 2744191 : cp_decl_specifier_seq decl_specifiers;
20207 : 2744191 : tree extension_specifier = NULL_TREE;
20208 : :
20209 : 2744191 : auto_timevar tv (TV_TEMPLATE_INST);
20210 : :
20211 : : /* Look for an (optional) storage-class-specifier or
20212 : : function-specifier. */
20213 : 2744191 : if (cp_parser_allow_gnu_extensions_p (parser))
20214 : : {
20215 : 2744191 : extension_specifier
20216 : 2744191 : = cp_parser_storage_class_specifier_opt (parser);
20217 : 2744191 : if (!extension_specifier)
20218 : 5709 : extension_specifier
20219 : 5709 : = cp_parser_function_specifier_opt (parser,
20220 : : /*decl_specs=*/NULL);
20221 : : }
20222 : :
20223 : : /* Look for the `template' keyword. */
20224 : 2744191 : cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE);
20225 : : /* Let the front end know that we are processing an explicit
20226 : : instantiation. */
20227 : 2744191 : begin_explicit_instantiation ();
20228 : : /* [temp.explicit] says that we are supposed to ignore access
20229 : : control while processing explicit instantiation directives. */
20230 : 2744191 : push_deferring_access_checks (dk_no_check);
20231 : : /* Parse a decl-specifier-seq. */
20232 : 2744191 : cp_parser_decl_specifier_seq (parser,
20233 : : CP_PARSER_FLAGS_OPTIONAL,
20234 : : &decl_specifiers,
20235 : : &declares_class_or_enum);
20236 : :
20237 : 2744191 : cp_omp_declare_simd_data odsd;
20238 : 2744191 : if (decl_specifiers.attributes && (flag_openmp || flag_openmp_simd))
20239 : 6 : cp_parser_handle_directive_omp_attributes (parser,
20240 : : &decl_specifiers.attributes,
20241 : : &odsd, true);
20242 : :
20243 : : /* If there was exactly one decl-specifier, and it declared a class,
20244 : : and there's no declarator, then we have an explicit type
20245 : : instantiation. */
20246 : 2744191 : if (declares_class_or_enum && cp_parser_declares_only_class_p (parser))
20247 : : {
20248 : 793601 : tree type = check_tag_decl (&decl_specifiers,
20249 : : /*explicit_type_instantiation_p=*/true);
20250 : : /* Turn access control back on for names used during
20251 : : template instantiation. */
20252 : 793601 : pop_deferring_access_checks ();
20253 : 793601 : if (type)
20254 : 793570 : do_type_instantiation (type, extension_specifier,
20255 : : /*complain=*/tf_error);
20256 : : }
20257 : : else
20258 : : {
20259 : 1950590 : cp_declarator *declarator;
20260 : 1950590 : tree decl;
20261 : :
20262 : : /* Parse the declarator. */
20263 : 1950590 : declarator
20264 : 1950590 : = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
20265 : : CP_PARSER_FLAGS_NONE,
20266 : : /*ctor_dtor_or_conv_p=*/NULL,
20267 : : /*parenthesized_p=*/NULL,
20268 : : /*member_p=*/false,
20269 : : /*friend_p=*/false,
20270 : : /*static_p=*/false);
20271 : 1950590 : if (declares_class_or_enum & 2)
20272 : 0 : cp_parser_check_for_definition_in_return_type (declarator,
20273 : : decl_specifiers.type,
20274 : : decl_specifiers.locations[ds_type_spec]);
20275 : 1950590 : if (declarator != cp_error_declarator)
20276 : : {
20277 : 1950569 : if (decl_spec_seq_has_spec_p (&decl_specifiers, ds_inline))
20278 : 3 : permerror (decl_specifiers.locations[ds_inline],
20279 : : "explicit instantiation shall not use"
20280 : : " %<inline%> specifier");
20281 : 1950569 : if (decl_spec_seq_has_spec_p (&decl_specifiers, ds_constexpr))
20282 : 3 : permerror (decl_specifiers.locations[ds_constexpr],
20283 : : "explicit instantiation shall not use"
20284 : : " %<constexpr%> specifier");
20285 : 1950569 : if (decl_spec_seq_has_spec_p (&decl_specifiers, ds_consteval))
20286 : 3 : permerror (decl_specifiers.locations[ds_consteval],
20287 : : "explicit instantiation shall not use"
20288 : : " %<consteval%> specifier");
20289 : :
20290 : 1950569 : decl = grokdeclarator (declarator, &decl_specifiers,
20291 : : NORMAL, 0, &decl_specifiers.attributes);
20292 : : /* Turn access control back on for names used during
20293 : : template instantiation. */
20294 : 1950569 : pop_deferring_access_checks ();
20295 : : /* Do the explicit instantiation. */
20296 : 1950569 : do_decl_instantiation (decl, extension_specifier);
20297 : : }
20298 : : else
20299 : : {
20300 : 21 : pop_deferring_access_checks ();
20301 : : /* Skip the body of the explicit instantiation. */
20302 : 21 : cp_parser_skip_to_end_of_statement (parser);
20303 : : }
20304 : : }
20305 : : /* We're done with the instantiation. */
20306 : 2744188 : end_explicit_instantiation ();
20307 : :
20308 : 2744188 : cp_parser_consume_semicolon_at_end_of_statement (parser);
20309 : :
20310 : 2744188 : cp_finalize_omp_declare_simd (parser, &odsd);
20311 : 2744188 : }
20312 : :
20313 : : /* Parse an explicit-specialization.
20314 : :
20315 : : explicit-specialization:
20316 : : template < > declaration
20317 : :
20318 : : Although the standard says `declaration', what it really means is:
20319 : :
20320 : : explicit-specialization:
20321 : : template <> decl-specifier [opt] init-declarator [opt] ;
20322 : : template <> function-definition
20323 : : template <> explicit-specialization
20324 : : template <> template-declaration */
20325 : :
20326 : : static void
20327 : 4811007 : cp_parser_explicit_specialization (cp_parser* parser)
20328 : : {
20329 : 4811007 : cp_token *token = cp_lexer_peek_token (parser->lexer);
20330 : :
20331 : : /* Look for the `template' keyword. */
20332 : 4811007 : cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE);
20333 : : /* Look for the `<'. */
20334 : 4811007 : cp_parser_require (parser, CPP_LESS, RT_LESS);
20335 : : /* Look for the `>'. */
20336 : 4811007 : cp_parser_require (parser, CPP_GREATER, RT_GREATER);
20337 : : /* We have processed another parameter list. */
20338 : 4811007 : ++parser->num_template_parameter_lists;
20339 : :
20340 : : /* [temp]
20341 : :
20342 : : A template ... explicit specialization ... shall not have C
20343 : : linkage. */
20344 : 4811007 : bool need_lang_pop = current_lang_name == lang_name_c;
20345 : 4811007 : if (need_lang_pop)
20346 : : {
20347 : 3 : auto_diagnostic_group d;
20348 : 3 : error_at (token->location, "template specialization with C linkage");
20349 : 3 : maybe_show_extern_c_location ();
20350 : :
20351 : : /* Give it C++ linkage to avoid confusing other parts of the
20352 : : front end. */
20353 : 3 : push_lang_context (lang_name_cplusplus);
20354 : 3 : }
20355 : :
20356 : : /* Let the front end know that we are beginning a specialization. */
20357 : 4811007 : if (begin_specialization ())
20358 : : {
20359 : : /* If the next keyword is `template', we need to figure out
20360 : : whether or not we're looking a template-declaration. */
20361 : 4810983 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
20362 : : {
20363 : 1180 : if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
20364 : 1180 : && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER)
20365 : 1024 : cp_parser_template_declaration_after_export (parser,
20366 : : /*member_p=*/false);
20367 : : else
20368 : 156 : cp_parser_explicit_specialization (parser);
20369 : : }
20370 : : else
20371 : : /* Parse the dependent declaration. */
20372 : 4809803 : cp_parser_single_declaration (parser,
20373 : : /*checks=*/NULL,
20374 : : /*member_p=*/false,
20375 : : /*explicit_specialization_p=*/true,
20376 : : /*friend_p=*/NULL);
20377 : : }
20378 : :
20379 : : /* We're done with the specialization. */
20380 : 4811007 : end_specialization ();
20381 : :
20382 : : /* For the erroneous case of a template with C linkage, we pushed an
20383 : : implicit C++ linkage scope; exit that scope now. */
20384 : 4811007 : if (need_lang_pop)
20385 : 3 : pop_lang_context ();
20386 : :
20387 : : /* We're done with this parameter list. */
20388 : 4811007 : --parser->num_template_parameter_lists;
20389 : 4811007 : }
20390 : :
20391 : : /* Preserve the attributes across a garbage collect (by making it a GC
20392 : : root), which can occur when parsing a member function. */
20393 : :
20394 : : static GTY(()) vec<tree, va_gc> *cp_parser_decl_specs_attrs;
20395 : :
20396 : : /* Parse a type-specifier.
20397 : :
20398 : : type-specifier:
20399 : : simple-type-specifier
20400 : : class-specifier
20401 : : enum-specifier
20402 : : elaborated-type-specifier
20403 : : cv-qualifier
20404 : :
20405 : : GNU Extension:
20406 : :
20407 : : type-specifier:
20408 : : __complex__
20409 : :
20410 : : Returns a representation of the type-specifier. For a
20411 : : class-specifier, enum-specifier, or elaborated-type-specifier, a
20412 : : TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
20413 : :
20414 : : The parser flags FLAGS is used to control type-specifier parsing.
20415 : :
20416 : : If IS_DECLARATION is TRUE, then this type-specifier is appearing
20417 : : in a decl-specifier-seq.
20418 : :
20419 : : If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
20420 : : class-specifier, enum-specifier, or elaborated-type-specifier, then
20421 : : *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
20422 : : if a type is declared; 2 if it is defined. Otherwise, it is set to
20423 : : zero.
20424 : :
20425 : : If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
20426 : : cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
20427 : : is set to FALSE. */
20428 : :
20429 : : static tree
20430 : 2091366443 : cp_parser_type_specifier (cp_parser* parser,
20431 : : cp_parser_flags flags,
20432 : : cp_decl_specifier_seq *decl_specs,
20433 : : bool is_declaration,
20434 : : int* declares_class_or_enum,
20435 : : bool* is_cv_qualifier)
20436 : : {
20437 : 2091366443 : tree type_spec = NULL_TREE;
20438 : 2091366443 : cp_token *token;
20439 : 2091366443 : enum rid keyword;
20440 : 2091366443 : cp_decl_spec ds = ds_last;
20441 : :
20442 : : /* Assume this type-specifier does not declare a new type. */
20443 : 2091366443 : if (declares_class_or_enum)
20444 : 1379802222 : *declares_class_or_enum = 0;
20445 : : /* And that it does not specify a cv-qualifier. */
20446 : 2091366443 : if (is_cv_qualifier)
20447 : 2080886759 : *is_cv_qualifier = false;
20448 : : /* Peek at the next token. */
20449 : 2091366443 : token = cp_lexer_peek_token (parser->lexer);
20450 : :
20451 : : /* If we're looking at a keyword, we can use that to guide the
20452 : : production we choose. */
20453 : 2091366443 : keyword = token->keyword;
20454 : 2091366443 : switch (keyword)
20455 : : {
20456 : 1609754 : case RID_ENUM:
20457 : 1609754 : if ((flags & CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS))
20458 : 3 : goto elaborated_type_specifier;
20459 : :
20460 : : /* Look for the enum-specifier. */
20461 : 1609751 : type_spec = cp_parser_enum_specifier (parser);
20462 : : /* If that worked, we're done. */
20463 : 1609751 : if (type_spec)
20464 : : {
20465 : 1583611 : if (declares_class_or_enum)
20466 : 1583572 : *declares_class_or_enum = 2;
20467 : 1583611 : if (decl_specs)
20468 : 1583611 : cp_parser_set_decl_spec_type (decl_specs,
20469 : : type_spec,
20470 : : token,
20471 : : /*type_definition_p=*/true);
20472 : 1583611 : return type_spec;
20473 : : }
20474 : : else
20475 : 26140 : goto elaborated_type_specifier;
20476 : :
20477 : : /* Any of these indicate either a class-specifier, or an
20478 : : elaborated-type-specifier. */
20479 : 35710610 : case RID_CLASS:
20480 : 35710610 : case RID_STRUCT:
20481 : 35710610 : case RID_UNION:
20482 : 35710610 : if ((flags & CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS))
20483 : 9 : goto elaborated_type_specifier;
20484 : :
20485 : : /* Parse tentatively so that we can back up if we don't find a
20486 : : class-specifier. */
20487 : 35710601 : cp_parser_parse_tentatively (parser);
20488 : 35710601 : if (decl_specs->attributes)
20489 : 406 : vec_safe_push (cp_parser_decl_specs_attrs, decl_specs->attributes);
20490 : : /* Look for the class-specifier. */
20491 : 35710601 : type_spec = cp_parser_class_specifier (parser);
20492 : 35710580 : if (decl_specs->attributes)
20493 : 406 : cp_parser_decl_specs_attrs->pop ();
20494 : 35710580 : invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, type_spec);
20495 : : /* If that worked, we're done. */
20496 : 35710580 : if (cp_parser_parse_definitely (parser))
20497 : : {
20498 : 23646873 : if (declares_class_or_enum)
20499 : 23646707 : *declares_class_or_enum = 2;
20500 : 23646873 : if (decl_specs)
20501 : 23646873 : cp_parser_set_decl_spec_type (decl_specs,
20502 : : type_spec,
20503 : : token,
20504 : : /*type_definition_p=*/true);
20505 : 23646873 : return type_spec;
20506 : : }
20507 : :
20508 : : /* Fall through. */
20509 : 12063707 : elaborated_type_specifier:
20510 : : /* We're declaring (not defining) a class or enum. */
20511 : 12089859 : if (declares_class_or_enum)
20512 : 7842755 : *declares_class_or_enum = 1;
20513 : :
20514 : : /* Fall through. */
20515 : 39084650 : case RID_TYPENAME:
20516 : : /* Look for an elaborated-type-specifier. */
20517 : 39084650 : type_spec
20518 : : = (cp_parser_elaborated_type_specifier
20519 : 39084650 : (parser,
20520 : 39084650 : decl_spec_seq_has_spec_p (decl_specs, ds_friend),
20521 : : is_declaration));
20522 : 39084650 : if (decl_specs)
20523 : 39084650 : cp_parser_set_decl_spec_type (decl_specs,
20524 : : type_spec,
20525 : : token,
20526 : : /*type_definition_p=*/false);
20527 : : return type_spec;
20528 : :
20529 : 95456111 : case RID_CONST:
20530 : 95456111 : ds = ds_const;
20531 : 95456111 : if (is_cv_qualifier)
20532 : 95456111 : *is_cv_qualifier = true;
20533 : : break;
20534 : :
20535 : 1504610 : case RID_VOLATILE:
20536 : 1504610 : ds = ds_volatile;
20537 : 1504610 : if (is_cv_qualifier)
20538 : 1504610 : *is_cv_qualifier = true;
20539 : : break;
20540 : :
20541 : 37 : case RID_RESTRICT:
20542 : 37 : ds = ds_restrict;
20543 : 37 : if (is_cv_qualifier)
20544 : 37 : *is_cv_qualifier = true;
20545 : : break;
20546 : :
20547 : : case RID_COMPLEX:
20548 : : /* The `__complex__' keyword is a GNU extension. */
20549 : : ds = ds_complex;
20550 : : break;
20551 : :
20552 : : default:
20553 : : break;
20554 : : }
20555 : :
20556 : : /* Handle simple keywords. */
20557 : 96960758 : if (ds != ds_last)
20558 : : {
20559 : 98272623 : if (decl_specs)
20560 : : {
20561 : 98272623 : set_and_check_decl_spec_loc (decl_specs, ds, token);
20562 : 98272623 : decl_specs->any_specifiers_p = true;
20563 : : }
20564 : 98272623 : return cp_lexer_consume_token (parser->lexer)->u.value;
20565 : : }
20566 : :
20567 : : /* If we do not already have a type-specifier, assume we are looking
20568 : : at a simple-type-specifier. */
20569 : 1928778665 : type_spec = cp_parser_simple_type_specifier (parser,
20570 : : decl_specs,
20571 : : flags);
20572 : :
20573 : : /* If we didn't find a type-specifier, and a type-specifier was not
20574 : : optional in this context, issue an error message. */
20575 : 1928778662 : if (!type_spec && !(flags & CP_PARSER_FLAGS_OPTIONAL))
20576 : : {
20577 : 0 : cp_parser_error (parser, "expected type specifier");
20578 : 0 : return error_mark_node;
20579 : : }
20580 : :
20581 : : return type_spec;
20582 : : }
20583 : :
20584 : : /* Parse a simple-type-specifier.
20585 : :
20586 : : simple-type-specifier:
20587 : : :: [opt] nested-name-specifier [opt] type-name
20588 : : :: [opt] nested-name-specifier template template-id
20589 : : char
20590 : : wchar_t
20591 : : bool
20592 : : short
20593 : : int
20594 : : long
20595 : : signed
20596 : : unsigned
20597 : : float
20598 : : double
20599 : : void
20600 : :
20601 : : C++11 Extension:
20602 : :
20603 : : simple-type-specifier:
20604 : : char16_t
20605 : : char32_t
20606 : : __underlying_type ( type-id )
20607 : : computed-type-specifier
20608 : : placeholder-type-specifier
20609 : :
20610 : : C++17 extension:
20611 : :
20612 : : nested-name-specifier(opt) template-name
20613 : :
20614 : : GNU Extension:
20615 : :
20616 : : simple-type-specifier:
20617 : : __int128
20618 : : __typeof__ unary-expression
20619 : : __typeof__ ( type-id )
20620 : : __typeof__ ( type-id ) { initializer-list , [opt] }
20621 : :
20622 : : Concepts Extension:
20623 : :
20624 : : simple-type-specifier:
20625 : : constrained-type-specifier
20626 : :
20627 : : Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
20628 : : appropriately updated. */
20629 : :
20630 : : static tree
20631 : 2788979296 : cp_parser_simple_type_specifier (cp_parser* parser,
20632 : : cp_decl_specifier_seq *decl_specs,
20633 : : cp_parser_flags flags)
20634 : : {
20635 : 2788979296 : tree type = NULL_TREE;
20636 : 2788979296 : cp_token *token;
20637 : 2788979296 : int idx;
20638 : :
20639 : : /* Peek at the next token. */
20640 : 2788979296 : token = cp_lexer_peek_token (parser->lexer);
20641 : :
20642 : : /* If we're looking at a keyword, things are easy. */
20643 : 2788979296 : switch (token->keyword)
20644 : : {
20645 : 19880477 : case RID_CHAR:
20646 : 19880477 : if (decl_specs)
20647 : 19838522 : decl_specs->explicit_char_p = true;
20648 : 19880477 : type = char_type_node;
20649 : 19880477 : break;
20650 : 248848 : case RID_CHAR8:
20651 : 248848 : type = char8_type_node;
20652 : 248848 : break;
20653 : 1032870 : case RID_CHAR16:
20654 : 1032870 : type = char16_type_node;
20655 : 1032870 : break;
20656 : 1108024 : case RID_CHAR32:
20657 : 1108024 : type = char32_type_node;
20658 : 1108024 : break;
20659 : 6220055 : case RID_WCHAR:
20660 : 6220055 : type = wchar_type_node;
20661 : 6220055 : break;
20662 : 35173954 : case RID_BOOL:
20663 : 35173954 : type = boolean_type_node;
20664 : 35173954 : break;
20665 : 1778102 : case RID_SHORT:
20666 : 1778102 : set_and_check_decl_spec_loc (decl_specs, ds_short, token);
20667 : 1778102 : type = short_integer_type_node;
20668 : 1778102 : break;
20669 : 36178809 : case RID_INT:
20670 : 36178809 : if (decl_specs)
20671 : 34863444 : decl_specs->explicit_int_p = true;
20672 : 36178809 : type = integer_type_node;
20673 : 36178809 : break;
20674 : 864490 : case RID_INT_N_0:
20675 : 864490 : case RID_INT_N_1:
20676 : 864490 : case RID_INT_N_2:
20677 : 864490 : case RID_INT_N_3:
20678 : 864490 : idx = token->keyword - RID_INT_N_0;
20679 : 864490 : if (! int_n_enabled_p [idx])
20680 : : break;
20681 : 864490 : if (decl_specs)
20682 : : {
20683 : 862408 : decl_specs->explicit_intN_p = true;
20684 : 862408 : decl_specs->int_n_idx = idx;
20685 : : /* Check if the alternate "__intN__" form has been used instead of
20686 : : "__intN". */
20687 : 862408 : if (startswith (IDENTIFIER_POINTER (token->u.value)
20688 : 862408 : + (IDENTIFIER_LENGTH (token->u.value) - 2), "__"))
20689 : 0 : decl_specs->int_n_alt = true;
20690 : : }
20691 : 864490 : type = int_n_trees [idx].signed_type;
20692 : 864490 : break;
20693 : 19633101 : case RID_LONG:
20694 : 19633101 : if (decl_specs)
20695 : 19633063 : set_and_check_decl_spec_loc (decl_specs, ds_long, token);
20696 : 19633101 : type = long_integer_type_node;
20697 : 19633101 : break;
20698 : 1005361 : case RID_SIGNED:
20699 : 1005361 : set_and_check_decl_spec_loc (decl_specs, ds_signed, token);
20700 : 1005361 : type = integer_type_node;
20701 : 1005361 : break;
20702 : 12267244 : case RID_UNSIGNED:
20703 : 12267244 : set_and_check_decl_spec_loc (decl_specs, ds_unsigned, token);
20704 : 12267244 : type = unsigned_type_node;
20705 : 12267244 : break;
20706 : 8284810 : case RID_FLOAT:
20707 : 8284810 : type = float_type_node;
20708 : 8284810 : break;
20709 : 17308988 : case RID_DOUBLE:
20710 : 17308988 : type = double_type_node;
20711 : 17308988 : break;
20712 : 23367271 : CASE_RID_FLOATN_NX:
20713 : 23367271 : type = FLOATN_NX_TYPE_NODE (token->keyword - RID_FLOATN_NX_FIRST);
20714 : 23367271 : if (type == NULL_TREE)
20715 : 0 : error ("%<_Float%d%s%> is not supported on this target",
20716 : 0 : floatn_nx_types[token->keyword - RID_FLOATN_NX_FIRST].n,
20717 : 0 : floatn_nx_types[token->keyword - RID_FLOATN_NX_FIRST].extended
20718 : : ? "x" : "");
20719 : : break;
20720 : 29600176 : case RID_VOID:
20721 : 29600176 : type = void_type_node;
20722 : 29600176 : break;
20723 : :
20724 : 9741986 : case RID_AUTO:
20725 : 9741986 : maybe_warn_cpp0x (CPP0X_AUTO);
20726 : 9741986 : if (parser->auto_is_implicit_function_template_parm_p)
20727 : : {
20728 : : /* The 'auto' might be the placeholder return type for a function decl
20729 : : with trailing return type. */
20730 : 343711 : bool have_trailing_return_fn_decl = false;
20731 : :
20732 : 343711 : cp_parser_parse_tentatively (parser);
20733 : 343711 : cp_lexer_consume_token (parser->lexer);
20734 : 343711 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
20735 : 978663 : && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
20736 : : && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
20737 : 978669 : && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
20738 : : {
20739 : 124 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
20740 : : {
20741 : 124 : cp_lexer_consume_token (parser->lexer);
20742 : 124 : cp_parser_skip_to_closing_parenthesis (parser,
20743 : : /*recovering*/false,
20744 : : /*or_comma*/false,
20745 : : /*consume_paren*/true);
20746 : 124 : continue;
20747 : : }
20748 : :
20749 : : if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
20750 : : {
20751 : : have_trailing_return_fn_decl = true;
20752 : : break;
20753 : : }
20754 : :
20755 : 634834 : cp_lexer_consume_token (parser->lexer);
20756 : : }
20757 : 343711 : cp_parser_abort_tentative_parse (parser);
20758 : :
20759 : 343711 : if (have_trailing_return_fn_decl)
20760 : : {
20761 : 37 : type = make_auto ();
20762 : 37 : break;
20763 : : }
20764 : :
20765 : 343674 : if (cxx_dialect >= cxx14)
20766 : : {
20767 : 343667 : type = synthesize_implicit_template_parm (parser, NULL_TREE);
20768 : 343667 : type = TREE_TYPE (type);
20769 : : }
20770 : : else
20771 : 7 : type = error_mark_node;
20772 : :
20773 : 686923 : if (current_class_type && LAMBDA_TYPE_P (current_class_type))
20774 : : {
20775 : 342817 : if (cxx_dialect < cxx14)
20776 : 3 : error_at (token->location,
20777 : : "use of %<auto%> in lambda parameter declaration "
20778 : : "only available with "
20779 : : "%<-std=c++14%> or %<-std=gnu++14%>");
20780 : : }
20781 : 857 : else if (parser->in_template_argument_list_p)
20782 : 6 : error_at (token->location,
20783 : : "use of %<auto%> in template argument");
20784 : 851 : else if (!flag_concepts)
20785 : 19 : pedwarn (token->location, OPT_Wc__20_extensions,
20786 : : "use of %<auto%> in parameter declaration "
20787 : : "only available with %<-std=c++20%> or %<-fconcepts%>");
20788 : 832 : else if (cxx_dialect < cxx14)
20789 : 0 : error_at (token->location,
20790 : : "use of %<auto%> in parameter declaration "
20791 : : "only available with "
20792 : : "%<-std=c++14%> or %<-std=gnu++14%>");
20793 : : }
20794 : : else
20795 : 9398275 : type = make_auto ();
20796 : : break;
20797 : :
20798 : 2975845 : case RID_DECLTYPE:
20799 : : /* Since DR 743, decltype can either be a simple-type-specifier by
20800 : : itself or begin a nested-name-specifier. Parsing it will replace
20801 : : it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
20802 : : handling below decide what to do. */
20803 : 2975845 : cp_parser_decltype (parser);
20804 : 2975845 : cp_lexer_set_token_position (parser->lexer, token);
20805 : 2975845 : break;
20806 : :
20807 : 92981 : case RID_TYPEOF:
20808 : : /* Consume the `typeof' token. */
20809 : 92981 : cp_lexer_consume_token (parser->lexer);
20810 : : /* Parse the operand to `typeof'. */
20811 : 92981 : type = cp_parser_sizeof_operand (parser, RID_TYPEOF);
20812 : : /* If it is not already a TYPE, take its type. */
20813 : 92981 : if (!TYPE_P (type))
20814 : 92978 : type = finish_typeof (type);
20815 : :
20816 : 92981 : if (decl_specs)
20817 : 92978 : cp_parser_set_decl_spec_type (decl_specs, type,
20818 : : token,
20819 : : /*type_definition_p=*/false);
20820 : :
20821 : : return type;
20822 : :
20823 : 2562215904 : default:
20824 : : /* If token is a type-yielding built-in traits, parse it. */
20825 : 2562215904 : const cp_trait* trait = cp_lexer_peek_trait_type (parser->lexer);
20826 : 2562215904 : if (trait)
20827 : : {
20828 : 156645 : type = cp_parser_trait (parser, trait);
20829 : 156645 : if (decl_specs)
20830 : 156645 : cp_parser_set_decl_spec_type (decl_specs, type,
20831 : : token,
20832 : : /*type_definition_p=*/false);
20833 : :
20834 : 156645 : return type;
20835 : : }
20836 : :
20837 : : break;
20838 : : }
20839 : :
20840 : : /* If token is an already-parsed decltype not followed by ::,
20841 : : it's a simple-type-specifier. */
20842 : 2788729670 : if (token->type == CPP_DECLTYPE
20843 : 2788729670 : && cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
20844 : : {
20845 : 2979058 : type = saved_checks_value (token->u.tree_check_value);
20846 : 2979058 : if (decl_specs)
20847 : : {
20848 : 2968194 : cp_parser_set_decl_spec_type (decl_specs, type,
20849 : : token,
20850 : : /*type_definition_p=*/false);
20851 : : /* Remember that we are handling a decltype in order to
20852 : : implement the resolution of DR 1510 when the argument
20853 : : isn't instantiation dependent. */
20854 : 2968194 : decl_specs->decltype_p = true;
20855 : : }
20856 : 2979058 : cp_lexer_consume_token (parser->lexer);
20857 : 2979058 : return type;
20858 : : }
20859 : :
20860 : : /* If the type-specifier was for a built-in type, we're done. */
20861 : 2785750612 : if (type)
20862 : : {
20863 : : /* Record the type. */
20864 : 223694566 : if (decl_specs
20865 : 218284719 : && (token->keyword != RID_SIGNED
20866 : : && token->keyword != RID_UNSIGNED
20867 : : && token->keyword != RID_SHORT
20868 : : && token->keyword != RID_LONG))
20869 : 183755602 : cp_parser_set_decl_spec_type (decl_specs,
20870 : : type,
20871 : : token,
20872 : : /*type_definition_p=*/false);
20873 : 218284719 : if (decl_specs)
20874 : 218284719 : decl_specs->any_specifiers_p = true;
20875 : :
20876 : : /* Consume the token. */
20877 : 223694566 : cp_lexer_consume_token (parser->lexer);
20878 : :
20879 : 223694566 : if (type == error_mark_node)
20880 : : return error_mark_node;
20881 : :
20882 : : /* There is no valid C++ program where a non-template type is
20883 : : followed by a "<". That usually indicates that the user thought
20884 : : that the type was a template. */
20885 : 223694553 : cp_parser_check_for_invalid_template_id (parser, type, none_type,
20886 : : token->location);
20887 : :
20888 : 223694553 : return TYPE_NAME (type);
20889 : : }
20890 : :
20891 : : /* The type-specifier must be a user-defined type. */
20892 : 2562056046 : if (!(flags & CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES))
20893 : : {
20894 : 1973835275 : bool qualified_p;
20895 : 1973835275 : bool global_p;
20896 : 3947670550 : const bool typename_p = (cxx_dialect >= cxx20
20897 : 1973835275 : && (flags & CP_PARSER_FLAGS_TYPENAME_OPTIONAL));
20898 : :
20899 : : /* Don't gobble tokens or issue error messages if this is an
20900 : : optional type-specifier. */
20901 : 1973835275 : if (flags & CP_PARSER_FLAGS_OPTIONAL)
20902 : 911649888 : cp_parser_parse_tentatively (parser);
20903 : :
20904 : : /* Remember current tentative parsing state -- if we know we need
20905 : : a type, we can give better diagnostics here. */
20906 : 1973835275 : bool tent = cp_parser_parsing_tentatively (parser);
20907 : :
20908 : 1973835275 : token = cp_lexer_peek_token (parser->lexer);
20909 : :
20910 : : /* Look for the optional `::' operator. */
20911 : 1973835275 : global_p
20912 : 1973835275 : = (cp_parser_global_scope_opt (parser,
20913 : : /*current_scope_valid_p=*/false)
20914 : : != NULL_TREE);
20915 : : /* Look for the nested-name specifier. */
20916 : 1973835275 : qualified_p
20917 : 1973835275 : = (cp_parser_nested_name_specifier_opt (parser,
20918 : : /*typename_keyword_p=*/false,
20919 : : /*check_dependency_p=*/true,
20920 : : /*type_p=*/false,
20921 : : /*is_declaration=*/false)
20922 : : != NULL_TREE);
20923 : : /* If we have seen a nested-name-specifier, and the next token
20924 : : is `template', then we are using the template-id production. */
20925 : 1973835272 : if (parser->scope
20926 : 1973835272 : && cp_parser_optional_template_keyword (parser))
20927 : : {
20928 : : /* Look for the template-id. */
20929 : 354596 : type = cp_parser_template_id (parser,
20930 : : /*template_keyword_p=*/true,
20931 : : /*check_dependency_p=*/true,
20932 : : none_type,
20933 : : /*is_declaration=*/false);
20934 : : /* If the template-id did not name a type, we are out of
20935 : : luck. */
20936 : 354596 : if (TREE_CODE (type) != TYPE_DECL)
20937 : : {
20938 : : /* ...unless we pretend we have seen 'typename'. */
20939 : 354562 : if (typename_p)
20940 : 24 : type = cp_parser_make_typename_type (parser, type,
20941 : : token->location);
20942 : : else
20943 : : {
20944 : 354538 : cp_parser_error (parser, "expected template-id for type");
20945 : 354538 : type = error_mark_node;
20946 : : }
20947 : : }
20948 : : }
20949 : : /* DR 1812: A < following a qualified-id in a typename-specifier
20950 : : could safely be assumed to begin a template argument list, so
20951 : : the template keyword should be optional. */
20952 : 1973480676 : else if (parser->scope
20953 : : && qualified_p
20954 : 136955881 : && typename_p
20955 : 1978018420 : && cp_lexer_next_token_is (parser->lexer, CPP_TEMPLATE_ID))
20956 : : {
20957 : 2407201 : cp_parser_parse_tentatively (parser);
20958 : :
20959 : 2407201 : type = cp_parser_template_id (parser,
20960 : : /*template_keyword_p=*/true,
20961 : : /*check_dependency_p=*/true,
20962 : : none_type,
20963 : : /*is_declaration=*/false);
20964 : : /* This is handled below, so back off. */
20965 : 2407201 : if (type && concept_check_p (type))
20966 : 2535269 : cp_parser_simulate_error (parser);
20967 : :
20968 : 2407201 : if (!cp_parser_parse_definitely (parser))
20969 : : type = NULL_TREE;
20970 : 2279133 : else if (TREE_CODE (type) == TEMPLATE_ID_EXPR)
20971 : 0 : type = make_typename_type (parser->scope, type, typename_type,
20972 : : /*complain=*/tf_error);
20973 : 2279133 : else if (TREE_CODE (type) != TYPE_DECL)
20974 : : type = NULL_TREE;
20975 : : }
20976 : :
20977 : : /* Otherwise, look for a type-name. */
20978 : 1971428037 : if (!type)
20979 : : {
20980 : 1971201554 : if (cxx_dialect >= cxx17 || flag_concepts)
20981 : 1940198117 : cp_parser_parse_tentatively (parser);
20982 : :
20983 : 1971201554 : type = cp_parser_type_name (parser, (qualified_p && typename_p));
20984 : :
20985 : 31003998 : if ((cxx_dialect >= cxx17 || flag_concepts)
20986 : 1971202115 : && !cp_parser_parse_definitely (parser))
20987 : : type = NULL_TREE;
20988 : : }
20989 : :
20990 : : /* "T...[constant-expression]" is a C++26 pack-index-specifier. */
20991 : 656033798 : if (type
20992 : 658667516 : && type != error_mark_node
20993 : 1294427809 : && cp_parser_next_tokens_are_pack_index_p (parser))
20994 : 58 : type = cp_parser_pack_index (parser, type);
20995 : :
20996 : 1973835272 : if (!type && flag_concepts && decl_specs)
20997 : : {
20998 : : /* Try for a type-constraint with template arguments. We check
20999 : : decl_specs here to avoid trying this for a functional cast. */
21000 : :
21001 : 148304349 : cp_parser_parse_tentatively (parser);
21002 : :
21003 : 148304349 : type = cp_parser_template_id (parser,
21004 : : /*template_keyword_p=*/false,
21005 : : /*check_dependency_p=*/true,
21006 : : none_type,
21007 : : /*is_declaration=*/false);
21008 : 148304349 : if (type && concept_check_p (type))
21009 : : {
21010 : 1560507 : location_t loc = EXPR_LOCATION (type);
21011 : 1560507 : type = cp_parser_placeholder_type_specifier (parser, loc,
21012 : : type, tent);
21013 : 1560507 : if (tent && type == error_mark_node)
21014 : : /* Perhaps it's a concept-check expression. */
21015 : 148907335 : cp_parser_simulate_error (parser);
21016 : : }
21017 : : else
21018 : 295048191 : cp_parser_simulate_error (parser);
21019 : :
21020 : 148304349 : if (!cp_parser_parse_definitely (parser))
21021 : : type = NULL_TREE;
21022 : : }
21023 : :
21024 : 1315167756 : if (!type && cxx_dialect >= cxx17)
21025 : : {
21026 : : /* Try class template argument deduction or type-constraint without
21027 : : template arguments. */
21028 : 1314209760 : tree name = cp_parser_identifier (parser);
21029 : 1314209760 : if (name && TREE_CODE (name) == IDENTIFIER_NODE
21030 : 712489479 : && parser->scope != error_mark_node)
21031 : : {
21032 : 712489479 : location_t loc
21033 : 712489479 : = cp_lexer_previous_token (parser->lexer)->location;
21034 : 712489479 : tree tmpl = cp_parser_lookup_name (parser, name,
21035 : : none_type,
21036 : : /*is_template=*/false,
21037 : : /*is_namespace=*/false,
21038 : : /*check_dependency=*/true,
21039 : : /*ambiguous_decls=*/NULL,
21040 : : token->location);
21041 : 712489479 : if (tmpl && tmpl != error_mark_node
21042 : 1421801929 : && ctad_template_p (tmpl))
21043 : 7550513 : type = make_template_placeholder (tmpl);
21044 : 903956130 : else if (flag_concepts && tmpl && concept_definition_p (tmpl))
21045 : 1402103 : type = cp_parser_placeholder_type_specifier (parser, loc,
21046 : : tmpl, tent);
21047 : : else
21048 : : {
21049 : 703536863 : type = error_mark_node;
21050 : 703536756 : if (!cp_parser_simulate_error (parser))
21051 : 107 : cp_parser_name_lookup_error (parser, name, tmpl,
21052 : : NLE_TYPE, token->location);
21053 : : }
21054 : : }
21055 : : else
21056 : 601720281 : type = error_mark_node;
21057 : : }
21058 : :
21059 : : /* If it didn't work out, we don't have a TYPE. */
21060 : 1973835272 : if (flags & CP_PARSER_FLAGS_OPTIONAL)
21061 : : {
21062 : 911649885 : if (!type)
21063 : 911649969 : cp_parser_simulate_error (parser);
21064 : 911649885 : if (!cp_parser_parse_definitely (parser))
21065 : 1973835272 : type = NULL_TREE;
21066 : : }
21067 : :
21068 : : /* Keep track of all name-lookups performed in class scopes. */
21069 : 1973835272 : if (type
21070 : 1973835272 : && !global_p
21071 : 1520394905 : && !qualified_p
21072 : 1400467733 : && TREE_CODE (type) == TYPE_DECL
21073 : 2588405494 : && identifier_p (DECL_NAME (type)))
21074 : 614570222 : maybe_note_name_used_in_class (DECL_NAME (type), type);
21075 : :
21076 : 1973835272 : if (type && decl_specs)
21077 : 666632237 : cp_parser_set_decl_spec_type (decl_specs, type,
21078 : : token,
21079 : : /*type_definition_p=*/false);
21080 : : }
21081 : :
21082 : : /* If we didn't get a type-name, issue an error message. */
21083 : 2562056043 : if (!type && !(flags & CP_PARSER_FLAGS_OPTIONAL))
21084 : : {
21085 : 391 : cp_parser_error (parser, "expected type-name");
21086 : 391 : return error_mark_node;
21087 : : }
21088 : :
21089 : 1521411774 : if (type && type != error_mark_node)
21090 : : {
21091 : : /* See if TYPE is an Objective-C type, and if so, parse and
21092 : : accept any protocol references following it. Do this before
21093 : : the cp_parser_check_for_invalid_template_id() call, because
21094 : : Objective-C types can be followed by '<...>' which would
21095 : : enclose protocol names rather than template arguments, and so
21096 : : everything is fine. */
21097 : 0 : if (c_dialect_objc () && !parser->scope
21098 : 648304072 : && (objc_is_id (type) || objc_is_class_name (type)))
21099 : : {
21100 : 0 : tree protos = cp_parser_objc_protocol_refs_opt (parser);
21101 : 0 : tree qual_type = objc_get_protocol_qualified_type (type, protos);
21102 : :
21103 : : /* Clobber the "unqualified" type previously entered into
21104 : : DECL_SPECS with the new, improved protocol-qualified version. */
21105 : 0 : if (decl_specs)
21106 : 0 : decl_specs->type = qual_type;
21107 : :
21108 : 0 : return qual_type;
21109 : : }
21110 : :
21111 : : /* There is no valid C++ program where a non-template type is
21112 : : followed by a "<". That usually indicates that the user
21113 : : thought that the type was a template. */
21114 : 648304072 : cp_parser_check_for_invalid_template_id (parser, type,
21115 : : none_type,
21116 : : token->location);
21117 : : }
21118 : :
21119 : : return type;
21120 : : }
21121 : :
21122 : : /* Parse the remainder of a placholder-type-specifier.
21123 : :
21124 : : placeholder-type-specifier:
21125 : : type-constraint_opt auto
21126 : : type-constraint_opt decltype(auto)
21127 : :
21128 : : The raw form of the constraint is parsed in cp_parser_simple_type_specifier
21129 : : and passed as TMPL. This function converts TMPL to an actual type-constraint,
21130 : : parses the placeholder type, and performs some contextual syntactic analysis.
21131 : :
21132 : : LOC provides the location of the template name.
21133 : :
21134 : : TENTATIVE is true if the type-specifier parsing is tentative; in that case,
21135 : : don't give an error if TMPL isn't a valid type-constraint, as the template-id
21136 : : might actually be a concept-check. */
21137 : :
21138 : : static tree
21139 : 2962610 : cp_parser_placeholder_type_specifier (cp_parser *parser, location_t loc,
21140 : : tree tmpl, bool tentative)
21141 : : {
21142 : 2962610 : if (tmpl == error_mark_node)
21143 : : return error_mark_node;
21144 : :
21145 : 2962610 : tree orig_tmpl = tmpl;
21146 : :
21147 : : /* Get the arguments as written for subsequent analysis. */
21148 : 2962610 : tree args = NULL_TREE;
21149 : 2962610 : if (TREE_CODE (tmpl) == TEMPLATE_ID_EXPR)
21150 : : {
21151 : 1560507 : args = TREE_OPERAND (tmpl, 1);
21152 : 1560507 : tmpl = TREE_OPERAND (tmpl, 0);
21153 : : }
21154 : : else
21155 : : /* A concept-name with no arguments can't be an expression. */
21156 : : tentative = false;
21157 : :
21158 : 2962610 : tree con = DECL_TEMPLATE_RESULT (tmpl);
21159 : 2962610 : tree proto = concept_prototype_parameter (con);
21160 : 2962610 : tsubst_flags_t complain = tentative ? tf_none : tf_warning_or_error;
21161 : :
21162 : : /* A type constraint constrains a contextually determined type or type
21163 : : parameter pack. */
21164 : 2962610 : if (TREE_CODE (proto) != TYPE_DECL)
21165 : : {
21166 : 10256 : if (!tentative)
21167 : : {
21168 : 53 : auto_diagnostic_group d;
21169 : 53 : error_at (loc, "%qE does not constrain a type", DECL_NAME (con));
21170 : 53 : inform (DECL_SOURCE_LOCATION (con), "concept defined here");
21171 : 53 : }
21172 : 10256 : return error_mark_node;
21173 : : }
21174 : :
21175 : : /* Get the concept and prototype parameter for the constraint. */
21176 : 2952354 : tree check = build_type_constraint (tmpl, args, complain);
21177 : 2952354 : if (check == error_mark_node)
21178 : : return error_mark_node;
21179 : :
21180 : : /* As per the standard, require auto or decltype(auto). */
21181 : 2377091 : cp_token *placeholder = NULL, *close_paren = NULL;
21182 : 2377091 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
21183 : 11196 : placeholder = cp_lexer_consume_token (parser->lexer);
21184 : 2365895 : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DECLTYPE))
21185 : : {
21186 : 64 : placeholder = cp_lexer_consume_token (parser->lexer);
21187 : 64 : matching_parens parens;
21188 : 64 : parens.require_open (parser);
21189 : 64 : cp_parser_require_keyword (parser, RID_AUTO, RT_AUTO);
21190 : 64 : close_paren = parens.require_close (parser);
21191 : : }
21192 : :
21193 : : /* In a template parameter list, a type-parameter can be introduced
21194 : : by type-constraints alone. */
21195 : 2377091 : if (processing_template_parmlist && !placeholder)
21196 : : {
21197 : : /* In a default argument we may not be creating new parameters. */
21198 : 2014935 : if (parser->local_variables_forbidden_p & LOCAL_VARS_FORBIDDEN)
21199 : : {
21200 : 4 : if (!tentative)
21201 : 3 : error_at (loc, "invalid use of concept-name %qD", con);
21202 : 4 : return error_mark_node;
21203 : : }
21204 : 2014931 : return build_constrained_parameter (con, proto, args);
21205 : : }
21206 : :
21207 : : /* Diagnose issues placeholder issues. */
21208 : 362156 : if (!parser->in_result_type_constraint_p && !placeholder)
21209 : : {
21210 : 17546 : if (tentative)
21211 : : /* Perhaps it's a concept-check expression (c++/91073). */
21212 : 17525 : return error_mark_node;
21213 : :
21214 : 21 : tree id = build_nt (TEMPLATE_ID_EXPR, tmpl, args);
21215 : 21 : tree expr = DECL_P (orig_tmpl) ? DECL_NAME (con) : id;
21216 : 21 : error_at (input_location,
21217 : : "expected %<auto%> or %<decltype(auto)%> after %qE", expr);
21218 : : /* Fall through. This is an error of omission. */
21219 : 21 : }
21220 : 344610 : else if (parser->in_result_type_constraint_p && placeholder)
21221 : : {
21222 : : /* A trailing return type only allows type-constraints. */
21223 : 0 : error_at (input_location,
21224 : : "unexpected placeholder in constrained result type");
21225 : : }
21226 : :
21227 : : /* In a parameter-declaration-clause, a placeholder-type-specifier
21228 : : results in an invented template parameter. */
21229 : 344631 : if (parser->auto_is_implicit_function_template_parm_p)
21230 : : {
21231 : 5681 : if (close_paren)
21232 : : {
21233 : 3 : location_t loc = make_location (placeholder->location,
21234 : : placeholder->location,
21235 : : close_paren->location);
21236 : 3 : error_at (loc, "cannot declare a parameter with %<decltype(auto)%>");
21237 : 3 : return error_mark_node;
21238 : : }
21239 : 5678 : tree parm = build_constrained_parameter (con, proto, args);
21240 : 5678 : return synthesize_implicit_template_parm (parser, parm);
21241 : : }
21242 : :
21243 : : /* Determine if the type should be deduced using template argument
21244 : : deduction or decltype deduction. Note that the latter is always
21245 : : used for type-constraints in trailing return types. */
21246 : 677900 : bool decltype_p = placeholder
21247 : 338950 : ? placeholder->keyword == RID_DECLTYPE
21248 : 333370 : : parser->in_result_type_constraint_p;
21249 : :
21250 : : /* Otherwise, this is the type of a variable or return type. */
21251 : 338950 : if (decltype_p)
21252 : 333411 : return make_constrained_decltype_auto (con, args);
21253 : : else
21254 : 5539 : return make_constrained_auto (con, args);
21255 : : }
21256 : :
21257 : : /* Parse a type-name.
21258 : :
21259 : : type-name:
21260 : : class-name
21261 : : enum-name
21262 : : typedef-name
21263 : : simple-template-id [in c++0x]
21264 : :
21265 : : enum-name:
21266 : : identifier
21267 : :
21268 : : typedef-name:
21269 : : identifier
21270 : :
21271 : : Concepts:
21272 : :
21273 : : type-name:
21274 : : concept-name
21275 : : partial-concept-id
21276 : :
21277 : : concept-name:
21278 : : identifier
21279 : :
21280 : : Returns a TYPE_DECL for the type. */
21281 : :
21282 : : static tree
21283 : 1971359916 : cp_parser_type_name (cp_parser* parser, bool typename_keyword_p)
21284 : : {
21285 : 1971359916 : tree type_decl;
21286 : :
21287 : : /* We can't know yet whether it is a class-name or not. */
21288 : 1971359916 : cp_parser_parse_tentatively (parser);
21289 : : /* Try a class-name. */
21290 : 1971359916 : type_decl = cp_parser_class_name (parser,
21291 : : typename_keyword_p,
21292 : : /*template_keyword_p=*/false,
21293 : : none_type,
21294 : : /*check_dependency_p=*/true,
21295 : : /*class_head_p=*/false,
21296 : : /*is_declaration=*/false);
21297 : : /* If it's not a class-name, keep looking. */
21298 : 1971359916 : if (!cp_parser_parse_definitely (parser))
21299 : : {
21300 : 1414701543 : if (cxx_dialect < cxx11)
21301 : : /* It must be a typedef-name or an enum-name. */
21302 : 7304483 : return cp_parser_nonclass_name (parser);
21303 : :
21304 : 1407397060 : cp_parser_parse_tentatively (parser);
21305 : : /* It is either a simple-template-id representing an
21306 : : instantiation of an alias template... */
21307 : 1407397060 : type_decl = cp_parser_template_id (parser,
21308 : : /*template_keyword_p=*/false,
21309 : : /*check_dependency_p=*/true,
21310 : : none_type,
21311 : : /*is_declaration=*/false);
21312 : : /* Note that this must be an instantiation of an alias template
21313 : : because [temp.names]/6 says:
21314 : :
21315 : : A template-id that names an alias template specialization
21316 : : is a type-name.
21317 : :
21318 : : Whereas [temp.names]/7 says:
21319 : :
21320 : : A simple-template-id that names a class template
21321 : : specialization is a class-name.
21322 : :
21323 : : With concepts, this could also be a partial-concept-id that
21324 : : declares a non-type template parameter. */
21325 : 1407397060 : if (type_decl != NULL_TREE
21326 : 1407397060 : && TREE_CODE (type_decl) == TYPE_DECL
21327 : 1408036416 : && TYPE_DECL_ALIAS_P (type_decl))
21328 : 639356 : gcc_assert (DECL_TEMPLATE_INSTANTIATION (type_decl));
21329 : : else
21330 : 2814154764 : cp_parser_simulate_error (parser);
21331 : :
21332 : 1407397060 : if (!cp_parser_parse_definitely (parser))
21333 : : /* ... Or a typedef-name or an enum-name. */
21334 : 1406757704 : return cp_parser_nonclass_name (parser);
21335 : : }
21336 : :
21337 : : return type_decl;
21338 : : }
21339 : :
21340 : : /* Parse a non-class type-name, that is, either an enum-name, a typedef-name,
21341 : : or a concept-name.
21342 : :
21343 : : enum-name:
21344 : : identifier
21345 : :
21346 : : typedef-name:
21347 : : identifier
21348 : :
21349 : : concept-name:
21350 : : identifier
21351 : :
21352 : : Returns a TYPE_DECL for the type. */
21353 : :
21354 : : static tree
21355 : 1414357313 : cp_parser_nonclass_name (cp_parser* parser)
21356 : : {
21357 : 1414357313 : tree type_decl;
21358 : 1414357313 : tree identifier;
21359 : :
21360 : 1414357313 : cp_token *token = cp_lexer_peek_token (parser->lexer);
21361 : 1414357313 : identifier = cp_parser_identifier (parser);
21362 : 1414357313 : if (identifier == error_mark_node)
21363 : : return error_mark_node;
21364 : :
21365 : : /* Look up the type-name. */
21366 : 802022608 : type_decl = cp_parser_lookup_name_simple (parser, identifier, token->location);
21367 : :
21368 : 802022608 : if (TREE_CODE (type_decl) != TYPE_DECL
21369 : 802022608 : && (objc_is_id (identifier) || objc_is_class_name (identifier)))
21370 : : {
21371 : : /* See if this is an Objective-C type. */
21372 : 0 : tree protos = cp_parser_objc_protocol_refs_opt (parser);
21373 : 0 : tree type = objc_get_protocol_qualified_type (identifier, protos);
21374 : 0 : if (type)
21375 : 0 : type_decl = TYPE_NAME (type);
21376 : : }
21377 : :
21378 : : /* Issue an error if we did not find a type-name. */
21379 : 802022608 : if (TREE_CODE (type_decl) != TYPE_DECL
21380 : : /* In Objective-C, we have the complication that class names are
21381 : : normally type names and start declarations (eg, the
21382 : : "NSObject" in "NSObject *object;"), but can be used in an
21383 : : Objective-C 2.0 dot-syntax (as in "NSObject.version") which
21384 : : is an expression. So, a classname followed by a dot is not a
21385 : : valid type-name. */
21386 : 802022608 : || (objc_is_class_name (TREE_TYPE (type_decl))
21387 : 0 : && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT))
21388 : : {
21389 : 722750738 : if (!cp_parser_simulate_error (parser))
21390 : 49 : cp_parser_name_lookup_error (parser, identifier, type_decl,
21391 : : NLE_TYPE, token->location);
21392 : 722750787 : return error_mark_node;
21393 : : }
21394 : : /* Remember that the name was used in the definition of the
21395 : : current class so that we can check later to see if the
21396 : : meaning would have been different after the class was
21397 : : entirely defined. */
21398 : 79271821 : else if (type_decl != error_mark_node
21399 : 79271821 : && !parser->scope)
21400 : 73560156 : maybe_note_name_used_in_class (identifier, type_decl);
21401 : :
21402 : : return type_decl;
21403 : : }
21404 : :
21405 : : /* Parse an elaborated-type-specifier. Note that the grammar given
21406 : : here incorporates the resolution to DR68.
21407 : :
21408 : : elaborated-type-specifier:
21409 : : class-key :: [opt] nested-name-specifier [opt] identifier
21410 : : class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
21411 : : enum-key :: [opt] nested-name-specifier [opt] identifier
21412 : : typename :: [opt] nested-name-specifier identifier
21413 : : typename :: [opt] nested-name-specifier template [opt]
21414 : : template-id
21415 : :
21416 : : GNU extension:
21417 : :
21418 : : elaborated-type-specifier:
21419 : : class-key attributes :: [opt] nested-name-specifier [opt] identifier
21420 : : class-key attributes :: [opt] nested-name-specifier [opt]
21421 : : template [opt] template-id
21422 : : enum attributes :: [opt] nested-name-specifier [opt] identifier
21423 : :
21424 : : If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
21425 : : declared `friend'. If IS_DECLARATION is TRUE, then this
21426 : : elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
21427 : : something is being declared.
21428 : :
21429 : : Returns the TYPE specified. */
21430 : :
21431 : : static tree
21432 : 39279636 : cp_parser_elaborated_type_specifier (cp_parser* parser,
21433 : : bool is_friend,
21434 : : bool is_declaration)
21435 : : {
21436 : 39279636 : enum tag_types tag_type;
21437 : 39279636 : tree identifier;
21438 : 39279636 : tree type = NULL_TREE;
21439 : 39279636 : tree attributes = NULL_TREE;
21440 : 39279636 : tree globalscope;
21441 : 39279636 : cp_token *token = NULL;
21442 : :
21443 : : /* For class and enum types the location of the class-key or enum-key. */
21444 : 39279636 : location_t key_loc = cp_lexer_peek_token (parser->lexer)->location;
21445 : : /* For a scoped enum, the 'class' or 'struct' keyword id. */
21446 : 39279636 : rid scoped_key = RID_MAX;
21447 : :
21448 : : /* See if we're looking at the `enum' keyword. */
21449 : 39279636 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM))
21450 : : {
21451 : : /* Consume the `enum' token. */
21452 : 26143 : cp_lexer_consume_token (parser->lexer);
21453 : : /* Remember that it's an enumeration type. */
21454 : 26143 : tag_type = enum_type;
21455 : : /* Issue a warning if the `struct' or `class' key (for C++0x scoped
21456 : : enums) is used here. */
21457 : 26143 : cp_token *token = cp_lexer_peek_token (parser->lexer);
21458 : 26143 : if (cp_parser_is_keyword (token, scoped_key = RID_CLASS)
21459 : 26143 : || cp_parser_is_keyword (token, scoped_key = RID_STRUCT))
21460 : : {
21461 : 58 : location_t loc = token->location;
21462 : 58 : gcc_rich_location richloc (loc);
21463 : 58 : richloc.add_range (input_location);
21464 : 58 : richloc.add_fixit_remove ();
21465 : 58 : pedwarn (&richloc, 0, "elaborated-type-specifier for "
21466 : : "a scoped enum must not use the %qD keyword",
21467 : : token->u.value);
21468 : : /* Consume the `struct' or `class' and parse it anyway. */
21469 : 58 : cp_lexer_consume_token (parser->lexer);
21470 : : /* Create a combined location for the whole scoped-enum-key. */
21471 : 58 : key_loc = make_location (key_loc, key_loc, loc);
21472 : 58 : }
21473 : : else
21474 : : scoped_key = RID_MAX;
21475 : :
21476 : : /* Parse the attributes. */
21477 : 26143 : attributes = cp_parser_attributes_opt (parser);
21478 : : }
21479 : : /* Or, it might be `typename'. */
21480 : 39253493 : else if (cp_lexer_next_token_is_keyword (parser->lexer,
21481 : : RID_TYPENAME))
21482 : : {
21483 : : /* Consume the `typename' token. */
21484 : 27189777 : cp_lexer_consume_token (parser->lexer);
21485 : : /* Remember that it's a `typename' type. */
21486 : 27189777 : tag_type = typename_type;
21487 : : }
21488 : : /* Otherwise it must be a class-key. */
21489 : : else
21490 : : {
21491 : 12063716 : key_loc = cp_lexer_peek_token (parser->lexer)->location;
21492 : 12063716 : tag_type = cp_parser_class_key (parser);
21493 : 12063716 : if (tag_type == none_type)
21494 : 0 : return error_mark_node;
21495 : : /* Parse the attributes. */
21496 : 12063716 : attributes = cp_parser_attributes_opt (parser);
21497 : : }
21498 : :
21499 : : /* Look for the `::' operator. */
21500 : 39279636 : globalscope = cp_parser_global_scope_opt (parser,
21501 : : /*current_scope_valid_p=*/false);
21502 : : /* Look for the nested-name-specifier. */
21503 : 39279636 : tree nested_name_specifier;
21504 : 39279636 : if (tag_type == typename_type && !globalscope)
21505 : : {
21506 : 27186252 : nested_name_specifier
21507 : 27186252 : = cp_parser_nested_name_specifier (parser,
21508 : : /*typename_keyword_p=*/true,
21509 : : /*check_dependency_p=*/true,
21510 : : /*type_p=*/true,
21511 : : is_declaration);
21512 : 27186252 : if (!nested_name_specifier)
21513 : 74 : return error_mark_node;
21514 : : }
21515 : : else
21516 : : /* Even though `typename' is not present, the proposed resolution
21517 : : to Core Issue 180 says that in `class A<T>::B', `B' should be
21518 : : considered a type-name, even if `A<T>' is dependent. */
21519 : 12093384 : nested_name_specifier
21520 : 12093384 : = cp_parser_nested_name_specifier_opt (parser,
21521 : : /*typename_keyword_p=*/true,
21522 : : /*check_dependency_p=*/true,
21523 : : /*type_p=*/true,
21524 : : is_declaration);
21525 : : /* For everything but enumeration types, consider a template-id.
21526 : : For an enumeration type, consider only a plain identifier. */
21527 : 39279562 : if (tag_type != enum_type)
21528 : : {
21529 : 39253419 : bool template_p = false;
21530 : 39253419 : tree decl;
21531 : :
21532 : : /* Allow the `template' keyword. */
21533 : 39253419 : template_p = cp_parser_optional_template_keyword (parser);
21534 : : /* If we didn't see `template', we don't know if there's a
21535 : : template-id or not. */
21536 : 39253419 : if (!template_p)
21537 : 39122615 : cp_parser_parse_tentatively (parser);
21538 : : /* The `template' keyword must follow a nested-name-specifier. */
21539 : 130804 : else if (!nested_name_specifier && !globalscope)
21540 : : {
21541 : 6 : cp_parser_error (parser, "%<template%> must follow a nested-"
21542 : : "name-specifier");
21543 : 6 : return error_mark_node;
21544 : : }
21545 : :
21546 : : /* Parse the template-id. */
21547 : 39253413 : token = cp_lexer_peek_token (parser->lexer);
21548 : 39253413 : decl = cp_parser_template_id (parser, template_p,
21549 : : /*check_dependency_p=*/true,
21550 : : tag_type,
21551 : : is_declaration);
21552 : : /* If we didn't find a template-id, look for an ordinary
21553 : : identifier. */
21554 : 39253413 : if (!template_p && !cp_parser_parse_definitely (parser))
21555 : : ;
21556 : : /* We can get here when cp_parser_template_id, called by
21557 : : cp_parser_class_name with tag_type == none_type, succeeds
21558 : : and caches a BASELINK. Then, when called again here,
21559 : : instead of failing and returning an error_mark_node
21560 : : returns it (see template/typename17.C in C++11).
21561 : : ??? Could we diagnose this earlier? */
21562 : 1732602 : else if (tag_type == typename_type && BASELINK_P (decl))
21563 : : {
21564 : 0 : cp_parser_diagnose_invalid_type_name (parser, decl, token->location);
21565 : 0 : type = error_mark_node;
21566 : : }
21567 : : /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
21568 : : in effect, then we must assume that, upon instantiation, the
21569 : : template will correspond to a class. */
21570 : 1732602 : else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
21571 : 130741 : && tag_type == typename_type)
21572 : 130741 : type = make_typename_type (parser->scope, decl,
21573 : : typename_type,
21574 : : /*complain=*/tf_error);
21575 : : /* If the `typename' keyword is in effect and DECL is not a type
21576 : : decl, then type is non existent. */
21577 : 1601861 : else if (tag_type == typename_type && TREE_CODE (decl) != TYPE_DECL)
21578 : : ;
21579 : 1601849 : else if (TREE_CODE (decl) == TYPE_DECL)
21580 : : {
21581 : 1601830 : type = check_elaborated_type_specifier (tag_type, decl,
21582 : : /*allow_template_p=*/true);
21583 : :
21584 : : /* If the next token is a semicolon, this must be a specialization,
21585 : : instantiation, or friend declaration. Check the scope while we
21586 : : still know whether or not we had a nested-name-specifier. */
21587 : 1601830 : if (type != error_mark_node
21588 : 1601809 : && !nested_name_specifier && !is_friend
21589 : 2659304 : && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
21590 : 1057102 : check_unqualified_spec_or_inst (type, token->location);
21591 : : }
21592 : 19 : else if (decl == error_mark_node)
21593 : 19 : type = error_mark_node;
21594 : : }
21595 : :
21596 : 39279556 : if (!type)
21597 : : {
21598 : 37546966 : token = cp_lexer_peek_token (parser->lexer);
21599 : 37546966 : identifier = cp_parser_identifier (parser);
21600 : :
21601 : 37546966 : if (identifier == error_mark_node)
21602 : : {
21603 : 73 : parser->scope = NULL_TREE;
21604 : 73 : return error_mark_node;
21605 : : }
21606 : :
21607 : : /* For a `typename', we needn't call xref_tag. */
21608 : 37546893 : if (tag_type == typename_type
21609 : 27036898 : && TREE_CODE (parser->scope) != NAMESPACE_DECL)
21610 : 27034596 : return cp_parser_make_typename_type (parser, identifier,
21611 : 27034596 : token->location);
21612 : :
21613 : : /* Template parameter lists apply only if we are not within a
21614 : : function parameter list. */
21615 : 10512297 : bool template_parm_lists_apply
21616 : 10512297 : = parser->num_template_parameter_lists;
21617 : 10512297 : if (template_parm_lists_apply)
21618 : 5391590 : for (cp_binding_level *s = current_binding_level;
21619 : 5393672 : s && s->kind != sk_template_parms;
21620 : 2082 : s = s->level_chain)
21621 : 2082 : if (s->kind == sk_function_parms)
21622 : 2070 : template_parm_lists_apply = false;
21623 : :
21624 : : /* Look up a qualified name in the usual way. */
21625 : 10512297 : if (parser->scope)
21626 : : {
21627 : 4469864 : tree decl;
21628 : 4469864 : tree ambiguous_decls;
21629 : :
21630 : 4469864 : decl = cp_parser_lookup_name (parser, identifier,
21631 : : tag_type,
21632 : : /*is_template=*/false,
21633 : : /*is_namespace=*/false,
21634 : : /*check_dependency=*/true,
21635 : : &ambiguous_decls,
21636 : : token->location);
21637 : :
21638 : : /* If the lookup was ambiguous, an error will already have been
21639 : : issued. */
21640 : 4469864 : if (ambiguous_decls)
21641 : 96 : return error_mark_node;
21642 : :
21643 : : /* If we are parsing friend declaration, DECL may be a
21644 : : TEMPLATE_DECL tree node here. However, we need to check
21645 : : whether this TEMPLATE_DECL results in valid code. Consider
21646 : : the following example:
21647 : :
21648 : : namespace N {
21649 : : template <class T> class C {};
21650 : : }
21651 : : class X {
21652 : : template <class T> friend class N::C; // #1, valid code
21653 : : };
21654 : : template <class T> class Y {
21655 : : friend class N::C; // #2, invalid code
21656 : : };
21657 : :
21658 : : For both case #1 and #2, we arrive at a TEMPLATE_DECL after
21659 : : name lookup of `N::C'. We see that friend declaration must
21660 : : be template for the code to be valid. Note that
21661 : : processing_template_decl does not work here since it is
21662 : : always 1 for the above two cases. */
21663 : :
21664 : 4469861 : decl = (cp_parser_maybe_treat_template_as_class
21665 : 8939722 : (decl, /*tag_name_p=*/is_friend
21666 : 4469861 : && template_parm_lists_apply));
21667 : :
21668 : 4469861 : if (TREE_CODE (decl) != TYPE_DECL)
21669 : : {
21670 : 69 : cp_parser_diagnose_invalid_type_name (parser,
21671 : : identifier,
21672 : : token->location);
21673 : 69 : return error_mark_node;
21674 : : }
21675 : :
21676 : 4469792 : if (TREE_CODE (TREE_TYPE (decl)) != TYPENAME_TYPE)
21677 : : {
21678 : 4468532 : bool allow_template = (template_parm_lists_apply
21679 : 4468532 : || DECL_SELF_REFERENCE_P (decl));
21680 : 4468532 : type = check_elaborated_type_specifier (tag_type, decl,
21681 : : allow_template);
21682 : :
21683 : 4468532 : if (type == error_mark_node)
21684 : : return error_mark_node;
21685 : : }
21686 : :
21687 : : /* Forward declarations of nested types, such as
21688 : :
21689 : : class C1::C2;
21690 : : class C1::C2::C3;
21691 : :
21692 : : are invalid unless all components preceding the final '::'
21693 : : are complete. If all enclosing types are complete, these
21694 : : declarations become merely pointless.
21695 : :
21696 : : Invalid forward declarations of nested types are errors
21697 : : caught elsewhere in parsing. Those that are pointless arrive
21698 : : here. */
21699 : :
21700 : 4469768 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
21701 : 215018 : && !is_friend && is_declaration
21702 : 4469802 : && !processing_explicit_instantiation)
21703 : 25 : warning (0, "declaration %qD does not declare anything", decl);
21704 : :
21705 : 4469768 : type = TREE_TYPE (decl);
21706 : : }
21707 : : else
21708 : : {
21709 : : /* An elaborated-type-specifier sometimes introduces a new type and
21710 : : sometimes names an existing type. Normally, the rule is that it
21711 : : introduces a new type only if there is not an existing type of
21712 : : the same name already in scope. For example, given:
21713 : :
21714 : : struct S {};
21715 : : void f() { struct S s; }
21716 : :
21717 : : the `struct S' in the body of `f' is the same `struct S' as in
21718 : : the global scope; the existing definition is used. However, if
21719 : : there were no global declaration, this would introduce a new
21720 : : local class named `S'.
21721 : :
21722 : : An exception to this rule applies to the following code:
21723 : :
21724 : : namespace N { struct S; }
21725 : :
21726 : : Here, the elaborated-type-specifier names a new type
21727 : : unconditionally; even if there is already an `S' in the
21728 : : containing scope this declaration names a new type.
21729 : : This exception only applies if the elaborated-type-specifier
21730 : : forms the complete declaration:
21731 : :
21732 : : [class.name]
21733 : :
21734 : : A declaration consisting solely of `class-key identifier ;' is
21735 : : either a redeclaration of the name in the current scope or a
21736 : : forward declaration of the identifier as a class name. It
21737 : : introduces the name into the current scope.
21738 : :
21739 : : We are in this situation precisely when the next token is a `;'.
21740 : :
21741 : : An exception to the exception is that a `friend' declaration does
21742 : : *not* name a new type; i.e., given:
21743 : :
21744 : : struct S { friend struct T; };
21745 : :
21746 : : `T' is not a new type in the scope of `S'.
21747 : :
21748 : : Also, `new struct S' or `sizeof (struct S)' never results in the
21749 : : definition of a new type; a new type can only be declared in a
21750 : : declaration context. */
21751 : :
21752 : 6042433 : TAG_how how;
21753 : :
21754 : 6042433 : if (is_friend)
21755 : : /* Friends have special name lookup rules. */
21756 : : how = TAG_how::HIDDEN_FRIEND;
21757 : 5303523 : else if (is_declaration
21758 : 5303523 : && cp_lexer_next_token_is (parser->lexer,
21759 : : CPP_SEMICOLON))
21760 : : /* This is a `class-key identifier ;' */
21761 : : how = TAG_how::CURRENT_ONLY;
21762 : : else
21763 : : how = TAG_how::GLOBAL;
21764 : :
21765 : 6042433 : bool template_p =
21766 : : (template_parm_lists_apply
21767 : 6042433 : && (cp_parser_next_token_starts_class_definition_p (parser)
21768 : 3103455 : || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)));
21769 : : /* An unqualified name was used to reference this type, so
21770 : : there were no qualifying templates. */
21771 : 3103461 : if (template_parm_lists_apply
21772 : 3103461 : && !cp_parser_check_template_parameters (parser,
21773 : : /*num_templates=*/0,
21774 : : /*template_id*/false,
21775 : : token->location,
21776 : : /*declarator=*/NULL))
21777 : 3 : return error_mark_node;
21778 : :
21779 : 6042430 : type = xref_tag (tag_type, identifier, how, template_p);
21780 : : }
21781 : : }
21782 : :
21783 : 12244788 : if (type == error_mark_node)
21784 : : return error_mark_node;
21785 : :
21786 : : /* Allow attributes on forward declarations of classes. */
21787 : 12244620 : if (attributes)
21788 : : {
21789 : 113 : if (TREE_CODE (type) == TYPENAME_TYPE)
21790 : 6 : warning (OPT_Wattributes,
21791 : : "attributes ignored on uninstantiated type");
21792 : 107 : else if (tag_type != enum_type
21793 : 76 : && TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM
21794 : 73 : && CLASSTYPE_TEMPLATE_INSTANTIATION (type)
21795 : 128 : && ! processing_explicit_instantiation)
21796 : 6 : warning (OPT_Wattributes,
21797 : : "attributes ignored on template instantiation");
21798 : 101 : else if (is_friend && cxx11_attribute_p (attributes))
21799 : : {
21800 : 3 : auto_diagnostic_group d;
21801 : 3 : if (warning (OPT_Wattributes, "attribute ignored"))
21802 : 3 : inform (input_location, "an attribute that appertains to a friend "
21803 : : "declaration that is not a definition is ignored");
21804 : 3 : }
21805 : 98 : else if (is_declaration && cp_parser_declares_only_class_p (parser))
21806 : 83 : cplus_decl_attributes (&type, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
21807 : : else
21808 : 15 : warning (OPT_Wattributes,
21809 : : "attributes ignored on elaborated-type-specifier that is "
21810 : : "not a forward declaration");
21811 : : }
21812 : :
21813 : 12244620 : if (tag_type == enum_type)
21814 : 26108 : cp_parser_maybe_warn_enum_key (parser, key_loc, type, scoped_key);
21815 : : else
21816 : : {
21817 : : /* Diagnose class/struct/union mismatches. IS_DECLARATION is false
21818 : : for alias definition. */
21819 : 12218512 : bool decl_class = (is_declaration
21820 : 12218512 : && cp_parser_declares_only_class_p (parser));
21821 : 12218512 : cp_parser_check_class_key (parser, key_loc, tag_type, type, false,
21822 : : decl_class);
21823 : :
21824 : : /* Indicate whether this class was declared as a `class' or as a
21825 : : `struct'. */
21826 : 12218512 : if (CLASS_TYPE_P (type) && !currently_open_class (type))
21827 : 11794514 : CLASSTYPE_DECLARED_CLASS (type) = (tag_type == class_type);
21828 : : }
21829 : :
21830 : : /* A "<" cannot follow an elaborated type specifier. If that
21831 : : happens, the user was probably trying to form a template-id. */
21832 : 12244620 : cp_parser_check_for_invalid_template_id (parser, type, tag_type,
21833 : : token->location);
21834 : :
21835 : 12244620 : return type;
21836 : : }
21837 : :
21838 : : /* Parse an enum-specifier.
21839 : :
21840 : : enum-specifier:
21841 : : enum-head { enumerator-list [opt] }
21842 : : enum-head { enumerator-list , } [C++0x]
21843 : :
21844 : : enum-head:
21845 : : enum-key identifier [opt] enum-base [opt]
21846 : : enum-key nested-name-specifier identifier enum-base [opt]
21847 : :
21848 : : enum-key:
21849 : : enum
21850 : : enum class [C++0x]
21851 : : enum struct [C++0x]
21852 : :
21853 : : enum-base: [C++0x]
21854 : : : type-specifier-seq
21855 : :
21856 : : opaque-enum-specifier:
21857 : : enum-key identifier enum-base [opt] ;
21858 : :
21859 : : GNU Extensions:
21860 : : enum-key attributes[opt] identifier [opt] enum-base [opt]
21861 : : { enumerator-list [opt] }attributes[opt]
21862 : : enum-key attributes[opt] identifier [opt] enum-base [opt]
21863 : : { enumerator-list, }attributes[opt] [C++0x]
21864 : :
21865 : : Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
21866 : : if the token stream isn't an enum-specifier after all. */
21867 : :
21868 : : static tree
21869 : 1609751 : cp_parser_enum_specifier (cp_parser* parser)
21870 : : {
21871 : 1609751 : tree identifier;
21872 : 1609751 : tree type = NULL_TREE;
21873 : 1609751 : tree prev_scope;
21874 : 1609751 : tree nested_name_specifier = NULL_TREE;
21875 : 1609751 : tree attributes;
21876 : 1609751 : bool scoped_enum_p = false;
21877 : 1609751 : bool has_underlying_type = false;
21878 : 1609751 : bool nested_being_defined = false;
21879 : 1609751 : bool new_value_list = false;
21880 : 1609751 : bool is_new_type = false;
21881 : 1609751 : bool is_unnamed = false;
21882 : 1609751 : tree underlying_type = NULL_TREE;
21883 : 1609751 : cp_token *type_start_token = NULL;
21884 : 1609751 : auto cleanup = make_temp_override (parser->colon_corrects_to_scope_p, false);
21885 : :
21886 : : /* Parse tentatively so that we can back up if we don't find a
21887 : : enum-specifier. */
21888 : 1609751 : cp_parser_parse_tentatively (parser);
21889 : :
21890 : : /* Caller guarantees that the current token is 'enum', an identifier
21891 : : possibly follows, and the token after that is an opening brace.
21892 : : If we don't have an identifier, fabricate an anonymous name for
21893 : : the enumeration being defined. */
21894 : 1609751 : cp_lexer_consume_token (parser->lexer);
21895 : :
21896 : : /* Parse the "class" or "struct", which indicates a scoped
21897 : : enumeration type in C++0x. */
21898 : 1609751 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CLASS)
21899 : 1609751 : || cp_lexer_next_token_is_keyword (parser->lexer, RID_STRUCT))
21900 : : {
21901 : 260141 : if (cxx_dialect < cxx11)
21902 : 9 : maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS);
21903 : :
21904 : : /* Consume the `struct' or `class' token. */
21905 : 260141 : cp_lexer_consume_token (parser->lexer);
21906 : :
21907 : 260141 : scoped_enum_p = true;
21908 : : }
21909 : :
21910 : 1609751 : attributes = cp_parser_attributes_opt (parser);
21911 : :
21912 : : /* Clear the qualification. */
21913 : 1609751 : parser->scope = NULL_TREE;
21914 : 1609751 : parser->qualifying_scope = NULL_TREE;
21915 : 1609751 : parser->object_scope = NULL_TREE;
21916 : :
21917 : : /* Figure out in what scope the declaration is being placed. */
21918 : 1609751 : prev_scope = current_scope ();
21919 : :
21920 : 1609751 : type_start_token = cp_lexer_peek_token (parser->lexer);
21921 : :
21922 : 1609751 : push_deferring_access_checks (dk_no_check);
21923 : 1609751 : nested_name_specifier
21924 : 1609751 : = cp_parser_nested_name_specifier_opt (parser,
21925 : : /*typename_keyword_p=*/true,
21926 : : /*check_dependency_p=*/false,
21927 : : /*type_p=*/false,
21928 : : /*is_declaration=*/false);
21929 : :
21930 : 1609751 : if (nested_name_specifier)
21931 : : {
21932 : 292 : tree name;
21933 : :
21934 : 292 : identifier = cp_parser_identifier (parser);
21935 : 292 : name = cp_parser_lookup_name (parser, identifier,
21936 : : enum_type,
21937 : : /*is_template=*/false,
21938 : : /*is_namespace=*/false,
21939 : : /*check_dependency=*/true,
21940 : : /*ambiguous_decls=*/NULL,
21941 : : input_location);
21942 : 292 : if (name && name != error_mark_node)
21943 : : {
21944 : 271 : type = TREE_TYPE (name);
21945 : 271 : if (TREE_CODE (type) == TYPENAME_TYPE)
21946 : : {
21947 : : /* Are template enums allowed in ISO? */
21948 : 63 : if (template_parm_scope_p ())
21949 : 21 : pedwarn (type_start_token->location, OPT_Wpedantic,
21950 : : "%qD is an enumeration template", name);
21951 : : /* ignore a typename reference, for it will be solved by name
21952 : : in start_enum. */
21953 : 63 : type = NULL_TREE;
21954 : : }
21955 : : }
21956 : 21 : else if (nested_name_specifier == error_mark_node)
21957 : : /* We already issued an error. */;
21958 : : else
21959 : : {
21960 : 18 : error_at (type_start_token->location,
21961 : : "%qD does not name an enumeration in %qT",
21962 : : identifier, nested_name_specifier);
21963 : 18 : nested_name_specifier = error_mark_node;
21964 : : }
21965 : : }
21966 : : else
21967 : : {
21968 : 1609459 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
21969 : 570071 : identifier = cp_parser_identifier (parser);
21970 : : else
21971 : : {
21972 : 1039388 : identifier = make_anon_name ();
21973 : 1039388 : is_unnamed = true;
21974 : 1039388 : if (scoped_enum_p)
21975 : 6 : error_at (type_start_token->location,
21976 : : "unnamed scoped enum is not allowed");
21977 : : }
21978 : : }
21979 : 1609751 : pop_deferring_access_checks ();
21980 : :
21981 : : /* Check for the `:' that denotes a specified underlying type in C++0x.
21982 : : Note that a ':' could also indicate a bitfield width, however. */
21983 : 1609751 : location_t colon_loc = UNKNOWN_LOCATION;
21984 : 1609751 : if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
21985 : : {
21986 : 217807 : cp_decl_specifier_seq type_specifiers;
21987 : :
21988 : : /* Consume the `:'. */
21989 : 217807 : colon_loc = cp_lexer_peek_token (parser->lexer)->location;
21990 : 217807 : cp_lexer_consume_token (parser->lexer);
21991 : :
21992 : 217807 : auto tdf
21993 : 217807 : = make_temp_override (parser->type_definition_forbidden_message,
21994 : 217807 : G_("types may not be defined in enum-base"));
21995 : :
21996 : : /* Parse the type-specifier-seq. */
21997 : 217807 : cp_parser_type_specifier_seq (parser, CP_PARSER_FLAGS_NONE,
21998 : : /*is_declaration=*/false,
21999 : : /*is_trailing_return=*/false,
22000 : : &type_specifiers);
22001 : :
22002 : : /* At this point this is surely not elaborated type specifier. */
22003 : 217807 : if (!cp_parser_parse_definitely (parser))
22004 : 15 : return NULL_TREE;
22005 : :
22006 : 217792 : if (cxx_dialect < cxx11)
22007 : 6 : maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS);
22008 : :
22009 : 217792 : has_underlying_type = true;
22010 : :
22011 : : /* If that didn't work, stop. */
22012 : 217792 : if (type_specifiers.type != error_mark_node)
22013 : : {
22014 : 217792 : underlying_type = grokdeclarator (NULL, &type_specifiers, TYPENAME,
22015 : : /*initialized=*/0, NULL);
22016 : 217792 : if (underlying_type == error_mark_node
22017 : 217792 : || check_for_bare_parameter_packs (underlying_type))
22018 : : underlying_type = NULL_TREE;
22019 : : }
22020 : 217807 : }
22021 : :
22022 : : /* Look for the `{' but don't consume it yet. */
22023 : 1609736 : if (!cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
22024 : : {
22025 : 49577 : if (cxx_dialect < cxx11 || (!scoped_enum_p && !underlying_type))
22026 : : {
22027 : 26076 : if (has_underlying_type)
22028 : 2 : cp_parser_commit_to_tentative_parse (parser);
22029 : 26076 : cp_parser_error (parser, "expected %<{%>");
22030 : 26076 : if (has_underlying_type)
22031 : 2 : return error_mark_node;
22032 : : }
22033 : : /* An opaque-enum-specifier must have a ';' here. */
22034 : 49575 : if ((scoped_enum_p || underlying_type)
22035 : 49575 : && cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
22036 : : {
22037 : 73 : if (has_underlying_type)
22038 : 22 : pedwarn (colon_loc,
22039 : : OPT_Welaborated_enum_base,
22040 : : "declaration of enumeration with "
22041 : : "fixed underlying type and no enumerator list is "
22042 : : "only permitted as a standalone declaration");
22043 : : else
22044 : 51 : cp_parser_error (parser, "expected %<;%> or %<{%>");
22045 : : }
22046 : : }
22047 : :
22048 : 1609734 : if (!has_underlying_type && !cp_parser_parse_definitely (parser))
22049 : : return NULL_TREE;
22050 : :
22051 : 1583609 : if (nested_name_specifier)
22052 : : {
22053 : 187 : if (CLASS_TYPE_P (nested_name_specifier))
22054 : : {
22055 : 127 : nested_being_defined = TYPE_BEING_DEFINED (nested_name_specifier);
22056 : 127 : TYPE_BEING_DEFINED (nested_name_specifier) = 1;
22057 : 127 : push_scope (nested_name_specifier);
22058 : : }
22059 : 60 : else if (TREE_CODE (nested_name_specifier) == NAMESPACE_DECL)
22060 : 39 : push_nested_namespace (nested_name_specifier);
22061 : : }
22062 : :
22063 : : /* Issue an error message if type-definitions are forbidden here. */
22064 : 1583609 : if (!cp_parser_check_type_definition (parser))
22065 : 21 : type = error_mark_node;
22066 : : else
22067 : : /* Create the new type. We do this before consuming the opening
22068 : : brace so the enum will be recorded as being on the line of its
22069 : : tag (or the 'enum' keyword, if there is no tag). */
22070 : 1583588 : type = start_enum (identifier, type, underlying_type,
22071 : : attributes, scoped_enum_p, &is_new_type);
22072 : :
22073 : : /* If the next token is not '{' it is an opaque-enum-specifier or an
22074 : : elaborated-type-specifier. */
22075 : 1583609 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
22076 : : {
22077 : 1560159 : auto_timevar tv (TV_PARSE_ENUM);
22078 : :
22079 : 1560159 : if (nested_name_specifier
22080 : 181 : && nested_name_specifier != error_mark_node)
22081 : : {
22082 : : /* The following catches invalid code such as:
22083 : : enum class S<int>::E { A, B, C }; */
22084 : 163 : if (!processing_specialization
22085 : 154 : && CLASS_TYPE_P (nested_name_specifier)
22086 : 278 : && CLASSTYPE_USE_TEMPLATE (nested_name_specifier))
22087 : 0 : error_at (type_start_token->location, "cannot add an enumerator "
22088 : : "list to a template instantiation");
22089 : :
22090 : 163 : if (TREE_CODE (nested_name_specifier) == TYPENAME_TYPE)
22091 : : {
22092 : 0 : error_at (type_start_token->location,
22093 : : "%<%T::%E%> has not been declared",
22094 : 0 : TYPE_CONTEXT (nested_name_specifier),
22095 : : nested_name_specifier);
22096 : 0 : type = error_mark_node;
22097 : : }
22098 : 163 : else if (TREE_CODE (nested_name_specifier) != NAMESPACE_DECL
22099 : 163 : && !CLASS_TYPE_P (nested_name_specifier))
22100 : : {
22101 : 3 : error_at (type_start_token->location, "nested name specifier "
22102 : : "%qT for enum declaration does not name a class "
22103 : : "or namespace", nested_name_specifier);
22104 : 3 : type = error_mark_node;
22105 : : }
22106 : : /* If that scope does not contain the scope in which the
22107 : : class was originally declared, the program is invalid. */
22108 : 160 : else if (prev_scope && !is_ancestor (prev_scope,
22109 : : nested_name_specifier))
22110 : : {
22111 : 12 : if (at_namespace_scope_p ())
22112 : 6 : error_at (type_start_token->location,
22113 : : "declaration of %qD in namespace %qD which does not "
22114 : : "enclose %qD",
22115 : : type, prev_scope, nested_name_specifier);
22116 : : else
22117 : 6 : error_at (type_start_token->location,
22118 : : "declaration of %qD in %qD which does not "
22119 : : "enclose %qD",
22120 : : type, prev_scope, nested_name_specifier);
22121 : 12 : type = error_mark_node;
22122 : : }
22123 : : /* If that scope is the scope where the declaration is being placed
22124 : : the program is invalid. */
22125 : 118 : else if (CLASS_TYPE_P (nested_name_specifier)
22126 : 118 : && CLASS_TYPE_P (prev_scope)
22127 : 184 : && same_type_p (nested_name_specifier, prev_scope))
22128 : : {
22129 : 21 : permerror (type_start_token->location,
22130 : : "extra qualification not allowed");
22131 : 21 : nested_name_specifier = NULL_TREE;
22132 : : }
22133 : : }
22134 : :
22135 : 1560159 : if (scoped_enum_p)
22136 : 237584 : begin_scope (sk_scoped_enum, type);
22137 : :
22138 : : /* Consume the opening brace. */
22139 : 1560159 : matching_braces braces;
22140 : 1560159 : braces.consume_open (parser);
22141 : :
22142 : 1560159 : if (type == error_mark_node)
22143 : : ; /* Nothing to add */
22144 : 1560111 : else if (OPAQUE_ENUM_P (type)
22145 : 1560141 : || (cxx_dialect > cxx98 && processing_specialization))
22146 : : {
22147 : 1560092 : new_value_list = true;
22148 : 1560092 : SET_OPAQUE_ENUM_P (type, false);
22149 : 1560092 : DECL_SOURCE_LOCATION (TYPE_NAME (type)) = type_start_token->location;
22150 : : }
22151 : : else
22152 : : {
22153 : 19 : auto_diagnostic_group d;
22154 : 19 : error_at (type_start_token->location,
22155 : : "multiple definition of %q#T", type);
22156 : 19 : inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
22157 : : "previous definition here");
22158 : 19 : type = error_mark_node;
22159 : 19 : }
22160 : :
22161 : 1560159 : if (type == error_mark_node)
22162 : 67 : cp_parser_skip_to_end_of_block_or_statement (parser);
22163 : : /* If the next token is not '}', then there are some enumerators. */
22164 : 1560092 : else if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
22165 : : {
22166 : 26717 : if (is_unnamed && !scoped_enum_p
22167 : : /* Don't warn for enum {} a; here. */
22168 : 26717 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_SEMICOLON))
22169 : 3 : pedwarn (type_start_token->location, OPT_Wpedantic,
22170 : : "ISO C++ forbids empty unnamed enum");
22171 : : }
22172 : : else
22173 : : {
22174 : : /* We've seen a '{' so we know we're in an enum-specifier.
22175 : : Commit to any tentative parse to get syntax errors. */
22176 : 1533375 : cp_parser_commit_to_tentative_parse (parser);
22177 : 1533375 : cp_parser_enumerator_list (parser, type);
22178 : : }
22179 : :
22180 : : /* Consume the final '}'. */
22181 : 1560159 : braces.require_close (parser);
22182 : :
22183 : 1560159 : if (scoped_enum_p)
22184 : 237584 : finish_scope ();
22185 : 1560159 : }
22186 : : else
22187 : : {
22188 : : /* If a ';' follows, then it is an opaque-enum-specifier
22189 : : and additional restrictions apply. */
22190 : 23450 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
22191 : : {
22192 : 23428 : if (is_unnamed)
22193 : 0 : error_at (type_start_token->location,
22194 : : "opaque-enum-specifier without name");
22195 : 23428 : else if (nested_name_specifier)
22196 : 6 : error_at (type_start_token->location,
22197 : : "opaque-enum-specifier must use a simple identifier");
22198 : : }
22199 : : }
22200 : :
22201 : : /* Look for trailing attributes to apply to this enumeration, and
22202 : : apply them if appropriate. */
22203 : 1583609 : if (cp_parser_allow_gnu_extensions_p (parser))
22204 : : {
22205 : 1583609 : tree trailing_attr = cp_parser_gnu_attributes_opt (parser);
22206 : 1583609 : cplus_decl_attributes (&type,
22207 : : trailing_attr,
22208 : : (int) ATTR_FLAG_TYPE_IN_PLACE);
22209 : : }
22210 : :
22211 : : /* Finish up the enumeration. */
22212 : 1583609 : if (type != error_mark_node)
22213 : : {
22214 : 1583542 : if (new_value_list)
22215 : 1560092 : finish_enum_value_list (type);
22216 : 1583542 : if (is_new_type)
22217 : 1550195 : finish_enum (type);
22218 : : }
22219 : :
22220 : 1583609 : if (nested_name_specifier)
22221 : : {
22222 : 166 : if (CLASS_TYPE_P (nested_name_specifier))
22223 : : {
22224 : 106 : TYPE_BEING_DEFINED (nested_name_specifier) = nested_being_defined;
22225 : 106 : pop_scope (nested_name_specifier);
22226 : : }
22227 : 60 : else if (TREE_CODE (nested_name_specifier) == NAMESPACE_DECL)
22228 : 39 : pop_nested_namespace (nested_name_specifier);
22229 : : }
22230 : 1583609 : return type;
22231 : 1609751 : }
22232 : :
22233 : : /* Parse an enumerator-list. The enumerators all have the indicated
22234 : : TYPE.
22235 : :
22236 : : enumerator-list:
22237 : : enumerator-definition
22238 : : enumerator-list , enumerator-definition */
22239 : :
22240 : : static void
22241 : 1533375 : cp_parser_enumerator_list (cp_parser* parser, tree type)
22242 : : {
22243 : 10101343 : while (true)
22244 : : {
22245 : : /* Parse an enumerator-definition. */
22246 : 10101343 : cp_parser_enumerator_definition (parser, type);
22247 : :
22248 : : /* If the next token is not a ',', we've reached the end of
22249 : : the list. */
22250 : 10101343 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
22251 : : break;
22252 : : /* Otherwise, consume the `,' and keep going. */
22253 : 8621326 : cp_lexer_consume_token (parser->lexer);
22254 : : /* If the next token is a `}', there is a trailing comma. */
22255 : 8621326 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
22256 : : {
22257 : 53358 : if (cxx_dialect < cxx11)
22258 : 93 : pedwarn (input_location, OPT_Wpedantic,
22259 : : "comma at end of enumerator list");
22260 : : break;
22261 : : }
22262 : : }
22263 : 1533375 : }
22264 : :
22265 : : /* Parse an enumerator-definition. The enumerator has the indicated
22266 : : TYPE.
22267 : :
22268 : : enumerator-definition:
22269 : : enumerator
22270 : : enumerator = constant-expression
22271 : :
22272 : : enumerator:
22273 : : identifier
22274 : :
22275 : : GNU Extensions:
22276 : :
22277 : : enumerator-definition:
22278 : : enumerator attributes [opt]
22279 : : enumerator attributes [opt] = constant-expression */
22280 : :
22281 : : static void
22282 : 10101343 : cp_parser_enumerator_definition (cp_parser* parser, tree type)
22283 : : {
22284 : 10101343 : tree identifier;
22285 : 10101343 : tree value;
22286 : 10101343 : location_t loc;
22287 : :
22288 : : /* Save the input location because we are interested in the location
22289 : : of the identifier and not the location of the explicit value. */
22290 : 10101343 : loc = cp_lexer_peek_token (parser->lexer)->location;
22291 : :
22292 : : /* Look for the identifier. */
22293 : 10101343 : identifier = cp_parser_identifier (parser);
22294 : 10101343 : if (identifier == error_mark_node)
22295 : : return;
22296 : :
22297 : : /* Parse any specified attributes. */
22298 : 10101337 : tree attrs = cp_parser_attributes_opt (parser);
22299 : :
22300 : : /* If the next token is an '=', then there is an explicit value. */
22301 : 10101337 : if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
22302 : : {
22303 : : /* Consume the `=' token. */
22304 : 4421568 : cp_lexer_consume_token (parser->lexer);
22305 : : /* Parse the value. */
22306 : 4421568 : value = cp_parser_constant_expression (parser);
22307 : : }
22308 : : else
22309 : : value = NULL_TREE;
22310 : :
22311 : : /* If we are processing a template, make sure the initializer of the
22312 : : enumerator doesn't contain any bare template parameter pack. */
22313 : 10101337 : if (current_lambda_expr ())
22314 : : {
22315 : : /* In a lambda it should work, but doesn't currently. */
22316 : 160 : if (uses_parameter_packs (value))
22317 : : {
22318 : 6 : sorry ("unexpanded parameter pack in enumerator in lambda");
22319 : 6 : value = error_mark_node;
22320 : : }
22321 : : }
22322 : 10101177 : else if (check_for_bare_parameter_packs (value))
22323 : 3 : value = error_mark_node;
22324 : :
22325 : : /* Create the enumerator. */
22326 : 10101337 : build_enumerator (identifier, value, type, attrs, loc);
22327 : : }
22328 : :
22329 : : /* Parse a namespace-name.
22330 : :
22331 : : namespace-name:
22332 : : original-namespace-name
22333 : : namespace-alias
22334 : :
22335 : : Returns the NAMESPACE_DECL for the namespace. */
22336 : :
22337 : : static tree
22338 : 93871719 : cp_parser_namespace_name (cp_parser* parser)
22339 : : {
22340 : 93871719 : tree identifier;
22341 : 93871719 : tree namespace_decl;
22342 : :
22343 : 93871719 : cp_token *token = cp_lexer_peek_token (parser->lexer);
22344 : :
22345 : : /* Get the name of the namespace. */
22346 : 93871719 : identifier = cp_parser_identifier (parser);
22347 : 93871719 : if (identifier == error_mark_node)
22348 : : return error_mark_node;
22349 : :
22350 : : /* Look up the identifier in the currently active scope. Look only
22351 : : for namespaces, due to:
22352 : :
22353 : : [basic.lookup.udir]
22354 : :
22355 : : When looking up a namespace-name in a using-directive or alias
22356 : : definition, only namespace names are considered.
22357 : :
22358 : : And:
22359 : :
22360 : : [basic.lookup.qual]
22361 : :
22362 : : During the lookup of a name preceding the :: scope resolution
22363 : : operator, object, function, and enumerator names are ignored.
22364 : :
22365 : : (Note that cp_parser_qualifying_entity only calls this
22366 : : function if the token after the name is the scope resolution
22367 : : operator.) */
22368 : 93871719 : namespace_decl = cp_parser_lookup_name (parser, identifier,
22369 : : none_type,
22370 : : /*is_template=*/false,
22371 : : /*is_namespace=*/true,
22372 : : /*check_dependency=*/true,
22373 : : /*ambiguous_decls=*/NULL,
22374 : : token->location);
22375 : : /* If it's not a namespace, issue an error. */
22376 : 93871719 : if (namespace_decl == error_mark_node
22377 : 93871365 : || TREE_CODE (namespace_decl) != NAMESPACE_DECL)
22378 : : {
22379 : 768 : if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
22380 : : {
22381 : 29 : auto_diagnostic_group d;
22382 : 29 : name_hint hint;
22383 : 29 : if (namespace_decl == error_mark_node
22384 : 26 : && parser->scope && TREE_CODE (parser->scope) == NAMESPACE_DECL)
22385 : 22 : hint = suggest_alternative_in_explicit_scope (token->location,
22386 : : identifier,
22387 : 11 : parser->scope);
22388 : 29 : if (const char *suggestion = hint.suggestion ())
22389 : : {
22390 : 3 : gcc_rich_location richloc (token->location);
22391 : 3 : richloc.add_fixit_replace (suggestion);
22392 : 3 : error_at (&richloc,
22393 : : "%qD is not a namespace-name; did you mean %qs?",
22394 : : identifier, suggestion);
22395 : 3 : }
22396 : : else
22397 : 26 : error_at (token->location, "%qD is not a namespace-name",
22398 : : identifier);
22399 : 29 : }
22400 : : else
22401 : 355 : cp_parser_error (parser, "expected namespace-name");
22402 : 384 : namespace_decl = error_mark_node;
22403 : : }
22404 : :
22405 : : return namespace_decl;
22406 : : }
22407 : :
22408 : : /* Parse a namespace-definition.
22409 : :
22410 : : namespace-definition:
22411 : : named-namespace-definition
22412 : : unnamed-namespace-definition
22413 : :
22414 : : named-namespace-definition:
22415 : : original-namespace-definition
22416 : : extension-namespace-definition
22417 : :
22418 : : original-namespace-definition:
22419 : : namespace identifier { namespace-body }
22420 : :
22421 : : extension-namespace-definition:
22422 : : namespace original-namespace-name { namespace-body }
22423 : :
22424 : : unnamed-namespace-definition:
22425 : : namespace { namespace-body } */
22426 : :
22427 : : static void
22428 : 5126222 : cp_parser_namespace_definition (cp_parser* parser)
22429 : : {
22430 : 5126222 : tree identifier;
22431 : 5126222 : int nested_definition_count = 0;
22432 : :
22433 : 5126222 : cp_ensure_no_omp_declare_simd (parser);
22434 : 5126222 : cp_ensure_no_oacc_routine (parser);
22435 : :
22436 : 5126222 : bool is_inline = cp_lexer_next_token_is_keyword (parser->lexer, RID_INLINE);
22437 : 5126222 : const bool topmost_inline_p = is_inline;
22438 : :
22439 : 5126222 : if (is_inline)
22440 : : {
22441 : 214777 : maybe_warn_cpp0x (CPP0X_INLINE_NAMESPACES);
22442 : 214777 : cp_lexer_consume_token (parser->lexer);
22443 : : }
22444 : :
22445 : : /* Look for the `namespace' keyword. */
22446 : 5126222 : cp_token* token
22447 : 5126222 : = cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
22448 : :
22449 : : /* Parse any specified attributes before the identifier. */
22450 : 5126222 : tree attribs = cp_parser_attributes_opt (parser);
22451 : :
22452 : 5286882 : for (;;)
22453 : : {
22454 : 5206552 : identifier = NULL_TREE;
22455 : :
22456 : 5206552 : bool nested_inline_p = cp_lexer_next_token_is_keyword (parser->lexer,
22457 : : RID_INLINE);
22458 : 5206552 : if (nested_inline_p && nested_definition_count != 0)
22459 : : {
22460 : 13 : if (pedantic && cxx_dialect < cxx20)
22461 : 6 : pedwarn (cp_lexer_peek_token (parser->lexer)->location,
22462 : : OPT_Wc__20_extensions, "nested inline namespace "
22463 : : "definitions only available with %<-std=c++20%> or "
22464 : : "%<-std=gnu++20%>");
22465 : 13 : cp_lexer_consume_token (parser->lexer);
22466 : : }
22467 : :
22468 : 5206552 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
22469 : : {
22470 : 5204878 : identifier = cp_parser_identifier (parser);
22471 : :
22472 : 5204878 : if (cp_next_tokens_can_be_std_attribute_p (parser))
22473 : 9 : pedwarn (input_location, OPT_Wpedantic,
22474 : : "standard attributes on namespaces must precede "
22475 : : "the namespace name");
22476 : :
22477 : : /* Parse any attributes specified after the identifier. */
22478 : 5204878 : attribs = attr_chainon (attribs, cp_parser_attributes_opt (parser));
22479 : : }
22480 : :
22481 : 5206552 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
22482 : : {
22483 : : /* Don't forget that the innermost namespace might have been
22484 : : marked as inline. Use |= because we cannot overwrite
22485 : : IS_INLINE in case the outermost namespace is inline, but
22486 : : there are no nested inlines. */
22487 : 5126222 : is_inline |= nested_inline_p;
22488 : 5126222 : break;
22489 : : }
22490 : :
22491 : 80330 : if (!nested_definition_count && pedantic && cxx_dialect < cxx17)
22492 : 6 : pedwarn (input_location, OPT_Wc__17_extensions,
22493 : : "nested namespace definitions only available with "
22494 : : "%<-std=c++17%> or %<-std=gnu++17%>");
22495 : :
22496 : : /* Nested namespace names can create new namespaces (unlike
22497 : : other qualified-ids). */
22498 : 160660 : if (int count = (identifier
22499 : 80330 : ? push_namespace (identifier, nested_inline_p)
22500 : 80330 : : 0))
22501 : 80330 : nested_definition_count += count;
22502 : : else
22503 : 0 : cp_parser_error (parser, "nested namespace name required");
22504 : 80330 : cp_lexer_consume_token (parser->lexer);
22505 : 80330 : }
22506 : :
22507 : 5126222 : if (nested_definition_count && !identifier)
22508 : 3 : cp_parser_error (parser, "namespace name required");
22509 : :
22510 : 5126222 : if (nested_definition_count && attribs)
22511 : 12 : error_at (token->location,
22512 : : "a nested namespace definition cannot have attributes");
22513 : 5126222 : if (nested_definition_count && topmost_inline_p)
22514 : 6 : error_at (token->location,
22515 : : "a nested namespace definition cannot be inline");
22516 : :
22517 : : /* Start the namespace. */
22518 : 5126222 : nested_definition_count += push_namespace (identifier, is_inline);
22519 : :
22520 : 5126222 : bool has_visibility = handle_namespace_attrs (current_namespace, attribs);
22521 : :
22522 : 5126222 : warning (OPT_Wnamespaces, "namespace %qD entered", current_namespace);
22523 : :
22524 : : /* Look for the `{' to validate starting the namespace. */
22525 : 5126222 : matching_braces braces;
22526 : 5126222 : if (braces.require_open (parser))
22527 : : {
22528 : : /* Parse the body of the namespace. */
22529 : 10252345 : cp_parser_namespace_body (parser);
22530 : :
22531 : : /* Look for the final `}'. */
22532 : 5126168 : braces.require_close (parser);
22533 : : }
22534 : :
22535 : 5126213 : if (has_visibility)
22536 : 2535491 : pop_visibility (1);
22537 : :
22538 : : /* Pop the nested namespace definitions. */
22539 : 10332759 : while (nested_definition_count--)
22540 : 5206546 : pop_namespace ();
22541 : 5126213 : }
22542 : :
22543 : : /* Parse a namespace-body.
22544 : :
22545 : : namespace-body:
22546 : : declaration-seq [opt] */
22547 : :
22548 : : static void
22549 : 5126177 : cp_parser_namespace_body (cp_parser* parser)
22550 : : {
22551 : 5126177 : cp_parser_declaration_seq_opt (parser);
22552 : 0 : }
22553 : :
22554 : : /* Parse a namespace-alias-definition.
22555 : :
22556 : : namespace-alias-definition:
22557 : : namespace identifier = qualified-namespace-specifier ; */
22558 : :
22559 : : static void
22560 : 107175 : cp_parser_namespace_alias_definition (cp_parser* parser)
22561 : : {
22562 : 107175 : tree identifier;
22563 : 107175 : tree namespace_specifier;
22564 : :
22565 : 107175 : cp_token *token = cp_lexer_peek_token (parser->lexer);
22566 : :
22567 : : /* Look for the `namespace' keyword. */
22568 : 107175 : cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
22569 : : /* Look for the identifier. */
22570 : 107175 : location_t id_location = cp_lexer_peek_token (parser->lexer)->location;
22571 : 107175 : identifier = cp_parser_identifier (parser);
22572 : 107175 : if (identifier == error_mark_node)
22573 : : return;
22574 : : /* Look for the `=' token. */
22575 : 321465 : if (!cp_parser_uncommitted_to_tentative_parse_p (parser)
22576 : 107157 : && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
22577 : : {
22578 : 6 : error_at (token->location, "%<namespace%> definition is not allowed here");
22579 : : /* Skip the definition. */
22580 : 6 : cp_lexer_consume_token (parser->lexer);
22581 : 6 : if (cp_parser_skip_to_closing_brace (parser))
22582 : 3 : cp_lexer_consume_token (parser->lexer);
22583 : 6 : return;
22584 : : }
22585 : 107151 : cp_parser_require (parser, CPP_EQ, RT_EQ);
22586 : : /* Look for the qualified-namespace-specifier. */
22587 : 107151 : namespace_specifier
22588 : 107151 : = cp_parser_qualified_namespace_specifier (parser);
22589 : 107151 : cp_warn_deprecated_use_scopes (namespace_specifier);
22590 : : /* Look for the `;' token. */
22591 : 107151 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
22592 : :
22593 : : /* Register the alias in the symbol table. */
22594 : 107151 : do_namespace_alias (id_location, identifier, namespace_specifier);
22595 : : }
22596 : :
22597 : : /* Parse a qualified-namespace-specifier.
22598 : :
22599 : : qualified-namespace-specifier:
22600 : : :: [opt] nested-name-specifier [opt] namespace-name
22601 : :
22602 : : Returns a NAMESPACE_DECL corresponding to the specified
22603 : : namespace. */
22604 : :
22605 : : static tree
22606 : 107151 : cp_parser_qualified_namespace_specifier (cp_parser* parser)
22607 : : {
22608 : : /* Look for the optional `::'. */
22609 : 107151 : cp_parser_global_scope_opt (parser,
22610 : : /*current_scope_valid_p=*/false);
22611 : :
22612 : : /* Look for the optional nested-name-specifier. */
22613 : 107151 : cp_parser_nested_name_specifier_opt (parser,
22614 : : /*typename_keyword_p=*/false,
22615 : : /*check_dependency_p=*/true,
22616 : : /*type_p=*/false,
22617 : : /*is_declaration=*/true);
22618 : :
22619 : 107151 : return cp_parser_namespace_name (parser);
22620 : : }
22621 : :
22622 : : /* Subroutine of cp_parser_using_declaration. */
22623 : :
22624 : : static tree
22625 : 7725330 : finish_using_decl (tree qscope, tree identifier, bool typename_p = false)
22626 : : {
22627 : 7725330 : tree decl = NULL_TREE;
22628 : 7725330 : if (at_class_scope_p ())
22629 : : {
22630 : : /* Create the USING_DECL. */
22631 : 1401333 : decl = do_class_using_decl (qscope, identifier);
22632 : :
22633 : 1401333 : if (check_for_bare_parameter_packs (decl))
22634 : 3 : return error_mark_node;
22635 : :
22636 : 1401330 : if (decl && typename_p)
22637 : 85295 : USING_DECL_TYPENAME_P (decl) = 1;
22638 : :
22639 : : /* Add it to the list of members in this class. */
22640 : 1401330 : finish_member_declaration (decl);
22641 : : }
22642 : : else
22643 : 6323997 : finish_nonmember_using_decl (qscope, identifier);
22644 : : return decl;
22645 : : }
22646 : :
22647 : : /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
22648 : : access declaration.
22649 : :
22650 : : using-declaration:
22651 : : using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
22652 : : using :: unqualified-id ;
22653 : :
22654 : : access-declaration:
22655 : : qualified-id ;
22656 : :
22657 : : */
22658 : :
22659 : : static bool
22660 : 119465377 : cp_parser_using_declaration (cp_parser* parser,
22661 : : bool access_declaration_p)
22662 : : {
22663 : 119465377 : cp_token *token;
22664 : 119465377 : bool typename_p = false;
22665 : 119465377 : bool global_scope_p;
22666 : 119465377 : tree identifier;
22667 : 119465377 : tree qscope;
22668 : 119465377 : int oldcount = errorcount;
22669 : 119465377 : cp_token *diag_token = NULL;
22670 : :
22671 : 119465377 : if (access_declaration_p)
22672 : : {
22673 : 112168877 : diag_token = cp_lexer_peek_token (parser->lexer);
22674 : 112168877 : cp_parser_parse_tentatively (parser);
22675 : : }
22676 : : else
22677 : : {
22678 : : /* Look for the `using' keyword. */
22679 : 7296500 : cp_parser_require_keyword (parser, RID_USING, RT_USING);
22680 : :
22681 : 7296521 : again:
22682 : : /* Peek at the next token. */
22683 : 7296521 : token = cp_lexer_peek_token (parser->lexer);
22684 : : /* See if it's `typename'. */
22685 : 7296521 : if (token->keyword == RID_TYPENAME)
22686 : : {
22687 : : /* Remember that we've seen it. */
22688 : 85301 : typename_p = true;
22689 : : /* Consume the `typename' token. */
22690 : 85301 : cp_lexer_consume_token (parser->lexer);
22691 : : }
22692 : : }
22693 : :
22694 : : /* Look for the optional global scope qualification. */
22695 : 119465398 : global_scope_p
22696 : 119465398 : = (cp_parser_global_scope_opt (parser,
22697 : : /*current_scope_valid_p=*/false)
22698 : : != NULL_TREE);
22699 : :
22700 : : /* If we saw `typename', or didn't see `::', then there must be a
22701 : : nested-name-specifier present. */
22702 : 119465398 : if (typename_p || !global_scope_p)
22703 : : {
22704 : 114174177 : qscope = cp_parser_nested_name_specifier (parser, typename_p,
22705 : : /*check_dependency_p=*/true,
22706 : : /*type_p=*/false,
22707 : : /*is_declaration=*/true);
22708 : 114174177 : if (!qscope && !cp_parser_uncommitted_to_tentative_parse_p (parser))
22709 : : {
22710 : 150 : cp_parser_skip_to_end_of_block_or_statement (parser);
22711 : 150 : return false;
22712 : : }
22713 : : }
22714 : : /* Otherwise, we could be in either of the two productions. In that
22715 : : case, treat the nested-name-specifier as optional. */
22716 : : else
22717 : 5291221 : qscope = cp_parser_nested_name_specifier_opt (parser,
22718 : : /*typename_keyword_p=*/false,
22719 : : /*check_dependency_p=*/true,
22720 : : /*type_p=*/false,
22721 : : /*is_declaration=*/true);
22722 : 119465248 : if (!qscope)
22723 : 115978678 : qscope = global_namespace;
22724 : :
22725 : 119465248 : cp_warn_deprecated_use_scopes (qscope);
22726 : :
22727 : 119465248 : if (access_declaration_p
22728 : 112168877 : && !MAYBE_CLASS_TYPE_P (qscope)
22729 : 231539951 : && TREE_CODE (qscope) != ENUMERAL_TYPE)
22730 : : /* If the qualifying scope of an access-declaration isn't a class
22731 : : or enumeration type then it can't be valid. */
22732 : 231539951 : cp_parser_simulate_error (parser);
22733 : :
22734 : 119465248 : if (access_declaration_p && cp_parser_error_occurred (parser))
22735 : : /* Something has already gone wrong; there's no need to parse
22736 : : further. Since an error has occurred, the return value of
22737 : : cp_parser_parse_definitely will be false, as required. */
22738 : 112074703 : return cp_parser_parse_definitely (parser);
22739 : :
22740 : 7390545 : token = cp_lexer_peek_token (parser->lexer);
22741 : : /* Parse the unqualified-id. */
22742 : 7390545 : identifier = cp_parser_unqualified_id (parser,
22743 : : /*template_keyword_p=*/false,
22744 : : /*check_dependency_p=*/true,
22745 : : /*declarator_p=*/true,
22746 : : /*optional_p=*/false);
22747 : :
22748 : 7390545 : if (access_declaration_p)
22749 : : {
22750 : 94174 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
22751 : 188226 : cp_parser_simulate_error (parser);
22752 : 94174 : if (!cp_parser_parse_definitely (parser))
22753 : : return false;
22754 : : }
22755 : 7296371 : else if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
22756 : : {
22757 : 9603 : cp_token *ell = cp_lexer_consume_token (parser->lexer);
22758 : 9603 : if (cxx_dialect < cxx17)
22759 : 8 : pedwarn (ell->location, OPT_Wc__17_extensions,
22760 : : "pack expansion in using-declaration only available "
22761 : : "with %<-std=c++17%> or %<-std=gnu++17%>");
22762 : :
22763 : : /* A parameter pack can appear in the qualifying scope, and/or in the
22764 : : terminal name (if naming a conversion function). Logically they're
22765 : : part of a single pack expansion of the overall USING_DECL, but we
22766 : : express them as separate pack expansions within the USING_DECL since
22767 : : we can't create a pack expansion over a USING_DECL. */
22768 : 9603 : bool saw_parm_pack = false;
22769 : 9603 : if (uses_parameter_packs (qscope))
22770 : : {
22771 : 9600 : qscope = make_pack_expansion (qscope);
22772 : 9600 : saw_parm_pack = true;
22773 : : }
22774 : 9603 : if (identifier_p (identifier)
22775 : 9603 : && IDENTIFIER_CONV_OP_P (identifier)
22776 : 18 : && uses_parameter_packs (TREE_TYPE (identifier)))
22777 : : {
22778 : 15 : identifier = make_conv_op_name (make_pack_expansion
22779 : 15 : (TREE_TYPE (identifier)));
22780 : 15 : saw_parm_pack = true;
22781 : : }
22782 : 9603 : if (!saw_parm_pack)
22783 : : {
22784 : : /* Issue an error in terms using a SCOPE_REF that includes both
22785 : : components. */
22786 : 0 : tree name
22787 : 0 : = build_qualified_name (NULL_TREE, qscope, identifier, false);
22788 : 0 : make_pack_expansion (name);
22789 : 0 : gcc_assert (seen_error ());
22790 : 0 : qscope = identifier = error_mark_node;
22791 : : }
22792 : : }
22793 : :
22794 : : /* The function we call to handle a using-declaration is different
22795 : : depending on what scope we are in. */
22796 : 7296493 : if (qscope == error_mark_node || identifier == error_mark_node)
22797 : : ;
22798 : 7296484 : else if (!identifier_p (identifier)
22799 : 15 : && TREE_CODE (identifier) != BIT_NOT_EXPR)
22800 : : /* [namespace.udecl]
22801 : :
22802 : : A using declaration shall not name a template-id. */
22803 : 12 : error_at (token->location,
22804 : : "a template-id may not appear in a using-declaration");
22805 : : else
22806 : : {
22807 : 7296472 : tree decl = finish_using_decl (qscope, identifier, typename_p);
22808 : :
22809 : 7296472 : if (decl == error_mark_node)
22810 : : {
22811 : 3 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
22812 : 3 : return false;
22813 : : }
22814 : : }
22815 : :
22816 : 7296490 : if (!access_declaration_p
22817 : 7296490 : && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
22818 : : {
22819 : 21 : cp_token *comma = cp_lexer_consume_token (parser->lexer);
22820 : 21 : if (cxx_dialect < cxx17)
22821 : 4 : pedwarn (comma->location, OPT_Wc__17_extensions,
22822 : : "comma-separated list in using-declaration only available "
22823 : : "with %<-std=c++17%> or %<-std=gnu++17%>");
22824 : 21 : goto again;
22825 : : }
22826 : :
22827 : : /* Look for the final `;'. */
22828 : 7296469 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
22829 : :
22830 : 7296469 : if (access_declaration_p && errorcount == oldcount)
22831 : 113 : warning_at (diag_token->location, OPT_Wdeprecated,
22832 : : "access declarations are deprecated "
22833 : : "in favor of using-declarations; "
22834 : : "suggestion: add the %<using%> keyword");
22835 : :
22836 : : return true;
22837 : : }
22838 : :
22839 : : /* C++20 using enum declaration.
22840 : :
22841 : : using-enum-declaration :
22842 : : using elaborated-enum-specifier ; */
22843 : :
22844 : : static void
22845 : 15146 : cp_parser_using_enum (cp_parser *parser)
22846 : : {
22847 : 15146 : cp_parser_require_keyword (parser, RID_USING, RT_USING);
22848 : :
22849 : : /* Using cp_parser_elaborated_type_specifier rejects typedef-names, which
22850 : : breaks one of the motivating examples in using-enum-5.C.
22851 : : cp_parser_simple_type_specifier seems to be closer to what we actually
22852 : : want, though that hasn't been properly specified yet. */
22853 : :
22854 : : /* Consume 'enum'. */
22855 : 15146 : gcc_checking_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM));
22856 : 15146 : cp_lexer_consume_token (parser->lexer);
22857 : :
22858 : 15146 : cp_token *start = cp_lexer_peek_token (parser->lexer);
22859 : :
22860 : 15146 : tree type = (cp_parser_simple_type_specifier
22861 : 15146 : (parser, NULL, CP_PARSER_FLAGS_TYPENAME_OPTIONAL));
22862 : :
22863 : 15146 : cp_token *end = cp_lexer_previous_token (parser->lexer);
22864 : :
22865 : 15146 : if (type == error_mark_node
22866 : 15146 : || !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
22867 : : {
22868 : 3 : cp_parser_skip_to_end_of_block_or_statement (parser);
22869 : 3 : return;
22870 : : }
22871 : 15143 : if (TREE_CODE (type) == TYPE_DECL)
22872 : 15143 : type = TREE_TYPE (type);
22873 : :
22874 : : /* The elaborated-enum-specifier shall not name a dependent type and the type
22875 : : shall have a reachable enum-specifier. */
22876 : 15143 : const char *msg = nullptr;
22877 : 15143 : if (cxx_dialect < cxx20)
22878 : : msg = G_("%<using enum%> "
22879 : : "only available with %<-std=c++20%> or %<-std=gnu++20%>");
22880 : 15143 : else if (dependent_type_p (type))
22881 : : msg = G_("%<using enum%> of dependent type %qT");
22882 : 15140 : else if (TREE_CODE (type) != ENUMERAL_TYPE)
22883 : : msg = G_("%<using enum%> of non-enumeration type %q#T");
22884 : 15138 : else if (!COMPLETE_TYPE_P (type))
22885 : : msg = G_("%<using enum%> of incomplete type %qT");
22886 : 15138 : else if (OPAQUE_ENUM_P (type))
22887 : : msg = G_("%<using enum%> of %qT before its enum-specifier");
22888 : : if (msg)
22889 : : {
22890 : 8 : location_t loc = make_location (start, start, end);
22891 : 8 : auto_diagnostic_group g;
22892 : 8 : error_at (loc, msg, type);
22893 : 8 : loc = location_of (type);
22894 : 8 : if (cxx_dialect < cxx20 || loc == input_location)
22895 : : ;
22896 : 7 : else if (OPAQUE_ENUM_P (type))
22897 : 3 : inform (loc, "opaque-enum-declaration here");
22898 : : else
22899 : 4 : inform (loc, "declared here");
22900 : 8 : }
22901 : :
22902 : : /* A using-enum-declaration introduces the enumerator names of the named
22903 : : enumeration as if by a using-declaration for each enumerator. */
22904 : 15143 : if (TREE_CODE (type) == ENUMERAL_TYPE)
22905 : 443996 : for (tree v = TYPE_VALUES (type); v; v = TREE_CHAIN (v))
22906 : 428858 : finish_using_decl (type, DECL_NAME (TREE_VALUE (v)));
22907 : : }
22908 : :
22909 : : /* Parse an alias-declaration.
22910 : :
22911 : : alias-declaration:
22912 : : using identifier attribute-specifier-seq [opt] = type-id */
22913 : :
22914 : : static tree
22915 : 16507579 : cp_parser_alias_declaration (cp_parser* parser)
22916 : : {
22917 : 16507579 : tree id, type, decl, pushed_scope = NULL_TREE, attributes;
22918 : 16507579 : location_t id_location, type_location;
22919 : 16507579 : cp_declarator *declarator;
22920 : 16507579 : cp_decl_specifier_seq decl_specs;
22921 : 16507579 : bool member_p;
22922 : 16507579 : const char *saved_message = NULL;
22923 : :
22924 : : /* Look for the `using' keyword. */
22925 : 16507579 : cp_token *using_token
22926 : 16507579 : = cp_parser_require_keyword (parser, RID_USING, RT_USING);
22927 : 16507579 : if (using_token == NULL)
22928 : 0 : return error_mark_node;
22929 : :
22930 : 16507579 : id_location = cp_lexer_peek_token (parser->lexer)->location;
22931 : 16507579 : id = cp_parser_identifier (parser);
22932 : 16507579 : if (id == error_mark_node)
22933 : : return error_mark_node;
22934 : :
22935 : 16422274 : cp_token *attrs_token = cp_lexer_peek_token (parser->lexer);
22936 : 16422274 : attributes = cp_parser_attributes_opt (parser);
22937 : 16422274 : if (attributes == error_mark_node)
22938 : : return error_mark_node;
22939 : :
22940 : 16422274 : cp_parser_require (parser, CPP_EQ, RT_EQ);
22941 : :
22942 : 32844548 : if (cp_parser_error_occurred (parser))
22943 : 1001765 : return error_mark_node;
22944 : :
22945 : 15420509 : cp_parser_commit_to_tentative_parse (parser);
22946 : :
22947 : : /* Now we are going to parse the type-id of the declaration. */
22948 : :
22949 : : /*
22950 : : [dcl.type]/3 says:
22951 : :
22952 : : "A type-specifier-seq shall not define a class or enumeration
22953 : : unless it appears in the type-id of an alias-declaration (7.1.3) that
22954 : : is not the declaration of a template-declaration."
22955 : :
22956 : : In other words, if we currently are in an alias template, the
22957 : : type-id should not define a type.
22958 : :
22959 : : So let's set parser->type_definition_forbidden_message in that
22960 : : case; cp_parser_check_type_definition (called by
22961 : : cp_parser_class_specifier) will then emit an error if a type is
22962 : : defined in the type-id. */
22963 : 15420509 : if (parser->num_template_parameter_lists)
22964 : : {
22965 : 3564683 : saved_message = parser->type_definition_forbidden_message;
22966 : 3564683 : parser->type_definition_forbidden_message =
22967 : : G_("types may not be defined in alias template declarations");
22968 : : }
22969 : :
22970 : 30841018 : type = cp_parser_type_id (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
22971 : : &type_location);
22972 : :
22973 : : /* Restore the error message if need be. */
22974 : 15420509 : if (parser->num_template_parameter_lists)
22975 : 3564683 : parser->type_definition_forbidden_message = saved_message;
22976 : :
22977 : 15420509 : if (type == error_mark_node
22978 : 15420509 : || !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
22979 : : {
22980 : 94 : cp_parser_skip_to_end_of_block_or_statement (parser);
22981 : 94 : return error_mark_node;
22982 : : }
22983 : :
22984 : : /* A typedef-name can also be introduced by an alias-declaration. The
22985 : : identifier following the using keyword becomes a typedef-name. It has
22986 : : the same semantics as if it were introduced by the typedef
22987 : : specifier. In particular, it does not define a new type and it shall
22988 : : not appear in the type-id. */
22989 : :
22990 : 15420415 : clear_decl_specs (&decl_specs);
22991 : 15420415 : decl_specs.type = type;
22992 : 15420415 : if (attributes != NULL_TREE)
22993 : : {
22994 : 50029 : decl_specs.attributes = attributes;
22995 : 50029 : set_and_check_decl_spec_loc (&decl_specs,
22996 : : ds_attribute,
22997 : : attrs_token);
22998 : : }
22999 : 15420415 : set_and_check_decl_spec_loc (&decl_specs,
23000 : : ds_typedef,
23001 : : using_token);
23002 : 15420415 : set_and_check_decl_spec_loc (&decl_specs,
23003 : : ds_alias,
23004 : : using_token);
23005 : 15420415 : decl_specs.locations[ds_type_spec] = type_location;
23006 : :
23007 : 15420415 : if (parser->num_template_parameter_lists
23008 : 15420415 : && !cp_parser_check_template_parameters (parser,
23009 : : /*num_templates=*/0,
23010 : : /*template_id*/false,
23011 : : id_location,
23012 : : /*declarator=*/NULL))
23013 : 6 : return error_mark_node;
23014 : :
23015 : 15420409 : declarator = make_id_declarator (NULL_TREE, id, sfk_none, id_location);
23016 : :
23017 : 15420409 : member_p = at_class_scope_p ();
23018 : 15420409 : if (member_p)
23019 : 9453364 : decl = grokfield (declarator, &decl_specs, NULL_TREE, false,
23020 : : NULL_TREE, attributes);
23021 : : else
23022 : 5967045 : decl = start_decl (declarator, &decl_specs, 0,
23023 : : attributes, NULL_TREE, &pushed_scope);
23024 : 15420409 : if (decl == error_mark_node)
23025 : : return decl;
23026 : :
23027 : 15420380 : cp_finish_decl (decl, NULL_TREE, 0, NULL_TREE, 0);
23028 : :
23029 : 15420380 : if (pushed_scope)
23030 : 2757086 : pop_scope (pushed_scope);
23031 : :
23032 : : /* If decl is a template, return its TEMPLATE_DECL so that it gets
23033 : : added into the symbol table; otherwise, return the TYPE_DECL. */
23034 : 15420380 : if (DECL_LANG_SPECIFIC (decl)
23035 : 11700384 : && DECL_TEMPLATE_INFO (decl)
23036 : 25957592 : && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)))
23037 : : {
23038 : 3564649 : decl = DECL_TI_TEMPLATE (decl);
23039 : 3564649 : if (member_p)
23040 : 1328639 : check_member_template (decl);
23041 : : }
23042 : :
23043 : 15420380 : check_module_decl_linkage (decl);
23044 : :
23045 : 15420380 : return decl;
23046 : : }
23047 : :
23048 : : /* Parse a using-directive.
23049 : :
23050 : : using-directive:
23051 : : attribute-specifier-seq [opt] using namespace :: [opt]
23052 : : nested-name-specifier [opt] namespace-name ; */
23053 : :
23054 : : static void
23055 : 99451 : cp_parser_using_directive (cp_parser* parser)
23056 : : {
23057 : 99451 : tree namespace_decl;
23058 : 99451 : tree attribs = cp_parser_std_attribute_spec_seq (parser);
23059 : 99451 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
23060 : : {
23061 : : /* Error during attribute parsing that resulted in skipping
23062 : : to next semicolon. */
23063 : 3 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
23064 : 3 : return;
23065 : : }
23066 : :
23067 : : /* Look for the `using' keyword. */
23068 : 99448 : cp_parser_require_keyword (parser, RID_USING, RT_USING);
23069 : : /* And the `namespace' keyword. */
23070 : 99448 : cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
23071 : : /* Look for the optional `::' operator. */
23072 : 99448 : cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
23073 : : /* And the optional nested-name-specifier. */
23074 : 99448 : cp_parser_nested_name_specifier_opt (parser,
23075 : : /*typename_keyword_p=*/false,
23076 : : /*check_dependency_p=*/true,
23077 : : /*type_p=*/false,
23078 : : /*is_declaration=*/true);
23079 : : /* Get the namespace being used. */
23080 : 99448 : namespace_decl = cp_parser_namespace_name (parser);
23081 : 99448 : cp_warn_deprecated_use_scopes (namespace_decl);
23082 : : /* And any specified GNU attributes. */
23083 : 99448 : if (cp_next_tokens_can_be_gnu_attribute_p (parser))
23084 : 6 : attribs = chainon (attribs, cp_parser_gnu_attributes_opt (parser));
23085 : :
23086 : : /* Update the symbol table. */
23087 : 99448 : finish_using_directive (namespace_decl, attribs);
23088 : :
23089 : : /* Look for the final `;'. */
23090 : 99448 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
23091 : : }
23092 : :
23093 : : /* Parse a string literal or constant expression yielding a string.
23094 : : The constant expression uses extra parens to avoid ambiguity with "x" (expr).
23095 : :
23096 : : asm-string-expr:
23097 : : string-literal
23098 : : ( constant-expr ) */
23099 : :
23100 : : static tree
23101 : 996884 : cp_parser_asm_string_expression (cp_parser *parser)
23102 : : {
23103 : 996884 : cp_token *tok = cp_lexer_peek_token (parser->lexer);
23104 : :
23105 : 996884 : if (tok->type == CPP_OPEN_PAREN)
23106 : : {
23107 : 8 : matching_parens parens;
23108 : 8 : parens.consume_open (parser);
23109 : 8 : tree string = cp_parser_constant_expression (parser);
23110 : 8 : if (string != error_mark_node)
23111 : 8 : string = cxx_constant_value (string, tf_error);
23112 : 8 : cexpr_str cstr (string);
23113 : 8 : if (!cstr.type_check (tok->location))
23114 : 0 : return error_mark_node;
23115 : 8 : if (!cstr.extract (tok->location, string))
23116 : 0 : string = error_mark_node;
23117 : 8 : parens.require_close (parser);
23118 : 8 : return string;
23119 : 8 : }
23120 : 996876 : else if (!cp_parser_is_string_literal (tok))
23121 : : {
23122 : 52 : error_at (tok->location,
23123 : : "expected string-literal or constexpr in parentheses");
23124 : 52 : return error_mark_node;
23125 : : }
23126 : 996824 : return cp_parser_string_literal (parser, false, false);
23127 : : }
23128 : :
23129 : : /* Parse an asm-definition.
23130 : :
23131 : : asm-qualifier:
23132 : : volatile
23133 : : inline
23134 : : goto
23135 : :
23136 : : asm-qualifier-list:
23137 : : asm-qualifier
23138 : : asm-qualifier-list asm-qualifier
23139 : :
23140 : : asm-definition:
23141 : : asm ( constant-expr ) ;
23142 : :
23143 : : GNU Extension:
23144 : :
23145 : : asm-definition:
23146 : : asm asm-qualifier-list [opt] ( asm-string-expr ) ;
23147 : : asm asm-qualifier-list [opt] ( asm-string-expr : asm-operand-list [opt] ) ;
23148 : : asm asm-qualifier-list [opt] ( asm-string-expr : asm-operand-list [opt]
23149 : : : asm-operand-list [opt] ) ;
23150 : : asm asm-qualifier-list [opt] ( asm-string-expr : asm-operand-list [opt]
23151 : : : asm-operand-list [opt]
23152 : : : asm-clobber-list [opt] ) ;
23153 : : asm asm-qualifier-list [opt] ( asm-string-expr : : asm-operand-list [opt]
23154 : : : asm-clobber-list [opt]
23155 : : : asm-goto-list ) ;
23156 : :
23157 : : The form with asm-goto-list is valid if and only if the asm-qualifier-list
23158 : : contains goto, and is the only allowed form in that case. No duplicates are
23159 : : allowed in an asm-qualifier-list. */
23160 : :
23161 : : static void
23162 : 23593 : cp_parser_asm_definition (cp_parser* parser)
23163 : : {
23164 : 23593 : tree outputs = NULL_TREE;
23165 : 23593 : tree inputs = NULL_TREE;
23166 : 23593 : tree clobbers = NULL_TREE;
23167 : 23593 : tree labels = NULL_TREE;
23168 : 23593 : tree asm_stmt;
23169 : 23593 : bool extended_p = false;
23170 : 23593 : bool invalid_inputs_p = false;
23171 : 23593 : bool invalid_outputs_p = false;
23172 : 23593 : required_token missing = RT_NONE;
23173 : 23593 : tree std_attrs = cp_parser_std_attribute_spec_seq (parser);
23174 : 23593 : location_t asm_loc = cp_lexer_peek_token (parser->lexer)->location;
23175 : :
23176 : : /* Look for the `asm' keyword. */
23177 : 23593 : cp_parser_require_keyword (parser, RID_ASM, RT_ASM);
23178 : :
23179 : : /* In C++20, unevaluated inline assembly is permitted in constexpr
23180 : : functions. */
23181 : 23593 : if (parser->in_function_body
23182 : 10889 : && DECL_DECLARED_CONSTEXPR_P (current_function_decl)
23183 : 23642 : && cxx_dialect < cxx20)
23184 : 4 : pedwarn (asm_loc, OPT_Wc__20_extensions, "%<asm%> in %<constexpr%> "
23185 : : "function only available with %<-std=c++20%> or "
23186 : : "%<-std=gnu++20%>");
23187 : :
23188 : : /* Handle the asm-qualifier-list. */
23189 : 23593 : location_t volatile_loc = UNKNOWN_LOCATION;
23190 : 23593 : location_t inline_loc = UNKNOWN_LOCATION;
23191 : 23593 : location_t goto_loc = UNKNOWN_LOCATION;
23192 : 23593 : location_t first_loc = UNKNOWN_LOCATION;
23193 : :
23194 : 23593 : if (cp_parser_allow_gnu_extensions_p (parser))
23195 : 31574 : for (;;)
23196 : : {
23197 : 31574 : cp_token *token = cp_lexer_peek_token (parser->lexer);
23198 : 31574 : location_t loc = token->location;
23199 : 31574 : switch (cp_lexer_peek_token (parser->lexer)->keyword)
23200 : : {
23201 : 7840 : case RID_VOLATILE:
23202 : 7840 : if (volatile_loc)
23203 : : {
23204 : 6 : auto_diagnostic_group d;
23205 : 6 : error_at (loc, "duplicate %<asm%> qualifier %qT",
23206 : : token->u.value);
23207 : 6 : inform (volatile_loc, "first seen here");
23208 : 6 : }
23209 : : else
23210 : : {
23211 : 7834 : if (!parser->in_function_body)
23212 : 1 : warning_at (loc, 0, "%<asm%> qualifier %qT ignored "
23213 : : "outside of function body", token->u.value);
23214 : : volatile_loc = loc;
23215 : : }
23216 : 7840 : cp_lexer_consume_token (parser->lexer);
23217 : 7840 : continue;
23218 : :
23219 : 39 : case RID_INLINE:
23220 : 39 : if (inline_loc)
23221 : : {
23222 : 6 : auto_diagnostic_group d;
23223 : 6 : error_at (loc, "duplicate %<asm%> qualifier %qT",
23224 : : token->u.value);
23225 : 6 : inform (inline_loc, "first seen here");
23226 : 6 : }
23227 : : else
23228 : : inline_loc = loc;
23229 : 39 : if (!first_loc)
23230 : 26 : first_loc = loc;
23231 : 39 : cp_lexer_consume_token (parser->lexer);
23232 : 39 : continue;
23233 : :
23234 : 99 : case RID_GOTO:
23235 : 99 : if (goto_loc)
23236 : : {
23237 : 6 : auto_diagnostic_group d;
23238 : 6 : error_at (loc, "duplicate %<asm%> qualifier %qT",
23239 : : token->u.value);
23240 : 6 : inform (goto_loc, "first seen here");
23241 : 6 : }
23242 : : else
23243 : : goto_loc = loc;
23244 : 99 : if (!first_loc)
23245 : 81 : first_loc = loc;
23246 : 99 : cp_lexer_consume_token (parser->lexer);
23247 : 99 : continue;
23248 : :
23249 : 3 : case RID_CONST:
23250 : 3 : case RID_RESTRICT:
23251 : 3 : error_at (loc, "%qT is not an %<asm%> qualifier", token->u.value);
23252 : 3 : cp_lexer_consume_token (parser->lexer);
23253 : 3 : continue;
23254 : :
23255 : : default:
23256 : : break;
23257 : 7981 : }
23258 : : break;
23259 : : }
23260 : :
23261 : 23593 : bool volatile_p = (volatile_loc != UNKNOWN_LOCATION);
23262 : 23593 : bool inline_p = (inline_loc != UNKNOWN_LOCATION);
23263 : 23593 : bool goto_p = (goto_loc != UNKNOWN_LOCATION);
23264 : :
23265 : 23593 : if (!parser->in_function_body && (inline_p || goto_p))
23266 : : {
23267 : 2 : error_at (first_loc, "%<asm%> qualifier outside of function body");
23268 : 2 : inline_p = goto_p = false;
23269 : : }
23270 : :
23271 : : /* Look for the opening `('. */
23272 : 23593 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23273 : : return;
23274 : : /* Look for the string. */
23275 : 23592 : tree string = cp_parser_asm_string_expression (parser);
23276 : 23592 : if (string == error_mark_node)
23277 : : {
23278 : 37 : cp_parser_skip_to_closing_parenthesis (parser, true, false,
23279 : : /*consume_paren=*/true);
23280 : 37 : return;
23281 : : }
23282 : :
23283 : : /* If we're allowing GNU extensions, check for the extended assembly
23284 : : syntax. Unfortunately, the `:' tokens need not be separated by
23285 : : a space in C, and so, for compatibility, we tolerate that here
23286 : : too. Doing that means that we have to treat the `::' operator as
23287 : : two `:' tokens. */
23288 : 23555 : if (cp_parser_allow_gnu_extensions_p (parser)
23289 : 23555 : && (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
23290 : 14369 : || cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)))
23291 : : {
23292 : 10254 : bool inputs_p = false;
23293 : 10254 : bool clobbers_p = false;
23294 : 10254 : bool labels_p = false;
23295 : :
23296 : : /* The extended syntax was used. */
23297 : 10254 : extended_p = true;
23298 : :
23299 : : /* Look for outputs. */
23300 : 10254 : if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
23301 : : {
23302 : : /* Consume the `:'. */
23303 : 9186 : cp_lexer_consume_token (parser->lexer);
23304 : : /* Parse the output-operands. */
23305 : 9186 : if (cp_lexer_next_token_is_not (parser->lexer,
23306 : : CPP_COLON)
23307 : : && cp_lexer_next_token_is_not (parser->lexer,
23308 : : CPP_SCOPE)
23309 : : && cp_lexer_next_token_is_not (parser->lexer,
23310 : : CPP_CLOSE_PAREN))
23311 : : {
23312 : 7634 : outputs = cp_parser_asm_operand_list (parser);
23313 : 7634 : if (outputs == error_mark_node)
23314 : : invalid_outputs_p = true;
23315 : : }
23316 : : }
23317 : : /* If the next token is `::', there are no outputs, and the
23318 : : next token is the beginning of the inputs. */
23319 : : else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
23320 : : /* The inputs are coming next. */
23321 : : inputs_p = true;
23322 : :
23323 : : /* Look for inputs. */
23324 : : if (inputs_p
23325 : 9186 : || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
23326 : : {
23327 : : /* Consume the `:' or `::'. */
23328 : 7298 : cp_lexer_consume_token (parser->lexer);
23329 : : /* Parse the output-operands. */
23330 : 7298 : if (cp_lexer_next_token_is_not (parser->lexer,
23331 : : CPP_COLON)
23332 : : && cp_lexer_next_token_is_not (parser->lexer,
23333 : : CPP_SCOPE)
23334 : : && cp_lexer_next_token_is_not (parser->lexer,
23335 : : CPP_CLOSE_PAREN))
23336 : : {
23337 : 6045 : inputs = cp_parser_asm_operand_list (parser);
23338 : 6045 : if (inputs == error_mark_node)
23339 : : invalid_inputs_p = true;
23340 : : }
23341 : : }
23342 : 2956 : else if (parser->in_function_body
23343 : 2956 : && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
23344 : : /* The clobbers are coming next. */
23345 : : clobbers_p = true;
23346 : :
23347 : : /* Look for clobbers. */
23348 : : if (clobbers_p
23349 : 10242 : || (parser->in_function_body
23350 : 10149 : && cp_lexer_next_token_is (parser->lexer, CPP_COLON)))
23351 : : {
23352 : 4585 : clobbers_p = true;
23353 : : /* Consume the `:' or `::'. */
23354 : 4585 : cp_lexer_consume_token (parser->lexer);
23355 : : /* Parse the clobbers. */
23356 : 4585 : if (cp_lexer_next_token_is_not (parser->lexer,
23357 : : CPP_COLON)
23358 : 4585 : && cp_lexer_next_token_is_not (parser->lexer,
23359 : : CPP_CLOSE_PAREN))
23360 : 4497 : clobbers = cp_parser_asm_clobber_list (parser);
23361 : : }
23362 : 5669 : else if (goto_p && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
23363 : : /* The labels are coming next. */
23364 : : labels_p = true;
23365 : :
23366 : : /* Look for labels. */
23367 : 4497 : if (labels_p
23368 : 10222 : || (goto_p && cp_lexer_next_token_is (parser->lexer, CPP_COLON)))
23369 : : {
23370 : 71 : labels_p = true;
23371 : : /* Consume the `:' or `::'. */
23372 : 71 : cp_lexer_consume_token (parser->lexer);
23373 : : /* Parse the labels. */
23374 : 71 : labels = cp_parser_asm_label_list (parser);
23375 : : }
23376 : :
23377 : 10254 : if (goto_p && !labels_p)
23378 : 18 : missing = clobbers_p ? RT_COLON : RT_COLON_SCOPE;
23379 : : }
23380 : 13301 : else if (goto_p)
23381 : : missing = RT_COLON_SCOPE;
23382 : :
23383 : : /* Look for the closing `)'. */
23384 : 23555 : if (!cp_parser_require (parser, missing ? CPP_COLON : CPP_CLOSE_PAREN,
23385 : : missing ? missing : RT_CLOSE_PAREN))
23386 : 39 : cp_parser_skip_to_closing_parenthesis (parser, true, false,
23387 : : /*consume_paren=*/true);
23388 : 23555 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
23389 : :
23390 : 23555 : if (!invalid_inputs_p && !invalid_outputs_p)
23391 : : {
23392 : : /* Create the ASM_EXPR. */
23393 : 23546 : if (parser->in_function_body)
23394 : : {
23395 : 10843 : asm_stmt = finish_asm_stmt (asm_loc, volatile_p, string, outputs,
23396 : : inputs, clobbers, labels, inline_p,
23397 : : false);
23398 : : /* If the extended syntax was not used, mark the ASM_EXPR. */
23399 : 10843 : if (!extended_p)
23400 : : {
23401 : 691 : tree temp = asm_stmt;
23402 : 691 : if (TREE_CODE (temp) == CLEANUP_POINT_EXPR)
23403 : 670 : temp = TREE_OPERAND (temp, 0);
23404 : :
23405 : 691 : ASM_BASIC_P (temp) = 1;
23406 : : }
23407 : : }
23408 : 12703 : else if (!extended_p)
23409 : 12610 : symtab->finalize_toplevel_asm (string);
23410 : : else
23411 : 93 : finish_asm_stmt (asm_loc, false, string, outputs, inputs,
23412 : : NULL_TREE, NULL_TREE, false, true);
23413 : : }
23414 : :
23415 : 23555 : if (std_attrs && any_nonignored_attribute_p (std_attrs))
23416 : 52 : warning_at (asm_loc, OPT_Wattributes,
23417 : : "attributes ignored on %<asm%> declaration");
23418 : : }
23419 : :
23420 : : /* Given the type TYPE of a declaration with declarator DECLARATOR, return the
23421 : : type that comes from the decl-specifier-seq. */
23422 : :
23423 : : static tree
23424 : 6259281 : strip_declarator_types (tree type, cp_declarator *declarator)
23425 : : {
23426 : 6993690 : for (cp_declarator *d = declarator; d;)
23427 : 6993690 : switch (d->kind)
23428 : : {
23429 : : case cdk_id:
23430 : : case cdk_decomp:
23431 : : case cdk_error:
23432 : : d = NULL;
23433 : : break;
23434 : :
23435 : 734409 : default:
23436 : 734409 : if (TYPE_PTRMEMFUNC_P (type))
23437 : 9 : type = TYPE_PTRMEMFUNC_FN_TYPE (type);
23438 : 734409 : type = TREE_TYPE (type);
23439 : 734409 : d = d->declarator;
23440 : 734409 : break;
23441 : : }
23442 : :
23443 : 6259281 : return type;
23444 : : }
23445 : :
23446 : : /* Warn about the most vexing parse syntactic ambiguity, i.e., warn when
23447 : : a construct looks like a variable definition but is actually a function
23448 : : declaration. DECL_SPECIFIERS is the decl-specifier-seq and DECLARATOR
23449 : : is the declarator for this function declaration. */
23450 : :
23451 : : static void
23452 : 72844815 : warn_about_ambiguous_parse (const cp_decl_specifier_seq *decl_specifiers,
23453 : : const cp_declarator *declarator)
23454 : : {
23455 : : /* Only warn if we are declaring a function at block scope. */
23456 : 72844815 : if (!at_function_scope_p ())
23457 : 72844714 : return;
23458 : :
23459 : : /* And only if there is no storage class specified. */
23460 : 34477 : if (decl_specifiers->storage_class != sc_none
23461 : 34477 : || decl_spec_seq_has_spec_p (decl_specifiers, ds_typedef))
23462 : 16153 : return;
23463 : :
23464 : 18324 : if (declarator->kind != cdk_function
23465 : 18321 : || !declarator->declarator
23466 : 18321 : || declarator->declarator->kind != cdk_id
23467 : 72881356 : || !identifier_p (get_unqualified_id
23468 : : (const_cast<cp_declarator *>(declarator))))
23469 : : return;
23470 : :
23471 : : /* Don't warn when the whole declarator (not just the declarator-id!)
23472 : : was parenthesized. That is, don't warn for int(n()) but do warn
23473 : : for int(f)(). */
23474 : 18321 : if (declarator->parenthesized != UNKNOWN_LOCATION)
23475 : : return;
23476 : :
23477 : 18303 : tree type;
23478 : 18303 : if (decl_specifiers->type)
23479 : : {
23480 : 18288 : type = decl_specifiers->type;
23481 : 18288 : if (TREE_CODE (type) == TYPE_DECL)
23482 : 193 : type = TREE_TYPE (type);
23483 : :
23484 : : /* If the return type is void there is no ambiguity. */
23485 : 18288 : if (same_type_p (type, void_type_node))
23486 : : return;
23487 : : }
23488 : 15 : else if (decl_specifiers->any_type_specifiers_p)
23489 : : /* Code like long f(); will have null ->type. If we have any
23490 : : type-specifiers, pretend we've seen int. */
23491 : 12 : type = integer_type_node;
23492 : : else
23493 : : return;
23494 : :
23495 : 381 : auto_diagnostic_group d;
23496 : 381 : location_t loc = declarator->u.function.parens_loc;
23497 : 381 : tree params = declarator->u.function.parameters;
23498 : 381 : const bool has_list_ctor_p = CLASS_TYPE_P (type) && TYPE_HAS_LIST_CTOR (type);
23499 : :
23500 : : /* The T t() case. */
23501 : 381 : if (params == void_list_node)
23502 : : {
23503 : 95 : if (warning_at (loc, OPT_Wvexing_parse,
23504 : : "empty parentheses were disambiguated as a function "
23505 : : "declaration"))
23506 : : {
23507 : : /* () means value-initialization (C++03 and up); {} (C++11 and up)
23508 : : means value-initialization or aggregate-initialization, nothing
23509 : : means default-initialization. We can only suggest removing the
23510 : : parentheses/adding {} if T has a default constructor. */
23511 : 95 : if (!CLASS_TYPE_P (type) || TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
23512 : : {
23513 : 75 : gcc_rich_location iloc (loc);
23514 : 75 : iloc.add_fixit_remove ();
23515 : 75 : inform (&iloc, "remove parentheses to default-initialize "
23516 : : "a variable");
23517 : 75 : if (cxx_dialect >= cxx11 && !has_list_ctor_p)
23518 : : {
23519 : 51 : if (CP_AGGREGATE_TYPE_P (type))
23520 : 13 : inform (loc, "or replace parentheses with braces to "
23521 : : "aggregate-initialize a variable");
23522 : : else
23523 : 38 : inform (loc, "or replace parentheses with braces to "
23524 : : "value-initialize a variable");
23525 : : }
23526 : 75 : }
23527 : : }
23528 : 95 : return;
23529 : : }
23530 : :
23531 : : /* If we had (...) or the parameter-list wasn't parenthesized,
23532 : : we're done. */
23533 : 566 : if (params == NULL_TREE || !PARENTHESIZED_LIST_P (params))
23534 : : return;
23535 : :
23536 : : /* The T t(X()) case. */
23537 : 101 : if (list_length (params) == 2)
23538 : : {
23539 : 69 : if (warning_at (loc, OPT_Wvexing_parse,
23540 : : "parentheses were disambiguated as a function "
23541 : : "declaration"))
23542 : : {
23543 : 67 : gcc_rich_location iloc (loc);
23544 : : /* {}-initialization means that we can use an initializer-list
23545 : : constructor if no default constructor is available, so don't
23546 : : suggest using {} for classes that have an initializer_list
23547 : : constructor. */
23548 : 67 : if (cxx_dialect >= cxx11 && !has_list_ctor_p)
23549 : : {
23550 : 45 : iloc.add_fixit_replace (get_start (loc), "{");
23551 : 45 : iloc.add_fixit_replace (get_finish (loc), "}");
23552 : 45 : inform (&iloc, "replace parentheses with braces to declare a "
23553 : : "variable");
23554 : : }
23555 : : else
23556 : : {
23557 : 22 : iloc.add_fixit_insert_after (get_start (loc), "(");
23558 : 22 : iloc.add_fixit_insert_before (get_finish (loc), ")");
23559 : 22 : inform (&iloc, "add parentheses to declare a variable");
23560 : : }
23561 : 67 : }
23562 : : }
23563 : : /* The T t(X(), X()) case. */
23564 : 32 : else if (warning_at (loc, OPT_Wvexing_parse,
23565 : : "parentheses were disambiguated as a function "
23566 : : "declaration"))
23567 : : {
23568 : 30 : gcc_rich_location iloc (loc);
23569 : 30 : if (cxx_dialect >= cxx11 && !has_list_ctor_p)
23570 : : {
23571 : 24 : iloc.add_fixit_replace (get_start (loc), "{");
23572 : 24 : iloc.add_fixit_replace (get_finish (loc), "}");
23573 : 24 : inform (&iloc, "replace parentheses with braces to declare a "
23574 : : "variable");
23575 : : }
23576 : 30 : }
23577 : 381 : }
23578 : :
23579 : : /* If DECLARATOR with DECL_SPECS is a function declarator that has
23580 : : the form of a deduction guide, tag it as such. CTOR_DTOR_OR_CONV_P
23581 : : has the same meaning as in cp_parser_declarator. */
23582 : :
23583 : : static void
23584 : 198529129 : cp_parser_maybe_adjust_declarator_for_dguide (cp_parser *parser,
23585 : : cp_decl_specifier_seq *decl_specs,
23586 : : cp_declarator *declarator,
23587 : : int *ctor_dtor_or_conv_p)
23588 : : {
23589 : 198529129 : if (cxx_dialect >= cxx17
23590 : 195474685 : && *ctor_dtor_or_conv_p <= 0
23591 : 171177584 : && !decl_specs->type
23592 : 2609724 : && !decl_specs->any_type_specifiers_p
23593 : 199426158 : && function_declarator_p (declarator))
23594 : : {
23595 : 897021 : cp_declarator *id = get_id_declarator (declarator);
23596 : 897021 : tree name = id->u.id.unqualified_name;
23597 : 897021 : parser->scope = id->u.id.qualifying_scope;
23598 : 897021 : tree tmpl = cp_parser_lookup_name_simple (parser, name, id->id_loc);
23599 : 897021 : if (tmpl
23600 : 897021 : && (DECL_CLASS_TEMPLATE_P (tmpl)
23601 : 226 : || DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)))
23602 : : {
23603 : 896798 : id->u.id.unqualified_name = dguide_name (tmpl);
23604 : 896798 : id->u.id.sfk = sfk_deduction_guide;
23605 : 896798 : *ctor_dtor_or_conv_p = 1;
23606 : : }
23607 : : }
23608 : 198529129 : }
23609 : :
23610 : : /* Declarators [gram.dcl.decl] */
23611 : :
23612 : : /* Parse an init-declarator.
23613 : :
23614 : : init-declarator:
23615 : : declarator initializer [opt]
23616 : :
23617 : : GNU Extension:
23618 : :
23619 : : init-declarator:
23620 : : declarator asm-specification [opt] attributes [opt] initializer [opt]
23621 : :
23622 : : function-definition:
23623 : : decl-specifier-seq [opt] declarator ctor-initializer [opt]
23624 : : function-body
23625 : : decl-specifier-seq [opt] declarator function-try-block
23626 : :
23627 : : GNU Extension:
23628 : :
23629 : : function-definition:
23630 : : __extension__ function-definition
23631 : :
23632 : : TM Extension:
23633 : :
23634 : : function-definition:
23635 : : decl-specifier-seq [opt] declarator function-transaction-block
23636 : :
23637 : : The parser flags FLAGS is used to control type-specifier parsing.
23638 : :
23639 : : The DECL_SPECIFIERS apply to this declarator. Returns a
23640 : : representation of the entity declared. If MEMBER_P is TRUE, then
23641 : : this declarator appears in a class scope. The new DECL created by
23642 : : this declarator is returned.
23643 : :
23644 : : The CHECKS are access checks that should be performed once we know
23645 : : what entity is being declared (and, therefore, what classes have
23646 : : befriended it).
23647 : :
23648 : : If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
23649 : : for a function-definition here as well. If the declarator is a
23650 : : declarator for a function-definition, *FUNCTION_DEFINITION_P will
23651 : : be TRUE upon return. By that point, the function-definition will
23652 : : have been completely parsed.
23653 : :
23654 : : FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
23655 : : is FALSE.
23656 : :
23657 : : If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
23658 : : parsed declaration if it is an uninitialized single declarator not followed
23659 : : by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
23660 : : if present, will not be consumed. If returned, this declarator will be
23661 : : created with SD_INITIALIZED but will not call cp_finish_decl.
23662 : :
23663 : : If INIT_LOC is not NULL, and *INIT_LOC is equal to UNKNOWN_LOCATION,
23664 : : and there is an initializer, the pointed location_t is set to the
23665 : : location of the '=' or `(', or '{' in C++11 token introducing the
23666 : : initializer. */
23667 : :
23668 : : static tree
23669 : 154798237 : cp_parser_init_declarator (cp_parser* parser,
23670 : : cp_parser_flags flags,
23671 : : cp_decl_specifier_seq *decl_specifiers,
23672 : : vec<deferred_access_check, va_gc> *checks,
23673 : : bool function_definition_allowed_p,
23674 : : bool member_p,
23675 : : int declares_class_or_enum,
23676 : : bool* function_definition_p,
23677 : : tree* maybe_range_for_decl,
23678 : : location_t* init_loc,
23679 : : tree* auto_result)
23680 : : {
23681 : 154798237 : cp_token *token = NULL, *asm_spec_start_token = NULL,
23682 : 154798237 : *attributes_start_token = NULL;
23683 : 154798237 : cp_declarator *declarator;
23684 : 154798237 : tree prefix_attributes;
23685 : 154798237 : tree attributes = NULL;
23686 : 154798237 : tree asm_specification;
23687 : 154798237 : tree initializer;
23688 : 154798237 : tree decl = NULL_TREE;
23689 : 154798237 : tree scope;
23690 : 154798237 : int is_initialized;
23691 : : /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
23692 : : initialized with "= ..", CPP_OPEN_PAREN if initialized with
23693 : : "(...)". */
23694 : 154798237 : enum cpp_ttype initialization_kind;
23695 : 154798237 : bool is_direct_init = false;
23696 : 154798237 : bool is_non_constant_init;
23697 : 154798237 : int ctor_dtor_or_conv_p;
23698 : 309596474 : bool friend_p = cp_parser_friend_p (decl_specifiers);
23699 : 154798237 : bool static_p = decl_specifiers->storage_class == sc_static;
23700 : 154798237 : tree pushed_scope = NULL_TREE;
23701 : 154798237 : bool range_for_decl_p = false;
23702 : 154798237 : bool saved_default_arg_ok_p = parser->default_arg_ok_p;
23703 : 154798237 : location_t tmp_init_loc = UNKNOWN_LOCATION;
23704 : :
23705 : 154798237 : if (decl_spec_seq_has_spec_p (decl_specifiers, ds_consteval))
23706 : 71329 : flags |= CP_PARSER_FLAGS_CONSTEVAL;
23707 : :
23708 : : /* Assume that this is not the declarator for a function
23709 : : definition. */
23710 : 154798237 : if (function_definition_p)
23711 : 154798237 : *function_definition_p = false;
23712 : :
23713 : : /* Default arguments are only permitted for function parameters. */
23714 : 154798237 : if (decl_spec_seq_has_spec_p (decl_specifiers, ds_typedef))
23715 : 12694069 : parser->default_arg_ok_p = false;
23716 : :
23717 : : /* Defer access checks while parsing the declarator; we cannot know
23718 : : what names are accessible until we know what is being
23719 : : declared. */
23720 : 154798237 : resume_deferring_access_checks ();
23721 : :
23722 : 154798237 : token = cp_lexer_peek_token (parser->lexer);
23723 : :
23724 : : /* Parse the declarator. */
23725 : 154798237 : declarator
23726 : 154798237 : = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
23727 : : flags, &ctor_dtor_or_conv_p,
23728 : : /*parenthesized_p=*/NULL,
23729 : : member_p, friend_p, static_p);
23730 : : /* Gather up the deferred checks. */
23731 : 154798237 : stop_deferring_access_checks ();
23732 : :
23733 : 154798237 : parser->default_arg_ok_p = saved_default_arg_ok_p;
23734 : :
23735 : : /* If the DECLARATOR was erroneous, there's no need to go
23736 : : further. */
23737 : 154798237 : if (declarator == cp_error_declarator)
23738 : 262761 : return error_mark_node;
23739 : :
23740 : : /* Check that the number of template-parameter-lists is OK. */
23741 : 154535476 : if (!cp_parser_check_declarator_template_parameters (parser, declarator,
23742 : : token->location))
23743 : 46 : return error_mark_node;
23744 : :
23745 : 154535430 : if (declares_class_or_enum & 2)
23746 : 530598 : cp_parser_check_for_definition_in_return_type (declarator,
23747 : : decl_specifiers->type,
23748 : : decl_specifiers->locations[ds_type_spec]);
23749 : :
23750 : : /* Figure out what scope the entity declared by the DECLARATOR is
23751 : : located in. `grokdeclarator' sometimes changes the scope, so
23752 : : we compute it now. */
23753 : 154535430 : scope = get_scope_of_declarator (declarator);
23754 : :
23755 : : /* Perform any lookups in the declared type which were thought to be
23756 : : dependent, but are not in the scope of the declarator. */
23757 : 154535430 : decl_specifiers->type
23758 : 154535430 : = maybe_update_decl_type (decl_specifiers->type, scope);
23759 : :
23760 : : /* If we're allowing GNU extensions, look for an
23761 : : asm-specification. */
23762 : 154535430 : if (cp_parser_allow_gnu_extensions_p (parser))
23763 : : {
23764 : : /* Look for an asm-specification. */
23765 : 154535430 : asm_spec_start_token = cp_lexer_peek_token (parser->lexer);
23766 : 154535430 : asm_specification = cp_parser_asm_specification_opt (parser);
23767 : : }
23768 : : else
23769 : : asm_specification = NULL_TREE;
23770 : :
23771 : : /* Gather the attributes that were provided with the
23772 : : decl-specifiers. */
23773 : 154535430 : prefix_attributes = decl_specifiers->attributes;
23774 : :
23775 : : /* Look for attributes. */
23776 : 154535430 : attributes_start_token = cp_lexer_peek_token (parser->lexer);
23777 : 154535430 : attributes = cp_parser_attributes_opt (parser);
23778 : :
23779 : : /* Peek at the next token. */
23780 : 154535430 : token = cp_lexer_peek_token (parser->lexer);
23781 : :
23782 : 154535430 : bool bogus_implicit_tmpl = false;
23783 : :
23784 : 154535430 : if (function_declarator_p (declarator))
23785 : : {
23786 : : /* Handle C++17 deduction guides. Note that class-scope
23787 : : non-template deduction guides are instead handled in
23788 : : cp_parser_member_declaration. */
23789 : 89488671 : cp_parser_maybe_adjust_declarator_for_dguide (parser,
23790 : : decl_specifiers,
23791 : : declarator,
23792 : : &ctor_dtor_or_conv_p);
23793 : :
23794 : 89488671 : if (!member_p && !cp_parser_error_occurred (parser))
23795 : 72844815 : warn_about_ambiguous_parse (decl_specifiers, declarator);
23796 : :
23797 : : /* Check to see if the token indicates the start of a
23798 : : function-definition. */
23799 : 89488671 : if (cp_parser_token_starts_function_definition_p (token))
23800 : : {
23801 : 50276186 : if (!function_definition_allowed_p)
23802 : : {
23803 : : /* If a function-definition should not appear here, issue an
23804 : : error message. */
23805 : 12 : cp_parser_error (parser,
23806 : : "a function-definition is not allowed here");
23807 : 12 : return error_mark_node;
23808 : : }
23809 : :
23810 : 50276174 : location_t func_brace_location
23811 : 50276174 : = cp_lexer_peek_token (parser->lexer)->location;
23812 : :
23813 : : /* Neither attributes nor an asm-specification are allowed
23814 : : on a function-definition. */
23815 : 50276174 : if (asm_specification)
23816 : 0 : error_at (asm_spec_start_token->location,
23817 : : "an %<asm%> specification is not allowed "
23818 : : "on a function-definition");
23819 : 50276174 : if (attributes)
23820 : 0 : error_at (attributes_start_token->location,
23821 : : "attributes are not allowed "
23822 : : "on a function-definition");
23823 : : /* This is a function-definition. */
23824 : 50276174 : *function_definition_p = true;
23825 : :
23826 : : /* Parse the function definition. */
23827 : 50276174 : if (member_p)
23828 : 13068887 : decl = cp_parser_save_member_function_body (parser,
23829 : : decl_specifiers,
23830 : : declarator,
23831 : : prefix_attributes);
23832 : : else
23833 : 37207287 : decl =
23834 : : (cp_parser_function_definition_from_specifiers_and_declarator
23835 : 37207287 : (parser, decl_specifiers, prefix_attributes, declarator));
23836 : :
23837 : 100551966 : if (decl != error_mark_node && DECL_STRUCT_FUNCTION (decl))
23838 : : {
23839 : : /* This is where the prologue starts... */
23840 : 37206938 : DECL_STRUCT_FUNCTION (decl)->function_start_locus
23841 : 37206938 : = func_brace_location;
23842 : : }
23843 : :
23844 : 50276150 : return decl;
23845 : : }
23846 : : }
23847 : 65046759 : else if (parser->fully_implicit_function_template_p)
23848 : : {
23849 : : /* A non-template declaration involving a function parameter list
23850 : : containing an implicit template parameter will be made into a
23851 : : template. If the resulting declaration is not going to be an
23852 : : actual function then finish the template scope here to prevent it.
23853 : : An error message will be issued once we have a decl to talk about.
23854 : :
23855 : : FIXME probably we should do type deduction rather than create an
23856 : : implicit template, but the standard currently doesn't allow it. */
23857 : 0 : bogus_implicit_tmpl = true;
23858 : 0 : finish_fully_implicit_template (parser, NULL_TREE);
23859 : : }
23860 : :
23861 : : /* [dcl.dcl]
23862 : :
23863 : : Only in function declarations for constructors, destructors, type
23864 : : conversions, and deduction guides can the decl-specifier-seq be omitted.
23865 : :
23866 : : We explicitly postpone this check past the point where we handle
23867 : : function-definitions because we tolerate function-definitions
23868 : : that are missing their return types in some modes. */
23869 : 104259244 : if (!decl_specifiers->any_specifiers_p && ctor_dtor_or_conv_p <= 0)
23870 : : {
23871 : 47 : cp_parser_error (parser,
23872 : : "expected constructor, destructor, or type conversion");
23873 : 47 : return error_mark_node;
23874 : : }
23875 : :
23876 : : /* An `=' or an '{' in C++11, indicate an initializer. An '(' may indicate
23877 : : an initializer as well. */
23878 : 104259197 : if (token->type == CPP_EQ
23879 : : || token->type == CPP_OPEN_PAREN
23880 : : || token->type == CPP_OPEN_BRACE)
23881 : : {
23882 : : /* Don't get fooled into thinking that F(i)(1)(2) is an initializer.
23883 : : It isn't; it's an expression. (Here '(i)' would have already been
23884 : : parsed as a declarator.) */
23885 : 46618953 : if (token->type == CPP_OPEN_PAREN
23886 : 46618953 : && cp_parser_uncommitted_to_tentative_parse_p (parser))
23887 : : {
23888 : 21 : cp_lexer_save_tokens (parser->lexer);
23889 : 21 : cp_lexer_consume_token (parser->lexer);
23890 : 21 : cp_parser_skip_to_closing_parenthesis (parser,
23891 : : /*recovering*/false,
23892 : : /*or_comma*/false,
23893 : : /*consume_paren*/true);
23894 : : /* If this is an initializer, only a ',' or ';' can follow: either
23895 : : we have another init-declarator, or we're at the end of an
23896 : : init-declarator-list which can only be followed by a ';'. */
23897 : 21 : bool ok = (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
23898 : 21 : || cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
23899 : 21 : cp_lexer_rollback_tokens (parser->lexer);
23900 : 21 : if (UNLIKELY (!ok))
23901 : : /* Not an init-declarator. */
23902 : 12 : return error_mark_node;
23903 : : }
23904 : 46618941 : is_initialized = SD_INITIALIZED;
23905 : 46618941 : initialization_kind = token->type;
23906 : 46618941 : declarator->init_loc = token->location;
23907 : 46618941 : if (maybe_range_for_decl)
23908 : 3457443 : *maybe_range_for_decl = error_mark_node;
23909 : 46618941 : tmp_init_loc = token->location;
23910 : 46618941 : if (init_loc && *init_loc == UNKNOWN_LOCATION)
23911 : 43193088 : *init_loc = tmp_init_loc;
23912 : :
23913 : 46618941 : if (token->type == CPP_EQ
23914 : 46618941 : && function_declarator_p (declarator))
23915 : : {
23916 : 498227 : cp_token *t2 = cp_lexer_peek_nth_token (parser->lexer, 2);
23917 : 498227 : if (t2->keyword == RID_DEFAULT)
23918 : : is_initialized = SD_DEFAULTED;
23919 : 476227 : else if (t2->keyword == RID_DELETE)
23920 : 104189708 : is_initialized = SD_DELETED;
23921 : : }
23922 : : }
23923 : : else
23924 : : {
23925 : : /* If the init-declarator isn't initialized and isn't followed by a
23926 : : `,' or `;', it's not a valid init-declarator. */
23927 : : if (token->type != CPP_COMMA
23928 : : && token->type != CPP_SEMICOLON)
23929 : : {
23930 : 278139 : if (maybe_range_for_decl && *maybe_range_for_decl != error_mark_node)
23931 : : range_for_decl_p = true;
23932 : : else
23933 : : {
23934 : 69471 : if (!maybe_range_for_decl)
23935 : 69471 : cp_parser_error (parser, "expected initializer");
23936 : 69477 : return error_mark_node;
23937 : : }
23938 : : }
23939 : : is_initialized = SD_UNINITIALIZED;
23940 : : initialization_kind = CPP_EOF;
23941 : : }
23942 : :
23943 : : /* Because start_decl has side-effects, we should only call it if we
23944 : : know we're going ahead. By this point, we know that we cannot
23945 : : possibly be looking at any other construct. */
23946 : 104189708 : cp_parser_commit_to_tentative_parse (parser);
23947 : :
23948 : : /* Enter the newly declared entry in the symbol table. If we're
23949 : : processing a declaration in a class-specifier, we wait until
23950 : : after processing the initializer. */
23951 : 104189708 : if (!member_p)
23952 : : {
23953 : 100333887 : if (parser->in_unbraced_linkage_specification_p)
23954 : 312300 : decl_specifiers->storage_class = sc_extern;
23955 : 200459112 : decl = start_decl (declarator, decl_specifiers,
23956 : : range_for_decl_p? SD_INITIALIZED : is_initialized,
23957 : : attributes, prefix_attributes, &pushed_scope);
23958 : 100333884 : cp_finalize_omp_declare_simd (parser, decl);
23959 : 100333884 : cp_finalize_oacc_routine (parser, decl, false);
23960 : : /* Adjust location of decl if declarator->id_loc is more appropriate:
23961 : : set, and decl wasn't merged with another decl, in which case its
23962 : : location would be different from input_location, and more accurate. */
23963 : 100333884 : if (DECL_P (decl)
23964 : 100331377 : && declarator->id_loc != UNKNOWN_LOCATION
23965 : 200660810 : && DECL_SOURCE_LOCATION (decl) == input_location)
23966 : 58475691 : DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
23967 : : }
23968 : 3855821 : else if (scope)
23969 : : /* Enter the SCOPE. That way unqualified names appearing in the
23970 : : initializer will be looked up in SCOPE. */
23971 : 48576 : pushed_scope = push_scope (scope);
23972 : :
23973 : : /* Perform deferred access control checks, now that we know in which
23974 : : SCOPE the declared entity resides. */
23975 : 104189705 : if (!member_p && decl)
23976 : : {
23977 : 100333884 : tree saved_current_function_decl = NULL_TREE;
23978 : :
23979 : : /* If the entity being declared is a function, pretend that we
23980 : : are in its scope. If it is a `friend', it may have access to
23981 : : things that would not otherwise be accessible. */
23982 : 100333884 : if (TREE_CODE (decl) == FUNCTION_DECL)
23983 : : {
23984 : 35600105 : saved_current_function_decl = current_function_decl;
23985 : 35600105 : current_function_decl = decl;
23986 : : }
23987 : :
23988 : : /* Perform access checks for template parameters. */
23989 : 100333884 : cp_parser_perform_template_parameter_access_checks (checks);
23990 : :
23991 : : /* Perform the access control checks for the declarator and the
23992 : : decl-specifiers. */
23993 : 100333884 : perform_deferred_access_checks (tf_warning_or_error);
23994 : :
23995 : : /* Restore the saved value. */
23996 : 100333884 : if (TREE_CODE (decl) == FUNCTION_DECL)
23997 : 35600105 : current_function_decl = saved_current_function_decl;
23998 : : }
23999 : :
24000 : : /* Parse the initializer. */
24001 : 104189705 : initializer = NULL_TREE;
24002 : 104189705 : is_direct_init = false;
24003 : 104189705 : is_non_constant_init = true;
24004 : 104189705 : if (is_initialized)
24005 : : {
24006 : 46618941 : if (function_declarator_p (declarator))
24007 : : {
24008 : 498233 : if (initialization_kind == CPP_EQ)
24009 : 498227 : initializer = cp_parser_pure_specifier (parser);
24010 : : else
24011 : : {
24012 : : /* If the declaration was erroneous, we don't really
24013 : : know what the user intended, so just silently
24014 : : consume the initializer. */
24015 : 6 : if (decl != error_mark_node)
24016 : 6 : error_at (tmp_init_loc, "initializer provided for function");
24017 : 6 : cp_parser_skip_to_closing_parenthesis (parser,
24018 : : /*recovering=*/true,
24019 : : /*or_comma=*/false,
24020 : : /*consume_paren=*/true);
24021 : : }
24022 : : }
24023 : : else
24024 : : {
24025 : : /* We want to record the extra mangling scope for in-class
24026 : : initializers of class members and initializers of static
24027 : : data member templates and namespace-scope initializers.
24028 : : The former involves deferring parsing of the initializer
24029 : : until end of class as with default arguments. So right
24030 : : here we only handle the latter two. */
24031 : 46120708 : bool has_lambda_scope = false;
24032 : :
24033 : 46120708 : if (decl != error_mark_node
24034 : 46120443 : && !member_p
24035 : 91960378 : && (processing_template_decl || DECL_NAMESPACE_SCOPE_P (decl)))
24036 : 43774434 : has_lambda_scope = true;
24037 : :
24038 : 43774434 : if (has_lambda_scope)
24039 : 43774434 : start_lambda_scope (decl);
24040 : 46120708 : initializer = cp_parser_initializer (parser,
24041 : : &is_direct_init,
24042 : : &is_non_constant_init);
24043 : 46120705 : if (has_lambda_scope)
24044 : 43774431 : finish_lambda_scope ();
24045 : 46120705 : if (initializer == error_mark_node)
24046 : 1704 : cp_parser_skip_to_end_of_statement (parser);
24047 : : }
24048 : : }
24049 : :
24050 : : /* The old parser allows attributes to appear after a parenthesized
24051 : : initializer. Mark Mitchell proposed removing this functionality
24052 : : on the GCC mailing lists on 2002-08-13. This parser accepts the
24053 : : attributes -- but ignores them. Made a permerror in GCC 8. */
24054 : 104189702 : if (cp_parser_allow_gnu_extensions_p (parser)
24055 : 104189702 : && initialization_kind == CPP_OPEN_PAREN
24056 : 4811323 : && cp_parser_attributes_opt (parser))
24057 : : {
24058 : 3 : static bool hint;
24059 : 3 : auto_diagnostic_group d;
24060 : 3 : if (permerror (input_location,
24061 : : "attributes after parenthesized initializer ignored")
24062 : 3 : && flag_permissive && !hint)
24063 : : {
24064 : 3 : hint = true;
24065 : 3 : inform (input_location,
24066 : : "this flexibility is deprecated and will be removed");
24067 : : }
24068 : 3 : }
24069 : :
24070 : : /* And now complain about a non-function implicit template. */
24071 : 104189702 : if (bogus_implicit_tmpl && decl != error_mark_node)
24072 : 0 : error_at (DECL_SOURCE_LOCATION (decl),
24073 : : "non-function %qD declared as implicit template", decl);
24074 : :
24075 : : /* For an in-class declaration, use `grokfield' to create the
24076 : : declaration. */
24077 : 104189702 : if (member_p)
24078 : : {
24079 : 3855821 : if (pushed_scope)
24080 : : {
24081 : 48573 : pop_scope (pushed_scope);
24082 : 48573 : pushed_scope = NULL_TREE;
24083 : : }
24084 : 3855821 : decl = grokfield (declarator, decl_specifiers,
24085 : 3855821 : initializer, !is_non_constant_init,
24086 : : /*asmspec=*/NULL_TREE,
24087 : : attr_chainon (attributes, prefix_attributes));
24088 : 3855821 : if (decl && TREE_CODE (decl) == FUNCTION_DECL)
24089 : 3574885 : cp_parser_save_default_args (parser, decl);
24090 : 3855821 : cp_finalize_omp_declare_simd (parser, decl);
24091 : 3855821 : cp_finalize_oacc_routine (parser, decl, false);
24092 : : }
24093 : :
24094 : : /* Finish processing the declaration. But, skip member
24095 : : declarations. */
24096 : 104189702 : if (!member_p && decl && decl != error_mark_node && !range_for_decl_p)
24097 : : {
24098 : 100122712 : cp_finish_decl (decl,
24099 : 100122712 : initializer, !is_non_constant_init,
24100 : : asm_specification,
24101 : : /* If the initializer is in parentheses, then this is
24102 : : a direct-initialization, which means that an
24103 : : `explicit' constructor is OK. Otherwise, an
24104 : : `explicit' constructor cannot be used. */
24105 : 94300214 : ((is_direct_init || !is_initialized)
24106 : : ? LOOKUP_NORMAL : LOOKUP_IMPLICIT));
24107 : 100122712 : check_module_decl_linkage (decl);
24108 : : }
24109 : 4066990 : else if ((cxx_dialect != cxx98) && friend_p
24110 : 4056261 : && decl && TREE_CODE (decl) == FUNCTION_DECL)
24111 : : /* Core issue #226 (C++0x only): A default template-argument
24112 : : shall not be specified in a friend class template
24113 : : declaration. */
24114 : 932128 : check_default_tmpl_args (decl, current_template_parms, /*is_primary=*/true,
24115 : : /*is_partial=*/false, /*is_friend_decl=*/1);
24116 : :
24117 : 104189702 : if (!friend_p && pushed_scope)
24118 : 13720487 : pop_scope (pushed_scope);
24119 : :
24120 : 104189702 : if (function_declarator_p (declarator)
24121 : 104189702 : && parser->fully_implicit_function_template_p)
24122 : : {
24123 : 122 : if (member_p)
24124 : 0 : decl = finish_fully_implicit_template (parser, decl);
24125 : : else
24126 : 122 : finish_fully_implicit_template (parser, /*member_decl_opt=*/0);
24127 : : }
24128 : :
24129 : 43367383 : if (auto_result && is_initialized && decl_specifiers->type
24130 : 146946867 : && type_uses_auto (decl_specifiers->type))
24131 : 6259281 : *auto_result = strip_declarator_types (TREE_TYPE (decl), declarator);
24132 : :
24133 : : return decl;
24134 : : }
24135 : :
24136 : : /* Parse a declarator.
24137 : :
24138 : : declarator:
24139 : : direct-declarator
24140 : : ptr-operator declarator
24141 : :
24142 : : abstract-declarator:
24143 : : ptr-operator abstract-declarator [opt]
24144 : : direct-abstract-declarator
24145 : :
24146 : : GNU Extensions:
24147 : :
24148 : : declarator:
24149 : : attributes [opt] direct-declarator
24150 : : attributes [opt] ptr-operator declarator
24151 : :
24152 : : abstract-declarator:
24153 : : attributes [opt] ptr-operator abstract-declarator [opt]
24154 : : attributes [opt] direct-abstract-declarator
24155 : :
24156 : : The parser flags FLAGS is used to control type-specifier parsing.
24157 : :
24158 : : If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
24159 : : detect constructors, destructors, deduction guides, or conversion operators.
24160 : : It is set to -1 if the declarator is a name, and +1 if it is a
24161 : : function. Otherwise it is set to zero. Usually you just want to
24162 : : test for >0, but internally the negative value is used.
24163 : :
24164 : : (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
24165 : : a decl-specifier-seq unless it declares a constructor, destructor,
24166 : : or conversion. It might seem that we could check this condition in
24167 : : semantic analysis, rather than parsing, but that makes it difficult
24168 : : to handle something like `f()'. We want to notice that there are
24169 : : no decl-specifiers, and therefore realize that this is an
24170 : : expression, not a declaration.)
24171 : :
24172 : : If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
24173 : : the declarator is a direct-declarator of the form "(...)".
24174 : :
24175 : : MEMBER_P is true iff this declarator is a member-declarator.
24176 : :
24177 : : FRIEND_P is true iff this declarator is a friend.
24178 : :
24179 : : STATIC_P is true iff the keyword static was seen. */
24180 : :
24181 : : static cp_declarator *
24182 : 1000316098 : cp_parser_declarator (cp_parser* parser,
24183 : : cp_parser_declarator_kind dcl_kind,
24184 : : cp_parser_flags flags,
24185 : : int* ctor_dtor_or_conv_p,
24186 : : bool* parenthesized_p,
24187 : : bool member_p, bool friend_p, bool static_p)
24188 : : {
24189 : 1000316098 : cp_declarator *declarator;
24190 : 1000316098 : enum tree_code code;
24191 : 1000316098 : cp_cv_quals cv_quals;
24192 : 1000316098 : tree class_type;
24193 : 1000316098 : tree gnu_attributes = NULL_TREE, std_attributes = NULL_TREE;
24194 : :
24195 : : /* Assume this is not a constructor, destructor, or type-conversion
24196 : : operator. */
24197 : 1000316098 : if (ctor_dtor_or_conv_p)
24198 : 264565808 : *ctor_dtor_or_conv_p = 0;
24199 : :
24200 : 1000316098 : if (cp_parser_allow_gnu_extensions_p (parser))
24201 : 1000316098 : gnu_attributes = cp_parser_gnu_attributes_opt (parser);
24202 : :
24203 : : /* Check for the ptr-operator production. */
24204 : 1000316098 : cp_parser_parse_tentatively (parser);
24205 : : /* Parse the ptr-operator. */
24206 : 1000316098 : code = cp_parser_ptr_operator (parser,
24207 : : &class_type,
24208 : : &cv_quals,
24209 : : &std_attributes);
24210 : :
24211 : : /* If that worked, then we have a ptr-operator. */
24212 : 1000316098 : if (cp_parser_parse_definitely (parser))
24213 : : {
24214 : : /* If a ptr-operator was found, then this declarator was not
24215 : : parenthesized. */
24216 : 170214314 : if (parenthesized_p)
24217 : 117605147 : *parenthesized_p = false;
24218 : : /* The dependent declarator is optional if we are parsing an
24219 : : abstract-declarator. */
24220 : 170214314 : if (dcl_kind != CP_PARSER_DECLARATOR_NAMED)
24221 : 136235543 : cp_parser_parse_tentatively (parser);
24222 : :
24223 : : /* Parse the dependent declarator. */
24224 : 170214314 : declarator = cp_parser_declarator (parser, dcl_kind, flags,
24225 : : /*ctor_dtor_or_conv_p=*/NULL,
24226 : : /*parenthesized_p=*/NULL,
24227 : : member_p, friend_p, static_p);
24228 : :
24229 : : /* If we are parsing an abstract-declarator, we must handle the
24230 : : case where the dependent declarator is absent. */
24231 : 170214314 : if (dcl_kind != CP_PARSER_DECLARATOR_NAMED
24232 : 170214314 : && !cp_parser_parse_definitely (parser))
24233 : : declarator = NULL;
24234 : :
24235 : 170214314 : declarator = cp_parser_make_indirect_declarator
24236 : 170214314 : (code, class_type, cv_quals, declarator, std_attributes);
24237 : : }
24238 : : /* Everything else is a direct-declarator. */
24239 : : else
24240 : : {
24241 : 830101784 : if (parenthesized_p)
24242 : 113106494 : *parenthesized_p = cp_lexer_next_token_is (parser->lexer,
24243 : : CPP_OPEN_PAREN);
24244 : 830101784 : declarator = cp_parser_direct_declarator (parser, dcl_kind,
24245 : : flags, ctor_dtor_or_conv_p,
24246 : : member_p, friend_p, static_p);
24247 : : }
24248 : :
24249 : 1000316098 : if (gnu_attributes && declarator && declarator != cp_error_declarator)
24250 : 10711 : declarator->attributes = gnu_attributes;
24251 : 1000316098 : return declarator;
24252 : : }
24253 : :
24254 : : /* Parse a direct-declarator or direct-abstract-declarator.
24255 : :
24256 : : direct-declarator:
24257 : : declarator-id
24258 : : direct-declarator ( parameter-declaration-clause )
24259 : : cv-qualifier-seq [opt]
24260 : : ref-qualifier [opt]
24261 : : exception-specification [opt]
24262 : : direct-declarator [ constant-expression [opt] ]
24263 : : ( declarator )
24264 : :
24265 : : direct-abstract-declarator:
24266 : : direct-abstract-declarator [opt]
24267 : : ( parameter-declaration-clause )
24268 : : cv-qualifier-seq [opt]
24269 : : ref-qualifier [opt]
24270 : : exception-specification [opt]
24271 : : direct-abstract-declarator [opt] [ constant-expression [opt] ]
24272 : : ( abstract-declarator )
24273 : :
24274 : : Returns a representation of the declarator. DCL_KIND is
24275 : : CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
24276 : : direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
24277 : : we are parsing a direct-declarator. It is
24278 : : CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
24279 : : of ambiguity we prefer an abstract declarator, as per
24280 : : [dcl.ambig.res].
24281 : : The parser flags FLAGS is used to control type-specifier parsing.
24282 : : CTOR_DTOR_OR_CONV_P, MEMBER_P, FRIEND_P, and STATIC_P are
24283 : : as for cp_parser_declarator. */
24284 : :
24285 : : static cp_declarator *
24286 : 830101784 : cp_parser_direct_declarator (cp_parser* parser,
24287 : : cp_parser_declarator_kind dcl_kind,
24288 : : cp_parser_flags flags,
24289 : : int* ctor_dtor_or_conv_p,
24290 : : bool member_p, bool friend_p, bool static_p)
24291 : : {
24292 : 830101784 : cp_token *token;
24293 : 830101784 : cp_declarator *declarator = NULL;
24294 : 830101784 : tree scope = NULL_TREE;
24295 : 830101784 : bool saved_default_arg_ok_p = parser->default_arg_ok_p;
24296 : 830101784 : bool saved_in_declarator_p = parser->in_declarator_p;
24297 : 830101784 : bool first = true;
24298 : 830101784 : tree pushed_scope = NULL_TREE;
24299 : 830101784 : cp_token *open_paren = NULL, *close_paren = NULL;
24300 : :
24301 : 1489554454 : while (true)
24302 : : {
24303 : : /* Peek at the next token. */
24304 : 1489554454 : token = cp_lexer_peek_token (parser->lexer);
24305 : 1489554454 : if (token->type == CPP_OPEN_PAREN
24306 : 1489554454 : || (first
24307 : 1316707881 : && dcl_kind != CP_PARSER_DECLARATOR_NAMED
24308 : 559964675 : && token->type == CPP_ELLIPSIS
24309 : 13140773 : && cxx_dialect > cxx98
24310 : 13139589 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN)))
24311 : : {
24312 : : /* This is either a parameter-declaration-clause, or a
24313 : : parenthesized declarator. When we know we are parsing a
24314 : : named declarator, it must be a parenthesized declarator
24315 : : if FIRST is true. For instance, `(int)' is a
24316 : : parameter-declaration-clause, with an omitted
24317 : : direct-abstract-declarator. But `((*))', is a
24318 : : parenthesized abstract declarator. Finally, when T is a
24319 : : template parameter `(T)' is a
24320 : : parameter-declaration-clause, and not a parenthesized
24321 : : named declarator.
24322 : :
24323 : : We first try and parse a parameter-declaration-clause,
24324 : : and then try a nested declarator (if FIRST is true).
24325 : :
24326 : : It is not an error for it not to be a
24327 : : parameter-declaration-clause, even when FIRST is
24328 : : false. Consider,
24329 : :
24330 : : int i (int);
24331 : : int i (3);
24332 : :
24333 : : The first is the declaration of a function while the
24334 : : second is the definition of a variable, including its
24335 : : initializer.
24336 : :
24337 : : Having seen only the parenthesis, we cannot know which of
24338 : : these two alternatives should be selected. Even more
24339 : : complex are examples like:
24340 : :
24341 : : int i (int (a));
24342 : : int i (int (3));
24343 : :
24344 : : The former is a function-declaration; the latter is a
24345 : : variable initialization.
24346 : :
24347 : : Thus again, we try a parameter-declaration-clause, and if
24348 : : that fails, we back out and return. */
24349 : 172846576 : bool pack_expansion_p = token->type == CPP_ELLIPSIS;
24350 : :
24351 : 172846576 : if (pack_expansion_p)
24352 : : /* Consume the `...' */
24353 : 3 : cp_lexer_consume_token (parser->lexer);
24354 : :
24355 : 172846576 : if (!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
24356 : : {
24357 : 171902573 : tree params;
24358 : 171902573 : bool is_declarator = false;
24359 : :
24360 : 171902573 : open_paren = NULL;
24361 : :
24362 : : /* In a member-declarator, the only valid interpretation
24363 : : of a parenthesis is the start of a
24364 : : parameter-declaration-clause. (It is invalid to
24365 : : initialize a static data member with a parenthesized
24366 : : initializer; only the "=" form of initialization is
24367 : : permitted.) */
24368 : 171902573 : if (!member_p)
24369 : 83910276 : cp_parser_parse_tentatively (parser);
24370 : :
24371 : : /* Consume the `('. */
24372 : 171902573 : const location_t parens_start = token->location;
24373 : 171902573 : matching_parens parens;
24374 : 171902573 : parens.consume_open (parser);
24375 : 171902573 : if (first)
24376 : : {
24377 : : /* If this is going to be an abstract declarator, we're
24378 : : in a declarator and we can't have default args. */
24379 : 2628049 : parser->default_arg_ok_p = false;
24380 : 2628049 : parser->in_declarator_p = true;
24381 : : }
24382 : :
24383 : 171902573 : begin_scope (sk_function_parms, NULL_TREE);
24384 : :
24385 : : /* Parse the parameter-declaration-clause. */
24386 : 171902573 : params
24387 : 171902573 : = cp_parser_parameter_declaration_clause (parser, flags,
24388 : : /*lambda_p=*/false);
24389 : 171902573 : const location_t parens_end
24390 : 171902573 : = cp_lexer_peek_token (parser->lexer)->location;
24391 : :
24392 : : /* Consume the `)'. */
24393 : 171902573 : parens.require_close (parser);
24394 : :
24395 : : /* For code like
24396 : : int x(auto(42));
24397 : : A a(auto(i), 42);
24398 : : we have synthesized an implicit template parameter and marked
24399 : : what we thought was a function as an implicit function template.
24400 : : But now, having seen the whole parameter list, we know it's not
24401 : : a function declaration, so undo that. */
24402 : 350776170 : if (cp_parser_error_occurred (parser)
24403 : 6971024 : && parser->fully_implicit_function_template_p
24404 : : /* Don't do this for the inner (). */
24405 : 82 : && parser->default_arg_ok_p)
24406 : 20 : abort_fully_implicit_template (parser);
24407 : :
24408 : : /* If all went well, parse the cv-qualifier-seq,
24409 : : ref-qualifier and the exception-specification. */
24410 : 171902573 : if (member_p || cp_parser_parse_definitely (parser))
24411 : : {
24412 : 164931549 : cp_cv_quals cv_quals;
24413 : 164931549 : cp_virt_specifiers virt_specifiers;
24414 : 164931549 : cp_ref_qualifier ref_qual;
24415 : 164931549 : tree exception_specification;
24416 : 164931549 : tree late_return;
24417 : 164931549 : tree attrs;
24418 : 164931549 : bool memfn = (member_p || (pushed_scope
24419 : 8761032 : && CLASS_TYPE_P (pushed_scope)));
24420 : 164931549 : unsigned char local_variables_forbidden_p
24421 : : = parser->local_variables_forbidden_p;
24422 : : /* 'this' is not allowed in static member functions. */
24423 : 164931549 : if (static_p || friend_p)
24424 : 11711938 : parser->local_variables_forbidden_p |= THIS_FORBIDDEN;
24425 : :
24426 : 164931549 : is_declarator = true;
24427 : :
24428 : 164931549 : if (ctor_dtor_or_conv_p)
24429 : 140582325 : *ctor_dtor_or_conv_p = *ctor_dtor_or_conv_p < 0;
24430 : 164931549 : first = false;
24431 : :
24432 : : /* Parse the cv-qualifier-seq. */
24433 : 164931549 : cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
24434 : : /* Parse the ref-qualifier. */
24435 : 164931549 : ref_qual = cp_parser_ref_qualifier_opt (parser);
24436 : : /* Parse the tx-qualifier. */
24437 : 164931549 : tree tx_qual = cp_parser_tx_qualifier_opt (parser);
24438 : :
24439 : 164931549 : tree save_ccp = current_class_ptr;
24440 : 164931549 : tree save_ccr = current_class_ref;
24441 : 164931549 : if (memfn && !friend_p && !static_p)
24442 : : /* DR 1207: 'this' is in scope after the cv-quals. */
24443 : 85144577 : inject_this_parameter (current_class_type, cv_quals);
24444 : :
24445 : : /* If it turned out that this is e.g. a pointer to a
24446 : : function, we don't want to delay noexcept parsing. */
24447 : 164931549 : if (declarator == NULL || declarator->kind != cdk_id)
24448 : 2331889 : flags &= ~CP_PARSER_FLAGS_DELAY_NOEXCEPT;
24449 : :
24450 : : /* Parse the exception-specification. */
24451 : 164931549 : exception_specification
24452 : 164931549 : = cp_parser_exception_specification_opt (parser,
24453 : : flags);
24454 : :
24455 : 164931549 : attrs = cp_parser_std_attribute_spec_seq (parser);
24456 : :
24457 : 164931549 : cp_omp_declare_simd_data odsd;
24458 : 164931549 : if ((flag_openmp || flag_openmp_simd)
24459 : 217154 : && declarator
24460 : 216790 : && declarator->std_attributes
24461 : 313 : && declarator->kind == cdk_id)
24462 : : {
24463 : 313 : tree *pa = &declarator->std_attributes;
24464 : 313 : cp_parser_handle_directive_omp_attributes (parser, pa,
24465 : : &odsd, false);
24466 : : }
24467 : :
24468 : : /* In here, we handle cases where attribute is used after
24469 : : the function declaration. For example:
24470 : : void func (int x) __attribute__((vector(..))); */
24471 : 164931549 : tree gnu_attrs = NULL_TREE;
24472 : 164931549 : tree requires_clause = NULL_TREE;
24473 : 164931549 : late_return
24474 : 164931549 : = cp_parser_late_return_type_opt (parser, declarator,
24475 : : requires_clause, params);
24476 : :
24477 : 164931549 : cp_finalize_omp_declare_simd (parser, &odsd);
24478 : :
24479 : : /* Parse the virt-specifier-seq. */
24480 : 164931549 : virt_specifiers = cp_parser_virt_specifier_seq_opt (parser);
24481 : :
24482 : 164931549 : location_t parens_loc = make_location (parens_start,
24483 : : parens_start,
24484 : : parens_end);
24485 : : /* Create the function-declarator. */
24486 : 164931549 : declarator = make_call_declarator (declarator,
24487 : : params,
24488 : : cv_quals,
24489 : : virt_specifiers,
24490 : : ref_qual,
24491 : : tx_qual,
24492 : : exception_specification,
24493 : : late_return,
24494 : : requires_clause,
24495 : : attrs,
24496 : : parens_loc);
24497 : 164931549 : declarator->attributes = gnu_attrs;
24498 : 164931549 : declarator->parameter_pack_p |= pack_expansion_p;
24499 : : /* Any subsequent parameter lists are to do with
24500 : : return type, so are not those of the declared
24501 : : function. */
24502 : 164931549 : parser->default_arg_ok_p = false;
24503 : :
24504 : 164931549 : current_class_ptr = save_ccp;
24505 : 164931549 : current_class_ref = save_ccr;
24506 : :
24507 : : /* Restore the state of local_variables_forbidden_p. */
24508 : 164931549 : parser->local_variables_forbidden_p
24509 : 164931549 : = local_variables_forbidden_p;
24510 : : }
24511 : :
24512 : : /* Remove the function parms from scope. */
24513 : 171902573 : pop_bindings_and_leave_scope ();
24514 : :
24515 : 6971024 : if (is_declarator)
24516 : : /* Repeat the main loop. */
24517 : 164931549 : continue;
24518 : : }
24519 : :
24520 : : /* If this is the first, we can try a parenthesized
24521 : : declarator. */
24522 : 7915027 : if (first && !pack_expansion_p)
24523 : : {
24524 : 3092207 : bool saved_in_type_id_in_expr_p;
24525 : :
24526 : 3092207 : parser->default_arg_ok_p = saved_default_arg_ok_p;
24527 : 3092207 : parser->in_declarator_p = saved_in_declarator_p;
24528 : :
24529 : 3092207 : open_paren = token;
24530 : : /* Consume the `('. */
24531 : 3092207 : matching_parens parens;
24532 : 3092207 : parens.consume_open (parser);
24533 : : /* Parse the nested declarator. */
24534 : 3092207 : saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
24535 : 3092207 : parser->in_type_id_in_expr_p = true;
24536 : 3092207 : declarator
24537 : 3092207 : = cp_parser_declarator (parser, dcl_kind, flags,
24538 : : ctor_dtor_or_conv_p,
24539 : : /*parenthesized_p=*/NULL,
24540 : : member_p, friend_p,
24541 : : /*static_p=*/false);
24542 : 3092207 : parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
24543 : 3092207 : first = false;
24544 : : /* Expect a `)'. */
24545 : 3092207 : close_paren = cp_lexer_peek_token (parser->lexer);
24546 : 3092207 : if (!parens.require_close (parser))
24547 : 596889 : declarator = cp_error_declarator;
24548 : 3092207 : if (declarator == cp_error_declarator)
24549 : : break;
24550 : :
24551 : 2401924 : goto handle_declarator;
24552 : : }
24553 : : /* Otherwise, we must be done. */
24554 : : else
24555 : : break;
24556 : : }
24557 : 1316707878 : else if ((!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
24558 : 1050142818 : && token->type == CPP_OPEN_SQUARE
24559 : 1319671083 : && !cp_next_tokens_can_be_attribute_p (parser))
24560 : : {
24561 : : /* Parse an array-declarator. */
24562 : 2963202 : tree bounds, attrs;
24563 : :
24564 : 2963202 : if (ctor_dtor_or_conv_p)
24565 : 1511544 : *ctor_dtor_or_conv_p = 0;
24566 : :
24567 : 2963202 : open_paren = NULL;
24568 : 2963202 : first = false;
24569 : 2963202 : parser->default_arg_ok_p = false;
24570 : 2963202 : parser->in_declarator_p = true;
24571 : : /* Consume the `['. */
24572 : 2963202 : cp_lexer_consume_token (parser->lexer);
24573 : : /* Peek at the next token. */
24574 : 2963202 : token = cp_lexer_peek_token (parser->lexer);
24575 : : /* If the next token is `]', then there is no
24576 : : constant-expression. */
24577 : 2963202 : if (token->type != CPP_CLOSE_SQUARE)
24578 : : {
24579 : 2282419 : bool non_constant_p;
24580 : 2282419 : bounds
24581 : 2282419 : = cp_parser_constant_expression (parser,
24582 : : /*allow_non_constant=*/true,
24583 : : &non_constant_p);
24584 : 2282419 : if (!non_constant_p)
24585 : : /* OK */;
24586 : 1404 : else if (error_operand_p (bounds))
24587 : : /* Already gave an error. */;
24588 : 2282419 : else if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
24589 : : /* Let compute_array_index_type diagnose this. */;
24590 : 227 : else if (!parser->in_function_body
24591 : 227 : || parsing_function_declarator ())
24592 : : {
24593 : : /* Normally, the array bound must be an integral constant
24594 : : expression. However, as an extension, we allow VLAs
24595 : : in function scopes as long as they aren't part of a
24596 : : parameter declaration. */
24597 : 7 : cp_parser_error (parser,
24598 : : "array bound is not an integer constant");
24599 : 7 : bounds = error_mark_node;
24600 : : }
24601 : 220 : else if (processing_template_decl
24602 : 220 : && !type_dependent_expression_p (bounds))
24603 : : {
24604 : : /* Remember this wasn't a constant-expression. */
24605 : 5 : bounds = build_nop (TREE_TYPE (bounds), bounds);
24606 : 5 : TREE_SIDE_EFFECTS (bounds) = 1;
24607 : : }
24608 : : }
24609 : : else
24610 : : bounds = NULL_TREE;
24611 : : /* Look for the closing `]'. */
24612 : 2963202 : if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
24613 : : {
24614 : 9 : declarator = cp_error_declarator;
24615 : 9 : break;
24616 : : }
24617 : :
24618 : 2963193 : attrs = cp_parser_std_attribute_spec_seq (parser);
24619 : 2963193 : declarator = make_array_declarator (declarator, bounds, attrs);
24620 : : }
24621 : 1313744676 : else if (first && dcl_kind != CP_PARSER_DECLARATOR_ABSTRACT)
24622 : : {
24623 : 509593669 : {
24624 : 509593669 : tree qualifying_scope;
24625 : 509593669 : tree unqualified_name;
24626 : 509593669 : tree attrs;
24627 : 509593669 : special_function_kind sfk;
24628 : 509593669 : bool abstract_ok;
24629 : 509593669 : bool pack_expansion_p = false;
24630 : 509593669 : cp_token *declarator_id_start_token;
24631 : :
24632 : : /* Parse a declarator-id */
24633 : 509593669 : abstract_ok = (dcl_kind == CP_PARSER_DECLARATOR_EITHER);
24634 : 509593669 : if (abstract_ok)
24635 : : {
24636 : 243028609 : cp_parser_parse_tentatively (parser);
24637 : :
24638 : : /* If we see an ellipsis, we should be looking at a
24639 : : parameter pack. */
24640 : 243028609 : if (token->type == CPP_ELLIPSIS)
24641 : : {
24642 : : /* Consume the `...' */
24643 : 4542402 : cp_lexer_consume_token (parser->lexer);
24644 : :
24645 : 4542402 : pack_expansion_p = true;
24646 : : }
24647 : : }
24648 : :
24649 : 509593669 : declarator_id_start_token = cp_lexer_peek_token (parser->lexer);
24650 : 509593669 : unqualified_name
24651 : 509593669 : = cp_parser_declarator_id (parser, /*optional_p=*/abstract_ok);
24652 : 509593669 : qualifying_scope = parser->scope;
24653 : 509593669 : if (abstract_ok)
24654 : : {
24655 : 243028609 : bool okay = false;
24656 : :
24657 : 243028609 : if (!unqualified_name && pack_expansion_p)
24658 : : {
24659 : : /* Check whether an error occurred. */
24660 : 2726700 : okay = !cp_parser_error_occurred (parser);
24661 : :
24662 : : /* We already consumed the ellipsis to mark a
24663 : : parameter pack, but we have no way to report it,
24664 : : so abort the tentative parse. We will be exiting
24665 : : immediately anyway. */
24666 : 1363350 : cp_parser_abort_tentative_parse (parser);
24667 : : }
24668 : : else
24669 : 241665259 : okay = cp_parser_parse_definitely (parser);
24670 : :
24671 : 243028609 : if (!okay)
24672 : 1 : unqualified_name = error_mark_node;
24673 : 243028608 : else if (unqualified_name
24674 : 243028608 : && (qualifying_scope
24675 : 509593678 : || (!identifier_p (unqualified_name))))
24676 : : {
24677 : 9 : cp_parser_error (parser, "expected unqualified-id");
24678 : 9 : unqualified_name = error_mark_node;
24679 : : }
24680 : : }
24681 : :
24682 : 509593669 : if (!unqualified_name)
24683 : : return NULL;
24684 : 489543905 : if (unqualified_name == error_mark_node)
24685 : : {
24686 : 195982 : declarator = cp_error_declarator;
24687 : 195982 : pack_expansion_p = false;
24688 : 195982 : declarator->parameter_pack_p = false;
24689 : 195982 : break;
24690 : : }
24691 : :
24692 : 489347923 : attrs = cp_parser_std_attribute_spec_seq (parser);
24693 : :
24694 : 9413851 : if (qualifying_scope && at_namespace_scope_p ()
24695 : 498479944 : && TREE_CODE (qualifying_scope) == TYPENAME_TYPE)
24696 : : {
24697 : : /* In the declaration of a member of a template class
24698 : : outside of the class itself, the SCOPE will sometimes
24699 : : be a TYPENAME_TYPE. For example, given:
24700 : :
24701 : : template <typename T>
24702 : : int S<T>::R::i = 3;
24703 : :
24704 : : the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
24705 : : this context, we must resolve S<T>::R to an ordinary
24706 : : type, rather than a typename type.
24707 : :
24708 : : The reason we normally avoid resolving TYPENAME_TYPEs
24709 : : is that a specialization of `S' might render
24710 : : `S<T>::R' not a type. However, if `S' is
24711 : : specialized, then this `i' will not be used, so there
24712 : : is no harm in resolving the types here. */
24713 : 15 : tree type;
24714 : :
24715 : : /* Resolve the TYPENAME_TYPE. */
24716 : 15 : type = resolve_typename_type (qualifying_scope,
24717 : : /*only_current_p=*/false);
24718 : : /* If that failed, the declarator is invalid. */
24719 : 15 : if (TREE_CODE (type) == TYPENAME_TYPE)
24720 : : {
24721 : 15 : if (typedef_variant_p (type))
24722 : 4 : error_at (declarator_id_start_token->location,
24723 : : "cannot define member of dependent typedef "
24724 : : "%qT", type);
24725 : : else
24726 : 22 : error_at (declarator_id_start_token->location,
24727 : : "%<%T::%E%> is not a type",
24728 : 11 : TYPE_CONTEXT (qualifying_scope),
24729 : 11 : TYPE_IDENTIFIER (qualifying_scope));
24730 : : }
24731 : : qualifying_scope = type;
24732 : : }
24733 : :
24734 : 489347923 : sfk = sfk_none;
24735 : :
24736 : 489347923 : if (unqualified_name)
24737 : : {
24738 : 489347923 : tree class_type;
24739 : :
24740 : 489347923 : if (qualifying_scope
24741 : 489347923 : && CLASS_TYPE_P (qualifying_scope))
24742 : : class_type = qualifying_scope;
24743 : : else
24744 : 480219544 : class_type = current_class_type;
24745 : :
24746 : 489347923 : if (TREE_CODE (unqualified_name) == TYPE_DECL)
24747 : : {
24748 : 101 : tree name_type = TREE_TYPE (unqualified_name);
24749 : :
24750 : 101 : if (!class_type || !same_type_p (name_type, class_type))
24751 : : {
24752 : : /* We do not attempt to print the declarator
24753 : : here because we do not have enough
24754 : : information about its original syntactic
24755 : : form. */
24756 : 66 : cp_parser_error (parser, "invalid declarator");
24757 : 66 : declarator = cp_error_declarator;
24758 : 66 : break;
24759 : : }
24760 : 35 : else if (qualifying_scope
24761 : 35 : && CLASSTYPE_USE_TEMPLATE (name_type))
24762 : : {
24763 : 0 : auto_diagnostic_group d;
24764 : 0 : error_at (declarator_id_start_token->location,
24765 : : "invalid use of constructor as a template");
24766 : 0 : inform (declarator_id_start_token->location,
24767 : : "use %<%T::%D%> instead of %<%T::%D%> to "
24768 : : "name the constructor in a qualified name",
24769 : : class_type,
24770 : 0 : DECL_NAME (TYPE_TI_TEMPLATE (class_type)),
24771 : : class_type, name_type);
24772 : 0 : declarator = cp_error_declarator;
24773 : 0 : break;
24774 : 0 : }
24775 : 35 : unqualified_name = constructor_name (class_type);
24776 : : }
24777 : :
24778 : 489347857 : if (class_type)
24779 : : {
24780 : 262872348 : if (TREE_CODE (unqualified_name) == BIT_NOT_EXPR)
24781 : : sfk = sfk_destructor;
24782 : 259891051 : else if (identifier_p (unqualified_name)
24783 : 259783359 : && IDENTIFIER_CONV_OP_P (unqualified_name))
24784 : : sfk = sfk_conversion;
24785 : 259307780 : else if (/* There's no way to declare a constructor
24786 : : for an unnamed type, even if the type
24787 : : got a name for linkage purposes. */
24788 : 259307780 : !TYPE_WAS_UNNAMED (class_type)
24789 : : /* Handle correctly (c++/19200):
24790 : :
24791 : : struct S {
24792 : : struct T{};
24793 : : friend void S(T);
24794 : : };
24795 : :
24796 : : and also:
24797 : :
24798 : : namespace N {
24799 : : void S();
24800 : : }
24801 : :
24802 : : struct S {
24803 : : friend void N::S();
24804 : : }; */
24805 : 259307774 : && (!friend_p || class_type == qualifying_scope)
24806 : 515013065 : && constructor_name_p (unqualified_name,
24807 : : class_type))
24808 : : sfk = sfk_constructor;
24809 : 238392713 : else if (is_overloaded_fn (unqualified_name)
24810 : 238420697 : && DECL_CONSTRUCTOR_P (get_first_fn
24811 : : (unqualified_name)))
24812 : : sfk = sfk_constructor;
24813 : :
24814 : 262872348 : if (ctor_dtor_or_conv_p && sfk != sfk_none)
24815 : 24479480 : *ctor_dtor_or_conv_p = -1;
24816 : : }
24817 : : }
24818 : 489347857 : declarator = make_id_declarator (qualifying_scope,
24819 : : unqualified_name,
24820 : : sfk, token->location);
24821 : 489347857 : declarator->std_attributes = attrs;
24822 : 489347857 : declarator->parameter_pack_p = pack_expansion_p;
24823 : :
24824 : 489347857 : if (pack_expansion_p)
24825 : 3179052 : maybe_warn_variadic_templates ();
24826 : :
24827 : : /* We're looking for this case in [temp.res]:
24828 : : A qualified-id is assumed to name a type if [...]
24829 : : - it is a decl-specifier of the decl-specifier-seq of a
24830 : : parameter-declaration in a declarator of a function or
24831 : : function template declaration, ... */
24832 : 489347857 : if (cxx_dialect >= cxx20
24833 : 125534767 : && (flags & CP_PARSER_FLAGS_TYPENAME_OPTIONAL)
24834 : 42644179 : && declarator->kind == cdk_id
24835 : 42644179 : && !at_class_scope_p ()
24836 : 498013579 : && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
24837 : : {
24838 : : /* ...whose declarator-id is qualified. If it isn't, never
24839 : : assume the parameters to refer to types. */
24840 : 7658714 : if (qualifying_scope == NULL_TREE)
24841 : 5969571 : flags &= ~CP_PARSER_FLAGS_TYPENAME_OPTIONAL;
24842 : : else
24843 : : {
24844 : : /* Now we have something like
24845 : : template <typename T> int C::x(S::p);
24846 : : which can be a function template declaration or a
24847 : : variable template definition. If name lookup for
24848 : : the declarator-id C::x finds one or more function
24849 : : templates, assume S::p to name a type. Otherwise,
24850 : : don't. */
24851 : 1689143 : tree decl
24852 : 1689143 : = cp_parser_lookup_name (parser, unqualified_name,
24853 : : none_type,
24854 : : /*is_template=*/false,
24855 : : /*is_namespace=*/false,
24856 : : /*check_dependency=*/false,
24857 : : /*ambiguous_decls=*/NULL,
24858 : : token->location);
24859 : :
24860 : 1689143 : if (!is_overloaded_fn (decl)
24861 : : /* Allow
24862 : : template<typename T>
24863 : : A<T>::A(T::type) { } */
24864 : 1689187 : && !(MAYBE_CLASS_TYPE_P (qualifying_scope)
24865 : 44 : && constructor_name_p (unqualified_name,
24866 : : qualifying_scope)))
24867 : 52 : flags &= ~CP_PARSER_FLAGS_TYPENAME_OPTIONAL;
24868 : : }
24869 : : }
24870 : : }
24871 : :
24872 : 491749781 : handle_declarator:;
24873 : 491749781 : scope = get_scope_of_declarator (declarator);
24874 : 491749781 : if (scope)
24875 : : {
24876 : : /* Any names that appear after the declarator-id for a
24877 : : member are looked up in the containing scope. */
24878 : 9413942 : if (at_function_scope_p ())
24879 : : {
24880 : : /* But declarations with qualified-ids can't appear in a
24881 : : function. */
24882 : 191853 : cp_parser_error (parser, "qualified-id in declaration");
24883 : 191853 : declarator = cp_error_declarator;
24884 : 191853 : break;
24885 : : }
24886 : 9222089 : pushed_scope = push_scope (scope);
24887 : : }
24888 : 491557928 : parser->in_declarator_p = true;
24889 : 491557928 : if ((ctor_dtor_or_conv_p && *ctor_dtor_or_conv_p)
24890 : 467078448 : || (declarator && declarator->kind == cdk_id))
24891 : : /* Default args are only allowed on function
24892 : : declarations. */
24893 : 489255373 : parser->default_arg_ok_p = saved_default_arg_ok_p;
24894 : : else
24895 : 2302555 : parser->default_arg_ok_p = false;
24896 : :
24897 : : first = false;
24898 : : }
24899 : : /* We're done. */
24900 : : else
24901 : : break;
24902 : : }
24903 : :
24904 : : /* For an abstract declarator, we might wind up with nothing at this
24905 : : point. That's an error; the declarator is not optional. */
24906 : 810052020 : if (!declarator)
24907 : 316656601 : cp_parser_error (parser, "expected declarator");
24908 : 493395419 : else if (open_paren)
24909 : : {
24910 : : /* Record overly parenthesized declarator so we can give a
24911 : : diagnostic about confusing decl/expr disambiguation. */
24912 : 789868 : if (declarator->kind == cdk_array)
24913 : : {
24914 : : /* If the open and close parens are on different lines, this
24915 : : is probably a formatting thing, so ignore. */
24916 : 31 : expanded_location open = expand_location (open_paren->location);
24917 : 31 : expanded_location close = expand_location (close_paren->location);
24918 : 31 : if (open.line != close.line || open.file != close.file)
24919 : 6 : open_paren = NULL;
24920 : : }
24921 : 6 : if (open_paren)
24922 : 789862 : declarator->parenthesized = make_location (open_paren->location,
24923 : : open_paren->location,
24924 : : close_paren->location);
24925 : : }
24926 : :
24927 : : /* If we entered a scope, we must exit it now. */
24928 : 810052020 : if (pushed_scope)
24929 : 9222035 : pop_scope (pushed_scope);
24930 : :
24931 : 810052020 : parser->default_arg_ok_p = saved_default_arg_ok_p;
24932 : 810052020 : parser->in_declarator_p = saved_in_declarator_p;
24933 : :
24934 : 810052020 : return declarator;
24935 : : }
24936 : :
24937 : : /* Parse a ptr-operator.
24938 : :
24939 : : ptr-operator:
24940 : : * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
24941 : : * cv-qualifier-seq [opt]
24942 : : &
24943 : : :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
24944 : : nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
24945 : :
24946 : : GNU Extension:
24947 : :
24948 : : ptr-operator:
24949 : : & cv-qualifier-seq [opt]
24950 : :
24951 : : Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
24952 : : Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
24953 : : an rvalue reference. In the case of a pointer-to-member, *TYPE is
24954 : : filled in with the TYPE containing the member. *CV_QUALS is
24955 : : filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
24956 : : are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
24957 : : Note that the tree codes returned by this function have nothing
24958 : : to do with the types of trees that will be eventually be created
24959 : : to represent the pointer or reference type being parsed. They are
24960 : : just constants with suggestive names. */
24961 : : static enum tree_code
24962 : 1002555956 : cp_parser_ptr_operator (cp_parser* parser,
24963 : : tree* type,
24964 : : cp_cv_quals *cv_quals,
24965 : : tree *attributes)
24966 : : {
24967 : 1002555956 : enum tree_code code = ERROR_MARK;
24968 : 1002555956 : cp_token *token;
24969 : 1002555956 : tree attrs = NULL_TREE;
24970 : :
24971 : : /* Assume that it's not a pointer-to-member. */
24972 : 1002555956 : *type = NULL_TREE;
24973 : : /* And that there are no cv-qualifiers. */
24974 : 1002555956 : *cv_quals = TYPE_UNQUALIFIED;
24975 : :
24976 : : /* Peek at the next token. */
24977 : 1002555956 : token = cp_lexer_peek_token (parser->lexer);
24978 : :
24979 : : /* If it's a `*', `&' or `&&' we have a pointer or reference. */
24980 : 1002555956 : if (token->type == CPP_MULT)
24981 : : code = INDIRECT_REF;
24982 : 944702731 : else if (token->type == CPP_AND)
24983 : : code = ADDR_EXPR;
24984 : 849630095 : else if ((cxx_dialect != cxx98) &&
24985 : : token->type == CPP_AND_AND) /* C++0x only */
24986 : : code = NON_LVALUE_EXPR;
24987 : :
24988 : : if (code != ERROR_MARK)
24989 : : {
24990 : : /* Consume the `*', `&' or `&&'. */
24991 : 169162484 : cp_lexer_consume_token (parser->lexer);
24992 : :
24993 : : /* A `*' can be followed by a cv-qualifier-seq, and so can a
24994 : : `&', if we are allowing GNU extensions. (The only qualifier
24995 : : that can legally appear after `&' is `restrict', but that is
24996 : : enforced during semantic analysis. */
24997 : 169162484 : if (code == INDIRECT_REF
24998 : 169162484 : || cp_parser_allow_gnu_extensions_p (parser))
24999 : 169162484 : *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
25000 : :
25001 : 169162484 : attrs = cp_parser_std_attribute_spec_seq (parser);
25002 : 169162484 : if (attributes != NULL)
25003 : 169162484 : *attributes = attrs;
25004 : : }
25005 : : else
25006 : : {
25007 : : /* Try the pointer-to-member case. */
25008 : 833393472 : cp_parser_parse_tentatively (parser);
25009 : : /* Look for the optional `::' operator. */
25010 : 833393472 : cp_parser_global_scope_opt (parser,
25011 : : /*current_scope_valid_p=*/false);
25012 : : /* Look for the nested-name specifier. */
25013 : 833393472 : token = cp_lexer_peek_token (parser->lexer);
25014 : 833393472 : cp_parser_nested_name_specifier (parser,
25015 : : /*typename_keyword_p=*/false,
25016 : : /*check_dependency_p=*/true,
25017 : : /*type_p=*/false,
25018 : : /*is_declaration=*/false);
25019 : : /* If we found it, and the next token is a `*', then we are
25020 : : indeed looking at a pointer-to-member operator. */
25021 : 1677374665 : if (!cp_parser_error_occurred (parser)
25022 : 10587721 : && cp_parser_require (parser, CPP_MULT, RT_MULT))
25023 : : {
25024 : : /* Indicate that the `*' operator was used. */
25025 : 1136990 : code = INDIRECT_REF;
25026 : :
25027 : 1136990 : if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
25028 : 6 : error_at (token->location, "%qD is a namespace", parser->scope);
25029 : 1136984 : else if (TREE_CODE (parser->scope) == ENUMERAL_TYPE)
25030 : 2 : error_at (token->location, "cannot form pointer to member of "
25031 : : "non-class %q#T", parser->scope);
25032 : : else
25033 : : {
25034 : : /* The type of which the member is a member is given by the
25035 : : current SCOPE. */
25036 : 1136982 : *type = parser->scope;
25037 : : /* The next name will not be qualified. */
25038 : 1136982 : parser->scope = NULL_TREE;
25039 : 1136982 : parser->qualifying_scope = NULL_TREE;
25040 : 1136982 : parser->object_scope = NULL_TREE;
25041 : : /* Look for optional c++11 attributes. */
25042 : 1136982 : attrs = cp_parser_std_attribute_spec_seq (parser);
25043 : 1136982 : if (attributes != NULL)
25044 : 1136982 : *attributes = attrs;
25045 : : /* Look for the optional cv-qualifier-seq. */
25046 : 1136982 : *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
25047 : : }
25048 : : }
25049 : : /* If that didn't work we don't have a ptr-operator. */
25050 : 833393472 : if (!cp_parser_parse_definitely (parser))
25051 : 832256482 : cp_parser_error (parser, "expected ptr-operator");
25052 : : }
25053 : :
25054 : 1002555956 : return code;
25055 : : }
25056 : :
25057 : : /* Parse an (optional) cv-qualifier-seq.
25058 : :
25059 : : cv-qualifier-seq:
25060 : : cv-qualifier cv-qualifier-seq [opt]
25061 : :
25062 : : cv-qualifier:
25063 : : const
25064 : : volatile
25065 : :
25066 : : GNU Extension:
25067 : :
25068 : : cv-qualifier:
25069 : : __restrict__
25070 : :
25071 : : Returns a bitmask representing the cv-qualifiers. */
25072 : :
25073 : : static cp_cv_quals
25074 : 335231015 : cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
25075 : : {
25076 : 335231015 : cp_cv_quals cv_quals = TYPE_UNQUALIFIED;
25077 : :
25078 : 371162519 : while (true)
25079 : : {
25080 : 371162519 : cp_token *token;
25081 : 371162519 : cp_cv_quals cv_qualifier;
25082 : :
25083 : : /* Peek at the next token. */
25084 : 371162519 : token = cp_lexer_peek_token (parser->lexer);
25085 : : /* See if it's a cv-qualifier. */
25086 : 371162519 : switch (token->keyword)
25087 : : {
25088 : : case RID_CONST:
25089 : : cv_qualifier = TYPE_QUAL_CONST;
25090 : : break;
25091 : :
25092 : 1432593 : case RID_VOLATILE:
25093 : 1432593 : cv_qualifier = TYPE_QUAL_VOLATILE;
25094 : 1432593 : break;
25095 : :
25096 : 7503801 : case RID_RESTRICT:
25097 : 7503801 : cv_qualifier = TYPE_QUAL_RESTRICT;
25098 : 7503801 : break;
25099 : :
25100 : 335231015 : default:
25101 : 335231015 : cv_qualifier = TYPE_UNQUALIFIED;
25102 : 335231015 : break;
25103 : : }
25104 : :
25105 : 8936394 : if (!cv_qualifier)
25106 : : break;
25107 : :
25108 : 35931504 : if (cv_quals & cv_qualifier)
25109 : : {
25110 : 3 : gcc_rich_location richloc (token->location);
25111 : 3 : richloc.add_fixit_remove ();
25112 : 3 : error_at (&richloc, "duplicate cv-qualifier");
25113 : 3 : cp_lexer_purge_token (parser->lexer);
25114 : 3 : }
25115 : : else
25116 : : {
25117 : 35931501 : cp_lexer_consume_token (parser->lexer);
25118 : 35931501 : cv_quals |= cv_qualifier;
25119 : : }
25120 : : }
25121 : :
25122 : 335231015 : return cv_quals;
25123 : : }
25124 : :
25125 : : /* Parse an (optional) ref-qualifier
25126 : :
25127 : : ref-qualifier:
25128 : : &
25129 : : &&
25130 : :
25131 : : Returns cp_ref_qualifier representing ref-qualifier. */
25132 : :
25133 : : static cp_ref_qualifier
25134 : 165000429 : cp_parser_ref_qualifier_opt (cp_parser* parser)
25135 : : {
25136 : 165000429 : cp_ref_qualifier ref_qual = REF_QUAL_NONE;
25137 : :
25138 : : /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
25139 : 165000429 : if (cxx_dialect < cxx11 && cp_parser_parsing_tentatively (parser))
25140 : : return ref_qual;
25141 : :
25142 : 165612692 : while (true)
25143 : : {
25144 : 165612692 : cp_ref_qualifier curr_ref_qual = REF_QUAL_NONE;
25145 : 165612692 : cp_token *token = cp_lexer_peek_token (parser->lexer);
25146 : :
25147 : 165612692 : switch (token->type)
25148 : : {
25149 : : case CPP_AND:
25150 : : curr_ref_qual = REF_QUAL_LVALUE;
25151 : : break;
25152 : :
25153 : : case CPP_AND_AND:
25154 : : curr_ref_qual = REF_QUAL_RVALUE;
25155 : : break;
25156 : :
25157 : : default:
25158 : : curr_ref_qual = REF_QUAL_NONE;
25159 : : break;
25160 : : }
25161 : :
25162 : 480205 : if (!curr_ref_qual)
25163 : : break;
25164 : 960170 : else if (ref_qual)
25165 : : {
25166 : 6 : error_at (token->location, "multiple ref-qualifiers");
25167 : 6 : cp_lexer_purge_token (parser->lexer);
25168 : : }
25169 : : else
25170 : : {
25171 : 960164 : ref_qual = curr_ref_qual;
25172 : 960164 : cp_lexer_consume_token (parser->lexer);
25173 : : }
25174 : : }
25175 : :
25176 : : return ref_qual;
25177 : : }
25178 : :
25179 : : /* Parse an optional tx-qualifier.
25180 : :
25181 : : tx-qualifier:
25182 : : transaction_safe
25183 : : transaction_safe_dynamic */
25184 : :
25185 : : static tree
25186 : 165530495 : cp_parser_tx_qualifier_opt (cp_parser *parser)
25187 : : {
25188 : 165530495 : cp_token *token = cp_lexer_peek_token (parser->lexer);
25189 : 165530495 : if (token->type == CPP_NAME)
25190 : : {
25191 : 90202 : tree name = token->u.value;
25192 : 90202 : const char *p = IDENTIFIER_POINTER (name);
25193 : 90202 : const int len = strlen ("transaction_safe");
25194 : 90202 : if (startswith (p, "transaction_safe"))
25195 : : {
25196 : 242 : p += len;
25197 : 242 : if (*p == '\0'
25198 : 29 : || !strcmp (p, "_dynamic"))
25199 : : {
25200 : 242 : cp_lexer_consume_token (parser->lexer);
25201 : 242 : if (!flag_tm)
25202 : : {
25203 : 0 : error ("%qE requires %<-fgnu-tm%>", name);
25204 : 0 : return NULL_TREE;
25205 : : }
25206 : : else
25207 : : return name;
25208 : : }
25209 : : }
25210 : : }
25211 : : return NULL_TREE;
25212 : : }
25213 : :
25214 : : /* Parse an (optional) virt-specifier-seq.
25215 : :
25216 : : virt-specifier-seq:
25217 : : virt-specifier virt-specifier-seq [opt]
25218 : :
25219 : : virt-specifier:
25220 : : override
25221 : : final
25222 : :
25223 : : Returns a bitmask representing the virt-specifiers. */
25224 : :
25225 : : static cp_virt_specifiers
25226 : 200642150 : cp_parser_virt_specifier_seq_opt (cp_parser* parser)
25227 : : {
25228 : 200642150 : cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
25229 : :
25230 : 200898589 : while (true)
25231 : : {
25232 : 200898589 : cp_token *token;
25233 : 200898589 : cp_virt_specifiers virt_specifier;
25234 : :
25235 : : /* Peek at the next token. */
25236 : 200898589 : token = cp_lexer_peek_token (parser->lexer);
25237 : : /* See if it's a virt-specifier-qualifier. */
25238 : 200898589 : if (token->type != CPP_NAME)
25239 : : break;
25240 : 810720 : if (id_equal (token->u.value, "override"))
25241 : : {
25242 : 150580 : maybe_warn_cpp0x (CPP0X_OVERRIDE_CONTROLS);
25243 : 150580 : virt_specifier = VIRT_SPEC_OVERRIDE;
25244 : : }
25245 : 660140 : else if (id_equal (token->u.value, "final"))
25246 : : {
25247 : 105858 : maybe_warn_cpp0x (CPP0X_OVERRIDE_CONTROLS);
25248 : 105858 : virt_specifier = VIRT_SPEC_FINAL;
25249 : : }
25250 : 554282 : else if (id_equal (token->u.value, "__final"))
25251 : : {
25252 : : virt_specifier = VIRT_SPEC_FINAL;
25253 : : }
25254 : : else
25255 : : break;
25256 : :
25257 : 256439 : if (virt_specifiers & virt_specifier)
25258 : : {
25259 : 12 : gcc_rich_location richloc (token->location);
25260 : 12 : richloc.add_fixit_remove ();
25261 : 12 : error_at (&richloc, "duplicate virt-specifier");
25262 : 12 : cp_lexer_purge_token (parser->lexer);
25263 : 12 : }
25264 : : else
25265 : : {
25266 : 256427 : cp_lexer_consume_token (parser->lexer);
25267 : 256427 : virt_specifiers |= virt_specifier;
25268 : : }
25269 : : }
25270 : 200642150 : return virt_specifiers;
25271 : : }
25272 : :
25273 : : /* Used by handling of trailing-return-types and NSDMI, in which 'this'
25274 : : is in scope even though it isn't real. */
25275 : :
25276 : : void
25277 : 87457774 : inject_this_parameter (tree ctype, cp_cv_quals quals)
25278 : : {
25279 : 87457774 : tree this_parm;
25280 : :
25281 : 87457774 : if (current_class_ptr)
25282 : : {
25283 : : /* We don't clear this between NSDMIs. Is it already what we want? */
25284 : 491279 : tree type = TREE_TYPE (TREE_TYPE (current_class_ptr));
25285 : 491279 : if (DECL_P (current_class_ptr)
25286 : 491279 : && DECL_CONTEXT (current_class_ptr) == NULL_TREE
25287 : 491279 : && same_type_ignoring_top_level_qualifiers_p (ctype, type)
25288 : 920675 : && cp_type_quals (type) == quals)
25289 : : return;
25290 : : }
25291 : :
25292 : 87028378 : this_parm = build_this_parm (NULL_TREE, ctype, quals);
25293 : : /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
25294 : 87028378 : current_class_ptr = NULL_TREE;
25295 : 87028378 : current_class_ref
25296 : 87028378 : = cp_build_fold_indirect_ref (this_parm);
25297 : 87028378 : current_class_ptr = this_parm;
25298 : : }
25299 : :
25300 : : /* Return true iff our current scope is a non-static data member
25301 : : initializer. */
25302 : :
25303 : : bool
25304 : 1410098389 : parsing_nsdmi (void)
25305 : : {
25306 : : /* We recognize NSDMI context by the context-less 'this' pointer set up
25307 : : by the function above. */
25308 : 1410098389 : if (current_class_ptr
25309 : 586162310 : && TREE_CODE (current_class_ptr) == PARM_DECL
25310 : 1996260699 : && DECL_CONTEXT (current_class_ptr) == NULL_TREE)
25311 : 1152 : return true;
25312 : : return false;
25313 : : }
25314 : :
25315 : : /* True if we're parsing a function declarator. */
25316 : :
25317 : : bool
25318 : 828501 : parsing_function_declarator ()
25319 : : {
25320 : : /* this_entity is NULL for a function parameter scope while parsing the
25321 : : declarator; it is set when parsing the body of the function. */
25322 : 828501 : return (current_binding_level->kind == sk_function_parms
25323 : 828501 : && !current_binding_level->this_entity);
25324 : : }
25325 : :
25326 : : /* Parse a late-specified return type, if any. This is not a separate
25327 : : non-terminal, but part of a function declarator, which looks like
25328 : :
25329 : : -> trailing-type-specifier-seq abstract-declarator(opt)
25330 : :
25331 : : Returns the type indicated by the type-id.
25332 : :
25333 : : In addition to this, parse any queued up #pragma omp declare simd
25334 : : clauses, and #pragma acc routine clauses.
25335 : :
25336 : : QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
25337 : : function. */
25338 : :
25339 : : static tree
25340 : 164931549 : cp_parser_late_return_type_opt (cp_parser *parser, cp_declarator *declarator,
25341 : : tree &requires_clause, tree parms)
25342 : : {
25343 : 164931549 : cp_token *token;
25344 : 164931549 : tree type = NULL_TREE;
25345 : 329863098 : bool declare_simd_p = (parser->omp_declare_simd
25346 : 2111 : && declarator
25347 : 164933660 : && declarator->kind == cdk_id);
25348 : :
25349 : 329863098 : bool oacc_routine_p = (parser->oacc_routine
25350 : 531 : && declarator
25351 : 164932080 : && declarator->kind == cdk_id);
25352 : :
25353 : : /* Peek at the next token. */
25354 : 164931549 : token = cp_lexer_peek_token (parser->lexer);
25355 : : /* A late-specified return type is indicated by an initial '->'. */
25356 : 164931549 : if (token->type != CPP_DEREF
25357 : 162351422 : && token->keyword != RID_REQUIRES
25358 : 161241337 : && !(token->type == CPP_NAME
25359 : 153179 : && token->u.value == ridpointers[RID_REQUIRES])
25360 : 161241337 : && !(declare_simd_p || oacc_routine_p))
25361 : : return NULL_TREE;
25362 : :
25363 : 3692851 : if (token->type == CPP_DEREF)
25364 : : {
25365 : : /* Consume the ->. */
25366 : 2580127 : cp_lexer_consume_token (parser->lexer);
25367 : :
25368 : 2580127 : type = cp_parser_trailing_type_id (parser);
25369 : : }
25370 : :
25371 : : /* Function declarations may be followed by a trailing
25372 : : requires-clause. */
25373 : 3692851 : requires_clause = cp_parser_requires_clause_opt (parser, false);
25374 : :
25375 : 3692851 : if (declare_simd_p)
25376 : 2111 : declarator->attributes
25377 : 2111 : = cp_parser_late_parsing_omp_declare_simd (parser, declarator->attributes,
25378 : : parms);
25379 : 3692851 : if (oacc_routine_p)
25380 : 530 : declarator->attributes
25381 : 530 : = cp_parser_late_parsing_oacc_routine (parser,
25382 : : declarator->attributes);
25383 : :
25384 : : return type;
25385 : : }
25386 : :
25387 : : /* Parse a declarator-id.
25388 : :
25389 : : declarator-id:
25390 : : id-expression
25391 : : :: [opt] nested-name-specifier [opt] type-name
25392 : :
25393 : : In the `id-expression' case, the value returned is as for
25394 : : cp_parser_id_expression if the id-expression was an unqualified-id.
25395 : : If the id-expression was a qualified-id, then a SCOPE_REF is
25396 : : returned. The first operand is the scope (either a NAMESPACE_DECL
25397 : : or TREE_TYPE), but the second is still just a representation of an
25398 : : unqualified-id. */
25399 : :
25400 : : static tree
25401 : 509593669 : cp_parser_declarator_id (cp_parser* parser, bool optional_p)
25402 : : {
25403 : 509593669 : tree id;
25404 : : /* The expression must be an id-expression. Assume that qualified
25405 : : names are the names of types so that:
25406 : :
25407 : : template <class T>
25408 : : int S<T>::R::i = 3;
25409 : :
25410 : : will work; we must treat `S<T>::R' as the name of a type.
25411 : : Similarly, assume that qualified names are templates, where
25412 : : required, so that:
25413 : :
25414 : : template <class T>
25415 : : int S<T>::R<T>::i = 3;
25416 : :
25417 : : will work, too. */
25418 : 509593669 : id = cp_parser_id_expression (parser,
25419 : : /*template_keyword_p=*/false,
25420 : : /*check_dependency_p=*/false,
25421 : : /*template_p=*/NULL,
25422 : : /*declarator_p=*/true,
25423 : : optional_p);
25424 : 509593669 : if (id && BASELINK_P (id))
25425 : 292 : id = BASELINK_FUNCTIONS (id);
25426 : 509593669 : return id;
25427 : : }
25428 : :
25429 : : /* Parse a type-id.
25430 : :
25431 : : type-id:
25432 : : type-specifier-seq abstract-declarator [opt]
25433 : :
25434 : : The parser flags FLAGS is used to control type-specifier parsing.
25435 : :
25436 : : If IS_TEMPLATE_ARG is true, we are parsing a template argument.
25437 : :
25438 : : If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
25439 : : i.e. we've just seen "->".
25440 : :
25441 : : Returns the TYPE specified. */
25442 : :
25443 : : static tree
25444 : 356406061 : cp_parser_type_id_1 (cp_parser *parser, cp_parser_flags flags,
25445 : : bool is_template_arg, bool is_trailing_return,
25446 : : location_t *type_location)
25447 : : {
25448 : 356406061 : cp_decl_specifier_seq type_specifier_seq;
25449 : 356406061 : cp_declarator *abstract_declarator;
25450 : :
25451 : : /* Parse the type-specifier-seq. */
25452 : 356406061 : cp_parser_type_specifier_seq (parser, flags,
25453 : : /*is_declaration=*/false,
25454 : : is_trailing_return,
25455 : : &type_specifier_seq);
25456 : 356406061 : if (type_location)
25457 : 15420509 : *type_location = type_specifier_seq.locations[ds_type_spec];
25458 : :
25459 : 303400562 : if (is_template_arg && type_specifier_seq.type
25460 : 301914011 : && TREE_CODE (type_specifier_seq.type) == TEMPLATE_TYPE_PARM
25461 : 363749700 : && CLASS_PLACEHOLDER_TEMPLATE (type_specifier_seq.type))
25462 : : /* A bare template name as a template argument is a template template
25463 : : argument, not a placeholder, so fail parsing it as a type argument. */
25464 : : {
25465 : 0 : gcc_assert (cp_parser_uncommitted_to_tentative_parse_p (parser));
25466 : 7343501 : cp_parser_simulate_error (parser);
25467 : 7343501 : return error_mark_node;
25468 : : }
25469 : 349062560 : if (type_specifier_seq.type == error_mark_node)
25470 : : return error_mark_node;
25471 : :
25472 : : /* There might or might not be an abstract declarator. */
25473 : 317402529 : cp_parser_parse_tentatively (parser);
25474 : : /* Look for the declarator. */
25475 : 317402529 : abstract_declarator
25476 : 317402529 : = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT,
25477 : : CP_PARSER_FLAGS_NONE, NULL,
25478 : : /*parenthesized_p=*/NULL,
25479 : : /*member_p=*/false,
25480 : : /*friend_p=*/false,
25481 : : /*static_p=*/false);
25482 : : /* Check to see if there really was a declarator. */
25483 : 317402529 : if (!cp_parser_parse_definitely (parser))
25484 : 301919240 : abstract_declarator = NULL;
25485 : :
25486 : 317402529 : bool auto_typeid_ok = false;
25487 : : /* DR 625 prohibits use of auto as a template-argument. We allow 'auto'
25488 : : outside the template-argument-list context here only for the sake of
25489 : : diagnostic: grokdeclarator then can emit a better error message for
25490 : : e.g. using T = auto. */
25491 : 317402529 : if (flag_concepts)
25492 : 92738216 : auto_typeid_ok = (!parser->in_type_id_in_expr_p
25493 : 92738216 : && !parser->in_template_argument_list_p);
25494 : :
25495 : 317402529 : if (type_specifier_seq.type
25496 : 314556869 : && !auto_typeid_ok
25497 : : /* None of the valid uses of 'auto' in C++14 involve the type-id
25498 : : nonterminal, but it is valid in a trailing-return-type. */
25499 : 305860245 : && !(cxx_dialect >= cxx14 && is_trailing_return))
25500 : 303978530 : if (tree auto_node = type_uses_auto (type_specifier_seq.type))
25501 : : {
25502 : : /* A type-id with type 'auto' is only ok if the abstract declarator
25503 : : is a function declarator with a late-specified return type.
25504 : :
25505 : : A type-id with 'auto' is also valid in a trailing-return-type
25506 : : in a compound-requirement. */
25507 : 272 : if (abstract_declarator
25508 : 104 : && abstract_declarator->kind == cdk_function
25509 : 37 : && abstract_declarator->u.function.late_return_type)
25510 : : /* OK */;
25511 : 244 : else if (parser->in_result_type_constraint_p)
25512 : : /* OK */;
25513 : : else
25514 : : {
25515 : 166 : if (!cp_parser_simulate_error (parser))
25516 : : {
25517 : 78 : location_t loc = type_specifier_seq.locations[ds_type_spec];
25518 : 78 : if (tree tmpl = CLASS_PLACEHOLDER_TEMPLATE (auto_node))
25519 : : {
25520 : 0 : auto_diagnostic_group g;
25521 : 0 : gcc_rich_location richloc (loc);
25522 : 0 : richloc.add_fixit_insert_after ("<>");
25523 : 0 : error_at (&richloc, "missing template arguments after %qE",
25524 : : tmpl);
25525 : 0 : inform (DECL_SOURCE_LOCATION (tmpl), "%qD declared here",
25526 : : tmpl);
25527 : 0 : }
25528 : 78 : else if (parser->in_template_argument_list_p)
25529 : 0 : error_at (loc, "%qT not permitted in template argument",
25530 : : auto_node);
25531 : : else
25532 : 78 : error_at (loc, "invalid use of %qT", auto_node);
25533 : : }
25534 : 244 : return error_mark_node;
25535 : : }
25536 : : }
25537 : :
25538 : 317402285 : return groktypename (&type_specifier_seq, abstract_declarator,
25539 : 317402285 : is_template_arg);
25540 : : }
25541 : :
25542 : : /* Wrapper for cp_parser_type_id_1. */
25543 : :
25544 : : static tree
25545 : 49955576 : cp_parser_type_id (cp_parser *parser, cp_parser_flags flags,
25546 : : location_t *type_location)
25547 : : {
25548 : 46302991 : return cp_parser_type_id_1 (parser, flags, false, false, type_location);
25549 : : }
25550 : :
25551 : : /* Wrapper for cp_parser_type_id_1. */
25552 : :
25553 : : static tree
25554 : 303400562 : cp_parser_template_type_arg (cp_parser *parser)
25555 : : {
25556 : 303400562 : const char *saved_message = parser->type_definition_forbidden_message;
25557 : 303400562 : parser->type_definition_forbidden_message
25558 : 303400562 : = G_("types may not be defined in template arguments");
25559 : 303400562 : tree r = cp_parser_type_id_1 (parser, CP_PARSER_FLAGS_NONE,
25560 : : /*is_template_arg=*/true,
25561 : : /*is_trailing_return=*/false, nullptr);
25562 : 303400562 : parser->type_definition_forbidden_message = saved_message;
25563 : : /* cp_parser_type_id_1 checks for auto, but only for
25564 : : ->auto_is_implicit_function_template_parm_p. */
25565 : 303400562 : if (cxx_dialect >= cxx14 && type_uses_auto (r))
25566 : : {
25567 : 12 : error ("invalid use of %<auto%> in template argument");
25568 : 12 : r = error_mark_node;
25569 : : }
25570 : 303400562 : return r;
25571 : : }
25572 : :
25573 : : /* Wrapper for cp_parser_type_id_1. */
25574 : :
25575 : : static tree
25576 : 3049923 : cp_parser_trailing_type_id (cp_parser *parser)
25577 : : {
25578 : 3049923 : return cp_parser_type_id_1 (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
25579 : 3049923 : false, true, NULL);
25580 : : }
25581 : :
25582 : : /* Parse a type-specifier-seq.
25583 : :
25584 : : type-specifier-seq:
25585 : : type-specifier type-specifier-seq [opt]
25586 : :
25587 : : GNU extension:
25588 : :
25589 : : type-specifier-seq:
25590 : : attributes type-specifier-seq [opt]
25591 : :
25592 : : The parser flags FLAGS is used to control type-specifier parsing.
25593 : :
25594 : : If IS_DECLARATION is true, we are at the start of a "condition" or
25595 : : exception-declaration, so we might be followed by a declarator-id.
25596 : :
25597 : : If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
25598 : : i.e. we've just seen "->".
25599 : :
25600 : : Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
25601 : :
25602 : : static void
25603 : 359271548 : cp_parser_type_specifier_seq (cp_parser* parser,
25604 : : cp_parser_flags flags,
25605 : : bool is_declaration,
25606 : : bool is_trailing_return,
25607 : : cp_decl_specifier_seq *type_specifier_seq)
25608 : : {
25609 : 359271548 : bool seen_type_specifier = false;
25610 : 359271548 : cp_token *start_token = NULL;
25611 : :
25612 : : /* Clear the TYPE_SPECIFIER_SEQ. */
25613 : 359271548 : clear_decl_specs (type_specifier_seq);
25614 : :
25615 : 359271548 : flags |= CP_PARSER_FLAGS_OPTIONAL;
25616 : : /* In the context of a trailing return type, enum E { } is an
25617 : : elaborated-type-specifier followed by a function-body, not an
25618 : : enum-specifier. */
25619 : 359271548 : if (is_trailing_return)
25620 : 3049923 : flags |= CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS;
25621 : :
25622 : : /* Parse the type-specifiers and attributes. */
25623 : 701085238 : while (true)
25624 : : {
25625 : 701085238 : tree type_specifier;
25626 : 701085238 : bool is_cv_qualifier;
25627 : :
25628 : : /* Check for attributes first. */
25629 : 701085238 : if (cp_next_tokens_can_be_attribute_p (parser))
25630 : : {
25631 : : /* GNU attributes at the end of a declaration apply to the
25632 : : declaration as a whole, not to the trailing return type. So look
25633 : : ahead to see if these attributes are at the end. */
25634 : 689 : if (seen_type_specifier && is_trailing_return
25635 : 689 : && cp_next_tokens_can_be_gnu_attribute_p (parser))
25636 : : {
25637 : 6 : size_t n = cp_parser_skip_attributes_opt (parser, 1);
25638 : 6 : cp_token *tok = cp_lexer_peek_nth_token (parser->lexer, n);
25639 : 6 : if (tok->type == CPP_SEMICOLON || tok->type == CPP_COMMA
25640 : : || tok->type == CPP_EQ || tok->type == CPP_OPEN_BRACE)
25641 : : break;
25642 : : }
25643 : 683 : location_t attr_loc = cp_lexer_peek_token (parser->lexer)->location;
25644 : 683 : tree attrs = cp_parser_attributes_opt (parser);
25645 : 683 : if (seen_type_specifier
25646 : 683 : && is_declaration
25647 : 683 : && cxx11_attribute_p (attrs))
25648 : : {
25649 : 50 : type_specifier_seq->std_attributes
25650 : 50 : = attr_chainon (type_specifier_seq->std_attributes, attrs);
25651 : 50 : if (type_specifier_seq->locations[ds_std_attribute] == 0)
25652 : 50 : type_specifier_seq->locations[ds_std_attribute] = attr_loc;
25653 : : }
25654 : : else
25655 : : {
25656 : 633 : type_specifier_seq->attributes
25657 : 633 : = attr_chainon (type_specifier_seq->attributes, attrs);
25658 : 633 : if (type_specifier_seq->locations[ds_attribute] == 0)
25659 : 633 : type_specifier_seq->locations[ds_attribute] = attr_loc;
25660 : : }
25661 : 683 : continue;
25662 : 683 : }
25663 : :
25664 : : /* record the token of the beginning of the type specifier seq,
25665 : : for error reporting purposes*/
25666 : 701084549 : if (!start_token)
25667 : : start_token = cp_lexer_peek_token (parser->lexer);
25668 : :
25669 : : /* Look for the type-specifier. */
25670 : 701084549 : type_specifier = cp_parser_type_specifier (parser,
25671 : : flags,
25672 : : type_specifier_seq,
25673 : : /*is_declaration=*/false,
25674 : : NULL,
25675 : : &is_cv_qualifier);
25676 : 701084549 : if (!type_specifier)
25677 : : {
25678 : : /* If the first type-specifier could not be found, this is not a
25679 : : type-specifier-seq at all. */
25680 : 359271542 : if (!seen_type_specifier)
25681 : : {
25682 : : /* Set in_declarator_p to avoid skipping to the semicolon. */
25683 : 31674576 : int in_decl = parser->in_declarator_p;
25684 : 31674576 : parser->in_declarator_p = true;
25685 : :
25686 : 63349228 : if (cp_parser_uncommitted_to_tentative_parse_p (parser)
25687 : 178 : || !cp_parser_parse_and_diagnose_invalid_type_name (parser))
25688 : 31674474 : cp_parser_error (parser, "expected type-specifier");
25689 : :
25690 : 31674576 : parser->in_declarator_p = in_decl;
25691 : :
25692 : 31674576 : type_specifier_seq->type = error_mark_node;
25693 : 31674576 : return;
25694 : : }
25695 : : /* If subsequent type-specifiers could not be found, the
25696 : : type-specifier-seq is complete. */
25697 : : break;
25698 : : }
25699 : :
25700 : 341813007 : seen_type_specifier = true;
25701 : : /* The standard says that a condition can be:
25702 : :
25703 : : type-specifier-seq declarator = assignment-expression
25704 : :
25705 : : However, given:
25706 : :
25707 : : struct S {};
25708 : : if (int S = ...)
25709 : :
25710 : : we should treat the "S" as a declarator, not as a
25711 : : type-specifier. The standard doesn't say that explicitly for
25712 : : type-specifier-seq, but it does say that for
25713 : : decl-specifier-seq in an ordinary declaration. Perhaps it
25714 : : would be clearer just to allow a decl-specifier-seq here, and
25715 : : then add a semantic restriction that if any decl-specifiers
25716 : : that are not type-specifiers appear, the program is invalid. */
25717 : 341813007 : if (is_declaration && !is_cv_qualifier)
25718 : 477431 : flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
25719 : : }
25720 : : }
25721 : :
25722 : : /* Return whether the function currently being declared has an associated
25723 : : template parameter list. */
25724 : :
25725 : : static bool
25726 : 271079300 : function_being_declared_is_template_p (cp_parser* parser)
25727 : : {
25728 : 271079300 : if (!current_template_parms || processing_template_parmlist)
25729 : : return false;
25730 : :
25731 : 168144598 : if (parser->implicit_template_scope)
25732 : : return true;
25733 : :
25734 : 168002638 : if (at_class_scope_p ()
25735 : 168002638 : && TYPE_BEING_DEFINED (current_class_type))
25736 : 84130026 : return parser->num_template_parameter_lists != 0;
25737 : :
25738 : 83872612 : return ((int) parser->num_template_parameter_lists > template_class_depth
25739 : 83872612 : (current_class_type));
25740 : : }
25741 : :
25742 : : /* Parse a parameter-declaration-clause.
25743 : :
25744 : : parameter-declaration-clause:
25745 : : parameter-declaration-list [opt] ... [opt]
25746 : : parameter-declaration-list , ...
25747 : :
25748 : : The parser flags FLAGS is used to control type-specifier parsing.
25749 : :
25750 : : LAMBDA_P is true if this is the parameter-declaration-clause of
25751 : : a lambda-declarator.
25752 : :
25753 : : Returns a representation for the parameter declarations. A return
25754 : : value of NULL indicates a parameter-declaration-clause consisting
25755 : : only of an ellipsis. */
25756 : :
25757 : : static tree
25758 : 172712722 : cp_parser_parameter_declaration_clause (cp_parser* parser,
25759 : : cp_parser_flags flags,
25760 : : bool lambda_p)
25761 : : {
25762 : 172712722 : tree parameters;
25763 : 172712722 : cp_token *token;
25764 : 172712722 : bool ellipsis_p;
25765 : :
25766 : 172712722 : auto cleanup = make_temp_override
25767 : 172712722 : (parser->auto_is_implicit_function_template_parm_p);
25768 : :
25769 : 172712722 : if (lambda_p
25770 : 172211611 : || (!processing_specialization
25771 : 171656952 : && !processing_template_parmlist
25772 : 171617579 : && !processing_explicit_instantiation
25773 : : /* default_arg_ok_p tracks whether this is a parameter-clause for an
25774 : : actual function or a random abstract declarator. */
25775 : 169667101 : && parser->default_arg_ok_p
25776 : 165072710 : && !current_function_decl))
25777 : 160517998 : parser->auto_is_implicit_function_template_parm_p = true;
25778 : :
25779 : : /* Peek at the next token. */
25780 : 172712722 : token = cp_lexer_peek_token (parser->lexer);
25781 : : /* Check for trivial parameter-declaration-clauses. */
25782 : 172712722 : if (token->type == CPP_ELLIPSIS)
25783 : : {
25784 : : /* Consume the `...' token. */
25785 : 246900 : cp_lexer_consume_token (parser->lexer);
25786 : 246900 : return NULL_TREE;
25787 : : }
25788 : 172465822 : else if (token->type == CPP_CLOSE_PAREN)
25789 : : /* There are no parameters. */
25790 : 31168703 : return void_list_node;
25791 : : /* Check for `(void)', too, which is a special case. */
25792 : 141297119 : else if (token->keyword == RID_VOID
25793 : 141297119 : && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
25794 : : == CPP_CLOSE_PAREN))
25795 : : {
25796 : : /* Consume the `void' token. */
25797 : 1117172 : cp_lexer_consume_token (parser->lexer);
25798 : : /* There are no parameters. */
25799 : 1117172 : return explicit_void_list_node;
25800 : : }
25801 : :
25802 : : /* A vector of parameters that haven't been pushed yet. */
25803 : 140179947 : auto_vec<tree> pending_decls;
25804 : :
25805 : : /* Parse the parameter-declaration-list. */
25806 : 140179947 : parameters = cp_parser_parameter_declaration_list (parser, flags,
25807 : : &pending_decls);
25808 : : /* If a parse error occurred while parsing the
25809 : : parameter-declaration-list, then the entire
25810 : : parameter-declaration-clause is erroneous. */
25811 : 140179947 : if (parameters == error_mark_node)
25812 : : return NULL_TREE;
25813 : :
25814 : : /* Peek at the next token. */
25815 : 133209017 : token = cp_lexer_peek_token (parser->lexer);
25816 : : /* If it's a `,', the clause should terminate with an ellipsis. */
25817 : 133209017 : if (token->type == CPP_COMMA)
25818 : : {
25819 : : /* Consume the `,'. */
25820 : 750980 : cp_lexer_consume_token (parser->lexer);
25821 : : /* Expect an ellipsis. */
25822 : 750980 : ellipsis_p
25823 : 750980 : = (cp_parser_require (parser, CPP_ELLIPSIS, RT_ELLIPSIS) != NULL);
25824 : : }
25825 : : /* It might also be `...' if the optional trailing `,' was
25826 : : omitted. */
25827 : 132458037 : else if (token->type == CPP_ELLIPSIS)
25828 : : {
25829 : : /* Deprecated by P3176R1 in C++26. */
25830 : 163 : if (warn_deprecated_variadic_comma_omission)
25831 : : {
25832 : 59 : gcc_rich_location richloc (token->location);
25833 : 59 : richloc.add_fixit_insert_before (", ");
25834 : 59 : warning_at (&richloc, OPT_Wdeprecated_variadic_comma_omission,
25835 : : "omission of %<,%> before varargs %<...%> is "
25836 : : "deprecated in C++26");
25837 : 59 : }
25838 : :
25839 : : /* Consume the `...' token. */
25840 : 163 : cp_lexer_consume_token (parser->lexer);
25841 : : /* And remember that we saw it. */
25842 : 163 : ellipsis_p = true;
25843 : : }
25844 : : else
25845 : : ellipsis_p = false;
25846 : :
25847 : : /* A valid parameter-declaration-clause can only be followed by a ')'.
25848 : : So it's time to push all the parameters we have seen now that we
25849 : : know we have a valid declaration. Note that here we may not have
25850 : : committed yet, nor should we. Pushing here will detect the error
25851 : : of redefining a parameter. */
25852 : 133209017 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
25853 : : {
25854 : 133208808 : for (tree p : pending_decls)
25855 : 12 : pushdecl (p);
25856 : :
25857 : : /* Delayed checking of auto parameters. */
25858 : 133208772 : if (!parser->auto_is_implicit_function_template_parm_p
25859 : 4509077 : && cxx_dialect >= cxx14)
25860 : 10750683 : for (tree p = parameters; p; p = TREE_CHAIN (p))
25861 : 6315249 : if (type_uses_auto (TREE_TYPE (TREE_VALUE (p))))
25862 : : {
25863 : 55 : error_at (location_of (TREE_VALUE (p)),
25864 : : "%<auto%> parameter not permitted in this context");
25865 : 55 : TREE_TYPE (TREE_VALUE (p)) = error_mark_node;
25866 : : }
25867 : : }
25868 : :
25869 : : /* Finish the parameter list. */
25870 : 133209017 : if (!ellipsis_p)
25871 : 132457874 : parameters = chainon (parameters, void_list_node);
25872 : :
25873 : : return parameters;
25874 : 140179947 : }
25875 : :
25876 : : /* Parse a parameter-declaration-list.
25877 : :
25878 : : parameter-declaration-list:
25879 : : parameter-declaration
25880 : : parameter-declaration-list , parameter-declaration
25881 : :
25882 : : The parser flags FLAGS is used to control type-specifier parsing.
25883 : : PENDING_DECLS is a vector of parameters that haven't been pushed yet.
25884 : :
25885 : : Returns a representation of the parameter-declaration-list, as for
25886 : : cp_parser_parameter_declaration_clause. However, the
25887 : : `void_list_node' is never appended to the list. */
25888 : :
25889 : : static tree
25890 : 140179973 : cp_parser_parameter_declaration_list (cp_parser* parser,
25891 : : cp_parser_flags flags,
25892 : : auto_vec<tree> *pending_decls)
25893 : : {
25894 : 140179973 : tree parameters = NULL_TREE;
25895 : 140179973 : tree *tail = ¶meters;
25896 : 140179973 : bool saved_in_unbraced_linkage_specification_p;
25897 : 140179973 : int index = 0;
25898 : :
25899 : : /* The special considerations that apply to a function within an
25900 : : unbraced linkage specifications do not apply to the parameters
25901 : : to the function. */
25902 : 140179973 : saved_in_unbraced_linkage_specification_p
25903 : 140179973 : = parser->in_unbraced_linkage_specification_p;
25904 : 140179973 : parser->in_unbraced_linkage_specification_p = false;
25905 : :
25906 : : /* Look for more parameters. */
25907 : 375177361 : while (true)
25908 : : {
25909 : 257678667 : cp_parameter_declarator *parameter;
25910 : 257678667 : tree decl = error_mark_node;
25911 : 257678667 : bool parenthesized_p = false;
25912 : :
25913 : : /* Parse the parameter. */
25914 : 257678667 : parameter
25915 : 257678667 : = cp_parser_parameter_declaration (parser, flags,
25916 : : /*template_parm_p=*/false,
25917 : : &parenthesized_p);
25918 : :
25919 : : /* We don't know yet if the enclosing context is unavailable or deprecated,
25920 : : so wait and deal with it in grokparms if appropriate. */
25921 : 257678667 : deprecated_state = UNAVAILABLE_DEPRECATED_SUPPRESS;
25922 : :
25923 : 257678667 : if (parameter && !cp_parser_error_occurred (parser))
25924 : : {
25925 : 501415704 : decl = grokdeclarator (parameter->declarator,
25926 : : ¶meter->decl_specifiers,
25927 : : PARM,
25928 : 250707852 : parameter->default_argument != NULL_TREE,
25929 : : ¶meter->decl_specifiers.attributes);
25930 : 250707852 : if (decl != error_mark_node && parameter->loc != UNKNOWN_LOCATION)
25931 : 250707737 : DECL_SOURCE_LOCATION (decl) = parameter->loc;
25932 : : }
25933 : :
25934 : 257678667 : deprecated_state = DEPRECATED_NORMAL;
25935 : :
25936 : : /* If a parse error occurred parsing the parameter declaration,
25937 : : then the entire parameter-declaration-list is erroneous. */
25938 : 257678667 : if (decl == error_mark_node)
25939 : : {
25940 : 6970930 : parameters = error_mark_node;
25941 : 6970930 : break;
25942 : : }
25943 : :
25944 : 250707737 : if (parameter->decl_specifiers.attributes)
25945 : 235385 : cplus_decl_attributes (&decl,
25946 : : parameter->decl_specifiers.attributes,
25947 : : 0);
25948 : 250707737 : if (DECL_NAME (decl))
25949 : : {
25950 : : /* We cannot always pushdecl while parsing tentatively because
25951 : : it may have side effects and we can't be sure yet if we're
25952 : : parsing a declaration, e.g.:
25953 : :
25954 : : S foo(int(x), int(x), int{x});
25955 : :
25956 : : where it's not clear if we're dealing with a constructor call
25957 : : or a function declaration until we've seen the last argument
25958 : : which breaks it up.
25959 : : It's safe to pushdecl so long as it doesn't result in a clash
25960 : : with an already-pushed parameter. But we don't delay pushing
25961 : : different parameters to handle
25962 : :
25963 : : S foo(int(i), decltype(i) j = 42);
25964 : :
25965 : : which is valid. */
25966 : 211118629 : if (pending_decls
25967 : 211418000 : && cp_parser_uncommitted_to_tentative_parse_p (parser)
25968 : : /* See if PARAMETERS already contains a parameter with the same
25969 : : DECL_NAME as DECL. */
25970 : 211418027 : && [parameters, decl] {
25971 : 361380 : for (tree p = parameters; p; p = TREE_CHAIN (p))
25972 : 62009 : if (DECL_NAME (decl) == DECL_NAME (TREE_VALUE (p)))
25973 : : return true;
25974 : : return false;
25975 : 299398 : }())
25976 : 27 : pending_decls->safe_push (decl);
25977 : : else
25978 : 211118602 : decl = pushdecl (decl);
25979 : : }
25980 : :
25981 : 250707737 : if (decl != error_mark_node)
25982 : : {
25983 : 250707677 : retrofit_lang_decl (decl);
25984 : 250707677 : DECL_PARM_INDEX (decl) = ++index;
25985 : 250707677 : DECL_PARM_LEVEL (decl) = function_parm_depth ();
25986 : : }
25987 : :
25988 : : /* Add the new parameter to the list. */
25989 : 250707737 : *tail = build_tree_list (parameter->default_argument, decl);
25990 : 250707737 : tail = &TREE_CHAIN (*tail);
25991 : :
25992 : : /* If the parameters were parenthesized, it's the case of
25993 : : T foo(X(x)) which looks like a variable definition but
25994 : : is a function declaration. */
25995 : 250707737 : if (index == 1 || PARENTHESIZED_LIST_P (parameters))
25996 : 133336848 : PARENTHESIZED_LIST_P (parameters) = parenthesized_p;
25997 : :
25998 : : /* Peek at the next token. */
25999 : 250707737 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
26000 : : || cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
26001 : : /* These are for Objective-C++ */
26002 : : || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
26003 : : || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
26004 : : /* The parameter-declaration-list is complete. */
26005 : : break;
26006 : : else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
26007 : : {
26008 : 118249674 : cp_token *token;
26009 : :
26010 : : /* Peek at the next token. */
26011 : 118249674 : token = cp_lexer_peek_nth_token (parser->lexer, 2);
26012 : : /* If it's an ellipsis, then the list is complete. */
26013 : 118249674 : if (token->type == CPP_ELLIPSIS)
26014 : : break;
26015 : : /* Otherwise, there must be more parameters. Consume the
26016 : : `,'. */
26017 : 117498694 : cp_lexer_consume_token (parser->lexer);
26018 : : /* When parsing something like:
26019 : :
26020 : : int i(float f, double d)
26021 : :
26022 : : we can tell after seeing the declaration for "f" that we
26023 : : are not looking at an initialization of a variable "i",
26024 : : but rather at the declaration of a function "i".
26025 : :
26026 : : Due to the fact that the parsing of template arguments
26027 : : (as specified to a template-id) requires backtracking we
26028 : : cannot use this technique when inside a template argument
26029 : : list. */
26030 : 117498694 : if (!parser->in_template_argument_list_p
26031 : 117383068 : && !parser->in_type_id_in_expr_p
26032 : 121107173 : && cp_parser_uncommitted_to_tentative_parse_p (parser)
26033 : : /* However, a parameter-declaration of the form
26034 : : "float(f)" (which is a valid declaration of a
26035 : : parameter "f") can also be interpreted as an
26036 : : expression (the conversion of "f" to "float"). */
26037 : 121107173 : && !parenthesized_p)
26038 : 3548177 : cp_parser_commit_to_tentative_parse (parser);
26039 : : }
26040 : : else
26041 : : {
26042 : 73 : cp_parser_error (parser, "expected %<,%> or %<...%>");
26043 : 140180083 : if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
26044 : 37 : cp_parser_skip_to_closing_parenthesis (parser,
26045 : : /*recovering=*/true,
26046 : : /*or_comma=*/false,
26047 : : /*consume_paren=*/false);
26048 : : break;
26049 : : }
26050 : 117498694 : }
26051 : :
26052 : 140179973 : parser->in_unbraced_linkage_specification_p
26053 : 140179973 : = saved_in_unbraced_linkage_specification_p;
26054 : :
26055 : : /* Reset implicit_template_scope if we are about to leave the function
26056 : : parameter list that introduced it. Note that for out-of-line member
26057 : : definitions, there will be one or more class scopes before we get to
26058 : : the template parameter scope. */
26059 : :
26060 : 140179973 : if (cp_binding_level *its = parser->implicit_template_scope)
26061 : 215428 : if (cp_binding_level *maybe_its = current_binding_level->level_chain)
26062 : : {
26063 : 215504 : while (maybe_its->kind == sk_class)
26064 : 76 : maybe_its = maybe_its->level_chain;
26065 : 215428 : if (maybe_its == its)
26066 : : {
26067 : 215350 : parser->implicit_template_parms = 0;
26068 : 215350 : parser->implicit_template_scope = 0;
26069 : : }
26070 : : }
26071 : :
26072 : 140179973 : return parameters;
26073 : : }
26074 : :
26075 : : /* Parse a parameter declaration.
26076 : :
26077 : : parameter-declaration:
26078 : : decl-specifier-seq ... [opt] declarator
26079 : : decl-specifier-seq declarator = assignment-expression
26080 : : decl-specifier-seq ... [opt] abstract-declarator [opt]
26081 : : decl-specifier-seq abstract-declarator [opt] = assignment-expression
26082 : :
26083 : : The parser flags FLAGS is used to control type-specifier parsing.
26084 : :
26085 : : If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
26086 : : declares a template parameter. (In that case, a non-nested `>'
26087 : : token encountered during the parsing of the assignment-expression
26088 : : is not interpreted as a greater-than operator.)
26089 : :
26090 : : Returns a representation of the parameter, or NULL if an error
26091 : : occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
26092 : : true iff the declarator is of the form "(p)". */
26093 : :
26094 : : static cp_parameter_declarator *
26095 : 271076099 : cp_parser_parameter_declaration (cp_parser *parser,
26096 : : cp_parser_flags flags,
26097 : : bool template_parm_p,
26098 : : bool *parenthesized_p)
26099 : : {
26100 : 271076099 : int declares_class_or_enum;
26101 : 271076099 : cp_decl_specifier_seq decl_specifiers;
26102 : 271076099 : cp_declarator *declarator;
26103 : 271076099 : tree default_argument;
26104 : 271076099 : cp_token *token = NULL, *declarator_token_start = NULL;
26105 : 271076099 : const char *saved_message;
26106 : 271076099 : bool template_parameter_pack_p = false;
26107 : :
26108 : : /* In a template parameter, `>' is not an operator.
26109 : :
26110 : : [temp.param]
26111 : :
26112 : : When parsing a default template-argument for a non-type
26113 : : template-parameter, the first non-nested `>' is taken as the end
26114 : : of the template parameter-list rather than a greater-than
26115 : : operator. */
26116 : :
26117 : : /* Type definitions may not appear in parameter types. */
26118 : 271076099 : saved_message = parser->type_definition_forbidden_message;
26119 : 271076099 : parser->type_definition_forbidden_message
26120 : 271076099 : = G_("types may not be defined in parameter types");
26121 : :
26122 : 271076099 : int template_parm_idx = (function_being_declared_is_template_p (parser) ?
26123 : 102316275 : TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
26124 : 271076099 : (current_template_parms)) : 0);
26125 : :
26126 : : /* Parse the declaration-specifiers. */
26127 : 271076099 : cp_token *decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
26128 : 271076099 : cp_parser_decl_specifier_seq (parser,
26129 : : flags | CP_PARSER_FLAGS_PARAMETER,
26130 : : &decl_specifiers,
26131 : : &declares_class_or_enum);
26132 : :
26133 : : /* [dcl.spec.auto.general]: "A placeholder-type-specifier of the form
26134 : : type-constraint opt auto can be used as a decl-specifier of the
26135 : : decl-specifier-seq of a parameter-declaration of a function declaration
26136 : : or lambda-expression..." but we must not synthesize an implicit template
26137 : : type parameter in its declarator. That is, in "void f(auto[auto{10}]);"
26138 : : we want to synthesize only the first auto. */
26139 : 271076099 : auto cleanup = make_temp_override
26140 : 271076099 : (parser->auto_is_implicit_function_template_parm_p, false);
26141 : :
26142 : : /* Complain about missing 'typename' or other invalid type names. */
26143 : 271076099 : if (!decl_specifiers.any_type_specifiers_p
26144 : 271076099 : && cp_parser_parse_and_diagnose_invalid_type_name (parser))
26145 : 21 : decl_specifiers.type = error_mark_node;
26146 : :
26147 : : /* If an error occurred, there's no reason to attempt to parse the
26148 : : rest of the declaration. */
26149 : 542152198 : if (cp_parser_error_occurred (parser))
26150 : : {
26151 : 6958100 : parser->type_definition_forbidden_message = saved_message;
26152 : 6958100 : return NULL;
26153 : : }
26154 : :
26155 : : /* Peek at the next token. */
26156 : 264117999 : token = cp_lexer_peek_token (parser->lexer);
26157 : :
26158 : : /* If the next token is a `)', `,', `=', `>', or `...', then there
26159 : : is no declarator. However, when variadic templates are enabled,
26160 : : there may be a declarator following `...'. */
26161 : 264117999 : if (token->type == CPP_CLOSE_PAREN
26162 : : || token->type == CPP_COMMA
26163 : : || token->type == CPP_EQ
26164 : : || token->type == CPP_GREATER)
26165 : : {
26166 : 21544107 : declarator = NULL;
26167 : 21544107 : if (parenthesized_p)
26168 : 20008926 : *parenthesized_p = false;
26169 : : }
26170 : : /* Otherwise, there should be a declarator. */
26171 : : else
26172 : : {
26173 : 242573892 : bool saved_default_arg_ok_p = parser->default_arg_ok_p;
26174 : 242573892 : parser->default_arg_ok_p = false;
26175 : :
26176 : : /* After seeing a decl-specifier-seq, if the next token is not a
26177 : : "(" or "{", there is no possibility that the code is a valid
26178 : : expression. Therefore, if parsing tentatively, we commit at
26179 : : this point. */
26180 : 242573892 : if (!parser->in_template_argument_list_p
26181 : : /* In an expression context, having seen:
26182 : :
26183 : : (int((char ...
26184 : :
26185 : : we cannot be sure whether we are looking at a
26186 : : function-type (taking a "char" as a parameter) or a cast
26187 : : of some object of type "char" to "int". */
26188 : 241502843 : && !parser->in_type_id_in_expr_p
26189 : 308764856 : && cp_parser_uncommitted_to_tentative_parse_p (parser)
26190 : 308764856 : && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
26191 : : {
26192 : 65759158 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
26193 : : {
26194 : 193 : if (decl_specifiers.type
26195 : 193 : && template_placeholder_p (decl_specifiers.type))
26196 : : /* This is a CTAD expression, not a parameter declaration. */
26197 : 242573895 : cp_parser_simulate_error (parser);
26198 : : }
26199 : : else
26200 : 65758965 : cp_parser_commit_to_tentative_parse (parser);
26201 : : }
26202 : : /* Parse the declarator. */
26203 : 242573892 : declarator_token_start = token;
26204 : 242573892 : declarator = cp_parser_declarator (parser,
26205 : : CP_PARSER_DECLARATOR_EITHER,
26206 : : CP_PARSER_FLAGS_NONE,
26207 : : /*ctor_dtor_or_conv_p=*/NULL,
26208 : : parenthesized_p,
26209 : : /*member_p=*/false,
26210 : : /*friend_p=*/false,
26211 : : /*static_p=*/false);
26212 : 242573892 : parser->default_arg_ok_p = saved_default_arg_ok_p;
26213 : : /* After the declarator, allow more attributes. */
26214 : 242573892 : decl_specifiers.attributes
26215 : 242573892 : = attr_chainon (decl_specifiers.attributes,
26216 : : cp_parser_attributes_opt (parser));
26217 : :
26218 : : /* If the declarator is a template parameter pack, remember that and
26219 : : clear the flag in the declarator itself so we don't get errors
26220 : : from grokdeclarator. */
26221 : 242573892 : if (template_parm_p && declarator && declarator->parameter_pack_p)
26222 : : {
26223 : 594045 : declarator->parameter_pack_p = false;
26224 : 594045 : template_parameter_pack_p = true;
26225 : : }
26226 : : }
26227 : :
26228 : : /* If the next token is an ellipsis, and we have not seen a declarator
26229 : : name, and if either the type of the declarator contains parameter
26230 : : packs but it is not a TYPE_PACK_EXPANSION or is null (this happens
26231 : : for, eg, abbreviated integral type names), then we actually have a
26232 : : parameter pack expansion expression. Otherwise, leave the ellipsis
26233 : : for a C-style variadic function. */
26234 : 264117999 : token = cp_lexer_peek_token (parser->lexer);
26235 : :
26236 : 264117999 : bool xobj_param_p
26237 : 264117999 : = decl_spec_seq_has_spec_p (&decl_specifiers, ds_this);
26238 : 264117999 : if (xobj_param_p
26239 : 17495 : && (template_parm_p || current_binding_level->requires_expression))
26240 : : {
26241 : 4 : if (template_parm_p)
26242 : 6 : error_at (decl_specifiers.locations[ds_this],
26243 : : "%<this%> specifier in template parameter declaration");
26244 : : else
26245 : 4 : error_at (decl_specifiers.locations[ds_this],
26246 : : "%<this%> specifier in a requires-expression parameter");
26247 : 10 : xobj_param_p = false;
26248 : 10 : decl_specifiers.locations[ds_this] = 0;
26249 : : }
26250 : :
26251 : : /* If a function parameter pack was specified and an implicit template
26252 : : parameter was introduced during cp_parser_parameter_declaration,
26253 : : change any implicit parameters introduced into packs. */
26254 : 264117999 : if (parser->implicit_template_parms
26255 : 264117999 : && ((token->type == CPP_ELLIPSIS
26256 : 130 : && declarator_can_be_parameter_pack (declarator))
26257 : 357121 : || (declarator && declarator->parameter_pack_p)))
26258 : : {
26259 : 34500 : int latest_template_parm_idx = TREE_VEC_LENGTH
26260 : : (INNERMOST_TEMPLATE_PARMS (current_template_parms));
26261 : :
26262 : 34500 : if (latest_template_parm_idx != template_parm_idx)
26263 : 34497 : decl_specifiers.type
26264 : 34497 : = convert_generic_types_to_packs (decl_specifiers.type,
26265 : : template_parm_idx,
26266 : : latest_template_parm_idx);
26267 : : }
26268 : :
26269 : 264117999 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
26270 : : {
26271 : 1363362 : tree type = decl_specifiers.type;
26272 : :
26273 : 1363362 : if (type && DECL_P (type))
26274 : 1343098 : type = TREE_TYPE (type);
26275 : :
26276 : 1343098 : if (((type
26277 : 1363350 : && TREE_CODE (type) != TYPE_PACK_EXPANSION
26278 : 1363350 : && (template_parm_p || uses_parameter_packs (type)))
26279 : 149 : || (!type && template_parm_p))
26280 : 2706323 : && declarator_can_be_parameter_pack (declarator))
26281 : : {
26282 : : /* Consume the `...'. */
26283 : 1363225 : cp_lexer_consume_token (parser->lexer);
26284 : 1363225 : maybe_warn_variadic_templates ();
26285 : :
26286 : : /* Build a pack expansion type */
26287 : 1363225 : if (template_parm_p)
26288 : : template_parameter_pack_p = true;
26289 : 1349638 : else if (declarator)
26290 : 139559 : declarator->parameter_pack_p = true;
26291 : : else
26292 : 1210079 : decl_specifiers.type = make_pack_expansion (type);
26293 : : }
26294 : : }
26295 : :
26296 : 264117999 : if (xobj_param_p
26297 : 17485 : && ((declarator && declarator->parameter_pack_p)
26298 : 17413 : || (decl_specifiers.type
26299 : 17405 : && PACK_EXPANSION_P (decl_specifiers.type))))
26300 : : {
26301 : 80 : location_t xobj_param
26302 : 80 : = make_location (decl_specifiers.locations[ds_this],
26303 : : decl_spec_token_start->location,
26304 : : input_location);
26305 : 80 : error_at (xobj_param,
26306 : : "an explicit object parameter cannot "
26307 : : "be a function parameter pack");
26308 : 80 : xobj_param_p = false;
26309 : 80 : decl_specifiers.locations[ds_this] = 0;
26310 : : }
26311 : :
26312 : : /* The restriction on defining new types applies only to the type
26313 : : of the parameter, not to the default argument. */
26314 : 264117999 : parser->type_definition_forbidden_message = saved_message;
26315 : 264117999 : cp_token *eq_token = NULL;
26316 : : /* If the next token is `=', then process a default argument. */
26317 : 264117999 : if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
26318 : : {
26319 : 9426813 : tree type = decl_specifiers.type;
26320 : 9426813 : token = cp_lexer_peek_token (parser->lexer);
26321 : : /* Used for diagnostics with an xobj parameter. */
26322 : 9426813 : eq_token = token;
26323 : 9426813 : if (declarator)
26324 : 7491989 : declarator->init_loc = token->location;
26325 : : /* If we are defining a class, then the tokens that make up the
26326 : : default argument must be saved and processed later. */
26327 : 7300233 : if (!template_parm_p && at_class_scope_p ()
26328 : 5726365 : && TYPE_BEING_DEFINED (current_class_type)
26329 : 20879323 : && !LAMBDA_TYPE_P (current_class_type))
26330 : 5726214 : default_argument = cp_parser_cache_defarg (parser, /*nsdmi=*/false);
26331 : :
26332 : : /* A constrained-type-specifier may declare a type
26333 : : template-parameter. */
26334 : 3700599 : else if (declares_constrained_type_template_parameter (type))
26335 : 144664 : default_argument
26336 : 144664 : = cp_parser_default_type_template_argument (parser);
26337 : :
26338 : : /* Outside of a class definition, we can just parse the
26339 : : assignment-expression. */
26340 : : else
26341 : 3555935 : default_argument
26342 : 3555935 : = cp_parser_default_argument (parser, template_parm_p);
26343 : :
26344 : 9426813 : if (!parser->default_arg_ok_p)
26345 : : {
26346 : 6 : permerror (token->location,
26347 : : "default arguments are only "
26348 : : "permitted for function parameters");
26349 : : }
26350 : 9426807 : else if ((declarator && declarator->parameter_pack_p)
26351 : 9426804 : || template_parameter_pack_p
26352 : 9426786 : || (decl_specifiers.type
26353 : 9360249 : && PACK_EXPANSION_P (decl_specifiers.type)))
26354 : : {
26355 : : /* Find the name of the parameter pack. */
26356 : : cp_declarator *id_declarator = declarator;
26357 : 30 : while (id_declarator && id_declarator->kind != cdk_id)
26358 : 6 : id_declarator = id_declarator->declarator;
26359 : :
26360 : 24 : if (id_declarator && id_declarator->kind == cdk_id)
26361 : 15 : error_at (declarator_token_start->location,
26362 : : template_parm_p
26363 : : ? G_("template parameter pack %qD "
26364 : : "cannot have a default argument")
26365 : : : G_("parameter pack %qD cannot have "
26366 : : "a default argument"),
26367 : : id_declarator->u.id.unqualified_name);
26368 : : else
26369 : 15 : error_at (declarator_token_start->location,
26370 : : template_parm_p
26371 : : ? G_("template parameter pack cannot have "
26372 : : "a default argument")
26373 : : : G_("parameter pack cannot have a "
26374 : : "default argument"));
26375 : :
26376 : : default_argument = NULL_TREE;
26377 : : }
26378 : : }
26379 : : else
26380 : : default_argument = NULL_TREE;
26381 : :
26382 : 9426789 : if (default_argument)
26383 : 9426789 : STRIP_ANY_LOCATION_WRAPPER (default_argument);
26384 : :
26385 : 264117999 : if (xobj_param_p)
26386 : : {
26387 : 17405 : if (default_argument)
26388 : : {
26389 : : /* If there is a default_argument, eq_token should always be set. */
26390 : 12 : gcc_assert (eq_token);
26391 : 12 : location_t param_with_init_loc
26392 : 12 : = make_location (eq_token->location,
26393 : : decl_spec_token_start->location,
26394 : : input_location);
26395 : 12 : error_at (param_with_init_loc,
26396 : : "an explicit object parameter "
26397 : : "may not have a default argument");
26398 : : }
26399 : : /* Xobj parameters can not have default arguments, thus
26400 : : we can reuse the default argument field to flag the param as such. */
26401 : 17405 : default_argument = this_identifier;
26402 : : }
26403 : :
26404 : : /* Generate a location for the parameter, ranging from the start of the
26405 : : initial token to the end of the final token (using input_location for
26406 : : the latter, set up by cp_lexer_set_source_position_from_token when
26407 : : consuming tokens).
26408 : :
26409 : : If we have a identifier, then use it for the caret location, e.g.
26410 : :
26411 : : extern int callee (int one, int (*two)(int, int), float three);
26412 : : ~~~~~~^~~~~~~~~~~~~~
26413 : :
26414 : : otherwise, reuse the start location for the caret location e.g.:
26415 : :
26416 : : extern int callee (int one, int (*)(int, int), float three);
26417 : : ^~~~~~~~~~~~~~~~~
26418 : :
26419 : : */
26420 : 241349906 : location_t caret_loc = (declarator && declarator->id_loc != UNKNOWN_LOCATION
26421 : 282737062 : ? declarator->id_loc
26422 : : : decl_spec_token_start->location);
26423 : 264117999 : location_t param_loc = make_location (caret_loc,
26424 : : decl_spec_token_start->location,
26425 : : input_location);
26426 : :
26427 : 264117999 : return make_parameter_declarator (&decl_specifiers,
26428 : : declarator,
26429 : : default_argument,
26430 : : param_loc,
26431 : 264117999 : template_parameter_pack_p);
26432 : 271076099 : }
26433 : :
26434 : : /* Parse a default argument and return it.
26435 : :
26436 : : TEMPLATE_PARM_P is true if this is a default argument for a
26437 : : non-type template parameter. */
26438 : : static tree
26439 : 3555935 : cp_parser_default_argument (cp_parser *parser, bool template_parm_p)
26440 : : {
26441 : 3555935 : tree default_argument = NULL_TREE;
26442 : 3555935 : bool saved_greater_than_is_operator_p;
26443 : 3555935 : unsigned char saved_local_variables_forbidden_p;
26444 : :
26445 : : /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
26446 : : set correctly. */
26447 : 3555935 : saved_greater_than_is_operator_p = parser->greater_than_is_operator_p;
26448 : 3555935 : parser->greater_than_is_operator_p = !template_parm_p;
26449 : 3555935 : auto odsd = make_temp_override (parser->omp_declare_simd, NULL);
26450 : 3555935 : auto ord = make_temp_override (parser->oacc_routine, NULL);
26451 : 3555935 : auto oafp = make_temp_override (parser->omp_attrs_forbidden_p, false);
26452 : :
26453 : : /* Local variable names (and the `this' keyword) may not
26454 : : appear in a default argument. */
26455 : 3555935 : saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
26456 : 3555935 : parser->local_variables_forbidden_p = LOCAL_VARS_AND_THIS_FORBIDDEN;
26457 : : /* Parse the assignment-expression. */
26458 : 3555935 : if (template_parm_p)
26459 : 1981916 : push_deferring_access_checks (dk_no_deferred);
26460 : 3555935 : tree saved_class_ptr = NULL_TREE;
26461 : 3555935 : tree saved_class_ref = NULL_TREE;
26462 : : /* The "this" pointer is not valid in a default argument. */
26463 : 3555935 : if (cfun)
26464 : : {
26465 : 2157 : saved_class_ptr = current_class_ptr;
26466 : 2157 : cp_function_chain->x_current_class_ptr = NULL_TREE;
26467 : 2157 : saved_class_ref = current_class_ref;
26468 : 2157 : cp_function_chain->x_current_class_ref = NULL_TREE;
26469 : : }
26470 : 3555935 : default_argument = cp_parser_initializer (parser);
26471 : : /* Restore the "this" pointer. */
26472 : 3555935 : if (cfun)
26473 : : {
26474 : 2157 : cp_function_chain->x_current_class_ptr = saved_class_ptr;
26475 : 2157 : cp_function_chain->x_current_class_ref = saved_class_ref;
26476 : : }
26477 : 3555935 : if (BRACE_ENCLOSED_INITIALIZER_P (default_argument))
26478 : 86780 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
26479 : 3555935 : if (template_parm_p)
26480 : 1981916 : pop_deferring_access_checks ();
26481 : 3555935 : parser->greater_than_is_operator_p = saved_greater_than_is_operator_p;
26482 : 3555935 : parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
26483 : :
26484 : 3555935 : return default_argument;
26485 : 3555935 : }
26486 : :
26487 : : /* Parse a function-body.
26488 : :
26489 : : function-body:
26490 : : compound_statement */
26491 : :
26492 : : static void
26493 : 101863812 : cp_parser_function_body (cp_parser *parser, bool in_function_try_block)
26494 : : {
26495 : 203128423 : cp_parser_compound_statement (parser, NULL, (in_function_try_block
26496 : : ? BCS_TRY_BLOCK : BCS_NORMAL),
26497 : : true);
26498 : 101264873 : }
26499 : :
26500 : : /* Parse a ctor-initializer-opt followed by a function-body. Return
26501 : : true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
26502 : : is true we are parsing a function-try-block. */
26503 : :
26504 : : static void
26505 : 101264897 : cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser,
26506 : : bool in_function_try_block)
26507 : : {
26508 : 101264897 : tree body, list;
26509 : 101264897 : const bool check_body_p
26510 : 101264897 : = (DECL_CONSTRUCTOR_P (current_function_decl)
26511 : 101264897 : && DECL_DECLARED_CONSTEXPR_P (current_function_decl));
26512 : 101264897 : tree last = NULL;
26513 : :
26514 : 101264897 : if (in_function_try_block
26515 : 286 : && DECL_DECLARED_CONSTEXPR_P (current_function_decl)
26516 : 101264951 : && cxx_dialect < cxx20)
26517 : : {
26518 : 36 : if (DECL_CONSTRUCTOR_P (current_function_decl))
26519 : 18 : pedwarn (input_location, OPT_Wc__20_extensions,
26520 : : "function-try-block body of %<constexpr%> constructor only "
26521 : : "available with %<-std=c++20%> or %<-std=gnu++20%>");
26522 : : else
26523 : 18 : pedwarn (input_location, OPT_Wc__20_extensions,
26524 : : "function-try-block body of %<constexpr%> function only "
26525 : : "available with %<-std=c++20%> or %<-std=gnu++20%>");
26526 : : }
26527 : :
26528 : : /* Begin the function body. */
26529 : 101264897 : body = begin_function_body ();
26530 : : /* Parse the optional ctor-initializer. */
26531 : 101264897 : cp_parser_ctor_initializer_opt (parser);
26532 : :
26533 : : /* If we're parsing a constexpr constructor definition, we need
26534 : : to check that the constructor body is indeed empty. However,
26535 : : before we get to cp_parser_function_body lot of junk has been
26536 : : generated, so we can't just check that we have an empty block.
26537 : : Rather we take a snapshot of the outermost block, and check whether
26538 : : cp_parser_function_body changed its state. */
26539 : 101264897 : if (check_body_p)
26540 : : {
26541 : 3033627 : list = cur_stmt_list;
26542 : 3033627 : if (STATEMENT_LIST_TAIL (list))
26543 : 2977186 : last = STATEMENT_LIST_TAIL (list)->stmt;
26544 : : }
26545 : : /* Parse the function-body. */
26546 : 101264897 : cp_parser_function_body (parser, in_function_try_block);
26547 : 101264873 : if (check_body_p)
26548 : 3033627 : check_constexpr_ctor_body (last, list, /*complain=*/true);
26549 : : /* Finish the function body. */
26550 : 101264873 : finish_function_body (body);
26551 : 101264873 : }
26552 : :
26553 : : /* Parse an initializer.
26554 : :
26555 : : initializer:
26556 : : = initializer-clause
26557 : : ( expression-list )
26558 : :
26559 : : Returns an expression representing the initializer. If no
26560 : : initializer is present, NULL_TREE is returned.
26561 : :
26562 : : *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
26563 : : production is used, and TRUE otherwise. *IS_DIRECT_INIT is
26564 : : set to TRUE if there is no initializer present. If there is an
26565 : : initializer, and it is not a constant-expression, *NON_CONSTANT_P
26566 : : is set to true; otherwise it is set to false. */
26567 : :
26568 : : static tree
26569 : 56512067 : cp_parser_initializer (cp_parser *parser, bool *is_direct_init /*=nullptr*/,
26570 : : bool *non_constant_p /*=nullptr*/, bool subexpression_p)
26571 : : {
26572 : 56512067 : cp_token *token;
26573 : 56512067 : tree init;
26574 : :
26575 : : /* Peek at the next token. */
26576 : 56512067 : token = cp_lexer_peek_token (parser->lexer);
26577 : :
26578 : : /* Let our caller know whether or not this initializer was
26579 : : parenthesized. */
26580 : 56512067 : if (is_direct_init)
26581 : 46189409 : *is_direct_init = (token->type != CPP_EQ);
26582 : : /* Assume that the initializer is constant. */
26583 : 56512067 : if (non_constant_p)
26584 : 46190051 : *non_constant_p = false;
26585 : :
26586 : 56512067 : if (token->type == CPP_EQ)
26587 : : {
26588 : : /* Consume the `='. */
26589 : 50511717 : cp_lexer_consume_token (parser->lexer);
26590 : : /* Parse the initializer-clause. */
26591 : 50511717 : init = cp_parser_initializer_clause (parser, non_constant_p);
26592 : : }
26593 : 6000350 : else if (token->type == CPP_OPEN_PAREN)
26594 : : {
26595 : 4811454 : vec<tree, va_gc> *vec;
26596 : 4811454 : vec = cp_parser_parenthesized_expression_list (parser, non_attr,
26597 : : /*cast_p=*/false,
26598 : : /*allow_expansion_p=*/true,
26599 : : non_constant_p);
26600 : 4811454 : if (vec == NULL)
26601 : 12 : return error_mark_node;
26602 : 4811442 : init = build_tree_list_vec (vec);
26603 : 4811442 : release_tree_vector (vec);
26604 : : }
26605 : 1188896 : else if (token->type == CPP_OPEN_BRACE)
26606 : : {
26607 : 1188896 : cp_lexer_set_source_position (parser->lexer);
26608 : 1188896 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
26609 : 1188896 : init = cp_parser_braced_list (parser, non_constant_p);
26610 : 1188896 : CONSTRUCTOR_IS_DIRECT_INIT (init) = 1;
26611 : : }
26612 : : else
26613 : : {
26614 : : /* Anything else is an error. */
26615 : 0 : cp_parser_error (parser, "expected initializer");
26616 : 0 : init = error_mark_node;
26617 : : }
26618 : :
26619 : 56512052 : if (!subexpression_p && check_for_bare_parameter_packs (init))
26620 : 18 : init = error_mark_node;
26621 : :
26622 : : return init;
26623 : : }
26624 : :
26625 : : /* Parse an initializer-clause.
26626 : :
26627 : : initializer-clause:
26628 : : assignment-expression
26629 : : braced-init-list
26630 : :
26631 : : Returns an expression representing the initializer.
26632 : :
26633 : : If the `assignment-expression' production is used the value
26634 : : returned is simply a representation for the expression.
26635 : :
26636 : : Otherwise, calls cp_parser_braced_list. */
26637 : :
26638 : : static cp_expr
26639 : 120627928 : cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
26640 : : {
26641 : 120627928 : cp_expr initializer;
26642 : :
26643 : : /* Assume the expression is constant. */
26644 : 120627928 : if (non_constant_p)
26645 : 51866335 : *non_constant_p = false;
26646 : :
26647 : : /* If it is not a `{', then we are looking at an
26648 : : assignment-expression. */
26649 : 120627928 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
26650 : : {
26651 : 117544041 : initializer
26652 : 117544041 : = cp_parser_constant_expression (parser,
26653 : : /*allow_non_constant_p=*/2,
26654 : : non_constant_p);
26655 : : }
26656 : : else
26657 : 3083887 : initializer = cp_parser_braced_list (parser, non_constant_p);
26658 : :
26659 : 120627923 : return initializer;
26660 : : }
26661 : :
26662 : : /* Parse a brace-enclosed initializer list.
26663 : :
26664 : : braced-init-list:
26665 : : { initializer-list , [opt] }
26666 : : { designated-initializer-list , [opt] }
26667 : : { }
26668 : :
26669 : : Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
26670 : : the elements of the initializer-list (or NULL, if the last
26671 : : production is used). The TREE_TYPE for the CONSTRUCTOR will be
26672 : : NULL_TREE. There is no way to detect whether or not the optional
26673 : : trailing `,' was provided. NON_CONSTANT_P is as for
26674 : : cp_parser_initializer. */
26675 : :
26676 : : static cp_expr
26677 : 9406528 : cp_parser_braced_list (cp_parser *parser, bool *non_constant_p /*=nullptr*/)
26678 : : {
26679 : 9406528 : tree initializer;
26680 : 9406528 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
26681 : 9406528 : auto oas = make_temp_override (parser->omp_array_section_p, false);
26682 : :
26683 : : /* Consume the `{' token. */
26684 : 9406528 : matching_braces braces;
26685 : 9406528 : bool found_opening_brace = braces.require_open (parser);
26686 : : /* Create a CONSTRUCTOR to represent the braced-initializer. */
26687 : 9406528 : initializer = make_node (CONSTRUCTOR);
26688 : : /* If it's not a `}', then there is a non-trivial initializer. */
26689 : 9406528 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
26690 : : {
26691 : 5299158 : bool designated;
26692 : : /* Parse the initializer list. */
26693 : 10598316 : CONSTRUCTOR_ELTS (initializer)
26694 : 5299158 : = cp_parser_initializer_list (parser, non_constant_p, &designated);
26695 : 5299158 : CONSTRUCTOR_IS_DESIGNATED_INIT (initializer) = designated;
26696 : : /* A trailing `,' token is allowed. */
26697 : 5299158 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
26698 : 74157 : cp_lexer_consume_token (parser->lexer);
26699 : : }
26700 : 4107370 : else if (non_constant_p)
26701 : 685941 : *non_constant_p = false;
26702 : : /* Now, there should be a trailing `}'. */
26703 : 9406528 : cp_token * token = cp_lexer_peek_token (parser->lexer);
26704 : 9406528 : location_t finish_loc = token->location;
26705 : : /* The part with CPP_SEMICOLON is just a heuristic. */
26706 : 9406558 : if (!braces.require_close (parser) && token->type != CPP_SEMICOLON
26707 : 9406549 : && found_opening_brace && cp_parser_skip_to_closing_brace (parser))
26708 : : {
26709 : 15 : cp_lexer_consume_token (parser->lexer);
26710 : 15 : inform (finish_loc,
26711 : : "probably missing a comma or an operator before");
26712 : : }
26713 : 9406528 : TREE_TYPE (initializer) = init_list_type_node;
26714 : 9406528 : recompute_constructor_flags (initializer);
26715 : :
26716 : 9406528 : cp_expr result (initializer);
26717 : : /* Build a location of the form:
26718 : : { ... }
26719 : : ^~~~~~~
26720 : : with caret==start at the open brace, finish at the close brace. */
26721 : 9406528 : location_t combined_loc = make_location (start_loc, start_loc, finish_loc);
26722 : 9406528 : result.set_location (combined_loc);
26723 : 9406528 : return result;
26724 : 9406528 : }
26725 : :
26726 : : /* Consume tokens up to, but not including, the next non-nested closing `]'.
26727 : : Returns true iff we found a closing `]'. */
26728 : :
26729 : : static bool
26730 : 278 : cp_parser_skip_up_to_closing_square_bracket (cp_parser *parser)
26731 : : {
26732 : 278 : unsigned square_depth = 0;
26733 : :
26734 : 830 : while (true)
26735 : : {
26736 : 554 : cp_token * token = cp_lexer_peek_token (parser->lexer);
26737 : :
26738 : 554 : switch (token->type)
26739 : : {
26740 : 0 : case CPP_PRAGMA_EOL:
26741 : 0 : if (!parser->lexer->in_pragma)
26742 : : break;
26743 : : /* FALLTHRU */
26744 : :
26745 : : case CPP_EOF:
26746 : : /* If we've run out of tokens, then there is no closing `]'. */
26747 : : return false;
26748 : :
26749 : 0 : case CPP_OPEN_SQUARE:
26750 : 0 : ++square_depth;
26751 : 0 : break;
26752 : :
26753 : 278 : case CPP_CLOSE_SQUARE:
26754 : 278 : if (!square_depth--)
26755 : : return true;
26756 : : break;
26757 : :
26758 : : default:
26759 : : break;
26760 : : }
26761 : :
26762 : : /* Consume the current token, skipping it. */
26763 : 276 : cp_lexer_consume_token (parser->lexer);
26764 : 276 : }
26765 : : }
26766 : :
26767 : : /* Consume tokens up to, and including, the next non-nested closing `]'.
26768 : : Returns true iff we found a closing `]'. */
26769 : :
26770 : : static bool
26771 : 265 : cp_parser_skip_to_closing_square_bracket (cp_parser *parser)
26772 : : {
26773 : 265 : bool found = cp_parser_skip_up_to_closing_square_bracket (parser);
26774 : 265 : if (found)
26775 : 265 : cp_lexer_consume_token (parser->lexer);
26776 : 265 : return found;
26777 : : }
26778 : :
26779 : : /* Return true if we are looking at an array-designator, false otherwise. */
26780 : :
26781 : : static bool
26782 : 253 : cp_parser_array_designator_p (cp_parser *parser)
26783 : : {
26784 : : /* Consume the `['. */
26785 : 253 : cp_lexer_consume_token (parser->lexer);
26786 : :
26787 : 253 : cp_lexer_save_tokens (parser->lexer);
26788 : :
26789 : : /* Skip tokens until the next token is a closing square bracket.
26790 : : If we find the closing `]', and the next token is a `=', then
26791 : : we are looking at an array designator. */
26792 : 253 : bool array_designator_p
26793 : 253 : = (cp_parser_skip_to_closing_square_bracket (parser)
26794 : 253 : && cp_lexer_next_token_is (parser->lexer, CPP_EQ));
26795 : :
26796 : : /* Roll back the tokens we skipped. */
26797 : 253 : cp_lexer_rollback_tokens (parser->lexer);
26798 : :
26799 : 253 : return array_designator_p;
26800 : : }
26801 : :
26802 : : /* Parse an initializer-list.
26803 : :
26804 : : initializer-list:
26805 : : initializer-clause ... [opt]
26806 : : initializer-list , initializer-clause ... [opt]
26807 : :
26808 : : C++20 Extension:
26809 : :
26810 : : designated-initializer-list:
26811 : : designated-initializer-clause
26812 : : designated-initializer-list , designated-initializer-clause
26813 : :
26814 : : designated-initializer-clause:
26815 : : designator brace-or-equal-initializer
26816 : :
26817 : : designator:
26818 : : . identifier
26819 : :
26820 : : GNU Extension:
26821 : :
26822 : : initializer-list:
26823 : : designation initializer-clause ...[opt]
26824 : : initializer-list , designation initializer-clause ...[opt]
26825 : :
26826 : : designation:
26827 : : . identifier =
26828 : : identifier :
26829 : : [ constant-expression ] =
26830 : :
26831 : : Returns a vec of constructor_elt. The VALUE of each elt is an expression
26832 : : for the initializer. If the INDEX of the elt is non-NULL, it is the
26833 : : IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
26834 : : as for cp_parser_initializer. Set *DESIGNATED to a boolean whether there
26835 : : are any designators. */
26836 : :
26837 : : static vec<constructor_elt, va_gc> *
26838 : 5299158 : cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p,
26839 : : bool *designated)
26840 : : {
26841 : 5299158 : vec<constructor_elt, va_gc> *v = NULL;
26842 : 5299158 : bool first_p = true;
26843 : 5299158 : tree first_designator = NULL_TREE;
26844 : :
26845 : : /* Assume all of the expressions are constant. */
26846 : 5299158 : if (non_constant_p)
26847 : 972508 : *non_constant_p = false;
26848 : :
26849 : 5299158 : unsigned nelts = 0;
26850 : 5299158 : int suppress = suppress_location_wrappers;
26851 : :
26852 : : /* Parse the rest of the list. */
26853 : 35438352 : while (true)
26854 : : {
26855 : 20368755 : cp_token *token;
26856 : 20368755 : tree designator;
26857 : 20368755 : tree initializer;
26858 : 20368755 : bool clause_non_constant_p;
26859 : 20368755 : bool direct_p = false;
26860 : 20368755 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
26861 : :
26862 : : /* Handle the C++20 syntax, '. id ='. */
26863 : 20368755 : if ((cxx_dialect >= cxx20
26864 : 6932016 : || cp_parser_allow_gnu_extensions_p (parser))
26865 : 20368755 : && cp_lexer_next_token_is (parser->lexer, CPP_DOT)
26866 : 4138 : && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_NAME
26867 : 20372893 : && (cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_EQ
26868 : 19 : || (cp_lexer_peek_nth_token (parser->lexer, 3)->type
26869 : : == CPP_OPEN_BRACE)))
26870 : : {
26871 : 4138 : if (pedantic && cxx_dialect < cxx20)
26872 : 54 : pedwarn (loc, OPT_Wc__20_extensions,
26873 : : "C++ designated initializers only available with "
26874 : : "%<-std=c++20%> or %<-std=gnu++20%>");
26875 : : /* Consume the `.'. */
26876 : 4138 : cp_lexer_consume_token (parser->lexer);
26877 : : /* Consume the identifier. */
26878 : 4138 : designator = cp_lexer_consume_token (parser->lexer)->u.value;
26879 : 4138 : if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
26880 : : /* Consume the `='. */
26881 : 4119 : cp_lexer_consume_token (parser->lexer);
26882 : : else
26883 : : direct_p = true;
26884 : : }
26885 : : /* Also, if the next token is an identifier and the following one is a
26886 : : colon, we are looking at the GNU designated-initializer
26887 : : syntax. */
26888 : 20364617 : else if (cp_parser_allow_gnu_extensions_p (parser)
26889 : 20364617 : && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
26890 : 4762456 : && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
26891 : : == CPP_COLON))
26892 : : {
26893 : : /* Warn the user that they are using an extension. */
26894 : 83 : pedwarn (loc, OPT_Wpedantic,
26895 : : "ISO C++ does not allow GNU designated initializers");
26896 : : /* Consume the identifier. */
26897 : 83 : designator = cp_lexer_consume_token (parser->lexer)->u.value;
26898 : : /* Consume the `:'. */
26899 : 83 : cp_lexer_consume_token (parser->lexer);
26900 : : }
26901 : : /* Also handle C99 array designators, '[ const ] ='. */
26902 : 20364534 : else if (cp_parser_allow_gnu_extensions_p (parser)
26903 : 20364534 : && !c_dialect_objc ()
26904 : 40729068 : && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
26905 : : {
26906 : : /* In C++11, [ could start a lambda-introducer. */
26907 : 253 : bool non_const = false;
26908 : :
26909 : 253 : cp_parser_parse_tentatively (parser);
26910 : :
26911 : 253 : if (!cp_parser_array_designator_p (parser))
26912 : : {
26913 : 406 : cp_parser_simulate_error (parser);
26914 : : designator = NULL_TREE;
26915 : : }
26916 : : else
26917 : : {
26918 : 100 : designator = cp_parser_constant_expression (parser, true,
26919 : : &non_const);
26920 : 100 : cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
26921 : 100 : cp_parser_require (parser, CPP_EQ, RT_EQ);
26922 : : }
26923 : :
26924 : 253 : if (!cp_parser_parse_definitely (parser))
26925 : : designator = NULL_TREE;
26926 : 100 : else if (non_const
26927 : 106 : && (!require_potential_rvalue_constant_expression
26928 : 6 : (designator)))
26929 : : designator = NULL_TREE;
26930 : 94 : if (designator)
26931 : : /* Warn the user that they are using an extension. */
26932 : 94 : pedwarn (loc, OPT_Wpedantic,
26933 : : "ISO C++ does not allow C99 designated initializers");
26934 : : }
26935 : : else
26936 : : designator = NULL_TREE;
26937 : :
26938 : 20368755 : if (first_p)
26939 : : {
26940 : : first_designator = designator;
26941 : : first_p = false;
26942 : : }
26943 : 15069597 : else if (cxx_dialect >= cxx20
26944 : 10567385 : && first_designator != error_mark_node
26945 : 10567375 : && (!first_designator != !designator))
26946 : : {
26947 : 12 : error_at (loc, "either all initializer clauses should be designated "
26948 : : "or none of them should be");
26949 : 12 : first_designator = error_mark_node;
26950 : : }
26951 : 15069585 : else if (cxx_dialect < cxx20 && !first_designator)
26952 : 9801134 : first_designator = designator;
26953 : :
26954 : : /* Parse the initializer. */
26955 : 20368755 : if (cp_lexer_next_token_is (parser->lexer, CPP_EMBED))
26956 : : {
26957 : 155 : initializer = cp_lexer_peek_token (parser->lexer)->u.value;
26958 : 155 : clause_non_constant_p = false;
26959 : 155 : cp_lexer_consume_token (parser->lexer);
26960 : : }
26961 : : else
26962 : 29749772 : initializer = cp_parser_initializer_clause (parser,
26963 : : (non_constant_p != nullptr
26964 : : ? &clause_non_constant_p
26965 : : : nullptr));
26966 : : /* If any clause is non-constant, so is the entire initializer. */
26967 : 20368755 : if (non_constant_p && clause_non_constant_p)
26968 : 111071 : *non_constant_p = true;
26969 : :
26970 : 20368755 : if (TREE_CODE (initializer) == CONSTRUCTOR)
26971 : : /* This uses |= rather than = because C_I_D_I could have been set in
26972 : : cp_parser_functional_cast so we must be careful not to clear the
26973 : : flag. */
26974 : 1922339 : CONSTRUCTOR_IS_DIRECT_INIT (initializer) |= direct_p;
26975 : :
26976 : : /* If we have an ellipsis, this is an initializer pack
26977 : : expansion. */
26978 : 20368755 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
26979 : : {
26980 : 128849 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
26981 : :
26982 : : /* Consume the `...'. */
26983 : 128849 : cp_lexer_consume_token (parser->lexer);
26984 : :
26985 : 128849 : if (designator && cxx_dialect >= cxx20)
26986 : 1 : error_at (loc,
26987 : : "%<...%> not allowed in designated initializer list");
26988 : :
26989 : : /* Turn the initializer into an initializer expansion. */
26990 : 128849 : initializer = make_pack_expansion (initializer);
26991 : : }
26992 : :
26993 : : /* Add it to the vector. */
26994 : 20368755 : CONSTRUCTOR_APPEND_ELT (v, designator, initializer);
26995 : :
26996 : : /* If the next token is not a comma, we have reached the end of
26997 : : the list. */
26998 : 20368755 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
26999 : : break;
27000 : :
27001 : : /* Peek at the next token. */
27002 : 15143754 : token = cp_lexer_peek_nth_token (parser->lexer, 2);
27003 : : /* If the next token is a `}', then we're still done. An
27004 : : initializer-clause can have a trailing `,' after the
27005 : : initializer-list and before the closing `}'. */
27006 : 15143754 : if (token->type == CPP_CLOSE_BRACE)
27007 : : break;
27008 : :
27009 : : /* Suppress location wrappers in a long initializer to save memory
27010 : : (14179). The cutoff is chosen arbitrarily. */
27011 : 15069597 : const unsigned loc_max = 256;
27012 : 15069597 : unsigned incr = 1;
27013 : 15069597 : if (TREE_CODE (initializer) == CONSTRUCTOR)
27014 : : /* Look one level down because it's easy. Looking deeper would require
27015 : : passing down a nelts pointer, and I don't think multi-level massive
27016 : : initializers are common enough to justify this. */
27017 : 1660623 : incr = CONSTRUCTOR_NELTS (initializer);
27018 : 15069597 : nelts += incr;
27019 : 15069597 : if (nelts >= loc_max && (nelts - incr) < loc_max)
27020 : 5813 : ++suppress_location_wrappers;
27021 : :
27022 : : /* Consume the `,' token. */
27023 : 15069597 : cp_lexer_consume_token (parser->lexer);
27024 : 15069597 : }
27025 : :
27026 : : /* The same identifier shall not appear in multiple designators
27027 : : of a designated-initializer-list. */
27028 : 5299158 : if (first_designator)
27029 : : {
27030 : : unsigned int i;
27031 : : tree designator, val;
27032 : 7169 : FOR_EACH_CONSTRUCTOR_ELT (v, i, designator, val)
27033 : 4375 : if (designator && TREE_CODE (designator) == IDENTIFIER_NODE)
27034 : : {
27035 : 4221 : if (IDENTIFIER_MARKED (designator))
27036 : : {
27037 : 6 : error_at (cp_expr_loc_or_input_loc (val),
27038 : : "%<.%s%> designator used multiple times in "
27039 : : "the same initializer list",
27040 : 6 : IDENTIFIER_POINTER (designator));
27041 : 6 : (*v)[i].index = error_mark_node;
27042 : : }
27043 : : else
27044 : 4215 : IDENTIFIER_MARKED (designator) = 1;
27045 : : }
27046 : 7169 : FOR_EACH_CONSTRUCTOR_ELT (v, i, designator, val)
27047 : 4375 : if (designator && TREE_CODE (designator) == IDENTIFIER_NODE)
27048 : 4215 : IDENTIFIER_MARKED (designator) = 0;
27049 : : }
27050 : :
27051 : 5299158 : suppress_location_wrappers = suppress;
27052 : :
27053 : 5299158 : *designated = first_designator != NULL_TREE;
27054 : 5299158 : return v;
27055 : : }
27056 : :
27057 : : /* Classes [gram.class] */
27058 : :
27059 : : /* Parse a class-name.
27060 : :
27061 : : class-name:
27062 : : identifier
27063 : : template-id
27064 : :
27065 : : TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
27066 : : to indicate that names looked up in dependent types should be
27067 : : assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
27068 : : keyword has been used to indicate that the name that appears next
27069 : : is a template. TAG_TYPE indicates the explicit tag given before
27070 : : the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
27071 : : looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
27072 : : is the class being defined in a class-head. If ENUM_OK is TRUE,
27073 : : enum-names are also accepted.
27074 : :
27075 : : Returns the TYPE_DECL representing the class. */
27076 : :
27077 : : static tree
27078 : 2510920764 : cp_parser_class_name (cp_parser *parser,
27079 : : bool typename_keyword_p,
27080 : : bool template_keyword_p,
27081 : : enum tag_types tag_type,
27082 : : bool check_dependency_p,
27083 : : bool class_head_p,
27084 : : bool is_declaration,
27085 : : bool enum_ok)
27086 : : {
27087 : 2510920764 : tree decl;
27088 : 2510920764 : tree identifier = NULL_TREE;
27089 : :
27090 : : /* All class-names start with an identifier. */
27091 : 2510920764 : cp_token *token = cp_lexer_peek_token (parser->lexer);
27092 : 2510920764 : if (token->type != CPP_NAME && token->type != CPP_TEMPLATE_ID)
27093 : : {
27094 : 581998575 : cp_parser_error (parser, "expected class-name");
27095 : 581998575 : return error_mark_node;
27096 : : }
27097 : :
27098 : : /* PARSER->SCOPE can be cleared when parsing the template-arguments
27099 : : to a template-id, so we save it here. Consider object scope too,
27100 : : so that make_typename_type below can use it (cp_parser_template_name
27101 : : considers object scope also). This may happen with code like
27102 : :
27103 : : p->template A<T>::a()
27104 : :
27105 : : where we first want to look up A<T>::a in the class of the object
27106 : : expression, as per [basic.lookup.classref]. */
27107 : 1928922189 : tree scope = parser->scope ? parser->scope : parser->context->object_type;
27108 : : /* This only checks parser->scope to avoid duplicate errors; if
27109 : : ->object_type is erroneous, go on to give a parse error. */
27110 : 1928922189 : if (parser->scope == error_mark_node)
27111 : : return error_mark_node;
27112 : :
27113 : : /* Any name names a type if we're following the `typename' keyword
27114 : : in a qualified name where the enclosing scope is type-dependent. */
27115 : 1928922129 : const bool typename_p = (typename_keyword_p
27116 : 64764976 : && parser->scope
27117 : 7027603 : && TYPE_P (parser->scope)
27118 : 1931158178 : && dependent_scope_p (parser->scope));
27119 : : /* Handle the common case (an identifier, but not a template-id)
27120 : : efficiently. */
27121 : 1928922129 : if (token->type == CPP_NAME
27122 : 1928922129 : && !cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
27123 : : {
27124 : 1498368559 : cp_token *identifier_token;
27125 : 1498368559 : bool ambiguous_p;
27126 : :
27127 : : /* Look for the identifier. */
27128 : 1498368559 : identifier_token = cp_lexer_peek_token (parser->lexer);
27129 : 1498368559 : ambiguous_p = identifier_token->error_reported;
27130 : 1498368559 : identifier = cp_parser_identifier (parser);
27131 : : /* If the next token isn't an identifier, we are certainly not
27132 : : looking at a class-name. */
27133 : 1498368559 : if (identifier == error_mark_node)
27134 : : decl = error_mark_node;
27135 : : /* If we know this is a type-name, there's no need to look it
27136 : : up. */
27137 : 1498368559 : else if (typename_p)
27138 : : decl = identifier;
27139 : : else
27140 : : {
27141 : 1497345084 : tree ambiguous_decls;
27142 : : /* If we already know that this lookup is ambiguous, then
27143 : : we've already issued an error message; there's no reason
27144 : : to check again. */
27145 : 1497345084 : if (ambiguous_p)
27146 : : {
27147 : 0 : cp_parser_simulate_error (parser);
27148 : 221 : return error_mark_node;
27149 : : }
27150 : : /* If the next token is a `::', then the name must be a type
27151 : : name.
27152 : :
27153 : : [basic.lookup.qual]
27154 : :
27155 : : During the lookup for a name preceding the :: scope
27156 : : resolution operator, object, function, and enumerator
27157 : : names are ignored. */
27158 : 1497345084 : if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
27159 : 135507865 : tag_type = scope_type;
27160 : : /* Look up the name. */
27161 : 1497345084 : decl = cp_parser_lookup_name (parser, identifier,
27162 : : tag_type,
27163 : : /*is_template=*/false,
27164 : : /*is_namespace=*/false,
27165 : : check_dependency_p,
27166 : : &ambiguous_decls,
27167 : : identifier_token->location);
27168 : 1497345084 : if (ambiguous_decls)
27169 : : {
27170 : 221 : if (cp_parser_parsing_tentatively (parser))
27171 : 442 : cp_parser_simulate_error (parser);
27172 : 221 : return error_mark_node;
27173 : : }
27174 : : }
27175 : : }
27176 : : else
27177 : : {
27178 : : /* Try a template-id. */
27179 : 430553570 : decl = cp_parser_template_id (parser, template_keyword_p,
27180 : : check_dependency_p,
27181 : : tag_type,
27182 : : is_declaration);
27183 : 430553567 : if (decl == error_mark_node)
27184 : : return error_mark_node;
27185 : : }
27186 : :
27187 : 1898990158 : decl = cp_parser_maybe_treat_template_as_class (decl, class_head_p);
27188 : :
27189 : : /* If this is a typename, create a TYPENAME_TYPE. */
27190 : 1898990158 : if (typename_p && decl != error_mark_node)
27191 : : {
27192 : 1357147 : decl = make_typename_type (scope, decl, typename_type,
27193 : : /*complain=*/tf_error);
27194 : 1357147 : if (decl != error_mark_node)
27195 : 1357147 : decl = TYPE_NAME (decl);
27196 : : }
27197 : :
27198 : : /* Check to see that it is really the name of a class. */
27199 : 1898990158 : if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
27200 : 96347673 : && identifier_p (TREE_OPERAND (decl, 0))
27201 : 1899738564 : && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
27202 : : /* Situations like this:
27203 : :
27204 : : template <typename T> struct A {
27205 : : typename T::template X<int>::I i;
27206 : : };
27207 : :
27208 : : are problematic. Is `T::template X<int>' a class-name? The
27209 : : standard does not seem to be definitive, but there is no other
27210 : : valid interpretation of the following `::'. Therefore, those
27211 : : names are considered class-names. */
27212 : : {
27213 : 113 : decl = make_typename_type (scope, decl, tag_type, tf_error);
27214 : 113 : if (decl != error_mark_node)
27215 : 113 : decl = TYPE_NAME (decl);
27216 : : }
27217 : 1898990045 : else if (TREE_CODE (decl) != TYPE_DECL
27218 : 980345865 : || TREE_TYPE (decl) == error_mark_node
27219 : 980345797 : || !(MAYBE_CLASS_TYPE_P (TREE_TYPE (decl))
27220 : 2367433 : || (enum_ok && TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE))
27221 : : /* In Objective-C 2.0, a classname followed by '.' starts a
27222 : : dot-syntax expression, and it's not a type-name. */
27223 : 2778872723 : || (c_dialect_objc ()
27224 : 0 : && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
27225 : 0 : && objc_is_class_name (decl)))
27226 : 1019107367 : decl = error_mark_node;
27227 : :
27228 : 1898990158 : if (decl == error_mark_node)
27229 : 1019107367 : cp_parser_error (parser, "expected class-name");
27230 : 879882791 : else if (identifier && !parser->scope)
27231 : 564037782 : maybe_note_name_used_in_class (identifier, decl);
27232 : :
27233 : : return decl;
27234 : : }
27235 : :
27236 : : /* Make sure that any member-function parameters are in scope.
27237 : : For instance, a function's noexcept-specifier can use the function's
27238 : : parameters:
27239 : :
27240 : : struct S {
27241 : : void fn (int p) noexcept(noexcept(p));
27242 : : };
27243 : :
27244 : : so we need to make sure name lookup can find them. This is used
27245 : : when we delay parsing of the noexcept-specifier. */
27246 : :
27247 : : static void
27248 : 2381457 : inject_parm_decls (tree decl)
27249 : : {
27250 : 2381457 : begin_scope (sk_function_parms, decl);
27251 : 2381457 : tree args = DECL_ARGUMENTS (decl);
27252 : :
27253 : 2381457 : do_push_parm_decls (decl, args, /*nonparms=*/NULL);
27254 : :
27255 : 2381457 : if (args && is_this_parameter (args))
27256 : : {
27257 : 2233922 : gcc_checking_assert (current_class_ptr == NULL_TREE);
27258 : 2233922 : current_class_ref = cp_build_fold_indirect_ref (args);
27259 : 2233922 : current_class_ptr = args;
27260 : : }
27261 : 2381457 : }
27262 : :
27263 : : /* Undo the effects of inject_parm_decls. */
27264 : :
27265 : : static void
27266 : 2381457 : pop_injected_parms (void)
27267 : : {
27268 : 2381457 : pop_bindings_and_leave_scope ();
27269 : 2381457 : current_class_ptr = current_class_ref = NULL_TREE;
27270 : 2381457 : }
27271 : :
27272 : : /* Parse a class-specifier.
27273 : :
27274 : : class-specifier:
27275 : : class-head { member-specification [opt] }
27276 : :
27277 : : Returns the TREE_TYPE representing the class. */
27278 : :
27279 : : tree
27280 : 35710601 : cp_parser_class_specifier (cp_parser* parser)
27281 : : {
27282 : 35710601 : auto_timevar tv (TV_PARSE_STRUCT);
27283 : :
27284 : 35710601 : tree type;
27285 : 35710601 : tree attributes = NULL_TREE;
27286 : 35710601 : bool nested_name_specifier_p;
27287 : 35710601 : unsigned saved_num_template_parameter_lists;
27288 : 35710601 : bool saved_in_function_body;
27289 : 35710601 : unsigned char in_statement;
27290 : 35710601 : bool in_switch_statement_p;
27291 : 35710601 : bool saved_in_unbraced_linkage_specification_p;
27292 : 35710601 : bool saved_in_unbraced_export_declaration_p;
27293 : 35710601 : tree old_scope = NULL_TREE;
27294 : 35710601 : tree scope = NULL_TREE;
27295 : 35710601 : cp_token *closing_brace;
27296 : :
27297 : 35710601 : push_deferring_access_checks (dk_no_deferred);
27298 : :
27299 : : /* Parse the class-head. */
27300 : 35710601 : type = cp_parser_class_head (parser,
27301 : : &nested_name_specifier_p);
27302 : : /* If the class-head was a semantic disaster, skip the entire body
27303 : : of the class. */
27304 : 35710601 : if (!type)
27305 : : {
27306 : 1134 : cp_parser_skip_to_end_of_block_or_statement (parser);
27307 : 1134 : pop_deferring_access_checks ();
27308 : 1134 : return error_mark_node;
27309 : : }
27310 : :
27311 : : /* Look for the `{'. */
27312 : 35709467 : matching_braces braces;
27313 : 35709467 : if (!braces.require_open (parser))
27314 : : {
27315 : 12063748 : pop_deferring_access_checks ();
27316 : 12063748 : return error_mark_node;
27317 : : }
27318 : :
27319 : 23645719 : cp_ensure_no_omp_declare_simd (parser);
27320 : 23645719 : cp_ensure_no_oacc_routine (parser);
27321 : :
27322 : : /* Issue an error message if type-definitions are forbidden here. */
27323 : 23645719 : bool type_definition_ok_p = cp_parser_check_type_definition (parser);
27324 : : /* Remember that we are defining one more class. */
27325 : 23645719 : ++parser->num_classes_being_defined;
27326 : : /* Inside the class, surrounding template-parameter-lists do not
27327 : : apply. */
27328 : 23645719 : saved_num_template_parameter_lists
27329 : 23645719 : = parser->num_template_parameter_lists;
27330 : 23645719 : parser->num_template_parameter_lists = 0;
27331 : : /* We are not in a function body. */
27332 : 23645719 : saved_in_function_body = parser->in_function_body;
27333 : 23645719 : parser->in_function_body = false;
27334 : : /* Or in a loop. */
27335 : 23645719 : in_statement = parser->in_statement;
27336 : 23645719 : parser->in_statement = 0;
27337 : : /* Or in a switch. */
27338 : 23645719 : in_switch_statement_p = parser->in_switch_statement_p;
27339 : 23645719 : parser->in_switch_statement_p = false;
27340 : : /* We are not immediately inside an extern "lang" block. */
27341 : 23645719 : saved_in_unbraced_linkage_specification_p
27342 : 23645719 : = parser->in_unbraced_linkage_specification_p;
27343 : 23645719 : parser->in_unbraced_linkage_specification_p = false;
27344 : : /* Or in an export-declaration. */
27345 : 23645719 : saved_in_unbraced_export_declaration_p
27346 : 23645719 : = parser->in_unbraced_export_declaration_p;
27347 : 23645719 : parser->in_unbraced_export_declaration_p = false;
27348 : : /* 'this' from an enclosing non-static member function is unavailable. */
27349 : 23645719 : tree saved_ccp = current_class_ptr;
27350 : 23645719 : tree saved_ccr = current_class_ref;
27351 : 23645719 : current_class_ptr = NULL_TREE;
27352 : 23645719 : current_class_ref = NULL_TREE;
27353 : :
27354 : : /* Start the class. */
27355 : 23645719 : if (nested_name_specifier_p)
27356 : : {
27357 : 249622 : scope = CP_DECL_CONTEXT (TYPE_MAIN_DECL (type));
27358 : : /* SCOPE must be a scope nested inside current scope. */
27359 : 249622 : if (is_nested_namespace (current_namespace,
27360 : : decl_namespace_context (scope)))
27361 : 249619 : old_scope = push_inner_scope (scope);
27362 : : else
27363 : 3 : nested_name_specifier_p = false;
27364 : : }
27365 : 23645719 : type = begin_class_definition (type);
27366 : :
27367 : 23645719 : if (type == error_mark_node)
27368 : : /* If the type is erroneous, skip the entire body of the class. */
27369 : 48 : cp_parser_skip_to_closing_brace (parser);
27370 : : else
27371 : : /* Parse the member-specification. */
27372 : 23645671 : cp_parser_member_specification_opt (parser);
27373 : :
27374 : : /* Look for the trailing `}'. */
27375 : 23645710 : closing_brace = braces.require_close (parser);
27376 : : /* Look for trailing attributes to apply to this class. */
27377 : 23645710 : if (cp_parser_allow_gnu_extensions_p (parser))
27378 : 23645710 : attributes = cp_parser_gnu_attributes_opt (parser);
27379 : 23645710 : if (type != error_mark_node)
27380 : 23645662 : type = finish_struct (type, attributes);
27381 : 23645701 : if (nested_name_specifier_p)
27382 : 249619 : pop_inner_scope (old_scope, scope);
27383 : :
27384 : : /* We've finished a type definition. Check for the common syntax
27385 : : error of forgetting a semicolon after the definition. We need to
27386 : : be careful, as we can't just check for not-a-semicolon and be done
27387 : : with it; the user might have typed:
27388 : :
27389 : : class X { } c = ...;
27390 : : class X { } *p = ...;
27391 : :
27392 : : and so forth. Instead, enumerate all the possible tokens that
27393 : : might follow this production; if we don't see one of them, then
27394 : : complain and silently insert the semicolon. */
27395 : 23645698 : {
27396 : 23645698 : cp_token *token = cp_lexer_peek_token (parser->lexer);
27397 : 23645698 : bool want_semicolon = true;
27398 : :
27399 : 23645698 : if (cp_next_tokens_can_be_std_attribute_p (parser))
27400 : : /* Don't try to parse c++11 attributes here. As per the
27401 : : grammar, that should be a task for
27402 : : cp_parser_decl_specifier_seq. */
27403 : 37 : want_semicolon = false;
27404 : :
27405 : 23645698 : switch (token->type)
27406 : : {
27407 : : case CPP_NAME:
27408 : : case CPP_SEMICOLON:
27409 : : case CPP_MULT:
27410 : : case CPP_AND:
27411 : : case CPP_OPEN_PAREN:
27412 : : case CPP_CLOSE_PAREN:
27413 : : case CPP_COMMA:
27414 : : case CPP_SCOPE:
27415 : 23645514 : want_semicolon = false;
27416 : : break;
27417 : :
27418 : : /* While it's legal for type qualifiers and storage class
27419 : : specifiers to follow type definitions in the grammar, only
27420 : : compiler testsuites contain code like that. Assume that if
27421 : : we see such code, then what we're really seeing is a case
27422 : : like:
27423 : :
27424 : : class X { }
27425 : : const <type> var = ...;
27426 : :
27427 : : or
27428 : :
27429 : : class Y { }
27430 : : static <type> func (...) ...
27431 : :
27432 : : i.e. the qualifier or specifier applies to the next
27433 : : declaration. To do so, however, we need to look ahead one
27434 : : more token to see if *that* token is a type specifier.
27435 : :
27436 : : This code could be improved to handle:
27437 : :
27438 : : class Z { }
27439 : : static const <type> var = ...; */
27440 : 14030 : case CPP_KEYWORD:
27441 : 14030 : if (keyword_is_decl_specifier (token->keyword))
27442 : : {
27443 : 13994 : cp_token *lookahead = cp_lexer_peek_nth_token (parser->lexer, 2);
27444 : :
27445 : : /* Handling user-defined types here would be nice, but very
27446 : : tricky. */
27447 : 13994 : want_semicolon
27448 : 13994 : = (lookahead->type == CPP_KEYWORD
27449 : 13994 : && keyword_begins_type_specifier (lookahead->keyword));
27450 : : }
27451 : : break;
27452 : : default:
27453 : : break;
27454 : : }
27455 : :
27456 : : /* If we don't have a type, then something is very wrong and we
27457 : : shouldn't try to do anything clever. Likewise for not seeing the
27458 : : closing brace. */
27459 : 23645698 : if (closing_brace && TYPE_P (type) && want_semicolon)
27460 : : {
27461 : : /* Locate the closing brace. */
27462 : 90 : cp_token_position prev
27463 : 90 : = cp_lexer_previous_token_position (parser->lexer);
27464 : 90 : cp_token *prev_token = cp_lexer_token_at (parser->lexer, prev);
27465 : 90 : location_t loc = prev_token->location;
27466 : :
27467 : : /* We want to suggest insertion of a ';' immediately *after* the
27468 : : closing brace, so, if we can, offset the location by 1 column. */
27469 : 90 : location_t next_loc = loc;
27470 : 90 : if (!linemap_location_from_macro_expansion_p (line_table, loc))
27471 : 90 : next_loc = linemap_position_for_loc_and_offset (line_table, loc, 1);
27472 : :
27473 : 90 : rich_location richloc (line_table, next_loc);
27474 : :
27475 : : /* If we successfully offset the location, suggest the fix-it. */
27476 : 90 : if (next_loc != loc)
27477 : 90 : richloc.add_fixit_insert_before (next_loc, ";");
27478 : :
27479 : 90 : if (CLASSTYPE_DECLARED_CLASS (type))
27480 : 37 : error_at (&richloc,
27481 : : "expected %<;%> after class definition");
27482 : 53 : else if (TREE_CODE (type) == RECORD_TYPE)
27483 : 48 : error_at (&richloc,
27484 : : "expected %<;%> after struct definition");
27485 : 5 : else if (TREE_CODE (type) == UNION_TYPE)
27486 : 5 : error_at (&richloc,
27487 : : "expected %<;%> after union definition");
27488 : : else
27489 : 0 : gcc_unreachable ();
27490 : :
27491 : : /* Unget one token and smash it to look as though we encountered
27492 : : a semicolon in the input stream. */
27493 : 90 : cp_lexer_set_token_position (parser->lexer, prev);
27494 : 90 : token = cp_lexer_peek_token (parser->lexer);
27495 : 90 : token->type = CPP_SEMICOLON;
27496 : 90 : token->keyword = RID_MAX;
27497 : 90 : }
27498 : : }
27499 : :
27500 : : /* If this class is not itself within the scope of another class,
27501 : : then we need to parse the bodies of all of the queued function
27502 : : definitions. Note that the queued functions defined in a class
27503 : : are not always processed immediately following the
27504 : : class-specifier for that class. Consider:
27505 : :
27506 : : struct A {
27507 : : struct B { void f() { sizeof (A); } };
27508 : : };
27509 : :
27510 : : If `f' were processed before the processing of `A' were
27511 : : completed, there would be no way to compute the size of `A'.
27512 : : Note that the nesting we are interested in here is lexical --
27513 : : not the semantic nesting given by TYPE_CONTEXT. In particular,
27514 : : for:
27515 : :
27516 : : struct A { struct B; };
27517 : : struct A::B { void f() { } };
27518 : :
27519 : : there is no need to delay the parsing of `A::B::f'. */
27520 : 23645698 : if (--parser->num_classes_being_defined == 0)
27521 : : {
27522 : 21498234 : tree decl;
27523 : 21498234 : tree class_type = NULL_TREE;
27524 : 21498234 : tree pushed_scope = NULL_TREE;
27525 : 21498234 : unsigned ix;
27526 : 21498234 : cp_default_arg_entry *e;
27527 : :
27528 : 21498234 : if (!type_definition_ok_p || any_erroneous_template_args_p (type))
27529 : : {
27530 : : /* Skip default arguments, NSDMIs, etc, in order to improve
27531 : : error recovery (c++/71169, c++/71832). */
27532 : 281 : vec_safe_truncate (unparsed_funs_with_default_args, 0);
27533 : 281 : vec_safe_truncate (unparsed_nsdmis, 0);
27534 : 281 : vec_safe_truncate (unparsed_funs_with_definitions, 0);
27535 : : }
27536 : :
27537 : : /* In a first pass, parse default arguments to the functions.
27538 : : Then, in a second pass, parse the bodies of the functions.
27539 : : This two-phased approach handles cases like:
27540 : :
27541 : : struct S {
27542 : : void f() { g(); }
27543 : : void g(int i = 3);
27544 : : };
27545 : :
27546 : : */
27547 : 26294102 : FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_default_args, ix, e)
27548 : : {
27549 : 4795868 : decl = e->decl;
27550 : : /* If there are default arguments that have not yet been processed,
27551 : : take care of them now. */
27552 : 4795868 : if (class_type != e->class_type)
27553 : : {
27554 : 1747925 : if (pushed_scope)
27555 : 141869 : pop_scope (pushed_scope);
27556 : 1747925 : class_type = e->class_type;
27557 : 1747925 : pushed_scope = push_scope (class_type);
27558 : : }
27559 : : /* Make sure that any template parameters are in scope. */
27560 : 4795868 : maybe_begin_member_template_processing (decl);
27561 : : /* Parse the default argument expressions. */
27562 : 4795868 : cp_parser_late_parsing_default_args (parser, decl);
27563 : : /* Remove any template parameters from the symbol table. */
27564 : 4795868 : maybe_end_member_template_processing ();
27565 : : }
27566 : 21498234 : vec_safe_truncate (unparsed_funs_with_default_args, 0);
27567 : :
27568 : : /* If there are noexcept-specifiers that have not yet been processed,
27569 : : take care of them now. Do this before processing NSDMIs as they
27570 : : may depend on noexcept-specifiers already having been processed. */
27571 : 23879528 : FOR_EACH_VEC_SAFE_ELT (unparsed_noexcepts, ix, decl)
27572 : : {
27573 : 2381294 : tree ctx = DECL_CONTEXT (decl);
27574 : 2381294 : if (class_type != ctx)
27575 : : {
27576 : 809088 : if (pushed_scope)
27577 : 18793 : pop_scope (pushed_scope);
27578 : 809088 : class_type = ctx;
27579 : 809088 : pushed_scope = push_scope (class_type);
27580 : : }
27581 : :
27582 : 2381294 : tree def_parse = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl));
27583 : 2381294 : def_parse = TREE_PURPOSE (def_parse);
27584 : :
27585 : : /* Make sure that any template parameters are in scope. */
27586 : 2381294 : maybe_begin_member_template_processing (decl);
27587 : :
27588 : : /* Make sure that any member-function parameters are in scope.
27589 : : This function doesn't expect ccp to be set. */
27590 : 2381294 : current_class_ptr = current_class_ref = NULL_TREE;
27591 : 2381294 : inject_parm_decls (decl);
27592 : :
27593 : : /* 'this' is not allowed in static member functions. */
27594 : 2381294 : unsigned char local_variables_forbidden_p
27595 : : = parser->local_variables_forbidden_p;
27596 : 2381294 : if (DECL_THIS_STATIC (decl))
27597 : 145165 : parser->local_variables_forbidden_p |= THIS_FORBIDDEN;
27598 : :
27599 : : /* Now we can parse the noexcept-specifier. */
27600 : 2381294 : tree spec = cp_parser_late_noexcept_specifier (parser, def_parse);
27601 : :
27602 : 2381294 : if (spec == error_mark_node)
27603 : 3 : spec = NULL_TREE;
27604 : :
27605 : : /* Update the fn's type directly -- it might have escaped
27606 : : beyond this decl :( */
27607 : 2381294 : fixup_deferred_exception_variants (TREE_TYPE (decl), spec);
27608 : : /* Update any instantiations we've already created. We must
27609 : : keep the new noexcept-specifier wrapped in a DEFERRED_NOEXCEPT
27610 : : so that maybe_instantiate_noexcept can tsubst the NOEXCEPT_EXPR
27611 : : in the pattern. */
27612 : 2381321 : for (tree i : DEFPARSE_INSTANTIATIONS (def_parse))
27613 : 9 : DEFERRED_NOEXCEPT_PATTERN (TREE_PURPOSE (i))
27614 : 27 : = spec ? TREE_PURPOSE (spec) : error_mark_node;
27615 : :
27616 : : /* Restore the state of local_variables_forbidden_p. */
27617 : 2381294 : parser->local_variables_forbidden_p = local_variables_forbidden_p;
27618 : :
27619 : : /* The finish_struct call above performed various override checking,
27620 : : but it skipped unparsed noexcept-specifier operands. Now that we
27621 : : have resolved them, check again. */
27622 : 2381294 : noexcept_override_late_checks (decl);
27623 : :
27624 : : /* Remove any member-function parameters from the symbol table. */
27625 : 2381294 : pop_injected_parms ();
27626 : :
27627 : : /* Remove any template parameters from the symbol table. */
27628 : 2381294 : maybe_end_member_template_processing ();
27629 : : }
27630 : 21498234 : vec_safe_truncate (unparsed_noexcepts, 0);
27631 : :
27632 : : /* Now parse any NSDMIs. */
27633 : 22523113 : FOR_EACH_VEC_SAFE_ELT (unparsed_nsdmis, ix, decl)
27634 : : {
27635 : 1024879 : tree ctx = type_context_for_name_lookup (decl);
27636 : 1024879 : if (class_type != ctx)
27637 : : {
27638 : 443612 : if (pushed_scope)
27639 : 89657 : pop_scope (pushed_scope);
27640 : 443612 : class_type = ctx;
27641 : 443612 : pushed_scope = push_scope (class_type);
27642 : : }
27643 : 1024879 : inject_this_parameter (class_type, TYPE_UNQUALIFIED);
27644 : 1024879 : cp_parser_late_parsing_nsdmi (parser, decl);
27645 : : }
27646 : 21498234 : vec_safe_truncate (unparsed_nsdmis, 0);
27647 : :
27648 : : /* Now contract attributes. */
27649 : 21498397 : FOR_EACH_VEC_SAFE_ELT (unparsed_contracts, ix, decl)
27650 : : {
27651 : 163 : tree ctx = DECL_CONTEXT (decl);
27652 : 163 : if (class_type != ctx)
27653 : : {
27654 : 65 : if (pushed_scope)
27655 : 11 : pop_scope (pushed_scope);
27656 : 65 : class_type = ctx;
27657 : 65 : pushed_scope = push_scope (class_type);
27658 : : }
27659 : :
27660 : 163 : temp_override<tree> cfd(current_function_decl, decl);
27661 : :
27662 : : /* Make sure that any template parameters are in scope. */
27663 : 163 : maybe_begin_member_template_processing (decl);
27664 : :
27665 : : /* Make sure that any member-function parameters are in scope.
27666 : : This function doesn't expect ccp to be set. */
27667 : 163 : current_class_ptr = current_class_ref = NULL_TREE;
27668 : 163 : inject_parm_decls (decl);
27669 : :
27670 : : /* 'this' is not allowed in static member functions. */
27671 : 163 : unsigned char local_variables_forbidden_p
27672 : : = parser->local_variables_forbidden_p;
27673 : 163 : if (DECL_THIS_STATIC (decl))
27674 : 5 : parser->local_variables_forbidden_p |= THIS_FORBIDDEN;
27675 : :
27676 : : /* Now we can parse contract conditions. */
27677 : 406 : for (tree a = DECL_ATTRIBUTES (decl); a; a = TREE_CHAIN (a))
27678 : : {
27679 : 243 : if (cxx_contract_attribute_p (a))
27680 : 242 : cp_parser_late_contract_condition (parser, decl, a);
27681 : : }
27682 : :
27683 : : /* Restore the state of local_variables_forbidden_p. */
27684 : 163 : parser->local_variables_forbidden_p = local_variables_forbidden_p;
27685 : :
27686 : : /* Remove any member-function parameters from the symbol table. */
27687 : 163 : pop_injected_parms ();
27688 : :
27689 : : /* Remove any template parameters from the symbol table. */
27690 : 163 : maybe_end_member_template_processing ();
27691 : :
27692 : : /* Perform any deferred contract matching. */
27693 : 163 : match_deferred_contracts (decl);
27694 : 163 : }
27695 : 21498234 : vec_safe_truncate (unparsed_contracts, 0);
27696 : :
27697 : 21498234 : current_class_ptr = NULL_TREE;
27698 : 21498234 : current_class_ref = NULL_TREE;
27699 : 21498234 : if (pushed_scope)
27700 : 2750360 : pop_scope (pushed_scope);
27701 : :
27702 : : /* Now parse the body of the functions. */
27703 : 21498234 : if (flag_openmp)
27704 : : {
27705 : : /* OpenMP UDRs need to be parsed before all other functions. */
27706 : 97166 : FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions, ix, decl)
27707 : 56186 : if (DECL_OMP_DECLARE_REDUCTION_P (decl))
27708 : 185 : cp_parser_late_parsing_for_member (parser, decl);
27709 : 97166 : FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions, ix, decl)
27710 : 56186 : if (!DECL_OMP_DECLARE_REDUCTION_P (decl))
27711 : 56001 : cp_parser_late_parsing_for_member (parser, decl);
27712 : : }
27713 : : else
27714 : 102102982 : FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions, ix, decl)
27715 : 80645728 : cp_parser_late_parsing_for_member (parser, decl);
27716 : 21498234 : vec_safe_truncate (unparsed_funs_with_definitions, 0);
27717 : : }
27718 : :
27719 : : /* Put back any saved access checks. */
27720 : 23645698 : pop_deferring_access_checks ();
27721 : :
27722 : : /* Restore saved state. */
27723 : 23645698 : parser->in_switch_statement_p = in_switch_statement_p;
27724 : 23645698 : parser->in_statement = in_statement;
27725 : 23645698 : parser->in_function_body = saved_in_function_body;
27726 : 23645698 : parser->num_template_parameter_lists
27727 : 23645698 : = saved_num_template_parameter_lists;
27728 : 23645698 : parser->in_unbraced_linkage_specification_p
27729 : 23645698 : = saved_in_unbraced_linkage_specification_p;
27730 : 23645698 : parser->in_unbraced_export_declaration_p
27731 : 23645698 : = saved_in_unbraced_export_declaration_p;
27732 : 23645698 : current_class_ptr = saved_ccp;
27733 : 23645698 : current_class_ref = saved_ccr;
27734 : :
27735 : 23645698 : return type;
27736 : 35710580 : }
27737 : :
27738 : : /* Parse a class-head.
27739 : :
27740 : : class-head:
27741 : : class-key identifier [opt] base-clause [opt]
27742 : : class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
27743 : : class-key nested-name-specifier [opt] template-id
27744 : : base-clause [opt]
27745 : :
27746 : : class-virt-specifier:
27747 : : final
27748 : :
27749 : : GNU Extensions:
27750 : : class-key attributes identifier [opt] base-clause [opt]
27751 : : class-key attributes nested-name-specifier identifier base-clause [opt]
27752 : : class-key attributes nested-name-specifier [opt] template-id
27753 : : base-clause [opt]
27754 : :
27755 : : Upon return BASES is initialized to the list of base classes (or
27756 : : NULL, if there are none) in the same form returned by
27757 : : cp_parser_base_clause.
27758 : :
27759 : : Returns the TYPE of the indicated class. Sets
27760 : : *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
27761 : : involving a nested-name-specifier was used, and FALSE otherwise.
27762 : :
27763 : : Returns error_mark_node if this is not a class-head.
27764 : :
27765 : : Returns NULL_TREE if the class-head is syntactically valid, but
27766 : : semantically invalid in a way that means we should skip the entire
27767 : : body of the class. */
27768 : :
27769 : : static tree
27770 : 35710601 : cp_parser_class_head (cp_parser* parser,
27771 : : bool* nested_name_specifier_p)
27772 : : {
27773 : 35710601 : tree nested_name_specifier;
27774 : 35710601 : enum tag_types class_key;
27775 : 35710601 : tree id = NULL_TREE;
27776 : 35710601 : tree type = NULL_TREE;
27777 : 35710601 : tree attributes;
27778 : 35710601 : tree bases;
27779 : 35710601 : cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
27780 : 35710601 : bool template_id_p = false;
27781 : 35710601 : bool qualified_p = false;
27782 : 35710601 : bool invalid_nested_name_p = false;
27783 : 35710601 : bool invalid_explicit_specialization_p = false;
27784 : 35710601 : bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
27785 : 35710601 : tree pushed_scope = NULL_TREE;
27786 : 35710601 : unsigned num_templates;
27787 : 35710601 : cp_token *type_start_token = NULL, *nested_name_specifier_token_start = NULL;
27788 : : /* Assume no nested-name-specifier will be present. */
27789 : 35710601 : *nested_name_specifier_p = false;
27790 : : /* Assume no template parameter lists will be used in defining the
27791 : : type. */
27792 : 35710601 : num_templates = 0;
27793 : 35710601 : parser->colon_corrects_to_scope_p = false;
27794 : :
27795 : : /* Look for the class-key. */
27796 : 35710601 : class_key = cp_parser_class_key (parser);
27797 : 35710601 : if (class_key == none_type)
27798 : 0 : return error_mark_node;
27799 : :
27800 : 35710601 : location_t class_head_start_location = input_location;
27801 : :
27802 : : /* Parse the attributes. */
27803 : 35710601 : attributes = cp_parser_attributes_opt (parser);
27804 : 35710601 : if (find_contract (attributes))
27805 : 1 : diagnose_misapplied_contracts (attributes);
27806 : :
27807 : : /* If the next token is `::', that is invalid -- but sometimes
27808 : : people do try to write:
27809 : :
27810 : : struct ::S {};
27811 : :
27812 : : Handle this gracefully by accepting the extra qualifier, and then
27813 : : issuing an error about it later if this really is a
27814 : : class-head. If it turns out just to be an elaborated type
27815 : : specifier, remain silent. */
27816 : 35710601 : if (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false))
27817 : 9930 : qualified_p = true;
27818 : :
27819 : : /* It is OK to define an inaccessible class; for example:
27820 : :
27821 : : class A { class B; };
27822 : : class A::B {};
27823 : :
27824 : : So we want to ignore access when parsing the class name.
27825 : : However, we might be tentatively parsing what is really an
27826 : : elaborated-type-specifier naming a template-id, e.g.
27827 : :
27828 : : struct C<&D::m> c;
27829 : :
27830 : : In this case the tentative parse as a class-head will fail, but not
27831 : : before cp_parser_template_id splices in a CPP_TEMPLATE_ID token.
27832 : : Since dk_no_check is sticky, we must instead use dk_deferred so that
27833 : : any such CPP_TEMPLATE_ID token created during this tentative parse
27834 : : will correctly capture the access checks imposed by the template-id . */
27835 : 35710601 : push_deferring_access_checks (dk_deferred);
27836 : :
27837 : : /* Determine the name of the class. Begin by looking for an
27838 : : optional nested-name-specifier. */
27839 : 35710601 : nested_name_specifier_token_start = cp_lexer_peek_token (parser->lexer);
27840 : 35710601 : nested_name_specifier
27841 : 35710601 : = cp_parser_nested_name_specifier_opt (parser,
27842 : : /*typename_keyword_p=*/false,
27843 : : /*check_dependency_p=*/false,
27844 : : /*type_p=*/true,
27845 : : /*is_declaration=*/false);
27846 : : /* If there was a nested-name-specifier, then there *must* be an
27847 : : identifier. */
27848 : :
27849 : 35710601 : cp_token *bad_template_keyword = NULL;
27850 : :
27851 : 35710601 : if (nested_name_specifier)
27852 : : {
27853 : 4849013 : type_start_token = cp_lexer_peek_token (parser->lexer);
27854 : : /* Although the grammar says `identifier', it really means
27855 : : `class-name' or `template-name'. You are only allowed to
27856 : : define a class that has already been declared with this
27857 : : syntax.
27858 : :
27859 : : The proposed resolution for Core Issue 180 says that wherever
27860 : : you see `class T::X' you should treat `X' as a type-name.
27861 : :
27862 : : We do not know if we will see a class-name, or a
27863 : : template-name. We look for a class-name first, in case the
27864 : : class-name is a template-id; if we looked for the
27865 : : template-name first we would stop after the template-name. */
27866 : 4849013 : cp_parser_parse_tentatively (parser);
27867 : 4849013 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
27868 : 6 : bad_template_keyword = cp_lexer_consume_token (parser->lexer);
27869 : 4849013 : type = cp_parser_class_name (parser,
27870 : : /*typename_keyword_p=*/false,
27871 : : /*template_keyword_p=*/false,
27872 : : class_type,
27873 : : /*check_dependency_p=*/false,
27874 : : /*class_head_p=*/true,
27875 : : /*is_declaration=*/false);
27876 : : /* If that didn't work, ignore the nested-name-specifier. */
27877 : 4849013 : if (!cp_parser_parse_definitely (parser))
27878 : : {
27879 : 57 : invalid_nested_name_p = true;
27880 : 57 : type_start_token = cp_lexer_peek_token (parser->lexer);
27881 : 57 : id = cp_parser_identifier (parser);
27882 : 57 : if (id == error_mark_node)
27883 : 0 : id = NULL_TREE;
27884 : : }
27885 : : /* If we could not find a corresponding TYPE, treat this
27886 : : declaration like an unqualified declaration. */
27887 : 4849013 : if (type == error_mark_node)
27888 : : nested_name_specifier = NULL_TREE;
27889 : : /* Otherwise, count the number of templates used in TYPE and its
27890 : : containing scopes. */
27891 : : else
27892 : 4848953 : num_templates = num_template_headers_for_class (TREE_TYPE (type));
27893 : : }
27894 : : /* Otherwise, the identifier is optional. */
27895 : : else
27896 : : {
27897 : : /* We don't know whether what comes next is a template-id,
27898 : : an identifier, or nothing at all. */
27899 : 30861588 : cp_parser_parse_tentatively (parser);
27900 : : /* Check for a template-id. */
27901 : 30861588 : type_start_token = cp_lexer_peek_token (parser->lexer);
27902 : 30861588 : id = cp_parser_template_id (parser,
27903 : : /*template_keyword_p=*/false,
27904 : : /*check_dependency_p=*/true,
27905 : : class_key,
27906 : : /*is_declaration=*/true);
27907 : : /* If that didn't work, it could still be an identifier. */
27908 : 30861588 : if (!cp_parser_parse_definitely (parser))
27909 : : {
27910 : 19693923 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
27911 : : {
27912 : 19072321 : type_start_token = cp_lexer_peek_token (parser->lexer);
27913 : 19072321 : id = cp_parser_identifier (parser);
27914 : : }
27915 : : else
27916 : : id = NULL_TREE;
27917 : : }
27918 : : else
27919 : : {
27920 : : template_id_p = true;
27921 : : ++num_templates;
27922 : : }
27923 : : }
27924 : :
27925 : 35088999 : pop_deferring_access_checks ();
27926 : :
27927 : 35710601 : if (id)
27928 : : {
27929 : 30240043 : cp_parser_check_for_invalid_template_id (parser, id,
27930 : : class_key,
27931 : : type_start_token->location);
27932 : : }
27933 : 35710601 : virt_specifiers = cp_parser_virt_specifier_seq_opt (parser);
27934 : :
27935 : : /* If it's not a `:' or a `{' then we can't really be looking at a
27936 : : class-head, since a class-head only appears as part of a
27937 : : class-specifier. We have to detect this situation before calling
27938 : : xref_tag, since that has irreversible side-effects. */
27939 : 71421202 : if (!cp_parser_next_token_starts_class_definition_p (parser))
27940 : : {
27941 : 12063707 : cp_parser_error (parser, "expected %<{%> or %<:%>");
27942 : 12063707 : type = error_mark_node;
27943 : 12063707 : goto out;
27944 : : }
27945 : :
27946 : : /* At this point, we're going ahead with the class-specifier, even
27947 : : if some other problem occurs. */
27948 : 23646894 : cp_parser_commit_to_tentative_parse (parser);
27949 : 23646894 : if (virt_specifiers & VIRT_SPEC_OVERRIDE)
27950 : : {
27951 : 6 : cp_parser_error (parser,
27952 : : "cannot specify %<override%> for a class");
27953 : 6 : type = error_mark_node;
27954 : 6 : goto out;
27955 : : }
27956 : : /* Issue the error about the overly-qualified name now. */
27957 : 23646888 : if (qualified_p)
27958 : : {
27959 : 12 : cp_parser_error (parser,
27960 : : "global qualification of class name is invalid");
27961 : 12 : type = error_mark_node;
27962 : 12 : goto out;
27963 : : }
27964 : 23646876 : else if (invalid_nested_name_p)
27965 : : {
27966 : 21 : cp_parser_error (parser,
27967 : : "qualified name does not name a class");
27968 : 21 : type = error_mark_node;
27969 : 21 : goto out;
27970 : : }
27971 : 23646855 : else if (nested_name_specifier)
27972 : : {
27973 : 249697 : tree scope;
27974 : :
27975 : 249697 : if (bad_template_keyword)
27976 : : /* [temp.names]: in a qualified-id formed by a class-head-name, the
27977 : : keyword template shall not appear at the top level. */
27978 : 3 : pedwarn (bad_template_keyword->location, OPT_Wpedantic,
27979 : : "keyword %<template%> not allowed in class-head-name");
27980 : :
27981 : : /* Reject typedef-names in class heads. */
27982 : 249697 : if (!DECL_IMPLICIT_TYPEDEF_P (type))
27983 : : {
27984 : 12 : error_at (type_start_token->location,
27985 : : "invalid class name in declaration of %qD",
27986 : : type);
27987 : 12 : type = NULL_TREE;
27988 : 12 : goto done;
27989 : : }
27990 : :
27991 : : /* Figure out in what scope the declaration is being placed. */
27992 : 249685 : scope = current_scope ();
27993 : : /* If that scope does not contain the scope in which the
27994 : : class was originally declared, the program is invalid. */
27995 : 249685 : if (scope && !is_ancestor (scope, nested_name_specifier))
27996 : : {
27997 : 18 : if (at_namespace_scope_p ())
27998 : 9 : error_at (type_start_token->location,
27999 : : "declaration of %qD in namespace %qD which does not "
28000 : : "enclose %qD",
28001 : : type, scope, nested_name_specifier);
28002 : : else
28003 : 9 : error_at (type_start_token->location,
28004 : : "declaration of %qD in %qD which does not enclose %qD",
28005 : : type, scope, nested_name_specifier);
28006 : 18 : type = NULL_TREE;
28007 : 18 : goto done;
28008 : : }
28009 : : /* [dcl.meaning]
28010 : :
28011 : : A declarator-id shall not be qualified except for the
28012 : : definition of a ... nested class outside of its class
28013 : : ... [or] the definition or explicit instantiation of a
28014 : : class member of a namespace outside of its namespace. */
28015 : 249667 : if (scope == nested_name_specifier)
28016 : 6 : permerror (nested_name_specifier_token_start->location,
28017 : : "extra qualification not allowed");
28018 : : }
28019 : : /* The name-declaration of an export-declaration shall not declare
28020 : : a partial specialization. */
28021 : 23646825 : if (template_id_p
28022 : 9729121 : && parser->in_unbraced_export_declaration_p
28023 : 6 : && !processing_specialization
28024 : 3 : && !processing_explicit_instantiation)
28025 : : {
28026 : 3 : auto_diagnostic_group d;
28027 : 3 : location_t loc = type_start_token->location;
28028 : 3 : error_at (loc, "declaration of partial specialization in unbraced "
28029 : : "export-declaration");
28030 : 3 : inform (loc, "a specialization is always exported alongside its "
28031 : : "primary template");
28032 : 3 : }
28033 : : /* An explicit-specialization must be preceded by "template <>". If
28034 : : it is not, try to recover gracefully. */
28035 : 23646825 : if (at_namespace_scope_p ()
28036 : 21317157 : && parser->num_template_parameter_lists == 0
28037 : 4059846 : && !processing_template_parmlist
28038 : 27706650 : && template_id_p)
28039 : : {
28040 : : /* Build a location of this form:
28041 : : struct typename <ARGS>
28042 : : ^~~~~~~~~~~~~~~~~~~~~~
28043 : : with caret==start at the start token, and
28044 : : finishing at the end of the type. */
28045 : 9 : location_t reported_loc
28046 : 9 : = make_location (class_head_start_location,
28047 : : class_head_start_location,
28048 : : get_finish (type_start_token->location));
28049 : 9 : rich_location richloc (line_table, reported_loc);
28050 : 9 : if (processing_explicit_instantiation)
28051 : : {
28052 : 3 : richloc.add_fixit_insert_before ("<> ");
28053 : 3 : error_at (&richloc,
28054 : : "an explicit instantiation cannot have a definition;"
28055 : : " use %<template <>%> to declare a specialization");
28056 : : }
28057 : : else
28058 : : {
28059 : 6 : richloc.add_fixit_insert_before ("template <> ");
28060 : 6 : error_at (&richloc,
28061 : : "an explicit specialization must be preceded by"
28062 : : " %<template <>%>");
28063 : : }
28064 : 9 : invalid_explicit_specialization_p = true;
28065 : : /* Take the same action that would have been taken by
28066 : : cp_parser_explicit_specialization. */
28067 : 9 : ++parser->num_template_parameter_lists;
28068 : 9 : begin_specialization ();
28069 : 9 : }
28070 : : /* There must be no "return" statements between this point and the
28071 : : end of this function; set "type "to the correct return value and
28072 : : use "goto done;" to return. */
28073 : : /* Make sure that the right number of template parameters were
28074 : : present. */
28075 : 23646825 : if (!cp_parser_check_template_parameters (parser, num_templates,
28076 : : template_id_p,
28077 : : type_start_token->location,
28078 : : /*declarator=*/NULL))
28079 : : {
28080 : : /* If something went wrong, there is no point in even trying to
28081 : : process the class-definition. */
28082 : 39 : type = NULL_TREE;
28083 : 39 : goto done;
28084 : : }
28085 : :
28086 : : /* Look up the type. */
28087 : 23646786 : if (template_id_p)
28088 : : {
28089 : 9729097 : if (TREE_CODE (id) == TEMPLATE_ID_EXPR
28090 : 9729097 : && (DECL_FUNCTION_TEMPLATE_P (TREE_OPERAND (id, 0))
28091 : 0 : || TREE_CODE (TREE_OPERAND (id, 0)) == OVERLOAD))
28092 : : {
28093 : 0 : error_at (type_start_token->location,
28094 : : "function template %qD redeclared as a class template", id);
28095 : 0 : type = error_mark_node;
28096 : : }
28097 : : else
28098 : : {
28099 : 9729097 : type = TREE_TYPE (id);
28100 : 9729097 : type = maybe_process_partial_specialization (type);
28101 : :
28102 : : /* Check the scope while we still know whether or not we had a
28103 : : nested-name-specifier. */
28104 : 9729097 : if (type != error_mark_node)
28105 : 9728251 : check_unqualified_spec_or_inst (type, type_start_token->location);
28106 : : }
28107 : 9729097 : if (nested_name_specifier)
28108 : 0 : pushed_scope = push_scope (nested_name_specifier);
28109 : : }
28110 : 13917689 : else if (nested_name_specifier)
28111 : : {
28112 : 249655 : type = TREE_TYPE (type);
28113 : :
28114 : : /* Given:
28115 : :
28116 : : template <typename T> struct S { struct T };
28117 : : template <typename T> struct S<T>::T { };
28118 : :
28119 : : we will get a TYPENAME_TYPE when processing the definition of
28120 : : `S::T'. We need to resolve it to the actual type before we
28121 : : try to define it. */
28122 : 249655 : if (TREE_CODE (type) == TYPENAME_TYPE)
28123 : : {
28124 : 0 : type = resolve_typename_type (type, /*only_current_p=*/false);
28125 : 0 : if (TREE_CODE (type) == TYPENAME_TYPE)
28126 : : {
28127 : 0 : cp_parser_error (parser, "could not resolve typename type");
28128 : 0 : type = error_mark_node;
28129 : : }
28130 : : }
28131 : :
28132 : 249655 : type = maybe_process_partial_specialization (type);
28133 : 249655 : if (type == error_mark_node)
28134 : : {
28135 : 12 : type = NULL_TREE;
28136 : 12 : goto done;
28137 : : }
28138 : :
28139 : : /* Enter the scope indicated by the nested-name-specifier. */
28140 : 249643 : pushed_scope = push_scope (nested_name_specifier);
28141 : : /* Get the canonical version of this type. */
28142 : 249643 : type = TYPE_MAIN_DECL (type);
28143 : : /* Call push_template_decl if it seems like we should be defining a
28144 : : template either from the template headers or the type we're
28145 : : defining, so that we diagnose both extra and missing headers. */
28146 : 249640 : if ((PROCESSING_REAL_TEMPLATE_DECL_P ()
28147 : 123471 : || CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (type)))
28148 : 427479 : && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type)))
28149 : : {
28150 : 116290 : type = push_template_decl (type);
28151 : 116290 : if (type == error_mark_node)
28152 : : {
28153 : 15 : type = NULL_TREE;
28154 : 15 : goto done;
28155 : : }
28156 : : }
28157 : :
28158 : 249628 : type = TREE_TYPE (type);
28159 : 249628 : *nested_name_specifier_p = true;
28160 : : }
28161 : : else /* The name is not a nested name. */
28162 : : {
28163 : : /* If the class was unnamed, create a dummy name. */
28164 : 13668034 : if (!id)
28165 : 621554 : id = make_anon_name ();
28166 : 27336068 : TAG_how how = (parser->in_type_id_in_expr_p
28167 : 13668034 : ? TAG_how::INNERMOST_NON_CLASS
28168 : : : TAG_how::CURRENT_ONLY);
28169 : 13668034 : type = xref_tag (class_key, id, how,
28170 : 13668034 : parser->num_template_parameter_lists);
28171 : : }
28172 : :
28173 : : /* Diagnose class/struct/union mismatches. */
28174 : 23646759 : cp_parser_check_class_key (parser, UNKNOWN_LOCATION, class_key, type,
28175 : : true, true);
28176 : :
28177 : : /* Indicate whether this class was declared as a `class' or as a
28178 : : `struct'. */
28179 : 23646759 : if (TREE_CODE (type) == RECORD_TYPE)
28180 : 23214503 : CLASSTYPE_DECLARED_CLASS (type) = class_key == class_type;
28181 : :
28182 : : /* If this type was already complete, and we see another definition,
28183 : : that's an error. Likewise if the type is already being defined:
28184 : : this can happen, eg, when it's defined from within an expression
28185 : : (c++/84605). */
28186 : 23646759 : if (type != error_mark_node
28187 : 23646759 : && (COMPLETE_TYPE_P (type) || TYPE_BEING_DEFINED (type)))
28188 : : {
28189 : 78 : auto_diagnostic_group d;
28190 : 78 : error_at (type_start_token->location, "redefinition of %q#T",
28191 : : type);
28192 : 78 : inform (location_of (type), "previous definition of %q#T",
28193 : : type);
28194 : 78 : type = NULL_TREE;
28195 : 78 : goto done;
28196 : 78 : }
28197 : 23646681 : else if (type == error_mark_node)
28198 : 960 : type = NULL_TREE;
28199 : :
28200 : 23646681 : if (type)
28201 : : {
28202 : 23645721 : if (current_lambda_expr ()
28203 : 23645721 : && uses_parameter_packs (attributes))
28204 : : {
28205 : : /* In a lambda this should work, but doesn't currently. */
28206 : 3 : sorry ("unexpanded parameter pack in local class in lambda");
28207 : 3 : attributes = NULL_TREE;
28208 : : }
28209 : :
28210 : : /* Apply attributes now, before any use of the class as a template
28211 : : argument in its base list. */
28212 : 23645721 : cplus_decl_attributes (&type, attributes, (int)ATTR_FLAG_TYPE_IN_PLACE);
28213 : 23645721 : fixup_attribute_variants (type);
28214 : : }
28215 : :
28216 : : /* Associate constraints with the type. */
28217 : 23646681 : if (flag_concepts)
28218 : 6494022 : type = associate_classtype_constraints (type);
28219 : :
28220 : : /* We will have entered the scope containing the class; the names of
28221 : : base classes should be looked up in that context. For example:
28222 : :
28223 : : struct A { struct B {}; struct C; };
28224 : : struct A::C : B {};
28225 : :
28226 : : is valid. */
28227 : :
28228 : : /* Get the list of base-classes, if there is one. Defer access checking
28229 : : until the entire list has been seen, as per [class.access.general]. */
28230 : 23646681 : push_deferring_access_checks (dk_deferred);
28231 : 23646681 : if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
28232 : : {
28233 : 10052501 : if (type)
28234 : : {
28235 : 10051778 : pushclass (type);
28236 : 10051778 : start_lambda_scope (TYPE_NAME (type));
28237 : : }
28238 : 10052501 : bases = cp_parser_base_clause (parser);
28239 : 10052501 : if (type)
28240 : : {
28241 : 10051778 : finish_lambda_scope ();
28242 : 10051778 : popclass ();
28243 : : }
28244 : : }
28245 : : else
28246 : : bases = NULL_TREE;
28247 : :
28248 : : /* If we're really defining a class, process the base classes.
28249 : : If they're invalid, fail. */
28250 : 23646681 : if (type && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
28251 : 23645680 : xref_basetypes (type, bases);
28252 : :
28253 : : /* Now that all bases have been seen and attached to the class, check
28254 : : accessibility of the types named in the base-clause. This must be
28255 : : done relative to the class scope, so that we accept e.g.
28256 : :
28257 : : struct A { protected: struct B {}; };
28258 : : struct C : A::B, A {}; // OK: A::B is accessible via base A
28259 : :
28260 : : as per [class.access.general]. */
28261 : 23646681 : if (type)
28262 : 23645721 : pushclass (type);
28263 : 23646681 : pop_to_parent_deferring_access_checks ();
28264 : 23646681 : if (type)
28265 : 23645721 : popclass ();
28266 : :
28267 : 23646855 : done:
28268 : : /* Leave the scope given by the nested-name-specifier. We will
28269 : : enter the class scope itself while processing the members. */
28270 : 23646855 : if (pushed_scope)
28271 : 249640 : pop_scope (pushed_scope);
28272 : :
28273 : 23646855 : if (invalid_explicit_specialization_p)
28274 : : {
28275 : 9 : end_specialization ();
28276 : 9 : --parser->num_template_parameter_lists;
28277 : : }
28278 : :
28279 : 23646855 : if (type)
28280 : 23645721 : DECL_SOURCE_LOCATION (TYPE_NAME (type)) = type_start_token->location;
28281 : 23646855 : if (type && (virt_specifiers & VIRT_SPEC_FINAL))
28282 : 103224 : CLASSTYPE_FINAL (type) = 1;
28283 : 23543631 : out:
28284 : 35710601 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
28285 : 35710601 : return type;
28286 : : }
28287 : :
28288 : : /* Parse a class-key.
28289 : :
28290 : : class-key:
28291 : : class
28292 : : struct
28293 : : union
28294 : :
28295 : : Returns the kind of class-key specified, or none_type to indicate
28296 : : error. */
28297 : :
28298 : : static enum tag_types
28299 : 47774317 : cp_parser_class_key (cp_parser* parser)
28300 : : {
28301 : 47774317 : cp_token *token;
28302 : 47774317 : enum tag_types tag_type;
28303 : :
28304 : : /* Look for the class-key. */
28305 : 47774317 : token = cp_parser_require (parser, CPP_KEYWORD, RT_CLASS_KEY);
28306 : 47774317 : if (!token)
28307 : : return none_type;
28308 : :
28309 : : /* Check to see if the TOKEN is a class-key. */
28310 : 132018012 : tag_type = cp_parser_token_is_class_key (token);
28311 : 36469378 : if (!tag_type)
28312 : 0 : cp_parser_error (parser, "expected class-key");
28313 : : return tag_type;
28314 : : }
28315 : :
28316 : : /* Parse a type-parameter-key.
28317 : :
28318 : : type-parameter-key:
28319 : : class
28320 : : typename
28321 : : */
28322 : :
28323 : : static void
28324 : 305651 : cp_parser_type_parameter_key (cp_parser* parser)
28325 : : {
28326 : : /* Look for the type-parameter-key. */
28327 : 305651 : enum tag_types tag_type = none_type;
28328 : 305651 : cp_token *token = cp_lexer_peek_token (parser->lexer);
28329 : 298328 : if ((tag_type = cp_parser_token_is_type_parameter_key (token)) != none_type)
28330 : : {
28331 : 305645 : cp_lexer_consume_token (parser->lexer);
28332 : 305645 : if (pedantic && tag_type == typename_type
28333 : 146 : && cxx_dialect < cxx17)
28334 : : /* typename is not allowed in a template template parameter
28335 : : by the standard until C++17. */
28336 : 1 : pedwarn (token->location, OPT_Wc__17_extensions,
28337 : : "ISO C++ forbids typename key in template template parameter;"
28338 : : " use %<-std=c++17%> or %<-std=gnu++17%>");
28339 : : }
28340 : : else
28341 : 6 : cp_parser_error (parser, "expected %<class%> or %<typename%>");
28342 : :
28343 : 305651 : return;
28344 : : }
28345 : :
28346 : : /* Parse an (optional) member-specification.
28347 : :
28348 : : member-specification:
28349 : : member-declaration member-specification [opt]
28350 : : access-specifier : member-specification [opt] */
28351 : :
28352 : : static void
28353 : 23645671 : cp_parser_member_specification_opt (cp_parser* parser)
28354 : : {
28355 : 179130549 : while (true)
28356 : : {
28357 : 179130549 : cp_token *token;
28358 : 179130549 : enum rid keyword;
28359 : :
28360 : : /* Peek at the next token. */
28361 : 179130549 : token = cp_lexer_peek_token (parser->lexer);
28362 : : /* If it's a `}', or EOF then we've seen all the members. */
28363 : 179130549 : if (token->type == CPP_CLOSE_BRACE
28364 : 155484941 : || token->type == CPP_EOF
28365 : 155484887 : || token->type == CPP_PRAGMA_EOL)
28366 : : break;
28367 : :
28368 : : /* See if this token is a keyword. */
28369 : 155484887 : keyword = token->keyword;
28370 : 155484887 : switch (keyword)
28371 : : {
28372 : 11030076 : case RID_PUBLIC:
28373 : 11030076 : case RID_PROTECTED:
28374 : 11030076 : case RID_PRIVATE:
28375 : : /* Consume the access-specifier. */
28376 : 11030076 : cp_lexer_consume_token (parser->lexer);
28377 : : /* Remember which access-specifier is active. */
28378 : 11030076 : current_access_specifier = token->u.value;
28379 : : /* Look for the `:'. */
28380 : 11030076 : cp_parser_require (parser, CPP_COLON, RT_COLON);
28381 : 11030076 : break;
28382 : :
28383 : 144454811 : default:
28384 : : /* Accept #pragmas at class scope. */
28385 : 144454811 : if (token->type == CPP_PRAGMA)
28386 : : {
28387 : 973734 : cp_parser_pragma (parser, pragma_member, NULL);
28388 : 973734 : break;
28389 : : }
28390 : :
28391 : : /* Otherwise, the next construction must be a
28392 : : member-declaration. */
28393 : 143481077 : cp_parser_member_declaration (parser);
28394 : : }
28395 : : }
28396 : 23645662 : }
28397 : :
28398 : : /* Parse a member-declaration.
28399 : :
28400 : : member-declaration:
28401 : : decl-specifier-seq [opt] member-declarator-list [opt] ;
28402 : : function-definition ; [opt]
28403 : : :: [opt] nested-name-specifier template [opt] unqualified-id ;
28404 : : using-declaration
28405 : : template-declaration
28406 : : alias-declaration
28407 : :
28408 : : member-declarator-list:
28409 : : member-declarator
28410 : : member-declarator-list , member-declarator
28411 : :
28412 : : member-declarator:
28413 : : declarator pure-specifier [opt]
28414 : : declarator constant-initializer [opt]
28415 : : identifier [opt] : constant-expression
28416 : :
28417 : : GNU Extensions:
28418 : :
28419 : : member-declaration:
28420 : : __extension__ member-declaration
28421 : :
28422 : : member-declarator:
28423 : : declarator attributes [opt] pure-specifier [opt]
28424 : : declarator attributes [opt] constant-initializer [opt]
28425 : : identifier [opt] attributes [opt] : constant-expression
28426 : :
28427 : : C++0x Extensions:
28428 : :
28429 : : member-declaration:
28430 : : static_assert-declaration */
28431 : :
28432 : : static void
28433 : 143578685 : cp_parser_member_declaration (cp_parser* parser)
28434 : : {
28435 : 143578685 : cp_decl_specifier_seq decl_specifiers;
28436 : 143578685 : tree prefix_attributes;
28437 : 143578685 : tree decl;
28438 : 143578685 : int declares_class_or_enum;
28439 : 143578685 : bool friend_p;
28440 : 143578685 : cp_token *token = NULL;
28441 : 143578685 : cp_token *decl_spec_token_start = NULL;
28442 : 143578685 : cp_token *initializer_token_start = NULL;
28443 : 143578685 : int saved_pedantic;
28444 : 143578685 : bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
28445 : :
28446 : : /* Check for the `__extension__' keyword. */
28447 : 143578685 : if (cp_parser_extension_opt (parser, &saved_pedantic))
28448 : : {
28449 : : /* Recurse. */
28450 : 97379 : cp_parser_member_declaration (parser);
28451 : : /* Restore the old value of the PEDANTIC flag. */
28452 : 97379 : pedantic = saved_pedantic;
28453 : :
28454 : 31409808 : return;
28455 : : }
28456 : :
28457 : : /* Check for a template-declaration. */
28458 : 143481306 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
28459 : : {
28460 : : /* An explicit specialization here is an error condition, and we
28461 : : expect the specialization handler to detect and report this. */
28462 : 20008687 : if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
28463 : 20008687 : && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
28464 : 24 : cp_parser_explicit_specialization (parser);
28465 : : else
28466 : 20008663 : cp_parser_template_declaration (parser, /*member_p=*/true);
28467 : :
28468 : 20008687 : return;
28469 : : }
28470 : : /* Check for a template introduction. */
28471 : 123472619 : else if (cp_parser_template_declaration_after_export (parser, true))
28472 : : return;
28473 : :
28474 : : /* Check for a using-declaration. */
28475 : 123472619 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
28476 : : {
28477 : 9215212 : if (cxx_dialect < cxx11)
28478 : : /* Parse the using-declaration. */
28479 : 2184 : cp_parser_using_declaration (parser, /*access_declaration_p=*/false);
28480 : 9213028 : else if (cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_ENUM))
28481 : 1248 : cp_parser_using_enum (parser);
28482 : : else
28483 : : {
28484 : 9211780 : tree decl;
28485 : 9211780 : bool alias_decl_expected;
28486 : 9211780 : cp_parser_parse_tentatively (parser);
28487 : 9211780 : decl = cp_parser_alias_declaration (parser);
28488 : : /* Note that if we actually see the '=' token after the
28489 : : identifier, cp_parser_alias_declaration commits the
28490 : : tentative parse. In that case, we really expect an
28491 : : alias-declaration. Otherwise, we expect a using
28492 : : declaration. */
28493 : 18423560 : alias_decl_expected =
28494 : 9211780 : !cp_parser_uncommitted_to_tentative_parse_p (parser);
28495 : 9211780 : cp_parser_parse_definitely (parser);
28496 : :
28497 : 9211780 : if (alias_decl_expected)
28498 : 8124733 : finish_member_declaration (decl);
28499 : : else
28500 : 1087047 : cp_parser_using_declaration (parser,
28501 : : /*access_declaration_p=*/false);
28502 : : }
28503 : 9215212 : return;
28504 : : }
28505 : :
28506 : : /* Check for @defs. */
28507 : 114257407 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_DEFS))
28508 : : {
28509 : 0 : tree ivar, member;
28510 : 0 : tree ivar_chains = cp_parser_objc_defs_expression (parser);
28511 : 0 : ivar = ivar_chains;
28512 : 0 : while (ivar)
28513 : : {
28514 : 0 : member = ivar;
28515 : 0 : ivar = TREE_CHAIN (member);
28516 : 0 : TREE_CHAIN (member) = NULL_TREE;
28517 : 0 : finish_member_declaration (member);
28518 : : }
28519 : : return;
28520 : : }
28521 : :
28522 : : /* If the next token is `static_assert' we have a static assertion. */
28523 : 114257407 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC_ASSERT))
28524 : : {
28525 : 2088530 : cp_parser_static_assert (parser, /*member_p=*/true);
28526 : 2088530 : return;
28527 : : }
28528 : :
28529 : 112168877 : parser->colon_corrects_to_scope_p = false;
28530 : :
28531 : 112168877 : cp_omp_declare_simd_data odsd;
28532 : 112168877 : if (cp_parser_using_declaration (parser, /*access_declaration=*/true))
28533 : 122 : goto out;
28534 : :
28535 : : /* Parse the decl-specifier-seq. */
28536 : 112168755 : decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
28537 : 112168755 : cp_parser_decl_specifier_seq (parser,
28538 : : (CP_PARSER_FLAGS_OPTIONAL
28539 : : | CP_PARSER_FLAGS_TYPENAME_OPTIONAL),
28540 : : &decl_specifiers,
28541 : : &declares_class_or_enum);
28542 : :
28543 : 112168755 : if (decl_specifiers.attributes && (flag_openmp || flag_openmp_simd))
28544 : 6875 : cp_parser_handle_directive_omp_attributes (parser,
28545 : : &decl_specifiers.attributes,
28546 : : &odsd, true);
28547 : :
28548 : : /* Check for an invalid type-name. */
28549 : 112168755 : if (!decl_specifiers.any_type_specifiers_p
28550 : 112168755 : && cp_parser_parse_and_diagnose_invalid_type_name (parser))
28551 : 185 : goto out;
28552 : : /* If there is no declarator, then the decl-specifier-seq should
28553 : : specify a type. For C++26 Variadic friends don't just check for
28554 : : a semicolon, but also for a comma and in both cases optionally
28555 : : preceded by ellipsis. */
28556 : 112168570 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
28557 : 221361564 : || (cp_parser_friend_p (&decl_specifiers)
28558 : 2339628 : && cxx_dialect >= cxx11
28559 : 2336356 : && (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
28560 : 2336350 : || (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
28561 : 6 : && (cp_lexer_nth_token_is (parser->lexer, 2, CPP_SEMICOLON)
28562 : 3 : || cp_lexer_nth_token_is (parser->lexer, 2,
28563 : : CPP_COMMA))))))
28564 : : {
28565 : : /* If there was no decl-specifier-seq, and the next token is a
28566 : : `;', then we have something like:
28567 : :
28568 : : struct S { ; };
28569 : :
28570 : : [class.mem] used to say
28571 : :
28572 : : Each member-declaration shall declare at least one member
28573 : : name of the class.
28574 : :
28575 : : but since DR 1693:
28576 : :
28577 : : A member-declaration does not declare new members of the class
28578 : : if it is
28579 : : -- [...]
28580 : : -- an empty-declaration.
28581 : : For any other member-declaration, each declared entity that is not
28582 : : an unnamed bit-field is a member of the class, and each such
28583 : : member-declaration shall either declare at least one member name of
28584 : : the class or declare at least one unnamed bit-field. */
28585 : 2975588 : if (!decl_specifiers.any_specifiers_p)
28586 : : {
28587 : 179 : cp_token *token = cp_lexer_peek_token (parser->lexer);
28588 : 179 : if (decl_spec_token_start == token)
28589 : 145 : maybe_warn_extra_semi (token->location, extra_semi_kind::member);
28590 : : else
28591 : 34 : pedwarn (decl_spec_token_start->location, OPT_Wpedantic,
28592 : : "declaration does not declare anything");
28593 : : }
28594 : : else
28595 : : {
28596 : : /* See if this declaration is a friend. */
28597 : 5950818 : friend_p = cp_parser_friend_p (&decl_specifiers);
28598 : : /* If there were decl-specifiers, check to see if there was
28599 : : a class-declaration. */
28600 : 2975409 : tree type = check_tag_decl (&decl_specifiers,
28601 : : /*explicit_type_instantiation_p=*/false);
28602 : : /* Nested classes have already been added to the class, but
28603 : : a `friend' needs to be explicitly registered. */
28604 : 2975409 : if (friend_p)
28605 : : {
28606 : : /* If the `friend' keyword was present, the friend must
28607 : : be introduced with a class-key. */
28608 : 963598 : if (!declares_class_or_enum && cxx_dialect < cxx11)
28609 : 6 : pedwarn (decl_spec_token_start->location, OPT_Wpedantic,
28610 : : "in C++03 a class-key must be used "
28611 : : "when declaring a friend");
28612 : 963598 : if (!cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
28613 : 963598 : && cxx_dialect < cxx26)
28614 : 12 : pedwarn (cp_lexer_peek_token (parser->lexer)->location,
28615 : : OPT_Wc__26_extensions,
28616 : : "variadic friends or friend type declarations with "
28617 : : "multiple types only available with "
28618 : : "%<-std=c++2c%> or %<-std=gnu++2c%>");
28619 : 963598 : location_t friend_loc = decl_specifiers.locations[ds_friend];
28620 : 963622 : do
28621 : : {
28622 : : /* In this case:
28623 : :
28624 : : template <typename T> struct A {
28625 : : friend struct A<T>::B;
28626 : : };
28627 : :
28628 : : A<T>::B will be represented by a TYPENAME_TYPE, and
28629 : : therefore not recognized by check_tag_decl. */
28630 : 963610 : if (!type)
28631 : : {
28632 : 172420 : type = decl_specifiers.type;
28633 : 172420 : if (type && TREE_CODE (type) == TYPE_DECL)
28634 : 171181 : type = TREE_TYPE (type);
28635 : : }
28636 : : /* Warn if an attribute cannot appear here, as per
28637 : : [dcl.attr.grammar]/5. But not when
28638 : : declares_class_or_enum: we ignore attributes in
28639 : : elaborated-type-specifiers. */
28640 : 963610 : if (!declares_class_or_enum
28641 : 963610 : && cxx11_attribute_p (decl_specifiers.attributes))
28642 : : {
28643 : 9 : decl_specifiers.attributes = NULL_TREE;
28644 : 9 : auto_diagnostic_group d;
28645 : 9 : if (warning_at (decl_spec_token_start->location,
28646 : : OPT_Wattributes, "attribute ignored"))
28647 : 9 : inform (decl_spec_token_start->location, "an attribute "
28648 : : "that appertains to a friend declaration that "
28649 : : "is not a definition is ignored");
28650 : 9 : }
28651 : 963610 : bool ellipsis = cp_lexer_next_token_is (parser->lexer,
28652 : : CPP_ELLIPSIS);
28653 : 963610 : if (ellipsis)
28654 : 12 : cp_lexer_consume_token (parser->lexer);
28655 : 963610 : if (!type || !TYPE_P (type))
28656 : 27 : error_at (decl_spec_token_start->location,
28657 : : "friend declaration does not name a class or "
28658 : : "function");
28659 : : else
28660 : : {
28661 : 963583 : if (ellipsis)
28662 : 12 : type = make_pack_expansion (type);
28663 : 963583 : if (type != error_mark_node)
28664 : 963583 : make_friend_class (current_class_type, type,
28665 : : /*complain=*/true);
28666 : : }
28667 : 963610 : if (!cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
28668 : : break;
28669 : 12 : cp_lexer_consume_token (parser->lexer);
28670 : 12 : clear_decl_specs (&decl_specifiers);
28671 : 12 : decl_specifiers.locations[ds_friend] = friend_loc;
28672 : 12 : decl_specifiers.any_specifiers_p = true;
28673 : 12 : declares_class_or_enum = false;
28674 : 12 : cp_parser_type_specifier (parser,
28675 : : CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
28676 : : &decl_specifiers,
28677 : : /*is_declaration=*/true,
28678 : : &declares_class_or_enum, NULL);
28679 : 12 : type = check_tag_decl (&decl_specifiers,
28680 : : /*explicit_type_instantiation_p=*/
28681 : : false);
28682 : 12 : }
28683 : : while (1);
28684 : : }
28685 : : /* If there is no TYPE, an error message will already have
28686 : : been issued. */
28687 : 2011811 : else if (!type || type == error_mark_node)
28688 : : ;
28689 : : /* An anonymous aggregate has to be handled specially; such
28690 : : a declaration really declares a data member (with a
28691 : : particular type), as opposed to a nested class. */
28692 : 2011699 : else if (ANON_AGGR_TYPE_P (type))
28693 : : {
28694 : : /* C++11 9.5/6. */
28695 : 88931 : if (decl_specifiers.storage_class != sc_none)
28696 : 13 : error_at (decl_spec_token_start->location,
28697 : : "a storage class on an anonymous aggregate "
28698 : : "in class scope is not allowed");
28699 : :
28700 : : /* Remove constructors and such from TYPE, now that we
28701 : : know it is an anonymous aggregate. */
28702 : 88931 : fixup_anonymous_aggr (type);
28703 : : /* And make the corresponding data member. */
28704 : 88931 : decl = build_decl (decl_spec_token_start->location,
28705 : : FIELD_DECL, NULL_TREE, type);
28706 : : /* Add it to the class. */
28707 : 88931 : finish_member_declaration (decl);
28708 : : }
28709 : : else
28710 : 1922768 : cp_parser_check_access_in_redeclaration
28711 : 1922768 : (TYPE_NAME (type),
28712 : : decl_spec_token_start->location);
28713 : : }
28714 : : }
28715 : : else
28716 : : {
28717 : 109192982 : bool assume_semicolon = false;
28718 : :
28719 : : /* Clear attributes from the decl_specifiers but keep them
28720 : : around as prefix attributes that apply them to the entity
28721 : : being declared. */
28722 : 109192982 : prefix_attributes = decl_specifiers.attributes;
28723 : 109192982 : decl_specifiers.attributes = NULL_TREE;
28724 : 109192982 : if (parser->omp_declare_simd
28725 : 199 : && (parser->omp_declare_simd->attribs[0]
28726 : : == &decl_specifiers.attributes))
28727 : 6 : parser->omp_declare_simd->attribs[0] = &prefix_attributes;
28728 : :
28729 : : /* See if these declarations will be friends. */
28730 : 109192982 : friend_p = cp_parser_friend_p (&decl_specifiers);
28731 : :
28732 : : /* Keep going until we hit the `;' at the end of the
28733 : : declaration. */
28734 : 167596165 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
28735 : : {
28736 : 109392699 : tree attributes = NULL_TREE;
28737 : 109392699 : tree first_attribute;
28738 : 109392699 : tree initializer;
28739 : 109392699 : bool named_bitfld = false;
28740 : :
28741 : : /* Peek at the next token. */
28742 : 109392699 : token = cp_lexer_peek_token (parser->lexer);
28743 : :
28744 : : /* The following code wants to know early if it is a bit-field
28745 : : or some other declaration. Attributes can appear before
28746 : : the `:' token. Skip over them without consuming any tokens
28747 : : to peek if they are followed by `:'. */
28748 : 109392699 : if (cp_next_tokens_can_be_attribute_p (parser)
28749 : 109392699 : || (token->type == CPP_NAME
28750 : 82704958 : && cp_nth_tokens_can_be_attribute_p (parser, 2)
28751 : : && (named_bitfld = true)))
28752 : : {
28753 : 47099 : size_t n
28754 : 47099 : = cp_parser_skip_attributes_opt (parser, 1 + named_bitfld);
28755 : 47099 : token = cp_lexer_peek_nth_token (parser->lexer, n);
28756 : : }
28757 : :
28758 : : /* Check for a bitfield declaration. */
28759 : 109392699 : if (token->type == CPP_COLON
28760 : 109392699 : || (token->type == CPP_NAME
28761 : 82657865 : && token == cp_lexer_peek_token (parser->lexer)
28762 : 82657862 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON)
28763 : : && (named_bitfld = true)))
28764 : : {
28765 : 352033 : tree identifier;
28766 : 352033 : tree width;
28767 : 352033 : tree late_attributes = NULL_TREE;
28768 : 352033 : location_t id_location
28769 : 352033 : = cp_lexer_peek_token (parser->lexer)->location;
28770 : :
28771 : 352033 : if (named_bitfld)
28772 : 221036 : identifier = cp_parser_identifier (parser);
28773 : : else
28774 : : identifier = NULL_TREE;
28775 : :
28776 : : /* Look for attributes that apply to the bitfield. */
28777 : 352033 : attributes = cp_parser_attributes_opt (parser);
28778 : :
28779 : : /* Consume the `:' token. */
28780 : 352033 : cp_lexer_consume_token (parser->lexer);
28781 : :
28782 : : /* Get the width of the bitfield. */
28783 : 352033 : width = cp_parser_constant_expression (parser, false, NULL,
28784 : 352033 : cxx_dialect >= cxx11);
28785 : :
28786 : : /* In C++20 and as extension for C++11 and above we allow
28787 : : default member initializers for bit-fields. */
28788 : 352033 : initializer = NULL_TREE;
28789 : 352033 : if (cxx_dialect >= cxx11
28790 : 352033 : && (cp_lexer_next_token_is (parser->lexer, CPP_EQ)
28791 : 345477 : || cp_lexer_next_token_is (parser->lexer,
28792 : : CPP_OPEN_BRACE)))
28793 : : {
28794 : 6860 : location_t loc
28795 : 6860 : = cp_lexer_peek_token (parser->lexer)->location;
28796 : 6860 : if (cxx_dialect < cxx20
28797 : 56 : && identifier != NULL_TREE)
28798 : 46 : pedwarn (loc, OPT_Wc__20_extensions,
28799 : : "default member initializers for bit-fields "
28800 : : "only available with %<-std=c++20%> or "
28801 : : "%<-std=gnu++20%>");
28802 : :
28803 : 13720 : initializer = cp_parser_save_nsdmi (parser);
28804 : 6860 : if (identifier == NULL_TREE)
28805 : : {
28806 : 16 : error_at (loc, "default member initializer for "
28807 : : "unnamed bit-field");
28808 : 16 : initializer = NULL_TREE;
28809 : : }
28810 : : }
28811 : : else
28812 : : {
28813 : : /* Look for attributes that apply to the bitfield after
28814 : : the `:' token and width. This is where GCC used to
28815 : : parse attributes in the past, pedwarn if there is
28816 : : a std attribute. */
28817 : 345173 : if (cp_next_tokens_can_be_std_attribute_p (parser))
28818 : 6 : pedwarn (input_location, OPT_Wpedantic,
28819 : : "ISO C++ allows bit-field attributes only "
28820 : : "before the %<:%> token");
28821 : :
28822 : 345173 : late_attributes = cp_parser_attributes_opt (parser);
28823 : : }
28824 : :
28825 : 352033 : attributes = attr_chainon (attributes, late_attributes);
28826 : :
28827 : : /* Remember which attributes are prefix attributes and
28828 : : which are not. */
28829 : 352033 : first_attribute = attributes;
28830 : : /* Combine the attributes. */
28831 : 352033 : attributes = attr_chainon (prefix_attributes, attributes);
28832 : :
28833 : : /* Create the bitfield declaration. */
28834 : 573069 : decl = grokbitfield (identifier
28835 : 221036 : ? make_id_declarator (NULL_TREE,
28836 : : identifier,
28837 : : sfk_none,
28838 : : id_location)
28839 : : : NULL,
28840 : : &decl_specifiers,
28841 : : width, initializer,
28842 : : attributes);
28843 : : }
28844 : : else
28845 : : {
28846 : 109040666 : cp_declarator *declarator;
28847 : 109040666 : tree asm_specification;
28848 : 109040666 : int ctor_dtor_or_conv_p;
28849 : 109040666 : bool static_p = (decl_specifiers.storage_class == sc_static);
28850 : 109040666 : cp_parser_flags flags = CP_PARSER_FLAGS_TYPENAME_OPTIONAL;
28851 : : /* We can't delay parsing for friends,
28852 : : alias-declarations, and typedefs, even though the
28853 : : standard seems to require it. */
28854 : 109040666 : if (!friend_p
28855 : 109040666 : && !decl_spec_seq_has_spec_p (&decl_specifiers, ds_typedef))
28856 : : flags |= CP_PARSER_FLAGS_DELAY_NOEXCEPT;
28857 : :
28858 : : /* Parse the declarator. */
28859 : 109040666 : declarator
28860 : 109040666 : = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
28861 : : flags,
28862 : : &ctor_dtor_or_conv_p,
28863 : : /*parenthesized_p=*/NULL,
28864 : : /*member_p=*/true,
28865 : : friend_p, static_p);
28866 : :
28867 : : /* If something went wrong parsing the declarator, make sure
28868 : : that we at least consume some tokens. */
28869 : 109040666 : if (declarator == cp_error_declarator)
28870 : : {
28871 : : /* Skip to the end of the statement. */
28872 : 208 : cp_parser_skip_to_end_of_statement (parser);
28873 : : /* If the next token is not a semicolon, that is
28874 : : probably because we just skipped over the body of
28875 : : a function. So, we consume a semicolon if
28876 : : present, but do not issue an error message if it
28877 : : is not present. */
28878 : 208 : if (cp_lexer_next_token_is (parser->lexer,
28879 : : CPP_SEMICOLON))
28880 : 141 : cp_lexer_consume_token (parser->lexer);
28881 : 50989411 : goto out;
28882 : : }
28883 : :
28884 : : /* Handle class-scope non-template C++17 deduction guides. */
28885 : 109040458 : cp_parser_maybe_adjust_declarator_for_dguide (parser,
28886 : : &decl_specifiers,
28887 : : declarator,
28888 : : &ctor_dtor_or_conv_p);
28889 : :
28890 : 109040458 : if (declares_class_or_enum & 2)
28891 : 210249 : cp_parser_check_for_definition_in_return_type
28892 : 210249 : (declarator, decl_specifiers.type,
28893 : : decl_specifiers.locations[ds_type_spec]);
28894 : :
28895 : : /* Look for an asm-specification. */
28896 : 109040458 : asm_specification = cp_parser_asm_specification_opt (parser);
28897 : : /* Look for attributes that apply to the declaration. */
28898 : 109040458 : attributes = cp_parser_attributes_opt (parser);
28899 : : /* Remember which attributes are prefix attributes and
28900 : : which are not. */
28901 : 109040458 : first_attribute = attributes;
28902 : : /* Combine the attributes. */
28903 : 109040458 : attributes = attr_chainon (prefix_attributes, attributes);
28904 : :
28905 : : /* If it's an `=', then we have a constant-initializer or a
28906 : : pure-specifier. It is not correct to parse the
28907 : : initializer before registering the member declaration
28908 : : since the member declaration should be in scope while
28909 : : its initializer is processed. However, the rest of the
28910 : : front end does not yet provide an interface that allows
28911 : : us to handle this correctly. */
28912 : 109040458 : if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
28913 : : {
28914 : : /* In [class.mem]:
28915 : :
28916 : : A pure-specifier shall be used only in the declaration of
28917 : : a virtual function.
28918 : :
28919 : : A member-declarator can contain a constant-initializer
28920 : : only if it declares a static member of integral or
28921 : : enumeration type.
28922 : :
28923 : : Therefore, if the DECLARATOR is for a function, we look
28924 : : for a pure-specifier; otherwise, we look for a
28925 : : constant-initializer. When we call `grokfield', it will
28926 : : perform more stringent semantics checks. */
28927 : 18241667 : initializer_token_start = cp_lexer_peek_token (parser->lexer);
28928 : 18241667 : declarator->init_loc = initializer_token_start->location;
28929 : 18241667 : if (function_declarator_p (declarator)
28930 : 18241667 : || (decl_specifiers.type
28931 : 9615938 : && TREE_CODE (decl_specifiers.type) == TYPE_DECL
28932 : 3187871 : && declarator->kind == cdk_id
28933 : 3041938 : && (TREE_CODE (TREE_TYPE (decl_specifiers.type))
28934 : : == FUNCTION_TYPE)))
28935 : 8622047 : initializer = cp_parser_pure_specifier (parser);
28936 : 9619620 : else if (decl_specifiers.storage_class != sc_static)
28937 : 859120 : initializer = cp_parser_save_nsdmi (parser);
28938 : 8760500 : else if (cxx_dialect >= cxx11)
28939 : : {
28940 : : /* Don't require a constant rvalue in C++11, since we
28941 : : might want a reference constant. We'll enforce
28942 : : constancy later. */
28943 : 8738832 : cp_lexer_consume_token (parser->lexer);
28944 : : /* Parse the initializer. */
28945 : 8738832 : initializer = cp_parser_initializer_clause (parser);
28946 : : }
28947 : : else
28948 : : /* Parse the initializer. */
28949 : 21668 : initializer = cp_parser_constant_initializer (parser);
28950 : : }
28951 : 90798791 : else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)
28952 : 90798791 : && !function_declarator_p (declarator))
28953 : : {
28954 : 173483 : declarator->init_loc
28955 : 173483 : = cp_lexer_peek_token (parser->lexer)->location;
28956 : 173483 : if (decl_specifiers.storage_class != sc_static)
28957 : 158967 : initializer = cp_parser_save_nsdmi (parser);
28958 : : else
28959 : 14516 : initializer = cp_parser_initializer (parser);
28960 : : }
28961 : : /* Detect invalid bit-field cases such as
28962 : :
28963 : : int *p : 4;
28964 : : int &&r : 3;
28965 : :
28966 : : and similar. */
28967 : 90625308 : else if (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
28968 : : /* If there were no type specifiers, it was a
28969 : : constructor. */
28970 : 90625308 : && decl_specifiers.any_type_specifiers_p)
28971 : : {
28972 : : /* This is called for a decent diagnostic only. */
28973 : 27 : tree d = grokdeclarator (declarator, &decl_specifiers,
28974 : : BITFIELD, /*initialized=*/false,
28975 : : &attributes);
28976 : 27 : if (!error_operand_p (d))
28977 : 27 : error_at (DECL_SOURCE_LOCATION (d),
28978 : : "bit-field %qD has non-integral type %qT",
28979 : 27 : d, TREE_TYPE (d));
28980 : 27 : cp_parser_skip_to_end_of_statement (parser);
28981 : : /* Avoid "extra ;" pedwarns. */
28982 : 27 : if (cp_lexer_next_token_is (parser->lexer,
28983 : : CPP_SEMICOLON))
28984 : 27 : cp_lexer_consume_token (parser->lexer);
28985 : 27 : goto out;
28986 : : }
28987 : : /* Otherwise, there is no initializer. */
28988 : : else
28989 : : initializer = NULL_TREE;
28990 : :
28991 : : /* See if we are probably looking at a function
28992 : : definition. We are certainly not looking at a
28993 : : member-declarator. Calling `grokfield' has
28994 : : side-effects, so we must not do it unless we are sure
28995 : : that we are looking at a member-declarator. */
28996 : 109040428 : if (cp_parser_token_starts_function_definition_p
28997 : 109040428 : (cp_lexer_peek_token (parser->lexer)))
28998 : : {
28999 : : /* The grammar does not allow a pure-specifier to be
29000 : : used when a member function is defined. (It is
29001 : : possible that this fact is an oversight in the
29002 : : standard, since a pure function may be defined
29003 : : outside of the class-specifier. */
29004 : 50989176 : if (initializer && initializer_token_start)
29005 : 3 : error_at (initializer_token_start->location,
29006 : : "pure-specifier on function-definition");
29007 : 50989176 : decl = cp_parser_save_member_function_body (parser,
29008 : : &decl_specifiers,
29009 : : declarator,
29010 : : attributes);
29011 : :
29012 : 50989176 : if (parser->fully_implicit_function_template_p)
29013 : 5696 : decl = finish_fully_implicit_template (parser, decl);
29014 : : /* If the member was not a friend, declare it here. */
29015 : 50989176 : if (!friend_p)
29016 : 48894331 : finish_member_declaration (decl);
29017 : : /* Peek at the next token. */
29018 : 50989176 : token = cp_lexer_peek_token (parser->lexer);
29019 : : /* If the next token is a semicolon, consume it. */
29020 : 50989176 : if (token->type == CPP_SEMICOLON)
29021 : : {
29022 : 25300 : location_t semicolon_loc
29023 : 25300 : = cp_lexer_consume_token (parser->lexer)->location;
29024 : 25300 : maybe_warn_extra_semi (semicolon_loc,
29025 : : extra_semi_kind::in_class_fn_def);
29026 : : }
29027 : 50989176 : goto out;
29028 : : }
29029 : : else
29030 : 58051252 : if (declarator->kind == cdk_function)
29031 : 15467229 : declarator->id_loc = token->location;
29032 : :
29033 : : /* Create the declaration. */
29034 : 58051252 : decl = grokfield (declarator, &decl_specifiers,
29035 : : initializer, /*init_const_expr_p=*/true,
29036 : : asm_specification, attributes);
29037 : :
29038 : 58051246 : if (parser->fully_implicit_function_template_p)
29039 : : {
29040 : 133 : if (friend_p)
29041 : 7 : finish_fully_implicit_template (parser, 0);
29042 : : else
29043 : 126 : decl = finish_fully_implicit_template (parser, decl);
29044 : : }
29045 : : }
29046 : :
29047 : 58403279 : cp_finalize_omp_declare_simd (parser, decl);
29048 : 58403279 : cp_finalize_oacc_routine (parser, decl, false);
29049 : :
29050 : : /* Reset PREFIX_ATTRIBUTES. */
29051 : 58403279 : if (attributes != error_mark_node)
29052 : : {
29053 : 58504553 : while (attributes && TREE_CHAIN (attributes) != first_attribute)
29054 : 101280 : attributes = TREE_CHAIN (attributes);
29055 : 58403273 : if (attributes)
29056 : 705491 : TREE_CHAIN (attributes) = NULL_TREE;
29057 : : }
29058 : :
29059 : : /* If there is any qualification still in effect, clear it
29060 : : now; we will be starting fresh with the next declarator. */
29061 : 58403279 : parser->scope = NULL_TREE;
29062 : 58403279 : parser->qualifying_scope = NULL_TREE;
29063 : 58403279 : parser->object_scope = NULL_TREE;
29064 : : /* If it's a `,', then there are more declarators. */
29065 : 58403279 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
29066 : : {
29067 : 199723 : cp_lexer_consume_token (parser->lexer);
29068 : 199723 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
29069 : : {
29070 : 6 : cp_token *token = cp_lexer_previous_token (parser->lexer);
29071 : 6 : gcc_rich_location richloc (token->location);
29072 : 6 : richloc.add_fixit_remove ();
29073 : 6 : error_at (&richloc, "stray %<,%> at end of "
29074 : : "member declaration");
29075 : 6 : }
29076 : : }
29077 : : /* If the next token isn't a `;', then we have a parse error. */
29078 : 58203556 : else if (cp_lexer_next_token_is_not (parser->lexer,
29079 : : CPP_SEMICOLON))
29080 : : {
29081 : : /* The next token might be a ways away from where the
29082 : : actual semicolon is missing. Find the previous token
29083 : : and use that for our error position. */
29084 : 96 : cp_token *token = cp_lexer_previous_token (parser->lexer);
29085 : 96 : gcc_rich_location richloc (token->location);
29086 : 96 : richloc.add_fixit_insert_after (";");
29087 : 96 : error_at (&richloc, "expected %<;%> at end of "
29088 : : "member declaration");
29089 : :
29090 : : /* Assume that the user meant to provide a semicolon. If
29091 : : we were to cp_parser_skip_to_end_of_statement, we might
29092 : : skip to a semicolon inside a member function definition
29093 : : and issue nonsensical error messages. */
29094 : 96 : assume_semicolon = true;
29095 : 96 : }
29096 : :
29097 : 58403279 : if (decl)
29098 : : {
29099 : : /* Add DECL to the list of members. */
29100 : 58403249 : if (!friend_p
29101 : : /* Explicitly include, eg, NSDMIs, for better error
29102 : : recovery (c++/58650). */
29103 : 58403249 : || !DECL_DECLARES_FUNCTION_P (decl))
29104 : 58158580 : finish_member_declaration (decl);
29105 : :
29106 : 58403249 : if (DECL_DECLARES_FUNCTION_P (decl))
29107 : 20068243 : cp_parser_save_default_args (parser, STRIP_TEMPLATE (decl));
29108 : 38335006 : else if (TREE_CODE (decl) == FIELD_DECL
29109 : 38335006 : && DECL_INITIAL (decl))
29110 : : /* Add DECL to the queue of NSDMI to be parsed later. */
29111 : 1024883 : vec_safe_push (unparsed_nsdmis, decl);
29112 : : }
29113 : :
29114 : 58403279 : if (assume_semicolon)
29115 : 96 : goto out;
29116 : : }
29117 : : }
29118 : :
29119 : 61179054 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
29120 : 112168868 : out:
29121 : 112168868 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
29122 : 112168868 : cp_finalize_omp_declare_simd (parser, &odsd);
29123 : : }
29124 : :
29125 : : /* Parse a pure-specifier.
29126 : :
29127 : : pure-specifier:
29128 : : = 0
29129 : :
29130 : : Returns INTEGER_ZERO_NODE if a pure specifier is found.
29131 : : Otherwise, ERROR_MARK_NODE is returned. */
29132 : :
29133 : : static tree
29134 : 9120274 : cp_parser_pure_specifier (cp_parser* parser)
29135 : : {
29136 : 9120274 : cp_token *token;
29137 : :
29138 : : /* Look for the `=' token. */
29139 : 9120274 : if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
29140 : 0 : return error_mark_node;
29141 : : /* Look for the `0' token. */
29142 : 9120274 : token = cp_lexer_peek_token (parser->lexer);
29143 : :
29144 : 9120274 : if (token->type == CPP_EOF
29145 : 9120271 : || token->type == CPP_PRAGMA_EOL)
29146 : 3 : return error_mark_node;
29147 : :
29148 : 9120271 : cp_lexer_consume_token (parser->lexer);
29149 : :
29150 : : /* Accept = default or = delete in c++0x mode. */
29151 : 9120271 : if (token->keyword == RID_DEFAULT
29152 : 3670890 : || token->keyword == RID_DELETE)
29153 : : {
29154 : 8768610 : maybe_warn_cpp0x (CPP0X_DEFAULTED_DELETED);
29155 : 8768610 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
29156 : : {
29157 : 42 : if (cxx_dialect >= cxx11 && cxx_dialect < cxx26)
29158 : 42 : pedwarn (cp_lexer_peek_token (parser->lexer)->location,
29159 : : OPT_Wc__26_extensions,
29160 : : "%<delete%> reason only available with "
29161 : : "%<-std=c++2c%> or %<-std=gnu++2c%>");
29162 : :
29163 : : /* Consume the `('. */
29164 : 42 : matching_parens parens;
29165 : 42 : parens.consume_open (parser);
29166 : 42 : tree reason = cp_parser_unevaluated_string_literal (parser);
29167 : : /* Consume the `)'. */
29168 : 42 : parens.require_close (parser);
29169 : 42 : if (TREE_CODE (reason) == STRING_CST)
29170 : : {
29171 : 33 : TREE_TYPE (reason) = token->u.value;
29172 : 33 : return reason;
29173 : : }
29174 : : }
29175 : :
29176 : 8768577 : return token->u.value;
29177 : : }
29178 : :
29179 : : /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
29180 : 351661 : if (token->type != CPP_NUMBER || !(token->flags & PURE_ZERO))
29181 : : {
29182 : 39 : cp_parser_error (parser,
29183 : : "invalid pure specifier (only %<= 0%> is allowed)");
29184 : 39 : cp_parser_skip_to_end_of_statement (parser);
29185 : 39 : return error_mark_node;
29186 : : }
29187 : 351622 : if (PROCESSING_REAL_TEMPLATE_DECL_P ())
29188 : : {
29189 : 3 : error_at (token->location, "templates may not be %<virtual%>");
29190 : 3 : return error_mark_node;
29191 : : }
29192 : :
29193 : 351619 : return integer_zero_node;
29194 : : }
29195 : :
29196 : : /* Parse a constant-initializer.
29197 : :
29198 : : constant-initializer:
29199 : : = constant-expression
29200 : :
29201 : : Returns a representation of the constant-expression. */
29202 : :
29203 : : static tree
29204 : 21668 : cp_parser_constant_initializer (cp_parser* parser)
29205 : : {
29206 : : /* Look for the `=' token. */
29207 : 21668 : if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
29208 : 0 : return error_mark_node;
29209 : :
29210 : : /* It is invalid to write:
29211 : :
29212 : : struct S { static const int i = { 7 }; };
29213 : :
29214 : : */
29215 : 21668 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
29216 : : {
29217 : 1 : cp_parser_error (parser,
29218 : : "a brace-enclosed initializer is not allowed here");
29219 : : /* Consume the opening brace. */
29220 : 1 : matching_braces braces;
29221 : 1 : braces.consume_open (parser);
29222 : : /* Skip the initializer. */
29223 : 1 : cp_parser_skip_to_closing_brace (parser);
29224 : : /* Look for the trailing `}'. */
29225 : 1 : braces.require_close (parser);
29226 : :
29227 : 1 : return error_mark_node;
29228 : : }
29229 : :
29230 : 21667 : return cp_parser_constant_expression (parser);
29231 : : }
29232 : :
29233 : : /* Derived classes [gram.class.derived] */
29234 : :
29235 : : /* Parse a base-clause.
29236 : :
29237 : : base-clause:
29238 : : : base-specifier-list
29239 : :
29240 : : base-specifier-list:
29241 : : base-specifier ... [opt]
29242 : : base-specifier-list , base-specifier ... [opt]
29243 : :
29244 : : Returns a TREE_LIST representing the base-classes, in the order in
29245 : : which they were declared. The representation of each node is as
29246 : : described by cp_parser_base_specifier.
29247 : :
29248 : : In the case that no bases are specified, this function will return
29249 : : NULL_TREE, not ERROR_MARK_NODE. */
29250 : :
29251 : : static tree
29252 : 10052501 : cp_parser_base_clause (cp_parser* parser)
29253 : : {
29254 : 10052501 : tree bases = NULL_TREE;
29255 : :
29256 : : /* Look for the `:' that begins the list. */
29257 : 10052501 : cp_parser_require (parser, CPP_COLON, RT_COLON);
29258 : :
29259 : : /* Scan the base-specifier-list. */
29260 : 10814053 : while (true)
29261 : : {
29262 : 10433277 : cp_token *token;
29263 : 10433277 : tree base;
29264 : 10433277 : bool pack_expansion_p = false;
29265 : :
29266 : : /* Look for the base-specifier. */
29267 : 10433277 : base = cp_parser_base_specifier (parser);
29268 : : /* Look for the (optional) ellipsis. */
29269 : 10433277 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
29270 : : {
29271 : : /* Consume the `...'. */
29272 : 19209 : cp_lexer_consume_token (parser->lexer);
29273 : :
29274 : 19209 : pack_expansion_p = true;
29275 : : }
29276 : :
29277 : : /* Add BASE to the front of the list. */
29278 : 10433277 : if (base && base != error_mark_node)
29279 : : {
29280 : 10433198 : if (pack_expansion_p)
29281 : : /* Make this a pack expansion type. */
29282 : 19209 : TREE_VALUE (base) = make_pack_expansion (TREE_VALUE (base));
29283 : :
29284 : 10433198 : if (!check_for_bare_parameter_packs (TREE_VALUE (base)))
29285 : : {
29286 : 10433180 : TREE_CHAIN (base) = bases;
29287 : 10433180 : bases = base;
29288 : : }
29289 : : }
29290 : : /* Peek at the next token. */
29291 : 10433277 : token = cp_lexer_peek_token (parser->lexer);
29292 : : /* If it's not a comma, then the list is complete. */
29293 : 10433277 : if (token->type != CPP_COMMA)
29294 : : break;
29295 : : /* Consume the `,'. */
29296 : 380776 : cp_lexer_consume_token (parser->lexer);
29297 : 380776 : }
29298 : :
29299 : : /* PARSER->SCOPE may still be non-NULL at this point, if the last
29300 : : base class had a qualified name. However, the next name that
29301 : : appears is certainly not qualified. */
29302 : 10052501 : parser->scope = NULL_TREE;
29303 : 10052501 : parser->qualifying_scope = NULL_TREE;
29304 : 10052501 : parser->object_scope = NULL_TREE;
29305 : :
29306 : 10052501 : return nreverse (bases);
29307 : : }
29308 : :
29309 : : /* Parse a base-specifier.
29310 : :
29311 : : base-specifier:
29312 : : attribute-specifier-seq [opt] class-or-decltype
29313 : : attribute-specifier-seq [opt] virtual access-specifier [opt]
29314 : : class-or-decltype
29315 : : attribute-specifier-seq [opt] access-specifier virtual [opt]
29316 : : class-or-decltype
29317 : :
29318 : : class-or-decltype:
29319 : : nested-name-specifier [opt] type-name
29320 : : nested-name-specifier template simple-template-id
29321 : : computed-type-specifier
29322 : :
29323 : : access-specifier:
29324 : : private
29325 : : protected
29326 : : public
29327 : :
29328 : : Returns a TREE_LIST. The TREE_PURPOSE will be one of
29329 : : ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
29330 : : indicate the specifiers provided. The TREE_VALUE will be a TYPE
29331 : : (or the ERROR_MARK_NODE) indicating the type that was specified. */
29332 : :
29333 : : static tree
29334 : 10433277 : cp_parser_base_specifier (cp_parser* parser)
29335 : : {
29336 : 10433277 : cp_token *token;
29337 : 10433277 : bool done = false;
29338 : 10433277 : bool virtual_p = false;
29339 : 10433277 : bool duplicate_virtual_error_issued_p = false;
29340 : 10433277 : bool duplicate_access_error_issued_p = false;
29341 : 10433277 : bool class_scope_p, template_p;
29342 : 10433277 : tree access = access_default_node;
29343 : 10433277 : tree type;
29344 : 10433277 : location_t attrs_loc = cp_lexer_peek_token (parser->lexer)->location;
29345 : 10433277 : tree std_attrs = cp_parser_std_attribute_spec_seq (parser);
29346 : :
29347 : 10433277 : if (std_attrs != NULL_TREE && any_nonignored_attribute_p (std_attrs))
29348 : 34 : warning_at (attrs_loc, OPT_Wattributes,
29349 : : "attributes on base specifiers are ignored");
29350 : :
29351 : : /* Process the optional `virtual' and `access-specifier'. */
29352 : 27024835 : while (!done)
29353 : : {
29354 : : /* Peek at the next token. */
29355 : 16591558 : token = cp_lexer_peek_token (parser->lexer);
29356 : : /* Process `virtual'. */
29357 : 16591558 : switch (token->keyword)
29358 : : {
29359 : 24961 : case RID_VIRTUAL:
29360 : : /* If `virtual' appears more than once, issue an error. */
29361 : 24961 : if (virtual_p && !duplicate_virtual_error_issued_p)
29362 : : {
29363 : 0 : cp_parser_error (parser,
29364 : : "%<virtual%> specified more than once in base-specifier");
29365 : 0 : duplicate_virtual_error_issued_p = true;
29366 : : }
29367 : :
29368 : 24961 : virtual_p = true;
29369 : :
29370 : : /* Consume the `virtual' token. */
29371 : 24961 : cp_lexer_consume_token (parser->lexer);
29372 : :
29373 : 24961 : break;
29374 : :
29375 : 6133320 : case RID_PUBLIC:
29376 : 6133320 : case RID_PROTECTED:
29377 : 6133320 : case RID_PRIVATE:
29378 : : /* If more than one access specifier appears, issue an
29379 : : error. */
29380 : 6133320 : if (access != access_default_node
29381 : 0 : && !duplicate_access_error_issued_p)
29382 : : {
29383 : 0 : cp_parser_error (parser,
29384 : : "more than one access specifier in base-specifier");
29385 : 0 : duplicate_access_error_issued_p = true;
29386 : : }
29387 : :
29388 : 6133320 : access = ridpointers[(int) token->keyword];
29389 : :
29390 : : /* Consume the access-specifier. */
29391 : 6133320 : cp_lexer_consume_token (parser->lexer);
29392 : :
29393 : 6133320 : break;
29394 : :
29395 : : default:
29396 : : done = true;
29397 : : break;
29398 : : }
29399 : : }
29400 : : /* It is not uncommon to see programs mechanically, erroneously, use
29401 : : the 'typename' keyword to denote (dependent) qualified types
29402 : : as base classes. */
29403 : 10433277 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
29404 : : {
29405 : 9 : token = cp_lexer_peek_token (parser->lexer);
29406 : 9 : if (!processing_template_decl)
29407 : 3 : error_at (token->location,
29408 : : "keyword %<typename%> not allowed outside of templates");
29409 : : else
29410 : 6 : error_at (token->location,
29411 : : "keyword %<typename%> not allowed in this context "
29412 : : "(the base class is implicitly a type)");
29413 : 9 : cp_lexer_consume_token (parser->lexer);
29414 : : }
29415 : :
29416 : : /* Look for the optional `::' operator. */
29417 : 10433277 : cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
29418 : : /* Look for the nested-name-specifier. The simplest way to
29419 : : implement:
29420 : :
29421 : : [temp.res]
29422 : :
29423 : : The keyword `typename' is not permitted in a base-specifier or
29424 : : mem-initializer; in these contexts a qualified name that
29425 : : depends on a template-parameter is implicitly assumed to be a
29426 : : type name.
29427 : :
29428 : : is to pretend that we have seen the `typename' keyword at this
29429 : : point. */
29430 : 10433277 : cp_parser_nested_name_specifier_opt (parser,
29431 : : /*typename_keyword_p=*/true,
29432 : : /*check_dependency_p=*/true,
29433 : : /*type_p=*/true,
29434 : : /*is_declaration=*/true);
29435 : : /* If the base class is given by a qualified name, assume that names
29436 : : we see are type names or templates, as appropriate. */
29437 : 10433277 : class_scope_p = (parser->scope && TYPE_P (parser->scope));
29438 : 1006179 : template_p = class_scope_p && cp_parser_optional_template_keyword (parser);
29439 : :
29440 : 10433277 : if (!parser->scope
29441 : 10433277 : && cp_lexer_next_token_is_decltype (parser->lexer))
29442 : : /* DR 950 allows decltype as a base-specifier. */
29443 : 27986 : type = cp_parser_decltype (parser);
29444 : : else
29445 : : {
29446 : : /* Otherwise, look for the class-name. */
29447 : 10405291 : type = cp_parser_class_name (parser,
29448 : : class_scope_p,
29449 : : template_p,
29450 : : typename_type,
29451 : : /*check_dependency_p=*/true,
29452 : : /*class_head_p=*/false,
29453 : : /*is_declaration=*/true);
29454 : 10405291 : type = TREE_TYPE (type);
29455 : : /* ": T...[constant-expression]" is a C++26 pack-index-specifier. */
29456 : 10405291 : if (cp_parser_next_tokens_are_pack_index_p (parser))
29457 : 1 : type = cp_parser_pack_index (parser, type);
29458 : : }
29459 : :
29460 : 10433277 : if (type == error_mark_node)
29461 : : return error_mark_node;
29462 : :
29463 : 10433201 : return finish_base_specifier (type, access, virtual_p);
29464 : : }
29465 : :
29466 : : /* Exception handling [gram.exception] */
29467 : :
29468 : : /* Save the tokens that make up the noexcept-specifier for a member-function.
29469 : : Returns a DEFERRED_PARSE. */
29470 : :
29471 : : static tree
29472 : 2381294 : cp_parser_save_noexcept (cp_parser *parser)
29473 : : {
29474 : 2381294 : cp_token *first = parser->lexer->next_token;
29475 : : /* We want everything up to, including, the final ')'. */
29476 : 2381294 : cp_parser_cache_group (parser, CPP_CLOSE_PAREN, /*depth=*/0);
29477 : 2381294 : cp_token *last = parser->lexer->next_token;
29478 : :
29479 : : /* As with default arguments and NSDMIs, make use of DEFERRED_PARSE
29480 : : to carry the information we will need. */
29481 : 2381294 : tree expr = make_node (DEFERRED_PARSE);
29482 : : /* Save away the noexcept-specifier; we will process it when the
29483 : : class is complete. */
29484 : 2381294 : DEFPARSE_TOKENS (expr) = cp_token_cache_new (first, last);
29485 : 2381294 : DEFPARSE_INSTANTIATIONS (expr) = nullptr;
29486 : 2381294 : expr = build_tree_list (expr, NULL_TREE);
29487 : 2381294 : return expr;
29488 : : }
29489 : :
29490 : : /* Used for late processing of noexcept-specifiers of member-functions.
29491 : : DEFAULT_ARG is the unparsed operand of a noexcept-specifier which
29492 : : we saved for later; parse it now. DECL is the declaration of the
29493 : : member function. */
29494 : :
29495 : : static tree
29496 : 2381294 : cp_parser_late_noexcept_specifier (cp_parser *parser, tree default_arg)
29497 : : {
29498 : : /* Make sure we've gotten something that hasn't been parsed yet. */
29499 : 2381294 : gcc_assert (TREE_CODE (default_arg) == DEFERRED_PARSE);
29500 : :
29501 : 2381294 : push_unparsed_function_queues (parser);
29502 : :
29503 : : /* Push the saved tokens for the noexcept-specifier onto the parser's
29504 : : lexer stack. */
29505 : 2381294 : cp_token_cache *tokens = DEFPARSE_TOKENS (default_arg);
29506 : 2381294 : cp_parser_push_lexer_for_tokens (parser, tokens);
29507 : :
29508 : : /* Parse the cached noexcept-specifier. */
29509 : 2381294 : tree parsed_arg
29510 : 2381294 : = cp_parser_noexcept_specification_opt (parser,
29511 : : CP_PARSER_FLAGS_NONE,
29512 : : /*require_constexpr=*/true,
29513 : : /*consumed_expr=*/NULL,
29514 : : /*return_cond=*/false);
29515 : :
29516 : : /* Revert to the main lexer. */
29517 : 2381294 : cp_parser_pop_lexer (parser);
29518 : :
29519 : : /* Restore the queue. */
29520 : 2381294 : pop_unparsed_function_queues (parser);
29521 : :
29522 : : /* And we're done. */
29523 : 2381294 : return parsed_arg;
29524 : : }
29525 : :
29526 : : /* Perform late checking of overriding function with respect to their
29527 : : noexcept-specifiers. FNDECL is the member function that potentially
29528 : : overrides some virtual function with the same signature. */
29529 : :
29530 : : static void
29531 : 2381294 : noexcept_override_late_checks (tree fndecl)
29532 : : {
29533 : 2381294 : tree binfo = TYPE_BINFO (DECL_CONTEXT (fndecl));
29534 : 2381294 : tree base_binfo;
29535 : :
29536 : 2381294 : if (DECL_STATIC_FUNCTION_P (fndecl))
29537 : 2381294 : return;
29538 : :
29539 : 3915461 : for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
29540 : : {
29541 : 1679332 : tree basetype = BINFO_TYPE (base_binfo);
29542 : :
29543 : 1679332 : if (!TYPE_POLYMORPHIC_P (basetype))
29544 : 1679323 : continue;
29545 : :
29546 : 9 : tree fn = look_for_overrides_here (basetype, fndecl);
29547 : 9 : if (fn)
29548 : 6 : maybe_check_overriding_exception_spec (fndecl, fn);
29549 : : }
29550 : : }
29551 : :
29552 : : /* Parse an (optional) noexcept-specification.
29553 : :
29554 : : noexcept-specification:
29555 : : noexcept ( constant-expression ) [opt]
29556 : :
29557 : : If no noexcept-specification is present, returns NULL_TREE.
29558 : : Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
29559 : : expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
29560 : : there are no parentheses. CONSUMED_EXPR will be set accordingly.
29561 : : Otherwise, returns a noexcept specification unless RETURN_COND is true,
29562 : : in which case a boolean condition is returned instead. The parser flags
29563 : : FLAGS is used to control parsing. QUALS are qualifiers indicating whether
29564 : : the (member) function is `const'. */
29565 : :
29566 : : static tree
29567 : 167912104 : cp_parser_noexcept_specification_opt (cp_parser* parser,
29568 : : cp_parser_flags flags,
29569 : : bool require_constexpr,
29570 : : bool* consumed_expr,
29571 : : bool return_cond)
29572 : : {
29573 : 167912104 : cp_token *token;
29574 : 167912104 : const char *saved_message;
29575 : :
29576 : : /* Peek at the next token. */
29577 : 167912104 : token = cp_lexer_peek_token (parser->lexer);
29578 : :
29579 : : /* Is it a noexcept-specification? */
29580 : 167912104 : if (cp_parser_is_keyword (token, RID_NOEXCEPT))
29581 : : {
29582 : 65037757 : tree expr;
29583 : :
29584 : : /* [class.mem]/6 says that a noexcept-specifer (within the
29585 : : member-specification of the class) is a complete-class context of
29586 : : a class. So, if the noexcept-specifier has the optional expression,
29587 : : just save the tokens, and reparse this after we're done with the
29588 : : class. */
29589 : :
29590 : 65037757 : if ((flags & CP_PARSER_FLAGS_DELAY_NOEXCEPT)
29591 : 27424809 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN)
29592 : : /* No need to delay parsing for a number literal or true/false. */
29593 : 2422677 : && !((cp_lexer_nth_token_is (parser->lexer, 3, CPP_NUMBER)
29594 : 2422668 : || cp_lexer_nth_token_is (parser->lexer, 3, CPP_KEYWORD))
29595 : 708845 : && cp_lexer_nth_token_is (parser->lexer, 4, CPP_CLOSE_PAREN))
29596 : 2381294 : && at_class_scope_p ()
29597 : 2381294 : && TYPE_BEING_DEFINED (current_class_type)
29598 : 69800345 : && !LAMBDA_TYPE_P (current_class_type))
29599 : 2381294 : return cp_parser_save_noexcept (parser);
29600 : :
29601 : 62656463 : cp_lexer_consume_token (parser->lexer);
29602 : :
29603 : 62656463 : if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
29604 : : {
29605 : 28665248 : matching_parens parens;
29606 : 28665248 : parens.consume_open (parser);
29607 : :
29608 : 28665248 : if (require_constexpr)
29609 : : {
29610 : : /* Types may not be defined in an exception-specification. */
29611 : 28665191 : saved_message = parser->type_definition_forbidden_message;
29612 : 28665191 : parser->type_definition_forbidden_message
29613 : 28665191 : = G_("types may not be defined in an exception-specification");
29614 : :
29615 : 28665191 : bool non_constant_p;
29616 : 28665191 : expr
29617 : 28665191 : = cp_parser_constant_expression (parser,
29618 : : /*allow_non_constant=*/true,
29619 : : &non_constant_p);
29620 : 28665191 : if (non_constant_p
29621 : 28665191 : && !require_potential_rvalue_constant_expression (expr))
29622 : : {
29623 : : expr = NULL_TREE;
29624 : : return_cond = true;
29625 : : }
29626 : :
29627 : : /* Restore the saved message. */
29628 : 28665191 : parser->type_definition_forbidden_message = saved_message;
29629 : : }
29630 : : else
29631 : : {
29632 : 57 : expr = cp_parser_expression (parser);
29633 : 57 : *consumed_expr = true;
29634 : : }
29635 : :
29636 : 28665248 : parens.require_close (parser);
29637 : : }
29638 : : else
29639 : : {
29640 : 33991215 : expr = boolean_true_node;
29641 : 33991215 : if (!require_constexpr)
29642 : 0 : *consumed_expr = false;
29643 : : }
29644 : :
29645 : : /* We cannot build a noexcept-spec right away because this will check
29646 : : that expr is a constexpr. */
29647 : 62656463 : if (!return_cond)
29648 : 62656316 : return build_noexcept_spec (expr, tf_warning_or_error);
29649 : : else
29650 : : return expr;
29651 : : }
29652 : : else
29653 : : return NULL_TREE;
29654 : : }
29655 : :
29656 : : /* Parse an (optional) exception-specification.
29657 : :
29658 : : exception-specification:
29659 : : throw ( type-id-list [opt] )
29660 : :
29661 : : Returns a TREE_LIST representing the exception-specification. The
29662 : : TREE_VALUE of each node is a type. The parser flags FLAGS is used to
29663 : : control parsing. QUALS are qualifiers indicating whether the (member)
29664 : : function is `const'. */
29665 : :
29666 : : static tree
29667 : 165530495 : cp_parser_exception_specification_opt (cp_parser* parser,
29668 : : cp_parser_flags flags)
29669 : : {
29670 : 165530495 : cp_token *token;
29671 : 165530495 : tree type_id_list;
29672 : 165530495 : const char *saved_message;
29673 : :
29674 : : /* Peek at the next token. */
29675 : 165530495 : token = cp_lexer_peek_token (parser->lexer);
29676 : :
29677 : : /* Is it a noexcept-specification? */
29678 : 165530495 : type_id_list
29679 : 165530495 : = cp_parser_noexcept_specification_opt (parser, flags,
29680 : : /*require_constexpr=*/true,
29681 : : /*consumed_expr=*/NULL,
29682 : : /*return_cond=*/false);
29683 : 165530495 : if (type_id_list != NULL_TREE)
29684 : : return type_id_list;
29685 : :
29686 : : /* If it's not `throw', then there's no exception-specification. */
29687 : 102874146 : if (!cp_parser_is_keyword (token, RID_THROW))
29688 : : return NULL_TREE;
29689 : :
29690 : 2020674 : location_t loc = token->location;
29691 : :
29692 : : /* Consume the `throw'. */
29693 : 2020674 : cp_lexer_consume_token (parser->lexer);
29694 : :
29695 : : /* Look for the `('. */
29696 : 2020674 : matching_parens parens;
29697 : 2020674 : parens.require_open (parser);
29698 : :
29699 : : /* Peek at the next token. */
29700 : 2020674 : token = cp_lexer_peek_token (parser->lexer);
29701 : : /* If it's not a `)', then there is a type-id-list. */
29702 : 2020674 : if (token->type != CPP_CLOSE_PAREN)
29703 : : {
29704 : : /* Types may not be defined in an exception-specification. */
29705 : 1168 : saved_message = parser->type_definition_forbidden_message;
29706 : 1168 : parser->type_definition_forbidden_message
29707 : 1168 : = G_("types may not be defined in an exception-specification");
29708 : : /* Parse the type-id-list. */
29709 : 1168 : type_id_list = cp_parser_type_id_list (parser);
29710 : : /* Restore the saved message. */
29711 : 1168 : parser->type_definition_forbidden_message = saved_message;
29712 : :
29713 : 1168 : if (cxx_dialect >= cxx17)
29714 : : {
29715 : 40 : error_at (loc, "ISO C++17 does not allow dynamic exception "
29716 : : "specifications");
29717 : 40 : type_id_list = NULL_TREE;
29718 : : }
29719 : 1128 : else if (cxx_dialect >= cxx11)
29720 : 221 : warning_at (loc, OPT_Wdeprecated,
29721 : : "dynamic exception specifications are deprecated in "
29722 : : "C++11");
29723 : : }
29724 : : /* In C++17, throw() is equivalent to noexcept (true). throw()
29725 : : is deprecated in C++11 and above as well, but is still widely used,
29726 : : so don't warn about it yet. */
29727 : 2019506 : else if (cxx_dialect >= cxx17)
29728 : 1713756 : type_id_list = noexcept_true_spec;
29729 : : else
29730 : 305750 : type_id_list = empty_except_spec;
29731 : :
29732 : : /* Look for the `)'. */
29733 : 2020674 : parens.require_close (parser);
29734 : :
29735 : 2020674 : return type_id_list;
29736 : : }
29737 : :
29738 : : /* Parse an (optional) type-id-list.
29739 : :
29740 : : type-id-list:
29741 : : type-id ... [opt]
29742 : : type-id-list , type-id ... [opt]
29743 : :
29744 : : Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
29745 : : in the order that the types were presented. */
29746 : :
29747 : : static tree
29748 : 1168 : cp_parser_type_id_list (cp_parser* parser)
29749 : : {
29750 : 1168 : tree types = NULL_TREE;
29751 : :
29752 : 1230 : while (true)
29753 : : {
29754 : 1199 : cp_token *token;
29755 : 1199 : tree type;
29756 : :
29757 : 1199 : token = cp_lexer_peek_token (parser->lexer);
29758 : :
29759 : : /* Get the next type-id. */
29760 : 1199 : type = cp_parser_type_id (parser);
29761 : : /* Check for invalid 'auto'. */
29762 : 1199 : if (flag_concepts && type_uses_auto (type))
29763 : : {
29764 : 2 : error_at (token->location,
29765 : : "invalid use of %<auto%> in exception-specification");
29766 : 2 : type = error_mark_node;
29767 : : }
29768 : : /* Parse the optional ellipsis. */
29769 : 1199 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
29770 : : {
29771 : : /* Consume the `...'. */
29772 : 4 : cp_lexer_consume_token (parser->lexer);
29773 : :
29774 : : /* Turn the type into a pack expansion expression. */
29775 : 4 : type = make_pack_expansion (type);
29776 : : }
29777 : : /* Add it to the list. */
29778 : 1199 : types = add_exception_specifier (types, type, /*complain=*/1);
29779 : : /* Peek at the next token. */
29780 : 1199 : token = cp_lexer_peek_token (parser->lexer);
29781 : : /* If it is not a `,', we are done. */
29782 : 1199 : if (token->type != CPP_COMMA)
29783 : : break;
29784 : : /* Consume the `,'. */
29785 : 31 : cp_lexer_consume_token (parser->lexer);
29786 : 31 : }
29787 : :
29788 : 1168 : return nreverse (types);
29789 : : }
29790 : :
29791 : : /* Parse a try-block.
29792 : :
29793 : : try-block:
29794 : : try compound-statement handler-seq */
29795 : :
29796 : : static tree
29797 : 983533 : cp_parser_try_block (cp_parser* parser)
29798 : : {
29799 : 983533 : tree try_block;
29800 : :
29801 : 983533 : cp_parser_require_keyword (parser, RID_TRY, RT_TRY);
29802 : 983533 : if (parser->in_function_body
29803 : 983533 : && DECL_DECLARED_CONSTEXPR_P (current_function_decl)
29804 : 1000068 : && cxx_dialect < cxx20)
29805 : 26 : pedwarn (input_location, OPT_Wc__20_extensions,
29806 : : "%<try%> in %<constexpr%> function only "
29807 : : "available with %<-std=c++20%> or %<-std=gnu++20%>");
29808 : :
29809 : 983533 : try_block = begin_try_block ();
29810 : 983533 : cp_parser_compound_statement (parser, NULL, BCS_TRY_BLOCK, false);
29811 : 983533 : finish_try_block (try_block);
29812 : 983533 : cp_parser_handler_seq (parser);
29813 : 983533 : finish_handler_sequence (try_block);
29814 : :
29815 : 983533 : return try_block;
29816 : : }
29817 : :
29818 : : /* Parse a function-try-block.
29819 : :
29820 : : function-try-block:
29821 : : try ctor-initializer [opt] function-body handler-seq */
29822 : :
29823 : : static void
29824 : 286 : cp_parser_function_try_block (cp_parser* parser)
29825 : : {
29826 : 286 : tree compound_stmt;
29827 : 286 : tree try_block;
29828 : :
29829 : : /* Look for the `try' keyword. */
29830 : 286 : if (!cp_parser_require_keyword (parser, RID_TRY, RT_TRY))
29831 : 0 : return;
29832 : : /* Let the rest of the front end know where we are. */
29833 : 286 : try_block = begin_function_try_block (&compound_stmt);
29834 : : /* Parse the function-body. */
29835 : 286 : cp_parser_ctor_initializer_opt_and_function_body
29836 : 286 : (parser, /*in_function_try_block=*/true);
29837 : : /* We're done with the `try' part. */
29838 : 286 : finish_function_try_block (try_block);
29839 : : /* Parse the handlers. */
29840 : 286 : cp_parser_handler_seq (parser);
29841 : : /* We're done with the handlers. */
29842 : 286 : finish_function_handler_sequence (try_block, compound_stmt);
29843 : : }
29844 : :
29845 : : /* Parse a handler-seq.
29846 : :
29847 : : handler-seq:
29848 : : handler handler-seq [opt] */
29849 : :
29850 : : static void
29851 : 983819 : cp_parser_handler_seq (cp_parser* parser)
29852 : : {
29853 : 1430256 : while (true)
29854 : : {
29855 : 1430256 : cp_token *token;
29856 : :
29857 : : /* Parse the handler. */
29858 : 1430256 : cp_parser_handler (parser);
29859 : : /* Peek at the next token. */
29860 : 1430256 : token = cp_lexer_peek_token (parser->lexer);
29861 : : /* If it's not `catch' then there are no more handlers. */
29862 : 1430256 : if (!cp_parser_is_keyword (token, RID_CATCH))
29863 : : break;
29864 : : }
29865 : 983819 : }
29866 : :
29867 : : /* Parse a handler.
29868 : :
29869 : : handler:
29870 : : catch ( exception-declaration ) compound-statement */
29871 : :
29872 : : static void
29873 : 1430256 : cp_parser_handler (cp_parser* parser)
29874 : : {
29875 : 1430256 : tree handler;
29876 : 1430256 : tree declaration;
29877 : :
29878 : 1430256 : cp_parser_require_keyword (parser, RID_CATCH, RT_CATCH);
29879 : 1430256 : handler = begin_handler ();
29880 : 1430256 : matching_parens parens;
29881 : 1430256 : parens.require_open (parser);
29882 : 1430256 : declaration = cp_parser_exception_declaration (parser);
29883 : 1430256 : finish_handler_parms (declaration, handler);
29884 : 1430256 : parens.require_close (parser);
29885 : 1430256 : cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
29886 : 1430256 : finish_handler (handler);
29887 : 1430256 : }
29888 : :
29889 : : /* Parse an exception-declaration.
29890 : :
29891 : : exception-declaration:
29892 : : type-specifier-seq declarator
29893 : : type-specifier-seq abstract-declarator
29894 : : type-specifier-seq
29895 : : ...
29896 : :
29897 : : Returns a VAR_DECL for the declaration, or NULL_TREE if the
29898 : : ellipsis variant is used. */
29899 : :
29900 : : static tree
29901 : 1430256 : cp_parser_exception_declaration (cp_parser* parser)
29902 : : {
29903 : 1430256 : cp_decl_specifier_seq type_specifiers;
29904 : 1430256 : cp_declarator *declarator;
29905 : 1430256 : const char *saved_message;
29906 : :
29907 : : /* If it's an ellipsis, it's easy to handle. */
29908 : 1430256 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
29909 : : {
29910 : : /* Consume the `...' token. */
29911 : 961282 : cp_lexer_consume_token (parser->lexer);
29912 : 961282 : return NULL_TREE;
29913 : : }
29914 : :
29915 : : /* Types may not be defined in exception-declarations. */
29916 : 468974 : saved_message = parser->type_definition_forbidden_message;
29917 : 468974 : parser->type_definition_forbidden_message
29918 : 468974 : = G_("types may not be defined in exception-declarations");
29919 : :
29920 : : /* Parse the type-specifier-seq. */
29921 : 468974 : cp_parser_type_specifier_seq (parser, CP_PARSER_FLAGS_NONE,
29922 : : /*is_declaration=*/true,
29923 : : /*is_trailing_return=*/false,
29924 : : &type_specifiers);
29925 : : /* If it's a `)', then there is no declarator. */
29926 : 468974 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
29927 : : declarator = NULL;
29928 : : else
29929 : 468096 : declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER,
29930 : : CP_PARSER_FLAGS_NONE,
29931 : : /*ctor_dtor_or_conv_p=*/NULL,
29932 : : /*parenthesized_p=*/NULL,
29933 : : /*member_p=*/false,
29934 : : /*friend_p=*/false,
29935 : : /*static_p=*/false);
29936 : :
29937 : : /* Restore the saved message. */
29938 : 468974 : parser->type_definition_forbidden_message = saved_message;
29939 : :
29940 : 468974 : if (!type_specifiers.any_specifiers_p)
29941 : 27 : return error_mark_node;
29942 : :
29943 : 468947 : tree decl = grokdeclarator (declarator, &type_specifiers, CATCHPARM, 1,
29944 : 468947 : &type_specifiers.attributes);
29945 : 468947 : if (decl != error_mark_node && type_specifiers.attributes)
29946 : : {
29947 : 75 : cplus_decl_attributes (&decl, type_specifiers.attributes, 0);
29948 : 150 : if (pedantic && lookup_attribute ("internal ", "aligned",
29949 : 75 : DECL_ATTRIBUTES (decl)))
29950 : 9 : pedwarn (type_specifiers.locations[ds_attribute]
29951 : : ? type_specifiers.locations[ds_attribute]
29952 : : : input_location, OPT_Wpedantic,
29953 : : "%<alignas%> on exception declaration");
29954 : : }
29955 : :
29956 : 468947 : return decl;
29957 : : }
29958 : :
29959 : : /* Parse a throw-expression.
29960 : :
29961 : : throw-expression:
29962 : : throw assignment-expression [opt]
29963 : :
29964 : : Returns a THROW_EXPR representing the throw-expression. */
29965 : :
29966 : : static tree
29967 : 1026402 : cp_parser_throw_expression (cp_parser* parser)
29968 : : {
29969 : 1026402 : tree expression;
29970 : 1026402 : cp_token* token;
29971 : 1026402 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
29972 : :
29973 : 1026402 : cp_parser_require_keyword (parser, RID_THROW, RT_THROW);
29974 : 1026402 : token = cp_lexer_peek_token (parser->lexer);
29975 : : /* Figure out whether or not there is an assignment-expression
29976 : : following the "throw" keyword. */
29977 : 1026402 : if (token->type == CPP_COMMA
29978 : : || token->type == CPP_SEMICOLON
29979 : : || token->type == CPP_CLOSE_PAREN
29980 : : || token->type == CPP_CLOSE_SQUARE
29981 : : || token->type == CPP_CLOSE_BRACE
29982 : : || token->type == CPP_COLON)
29983 : : expression = NULL_TREE;
29984 : : else
29985 : 142352 : expression = cp_parser_assignment_expression (parser);
29986 : :
29987 : : /* Construct a location e.g.:
29988 : : throw x
29989 : : ^~~~~~~
29990 : : with caret == start at the start of the "throw" token, and
29991 : : the end at the end of the final token we consumed. */
29992 : 1026402 : location_t combined_loc = make_location (start_loc, start_loc,
29993 : : parser->lexer);
29994 : 1026402 : expression = build_throw (combined_loc, expression, tf_warning_or_error);
29995 : :
29996 : 1026402 : return expression;
29997 : : }
29998 : :
29999 : : /* Parse a yield-expression.
30000 : :
30001 : : yield-expression:
30002 : : co_yield assignment-expression
30003 : : co_yield braced-init-list
30004 : :
30005 : : Returns a CO_YIELD_EXPR representing the yield-expression. */
30006 : :
30007 : : static tree
30008 : 1499 : cp_parser_yield_expression (cp_parser* parser)
30009 : : {
30010 : 1499 : tree expr;
30011 : :
30012 : 1499 : cp_token *token = cp_lexer_peek_token (parser->lexer);
30013 : 1499 : location_t kw_loc = token->location; /* Save for later. */
30014 : :
30015 : 1499 : cp_parser_require_keyword (parser, RID_CO_YIELD, RT_CO_YIELD);
30016 : :
30017 : 1499 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
30018 : : {
30019 : 2 : cp_lexer_set_source_position (parser->lexer);
30020 : : /* ??? : probably a moot point? */
30021 : 2 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
30022 : 2 : expr = cp_parser_braced_list (parser);
30023 : : }
30024 : : else
30025 : 1497 : expr = cp_parser_assignment_expression (parser);
30026 : :
30027 : : /* Similar to co_await, we cannot use co_yield in default arguments (as
30028 : : co_awaits underlie co_yield). */
30029 : 1499 : if (parser->local_variables_forbidden_p & LOCAL_VARS_FORBIDDEN)
30030 : : {
30031 : 1 : error_at (kw_loc,
30032 : : "%<co_yield%> cannot be used in default arguments");
30033 : 1 : return error_mark_node;
30034 : : }
30035 : :
30036 : 1498 : if (expr == error_mark_node)
30037 : : return expr;
30038 : :
30039 : 1496 : return finish_co_yield_expr (kw_loc, expr);
30040 : : }
30041 : :
30042 : : /* GNU Extensions */
30043 : :
30044 : : /* Parse an (optional) asm-specification.
30045 : :
30046 : : asm-specification:
30047 : : asm ( asm-string-expr )
30048 : :
30049 : : If the asm-specification is present, returns a STRING_CST
30050 : : corresponding to the string-literal. Otherwise, returns
30051 : : NULL_TREE. */
30052 : :
30053 : : static tree
30054 : 264350258 : cp_parser_asm_specification_opt (cp_parser* parser)
30055 : : {
30056 : : /* Peek at the next token. */
30057 : 264350258 : cp_token *token = cp_lexer_peek_token (parser->lexer);
30058 : : /* If the next token isn't the `asm' keyword, then there's no
30059 : : asm-specification. */
30060 : 264350258 : if (!cp_parser_is_keyword (token, RID_ASM))
30061 : : return NULL_TREE;
30062 : :
30063 : : /* Consume the `asm' token. */
30064 : 938850 : cp_lexer_consume_token (parser->lexer);
30065 : : /* Look for the `('. */
30066 : 938850 : matching_parens parens;
30067 : 938850 : parens.require_open (parser);
30068 : :
30069 : : /* Look for the string-literal. */
30070 : 938850 : tree asm_specification = cp_parser_asm_string_expression (parser);
30071 : :
30072 : : /* Look for the `)'. */
30073 : 938850 : parens.require_close (parser);
30074 : :
30075 : 938850 : return asm_specification;
30076 : : }
30077 : :
30078 : : /* Parse an asm-operand-list.
30079 : :
30080 : : asm-operand-list:
30081 : : asm-operand
30082 : : asm-operand-list , asm-operand
30083 : :
30084 : : asm-operand:
30085 : : asm-string-expr ( expression )
30086 : : [ asm-string-expr ] asm-string-expr ( expression )
30087 : :
30088 : : Returns a TREE_LIST representing the operands. The TREE_VALUE of
30089 : : each node is the expression. The TREE_PURPOSE is itself a
30090 : : TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
30091 : : string-literal (or NULL_TREE if not present) and whose TREE_VALUE
30092 : : is a STRING_CST for the string literal before the parenthesis. Returns
30093 : : ERROR_MARK_NODE if any of the operands are invalid. */
30094 : :
30095 : : static tree
30096 : 13679 : cp_parser_asm_operand_list (cp_parser* parser)
30097 : : {
30098 : 13679 : tree asm_operands = NULL_TREE;
30099 : 13679 : bool invalid_operands = false;
30100 : :
30101 : 46087 : while (true)
30102 : : {
30103 : 29883 : tree name;
30104 : :
30105 : 29883 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
30106 : : {
30107 : : /* Consume the `[' token. */
30108 : 53 : cp_lexer_consume_token (parser->lexer);
30109 : : /* Read the operand name. */
30110 : 53 : name = cp_parser_identifier (parser);
30111 : 53 : if (name != error_mark_node)
30112 : 50 : name = build_string (IDENTIFIER_LENGTH (name),
30113 : 50 : IDENTIFIER_POINTER (name));
30114 : : /* Look for the closing `]'. */
30115 : 53 : cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
30116 : : }
30117 : : else
30118 : : name = NULL_TREE;
30119 : : /* Look for the string. */
30120 : 29883 : tree string_literal = cp_parser_asm_string_expression (parser);
30121 : :
30122 : : /* Look for the `('. */
30123 : 29883 : matching_parens parens;
30124 : 29883 : parens.require_open (parser);
30125 : : /* Parse the expression. */
30126 : 29883 : tree expression = cp_parser_expression (parser);
30127 : : /* Look for the `)'. */
30128 : 29883 : parens.require_close (parser);
30129 : :
30130 : 29883 : if (name == error_mark_node
30131 : 29880 : || string_literal == error_mark_node
30132 : 29874 : || expression == error_mark_node)
30133 : 9 : invalid_operands = true;
30134 : :
30135 : : /* Add this operand to the list. */
30136 : 29883 : asm_operands = tree_cons (build_tree_list (name, string_literal),
30137 : : expression,
30138 : : asm_operands);
30139 : : /* If the next token is not a `,', there are no more
30140 : : operands. */
30141 : 29883 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
30142 : : break;
30143 : : /* Consume the `,'. */
30144 : 16204 : cp_lexer_consume_token (parser->lexer);
30145 : 16204 : }
30146 : :
30147 : 13679 : return invalid_operands ? error_mark_node : nreverse (asm_operands);
30148 : : }
30149 : :
30150 : : /* Parse an asm-clobber-list.
30151 : :
30152 : : asm-clobber-list:
30153 : : const-expression
30154 : : asm-clobber-list , const-expression
30155 : :
30156 : : Returns a TREE_LIST, indicating the clobbers in the order that they
30157 : : appeared. The TREE_VALUE of each node is a STRING_CST. */
30158 : :
30159 : : static tree
30160 : 4497 : cp_parser_asm_clobber_list (cp_parser* parser)
30161 : : {
30162 : 4497 : tree clobbers = NULL_TREE;
30163 : :
30164 : 4621 : while (true)
30165 : : {
30166 : : /* Look for the string literal. */
30167 : 4559 : tree string_literal = cp_parser_asm_string_expression (parser);
30168 : : /* Add it to the list. */
30169 : 4559 : clobbers = tree_cons (NULL_TREE, string_literal, clobbers);
30170 : : /* If the next token is not a `,', then the list is
30171 : : complete. */
30172 : 4559 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
30173 : : break;
30174 : : /* Consume the `,' token. */
30175 : 62 : cp_lexer_consume_token (parser->lexer);
30176 : 62 : }
30177 : :
30178 : 4497 : return clobbers;
30179 : : }
30180 : :
30181 : : /* Parse an asm-label-list.
30182 : :
30183 : : asm-label-list:
30184 : : identifier
30185 : : asm-label-list , identifier
30186 : :
30187 : : Returns a TREE_LIST, indicating the labels in the order that they
30188 : : appeared. The TREE_VALUE of each node is a label. */
30189 : :
30190 : : static tree
30191 : 71 : cp_parser_asm_label_list (cp_parser* parser)
30192 : : {
30193 : 71 : tree labels = NULL_TREE;
30194 : :
30195 : 113 : while (true)
30196 : : {
30197 : 92 : tree identifier, label, name;
30198 : :
30199 : : /* Look for the identifier. */
30200 : 92 : identifier = cp_parser_identifier (parser);
30201 : 92 : if (!error_operand_p (identifier))
30202 : : {
30203 : 89 : label = lookup_label (identifier);
30204 : 89 : if (TREE_CODE (label) == LABEL_DECL)
30205 : : {
30206 : 89 : TREE_USED (label) = 1;
30207 : 89 : check_goto (label);
30208 : 89 : name = build_string (IDENTIFIER_LENGTH (identifier),
30209 : 89 : IDENTIFIER_POINTER (identifier));
30210 : 89 : labels = tree_cons (name, label, labels);
30211 : : }
30212 : : }
30213 : : /* If the next token is not a `,', then the list is
30214 : : complete. */
30215 : 92 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
30216 : : break;
30217 : : /* Consume the `,' token. */
30218 : 21 : cp_lexer_consume_token (parser->lexer);
30219 : 21 : }
30220 : :
30221 : 71 : return nreverse (labels);
30222 : : }
30223 : :
30224 : : /* Return TRUE iff the next tokens in the stream are possibly the
30225 : : beginning of a GNU extension attribute. */
30226 : :
30227 : : static bool
30228 : 3048261320 : cp_next_tokens_can_be_gnu_attribute_p (cp_parser *parser)
30229 : : {
30230 : 6096522640 : return cp_nth_tokens_can_be_gnu_attribute_p (parser, 1);
30231 : : }
30232 : :
30233 : : /* Return TRUE iff the next tokens in the stream are possibly the
30234 : : beginning of a standard C++-11 attribute specifier. */
30235 : :
30236 : : static bool
30237 : 3060889768 : cp_next_tokens_can_be_std_attribute_p (cp_parser *parser)
30238 : : {
30239 : 49784363 : return cp_nth_tokens_can_be_std_attribute_p (parser, 1);
30240 : : }
30241 : :
30242 : : /* Return TRUE iff the next Nth tokens in the stream are possibly the
30243 : : beginning of a standard C++-11 attribute specifier. */
30244 : :
30245 : : static bool
30246 : 3144472417 : cp_nth_tokens_can_be_std_attribute_p (cp_parser *parser, size_t n)
30247 : : {
30248 : 3144472417 : cp_token *token = cp_lexer_peek_nth_token (parser->lexer, n);
30249 : :
30250 : 3144472417 : return ((token->type == CPP_KEYWORD && token->keyword == RID_ALIGNAS)
30251 : 3144472417 : || (token->type == CPP_OPEN_SQUARE
30252 : 38235978 : && (token = cp_lexer_peek_nth_token (parser->lexer, n + 1))
30253 : 38235978 : && token->type == CPP_OPEN_SQUARE));
30254 : : }
30255 : :
30256 : : /* Return TRUE iff the next Nth tokens in the stream are possibly the
30257 : : beginning of a GNU extension attribute. */
30258 : :
30259 : : static bool
30260 : 3131921150 : cp_nth_tokens_can_be_gnu_attribute_p (cp_parser *parser, size_t n)
30261 : : {
30262 : 3048261320 : cp_token *token = cp_lexer_peek_nth_token (parser->lexer, n);
30263 : :
30264 : 3131921150 : return token->type == CPP_KEYWORD && token->keyword == RID_ATTRIBUTE;
30265 : : }
30266 : :
30267 : : /* Return true iff the next tokens can be the beginning of either a
30268 : : GNU attribute list, or a standard C++11 attribute sequence. */
30269 : :
30270 : : static bool
30271 : 2385865756 : cp_next_tokens_can_be_attribute_p (cp_parser *parser)
30272 : : {
30273 : 2385865756 : return (cp_next_tokens_can_be_gnu_attribute_p (parser)
30274 : 2385865756 : || cp_next_tokens_can_be_std_attribute_p (parser));
30275 : : }
30276 : :
30277 : : /* Return true iff the next Nth tokens can be the beginning of either
30278 : : a GNU attribute list, or a standard C++11 attribute sequence. */
30279 : :
30280 : : static bool
30281 : 83611858 : cp_nth_tokens_can_be_attribute_p (cp_parser *parser, size_t n)
30282 : : {
30283 : 83611858 : return (cp_nth_tokens_can_be_gnu_attribute_p (parser, n)
30284 : 83611858 : || cp_nth_tokens_can_be_std_attribute_p (parser, n));
30285 : : }
30286 : :
30287 : : /* Parse either a standard C++-11 attribute-specifier-seq, or a series
30288 : : of GNU attributes, or return NULL. */
30289 : :
30290 : : static tree
30291 : 617943231 : cp_parser_attributes_opt (cp_parser *parser)
30292 : : {
30293 : 617943231 : tree attrs = NULL_TREE;
30294 : 649079188 : while (true)
30295 : : {
30296 : 649079188 : if (cp_next_tokens_can_be_gnu_attribute_p (parser))
30297 : 19210927 : attrs = attr_chainon (attrs, cp_parser_gnu_attributes_opt (parser));
30298 : 629868261 : else if (cp_next_tokens_can_be_std_attribute_p (parser))
30299 : 11925030 : attrs = attr_chainon (attrs, cp_parser_std_attribute_spec_seq (parser));
30300 : : else
30301 : : break;
30302 : : }
30303 : 617943231 : return attrs;
30304 : : }
30305 : :
30306 : : /* Parse an (optional) series of attributes.
30307 : :
30308 : : attributes:
30309 : : attributes attribute
30310 : :
30311 : : attribute:
30312 : : __attribute__ (( attribute-list [opt] ))
30313 : :
30314 : : The return value is as for cp_parser_gnu_attribute_list. */
30315 : :
30316 : : static tree
30317 : 1141226503 : cp_parser_gnu_attributes_opt (cp_parser* parser)
30318 : : {
30319 : 1141226503 : tree attributes = NULL_TREE;
30320 : :
30321 : 1141226503 : auto cleanup = make_temp_override
30322 : 1141226503 : (parser->auto_is_implicit_function_template_parm_p, false);
30323 : :
30324 : 1183078721 : while (true)
30325 : : {
30326 : 1162152612 : cp_token *token;
30327 : 1162152612 : tree attribute_list;
30328 : 1162152612 : bool ok = true;
30329 : :
30330 : : /* Peek at the next token. */
30331 : 1162152612 : token = cp_lexer_peek_token (parser->lexer);
30332 : : /* If it's not `__attribute__', then we're done. */
30333 : 1162152612 : if (token->keyword != RID_ATTRIBUTE)
30334 : : break;
30335 : :
30336 : : /* Consume the `__attribute__' keyword. */
30337 : 20926109 : cp_lexer_consume_token (parser->lexer);
30338 : : /* Look for the two `(' tokens. */
30339 : 20926109 : matching_parens outer_parens;
30340 : 20926109 : if (!outer_parens.require_open (parser))
30341 : : ok = false;
30342 : 20926109 : matching_parens inner_parens;
30343 : 20926109 : if (!inner_parens.require_open (parser))
30344 : 30 : ok = false;
30345 : :
30346 : : /* Peek at the next token. */
30347 : 20926109 : token = cp_lexer_peek_token (parser->lexer);
30348 : 20926109 : if (token->type != CPP_CLOSE_PAREN)
30349 : : /* Parse the attribute-list. */
30350 : 20926077 : attribute_list = cp_parser_gnu_attribute_list (parser);
30351 : : else
30352 : : /* If the next token is a `)', then there is no attribute
30353 : : list. */
30354 : : attribute_list = NULL;
30355 : :
30356 : : /* Look for the two `)' tokens. */
30357 : 20926109 : if (!inner_parens.require_close (parser))
30358 : 39 : ok = false;
30359 : 20926109 : if (!outer_parens.require_close (parser))
30360 : : ok = false;
30361 : 20926049 : if (!ok)
30362 : 75 : cp_parser_skip_to_end_of_statement (parser);
30363 : :
30364 : : /* Add these new attributes to the list. */
30365 : 20926109 : attributes = attr_chainon (attributes, attribute_list);
30366 : 20926109 : }
30367 : :
30368 : 1141226503 : return attributes;
30369 : 1141226503 : }
30370 : :
30371 : : /* Parse a GNU attribute-list.
30372 : :
30373 : : attribute-list:
30374 : : attribute
30375 : : attribute-list , attribute
30376 : :
30377 : : attribute:
30378 : : identifier
30379 : : identifier ( identifier )
30380 : : identifier ( identifier , expression-list )
30381 : : identifier ( expression-list )
30382 : :
30383 : : Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
30384 : : to an attribute. The TREE_PURPOSE of each node is the identifier
30385 : : indicating which attribute is in use. The TREE_VALUE represents
30386 : : the arguments, if any. */
30387 : :
30388 : : static tree
30389 : 20928172 : cp_parser_gnu_attribute_list (cp_parser* parser, bool exactly_one /* = false */)
30390 : : {
30391 : 20928172 : tree attribute_list = NULL_TREE;
30392 : 20928172 : bool save_translate_strings_p = parser->translate_strings_p;
30393 : :
30394 : : /* Don't create wrapper nodes within attributes: the
30395 : : handlers don't know how to handle them. */
30396 : 20928172 : auto_suppress_location_wrappers sentinel;
30397 : :
30398 : 20928172 : parser->translate_strings_p = false;
30399 : 27303296 : while (true)
30400 : : {
30401 : 24115734 : cp_token *token;
30402 : 24115734 : tree identifier;
30403 : 24115734 : tree attribute;
30404 : :
30405 : : /* Look for the identifier. We also allow keywords here; for
30406 : : example `__attribute__ ((const))' is legal. */
30407 : 24115734 : token = cp_lexer_peek_token (parser->lexer);
30408 : 24115734 : if (token->type == CPP_NAME
30409 : 3555053 : || token->type == CPP_KEYWORD)
30410 : : {
30411 : 24115719 : tree arguments = NULL_TREE;
30412 : :
30413 : : /* Consume the token, but save it since we need it for the
30414 : : SIMD enabled function parsing. */
30415 : 24115719 : cp_token *id_token = cp_lexer_consume_token (parser->lexer);
30416 : :
30417 : : /* Save away the identifier that indicates which attribute
30418 : : this is. */
30419 : 48231438 : identifier = (token->type == CPP_KEYWORD)
30420 : : /* For keywords, use the canonical spelling, not the
30421 : : parsed identifier. */
30422 : 24115719 : ? ridpointers[(int) token->keyword]
30423 : : : id_token->u.value;
30424 : :
30425 : 24115719 : identifier = canonicalize_attr_name (identifier);
30426 : 24115719 : attribute = build_tree_list (identifier, NULL_TREE);
30427 : :
30428 : : /* Peek at the next token. */
30429 : 24115719 : token = cp_lexer_peek_token (parser->lexer);
30430 : : /* If it's an `(', then parse the attribute arguments. */
30431 : 24115719 : if (token->type == CPP_OPEN_PAREN)
30432 : : {
30433 : 10209271 : vec<tree, va_gc> *vec;
30434 : 10209271 : int attr_flag = (attribute_takes_identifier_p (identifier)
30435 : 10209271 : ? id_attr : normal_attr);
30436 : 10209271 : if (is_attribute_p ("assume", identifier))
30437 : 20573 : attr_flag = assume_attr;
30438 : 10209271 : vec = cp_parser_parenthesized_expression_list
30439 : 10209271 : (parser, attr_flag, /*cast_p=*/false,
30440 : : /*allow_expansion_p=*/false,
30441 : : /*non_constant_p=*/NULL);
30442 : 10209271 : if (vec == NULL)
30443 : 33 : arguments = error_mark_node;
30444 : : else
30445 : : {
30446 : 10209238 : arguments = build_tree_list_vec (vec);
30447 : 10209238 : release_tree_vector (vec);
30448 : : }
30449 : : /* Save the arguments away. */
30450 : 10209271 : TREE_VALUE (attribute) = arguments;
30451 : : }
30452 : :
30453 : 24115719 : if (arguments != error_mark_node)
30454 : : {
30455 : : /* Add this attribute to the list. */
30456 : 24115686 : TREE_CHAIN (attribute) = attribute_list;
30457 : 24115686 : attribute_list = attribute;
30458 : : }
30459 : :
30460 : 24115719 : token = cp_lexer_peek_token (parser->lexer);
30461 : : }
30462 : : /* Unless EXACTLY_ONE is set look for more attributes.
30463 : : If the next token isn't a `,', we're done. */
30464 : 24115734 : if (exactly_one || token->type != CPP_COMMA)
30465 : : break;
30466 : :
30467 : : /* Consume the comma and keep going. */
30468 : 3187562 : cp_lexer_consume_token (parser->lexer);
30469 : 3187562 : }
30470 : 20928172 : parser->translate_strings_p = save_translate_strings_p;
30471 : :
30472 : : /* We built up the list in reverse order. */
30473 : 20928172 : return nreverse (attribute_list);
30474 : : }
30475 : :
30476 : : /* Parse arguments of omp::directive attribute.
30477 : :
30478 : : ( directive-name ,[opt] clause-list[opt] )
30479 : :
30480 : : For directive just remember the first/last tokens for subsequent
30481 : : parsing. */
30482 : :
30483 : : static void
30484 : 3007 : cp_parser_omp_directive_args (cp_parser *parser, tree attribute, bool decl_p)
30485 : : {
30486 : 3007 : cp_token *first = cp_lexer_peek_nth_token (parser->lexer, 2);
30487 : 3007 : if (first->type == CPP_CLOSE_PAREN)
30488 : : {
30489 : 9 : cp_lexer_consume_token (parser->lexer);
30490 : 9 : error_at (first->location, "expected OpenMP directive name");
30491 : 9 : cp_lexer_consume_token (parser->lexer);
30492 : 9 : TREE_VALUE (attribute) = NULL_TREE;
30493 : 9 : return;
30494 : : }
30495 : 2998 : size_t n = cp_parser_skip_balanced_tokens (parser, 1);
30496 : 2998 : if (n == 1)
30497 : : {
30498 : 3 : cp_lexer_consume_token (parser->lexer);
30499 : 3 : error_at (first->location, "expected attribute argument as balanced "
30500 : : "token sequence");
30501 : 3 : TREE_VALUE (attribute) = NULL_TREE;
30502 : 3 : return;
30503 : : }
30504 : 59814 : for (n = n - 2; n; --n)
30505 : 56819 : cp_lexer_consume_token (parser->lexer);
30506 : 2995 : cp_token *last = cp_lexer_peek_token (parser->lexer);
30507 : 2995 : cp_lexer_consume_token (parser->lexer);
30508 : 2995 : tree arg = make_node (DEFERRED_PARSE);
30509 : 2995 : DEFPARSE_TOKENS (arg) = cp_token_cache_new (first, last);
30510 : 2995 : DEFPARSE_INSTANTIATIONS (arg) = nullptr;
30511 : 2995 : if (decl_p)
30512 : 242 : TREE_PUBLIC (arg) = 1;
30513 : 2995 : TREE_VALUE (attribute) = tree_cons (NULL_TREE, arg, TREE_VALUE (attribute));
30514 : : }
30515 : :
30516 : : /* Parse arguments of omp::sequence attribute.
30517 : :
30518 : : ( omp::[opt] directive-attr [ , omp::[opt] directive-attr ]... ) */
30519 : :
30520 : : static void
30521 : 504 : cp_parser_omp_sequence_args (cp_parser *parser, tree attribute)
30522 : : {
30523 : 504 : matching_parens parens;
30524 : 504 : parens.consume_open (parser);
30525 : 1490 : do
30526 : : {
30527 : 997 : cp_token *token = cp_lexer_peek_token (parser->lexer);
30528 : 997 : if (token->type == CPP_NAME
30529 : 994 : && token->u.value == omp_identifier
30530 : 1225 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_SCOPE))
30531 : : {
30532 : 228 : cp_lexer_consume_token (parser->lexer);
30533 : 228 : cp_lexer_consume_token (parser->lexer);
30534 : 228 : token = cp_lexer_peek_token (parser->lexer);
30535 : : }
30536 : 997 : bool directive = false;
30537 : 997 : const char *p;
30538 : 997 : if (token->type != CPP_NAME)
30539 : : p = "";
30540 : : else
30541 : 994 : p = IDENTIFIER_POINTER (token->u.value);
30542 : 997 : if (strcmp (p, "directive") == 0)
30543 : : directive = true;
30544 : 42 : else if (strcmp (p, "sequence") != 0)
30545 : : {
30546 : 27 : error_at (token->location, "expected %<directive%> or %<sequence%>");
30547 : 27 : cp_parser_skip_to_closing_parenthesis (parser,
30548 : : /*recovering=*/true,
30549 : : /*or_comma=*/true,
30550 : : /*consume_paren=*/false);
30551 : 27 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
30552 : : break;
30553 : 0 : cp_lexer_consume_token (parser->lexer);
30554 : : }
30555 : 970 : cp_lexer_consume_token (parser->lexer);
30556 : 970 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
30557 : 6 : cp_parser_required_error (parser, RT_OPEN_PAREN, false,
30558 : : UNKNOWN_LOCATION);
30559 : 964 : else if (directive)
30560 : 952 : cp_parser_omp_directive_args (parser, attribute, false);
30561 : : else
30562 : 12 : cp_parser_omp_sequence_args (parser, attribute);
30563 : 970 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
30564 : : break;
30565 : 493 : cp_lexer_consume_token (parser->lexer);
30566 : 493 : }
30567 : : while (1);
30568 : 504 : if (!parens.require_close (parser))
30569 : 3 : cp_parser_skip_to_closing_parenthesis (parser, true, false,
30570 : : /*consume_paren=*/true);
30571 : 504 : }
30572 : :
30573 : : /* Parse a standard C++11 attribute.
30574 : :
30575 : : The returned representation is a TREE_LIST which TREE_PURPOSE is
30576 : : the scoped name of the attribute, and the TREE_VALUE is its
30577 : : arguments list.
30578 : :
30579 : : Note that the scoped name of the attribute is itself a TREE_LIST
30580 : : which TREE_PURPOSE is the namespace of the attribute, and
30581 : : TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
30582 : : by cp_parser_gnu_attribute_list -- that doesn't have any namespace
30583 : : and which TREE_PURPOSE is directly the attribute name.
30584 : :
30585 : : Clients of the attribute code should use get_attribute_namespace
30586 : : and get_attribute_name to get the actual namespace and name of
30587 : : attributes, regardless of their being GNU or C++11 attributes.
30588 : :
30589 : : attribute:
30590 : : attribute-token attribute-argument-clause [opt]
30591 : :
30592 : : attribute-token:
30593 : : identifier
30594 : : attribute-scoped-token
30595 : :
30596 : : attribute-scoped-token:
30597 : : attribute-namespace :: identifier
30598 : :
30599 : : attribute-namespace:
30600 : : identifier
30601 : :
30602 : : attribute-argument-clause:
30603 : : ( balanced-token-seq )
30604 : :
30605 : : balanced-token-seq:
30606 : : balanced-token [opt]
30607 : : balanced-token-seq balanced-token
30608 : :
30609 : : balanced-token:
30610 : : ( balanced-token-seq )
30611 : : [ balanced-token-seq ]
30612 : : { balanced-token-seq }. */
30613 : :
30614 : : static tree
30615 : 13352041 : cp_parser_std_attribute (cp_parser *parser, tree attr_ns)
30616 : : {
30617 : 13352041 : tree attribute, attr_id = NULL_TREE, arguments;
30618 : 13352041 : cp_token *token;
30619 : :
30620 : 13352041 : auto cleanup = make_temp_override
30621 : 13352041 : (parser->auto_is_implicit_function_template_parm_p, false);
30622 : :
30623 : : /* First, parse name of the attribute, a.k.a attribute-token. */
30624 : :
30625 : 13352041 : token = cp_lexer_peek_token (parser->lexer);
30626 : 13352041 : if (token->type == CPP_NAME)
30627 : 13351714 : attr_id = token->u.value;
30628 : 327 : else if (token->type == CPP_KEYWORD)
30629 : 18 : attr_id = ridpointers[(int) token->keyword];
30630 : 309 : else if (token->flags & NAMED_OP)
30631 : 30 : attr_id = get_identifier (cpp_type2name (token->type, token->flags));
30632 : :
30633 : 13351762 : if (attr_id == NULL_TREE)
30634 : 279 : return NULL_TREE;
30635 : :
30636 : 13351762 : cp_lexer_consume_token (parser->lexer);
30637 : :
30638 : 13351762 : token = cp_lexer_peek_token (parser->lexer);
30639 : 13351762 : if (token->type == CPP_SCOPE)
30640 : : {
30641 : : /* We are seeing a scoped attribute token. */
30642 : :
30643 : 1373982 : cp_lexer_consume_token (parser->lexer);
30644 : 1373982 : if (attr_ns)
30645 : 6 : error_at (token->location, "attribute using prefix used together "
30646 : : "with scoped attribute token");
30647 : 1373982 : attr_ns = attr_id;
30648 : :
30649 : 1373982 : token = cp_lexer_peek_token (parser->lexer);
30650 : 1373982 : if (token->type == CPP_NAME)
30651 : 1235308 : attr_id = token->u.value;
30652 : 138674 : else if (token->type == CPP_KEYWORD)
30653 : 138662 : attr_id = ridpointers[(int) token->keyword];
30654 : 12 : else if (token->flags & NAMED_OP)
30655 : 9 : attr_id = get_identifier (cpp_type2name (token->type, token->flags));
30656 : : else
30657 : : {
30658 : 3 : error_at (token->location,
30659 : : "expected an identifier for the attribute name");
30660 : 3 : return error_mark_node;
30661 : : }
30662 : 1373979 : cp_lexer_consume_token (parser->lexer);
30663 : :
30664 : 1373979 : attr_ns = canonicalize_attr_name (attr_ns);
30665 : 1373979 : attr_id = canonicalize_attr_name (attr_id);
30666 : 1373979 : attribute = build_tree_list (build_tree_list (attr_ns, attr_id),
30667 : : NULL_TREE);
30668 : 1373979 : token = cp_lexer_peek_token (parser->lexer);
30669 : : }
30670 : 11977780 : else if (attr_ns)
30671 : : {
30672 : 137 : attr_ns = canonicalize_attr_name (attr_ns);
30673 : 137 : attr_id = canonicalize_attr_name (attr_id);
30674 : 137 : attribute = build_tree_list (build_tree_list (attr_ns, attr_id),
30675 : : NULL_TREE);
30676 : : }
30677 : : else
30678 : : {
30679 : 11977643 : attr_id = canonicalize_attr_name (attr_id);
30680 : 11977643 : attribute = build_tree_list (build_tree_list (NULL_TREE, attr_id),
30681 : : NULL_TREE);
30682 : :
30683 : : /* We used to treat C++11 noreturn attribute as equivalent to GNU's,
30684 : : but no longer: we have to be able to tell [[noreturn]] and
30685 : : __attribute__((noreturn)) apart.
30686 : : Similarly for C++14 deprecated attribute, we need to emit extra
30687 : : diagnostics for [[deprecated]] compared to [[gnu::deprecated]]. */
30688 : : /* C++17 fallthrough attribute is equivalent to GNU's. */
30689 : 11977643 : if (is_attribute_p ("fallthrough", attr_id))
30690 : 15704 : TREE_PURPOSE (TREE_PURPOSE (attribute)) = gnu_identifier;
30691 : : /* C++23 assume attribute is equivalent to GNU's. */
30692 : 11961939 : else if (is_attribute_p ("assume", attr_id))
30693 : 584 : TREE_PURPOSE (TREE_PURPOSE (attribute)) = gnu_identifier;
30694 : : /* Transactional Memory TS optimize_for_synchronized attribute is
30695 : : equivalent to GNU transaction_callable. */
30696 : 11961355 : else if (is_attribute_p ("optimize_for_synchronized", attr_id))
30697 : 6 : TREE_PURPOSE (attribute)
30698 : 3 : = get_identifier ("transaction_callable");
30699 : : /* Transactional Memory attributes are GNU attributes. */
30700 : 11961352 : else if (tm_attr_to_mask (attr_id))
30701 : 0 : TREE_PURPOSE (attribute) = attr_id;
30702 : : }
30703 : :
30704 : : /* Now parse the optional argument clause of the attribute. */
30705 : :
30706 : 13351759 : if (token->type != CPP_OPEN_PAREN)
30707 : : {
30708 : 13290310 : if ((flag_openmp || flag_openmp_simd)
30709 : 15140 : && attr_ns == omp_identifier
30710 : 13305462 : && (is_attribute_p ("directive", attr_id)
30711 : 9 : || is_attribute_p ("sequence", attr_id)
30712 : 6 : || is_attribute_p ("decl", attr_id)))
30713 : : {
30714 : 12 : error_at (token->location, "%<omp::%E%> attribute requires argument",
30715 : : attr_id);
30716 : 12 : return NULL_TREE;
30717 : : }
30718 : : return attribute;
30719 : : }
30720 : :
30721 : 46309 : {
30722 : 46309 : vec<tree, va_gc> *vec;
30723 : 46309 : int attr_flag = normal_attr;
30724 : :
30725 : : /* Maybe we don't expect to see any arguments for this attribute. */
30726 : 46309 : const attribute_spec *as
30727 : 46309 : = lookup_attribute_spec (TREE_PURPOSE (attribute));
30728 : 46309 : if (as && as->max_length == 0)
30729 : : {
30730 : 49 : error_at (token->location, "%qE attribute does not take any arguments",
30731 : : attr_id);
30732 : 49 : cp_parser_skip_to_closing_parenthesis (parser,
30733 : : /*recovering=*/true,
30734 : : /*or_comma=*/false,
30735 : : /*consume_paren=*/true);
30736 : 49 : return error_mark_node;
30737 : : }
30738 : :
30739 : 46260 : if (is_attribute_p ("assume", attr_id)
30740 : 46260 : && (attr_ns == NULL_TREE || attr_ns == gnu_identifier))
30741 : : /* The assume attribute needs special handling of the argument. */
30742 : : attr_flag = assume_attr;
30743 : 45591 : else if (attr_ns == gnu_identifier
30744 : 45591 : && attribute_takes_identifier_p (attr_id))
30745 : : /* A GNU attribute that takes an identifier in parameter. */
30746 : : attr_flag = id_attr;
30747 : 35304 : else if (attr_ns == NULL_TREE
30748 : 32316 : && cxx_dialect >= cxx26
30749 : 36667 : && (is_attribute_p ("deprecated", attr_id)
30750 : 41 : || is_attribute_p ("nodiscard", attr_id)))
30751 : : attr_flag = uneval_string_attr;
30752 : :
30753 : : /* If this is a fake attribute created to handle -Wno-attributes,
30754 : : we must skip parsing the arguments. */
30755 : 46260 : if (as == NULL || attribute_ignored_p (as))
30756 : : {
30757 : 2643 : if ((flag_openmp || flag_openmp_simd) && attr_ns == omp_identifier)
30758 : : {
30759 : 2547 : if (is_attribute_p ("directive", attr_id))
30760 : : {
30761 : 1807 : cp_parser_omp_directive_args (parser, attribute, false);
30762 : 1807 : return attribute;
30763 : : }
30764 : 740 : else if (is_attribute_p ("decl", attr_id))
30765 : : {
30766 : 248 : TREE_VALUE (TREE_PURPOSE (attribute))
30767 : 248 : = get_identifier ("directive");
30768 : 248 : cp_parser_omp_directive_args (parser, attribute, true);
30769 : 248 : return attribute;
30770 : : }
30771 : 492 : else if (is_attribute_p ("sequence", attr_id))
30772 : : {
30773 : 492 : TREE_VALUE (TREE_PURPOSE (attribute))
30774 : 492 : = get_identifier ("directive");
30775 : 492 : cp_parser_omp_sequence_args (parser, attribute);
30776 : 492 : TREE_VALUE (attribute) = nreverse (TREE_VALUE (attribute));
30777 : 492 : return attribute;
30778 : : }
30779 : : }
30780 : :
30781 : : /* For unknown attributes, just skip balanced tokens instead of
30782 : : trying to parse the arguments. Set TREE_VALUE (attribute) to
30783 : : error_mark_node to distinguish skipped arguments from attributes
30784 : : with no arguments. */
30785 : 645 : for (size_t n = cp_parser_skip_balanced_tokens (parser, 1) - 1; n; --n)
30786 : 549 : cp_lexer_consume_token (parser->lexer);
30787 : 96 : TREE_VALUE (attribute) = error_mark_node;
30788 : 96 : return attribute;
30789 : : }
30790 : :
30791 : 43617 : vec = cp_parser_parenthesized_expression_list
30792 : 43617 : (parser, attr_flag, /*cast_p=*/false,
30793 : : /*allow_expansion_p=*/true,
30794 : : /*non_constant_p=*/NULL);
30795 : 43617 : if (vec == NULL)
30796 : 27 : arguments = error_mark_node;
30797 : : else
30798 : : {
30799 : 43590 : if (vec->is_empty ())
30800 : : /* e.g. [[attr()]]. */
30801 : 15 : error_at (token->location, "parentheses must be omitted if "
30802 : : "%qE attribute argument list is empty",
30803 : : attr_id);
30804 : 43590 : arguments = build_tree_list_vec (vec);
30805 : 43590 : release_tree_vector (vec);
30806 : : }
30807 : :
30808 : 43617 : if (arguments == error_mark_node)
30809 : : attribute = error_mark_node;
30810 : : else
30811 : 43590 : TREE_VALUE (attribute) = arguments;
30812 : : }
30813 : :
30814 : : return attribute;
30815 : 13352041 : }
30816 : :
30817 : : /* Warn if the attribute ATTRIBUTE appears more than once in the
30818 : : attribute-list ATTRIBUTES. This used to be enforced for certain
30819 : : attributes, but the restriction was removed in P2156.
30820 : : LOC is the location of ATTRIBUTE. Returns true if ATTRIBUTE was not
30821 : : found in ATTRIBUTES. */
30822 : :
30823 : : static bool
30824 : 13351671 : cp_parser_check_std_attribute (location_t loc, tree attributes, tree attribute)
30825 : : {
30826 : 13351671 : static auto alist = { "noreturn", "deprecated", "nodiscard", "maybe_unused",
30827 : : "likely", "unlikely", "fallthrough",
30828 : : "no_unique_address", "carries_dependency" };
30829 : 13351671 : if (attributes)
30830 : 6627310 : for (const auto &a : alist)
30831 : 5964597 : if (is_attribute_p (a, get_attribute_name (attribute))
30832 : 39279 : && is_attribute_namespace_p ("", attribute)
30833 : 6003867 : && lookup_attribute ("", a, attributes))
30834 : : {
30835 : 45 : if (!from_macro_expansion_at (loc))
30836 : 42 : warning_at (loc, OPT_Wattributes, "attribute %qs specified "
30837 : : "multiple times", a);
30838 : 45 : return false;
30839 : : }
30840 : : return true;
30841 : : }
30842 : :
30843 : : /* Parse a list of standard C++-11 attributes.
30844 : :
30845 : : attribute-list:
30846 : : attribute [opt]
30847 : : attribute-list , attribute[opt]
30848 : : attribute ...
30849 : : attribute-list , attribute ...
30850 : : */
30851 : :
30852 : : static tree
30853 : 12689273 : cp_parser_std_attribute_list (cp_parser *parser, tree attr_ns)
30854 : : {
30855 : 12689273 : tree attributes = NULL_TREE, attribute = NULL_TREE;
30856 : 12689273 : cp_token *token = NULL;
30857 : :
30858 : 14014809 : while (true)
30859 : : {
30860 : 13352041 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
30861 : 13352041 : attribute = cp_parser_std_attribute (parser, attr_ns);
30862 : 13352041 : if (attribute == error_mark_node)
30863 : : break;
30864 : 13351962 : if (attribute != NULL_TREE)
30865 : : {
30866 : 13351671 : if (cp_parser_check_std_attribute (loc, attributes, attribute))
30867 : : {
30868 : 13351626 : TREE_CHAIN (attribute) = attributes;
30869 : 13351626 : attributes = attribute;
30870 : : }
30871 : : }
30872 : 13351962 : token = cp_lexer_peek_token (parser->lexer);
30873 : 13351962 : if (token->type == CPP_ELLIPSIS)
30874 : : {
30875 : 48 : cp_lexer_consume_token (parser->lexer);
30876 : 48 : if (attribute == NULL_TREE)
30877 : 6 : error_at (token->location,
30878 : : "expected attribute before %<...%>");
30879 : 42 : else if (TREE_VALUE (attribute) == NULL_TREE)
30880 : : {
30881 : 21 : error_at (token->location, "attribute with no arguments "
30882 : : "contains no parameter packs");
30883 : 21 : return error_mark_node;
30884 : : }
30885 : 21 : else if (TREE_VALUE (attribute) != error_mark_node)
30886 : : {
30887 : 18 : tree pack = make_pack_expansion (TREE_VALUE (attribute));
30888 : 18 : if (pack == error_mark_node)
30889 : : return error_mark_node;
30890 : 9 : TREE_VALUE (attribute) = pack;
30891 : : }
30892 : 18 : token = cp_lexer_peek_token (parser->lexer);
30893 : : }
30894 : 13351932 : if (token->type != CPP_COMMA)
30895 : : break;
30896 : 662768 : cp_lexer_consume_token (parser->lexer);
30897 : 662768 : }
30898 : 12689243 : attributes = nreverse (attributes);
30899 : 12689243 : return attributes;
30900 : : }
30901 : :
30902 : : /* Optionally parse a C++20 contract role. A NULL return means that no
30903 : : contract role was specified.
30904 : :
30905 : : contract-role:
30906 : : % default
30907 : : % identifier
30908 : :
30909 : : If the identifier does not name a known contract role, it will
30910 : : be assumed to be default. Returns the identifier for the role
30911 : : token. */
30912 : :
30913 : : static tree
30914 : 31 : cp_parser_contract_role (cp_parser *parser)
30915 : : {
30916 : 31 : gcc_assert (cp_lexer_next_token_is (parser->lexer, CPP_MOD));
30917 : 31 : cp_lexer_consume_token (parser->lexer);
30918 : :
30919 : 31 : cp_token *token = cp_lexer_peek_token (parser->lexer);
30920 : 31 : tree role_id = NULL_TREE;
30921 : 31 : if (token->type == CPP_NAME)
30922 : 12 : role_id = token->u.value;
30923 : 19 : else if (token->type == CPP_KEYWORD && token->keyword == RID_DEFAULT)
30924 : 19 : role_id = get_identifier ("default");
30925 : : else
30926 : : {
30927 : 0 : error_at (token->location, "expected contract-role");
30928 : 0 : return error_mark_node;
30929 : : }
30930 : 31 : cp_lexer_consume_token (parser->lexer);
30931 : :
30932 : : /* FIXME: Warn about invalid/unknown roles? */
30933 : 31 : return role_id;
30934 : : }
30935 : :
30936 : : /* Parse an optional contract mode.
30937 : :
30938 : : contract-mode:
30939 : : contract-semantic
30940 : : [contract-level] [contract-role]
30941 : :
30942 : : contract-semantic:
30943 : : check_never_continue
30944 : : check_maybe_continue
30945 : : check_always_continue
30946 : :
30947 : : contract-level:
30948 : : default
30949 : : audit
30950 : : axiom
30951 : :
30952 : : contract-role:
30953 : : default
30954 : : identifier
30955 : :
30956 : : This grammar is taken from P1332R0. During parsing, this sets options
30957 : : on the MODE object to determine the configuration of the contract.
30958 : :
30959 : : Returns a tree containing the identifiers used in the configuration.
30960 : : This is either an IDENTIFIER with the literal semantic or a TREE_LIST
30961 : : whose TREE_VALUE is the contract-level and whose TREE_PURPOSE is the
30962 : : contract-role, if any. NULL_TREE is returned if no information is
30963 : : given (i.e., all defaults selected). */
30964 : :
30965 : : static tree
30966 : 849 : cp_parser_contract_mode_opt (cp_parser *parser,
30967 : : bool postcondition_p)
30968 : : {
30969 : : /* The mode is empty; the level and role are default. */
30970 : 849 : if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
30971 : : return NULL_TREE;
30972 : :
30973 : : /* There is only a role; the level is default. */
30974 : 191 : if (cp_lexer_next_token_is (parser->lexer, CPP_MOD))
30975 : : {
30976 : 10 : tree role_id = cp_parser_contract_role (parser);
30977 : 10 : return build_tree_list (role_id, get_identifier ("default"));
30978 : : }
30979 : :
30980 : : /* Otherwise, match semantic or level. */
30981 : 181 : cp_token *token = cp_lexer_peek_token (parser->lexer);
30982 : 181 : contract_level level = CONTRACT_INVALID;
30983 : 181 : contract_semantic semantic = CCS_INVALID;
30984 : 181 : tree config_id;
30985 : 181 : if (token->type == CPP_NAME)
30986 : : {
30987 : 156 : config_id = token->u.value;
30988 : :
30989 : : /* Either a named level, a concrete semantic, or an identifier
30990 : : for a postcondition. */
30991 : 156 : const char *ident = IDENTIFIER_POINTER (token->u.value);
30992 : 156 : level = map_contract_level (ident);
30993 : 156 : semantic = map_contract_semantic (ident);
30994 : :
30995 : : /* The identifier is the return value for a postcondition. */
30996 : 156 : if (level == CONTRACT_INVALID && semantic == CCS_INVALID
30997 : 75 : && postcondition_p)
30998 : : return NULL_TREE;
30999 : : }
31000 : 25 : else if (token->type == CPP_KEYWORD && token->keyword == RID_DEFAULT)
31001 : : {
31002 : 25 : config_id = get_identifier ("default");
31003 : 25 : level = CONTRACT_DEFAULT;
31004 : : }
31005 : : else
31006 : : {
31007 : : /* We got some other token other than a ':'. */
31008 : 0 : error_at (token->location, "expected contract semantic or level");
31009 : 0 : return NULL_TREE;
31010 : : }
31011 : :
31012 : : /* Consume the literal semantic or level token. */
31013 : 109 : cp_lexer_consume_token (parser->lexer);
31014 : :
31015 : 109 : if (semantic == CCS_INVALID && level == CONTRACT_INVALID)
31016 : : {
31017 : 3 : error_at (token->location,
31018 : : "expected contract level: "
31019 : : "%<default%>, %<audit%>, or %<axiom%>");
31020 : 3 : return NULL_TREE;
31021 : : }
31022 : :
31023 : : /* We matched an explicit semantic. */
31024 : 106 : if (semantic != CCS_INVALID)
31025 : : {
31026 : 42 : if (cp_lexer_next_token_is (parser->lexer, CPP_MOD))
31027 : : {
31028 : 0 : error ("invalid use of contract role for explicit semantic");
31029 : 0 : cp_lexer_consume_token (parser->lexer);
31030 : 0 : cp_lexer_consume_token (parser->lexer);
31031 : : }
31032 : 42 : return config_id;
31033 : : }
31034 : :
31035 : : /* We matched a level, there may be a role; otherwise this is default. */
31036 : 64 : if (cp_lexer_next_token_is (parser->lexer, CPP_MOD))
31037 : : {
31038 : 21 : tree role_id = cp_parser_contract_role (parser);
31039 : 21 : return build_tree_list (role_id, config_id);
31040 : : }
31041 : :
31042 : 43 : return build_tree_list (NULL_TREE, config_id);
31043 : : }
31044 : :
31045 : : static tree
31046 : 2787 : find_error (tree *tp, int *, void *)
31047 : : {
31048 : 2787 : if (*tp == error_mark_node)
31049 : 13 : return *tp;
31050 : : return NULL_TREE;
31051 : : }
31052 : :
31053 : : static bool
31054 : 607 : contains_error_p (tree t)
31055 : : {
31056 : 607 : return walk_tree (&t, find_error, NULL, NULL);
31057 : : }
31058 : :
31059 : : /* Parse a standard C++20 contract attribute specifier.
31060 : :
31061 : : contract-attribute-specifier:
31062 : : [ [ assert contract-level [opt] : conditional-expression ] ]
31063 : : [ [ pre contract-level [opt] : conditional-expression ] ]
31064 : : [ [ post contract-level [opt] identifier [opt] : conditional-expression ] ]
31065 : :
31066 : : For free functions, we cannot determine the type of the postcondition
31067 : : identifier because the we haven't called grokdeclarator yet. In those
31068 : : cases we parse the postcondition as if the identifier was declared as
31069 : : 'auto <identifier>'. We then instantiate the postcondition once the
31070 : : return type is known.
31071 : :
31072 : : For member functions, contracts are in the complete-class context, so the
31073 : : parse is deferred. We also have the return type avaialable (unless it's
31074 : : deduced), so we don't need to parse the postcondition in terms of a
31075 : : placeholder. */
31076 : :
31077 : : static tree
31078 : 849 : cp_parser_contract_attribute_spec (cp_parser *parser, tree attribute)
31079 : : {
31080 : 849 : gcc_assert (contract_attribute_p (attribute));
31081 : 849 : cp_token *token = cp_lexer_consume_token (parser->lexer);
31082 : 849 : location_t loc = token->location;
31083 : :
31084 : 849 : bool assertion_p = is_attribute_p ("assert", attribute);
31085 : 849 : bool postcondition_p = is_attribute_p ("post", attribute);
31086 : :
31087 : : /* Parse the optional mode. */
31088 : 849 : tree mode = cp_parser_contract_mode_opt (parser, postcondition_p);
31089 : :
31090 : : /* Check for postcondition identifiers. */
31091 : 849 : cp_expr identifier;
31092 : 849 : if (postcondition_p && cp_lexer_next_token_is (parser->lexer, CPP_NAME))
31093 : 77 : identifier = cp_parser_identifier (parser);
31094 : 849 : if (identifier == error_mark_node)
31095 : : return error_mark_node;
31096 : :
31097 : 849 : cp_parser_require (parser, CPP_COLON, RT_COLON);
31098 : :
31099 : : /* Defer the parsing of pre/post contracts inside class definitions. */
31100 : 849 : tree contract;
31101 : 1538 : if (!assertion_p &&
31102 : 849 : current_class_type &&
31103 : 345 : TYPE_BEING_DEFINED (current_class_type))
31104 : : {
31105 : : /* Skip until we reach an unenclose ']'. If we ran into an unnested ']'
31106 : : that doesn't close the attribute, return an error and let the attribute
31107 : : handling code emit an error for missing ']]'. */
31108 : 242 : cp_token *first = cp_lexer_peek_token (parser->lexer);
31109 : 242 : cp_parser_skip_to_closing_parenthesis_1 (parser,
31110 : : /*recovering=*/false,
31111 : : CPP_CLOSE_SQUARE,
31112 : : /*consume_paren=*/false);
31113 : 242 : if (cp_lexer_peek_token (parser->lexer)->type != CPP_CLOSE_SQUARE
31114 : 242 : || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_CLOSE_SQUARE)
31115 : 0 : return error_mark_node;
31116 : 242 : cp_token *last = cp_lexer_peek_token (parser->lexer);
31117 : :
31118 : : /* Build a deferred-parse node. */
31119 : 242 : tree condition = make_node (DEFERRED_PARSE);
31120 : 242 : DEFPARSE_TOKENS (condition) = cp_token_cache_new (first, last);
31121 : 242 : DEFPARSE_INSTANTIATIONS (condition) = NULL;
31122 : :
31123 : : /* And its corresponding contract. */
31124 : 242 : contract = grok_contract (attribute, mode, identifier, condition, loc);
31125 : : }
31126 : : else
31127 : : {
31128 : : /* Enable location wrappers when parsing contracts. */
31129 : 607 : auto suppression = make_temp_override (suppress_location_wrappers, 0);
31130 : :
31131 : : /* Build a fake variable for the result identifier. */
31132 : 607 : tree result = NULL_TREE;
31133 : 607 : if (identifier)
31134 : : {
31135 : 69 : begin_scope (sk_block, NULL_TREE);
31136 : 69 : result = make_postcondition_variable (identifier);
31137 : 69 : ++processing_template_decl;
31138 : : }
31139 : :
31140 : : /* Parse the condition, ensuring that parameters or the return variable
31141 : : aren't flagged for use outside the body of a function. */
31142 : 607 : ++processing_contract_condition;
31143 : 607 : cp_expr condition = cp_parser_conditional_expression (parser);
31144 : 607 : --processing_contract_condition;
31145 : :
31146 : : /* Try to recover from errors by scanning up to the end of the
31147 : : attribute. Sometimes we get partially parsed expressions, so
31148 : : we need to search the condition for errors. */
31149 : 607 : if (contains_error_p (condition))
31150 : 13 : cp_parser_skip_up_to_closing_square_bracket (parser);
31151 : :
31152 : : /* Build the contract. */
31153 : 607 : contract = grok_contract (attribute, mode, result, condition, loc);
31154 : :
31155 : : /* Leave our temporary scope for the postcondition result. */
31156 : 607 : if (result)
31157 : : {
31158 : 69 : --processing_template_decl;
31159 : 69 : pop_bindings_and_leave_scope ();
31160 : : }
31161 : 607 : }
31162 : :
31163 : 849 : if (!flag_contracts)
31164 : : {
31165 : 3 : error_at (loc, "contracts are only available with %<-fcontracts%>");
31166 : 3 : return error_mark_node;
31167 : : }
31168 : :
31169 : 846 : return finish_contract_attribute (attribute, contract);
31170 : : }
31171 : :
31172 : : /* Parse a contract condition for a deferred contract. */
31173 : :
31174 : 242 : void cp_parser_late_contract_condition (cp_parser *parser,
31175 : : tree fn,
31176 : : tree attribute)
31177 : : {
31178 : 242 : tree contract = TREE_VALUE (TREE_VALUE (attribute));
31179 : :
31180 : : /* Make sure we've gotten something that hasn't been parsed yet or that
31181 : : we're not parsing an invalid contract. */
31182 : 242 : tree condition = CONTRACT_CONDITION (contract);
31183 : 242 : if (TREE_CODE (condition) != DEFERRED_PARSE)
31184 : : return;
31185 : :
31186 : 231 : tree identifier = NULL_TREE;
31187 : 231 : if (TREE_CODE (contract) == POSTCONDITION_STMT)
31188 : 35 : identifier = POSTCONDITION_IDENTIFIER (contract);
31189 : :
31190 : : /* Build a fake variable for the result identifier. */
31191 : 35 : tree result = NULL_TREE;
31192 : 35 : if (identifier)
31193 : : {
31194 : : /* TODO: Can we guarantee that the identifier has a location? */
31195 : 8 : location_t loc = cp_expr_location (contract);
31196 : 8 : tree type = TREE_TYPE (TREE_TYPE (fn));
31197 : 8 : if (!check_postcondition_result (fn, type, loc))
31198 : : {
31199 : 4 : invalidate_contract (contract);
31200 : 4 : return;
31201 : : }
31202 : :
31203 : 4 : begin_scope (sk_block, NULL_TREE);
31204 : 4 : result = make_postcondition_variable (identifier, type);
31205 : 4 : ++processing_template_decl;
31206 : : }
31207 : :
31208 : : /* 'this' is not allowed in preconditions of constructors or in postconditions
31209 : : of destructors. Note that the previous value of this variable is
31210 : : established by the calling function, so we need to save it here. */
31211 : 227 : tree saved_ccr = current_class_ref;
31212 : 227 : tree saved_ccp = current_class_ptr;
31213 : 454 : if ((DECL_CONSTRUCTOR_P (fn) && PRECONDITION_P (contract)) ||
31214 : 198 : (DECL_DESTRUCTOR_P (fn) && POSTCONDITION_P (contract)))
31215 : : {
31216 : 39 : current_class_ref = current_class_ptr = NULL_TREE;
31217 : 39 : parser->local_variables_forbidden_p |= THIS_FORBIDDEN;
31218 : : }
31219 : :
31220 : 227 : push_unparsed_function_queues (parser);
31221 : :
31222 : : /* Push the saved tokens onto the parser's lexer stack. */
31223 : 227 : cp_token_cache *tokens = DEFPARSE_TOKENS (condition);
31224 : 227 : cp_parser_push_lexer_for_tokens (parser, tokens);
31225 : :
31226 : : /* Parse the condition, ensuring that parameters or the return variable
31227 : : aren't flagged for use outside the body of a function. */
31228 : 227 : ++processing_contract_condition;
31229 : 227 : condition = cp_parser_conditional_expression (parser);
31230 : 227 : --processing_contract_condition;
31231 : :
31232 : : /* Revert to the main lexer. */
31233 : 227 : cp_parser_pop_lexer (parser);
31234 : :
31235 : : /* Restore the queue. */
31236 : 227 : pop_unparsed_function_queues (parser);
31237 : :
31238 : 227 : current_class_ref = saved_ccr;
31239 : 227 : current_class_ptr = saved_ccp;
31240 : :
31241 : : /* Commit to changes. */
31242 : 227 : update_late_contract (contract, result, condition);
31243 : :
31244 : : /* Leave our temporary scope for the postcondition result. */
31245 : 227 : if (result)
31246 : : {
31247 : 4 : --processing_template_decl;
31248 : 4 : pop_bindings_and_leave_scope ();
31249 : : }
31250 : : }
31251 : :
31252 : : /* Parse a standard C++-11 attribute specifier.
31253 : :
31254 : : attribute-specifier:
31255 : : [ [ attribute-using-prefix [opt] attribute-list ] ]
31256 : : contract-attribute-specifier
31257 : : alignment-specifier
31258 : :
31259 : : attribute-using-prefix:
31260 : : using attribute-namespace :
31261 : :
31262 : : alignment-specifier:
31263 : : alignas ( type-id ... [opt] )
31264 : : alignas ( alignment-expression ... [opt] ).
31265 : :
31266 : : Extensions for contracts:
31267 : :
31268 : : contract-attribute-specifier:
31269 : : [ [ assert : contract-mode [opt] : conditional-expression ] ]
31270 : : [ [ pre : contract-mode [opt] : conditional-expression ] ]
31271 : : [ [ post : contract-mode [opt] identifier [opt] :
31272 : : conditional-expression ] ]
31273 : :
31274 : : Return void_list_node if the current token doesn't start an
31275 : : attribute-specifier to differentiate from NULL_TREE returned e.g.
31276 : : for [ [ ] ]. */
31277 : :
31278 : : static tree
31279 : 1151970856 : cp_parser_std_attribute_spec (cp_parser *parser)
31280 : : {
31281 : 1151970856 : tree attributes = NULL_TREE;
31282 : 1151970856 : cp_token *token = cp_lexer_peek_token (parser->lexer);
31283 : :
31284 : 1151970856 : if (token->type == CPP_OPEN_SQUARE
31285 : 1151970856 : && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_OPEN_SQUARE)
31286 : : {
31287 : 12690122 : tree attr_ns = NULL_TREE;
31288 : 12690122 : tree attr_name = NULL_TREE;
31289 : :
31290 : 12690122 : cp_lexer_consume_token (parser->lexer);
31291 : 12690122 : cp_lexer_consume_token (parser->lexer);
31292 : :
31293 : 12690122 : token = cp_lexer_peek_token (parser->lexer);
31294 : 12690122 : if (token->type == CPP_NAME)
31295 : : {
31296 : 12689729 : attr_name = token->u.value;
31297 : 12689729 : attr_name = canonicalize_attr_name (attr_name);
31298 : : }
31299 : :
31300 : : /* Handle contract-attribute-specs specially. */
31301 : 12689729 : if (attr_name && contract_attribute_p (attr_name))
31302 : : {
31303 : 849 : tree attrs = cp_parser_contract_attribute_spec (parser, attr_name);
31304 : 849 : if (attrs != error_mark_node)
31305 : 829 : attributes = attrs;
31306 : 849 : goto finish_attrs;
31307 : : }
31308 : :
31309 : 12689273 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
31310 : : {
31311 : 116 : token = cp_lexer_peek_nth_token (parser->lexer, 2);
31312 : 116 : if (token->type == CPP_NAME)
31313 : 107 : attr_ns = token->u.value;
31314 : 9 : else if (token->type == CPP_KEYWORD)
31315 : 3 : attr_ns = ridpointers[(int) token->keyword];
31316 : 6 : else if (token->flags & NAMED_OP)
31317 : 3 : attr_ns = get_identifier (cpp_type2name (token->type,
31318 : : token->flags));
31319 : 113 : if (attr_ns
31320 : 113 : && cp_lexer_nth_token_is (parser->lexer, 3, CPP_COLON))
31321 : : {
31322 : 113 : if (cxx_dialect < cxx17)
31323 : 44 : pedwarn (input_location, OPT_Wc__17_extensions,
31324 : : "attribute using prefix only available "
31325 : : "with %<-std=c++17%> or %<-std=gnu++17%>");
31326 : :
31327 : 113 : cp_lexer_consume_token (parser->lexer);
31328 : 113 : cp_lexer_consume_token (parser->lexer);
31329 : 113 : cp_lexer_consume_token (parser->lexer);
31330 : : }
31331 : : else
31332 : : attr_ns = NULL_TREE;
31333 : : }
31334 : :
31335 : 12689273 : attributes = cp_parser_std_attribute_list (parser, attr_ns);
31336 : :
31337 : 12690122 : finish_attrs:
31338 : 12690122 : if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE)
31339 : 12690122 : || !cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
31340 : 59 : cp_parser_skip_to_end_of_statement (parser);
31341 : : else
31342 : : /* Warn about parsing c++11 attribute in non-c++11 mode, only
31343 : : when we are sure that we have actually parsed them. */
31344 : 12690063 : maybe_warn_cpp0x (CPP0X_ATTRIBUTES);
31345 : : }
31346 : : else
31347 : : {
31348 : 1139280734 : tree alignas_expr;
31349 : :
31350 : : /* Look for an alignment-specifier. */
31351 : :
31352 : 1139280734 : token = cp_lexer_peek_token (parser->lexer);
31353 : :
31354 : 1139280734 : if (token->type != CPP_KEYWORD
31355 : 1139280734 : || token->keyword != RID_ALIGNAS)
31356 : 1139092599 : return void_list_node;
31357 : :
31358 : 188208 : cp_lexer_consume_token (parser->lexer);
31359 : 188208 : maybe_warn_cpp0x (CPP0X_ATTRIBUTES);
31360 : :
31361 : 188208 : matching_parens parens;
31362 : 188208 : if (!parens.require_open (parser))
31363 : 19 : return error_mark_node;
31364 : :
31365 : 188189 : cp_parser_parse_tentatively (parser);
31366 : 188189 : alignas_expr = cp_parser_type_id (parser);
31367 : :
31368 : 188189 : if (!cp_parser_parse_definitely (parser))
31369 : : {
31370 : 71916 : alignas_expr = cp_parser_assignment_expression (parser);
31371 : 71916 : if (alignas_expr == error_mark_node)
31372 : 24 : cp_parser_skip_to_end_of_statement (parser);
31373 : 71916 : if (alignas_expr == NULL_TREE
31374 : 71916 : || alignas_expr == error_mark_node)
31375 : : return alignas_expr;
31376 : : }
31377 : :
31378 : 188165 : alignas_expr = cxx_alignas_expr (alignas_expr);
31379 : 188165 : alignas_expr = build_tree_list (NULL_TREE, alignas_expr);
31380 : :
31381 : : /* Handle alignas (pack...). */
31382 : 188165 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
31383 : : {
31384 : 18 : cp_lexer_consume_token (parser->lexer);
31385 : 18 : alignas_expr = make_pack_expansion (alignas_expr);
31386 : : }
31387 : :
31388 : : /* Something went wrong, so don't build the attribute. */
31389 : 188165 : if (alignas_expr == error_mark_node)
31390 : : return error_mark_node;
31391 : :
31392 : : /* Missing ')' means the code cannot possibly be valid; go ahead
31393 : : and commit to make sure we issue a hard error. */
31394 : 431133 : if (cp_parser_uncommitted_to_tentative_parse_p (parser)
31395 : 54809 : && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
31396 : 18 : cp_parser_commit_to_tentative_parse (parser);
31397 : :
31398 : 188162 : if (!parens.require_close (parser))
31399 : 27 : return error_mark_node;
31400 : :
31401 : : /* Build the C++-11 representation of an 'aligned'
31402 : : attribute. */
31403 : 188135 : attributes
31404 : 188135 : = build_tree_list (build_tree_list (internal_identifier,
31405 : : aligned_identifier), alignas_expr);
31406 : : }
31407 : :
31408 : : return attributes;
31409 : : }
31410 : :
31411 : : /* Parse a standard C++-11 attribute-specifier-seq.
31412 : :
31413 : : attribute-specifier-seq:
31414 : : attribute-specifier-seq [opt] attribute-specifier */
31415 : :
31416 : : static tree
31417 : 1139092629 : cp_parser_std_attribute_spec_seq (cp_parser *parser)
31418 : : {
31419 : 1139092629 : tree attr_specs = NULL_TREE;
31420 : 1139092629 : tree attr_last = NULL_TREE;
31421 : :
31422 : : /* Don't create wrapper nodes within attributes: the
31423 : : handlers don't know how to handle them. */
31424 : 1139092629 : auto_suppress_location_wrappers sentinel;
31425 : :
31426 : 1151970856 : while (true)
31427 : : {
31428 : 1151970856 : tree attr_spec = cp_parser_std_attribute_spec (parser);
31429 : 1151970856 : if (attr_spec == void_list_node)
31430 : : break;
31431 : : /* Accept [[]][[]]; for which cp_parser_std_attribute_spec
31432 : : returns NULL_TREE as there are no attributes. */
31433 : 12878330 : if (attr_spec == NULL_TREE)
31434 : 380 : continue;
31435 : 12877950 : if (attr_spec == error_mark_node)
31436 : : return error_mark_node;
31437 : :
31438 : 12877847 : if (attr_last)
31439 : 36925 : TREE_CHAIN (attr_last) = attr_spec;
31440 : : else
31441 : : attr_specs = attr_last = attr_spec;
31442 : 12877847 : attr_last = tree_last (attr_last);
31443 : : }
31444 : :
31445 : : return attr_specs;
31446 : : }
31447 : :
31448 : : /* Skip a balanced-token starting at Nth token (with 1 as the next token),
31449 : : return index of the first token after balanced-token, or N on failure. */
31450 : :
31451 : : static size_t
31452 : 3748189 : cp_parser_skip_balanced_tokens (cp_parser *parser, size_t n)
31453 : : {
31454 : 3748189 : size_t orig_n = n;
31455 : 3748189 : int nparens = 0, nbraces = 0, nsquares = 0;
31456 : 12644209 : do
31457 : 12644209 : switch (cp_lexer_peek_nth_token (parser->lexer, n++)->type)
31458 : : {
31459 : 9 : case CPP_PRAGMA_EOL:
31460 : 9 : if (!parser->lexer->in_pragma)
31461 : : break;
31462 : : /* FALLTHRU */
31463 : : case CPP_EOF:
31464 : : /* Ran out of tokens. */
31465 : : return orig_n;
31466 : 151084 : case CPP_OPEN_PAREN:
31467 : 151084 : ++nparens;
31468 : 151084 : break;
31469 : 282 : case CPP_OPEN_BRACE:
31470 : 282 : ++nbraces;
31471 : 282 : break;
31472 : 3663437 : case CPP_OPEN_SQUARE:
31473 : 3663437 : ++nsquares;
31474 : 3663437 : break;
31475 : 151078 : case CPP_CLOSE_PAREN:
31476 : 151078 : --nparens;
31477 : 151078 : break;
31478 : 273 : case CPP_CLOSE_BRACE:
31479 : 273 : --nbraces;
31480 : 273 : break;
31481 : 3663443 : case CPP_CLOSE_SQUARE:
31482 : 3663443 : --nsquares;
31483 : 3663443 : break;
31484 : : default:
31485 : : break;
31486 : : }
31487 : 12644179 : while (nparens || nbraces || nsquares);
31488 : : return n;
31489 : : }
31490 : :
31491 : : /* Skip GNU attribute tokens starting at Nth token (with 1 as the next token),
31492 : : return index of the first token after the GNU attribute tokens, or N on
31493 : : failure. */
31494 : :
31495 : : static size_t
31496 : 29226 : cp_parser_skip_gnu_attributes_opt (cp_parser *parser, size_t n)
31497 : : {
31498 : 87678 : while (true)
31499 : : {
31500 : 58452 : if (!cp_lexer_nth_token_is_keyword (parser->lexer, n, RID_ATTRIBUTE)
31501 : 29226 : || !cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_PAREN)
31502 : 87678 : || !cp_lexer_nth_token_is (parser->lexer, n + 2, CPP_OPEN_PAREN))
31503 : : break;
31504 : :
31505 : 29226 : size_t n2 = cp_parser_skip_balanced_tokens (parser, n + 2);
31506 : 29226 : if (n2 == n + 2)
31507 : : break;
31508 : 29226 : if (!cp_lexer_nth_token_is (parser->lexer, n2, CPP_CLOSE_PAREN))
31509 : : break;
31510 : 29226 : n = n2 + 1;
31511 : 29226 : }
31512 : 29226 : return n;
31513 : : }
31514 : :
31515 : : /* Skip standard C++11 attribute tokens starting at Nth token (with 1 as the
31516 : : next token), return index of the first token after the standard C++11
31517 : : attribute tokens, or N on failure. */
31518 : :
31519 : : static size_t
31520 : 317472883 : cp_parser_skip_std_attribute_spec_seq (cp_parser *parser, size_t n)
31521 : : {
31522 : 321188290 : while (true)
31523 : : {
31524 : 321188290 : if (cp_lexer_nth_token_is (parser->lexer, n, CPP_OPEN_SQUARE)
31525 : 321188290 : && cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_SQUARE))
31526 : : {
31527 : 3663263 : size_t n2 = cp_parser_skip_balanced_tokens (parser, n + 1);
31528 : 3663263 : if (n2 == n + 1)
31529 : : break;
31530 : 3663251 : if (!cp_lexer_nth_token_is (parser->lexer, n2, CPP_CLOSE_SQUARE))
31531 : : break;
31532 : 3663251 : n = n2 + 1;
31533 : : }
31534 : 317525027 : else if (cp_lexer_nth_token_is_keyword (parser->lexer, n, RID_ALIGNAS)
31535 : 317525027 : && cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_PAREN))
31536 : : {
31537 : 52162 : size_t n2 = cp_parser_skip_balanced_tokens (parser, n + 1);
31538 : 52162 : if (n2 == n + 1)
31539 : : break;
31540 : : n = n2;
31541 : : }
31542 : : else
31543 : : break;
31544 : : }
31545 : 317472883 : return n;
31546 : : }
31547 : :
31548 : : /* Skip standard C++11 or GNU attribute tokens starting at Nth token (with 1
31549 : : as the next token), return index of the first token after the attribute
31550 : : tokens, or N on failure. */
31551 : :
31552 : : static size_t
31553 : 47972 : cp_parser_skip_attributes_opt (cp_parser *parser, size_t n)
31554 : : {
31555 : 47972 : if (cp_nth_tokens_can_be_gnu_attribute_p (parser, n))
31556 : 29206 : return cp_parser_skip_gnu_attributes_opt (parser, n);
31557 : 18766 : return cp_parser_skip_std_attribute_spec_seq (parser, n);
31558 : : }
31559 : :
31560 : : /* Parse an optional `__extension__' keyword. Returns TRUE if it is
31561 : : present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
31562 : : current value of the PEDANTIC flag, regardless of whether or not
31563 : : the `__extension__' keyword is present. The caller is responsible
31564 : : for restoring the value of the PEDANTIC flag. */
31565 : :
31566 : : static bool
31567 : 473919655 : cp_parser_extension_opt (cp_parser* parser, int* saved_pedantic)
31568 : : {
31569 : : /* Save the old value of the PEDANTIC flag. */
31570 : 473919655 : *saved_pedantic = pedantic;
31571 : :
31572 : 473919655 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION))
31573 : : {
31574 : : /* Consume the `__extension__' token. */
31575 : 1031070 : cp_lexer_consume_token (parser->lexer);
31576 : : /* We're not being pedantic while the `__extension__' keyword is
31577 : : in effect. */
31578 : 1031070 : pedantic = 0;
31579 : :
31580 : 1031070 : return true;
31581 : : }
31582 : :
31583 : : return false;
31584 : : }
31585 : :
31586 : : /* Parse a label declaration.
31587 : :
31588 : : label-declaration:
31589 : : __label__ label-declarator-seq ;
31590 : :
31591 : : label-declarator-seq:
31592 : : identifier , label-declarator-seq
31593 : : identifier */
31594 : :
31595 : : static void
31596 : 93 : cp_parser_label_declaration (cp_parser* parser)
31597 : : {
31598 : : /* Look for the `__label__' keyword. */
31599 : 93 : cp_parser_require_keyword (parser, RID_LABEL, RT_LABEL);
31600 : :
31601 : 219 : while (true)
31602 : : {
31603 : 156 : tree identifier;
31604 : :
31605 : : /* Look for an identifier. */
31606 : 156 : identifier = cp_parser_identifier (parser);
31607 : : /* If we failed, stop. */
31608 : 156 : if (identifier == error_mark_node)
31609 : : break;
31610 : : /* Declare it as a label. */
31611 : 156 : finish_label_decl (identifier);
31612 : : /* If the next token is a `;', stop. */
31613 : 156 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
31614 : : break;
31615 : : /* Look for the `,' separating the label declarations. */
31616 : 63 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
31617 : 63 : }
31618 : :
31619 : : /* Look for the final `;'. */
31620 : 93 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
31621 : 93 : }
31622 : :
31623 : : // -------------------------------------------------------------------------- //
31624 : : // Concept definitions
31625 : :
31626 : : static tree
31627 : 621751 : cp_parser_concept_definition (cp_parser *parser)
31628 : : {
31629 : : /* A concept definition is an unevaluated context. */
31630 : 621751 : cp_unevaluated u;
31631 : :
31632 : 621751 : gcc_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_CONCEPT));
31633 : 621751 : cp_lexer_consume_token (parser->lexer);
31634 : :
31635 : 621751 : cp_expr id = cp_parser_identifier (parser);
31636 : 621751 : if (id == error_mark_node)
31637 : : {
31638 : 0 : cp_parser_skip_to_end_of_statement (parser);
31639 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
31640 : 0 : return NULL_TREE;
31641 : : }
31642 : :
31643 : 621751 : tree attrs = cp_parser_attributes_opt (parser);
31644 : :
31645 : 621751 : if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
31646 : : {
31647 : 9 : cp_parser_skip_to_end_of_statement (parser);
31648 : 9 : cp_parser_consume_semicolon_at_end_of_statement (parser);
31649 : 9 : return error_mark_node;
31650 : : }
31651 : :
31652 : 621742 : processing_constraint_expression_sentinel parsing_constraint;
31653 : 621742 : tree init = cp_parser_constraint_expression (parser);
31654 : 621742 : if (init == error_mark_node)
31655 : 13 : cp_parser_skip_to_end_of_statement (parser);
31656 : :
31657 : : /* Consume the trailing ';'. Diagnose the problem if it isn't there,
31658 : : but continue as if it were. */
31659 : 621742 : cp_parser_consume_semicolon_at_end_of_statement (parser);
31660 : :
31661 : 621742 : return finish_concept_definition (id, init, attrs);
31662 : 621751 : }
31663 : :
31664 : : // -------------------------------------------------------------------------- //
31665 : : // Requires Clause
31666 : :
31667 : : /* Diagnose an expression that should appear in ()'s within a requires-clause
31668 : : and suggest where to place those parentheses. */
31669 : :
31670 : : static void
31671 : 3 : cp_parser_diagnose_ungrouped_constraint_plain (location_t loc)
31672 : : {
31673 : 0 : error_at (loc, "expression must be enclosed in parentheses");
31674 : 0 : }
31675 : :
31676 : : static void
31677 : 54 : cp_parser_diagnose_ungrouped_constraint_rich (location_t loc)
31678 : : {
31679 : 54 : gcc_rich_location richloc (loc);
31680 : 54 : richloc.add_fixit_insert_before ("(");
31681 : 54 : richloc.add_fixit_insert_after (")");
31682 : 54 : error_at (&richloc, "expression must be enclosed in parentheses");
31683 : 54 : }
31684 : :
31685 : : /* Characterizes the likely kind of expression intended by a mis-written
31686 : : primary constraint. */
31687 : : enum primary_constraint_error
31688 : : {
31689 : : pce_ok,
31690 : : pce_maybe_operator,
31691 : : pce_maybe_postfix
31692 : : };
31693 : :
31694 : : /* Returns true if the token(s) following a primary-expression in a
31695 : : constraint-logical-* expression would require parentheses. */
31696 : :
31697 : : static primary_constraint_error
31698 : 3670749 : cp_parser_constraint_requires_parens (cp_parser *parser, bool lambda_p)
31699 : : {
31700 : 3670749 : cp_token *token = cp_lexer_peek_token (parser->lexer);
31701 : 3670749 : switch (token->type)
31702 : : {
31703 : : default:
31704 : : return pce_ok;
31705 : :
31706 : 69973 : case CPP_EQ:
31707 : 69973 : {
31708 : : /* An equal sign may be part of the definition of a function,
31709 : : and not an assignment operator, when parsing the expression
31710 : : for a trailing requires-clause. For example:
31711 : :
31712 : : template<typename T>
31713 : : struct S {
31714 : : S() requires C<T> = default;
31715 : : };
31716 : :
31717 : : Don't try to reparse this a binary operator. */
31718 : 69973 : if (cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_DELETE)
31719 : 69973 : || cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_DEFAULT))
31720 : : return pce_ok;
31721 : :
31722 : : gcc_fallthrough ();
31723 : : }
31724 : :
31725 : : /* Arithmetic operators. */
31726 : : case CPP_PLUS:
31727 : : case CPP_MINUS:
31728 : : case CPP_MULT:
31729 : : case CPP_DIV:
31730 : : case CPP_MOD:
31731 : : /* Bitwise operators. */
31732 : : case CPP_AND:
31733 : : case CPP_OR:
31734 : : case CPP_XOR:
31735 : : case CPP_RSHIFT:
31736 : : case CPP_LSHIFT:
31737 : : /* Relational operators. */
31738 : : case CPP_EQ_EQ:
31739 : : case CPP_NOT_EQ:
31740 : : case CPP_LESS:
31741 : : case CPP_GREATER:
31742 : : case CPP_LESS_EQ:
31743 : : case CPP_GREATER_EQ:
31744 : : case CPP_SPACESHIP:
31745 : : /* Pointer-to-member. */
31746 : : case CPP_DOT_STAR:
31747 : : case CPP_DEREF_STAR:
31748 : : /* Assignment operators. */
31749 : : case CPP_PLUS_EQ:
31750 : : case CPP_MINUS_EQ:
31751 : : case CPP_MULT_EQ:
31752 : : case CPP_DIV_EQ:
31753 : : case CPP_MOD_EQ:
31754 : : case CPP_AND_EQ:
31755 : : case CPP_OR_EQ:
31756 : : case CPP_XOR_EQ:
31757 : : case CPP_RSHIFT_EQ:
31758 : : case CPP_LSHIFT_EQ:
31759 : : /* Conditional operator */
31760 : : case CPP_QUERY:
31761 : : /* Unenclosed binary or conditional operator. */
31762 : : return pce_maybe_operator;
31763 : :
31764 : 17 : case CPP_OPEN_PAREN:
31765 : 17 : {
31766 : : /* A primary constraint that precedes the parameter-list of a
31767 : : lambda expression is followed by an open paren.
31768 : :
31769 : : []<typename T> requires C (T a, T b) { ... }
31770 : :
31771 : : Don't try to re-parse this as a postfix expression. */
31772 : 17 : if (lambda_p)
31773 : : return pce_ok;
31774 : :
31775 : 36820 : gcc_fallthrough ();
31776 : : }
31777 : 36820 : case CPP_OPEN_SQUARE:
31778 : 36820 : {
31779 : : /* A primary-constraint-expression followed by a '[[' is not a
31780 : : postfix expression. */
31781 : 36820 : if (cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_SQUARE))
31782 : : return pce_ok;
31783 : :
31784 : : gcc_fallthrough ();
31785 : : }
31786 : : case CPP_PLUS_PLUS:
31787 : : case CPP_MINUS_MINUS:
31788 : : case CPP_DOT:
31789 : : /* Unenclosed postfix operator. */
31790 : : return pce_maybe_postfix;
31791 : :
31792 : 10 : case CPP_DEREF:
31793 : : /* A primary constraint that precedes the lambda-declarator of a
31794 : : lambda expression is followed by trailing return type.
31795 : :
31796 : : []<typename T> requires C -> void {}
31797 : :
31798 : : Don't try to re-parse this as a postfix expression in
31799 : : C++23 and later. In C++20 ( needs to come in between but we
31800 : : allow it to be omitted with pedwarn. */
31801 : 10 : if (lambda_p)
31802 : : return pce_ok;
31803 : : /* Unenclosed postfix operator. */
31804 : : return pce_maybe_postfix;
31805 : : }
31806 : : }
31807 : :
31808 : : /* Returns true if the next token begins a unary expression, preceded by
31809 : : an operator or keyword. */
31810 : :
31811 : : static bool
31812 : 3670776 : cp_parser_unary_constraint_requires_parens (cp_parser *parser)
31813 : : {
31814 : 3670776 : cp_token *token = cp_lexer_peek_token (parser->lexer);
31815 : 3670776 : switch (token->type)
31816 : : {
31817 : : case CPP_NOT:
31818 : : case CPP_PLUS:
31819 : : case CPP_MINUS:
31820 : : case CPP_MULT:
31821 : : case CPP_COMPL:
31822 : : case CPP_PLUS_PLUS:
31823 : : case CPP_MINUS_MINUS:
31824 : : return true;
31825 : :
31826 : 202672 : case CPP_KEYWORD:
31827 : 202672 : {
31828 : 202672 : switch (token->keyword)
31829 : : {
31830 : : case RID_STATCAST:
31831 : : case RID_DYNCAST:
31832 : : case RID_REINTCAST:
31833 : : case RID_CONSTCAST:
31834 : : case RID_TYPEID:
31835 : : case RID_SIZEOF:
31836 : : case RID_ALIGNOF:
31837 : : case RID_NOEXCEPT:
31838 : : case RID_NEW:
31839 : : case RID_DELETE:
31840 : : case RID_THROW:
31841 : : return true;
31842 : :
31843 : : default:
31844 : : break;
31845 : : }
31846 : : }
31847 : :
31848 : : default:
31849 : : break;
31850 : : }
31851 : :
31852 : : return false;
31853 : : }
31854 : :
31855 : : /* Parse a primary expression within a constraint. */
31856 : :
31857 : : static cp_expr
31858 : 3670776 : cp_parser_constraint_primary_expression (cp_parser *parser, bool lambda_p)
31859 : : {
31860 : : /* If this looks like a unary expression, parse it as such, but diagnose
31861 : : it as ill-formed; it requires parens. */
31862 : 3670776 : if (cp_parser_unary_constraint_requires_parens (parser))
31863 : : {
31864 : 12 : cp_expr e = cp_parser_assignment_expression (parser, NULL, false, false);
31865 : 12 : cp_parser_diagnose_ungrouped_constraint_rich (e.get_location());
31866 : 12 : return e;
31867 : : }
31868 : :
31869 : 3670764 : cp_lexer_save_tokens (parser->lexer);
31870 : 3670764 : cp_id_kind idk;
31871 : 3670764 : location_t loc = input_location;
31872 : 3670764 : cp_expr expr = cp_parser_primary_expression (parser,
31873 : : /*address_p=*/false,
31874 : : /*cast_p=*/false,
31875 : : /*template_arg_p=*/false,
31876 : : &idk);
31877 : 3670764 : expr.maybe_add_location_wrapper ();
31878 : :
31879 : 3670764 : primary_constraint_error pce = pce_ok;
31880 : 3670764 : if (expr != error_mark_node)
31881 : : {
31882 : : /* The primary-expression could be part of an unenclosed non-logical
31883 : : compound expression. */
31884 : 3670749 : pce = cp_parser_constraint_requires_parens (parser, lambda_p);
31885 : : }
31886 : 3670749 : if (pce == pce_ok)
31887 : : {
31888 : 3670719 : if (idk == CP_ID_KIND_UNQUALIFIED && identifier_p (expr))
31889 : 9 : expr = unqualified_name_lookup_error (expr);
31890 : 3670719 : cp_lexer_commit_tokens (parser->lexer);
31891 : 3670719 : return finish_constraint_primary_expr (expr);
31892 : : }
31893 : :
31894 : : /* Retry the parse at a lower precedence. If that succeeds, diagnose the
31895 : : error, but return the expression as if it were valid. */
31896 : 45 : cp_lexer_rollback_tokens (parser->lexer);
31897 : 45 : cp_parser_parse_tentatively (parser);
31898 : 45 : if (pce == pce_maybe_operator)
31899 : 24 : expr = cp_parser_assignment_expression (parser, NULL, false, false);
31900 : : else
31901 : 21 : expr = cp_parser_simple_cast_expression (parser);
31902 : 45 : if (cp_parser_parse_definitely (parser))
31903 : : {
31904 : 42 : cp_parser_diagnose_ungrouped_constraint_rich (expr.get_location());
31905 : 42 : return expr;
31906 : : }
31907 : :
31908 : : /* Otherwise, something has gone very wrong, and we can't generate a more
31909 : : meaningful diagnostic or recover. */
31910 : 3 : cp_parser_diagnose_ungrouped_constraint_plain (loc);
31911 : 3 : return error_mark_node;
31912 : : }
31913 : :
31914 : : /* Parse a constraint-logical-and-expression.
31915 : :
31916 : : constraint-logical-and-expression:
31917 : : primary-expression
31918 : : constraint-logical-and-expression '&&' primary-expression */
31919 : :
31920 : : static cp_expr
31921 : 2742321 : cp_parser_constraint_logical_and_expression (cp_parser *parser, bool lambda_p)
31922 : : {
31923 : 2742321 : cp_expr lhs = cp_parser_constraint_primary_expression (parser, lambda_p);
31924 : 6413097 : while (cp_lexer_next_token_is (parser->lexer, CPP_AND_AND))
31925 : : {
31926 : 928455 : cp_token *op = cp_lexer_consume_token (parser->lexer);
31927 : 928455 : tree rhs = cp_parser_constraint_primary_expression (parser, lambda_p);
31928 : 928455 : lhs = finish_constraint_and_expr (op->location, lhs, rhs);
31929 : : }
31930 : 2742321 : return lhs;
31931 : : }
31932 : :
31933 : : /* Parse a constraint-logical-or-expression.
31934 : :
31935 : : constraint-logical-or-expression:
31936 : : constraint-logical-and-expression
31937 : : constraint-logical-or-expression '||' constraint-logical-and-expression */
31938 : :
31939 : : static cp_expr
31940 : 2551325 : cp_parser_constraint_logical_or_expression (cp_parser *parser, bool lambda_p)
31941 : : {
31942 : 2551325 : cp_expr lhs = cp_parser_constraint_logical_and_expression (parser, lambda_p);
31943 : 5293646 : while (cp_lexer_next_token_is (parser->lexer, CPP_OR_OR))
31944 : : {
31945 : 190996 : cp_token *op = cp_lexer_consume_token (parser->lexer);
31946 : 190996 : cp_expr rhs = cp_parser_constraint_logical_and_expression (parser, lambda_p);
31947 : 190996 : lhs = finish_constraint_or_expr (op->location, lhs, rhs);
31948 : : }
31949 : 2551325 : return lhs;
31950 : : }
31951 : :
31952 : : /* Parse the expression after a requires-clause. */
31953 : :
31954 : : static tree
31955 : 2551325 : cp_parser_requires_clause_expression (cp_parser *parser, bool lambda_p)
31956 : : {
31957 : 2551325 : processing_constraint_expression_sentinel parsing_constraint;
31958 : 2551325 : ++processing_template_decl;
31959 : 2551325 : cp_expr expr = cp_parser_constraint_logical_or_expression (parser, lambda_p);
31960 : 2551325 : --processing_template_decl;
31961 : 2551325 : if (check_for_bare_parameter_packs (expr))
31962 : 6 : expr = error_mark_node;
31963 : 5102650 : return expr;
31964 : 2551325 : }
31965 : :
31966 : : /* Parse a expression after a requires clause.
31967 : :
31968 : : constraint-expression:
31969 : : logical-or-expression
31970 : :
31971 : : The required logical-or-expression must be a constant expression. Note
31972 : : that we don't check that the expression is constepxr here. We defer until
31973 : : we analyze constraints and then, we only check atomic constraints. */
31974 : :
31975 : : static tree
31976 : 657612 : cp_parser_constraint_expression (cp_parser *parser)
31977 : : {
31978 : 657612 : processing_constraint_expression_sentinel parsing_constraint;
31979 : 657612 : ++processing_template_decl;
31980 : 657612 : cp_expr expr = cp_parser_binary_expression (parser, false, true,
31981 : : PREC_NOT_OPERATOR, NULL);
31982 : 657612 : --processing_template_decl;
31983 : 657612 : if (check_for_bare_parameter_packs (expr))
31984 : 0 : expr = error_mark_node;
31985 : 657612 : expr.maybe_add_location_wrapper ();
31986 : 657612 : return expr;
31987 : 657612 : }
31988 : :
31989 : : /* Optionally parse a requires clause:
31990 : :
31991 : : requires-clause:
31992 : : `requires` constraint-logical-or-expression.
31993 : : [ConceptsTS]
31994 : : `requires constraint-expression.
31995 : :
31996 : : LAMBDA_P is true when the requires-clause is parsed before the
31997 : : parameter-list of a lambda-declarator. */
31998 : :
31999 : : static tree
32000 : 24882708 : cp_parser_requires_clause_opt (cp_parser *parser, bool lambda_p)
32001 : : {
32002 : : /* A requires clause is an unevaluated context. */
32003 : 24882708 : cp_unevaluated u;
32004 : :
32005 : 24882708 : cp_token *tok = cp_lexer_peek_token (parser->lexer);
32006 : 24882708 : if (tok->keyword != RID_REQUIRES)
32007 : : {
32008 : 22331383 : if (!flag_concepts && tok->type == CPP_NAME
32009 : 18 : && tok->u.value == ridpointers[RID_REQUIRES])
32010 : : {
32011 : 4 : error_at (cp_lexer_peek_token (parser->lexer)->location,
32012 : : "%<requires%> only available with "
32013 : : "%<-std=c++20%> or %<-fconcepts%>");
32014 : : /* Parse and discard the requires-clause. */
32015 : 4 : cp_lexer_consume_token (parser->lexer);
32016 : 4 : cp_parser_constraint_expression (parser);
32017 : : }
32018 : 22331383 : return NULL_TREE;
32019 : : }
32020 : :
32021 : 2551325 : cp_token *tok2 = cp_lexer_peek_nth_token (parser->lexer, 2);
32022 : 2551325 : if (tok2->type == CPP_OPEN_BRACE)
32023 : : {
32024 : : /* An opening brace following the start of a requires-clause is
32025 : : ill-formed; the user likely forgot the second `requires' that
32026 : : would start a requires-expression. */
32027 : 1 : gcc_rich_location richloc (tok2->location);
32028 : 1 : richloc.add_fixit_insert_after (tok->location, " requires");
32029 : 1 : error_at (&richloc, "missing additional %<requires%> to start "
32030 : : "a requires-expression");
32031 : : /* Don't consume the `requires', so that it's reused as the start of a
32032 : : requires-expression. */
32033 : 1 : }
32034 : : else
32035 : 2551324 : cp_lexer_consume_token (parser->lexer);
32036 : :
32037 : 2551325 : return cp_parser_requires_clause_expression (parser, lambda_p);
32038 : 24882708 : }
32039 : :
32040 : : /*---------------------------------------------------------------------------
32041 : : Requires expressions
32042 : : ---------------------------------------------------------------------------*/
32043 : :
32044 : : /* Parse a requires expression
32045 : :
32046 : : requirement-expression:
32047 : : 'requires' requirement-parameter-list [opt] requirement-body */
32048 : :
32049 : : static tree
32050 : 630006 : cp_parser_requires_expression (cp_parser *parser)
32051 : : {
32052 : 630006 : gcc_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_REQUIRES));
32053 : 630006 : location_t loc = cp_lexer_consume_token (parser->lexer)->location;
32054 : :
32055 : : /* Avoid committing to outer tentative parse. */
32056 : 630006 : tentative_firewall firewall (parser);
32057 : :
32058 : : /* This is definitely a requires-expression. */
32059 : 630006 : cp_parser_commit_to_tentative_parse (parser);
32060 : :
32061 : 630006 : tree parms, reqs;
32062 : 630006 : {
32063 : : /* Local parameters are delared as variables within the scope
32064 : : of the expression. They are not visible past the end of
32065 : : the expression. Expressions within the requires-expression
32066 : : are unevaluated. */
32067 : 630006 : struct scope_sentinel
32068 : : {
32069 : 630006 : scope_sentinel ()
32070 : : {
32071 : 630006 : ++cp_unevaluated_operand;
32072 : 630006 : begin_scope (sk_function_parms, NULL_TREE);
32073 : 630006 : current_binding_level->requires_expression = true;
32074 : 630006 : }
32075 : :
32076 : 630006 : ~scope_sentinel ()
32077 : : {
32078 : 630006 : pop_bindings_and_leave_scope ();
32079 : 10 : --cp_unevaluated_operand;
32080 : : }
32081 : 630006 : } s;
32082 : :
32083 : : /* Parse the optional parameter list. */
32084 : 630006 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
32085 : : {
32086 : 309038 : parms = cp_parser_requirement_parameter_list (parser);
32087 : 309038 : if (parms == error_mark_node)
32088 : : return error_mark_node;
32089 : : }
32090 : : else
32091 : 320968 : parms = NULL_TREE;
32092 : :
32093 : : /* Parse the requirement body. */
32094 : 630006 : ++processing_template_decl;
32095 : 630006 : reqs = cp_parser_requirement_body (parser);
32096 : 630006 : --processing_template_decl;
32097 : 630006 : if (reqs == error_mark_node)
32098 : : return error_mark_node;
32099 : : }
32100 : :
32101 : : /* This needs to happen after pop_bindings_and_leave_scope, as it reverses
32102 : : the parm chain. */
32103 : 629996 : grokparms (parms, &parms);
32104 : 629996 : loc = make_location (loc, loc, parser->lexer);
32105 : 629996 : tree expr = finish_requires_expr (loc, parms, reqs);
32106 : 629996 : if (!processing_template_decl)
32107 : : {
32108 : : /* Perform semantic processing now to diagnose any invalid types and
32109 : : expressions. */
32110 : 105 : int saved_errorcount = errorcount;
32111 : 105 : tsubst_requires_expr (expr, NULL_TREE, tf_warning_or_error, NULL_TREE);
32112 : 105 : if (errorcount > saved_errorcount)
32113 : 5 : return error_mark_node;
32114 : : }
32115 : : return expr;
32116 : 630006 : }
32117 : :
32118 : : /* Parse a parameterized requirement.
32119 : :
32120 : : requirement-parameter-list:
32121 : : '(' parameter-declaration-clause ')' */
32122 : :
32123 : : static tree
32124 : 309038 : cp_parser_requirement_parameter_list (cp_parser *parser)
32125 : : {
32126 : 309038 : matching_parens parens;
32127 : 309038 : if (!parens.require_open (parser))
32128 : 0 : return error_mark_node;
32129 : :
32130 : 309038 : tree parms = (cp_parser_parameter_declaration_clause
32131 : 309038 : (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
32132 : : /*lambda_p=*/false));
32133 : :
32134 : 309038 : if (!parens.require_close (parser))
32135 : 0 : return error_mark_node;
32136 : :
32137 : : /* Modify the declared parameters by removing their context
32138 : : so they don't refer to the enclosing scope and explicitly
32139 : : indicating that they are constraint variables. */
32140 : 777409 : for (tree parm = parms; parm; parm = TREE_CHAIN (parm))
32141 : : {
32142 : 777406 : if (parm == void_list_node || parm == explicit_void_list_node)
32143 : : break;
32144 : 468371 : tree decl = TREE_VALUE (parm);
32145 : 468371 : if (decl != error_mark_node)
32146 : : {
32147 : 468365 : DECL_CONTEXT (decl) = NULL_TREE;
32148 : 468365 : CONSTRAINT_VAR_P (decl) = true;
32149 : : }
32150 : : }
32151 : :
32152 : : return parms;
32153 : : }
32154 : :
32155 : : /* Parse the body of a requirement.
32156 : :
32157 : : requirement-body:
32158 : : '{' requirement-list '}' */
32159 : : static tree
32160 : 630006 : cp_parser_requirement_body (cp_parser *parser)
32161 : : {
32162 : 630006 : matching_braces braces;
32163 : 630006 : if (!braces.require_open (parser))
32164 : 0 : return error_mark_node;
32165 : :
32166 : 630006 : tree reqs = cp_parser_requirement_seq (parser);
32167 : :
32168 : 630006 : if (!braces.require_close (parser))
32169 : 3 : return error_mark_node;
32170 : :
32171 : : return reqs;
32172 : : }
32173 : :
32174 : : /* Parse a sequence of requirements.
32175 : :
32176 : : requirement-seq:
32177 : : requirement
32178 : : requirement-seq requirement */
32179 : :
32180 : : static tree
32181 : 630006 : cp_parser_requirement_seq (cp_parser *parser)
32182 : : {
32183 : 630006 : tree result = NULL_TREE;
32184 : 873467 : do
32185 : : {
32186 : 873467 : tree req = cp_parser_requirement (parser);
32187 : 873467 : if (req != error_mark_node)
32188 : 873454 : result = tree_cons (NULL_TREE, req, result);
32189 : : }
32190 : 873467 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE)
32191 : 1503473 : && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF));
32192 : :
32193 : : /* If there are no valid requirements, this is not a valid expression. */
32194 : 630006 : if (!result)
32195 : 7 : return error_mark_node;
32196 : :
32197 : : /* Reverse the order of requirements so they are analyzed in order. */
32198 : 629999 : return nreverse (result);
32199 : : }
32200 : :
32201 : : /* Parse a syntactic requirement or type requirement.
32202 : :
32203 : : requirement:
32204 : : simple-requirement
32205 : : compound-requirement
32206 : : type-requirement
32207 : : nested-requirement */
32208 : :
32209 : : static tree
32210 : 873467 : cp_parser_requirement (cp_parser *parser)
32211 : : {
32212 : 873467 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
32213 : 341970 : return cp_parser_compound_requirement (parser);
32214 : 531497 : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
32215 : : {
32216 : : /* It's probably a type-requirement. */
32217 : 158373 : cp_parser_parse_tentatively (parser);
32218 : 158373 : tree req = cp_parser_type_requirement (parser);
32219 : 158373 : if (cp_parser_parse_definitely (parser))
32220 : : return req;
32221 : : /* No, maybe it's something like typename T::type(); */
32222 : 3 : cp_parser_parse_tentatively (parser);
32223 : 3 : req = cp_parser_simple_requirement (parser);
32224 : 3 : if (cp_parser_parse_definitely (parser))
32225 : : return req;
32226 : : /* Non-tentative for the error. */
32227 : 0 : return cp_parser_type_requirement (parser);
32228 : : }
32229 : 373124 : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_REQUIRES))
32230 : 35866 : return cp_parser_nested_requirement (parser);
32231 : : else
32232 : 337258 : return cp_parser_simple_requirement (parser);
32233 : : }
32234 : :
32235 : : /* Parse a simple requirement.
32236 : :
32237 : : simple-requirement:
32238 : : expression ';' */
32239 : :
32240 : : static tree
32241 : 337261 : cp_parser_simple_requirement (cp_parser *parser)
32242 : : {
32243 : 337261 : location_t start = cp_lexer_peek_token (parser->lexer)->location;
32244 : 337261 : cp_expr expr = cp_parser_expression (parser, NULL, false, false);
32245 : 337261 : if (expr == error_mark_node)
32246 : 3 : cp_parser_skip_to_end_of_statement (parser);
32247 : :
32248 : 337261 : cp_parser_consume_semicolon_at_end_of_statement (parser);
32249 : :
32250 : 337261 : if (!expr || expr == error_mark_node)
32251 : 3 : return error_mark_node;
32252 : :
32253 : : /* Sometimes we don't get locations, so use the cached token location
32254 : : as a reasonable approximation. */
32255 : 337258 : if (expr.get_location() == UNKNOWN_LOCATION)
32256 : 0 : expr.set_location (start);
32257 : :
32258 : 337258 : for (tree t = expr; ; )
32259 : : {
32260 : 337418 : if (TREE_CODE (t) == TRUTH_ANDIF_EXPR
32261 : 337338 : || TREE_CODE (t) == TRUTH_ORIF_EXPR)
32262 : : {
32263 : 80 : t = TREE_OPERAND (t, 0);
32264 : 80 : continue;
32265 : : }
32266 : 337258 : if (concept_check_p (t))
32267 : : {
32268 : 6 : gcc_rich_location richloc (get_start (start));
32269 : 6 : richloc.add_fixit_insert_before (start, "requires ");
32270 : 6 : warning_at (&richloc, OPT_Wmissing_requires, "testing "
32271 : : "if a concept-id is a valid expression; add "
32272 : : "%<requires%> to check satisfaction");
32273 : 6 : }
32274 : 337258 : break;
32275 : 80 : }
32276 : :
32277 : 337258 : return finish_simple_requirement (expr.get_location (), expr);
32278 : : }
32279 : :
32280 : : /* Parse a type requirement
32281 : :
32282 : : type-requirement
32283 : : nested-name-specifier [opt] required-type-name ';'
32284 : :
32285 : : required-type-name:
32286 : : type-name
32287 : : 'template' [opt] simple-template-id */
32288 : :
32289 : : static tree
32290 : 158373 : cp_parser_type_requirement (cp_parser *parser)
32291 : : {
32292 : 158373 : cp_token *start_tok = cp_lexer_consume_token (parser->lexer);
32293 : 158373 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
32294 : :
32295 : : // Save the scope before parsing name specifiers.
32296 : 158373 : tree saved_scope = parser->scope;
32297 : 158373 : tree saved_object_scope = parser->object_scope;
32298 : 158373 : tree saved_qualifying_scope = parser->qualifying_scope;
32299 : 158373 : cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
32300 : 158373 : cp_parser_nested_name_specifier_opt (parser,
32301 : : /*typename_keyword_p=*/true,
32302 : : /*check_dependency_p=*/true,
32303 : : /*type_p=*/true,
32304 : : /*is_declaration=*/false);
32305 : :
32306 : 158373 : tree type;
32307 : 158373 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
32308 : : {
32309 : 11 : cp_lexer_consume_token (parser->lexer);
32310 : 11 : type = cp_parser_template_id (parser,
32311 : : /*template_keyword_p=*/true,
32312 : : /*check_dependency_p=*/true,
32313 : : /*tag_type=*/none_type,
32314 : : /*is_declaration=*/false);
32315 : 11 : type = make_typename_type (parser->scope, type, typename_type,
32316 : : /*complain=*/tf_error);
32317 : : }
32318 : : else
32319 : 158362 : type = cp_parser_type_name (parser, /*typename_keyword_p=*/true);
32320 : :
32321 : 158373 : if (TREE_CODE (type) == TYPE_DECL)
32322 : 158362 : type = TREE_TYPE (type);
32323 : :
32324 : 158373 : parser->scope = saved_scope;
32325 : 158373 : parser->object_scope = saved_object_scope;
32326 : 158373 : parser->qualifying_scope = saved_qualifying_scope;
32327 : :
32328 : 158373 : if (type == error_mark_node)
32329 : 0 : cp_parser_skip_to_end_of_statement (parser);
32330 : :
32331 : 158373 : cp_parser_consume_semicolon_at_end_of_statement (parser);
32332 : :
32333 : 158373 : if (type == error_mark_node)
32334 : : return error_mark_node;
32335 : :
32336 : 158373 : loc = make_location (loc, start_tok->location, parser->lexer);
32337 : 158373 : return finish_type_requirement (loc, type);
32338 : : }
32339 : :
32340 : : /* Parse a compound requirement
32341 : :
32342 : : compound-requirement:
32343 : : '{' expression '}' 'noexcept' [opt] trailing-return-type [opt] ';' */
32344 : :
32345 : : static tree
32346 : 341970 : cp_parser_compound_requirement (cp_parser *parser)
32347 : : {
32348 : : /* Parse an expression enclosed in '{ }'s. */
32349 : 341970 : matching_braces braces;
32350 : 341970 : if (!braces.require_open (parser))
32351 : 0 : return error_mark_node;
32352 : :
32353 : 341970 : cp_token *expr_token = cp_lexer_peek_token (parser->lexer);
32354 : :
32355 : 341970 : tree expr = cp_parser_expression (parser, NULL, false, false);
32356 : 341970 : if (expr == error_mark_node)
32357 : 3 : cp_parser_skip_to_closing_brace (parser);
32358 : :
32359 : 341970 : if (!braces.require_close (parser))
32360 : : {
32361 : 0 : cp_parser_skip_to_end_of_statement (parser);
32362 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
32363 : 0 : return error_mark_node;
32364 : : }
32365 : :
32366 : : /* If the expression was invalid, skip the remainder of the requirement. */
32367 : 341970 : if (!expr || expr == error_mark_node)
32368 : : {
32369 : 3 : cp_parser_skip_to_end_of_statement (parser);
32370 : 3 : cp_parser_consume_semicolon_at_end_of_statement (parser);
32371 : 3 : return error_mark_node;
32372 : : }
32373 : :
32374 : : /* Parse the optional noexcept. */
32375 : 341967 : bool noexcept_p = false;
32376 : 341967 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_NOEXCEPT))
32377 : : {
32378 : 8582 : cp_lexer_consume_token (parser->lexer);
32379 : 8582 : noexcept_p = true;
32380 : : }
32381 : :
32382 : : /* Parse the optional trailing return type. */
32383 : 341967 : tree type = NULL_TREE;
32384 : 341967 : if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
32385 : : {
32386 : 333365 : cp_lexer_consume_token (parser->lexer);
32387 : 333365 : cp_token *tok = cp_lexer_peek_token (parser->lexer);
32388 : :
32389 : 333365 : bool saved_result_type_constraint_p = parser->in_result_type_constraint_p;
32390 : 333365 : parser->in_result_type_constraint_p = true;
32391 : : /* C++20 allows either a type-id or a type-constraint. Parsing
32392 : : a type-id will subsume the parsing for a type-constraint but
32393 : : allow for more syntactic forms (e.g., const C<T>*). */
32394 : 333365 : type = cp_parser_trailing_type_id (parser);
32395 : 333365 : parser->in_result_type_constraint_p = saved_result_type_constraint_p;
32396 : 333365 : if (type == error_mark_node)
32397 : : return error_mark_node;
32398 : :
32399 : 333365 : location_t type_loc = make_location (tok->location, tok->location,
32400 : : parser->lexer);
32401 : :
32402 : : /* Check that we haven't written something like 'const C<T>*'. */
32403 : 333365 : if (type_uses_auto (type))
32404 : : {
32405 : 333350 : if (!is_auto (type))
32406 : : {
32407 : 6 : error_at (type_loc,
32408 : : "result type is not a plain type-constraint");
32409 : 6 : cp_parser_consume_semicolon_at_end_of_statement (parser);
32410 : 6 : return error_mark_node;
32411 : : }
32412 : : }
32413 : : else
32414 : : /* P1452R2 removed the trailing-return-type option. */
32415 : 15 : error_at (type_loc,
32416 : : "return-type-requirement is not a type-constraint");
32417 : : }
32418 : :
32419 : 341961 : location_t loc = make_location (expr_token->location,
32420 : : braces.open_location (),
32421 : : parser->lexer);
32422 : :
32423 : 341961 : cp_parser_consume_semicolon_at_end_of_statement (parser);
32424 : :
32425 : 341961 : if (expr == error_mark_node || type == error_mark_node)
32426 : : return error_mark_node;
32427 : :
32428 : 341961 : return finish_compound_requirement (loc, expr, type, noexcept_p);
32429 : : }
32430 : :
32431 : : /* Parse a nested requirement. This is the same as a requires clause.
32432 : :
32433 : : nested-requirement:
32434 : : requires-clause */
32435 : :
32436 : : static tree
32437 : 35866 : cp_parser_nested_requirement (cp_parser *parser)
32438 : : {
32439 : 35866 : gcc_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_REQUIRES));
32440 : 35866 : cp_token *tok = cp_lexer_consume_token (parser->lexer);
32441 : 35866 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
32442 : 35866 : tree req = cp_parser_constraint_expression (parser);
32443 : 35866 : if (req == error_mark_node)
32444 : 1 : cp_parser_skip_to_end_of_statement (parser);
32445 : 35866 : loc = make_location (loc, tok->location, parser->lexer);
32446 : 35866 : cp_parser_consume_semicolon_at_end_of_statement (parser);
32447 : 35866 : if (req == error_mark_node)
32448 : : return error_mark_node;
32449 : 35865 : return finish_nested_requirement (loc, req);
32450 : : }
32451 : :
32452 : : /* Support Functions */
32453 : :
32454 : : /* Return the appropriate prefer_type argument for lookup_name based on
32455 : : tag_type. */
32456 : :
32457 : : static inline LOOK_want
32458 : 3806432810 : prefer_type_arg (tag_types tag_type)
32459 : : {
32460 : 3482554127 : switch (tag_type)
32461 : : {
32462 : : case none_type: return LOOK_want::NORMAL; // No preference.
32463 : 135148475 : case scope_type: return LOOK_want::TYPE_NAMESPACE; // Type or namespace.
32464 : 51311412 : default: return LOOK_want::TYPE; // Type only.
32465 : : }
32466 : : }
32467 : :
32468 : : /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
32469 : : NAME should have one of the representations used for an
32470 : : id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
32471 : : is returned. If PARSER->SCOPE is a dependent type, then a
32472 : : SCOPE_REF is returned.
32473 : :
32474 : : If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
32475 : : returned; the name was already resolved when the TEMPLATE_ID_EXPR
32476 : : was formed. Abstractly, such entities should not be passed to this
32477 : : function, because they do not need to be looked up, but it is
32478 : : simpler to check for this special case here, rather than at the
32479 : : call-sites.
32480 : :
32481 : : In cases not explicitly covered above, this function returns a
32482 : : DECL, OVERLOAD, or baselink representing the result of the lookup.
32483 : : If there was no entity with the indicated NAME, the ERROR_MARK_NODE
32484 : : is returned.
32485 : :
32486 : : If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
32487 : : (e.g., "struct") that was used. In that case bindings that do not
32488 : : refer to types are ignored.
32489 : :
32490 : : If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
32491 : : ignored. If IS_TEMPLATE IS 2, the 'template' keyword was specified.
32492 : :
32493 : : If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
32494 : : are ignored.
32495 : :
32496 : : If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
32497 : : types.
32498 : :
32499 : : If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
32500 : : TREE_LIST of candidates if name-lookup results in an ambiguity, and
32501 : : NULL_TREE otherwise. */
32502 : :
32503 : : static cp_expr
32504 : 4009950376 : cp_parser_lookup_name (cp_parser *parser, tree name,
32505 : : enum tag_types tag_type,
32506 : : int is_template,
32507 : : bool is_namespace,
32508 : : bool check_dependency,
32509 : : tree *ambiguous_decls,
32510 : : location_t name_location)
32511 : : {
32512 : 4009950376 : tree decl;
32513 : 4009950376 : tree object_type = parser->context->object_type;
32514 : :
32515 : : /* Assume that the lookup will be unambiguous. */
32516 : 4009950376 : if (ambiguous_decls)
32517 : 2083347551 : *ambiguous_decls = NULL_TREE;
32518 : :
32519 : : /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
32520 : : no longer valid. Note that if we are parsing tentatively, and
32521 : : the parse fails, OBJECT_TYPE will be automatically restored. */
32522 : 4009950376 : parser->context->object_type = NULL_TREE;
32523 : :
32524 : 4009950376 : if (name == error_mark_node)
32525 : 2 : return error_mark_node;
32526 : :
32527 : : /* A template-id has already been resolved; there is no lookup to
32528 : : do. */
32529 : 4009950374 : if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
32530 : 593236 : return name;
32531 : 4009357138 : if (BASELINK_P (name))
32532 : : {
32533 : 73240 : gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name))
32534 : : == TEMPLATE_ID_EXPR);
32535 : 73240 : return name;
32536 : : }
32537 : :
32538 : : /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
32539 : : it should already have been checked to make sure that the name
32540 : : used matches the type being destroyed. */
32541 : 4009283898 : if (TREE_CODE (name) == BIT_NOT_EXPR)
32542 : : {
32543 : 32401 : tree type;
32544 : :
32545 : : /* Figure out to which type this destructor applies. */
32546 : 32401 : if (parser->scope)
32547 : : type = parser->scope;
32548 : 11 : else if (object_type)
32549 : : type = object_type;
32550 : : else
32551 : 11 : type = current_class_type;
32552 : : /* If that's not a class type, there is no destructor. */
32553 : 32401 : if (!type || !CLASS_TYPE_P (type))
32554 : 25 : return error_mark_node;
32555 : :
32556 : : /* In a non-static member function, check implicit this->. */
32557 : 32376 : if (current_class_ref)
32558 : 15 : return lookup_destructor (current_class_ref, parser->scope, name,
32559 : 15 : tf_warning_or_error);
32560 : :
32561 : 32361 : if (CLASSTYPE_LAZY_DESTRUCTOR (type))
32562 : 6 : lazily_declare_fn (sfk_destructor, type);
32563 : :
32564 : 32361 : if (tree dtor = CLASSTYPE_DESTRUCTOR (type))
32565 : 32356 : return dtor;
32566 : :
32567 : 5 : return error_mark_node;
32568 : : }
32569 : :
32570 : : /* By this point, the NAME should be an ordinary identifier. If
32571 : : the id-expression was a qualified name, the qualifying scope is
32572 : : stored in PARSER->SCOPE at this point. */
32573 : 4009251497 : gcc_assert (identifier_p (name));
32574 : :
32575 : : /* Perform the lookup. */
32576 : 4009251497 : if (parser->scope)
32577 : : {
32578 : 436450144 : bool dependent_p;
32579 : :
32580 : 436450144 : if (parser->scope == error_mark_node)
32581 : 148 : return error_mark_node;
32582 : :
32583 : : /* If the SCOPE is dependent, the lookup must be deferred until
32584 : : the template is instantiated -- unless we are explicitly
32585 : : looking up names in uninstantiated templates. Even then, we
32586 : : cannot look up the name if the scope is not a class type; it
32587 : : might, for example, be a template type parameter. */
32588 : 872899992 : dependent_p = (TYPE_P (parser->scope)
32589 : 436449996 : && dependent_scope_p (parser->scope));
32590 : 13068371 : if ((check_dependency || !CLASS_TYPE_P (parser->scope))
32591 : 447470815 : && dependent_p)
32592 : : /* Defer lookup. */
32593 : 112571313 : decl = error_mark_node;
32594 : : else
32595 : : {
32596 : 323878683 : tree pushed_scope = NULL_TREE;
32597 : :
32598 : : /* If PARSER->SCOPE is a dependent type, then it must be a
32599 : : class type, and we must not be checking dependencies;
32600 : : otherwise, we would have processed this lookup above. So
32601 : : that PARSER->SCOPE is not considered a dependent base by
32602 : : lookup_member, we must enter the scope here. */
32603 : 323878683 : if (dependent_p)
32604 : 1683288 : pushed_scope = push_scope (parser->scope);
32605 : :
32606 : : /* If the PARSER->SCOPE is a template specialization, it
32607 : : may be instantiated during name lookup. In that case,
32608 : : errors may be issued. Even if we rollback the current
32609 : : tentative parse, those errors are valid. */
32610 : 342471654 : decl = lookup_qualified_name (parser->scope, name,
32611 : : prefer_type_arg (tag_type),
32612 : : /*complain=*/true);
32613 : :
32614 : : /* 3.4.3.1: In a lookup in which the constructor is an acceptable
32615 : : lookup result and the nested-name-specifier nominates a class C:
32616 : : * if the name specified after the nested-name-specifier, when
32617 : : looked up in C, is the injected-class-name of C (Clause 9), or
32618 : : * if the name specified after the nested-name-specifier is the
32619 : : same as the identifier or the simple-template-id's template-
32620 : : name in the last component of the nested-name-specifier,
32621 : : the name is instead considered to name the constructor of
32622 : : class C. [ Note: for example, the constructor is not an
32623 : : acceptable lookup result in an elaborated-type-specifier so
32624 : : the constructor would not be used in place of the
32625 : : injected-class-name. --end note ] Such a constructor name
32626 : : shall be used only in the declarator-id of a declaration that
32627 : : names a constructor or in a using-declaration. */
32628 : 323878683 : if (tag_type == none_type
32629 : 305285712 : && DECL_SELF_REFERENCE_P (decl)
32630 : 324026662 : && same_type_p (DECL_CONTEXT (decl), parser->scope))
32631 : 147964 : decl = lookup_qualified_name (parser->scope, ctor_identifier,
32632 : : prefer_type_arg (tag_type),
32633 : : /*complain=*/true);
32634 : :
32635 : 323878683 : if (pushed_scope)
32636 : 1683288 : pop_scope (pushed_scope);
32637 : : }
32638 : :
32639 : : /* If the scope is a dependent type and either we deferred lookup or
32640 : : we did lookup but didn't find the name, rememeber the name. */
32641 : 112578754 : if (decl == error_mark_node && TYPE_P (parser->scope)
32642 : 549026863 : && dependentish_scope_p (parser->scope))
32643 : : {
32644 : 112575871 : if (tag_type)
32645 : : {
32646 : 341205 : tree type;
32647 : :
32648 : : /* The resolution to Core Issue 180 says that `struct
32649 : : A::B' should be considered a type-name, even if `A'
32650 : : is dependent. */
32651 : 341205 : type = make_typename_type (parser->scope, name, tag_type,
32652 : : /*complain=*/tf_error);
32653 : 341205 : if (type != error_mark_node)
32654 : 341199 : decl = TYPE_NAME (type);
32655 : : }
32656 : 112234666 : else if (is_template
32657 : 112234666 : && (cp_parser_next_token_ends_template_argument_p (parser)
32658 : 2785578 : || cp_lexer_next_token_is (parser->lexer,
32659 : : CPP_CLOSE_PAREN)))
32660 : 44341 : decl = make_unbound_class_template (parser->scope,
32661 : : name, NULL_TREE,
32662 : : /*complain=*/tf_error);
32663 : : else
32664 : 112190325 : decl = build_qualified_name (/*type=*/NULL_TREE,
32665 : : parser->scope, name,
32666 : : is_template);
32667 : : }
32668 : 436449996 : parser->qualifying_scope = parser->scope;
32669 : 436449996 : parser->object_scope = NULL_TREE;
32670 : : }
32671 : 3572801353 : else if (object_type)
32672 : : {
32673 : 1955487 : bool dep = dependent_scope_p (object_type);
32674 : :
32675 : : /* Look up the name in the scope of the OBJECT_TYPE, unless the
32676 : : OBJECT_TYPE is not a class. */
32677 : 1955487 : if (!dep && CLASS_TYPE_P (object_type))
32678 : : /* If the OBJECT_TYPE is a template specialization, it may
32679 : : be instantiated during name lookup. In that case, errors
32680 : : may be issued. Even if we rollback the current tentative
32681 : : parse, those errors are valid. */
32682 : 768089 : decl = lookup_member (object_type,
32683 : : name,
32684 : : /*protect=*/0,
32685 : : /*prefer_type=*/tag_type != none_type,
32686 : : tf_warning_or_error);
32687 : : else
32688 : : decl = NULL_TREE;
32689 : :
32690 : : /* If we didn't find a member and have dependent bases, the member lookup
32691 : : is now dependent. */
32692 : 1955487 : if (!dep && !decl && any_dependent_bases_p (object_type))
32693 : : dep = true;
32694 : :
32695 : 1955487 : if (dep && is_template == 2)
32696 : : /* The template keyword specifies a dependent template. */;
32697 : 1946123 : else if (!decl)
32698 : : /* Look it up in the enclosing context. DR 141: When looking for a
32699 : : template-name after -> or ., only consider class templates. */
32700 : 1281173 : decl = lookup_name (name, is_namespace ? LOOK_want::NAMESPACE
32701 : : /* DR 141: When looking in the
32702 : : current enclosing context for a
32703 : : template-name after -> or ., only
32704 : : consider class templates. */
32705 : 1281108 : : is_template ? LOOK_want::TYPE
32706 : 1281173 : : prefer_type_arg (tag_type));
32707 : :
32708 : : /* If we did unqualified lookup of a dependent member-qualified name and
32709 : : found something, do we want to use it? P1787 clarified that we need
32710 : : to look in the object scope first even if it's dependent, but for now
32711 : : let's still use it in some cases.
32712 : : FIXME remember unqualified lookup result to use if member lookup fails
32713 : : at instantiation time. */
32714 : 1955487 : if (decl && dep && is_template)
32715 : : {
32716 : 86618 : saved_token_sentinel toks (parser->lexer, STS_ROLLBACK);
32717 : : /* Only use the unqualified class template lookup if we're actually
32718 : : looking at a template arg list. */
32719 : 86618 : if (!cp_parser_skip_entire_template_parameter_list (parser))
32720 : 9 : decl = NULL_TREE;
32721 : 86618 : }
32722 : :
32723 : : /* If we know we're looking for a type (e.g. A in p->A::x),
32724 : : mock up a typename. */
32725 : 1955487 : if (!decl && dep && tag_type != none_type)
32726 : : {
32727 : 18 : tree type = build_typename_type (object_type, name, name,
32728 : : typename_type);
32729 : 18 : decl = TYPE_NAME (type);
32730 : : }
32731 : :
32732 : 1955487 : parser->object_scope = object_type;
32733 : 1955487 : parser->qualifying_scope = NULL_TREE;
32734 : : }
32735 : : else
32736 : : {
32737 : 3570845866 : decl = lookup_name (name, is_namespace ? LOOK_want::NAMESPACE
32738 : 3570845866 : : prefer_type_arg (tag_type));
32739 : 3570845866 : parser->qualifying_scope = NULL_TREE;
32740 : 3570845866 : parser->object_scope = NULL_TREE;
32741 : : }
32742 : :
32743 : : /* If the lookup failed, let our caller know. */
32744 : 4009251349 : if (!decl || decl == error_mark_node)
32745 : 18744655 : return error_mark_node;
32746 : :
32747 : : /* If we have resolved the name of a member declaration, check to
32748 : : see if the declaration is accessible. When the name resolves to
32749 : : set of overloaded functions, accessibility is checked when
32750 : : overload resolution is done. If we have a TREE_LIST, then the lookup
32751 : : is either ambiguous or it found multiple injected-class-names, the
32752 : : accessibility of which is trivially satisfied.
32753 : :
32754 : : During an explicit instantiation, access is not checked at all,
32755 : : as per [temp.explicit]. */
32756 : 3990506694 : if (DECL_P (decl))
32757 : 3585726025 : check_accessibility_of_qualified_id (decl, object_type, parser->scope,
32758 : : tf_warning_or_error);
32759 : :
32760 : : /* Pull out the template from an injected-class-name (or multiple). */
32761 : 3990506694 : if (is_template)
32762 : 279480574 : decl = maybe_get_template_decl_from_type_decl (decl);
32763 : :
32764 : : /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
32765 : 3990506694 : if (TREE_CODE (decl) == TREE_LIST)
32766 : : {
32767 : 19419 : if (ambiguous_decls)
32768 : 392 : *ambiguous_decls = decl;
32769 : : /* The error message we have to print is too complicated for
32770 : : cp_parser_error, so we incorporate its actions directly. */
32771 : 19242 : if (!cp_parser_simulate_error (parser))
32772 : : {
32773 : 177 : auto_diagnostic_group d;
32774 : 177 : error_at (name_location, "reference to %qD is ambiguous",
32775 : : name);
32776 : 177 : print_candidates (decl);
32777 : 177 : }
32778 : 19419 : return error_mark_node;
32779 : : }
32780 : :
32781 : 3990487275 : gcc_assert (DECL_P (decl)
32782 : : || TREE_CODE (decl) == OVERLOAD
32783 : : || TREE_CODE (decl) == SCOPE_REF
32784 : : || TREE_CODE (decl) == UNBOUND_CLASS_TEMPLATE
32785 : : || BASELINK_P (decl));
32786 : :
32787 : 3990487275 : maybe_record_typedef_use (decl);
32788 : :
32789 : 3990487275 : return cp_expr (decl, name_location);
32790 : : }
32791 : :
32792 : : /* Like cp_parser_lookup_name, but for use in the typical case where
32793 : : CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
32794 : : IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
32795 : :
32796 : : static tree
32797 : 805604609 : cp_parser_lookup_name_simple (cp_parser* parser, tree name, location_t location)
32798 : : {
32799 : 805604609 : return cp_parser_lookup_name (parser, name,
32800 : : none_type,
32801 : : /*is_template=*/false,
32802 : : /*is_namespace=*/false,
32803 : : /*check_dependency=*/true,
32804 : : /*ambiguous_decls=*/NULL,
32805 : 805604609 : location);
32806 : : }
32807 : :
32808 : : /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
32809 : : the current context, return the TYPE_DECL. If TAG_NAME_P is
32810 : : true, the DECL indicates the class being defined in a class-head,
32811 : : or declared in an elaborated-type-specifier.
32812 : :
32813 : : Otherwise, return DECL. */
32814 : :
32815 : : static tree
32816 : 1903460019 : cp_parser_maybe_treat_template_as_class (tree decl, bool tag_name_p)
32817 : : {
32818 : : /* If the TEMPLATE_DECL is being declared as part of a class-head,
32819 : : the translation from TEMPLATE_DECL to TYPE_DECL occurs:
32820 : :
32821 : : struct A {
32822 : : template <typename T> struct B;
32823 : : };
32824 : :
32825 : : template <typename T> struct A::B {};
32826 : :
32827 : : Similarly, in an elaborated-type-specifier:
32828 : :
32829 : : namespace N { struct X{}; }
32830 : :
32831 : : struct A {
32832 : : template <typename T> friend struct N::X;
32833 : : };
32834 : :
32835 : : However, if the DECL refers to a class type, and we are in
32836 : : the scope of the class, then the name lookup automatically
32837 : : finds the TYPE_DECL created by build_self_reference rather
32838 : : than a TEMPLATE_DECL. For example, in:
32839 : :
32840 : : template <class T> struct S {
32841 : : S s;
32842 : : };
32843 : :
32844 : : there is no need to handle such case. */
32845 : :
32846 : 1903460019 : if (DECL_CLASS_TEMPLATE_P (decl) && tag_name_p)
32847 : : return DECL_TEMPLATE_RESULT (decl);
32848 : :
32849 : : return decl;
32850 : : }
32851 : :
32852 : : /* If too many, or too few, template-parameter lists apply to the
32853 : : declarator, issue an error message. Returns TRUE if all went well,
32854 : : and FALSE otherwise. */
32855 : :
32856 : : static bool
32857 : 154535476 : cp_parser_check_declarator_template_parameters (cp_parser* parser,
32858 : : cp_declarator *declarator,
32859 : : location_t declarator_location)
32860 : : {
32861 : 260504787 : switch (declarator->kind)
32862 : : {
32863 : 154535476 : case cdk_id:
32864 : 154535476 : {
32865 : 154535476 : unsigned num_templates = 0;
32866 : 154535476 : tree scope = declarator->u.id.qualifying_scope;
32867 : 154535476 : bool template_id_p = false;
32868 : :
32869 : 154535476 : if (scope)
32870 : 8780829 : num_templates = num_template_headers_for_class (scope);
32871 : 145754647 : else if (TREE_CODE (declarator->u.id.unqualified_name)
32872 : : == TEMPLATE_ID_EXPR)
32873 : : {
32874 : : /* If the DECLARATOR has the form `X<y>' then it uses one
32875 : : additional level of template parameters. */
32876 : 932591 : ++num_templates;
32877 : 932591 : template_id_p = true;
32878 : : }
32879 : :
32880 : 154535476 : return cp_parser_check_template_parameters
32881 : 154535476 : (parser, num_templates, template_id_p, declarator_location,
32882 : 154535476 : declarator);
32883 : : }
32884 : :
32885 : 105969311 : case cdk_function:
32886 : 105969311 : case cdk_array:
32887 : 105969311 : case cdk_pointer:
32888 : 105969311 : case cdk_reference:
32889 : 105969311 : case cdk_ptrmem:
32890 : 105969311 : return (cp_parser_check_declarator_template_parameters
32891 : 105969311 : (parser, declarator->declarator, declarator_location));
32892 : :
32893 : : case cdk_decomp:
32894 : : case cdk_error:
32895 : : return true;
32896 : :
32897 : 0 : default:
32898 : 0 : gcc_unreachable ();
32899 : : }
32900 : : return false;
32901 : : }
32902 : :
32903 : : /* NUM_TEMPLATES were used in the current declaration. If that is
32904 : : invalid, return FALSE and issue an error messages. Otherwise,
32905 : : return TRUE. If DECLARATOR is non-NULL, then we are checking a
32906 : : declarator and we can print more accurate diagnostics. */
32907 : :
32908 : : static bool
32909 : 184850426 : cp_parser_check_template_parameters (cp_parser* parser,
32910 : : unsigned num_templates,
32911 : : bool template_id_p,
32912 : : location_t location,
32913 : : cp_declarator *declarator)
32914 : : {
32915 : : /* If there are the same number of template classes and parameter
32916 : : lists, that's OK. */
32917 : 184850426 : if (parser->num_template_parameter_lists == num_templates)
32918 : : return true;
32919 : : /* If there are more, but only one more, and the name ends in an identifier,
32920 : : then we are declaring a primary template. That's OK too. */
32921 : 61104188 : if (!template_id_p
32922 : 61104142 : && parser->num_template_parameter_lists == num_templates + 1)
32923 : : return true;
32924 : :
32925 : 188 : if (cp_parser_simulate_error (parser))
32926 : 9 : return false;
32927 : :
32928 : : /* If there are more template classes than parameter lists, we have
32929 : : something like:
32930 : :
32931 : : template <class T> void S<T>::R<T>::f (); */
32932 : 85 : if (parser->num_template_parameter_lists < num_templates)
32933 : : {
32934 : 49 : if (declarator && !current_function_decl)
32935 : 16 : error_at (location, "specializing member %<%T::%E%> "
32936 : : "requires %<template<>%> syntax",
32937 : : declarator->u.id.qualifying_scope,
32938 : : declarator->u.id.unqualified_name);
32939 : 6 : else if (declarator)
32940 : 6 : error_at (location, "invalid declaration of %<%T::%E%>",
32941 : : declarator->u.id.qualifying_scope,
32942 : : declarator->u.id.unqualified_name);
32943 : : else
32944 : 27 : error_at (location, "too few template-parameter-lists");
32945 : 49 : return false;
32946 : : }
32947 : : /* Otherwise, there are too many template parameter lists. We have
32948 : : something like:
32949 : :
32950 : : template <class T> template <class U> void S::f(); */
32951 : 36 : error_at (location, "too many template-parameter-lists");
32952 : 36 : return false;
32953 : : }
32954 : :
32955 : : /* Parse an optional `::' token indicating that the following name is
32956 : : from the global namespace. If so, PARSER->SCOPE is set to the
32957 : : GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
32958 : : unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
32959 : : Returns the new value of PARSER->SCOPE, if the `::' token is
32960 : : present, and NULL_TREE otherwise. */
32961 : :
32962 : : static tree
32963 : 4505458872 : cp_parser_global_scope_opt (cp_parser* parser, bool current_scope_valid_p)
32964 : : {
32965 : 4505458872 : cp_token *token;
32966 : :
32967 : : /* Peek at the next token. */
32968 : 4505458872 : token = cp_lexer_peek_token (parser->lexer);
32969 : : /* If we're looking at a `::' token then we're starting from the
32970 : : global namespace, not our current location. */
32971 : 4505458872 : if (token->type == CPP_SCOPE)
32972 : : {
32973 : : /* Consume the `::' token. */
32974 : 7579063 : cp_lexer_consume_token (parser->lexer);
32975 : : /* Set the SCOPE so that we know where to start the lookup. */
32976 : 7579063 : parser->scope = global_namespace;
32977 : 7579063 : parser->qualifying_scope = global_namespace;
32978 : 7579063 : parser->object_scope = NULL_TREE;
32979 : :
32980 : 7579063 : return parser->scope;
32981 : : }
32982 : 4497879809 : else if (!current_scope_valid_p)
32983 : : {
32984 : 4428912201 : parser->scope = NULL_TREE;
32985 : 4428912201 : parser->qualifying_scope = NULL_TREE;
32986 : 4428912201 : parser->object_scope = NULL_TREE;
32987 : : }
32988 : :
32989 : : return NULL_TREE;
32990 : : }
32991 : :
32992 : : /* Returns TRUE if the upcoming token sequence is the start of a
32993 : : constructor declarator or C++17 deduction guide. If FRIEND_P is true, the
32994 : : declarator is preceded by the `friend' specifier. The parser flags FLAGS
32995 : : is used to control type-specifier parsing. */
32996 : :
32997 : : static bool
32998 : 420922650 : cp_parser_constructor_declarator_p (cp_parser *parser, cp_parser_flags flags,
32999 : : bool friend_p)
33000 : : {
33001 : 420922650 : bool constructor_p;
33002 : 420922650 : bool outside_class_specifier_p;
33003 : 420922650 : tree nested_name_specifier;
33004 : 420922650 : cp_token *next_token;
33005 : :
33006 : : /* The common case is that this is not a constructor declarator, so
33007 : : try to avoid doing lots of work if at all possible. It's not
33008 : : valid declare a constructor at function scope. */
33009 : 420922650 : if (parser->in_function_body)
33010 : : return false;
33011 : : /* And only certain tokens can begin a constructor declarator. */
33012 : 237051432 : next_token = cp_lexer_peek_token (parser->lexer);
33013 : 237051432 : if (next_token->type != CPP_NAME
33014 : : && next_token->type != CPP_SCOPE
33015 : : && next_token->type != CPP_NESTED_NAME_SPECIFIER
33016 : : && next_token->type != CPP_TEMPLATE_ID)
33017 : : return false;
33018 : :
33019 : : /* Parse tentatively; we are going to roll back all of the tokens
33020 : : consumed here. */
33021 : 101946511 : cp_parser_parse_tentatively (parser);
33022 : : /* Assume that we are looking at a constructor declarator. */
33023 : 101946511 : constructor_p = true;
33024 : :
33025 : : /* Look for the optional `::' operator. */
33026 : 101946511 : cp_parser_global_scope_opt (parser,
33027 : : /*current_scope_valid_p=*/false);
33028 : : /* Look for the nested-name-specifier. */
33029 : 101946511 : nested_name_specifier
33030 : 101946511 : = (cp_parser_nested_name_specifier_opt (parser,
33031 : : /*typename_keyword_p=*/false,
33032 : : /*check_dependency_p=*/false,
33033 : : /*type_p=*/false,
33034 : : /*is_declaration=*/false));
33035 : :
33036 : : /* Resolve the TYPENAME_TYPE, because the call above didn't do it. */
33037 : 101946508 : if (nested_name_specifier
33038 : 6832718 : && TREE_CODE (nested_name_specifier) == TYPENAME_TYPE)
33039 : : {
33040 : 18 : tree s = resolve_typename_type (nested_name_specifier,
33041 : : /*only_current_p=*/false);
33042 : 18 : if (TREE_CODE (s) != TYPENAME_TYPE)
33043 : 101946508 : nested_name_specifier = s;
33044 : : }
33045 : :
33046 : 101946508 : outside_class_specifier_p = (!at_class_scope_p ()
33047 : 69911969 : || !TYPE_BEING_DEFINED (current_class_type)
33048 : 101946508 : || friend_p);
33049 : :
33050 : : /* Outside of a class-specifier, there must be a
33051 : : nested-name-specifier. Except in C++17 mode, where we
33052 : : might be declaring a guiding declaration. */
33053 : 101946508 : if (!nested_name_specifier && outside_class_specifier_p
33054 : 28862375 : && cxx_dialect < cxx17)
33055 : : constructor_p = false;
33056 : 100904012 : else if (nested_name_specifier == error_mark_node)
33057 : 1042502 : constructor_p = false;
33058 : :
33059 : : /* If we have a class scope, this is easy; DR 147 says that S::S always
33060 : : names the constructor, and no other qualified name could. */
33061 : 101946508 : if (constructor_p && nested_name_specifier
33062 : 101946508 : && CLASS_TYPE_P (nested_name_specifier))
33063 : : {
33064 : 1447801 : tree id = cp_parser_unqualified_id (parser,
33065 : : /*template_keyword_p=*/false,
33066 : : /*check_dependency_p=*/false,
33067 : : /*declarator_p=*/true,
33068 : : /*optional_p=*/false);
33069 : 1447801 : if (is_overloaded_fn (id))
33070 : 21 : id = DECL_NAME (get_first_fn (id));
33071 : 1447801 : if (!constructor_name_p (id, nested_name_specifier))
33072 : 80134605 : constructor_p = false;
33073 : : }
33074 : : /* If we still think that this might be a constructor-declarator,
33075 : : look for a class-name. */
33076 : 100498707 : else if (constructor_p)
33077 : : {
33078 : : /* If we have:
33079 : :
33080 : : template <typename T> struct S {
33081 : : S();
33082 : : };
33083 : :
33084 : : we must recognize that the nested `S' names a class. */
33085 : 99456205 : if (cxx_dialect >= cxx17)
33086 : 98900097 : cp_parser_parse_tentatively (parser);
33087 : :
33088 : 99456205 : tree type_decl;
33089 : 99456205 : type_decl = cp_parser_class_name (parser,
33090 : : /*typename_keyword_p=*/false,
33091 : : /*template_keyword_p=*/false,
33092 : : none_type,
33093 : : /*check_dependency_p=*/false,
33094 : : /*class_head_p=*/false,
33095 : : /*is_declaration=*/false);
33096 : :
33097 : 99456205 : if (cxx_dialect >= cxx17
33098 : 99456205 : && !cp_parser_parse_definitely (parser))
33099 : : {
33100 : 22973686 : type_decl = NULL_TREE;
33101 : 22973686 : tree tmpl = cp_parser_template_name (parser,
33102 : : /*template_keyword*/false,
33103 : : /*check_dependency_p*/false,
33104 : : /*is_declaration*/false,
33105 : : none_type,
33106 : : /*is_identifier*/NULL);
33107 : 2195680 : if (DECL_CLASS_TEMPLATE_P (tmpl)
33108 : 24271870 : || DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl))
33109 : : /* It's a deduction guide, return true. */;
33110 : : else
33111 : 121532366 : cp_parser_simulate_error (parser);
33112 : : }
33113 : :
33114 : : /* If there was no class-name, then this is not a constructor.
33115 : : Otherwise, if we are in a class-specifier and we aren't
33116 : : handling a friend declaration, check that its type matches
33117 : : current_class_type (c++/38313). Note: error_mark_node
33118 : : is left alone for error recovery purposes. */
33119 : 297223042 : constructor_p = (!cp_parser_error_occurred (parser)
33120 : 77266162 : && (outside_class_specifier_p
33121 : 77266162 : || type_decl == NULL_TREE
33122 : 55446935 : || type_decl == error_mark_node
33123 : 55446864 : || same_type_p (current_class_type,
33124 : : TREE_TYPE (type_decl))));
33125 : :
33126 : : /* If we're still considering a constructor, we have to see a `(',
33127 : : to begin the parameter-declaration-clause, followed by either a
33128 : : `)', an `...', or a decl-specifier. We need to check for a
33129 : : type-specifier to avoid being fooled into thinking that:
33130 : :
33131 : : S (f) (int);
33132 : :
33133 : : is a constructor. (It is actually a function named `f' that
33134 : : takes one parameter (of type `int') and returns a value of type
33135 : : `S'. */
33136 : 51097671 : if (constructor_p
33137 : 51097671 : && !cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
33138 : : constructor_p = false;
33139 : :
33140 : 69403004 : if (constructor_p
33141 : 21044470 : && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
33142 : 17211767 : && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
33143 : : /* A parameter declaration begins with a decl-specifier,
33144 : : which is either the "attribute" keyword, a storage class
33145 : : specifier, or (usually) a type-specifier. */
33146 : 17210238 : && !cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer)
33147 : : /* GNU attributes can actually appear both at the start of
33148 : : a parameter and parenthesized declarator.
33149 : : S (__attribute__((unused)) int);
33150 : : is a constructor, but
33151 : : S (__attribute__((unused)) foo) (int);
33152 : : is a function declaration. [[attribute]] can appear in the
33153 : : first form too, but not in the second form. */
33154 : 79882688 : && !cp_next_tokens_can_be_std_attribute_p (parser))
33155 : : {
33156 : 10479672 : tree type;
33157 : 10479672 : tree pushed_scope = NULL_TREE;
33158 : 10479672 : unsigned saved_num_template_parameter_lists;
33159 : :
33160 : 10479672 : if (cp_parser_allow_gnu_extensions_p (parser)
33161 : 10479672 : && cp_next_tokens_can_be_gnu_attribute_p (parser))
33162 : : {
33163 : 20 : unsigned int n = cp_parser_skip_gnu_attributes_opt (parser, 1);
33164 : 140 : while (--n)
33165 : 120 : cp_lexer_consume_token (parser->lexer);
33166 : : }
33167 : :
33168 : : /* Names appearing in the type-specifier should be looked up
33169 : : in the scope of the class. */
33170 : 10479672 : if (current_class_type)
33171 : 10479672 : type = NULL_TREE;
33172 : 883106 : else if (type_decl)
33173 : : {
33174 : 146 : type = TREE_TYPE (type_decl);
33175 : 146 : if (TREE_CODE (type) == TYPENAME_TYPE)
33176 : : {
33177 : 0 : type = resolve_typename_type (type,
33178 : : /*only_current_p=*/false);
33179 : 0 : if (TREE_CODE (type) == TYPENAME_TYPE)
33180 : : {
33181 : 0 : cp_parser_abort_tentative_parse (parser);
33182 : 0 : return false;
33183 : : }
33184 : : }
33185 : 146 : pushed_scope = push_scope (type);
33186 : : }
33187 : :
33188 : : /* Inside the constructor parameter list, surrounding
33189 : : template-parameter-lists do not apply. */
33190 : 10479672 : saved_num_template_parameter_lists
33191 : 10479672 : = parser->num_template_parameter_lists;
33192 : 10479672 : parser->num_template_parameter_lists = 0;
33193 : :
33194 : : /* Look for the type-specifier. It's not optional, but its typename
33195 : : might be. Unless this is a friend declaration; we don't want to
33196 : : treat
33197 : :
33198 : : friend S (T::fn)(int);
33199 : :
33200 : : as a constructor, but with P0634, we might assume a type when
33201 : : looking for the type-specifier. It is actually a function named
33202 : : `T::fn' that takes one parameter (of type `int') and returns a
33203 : : value of type `S'. Constructors can be friends, but they must
33204 : : use a qualified name.
33205 : :
33206 : : Parse with an empty set of declaration specifiers since we're
33207 : : trying to match a decl-specifier-seq of the first parameter.
33208 : : This must be non-null so that cp_parser_simple_type_specifier
33209 : : will recognize a constrained placeholder type such as:
33210 : : 'C<int> auto' where C is a type concept. */
33211 : 10479672 : cp_decl_specifier_seq ctor_specs;
33212 : 10479672 : clear_decl_specs (&ctor_specs);
33213 : 10479672 : cp_parser_type_specifier (parser,
33214 : : (friend_p ? CP_PARSER_FLAGS_NONE
33215 : : : (flags & ~CP_PARSER_FLAGS_OPTIONAL)),
33216 : : /*decl_specs=*/&ctor_specs,
33217 : : /*is_declarator=*/true,
33218 : : /*declares_class_or_enum=*/NULL,
33219 : : /*is_cv_qualifier=*/NULL);
33220 : :
33221 : 10479672 : parser->num_template_parameter_lists
33222 : 10479672 : = saved_num_template_parameter_lists;
33223 : :
33224 : : /* Leave the scope of the class. */
33225 : 10479672 : if (pushed_scope)
33226 : 146 : pop_scope (pushed_scope);
33227 : :
33228 : 10479672 : constructor_p = !cp_parser_error_occurred (parser);
33229 : : }
33230 : : }
33231 : :
33232 : : /* We did not really want to consume any tokens. */
33233 : 101946508 : cp_parser_abort_tentative_parse (parser);
33234 : :
33235 : : /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
33236 : : declarator-id of a constructor or destructor. */
33237 : 101946508 : if (constructor_p
33238 : 101946508 : && cp_lexer_peek_token (parser->lexer)->type == CPP_TEMPLATE_ID)
33239 : : {
33240 : 50 : auto_diagnostic_group d;
33241 : 84 : if (emit_diagnostic (cxx_dialect >= cxx20 ? DK_PEDWARN : DK_WARNING,
33242 : : input_location, OPT_Wtemplate_id_cdtor,
33243 : : "template-id not allowed for constructor in C++20"))
33244 : 21 : inform (input_location, "remove the %qs", "< >");
33245 : 50 : }
33246 : :
33247 : : return constructor_p;
33248 : : }
33249 : :
33250 : : /* Parse the definition of the function given by the DECL_SPECIFIERS,
33251 : : ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
33252 : : they must be performed once we are in the scope of the function.
33253 : :
33254 : : Returns the function defined. */
33255 : :
33256 : : static tree
33257 : 37207287 : cp_parser_function_definition_from_specifiers_and_declarator
33258 : : (cp_parser* parser,
33259 : : cp_decl_specifier_seq *decl_specifiers,
33260 : : tree attributes,
33261 : : const cp_declarator *declarator)
33262 : : {
33263 : 37207287 : tree fn;
33264 : 37207287 : bool success_p;
33265 : :
33266 : : /* Begin the function-definition. */
33267 : 37207287 : success_p = start_function (decl_specifiers, declarator, attributes);
33268 : :
33269 : : /* The things we're about to see are not directly qualified by any
33270 : : template headers we've seen thus far. */
33271 : 37207287 : reset_specialization ();
33272 : :
33273 : : /* If there were names looked up in the decl-specifier-seq that we
33274 : : did not check, check them now. We must wait until we are in the
33275 : : scope of the function to perform the checks, since the function
33276 : : might be a friend. */
33277 : 37207287 : perform_deferred_access_checks (tf_warning_or_error);
33278 : :
33279 : 37207287 : if (success_p)
33280 : : {
33281 : 37206962 : cp_finalize_omp_declare_simd (parser, current_function_decl);
33282 : 37206962 : parser->omp_declare_simd = NULL;
33283 : 37206962 : cp_finalize_oacc_routine (parser, current_function_decl, true);
33284 : 37206962 : parser->oacc_routine = NULL;
33285 : : }
33286 : :
33287 : 37207287 : if (!success_p)
33288 : : {
33289 : : /* Skip the entire function. */
33290 : 325 : cp_parser_skip_to_end_of_block_or_statement (parser);
33291 : 325 : fn = error_mark_node;
33292 : : }
33293 : 37206962 : else if (DECL_INITIAL (current_function_decl) != error_mark_node)
33294 : : {
33295 : : /* Seen already, skip it. An error message has already been output. */
33296 : 0 : cp_parser_skip_to_end_of_block_or_statement (parser);
33297 : 0 : fn = current_function_decl;
33298 : 0 : current_function_decl = NULL_TREE;
33299 : : /* If this is a function from a class, pop the nested class. */
33300 : 0 : if (current_class_name)
33301 : 0 : pop_nested_class ();
33302 : : }
33303 : : else
33304 : : {
33305 : 37206962 : auto_timevar tv (DECL_DECLARED_INLINE_P (current_function_decl)
33306 : 45955980 : ? TV_PARSE_INLINE : TV_PARSE_FUNC);
33307 : 37206962 : fn = cp_parser_function_definition_after_declarator (parser,
33308 : : /*inline_p=*/false);
33309 : 37206938 : }
33310 : :
33311 : 37207263 : return fn;
33312 : : }
33313 : :
33314 : : /* Parse the part of a function-definition that follows the
33315 : : declarator. INLINE_P is TRUE iff this function is an inline
33316 : : function defined within a class-specifier.
33317 : :
33318 : : Returns the function defined. */
33319 : :
33320 : : static tree
33321 : 101264897 : cp_parser_function_definition_after_declarator (cp_parser* parser,
33322 : : bool inline_p)
33323 : : {
33324 : 101264897 : tree fn;
33325 : 101264897 : bool saved_in_unbraced_linkage_specification_p;
33326 : 101264897 : bool saved_in_function_body;
33327 : 101264897 : unsigned saved_num_template_parameter_lists;
33328 : 101264897 : cp_token *token;
33329 : 101264897 : bool fully_implicit_function_template_p
33330 : : = parser->fully_implicit_function_template_p;
33331 : 101264897 : parser->fully_implicit_function_template_p = false;
33332 : 101264897 : tree implicit_template_parms
33333 : : = parser->implicit_template_parms;
33334 : 101264897 : parser->implicit_template_parms = 0;
33335 : 101264897 : cp_binding_level* implicit_template_scope
33336 : : = parser->implicit_template_scope;
33337 : 101264897 : parser->implicit_template_scope = 0;
33338 : :
33339 : 101264897 : saved_in_function_body = parser->in_function_body;
33340 : 101264897 : parser->in_function_body = true;
33341 : : /* If the next token is `return', then the code may be trying to
33342 : : make use of the "named return value" extension that G++ used to
33343 : : support. */
33344 : 101264897 : token = cp_lexer_peek_token (parser->lexer);
33345 : 101264897 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN))
33346 : : {
33347 : : /* Consume the `return' keyword. */
33348 : 216 : cp_lexer_consume_token (parser->lexer);
33349 : : /* Look for the identifier that indicates what value is to be
33350 : : returned. */
33351 : 216 : cp_parser_identifier (parser);
33352 : : /* Issue an error message. */
33353 : 216 : error_at (token->location,
33354 : : "named return values are no longer supported");
33355 : : /* Skip tokens until we reach the start of the function body. */
33356 : 1434 : while (true)
33357 : : {
33358 : 825 : cp_token *token = cp_lexer_peek_token (parser->lexer);
33359 : 825 : if (token->type == CPP_OPEN_BRACE
33360 : 612 : || token->type == CPP_EOF
33361 : 609 : || token->type == CPP_PRAGMA_EOL)
33362 : : break;
33363 : 609 : cp_lexer_consume_token (parser->lexer);
33364 : 609 : }
33365 : : }
33366 : : /* The `extern' in `extern "C" void f () { ... }' does not apply to
33367 : : anything declared inside `f'. */
33368 : 101264897 : saved_in_unbraced_linkage_specification_p
33369 : 101264897 : = parser->in_unbraced_linkage_specification_p;
33370 : 101264897 : parser->in_unbraced_linkage_specification_p = false;
33371 : : /* Inside the function, surrounding template-parameter-lists do not
33372 : : apply. */
33373 : 101264897 : saved_num_template_parameter_lists
33374 : 101264897 : = parser->num_template_parameter_lists;
33375 : 101264897 : parser->num_template_parameter_lists = 0;
33376 : :
33377 : : /* If the next token is `try', `__transaction_atomic', or
33378 : : `__transaction_relaxed`, then we are looking at either function-try-block
33379 : : or function-transaction-block. Note that all of these include the
33380 : : function-body. */
33381 : 101264897 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRANSACTION_ATOMIC))
33382 : 21 : cp_parser_function_transaction (parser, RID_TRANSACTION_ATOMIC);
33383 : 101264876 : else if (cp_lexer_next_token_is_keyword (parser->lexer,
33384 : : RID_TRANSACTION_RELAXED))
33385 : 0 : cp_parser_function_transaction (parser, RID_TRANSACTION_RELAXED);
33386 : 101264876 : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
33387 : 274 : cp_parser_function_try_block (parser);
33388 : : else
33389 : 101264602 : cp_parser_ctor_initializer_opt_and_function_body
33390 : 101264602 : (parser, /*in_function_try_block=*/false);
33391 : :
33392 : : /* Finish the function. */
33393 : 101264873 : fn = finish_function (inline_p);
33394 : 101264873 : check_module_decl_linkage (fn);
33395 : :
33396 : 101264873 : if (modules_p ()
33397 : 477339 : && !inline_p
33398 : 168853 : && TYPE_P (DECL_CONTEXT (fn))
33399 : 101292933 : && (DECL_DECLARED_INLINE_P (fn)
33400 : 15898 : || processing_template_decl))
33401 : 27976 : set_defining_module (fn);
33402 : :
33403 : : /* Generate code for it, if necessary. */
33404 : 101264873 : expand_or_defer_fn (fn);
33405 : :
33406 : : /* Restore the saved values. */
33407 : 101264873 : parser->in_unbraced_linkage_specification_p
33408 : 101264873 : = saved_in_unbraced_linkage_specification_p;
33409 : 101264873 : parser->num_template_parameter_lists
33410 : 101264873 : = saved_num_template_parameter_lists;
33411 : 101264873 : parser->in_function_body = saved_in_function_body;
33412 : :
33413 : 101264873 : parser->fully_implicit_function_template_p
33414 : 101264873 : = fully_implicit_function_template_p;
33415 : 101264873 : parser->implicit_template_parms
33416 : 101264873 : = implicit_template_parms;
33417 : 101264873 : parser->implicit_template_scope
33418 : 101264873 : = implicit_template_scope;
33419 : :
33420 : 101264873 : if (parser->fully_implicit_function_template_p)
33421 : 388 : finish_fully_implicit_template (parser, /*member_decl_opt=*/0);
33422 : :
33423 : 101264873 : return fn;
33424 : : }
33425 : :
33426 : : /* Parse a template-declaration body (following argument list). */
33427 : :
33428 : : static void
33429 : 76223080 : cp_parser_template_declaration_after_parameters (cp_parser* parser,
33430 : : tree parameter_list,
33431 : : bool member_p)
33432 : : {
33433 : 76223080 : tree decl = NULL_TREE;
33434 : 76223080 : bool friend_p = false;
33435 : :
33436 : : /* We just processed one more parameter list. */
33437 : 76223080 : ++parser->num_template_parameter_lists;
33438 : :
33439 : : /* Get the deferred access checks from the parameter list. These
33440 : : will be checked once we know what is being declared, as for a
33441 : : member template the checks must be performed in the scope of the
33442 : : class containing the member. */
33443 : 76223080 : vec<deferred_access_check, va_gc> *checks = get_deferred_access_checks ();
33444 : :
33445 : : /* Tentatively parse for a new template parameter list, which can either be
33446 : : the template keyword or a template introduction. */
33447 : 76223080 : if (cp_parser_template_declaration_after_export (parser, member_p))
33448 : : /* OK */;
33449 : 74292813 : else if (cxx_dialect >= cxx11
33450 : 74292813 : && cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
33451 : 3564698 : decl = cp_parser_alias_declaration (parser);
33452 : 70728115 : else if (flag_concepts
33453 : 19011428 : && cp_lexer_next_token_is_keyword (parser->lexer, RID_CONCEPT)
33454 : 71349893 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
33455 : 621751 : decl = cp_parser_concept_definition (parser);
33456 : : else
33457 : : {
33458 : 70106364 : cp_token *token = cp_lexer_peek_token (parser->lexer);
33459 : 70106364 : decl = cp_parser_single_declaration (parser,
33460 : : checks,
33461 : : member_p,
33462 : : /*explicit_specialization_p=*/false,
33463 : : &friend_p);
33464 : :
33465 : : /* If this is a member template declaration, let the front
33466 : : end know. */
33467 : 70106355 : if (member_p && !friend_p && decl)
33468 : : {
33469 : 16817444 : if (TREE_CODE (decl) == TYPE_DECL)
33470 : 1155820 : cp_parser_check_access_in_redeclaration (decl, token->location);
33471 : :
33472 : 16817444 : decl = finish_member_template_decl (decl);
33473 : : }
33474 : 1862565 : else if (friend_p && decl
33475 : 55151476 : && DECL_DECLARES_TYPE_P (decl))
33476 : 599405 : make_friend_class (current_class_type, TREE_TYPE (decl),
33477 : : /*complain=*/true);
33478 : : }
33479 : : /* We are done with the current parameter list. */
33480 : 76223071 : --parser->num_template_parameter_lists;
33481 : :
33482 : 76223071 : pop_deferring_access_checks ();
33483 : :
33484 : : /* Finish up. */
33485 : 76223071 : finish_template_decl (parameter_list);
33486 : :
33487 : : /* Check the template arguments for a literal operator template. */
33488 : 76223071 : if (decl
33489 : 73715549 : && DECL_DECLARES_FUNCTION_P (decl)
33490 : 125576921 : && UDLIT_OPER_P (DECL_NAME (decl)))
33491 : : {
33492 : 57729 : bool ok = true;
33493 : 57729 : if (parameter_list == NULL_TREE)
33494 : : ok = false;
33495 : : else
33496 : : {
33497 : 57729 : int num_parms = TREE_VEC_LENGTH (parameter_list);
33498 : 57729 : if (num_parms == 1)
33499 : : {
33500 : 57695 : tree parm_list = TREE_VEC_ELT (parameter_list, 0);
33501 : 57695 : tree parm = INNERMOST_TEMPLATE_PARMS (parm_list);
33502 : 57695 : if (TREE_CODE (parm) != PARM_DECL)
33503 : : ok = false;
33504 : 57689 : else if (MAYBE_CLASS_TYPE_P (TREE_TYPE (parm))
33505 : 18 : && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
33506 : : /* OK, C++20 string literal operator template. We don't need
33507 : : to warn in lower dialects here because we will have already
33508 : : warned about the template parameter. */;
33509 : 57677 : else if (TREE_TYPE (parm) != char_type_node
33510 : 57677 : || !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
33511 : : ok = false;
33512 : : }
33513 : 34 : else if (num_parms == 2 && cxx_dialect >= cxx14)
33514 : : {
33515 : 32 : tree parm_type = TREE_VEC_ELT (parameter_list, 0);
33516 : 32 : tree type = INNERMOST_TEMPLATE_PARMS (parm_type);
33517 : 32 : tree parm_list = TREE_VEC_ELT (parameter_list, 1);
33518 : 32 : tree parm = INNERMOST_TEMPLATE_PARMS (parm_list);
33519 : 32 : if (TREE_CODE (parm) != PARM_DECL
33520 : 30 : || TREE_TYPE (parm) != TREE_TYPE (type)
33521 : 62 : || !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
33522 : : ok = false;
33523 : : else
33524 : : /* http://cplusplus.github.io/EWG/ewg-active.html#66 */
33525 : 30 : pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wpedantic,
33526 : : "ISO C++ did not adopt string literal operator templa"
33527 : : "tes taking an argument pack of characters");
33528 : : }
33529 : : else
33530 : : ok = false;
33531 : : }
33532 : 30 : if (!ok)
33533 : : {
33534 : 25 : if (cxx_dialect > cxx17)
33535 : 14 : error_at (DECL_SOURCE_LOCATION (decl), "literal operator "
33536 : : "template %qD has invalid parameter list; expected "
33537 : : "non-type template parameter pack %<<char...>%> or "
33538 : : "single non-type parameter of class type",
33539 : : decl);
33540 : : else
33541 : 11 : error_at (DECL_SOURCE_LOCATION (decl), "literal operator "
33542 : : "template %qD has invalid parameter list; expected "
33543 : : "non-type template parameter pack %<<char...>%>",
33544 : : decl);
33545 : : }
33546 : : }
33547 : :
33548 : : /* Register member declarations. */
33549 : 76223071 : if (member_p && !friend_p && decl && !DECL_CLASS_TEMPLATE_P (decl))
33550 : 16910661 : finish_member_declaration (decl);
33551 : : /* If DECL is a function template, we must return to parse it later.
33552 : : (Even though there is no definition, there might be default
33553 : : arguments that need handling.) */
33554 : 20008726 : if (member_p && decl
33555 : 95654476 : && DECL_DECLARES_FUNCTION_P (decl))
33556 : 16643808 : vec_safe_push (unparsed_funs_with_definitions, decl);
33557 : 76223071 : }
33558 : :
33559 : : /* Parse a normal template-declaration following the template keyword. */
33560 : :
33561 : : static void
33562 : 76223086 : cp_parser_explicit_template_declaration (cp_parser* parser, bool member_p)
33563 : : {
33564 : 76223086 : tree parameter_list;
33565 : 76223086 : bool need_lang_pop;
33566 : 76223086 : location_t location = input_location;
33567 : :
33568 : : /* Look for the `<' token. */
33569 : 76223086 : if (!cp_parser_require (parser, CPP_LESS, RT_LESS))
33570 : : return;
33571 : 76223083 : if (at_class_scope_p () && current_function_decl)
33572 : : {
33573 : : /* 14.5.2.2 [temp.mem]
33574 : :
33575 : : A local class shall not have member templates. */
33576 : 3 : error_at (location,
33577 : : "invalid declaration of member template in local class");
33578 : 3 : cp_parser_skip_to_end_of_block_or_statement (parser);
33579 : 3 : return;
33580 : : }
33581 : : /* [temp]
33582 : :
33583 : : A template ... shall not have C linkage. */
33584 : 76223080 : if (current_lang_name == lang_name_c)
33585 : : {
33586 : 18 : auto_diagnostic_group d;
33587 : 18 : error_at (location, "template with C linkage");
33588 : 18 : maybe_show_extern_c_location ();
33589 : : /* Give it C++ linkage to avoid confusing other parts of the
33590 : : front end. */
33591 : 18 : push_lang_context (lang_name_cplusplus);
33592 : 18 : need_lang_pop = true;
33593 : 18 : }
33594 : : else
33595 : : need_lang_pop = false;
33596 : :
33597 : : /* We cannot perform access checks on the template parameter
33598 : : declarations until we know what is being declared, just as we
33599 : : cannot check the decl-specifier list. */
33600 : 76223080 : push_deferring_access_checks (dk_deferred);
33601 : :
33602 : : /* If the next token is `>', then we have an invalid
33603 : : specialization. Rather than complain about an invalid template
33604 : : parameter, issue an error message here. */
33605 : 76223080 : if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
33606 : : {
33607 : 6 : cp_parser_error (parser, "invalid explicit specialization");
33608 : 6 : begin_specialization ();
33609 : 6 : parameter_list = NULL_TREE;
33610 : : }
33611 : : else
33612 : : {
33613 : : /* Parse the template parameters. */
33614 : 76223074 : parameter_list = cp_parser_template_parameter_list (parser);
33615 : : }
33616 : :
33617 : : /* Look for the `>'. */
33618 : 76223080 : cp_parser_require_end_of_template_parameter_list (parser);
33619 : :
33620 : : /* Manage template requirements */
33621 : 76223080 : if (flag_concepts)
33622 : : {
33623 : 20529744 : tree reqs = get_shorthand_constraints (current_template_parms);
33624 : 20529744 : if (tree treqs = cp_parser_requires_clause_opt (parser, false))
33625 : 1441088 : reqs = combine_constraint_expressions (reqs, treqs);
33626 : 20529744 : TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = reqs;
33627 : : }
33628 : :
33629 : 76223080 : cp_parser_template_declaration_after_parameters (parser, parameter_list,
33630 : : member_p);
33631 : :
33632 : : /* For the erroneous case of a template with C linkage, we pushed an
33633 : : implicit C++ linkage scope; exit that scope now. */
33634 : 76223071 : if (need_lang_pop)
33635 : 18 : pop_lang_context ();
33636 : : }
33637 : :
33638 : : /* Parse a template-declaration, assuming that the `export' (and
33639 : : `extern') keywords, if present, has already been scanned. MEMBER_P
33640 : : is as for cp_parser_template_declaration. */
33641 : :
33642 : : static bool
33643 : 287729271 : cp_parser_template_declaration_after_export (cp_parser* parser, bool member_p)
33644 : : {
33645 : 287729271 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
33646 : : {
33647 : 76223086 : cp_lexer_consume_token (parser->lexer);
33648 : 76223086 : cp_parser_explicit_template_declaration (parser, member_p);
33649 : 76223086 : return true;
33650 : : }
33651 : :
33652 : : return false;
33653 : : }
33654 : :
33655 : : /* Perform the deferred access checks from a template-parameter-list.
33656 : : CHECKS is a TREE_LIST of access checks, as returned by
33657 : : get_deferred_access_checks. */
33658 : :
33659 : : static void
33660 : 122199268 : cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
33661 : : {
33662 : 122199268 : ++processing_template_parmlist;
33663 : 122199268 : perform_access_checks (checks, tf_warning_or_error);
33664 : 122199268 : --processing_template_parmlist;
33665 : 122199268 : }
33666 : :
33667 : : /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
33668 : : `function-definition' sequence that follows a template header.
33669 : : If MEMBER_P is true, this declaration appears in a class scope.
33670 : :
33671 : : Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
33672 : : *FRIEND_P is set to TRUE iff the declaration is a friend. */
33673 : :
33674 : : static tree
33675 : 74916167 : cp_parser_single_declaration (cp_parser* parser,
33676 : : vec<deferred_access_check, va_gc> *checks,
33677 : : bool member_p,
33678 : : bool explicit_specialization_p,
33679 : : bool* friend_p)
33680 : : {
33681 : 74916167 : int declares_class_or_enum;
33682 : 74916167 : tree decl = NULL_TREE;
33683 : 74916167 : cp_decl_specifier_seq decl_specifiers;
33684 : 74916167 : bool function_definition_p = false;
33685 : 74916167 : cp_token *decl_spec_token_start;
33686 : :
33687 : : /* This function is only used when processing a template
33688 : : declaration. */
33689 : 74916167 : gcc_assert (innermost_scope_kind () == sk_template_parms
33690 : : || innermost_scope_kind () == sk_template_spec);
33691 : :
33692 : : /* Defer access checks until we know what is being declared. */
33693 : 74916167 : push_deferring_access_checks (dk_deferred);
33694 : :
33695 : : /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
33696 : : alternative. */
33697 : 74916167 : decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
33698 : 74916167 : cp_parser_decl_specifier_seq (parser,
33699 : : (CP_PARSER_FLAGS_OPTIONAL
33700 : : | CP_PARSER_FLAGS_TYPENAME_OPTIONAL),
33701 : : &decl_specifiers,
33702 : : &declares_class_or_enum);
33703 : :
33704 : 74916158 : cp_omp_declare_simd_data odsd;
33705 : 74916158 : if (decl_specifiers.attributes && (flag_openmp || flag_openmp_simd))
33706 : 8345 : cp_parser_handle_directive_omp_attributes (parser,
33707 : : &decl_specifiers.attributes,
33708 : : &odsd, true);
33709 : :
33710 : 74916158 : if (friend_p)
33711 : 70106355 : *friend_p = cp_parser_friend_p (&decl_specifiers);
33712 : :
33713 : : /* There are no template typedefs. */
33714 : 74916158 : if (decl_spec_seq_has_spec_p (&decl_specifiers, ds_typedef))
33715 : : {
33716 : 3 : error_at (decl_spec_token_start->location,
33717 : : "template declaration of %<typedef%>");
33718 : 3 : decl = error_mark_node;
33719 : : }
33720 : :
33721 : : /* Gather up the access checks that occurred the
33722 : : decl-specifier-seq. */
33723 : 74916158 : stop_deferring_access_checks ();
33724 : :
33725 : : /* Check for the declaration of a template class. */
33726 : 74916158 : if (declares_class_or_enum)
33727 : : {
33728 : 43730910 : if (cp_parser_declares_only_class_p (parser)
33729 : 88 : || (declares_class_or_enum & 2))
33730 : : {
33731 : 21865384 : decl = shadow_tag (&decl_specifiers);
33732 : :
33733 : : /* In this case:
33734 : :
33735 : : struct C {
33736 : : friend template <typename T> struct A<T>::B;
33737 : : };
33738 : :
33739 : : A<T>::B will be represented by a TYPENAME_TYPE, and
33740 : : therefore not recognized by shadow_tag. */
33741 : 21865384 : if (friend_p && *friend_p
33742 : 599417 : && !decl
33743 : 75 : && decl_specifiers.type
33744 : 75 : && TYPE_P (decl_specifiers.type))
33745 : 21266042 : decl = decl_specifiers.type;
33746 : :
33747 : 21865384 : if (decl && decl != error_mark_node)
33748 : 21863190 : decl = TYPE_NAME (decl);
33749 : : else
33750 : 2194 : decl = error_mark_node;
33751 : :
33752 : : /* If this is a declaration, but not a definition, associate
33753 : : any constraints with the type declaration. Constraints
33754 : : are associated with definitions in cp_parser_class_specifier. */
33755 : 21865384 : if (declares_class_or_enum == 1)
33756 : 3621453 : associate_classtype_constraints (TREE_TYPE (decl));
33757 : :
33758 : : /* Perform access checks for template parameters. */
33759 : 21865384 : cp_parser_perform_template_parameter_access_checks (checks);
33760 : :
33761 : : /* Give a helpful diagnostic for
33762 : : template <class T> struct A { } a;
33763 : : if we aren't already recovering from an error. */
33764 : 96781573 : if (!cp_parser_declares_only_class_p (parser)
33765 : 34 : && !seen_error ())
33766 : : {
33767 : 3 : error_at (cp_lexer_peek_token (parser->lexer)->location,
33768 : : "a class template declaration must not declare "
33769 : : "anything else");
33770 : 3 : cp_parser_skip_to_end_of_block_or_statement (parser);
33771 : 3 : goto out;
33772 : : }
33773 : : }
33774 : : }
33775 : :
33776 : : /* Complain about missing 'typename' or other invalid type names. */
33777 : 74916155 : if (!decl_specifiers.any_type_specifiers_p
33778 : 74916155 : && cp_parser_parse_and_diagnose_invalid_type_name (parser))
33779 : : {
33780 : : /* cp_parser_parse_and_diagnose_invalid_type_name calls
33781 : : cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
33782 : : the rest of this declaration. */
33783 : 42 : decl = error_mark_node;
33784 : 42 : goto out;
33785 : : }
33786 : :
33787 : : /* If it's not a template class, try for a template function. If
33788 : : the next token is a `;', then this declaration does not declare
33789 : : anything. But, if there were errors in the decl-specifiers, then
33790 : : the error might well have come from an attempted class-specifier.
33791 : : In that case, there's no need to warn about a missing declarator. */
33792 : 74916113 : if (!decl
33793 : 74916113 : && (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
33794 : 34 : || decl_specifiers.type != error_mark_node))
33795 : : {
33796 : 53050732 : int flags = CP_PARSER_FLAGS_TYPENAME_OPTIONAL;
33797 : : /* We don't delay parsing for friends, though CWG 2510 may change
33798 : : that. */
33799 : 53050732 : if (member_p && !(friend_p && *friend_p))
33800 : 53050732 : flags |= CP_PARSER_FLAGS_DELAY_NOEXCEPT;
33801 : 53050732 : decl = cp_parser_init_declarator (parser,
33802 : : flags,
33803 : : &decl_specifiers,
33804 : : checks,
33805 : : /*function_definition_allowed_p=*/true,
33806 : : member_p,
33807 : : declares_class_or_enum,
33808 : : &function_definition_p,
33809 : : NULL, NULL, NULL);
33810 : :
33811 : : /* 7.1.1-1 [dcl.stc]
33812 : :
33813 : : A storage-class-specifier shall not be specified in an explicit
33814 : : specialization... */
33815 : 53050732 : if (decl
33816 : 53050732 : && explicit_specialization_p
33817 : 889883 : && decl_specifiers.storage_class != sc_none)
33818 : : {
33819 : 6 : error_at (decl_spec_token_start->location,
33820 : : "explicit template specialization cannot have a storage class");
33821 : 6 : decl = error_mark_node;
33822 : : }
33823 : :
33824 : 53050732 : if (decl && VAR_P (decl))
33825 : 3141730 : check_template_variable (decl);
33826 : : }
33827 : :
33828 : : /* Look for a trailing `;' after the declaration. */
33829 : 74916113 : if (!function_definition_p
33830 : 74916113 : && (decl == error_mark_node
33831 : 34416935 : || !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON)))
33832 : 2655 : cp_parser_skip_to_end_of_block_or_statement (parser);
33833 : :
33834 : 74916158 : out:
33835 : 74916158 : pop_deferring_access_checks ();
33836 : :
33837 : : /* Clear any current qualification; whatever comes next is the start
33838 : : of something new. */
33839 : 74916158 : parser->scope = NULL_TREE;
33840 : 74916158 : parser->qualifying_scope = NULL_TREE;
33841 : 74916158 : parser->object_scope = NULL_TREE;
33842 : :
33843 : 74916158 : cp_finalize_omp_declare_simd (parser, &odsd);
33844 : :
33845 : 74916158 : return decl;
33846 : : }
33847 : :
33848 : : /* Parse a cast-expression that is not the operand of a unary "&". */
33849 : :
33850 : : static cp_expr
33851 : 118795280 : cp_parser_simple_cast_expression (cp_parser *parser)
33852 : : {
33853 : 118795280 : return cp_parser_cast_expression (parser, /*address_p=*/false,
33854 : 118795280 : /*cast_p=*/false, /*decltype*/false, NULL);
33855 : : }
33856 : :
33857 : : /* Parse a functional cast to TYPE. Returns an expression
33858 : : representing the cast. */
33859 : :
33860 : : static cp_expr
33861 : 40041560 : cp_parser_functional_cast (cp_parser* parser, tree type)
33862 : : {
33863 : 40041560 : vec<tree, va_gc> *vec;
33864 : 40041560 : tree expression_list;
33865 : 40041560 : cp_expr cast;
33866 : :
33867 : 40041560 : location_t start_loc = input_location;
33868 : :
33869 : 40041560 : if (!type)
33870 : 0 : type = error_mark_node;
33871 : :
33872 : 40041560 : if (TREE_CODE (type) == TYPE_DECL
33873 : 40041560 : && is_auto (TREE_TYPE (type)))
33874 : 6108 : type = TREE_TYPE (type);
33875 : :
33876 : 40041560 : if (is_auto (type)
33877 : 200385 : && !AUTO_IS_DECLTYPE (type)
33878 : 200378 : && !PLACEHOLDER_TYPE_CONSTRAINTS (type)
33879 : 40241934 : && !CLASS_PLACEHOLDER_TEMPLATE (type))
33880 : : /* auto(x) and auto{x} need to use a level-less auto. */
33881 : 6104 : type = make_cast_auto ();
33882 : :
33883 : 40041560 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
33884 : : {
33885 : 3485424 : cp_lexer_set_source_position (parser->lexer);
33886 : 3485424 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
33887 : 3485424 : expression_list = cp_parser_braced_list (parser);
33888 : 3485424 : CONSTRUCTOR_IS_DIRECT_INIT (expression_list) = 1;
33889 : 3485424 : if (TREE_CODE (type) == TYPE_DECL)
33890 : 3339397 : type = TREE_TYPE (type);
33891 : :
33892 : 6970848 : cast = finish_compound_literal (type, expression_list,
33893 : 3485424 : tf_warning_or_error, fcl_functional);
33894 : : /* Create a location of the form:
33895 : : type_name{i, f}
33896 : : ^~~~~~~~~~~~~~~
33897 : : with caret == start at the start of the type name,
33898 : : finishing at the closing brace. */
33899 : 3485424 : location_t combined_loc = make_location (start_loc, start_loc,
33900 : : parser->lexer);
33901 : 3485424 : cast.set_location (combined_loc);
33902 : 3485424 : return cast;
33903 : : }
33904 : :
33905 : :
33906 : 36556136 : vec = cp_parser_parenthesized_expression_list (parser, non_attr,
33907 : : /*cast_p=*/true,
33908 : : /*allow_expansion_p=*/true,
33909 : : /*non_constant_p=*/NULL);
33910 : 36556136 : if (vec == NULL)
33911 : 637 : expression_list = error_mark_node;
33912 : : else
33913 : : {
33914 : 36555499 : expression_list = build_tree_list_vec (vec);
33915 : 36555499 : release_tree_vector (vec);
33916 : : }
33917 : :
33918 : : /* Create a location of the form:
33919 : : float(i)
33920 : : ^~~~~~~~
33921 : : with caret == start at the start of the type name,
33922 : : finishing at the closing paren. */
33923 : 36556136 : location_t combined_loc = make_location (start_loc, start_loc,
33924 : : parser->lexer);
33925 : 73112272 : cast = build_functional_cast (combined_loc, type, expression_list,
33926 : 36556136 : tf_warning_or_error);
33927 : :
33928 : : /* [expr.const]/1: In an integral constant expression "only type
33929 : : conversions to integral or enumeration type can be used". */
33930 : 36556136 : if (TREE_CODE (type) == TYPE_DECL)
33931 : 36295852 : type = TREE_TYPE (type);
33932 : 36556136 : if (cast != error_mark_node
33933 : 36555285 : && !cast_valid_in_integral_constant_expression_p (type)
33934 : 36564987 : && cp_parser_non_integral_constant_expression (parser,
33935 : : NIC_CONSTRUCTOR))
33936 : 1 : return error_mark_node;
33937 : :
33938 : 36556135 : return cast;
33939 : : }
33940 : :
33941 : : /* Save the tokens that make up the body of a member function defined
33942 : : in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
33943 : : already been parsed. The ATTRIBUTES are any GNU "__attribute__"
33944 : : specifiers applied to the declaration. Returns the FUNCTION_DECL
33945 : : for the member function. */
33946 : :
33947 : : static tree
33948 : 64058063 : cp_parser_save_member_function_body (cp_parser* parser,
33949 : : cp_decl_specifier_seq *decl_specifiers,
33950 : : cp_declarator *declarator,
33951 : : tree attributes)
33952 : : {
33953 : 64058063 : cp_token *first;
33954 : 64058063 : cp_token *last;
33955 : 64058063 : tree fn;
33956 : 64058063 : bool function_try_block = false;
33957 : :
33958 : : /* Create the FUNCTION_DECL. */
33959 : 64058063 : fn = grokmethod (decl_specifiers, declarator, attributes);
33960 : 64058063 : cp_finalize_omp_declare_simd (parser, fn);
33961 : 64058063 : cp_finalize_oacc_routine (parser, fn, true);
33962 : : /* If something went badly wrong, bail out now. */
33963 : 64058063 : if (fn == error_mark_node)
33964 : : {
33965 : : /* If there's a function-body, skip it. */
33966 : 94 : if (cp_parser_token_starts_function_definition_p
33967 : 94 : (cp_lexer_peek_token (parser->lexer)))
33968 : 94 : cp_parser_skip_to_end_of_block_or_statement (parser);
33969 : 94 : return error_mark_node;
33970 : : }
33971 : :
33972 : : /* Remember it, if there are default args to post process. */
33973 : 64057969 : cp_parser_save_default_args (parser, fn);
33974 : :
33975 : : /* Save away the tokens that make up the body of the
33976 : : function. */
33977 : 64057969 : first = parser->lexer->next_token;
33978 : :
33979 : 64057969 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRANSACTION_RELAXED))
33980 : 0 : cp_lexer_consume_token (parser->lexer);
33981 : 64057969 : else if (cp_lexer_next_token_is_keyword (parser->lexer,
33982 : : RID_TRANSACTION_ATOMIC))
33983 : : {
33984 : 6 : cp_lexer_consume_token (parser->lexer);
33985 : : /* Match cp_parser_txn_attribute_opt [[ identifier ]]. */
33986 : 6 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE)
33987 : 3 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_SQUARE)
33988 : 3 : && (cp_lexer_nth_token_is (parser->lexer, 3, CPP_NAME)
33989 : 0 : || cp_lexer_nth_token_is (parser->lexer, 3, CPP_KEYWORD))
33990 : 3 : && cp_lexer_nth_token_is (parser->lexer, 4, CPP_CLOSE_SQUARE)
33991 : 9 : && cp_lexer_nth_token_is (parser->lexer, 5, CPP_CLOSE_SQUARE))
33992 : : {
33993 : 3 : cp_lexer_consume_token (parser->lexer);
33994 : 3 : cp_lexer_consume_token (parser->lexer);
33995 : 3 : cp_lexer_consume_token (parser->lexer);
33996 : 3 : cp_lexer_consume_token (parser->lexer);
33997 : 3 : cp_lexer_consume_token (parser->lexer);
33998 : : }
33999 : : else
34000 : 6 : while (cp_next_tokens_can_be_gnu_attribute_p (parser)
34001 : 6 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
34002 : : {
34003 : 3 : cp_lexer_consume_token (parser->lexer);
34004 : 3 : if (cp_parser_cache_group (parser, CPP_CLOSE_PAREN, /*depth=*/0))
34005 : : break;
34006 : : }
34007 : : }
34008 : :
34009 : : /* Handle function try blocks. */
34010 : 64057969 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
34011 : : {
34012 : 111 : cp_lexer_consume_token (parser->lexer);
34013 : 111 : function_try_block = true;
34014 : : }
34015 : : /* We can have braced-init-list mem-initializers before the fn body. */
34016 : 64057969 : if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
34017 : : {
34018 : 12455347 : cp_lexer_consume_token (parser->lexer);
34019 : 43177978 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
34020 : : {
34021 : : /* cache_group will stop after an un-nested { } pair, too. */
34022 : 18267295 : if (cp_parser_cache_group (parser, CPP_CLOSE_PAREN, /*depth=*/0))
34023 : : break;
34024 : :
34025 : : /* variadic mem-inits have ... after the ')'. */
34026 : 18267284 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
34027 : 33 : cp_lexer_consume_token (parser->lexer);
34028 : : }
34029 : : }
34030 : 64057969 : cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
34031 : : /* Handle function try blocks. */
34032 : 64057969 : if (function_try_block)
34033 : 234 : while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
34034 : 123 : cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
34035 : 64057969 : last = parser->lexer->next_token;
34036 : :
34037 : : /* Save away the inline definition; we will process it when the
34038 : : class is complete. */
34039 : 64057969 : DECL_PENDING_INLINE_INFO (fn) = cp_token_cache_new (first, last);
34040 : 64057969 : DECL_PENDING_INLINE_P (fn) = 1;
34041 : :
34042 : : /* We need to know that this was defined in the class, so that
34043 : : friend templates are handled correctly. */
34044 : 64057969 : DECL_INITIALIZED_IN_CLASS_P (fn) = 1;
34045 : :
34046 : : /* Add FN to the queue of functions to be parsed later. */
34047 : 64057969 : vec_safe_push (unparsed_funs_with_definitions, fn);
34048 : :
34049 : 64057969 : check_module_decl_linkage (fn);
34050 : :
34051 : 64057969 : return fn;
34052 : : }
34053 : :
34054 : : /* Save the tokens that make up the in-class initializer for a non-static
34055 : : data member. Returns a DEFERRED_PARSE. */
34056 : :
34057 : : static tree
34058 : 1024947 : cp_parser_save_nsdmi (cp_parser* parser)
34059 : : {
34060 : 1024947 : return cp_parser_cache_defarg (parser, /*nsdmi=*/true);
34061 : : }
34062 : :
34063 : : /* Parse a template-argument-list, as well as the trailing ">" (but
34064 : : not the opening "<"). See cp_parser_template_argument_list for the
34065 : : return value. */
34066 : :
34067 : : static tree
34068 : 186638124 : cp_parser_enclosed_template_argument_list (cp_parser* parser)
34069 : : {
34070 : 186638124 : tree arguments;
34071 : 186638124 : tree saved_scope;
34072 : 186638124 : tree saved_qualifying_scope;
34073 : 186638124 : tree saved_object_scope;
34074 : 186638124 : bool saved_greater_than_is_operator_p;
34075 : :
34076 : : /* [temp.names]
34077 : :
34078 : : When parsing a template-id, the first non-nested `>' is taken as
34079 : : the end of the template-argument-list rather than a greater-than
34080 : : operator. */
34081 : 186638124 : saved_greater_than_is_operator_p
34082 : 186638124 : = parser->greater_than_is_operator_p;
34083 : 186638124 : parser->greater_than_is_operator_p = false;
34084 : : /* Parsing the argument list may modify SCOPE, so we save it
34085 : : here. */
34086 : 186638124 : saved_scope = parser->scope;
34087 : 186638124 : saved_qualifying_scope = parser->qualifying_scope;
34088 : 186638124 : saved_object_scope = parser->object_scope;
34089 : : /* We need to evaluate the template arguments, even though this
34090 : : template-id may be nested within a "sizeof". */
34091 : 186638124 : cp_evaluated ev;
34092 : : /* Parse the template-argument-list itself. */
34093 : 186638124 : if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER)
34094 : : || cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT)
34095 : : || cp_lexer_next_token_is (parser->lexer, CPP_GREATER_EQ)
34096 : : || cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT_EQ))
34097 : : {
34098 : 492051 : arguments = make_tree_vec (0);
34099 : 492051 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (arguments, 0);
34100 : : }
34101 : : else
34102 : 186146073 : arguments = cp_parser_template_argument_list (parser);
34103 : : /* Look for the `>' that ends the template-argument-list. If we find
34104 : : a '>>' instead, it's probably just a typo. */
34105 : 186638124 : if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
34106 : : {
34107 : 11802776 : if (cxx_dialect != cxx98)
34108 : : {
34109 : : /* In C++0x, a `>>' in a template argument list or cast
34110 : : expression is considered to be two separate `>'
34111 : : tokens. So, change the current token to a `>', but don't
34112 : : consume it: it will be consumed later when the outer
34113 : : template argument list (or cast expression) is parsed.
34114 : : Note that this replacement of `>' for `>>' is necessary
34115 : : even if we are parsing tentatively: in the tentative
34116 : : case, after calling
34117 : : cp_parser_enclosed_template_argument_list we will always
34118 : : throw away all of the template arguments and the first
34119 : : closing `>', either because the template argument list
34120 : : was erroneous or because we are replacing those tokens
34121 : : with a CPP_TEMPLATE_ID token. The second `>' (which will
34122 : : not have been thrown away) is needed either to close an
34123 : : outer template argument list or to complete a new-style
34124 : : cast. */
34125 : 11802768 : cp_token *token = cp_lexer_peek_token (parser->lexer);
34126 : 11802768 : token->type = CPP_GREATER;
34127 : : }
34128 : 8 : else if (!saved_greater_than_is_operator_p)
34129 : : {
34130 : : /* If we're in a nested template argument list, the '>>' has
34131 : : to be a typo for '> >'. We emit the error message, but we
34132 : : continue parsing and we push a '>' as next token, so that
34133 : : the argument list will be parsed correctly. Note that the
34134 : : global source location is still on the token before the
34135 : : '>>', so we need to say explicitly where we want it. */
34136 : 6 : cp_token *token = cp_lexer_peek_token (parser->lexer);
34137 : 6 : gcc_rich_location richloc (token->location);
34138 : 6 : richloc.add_fixit_replace ("> >");
34139 : 6 : error_at (&richloc, "%<>>%> should be %<> >%> "
34140 : : "within a nested template argument list");
34141 : :
34142 : 6 : token->type = CPP_GREATER;
34143 : 6 : }
34144 : : else
34145 : : {
34146 : : /* If this is not a nested template argument list, the '>>'
34147 : : is a typo for '>'. Emit an error message and continue.
34148 : : Same deal about the token location, but here we can get it
34149 : : right by consuming the '>>' before issuing the diagnostic. */
34150 : 2 : cp_token *token = cp_lexer_consume_token (parser->lexer);
34151 : 2 : error_at (token->location,
34152 : : "spurious %<>>%>, use %<>%> to terminate "
34153 : : "a template argument list");
34154 : : }
34155 : : }
34156 : : /* Similarly for >>= and >=. */
34157 : 174835348 : else if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER_EQ)
34158 : 174835348 : || cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT_EQ))
34159 : : {
34160 : 12 : cp_token *token = cp_lexer_consume_token (parser->lexer);
34161 : 12 : gcc_rich_location richloc (token->location);
34162 : 12 : enum cpp_ttype new_type;
34163 : 12 : const char *replacement;
34164 : 12 : if (token->type == CPP_GREATER_EQ)
34165 : : {
34166 : : replacement = "> =";
34167 : : new_type = CPP_EQ;
34168 : : }
34169 : 6 : else if (!saved_greater_than_is_operator_p)
34170 : : {
34171 : 3 : if (cxx_dialect != cxx98)
34172 : : replacement = ">> =";
34173 : : else
34174 : 1 : replacement = "> > =";
34175 : : new_type = CPP_GREATER;
34176 : : }
34177 : : else
34178 : : {
34179 : : replacement = "> >=";
34180 : : new_type = CPP_GREATER_EQ;
34181 : : }
34182 : 12 : richloc.add_fixit_replace (replacement);
34183 : 12 : error_at (&richloc, "%qs should be %qs to terminate a template "
34184 : : "argument list",
34185 : 12 : cpp_type2name (token->type, token->flags), replacement);
34186 : 12 : token->type = new_type;
34187 : 12 : }
34188 : : else
34189 : 174835336 : cp_parser_require_end_of_template_parameter_list (parser);
34190 : : /* The `>' token might be a greater-than operator again now. */
34191 : 186638124 : parser->greater_than_is_operator_p
34192 : 186638124 : = saved_greater_than_is_operator_p;
34193 : : /* Restore the SAVED_SCOPE. */
34194 : 186638124 : parser->scope = saved_scope;
34195 : 186638124 : parser->qualifying_scope = saved_qualifying_scope;
34196 : 186638124 : parser->object_scope = saved_object_scope;
34197 : :
34198 : 186638124 : return arguments;
34199 : 186638124 : }
34200 : :
34201 : : /* MEMBER_FUNCTION is a member function, or a friend. If default
34202 : : arguments, or the body of the function have not yet been parsed,
34203 : : parse them now. */
34204 : :
34205 : : static void
34206 : 80701914 : cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function)
34207 : : {
34208 : 80701914 : auto_timevar tv (TV_PARSE_INMETH);
34209 : :
34210 : : /* If this member is a template, get the underlying
34211 : : FUNCTION_DECL. */
34212 : 80701914 : if (DECL_FUNCTION_TEMPLATE_P (member_function))
34213 : : member_function = DECL_TEMPLATE_RESULT (member_function);
34214 : :
34215 : : /* There should not be any class definitions in progress at this
34216 : : point; the bodies of members are only parsed outside of all class
34217 : : definitions. */
34218 : 80701914 : gcc_assert (parser->num_classes_being_defined == 0);
34219 : : /* While we're parsing the member functions we might encounter more
34220 : : classes. We want to handle them right away, but we don't want
34221 : : them getting mixed up with functions that are currently in the
34222 : : queue. */
34223 : 80701914 : push_unparsed_function_queues (parser);
34224 : :
34225 : : /* Make sure that any template parameters are in scope. */
34226 : 80701914 : maybe_begin_member_template_processing (member_function);
34227 : :
34228 : : /* If the body of the function has not yet been parsed, parse it
34229 : : now. Except if the tokens have been purged (PR c++/39751). */
34230 : 80701914 : if (DECL_PENDING_INLINE_P (member_function)
34231 : 80701914 : && !DECL_PENDING_INLINE_INFO (member_function)->first->purged_p)
34232 : : {
34233 : 64058120 : tree function_scope;
34234 : 64058120 : cp_token_cache *tokens;
34235 : :
34236 : : /* The function is no longer pending; we are processing it. */
34237 : 64058120 : tokens = DECL_PENDING_INLINE_INFO (member_function);
34238 : 64058120 : DECL_PENDING_INLINE_INFO (member_function) = NULL;
34239 : 64058120 : DECL_PENDING_INLINE_P (member_function) = 0;
34240 : :
34241 : : /* If this is a local class, enter the scope of the containing
34242 : : function. */
34243 : 64058120 : function_scope = current_function_decl;
34244 : 64058120 : if (function_scope)
34245 : 324284 : push_function_context ();
34246 : :
34247 : : /* Push the body of the function onto the lexer stack. */
34248 : 64058120 : cp_parser_push_lexer_for_tokens (parser, tokens);
34249 : :
34250 : : /* Let the front end know that we going to be defining this
34251 : : function. */
34252 : 64058120 : start_preparsed_function (member_function, NULL_TREE,
34253 : : SF_PRE_PARSED | SF_INCLASS_INLINE);
34254 : :
34255 : : /* #pragma omp declare reduction needs special parsing. */
34256 : 64058120 : if (DECL_OMP_DECLARE_REDUCTION_P (member_function))
34257 : : {
34258 : 185 : parser->lexer->in_pragma = true;
34259 : 185 : cp_parser_omp_declare_reduction_exprs (member_function, parser);
34260 : 185 : finish_function (/*inline_p=*/true);
34261 : 185 : cp_check_omp_declare_reduction (member_function);
34262 : : }
34263 : : else
34264 : : /* Now, parse the body of the function. */
34265 : 64057935 : cp_parser_function_definition_after_declarator (parser,
34266 : : /*inline_p=*/true);
34267 : :
34268 : : /* Leave the scope of the containing function. */
34269 : 64058120 : if (function_scope)
34270 : 324284 : pop_function_context ();
34271 : 64058120 : cp_parser_pop_lexer (parser);
34272 : : }
34273 : :
34274 : : /* Remove any template parameters from the symbol table. */
34275 : 80701914 : maybe_end_member_template_processing ();
34276 : :
34277 : : /* Restore the queue. */
34278 : 80701914 : pop_unparsed_function_queues (parser);
34279 : 80701914 : }
34280 : :
34281 : : /* If DECL contains any default args, remember it on the unparsed
34282 : : functions queue. */
34283 : :
34284 : : static void
34285 : 87701097 : cp_parser_save_default_args (cp_parser* parser, tree decl)
34286 : : {
34287 : 87701097 : tree probe;
34288 : :
34289 : 87701097 : for (probe = TYPE_ARG_TYPES (TREE_TYPE (decl));
34290 : 340898994 : probe;
34291 : 253197897 : probe = TREE_CHAIN (probe))
34292 : 257993765 : if (TREE_PURPOSE (probe))
34293 : : {
34294 : 4795868 : cp_default_arg_entry entry = {current_class_type, decl};
34295 : 4795868 : vec_safe_push (unparsed_funs_with_default_args, entry);
34296 : 4795868 : break;
34297 : : }
34298 : :
34299 : : /* Remember if there is a noexcept-specifier to post process. */
34300 : 87701097 : tree spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl));
34301 : 118111196 : if (UNPARSED_NOEXCEPT_SPEC_P (spec))
34302 : 2381294 : vec_safe_push (unparsed_noexcepts, decl);
34303 : :
34304 : : /* Contracts are deferred. */
34305 : 95611815 : for (tree attr = DECL_ATTRIBUTES (decl); attr; attr = TREE_CHAIN (attr))
34306 : 7910881 : if (cxx_contract_attribute_p (attr))
34307 : : {
34308 : 163 : vec_safe_push (unparsed_contracts, decl);
34309 : 163 : break;
34310 : : }
34311 : 87701097 : }
34312 : :
34313 : : /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
34314 : : which is either a FIELD_DECL or PARM_DECL. Parse it and return
34315 : : the result. For a PARM_DECL, PARMTYPE is the corresponding type
34316 : : from the parameter-type-list. */
34317 : :
34318 : : static tree
34319 : 6751039 : cp_parser_late_parse_one_default_arg (cp_parser *parser, tree decl,
34320 : : tree default_arg, tree parmtype)
34321 : : {
34322 : 6751039 : cp_token_cache *tokens;
34323 : 6751039 : tree parsed_arg;
34324 : :
34325 : 6751039 : if (default_arg == error_mark_node)
34326 : : return error_mark_node;
34327 : :
34328 : : /* Push the saved tokens for the default argument onto the parser's
34329 : : lexer stack. */
34330 : 6751030 : tokens = DEFPARSE_TOKENS (default_arg);
34331 : 6751030 : cp_parser_push_lexer_for_tokens (parser, tokens);
34332 : :
34333 : 6751030 : start_lambda_scope (decl);
34334 : :
34335 : : /* Parse the default argument. */
34336 : 6751030 : parsed_arg = cp_parser_initializer (parser);
34337 : 6751030 : if (BRACE_ENCLOSED_INITIALIZER_P (parsed_arg))
34338 : 870139 : maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
34339 : :
34340 : 6751030 : finish_lambda_scope ();
34341 : :
34342 : 6751030 : if (parsed_arg == error_mark_node)
34343 : 119 : cp_parser_skip_to_end_of_statement (parser);
34344 : :
34345 : 6751030 : if (!processing_template_decl)
34346 : : {
34347 : : /* In a non-template class, check conversions now. In a template,
34348 : : we'll wait and instantiate these as needed. */
34349 : 1038988 : if (TREE_CODE (decl) == PARM_DECL)
34350 : 684398 : parsed_arg = check_default_argument (parmtype, parsed_arg,
34351 : : tf_warning_or_error);
34352 : 354590 : else if (maybe_reject_flexarray_init (decl, parsed_arg))
34353 : 33 : parsed_arg = error_mark_node;
34354 : : else
34355 : 354557 : parsed_arg = digest_nsdmi_init (decl, parsed_arg, tf_warning_or_error);
34356 : : }
34357 : :
34358 : : /* If the token stream has not been completely used up, then
34359 : : there was extra junk after the end of the default
34360 : : argument. */
34361 : 6751030 : if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF))
34362 : : {
34363 : 7 : if (TREE_CODE (decl) == PARM_DECL)
34364 : 4 : cp_parser_error (parser, "expected %<,%>");
34365 : : else
34366 : 3 : cp_parser_error (parser, "expected %<;%>");
34367 : : }
34368 : :
34369 : : /* Revert to the main lexer. */
34370 : 6751030 : cp_parser_pop_lexer (parser);
34371 : :
34372 : 6751030 : return parsed_arg;
34373 : : }
34374 : :
34375 : : /* FIELD is a non-static data member with an initializer which we saved for
34376 : : later; parse it now. */
34377 : :
34378 : : static void
34379 : 1024879 : cp_parser_late_parsing_nsdmi (cp_parser *parser, tree field)
34380 : : {
34381 : 1024879 : tree def;
34382 : :
34383 : 1024879 : maybe_begin_member_template_processing (field);
34384 : :
34385 : 1024879 : push_unparsed_function_queues (parser);
34386 : 1024879 : def = cp_parser_late_parse_one_default_arg (parser, field,
34387 : 1024879 : DECL_INITIAL (field),
34388 : : NULL_TREE);
34389 : 1024879 : pop_unparsed_function_queues (parser);
34390 : :
34391 : 1024879 : maybe_end_member_template_processing ();
34392 : :
34393 : 1024879 : DECL_INITIAL (field) = def;
34394 : 1024879 : }
34395 : :
34396 : : /* FN is a FUNCTION_DECL which may contains a parameter with an
34397 : : unparsed DEFERRED_PARSE. Parse the default args now. This function
34398 : : assumes that the current scope is the scope in which the default
34399 : : argument should be processed. */
34400 : :
34401 : : static void
34402 : 4795868 : cp_parser_late_parsing_default_args (cp_parser *parser, tree fn)
34403 : : {
34404 : 4795868 : unsigned char saved_local_variables_forbidden_p;
34405 : :
34406 : : /* While we're parsing the default args, we might (due to the
34407 : : statement expression extension) encounter more classes. We want
34408 : : to handle them right away, but we don't want them getting mixed
34409 : : up with default args that are currently in the queue. */
34410 : 4795868 : push_unparsed_function_queues (parser);
34411 : :
34412 : : /* Local variable names (and the `this' keyword) may not appear
34413 : : in a default argument. */
34414 : 4795868 : saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
34415 : 4795868 : parser->local_variables_forbidden_p = LOCAL_VARS_AND_THIS_FORBIDDEN;
34416 : :
34417 : 4795868 : push_defarg_context (fn);
34418 : :
34419 : 4795868 : begin_scope (sk_function_parms, fn);
34420 : :
34421 : : /* Gather the PARM_DECLs into a vec so we can keep track of them when
34422 : : pushdecl clears DECL_CHAIN. */
34423 : 4795868 : releasing_vec parms;
34424 : 20993357 : for (tree parmdecl = DECL_ARGUMENTS (fn); parmdecl;
34425 : 16197489 : parmdecl = DECL_CHAIN (parmdecl))
34426 : 16197489 : vec_safe_push (parms, parmdecl);
34427 : :
34428 : 4795868 : tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
34429 : 4795868 : for (int i = 0;
34430 : 20993357 : parm && parm != void_list_node;
34431 : 16197489 : parm = TREE_CHAIN (parm),
34432 : : ++i)
34433 : : {
34434 : 16197489 : tree default_arg = TREE_PURPOSE (parm);
34435 : 16197489 : tree parsed_arg;
34436 : :
34437 : 16197489 : tree parmdecl = parms[i];
34438 : 16197489 : pushdecl (parmdecl);
34439 : :
34440 : 16197489 : if (!default_arg)
34441 : 10471302 : continue;
34442 : :
34443 : 5726187 : if (TREE_CODE (default_arg) != DEFERRED_PARSE)
34444 : : /* This can happen for a friend declaration for a function
34445 : : already declared with default arguments. */
34446 : 27 : continue;
34447 : :
34448 : 5726160 : parsed_arg
34449 : 11452320 : = cp_parser_late_parse_one_default_arg (parser, parmdecl,
34450 : : default_arg,
34451 : 5726160 : TREE_VALUE (parm));
34452 : 5726160 : TREE_PURPOSE (parm) = parsed_arg;
34453 : :
34454 : : /* Update any instantiations we've already created. */
34455 : 5726169 : for (tree copy : DEFPARSE_INSTANTIATIONS (default_arg))
34456 : 3 : TREE_PURPOSE (copy) = parsed_arg;
34457 : : }
34458 : :
34459 : 4795868 : pop_bindings_and_leave_scope ();
34460 : :
34461 : : /* Restore DECL_CHAINs after clobbering by pushdecl. */
34462 : 4795868 : parm = NULL_TREE;
34463 : 20993357 : for (int i = parms->length () - 1; i >= 0; --i)
34464 : : {
34465 : 16197489 : DECL_CHAIN (parms[i]) = parm;
34466 : 16197489 : parm = parms[i];
34467 : : }
34468 : :
34469 : 4795868 : pop_defarg_context ();
34470 : :
34471 : : /* Make sure no default arg is missing. */
34472 : 4795868 : check_default_args (fn);
34473 : :
34474 : : /* Restore the state of local_variables_forbidden_p. */
34475 : 4795868 : parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
34476 : :
34477 : : /* Restore the queue. */
34478 : 4795868 : pop_unparsed_function_queues (parser);
34479 : 4795868 : }
34480 : :
34481 : : /* Subroutine of cp_parser_sizeof_operand, for handling C++11
34482 : :
34483 : : sizeof ... ( identifier )
34484 : :
34485 : : where the 'sizeof' token has already been consumed. */
34486 : :
34487 : : static tree
34488 : 1105681 : cp_parser_sizeof_pack (cp_parser *parser)
34489 : : {
34490 : : /* Consume the `...'. */
34491 : 1105681 : cp_lexer_consume_token (parser->lexer);
34492 : 1105681 : maybe_warn_variadic_templates ();
34493 : :
34494 : 1105681 : matching_parens parens;
34495 : 1105681 : bool paren = cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN);
34496 : 1105681 : if (paren)
34497 : 1105675 : parens.consume_open (parser);
34498 : : else
34499 : 6 : permerror (cp_lexer_peek_token (parser->lexer)->location,
34500 : : "%<sizeof...%> argument must be surrounded by parentheses");
34501 : :
34502 : 1105681 : cp_token *token = cp_lexer_peek_token (parser->lexer);
34503 : 1105681 : tree name = cp_parser_identifier (parser);
34504 : 1105681 : if (name == error_mark_node)
34505 : : return error_mark_node;
34506 : : /* The name is not qualified. */
34507 : 1105681 : parser->scope = NULL_TREE;
34508 : 1105681 : parser->qualifying_scope = NULL_TREE;
34509 : 1105681 : parser->object_scope = NULL_TREE;
34510 : 1105681 : tree expr = cp_parser_lookup_name_simple (parser, name, token->location);
34511 : 1105681 : if (expr == error_mark_node)
34512 : 0 : cp_parser_name_lookup_error (parser, name, expr, NLE_NULL,
34513 : : token->location);
34514 : 1105681 : if (TREE_CODE (expr) == TYPE_DECL || TREE_CODE (expr) == TEMPLATE_DECL)
34515 : 1073253 : expr = TREE_TYPE (expr);
34516 : 32428 : else if (TREE_CODE (expr) == CONST_DECL)
34517 : 32327 : expr = DECL_INITIAL (expr);
34518 : 1105681 : expr = make_pack_expansion (expr);
34519 : 1105681 : if (expr != error_mark_node)
34520 : 1105678 : PACK_EXPANSION_SIZEOF_P (expr) = true;
34521 : :
34522 : 1105681 : if (paren)
34523 : 1105675 : parens.require_close (parser);
34524 : :
34525 : : return expr;
34526 : : }
34527 : :
34528 : : /* Parse the operand of `sizeof' (or a similar operator). Returns
34529 : : either a TYPE or an expression, depending on the form of the
34530 : : input. The KEYWORD indicates which kind of expression we have
34531 : : encountered. */
34532 : :
34533 : : static tree
34534 : 4573024 : cp_parser_sizeof_operand (cp_parser* parser, enum rid keyword)
34535 : : {
34536 : 4573024 : tree expr = NULL_TREE;
34537 : 4573024 : const char *saved_message;
34538 : 4573024 : const char *saved_message_arg;
34539 : 4573024 : bool saved_integral_constant_expression_p;
34540 : 4573024 : bool saved_non_integral_constant_expression_p;
34541 : :
34542 : : /* If it's a `...', then we are computing the length of a parameter
34543 : : pack. */
34544 : 4573024 : if (keyword == RID_SIZEOF
34545 : 4573024 : && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
34546 : 1105681 : return cp_parser_sizeof_pack (parser);
34547 : :
34548 : : /* Types cannot be defined in a `sizeof' expression. Save away the
34549 : : old message. */
34550 : 3467343 : saved_message = parser->type_definition_forbidden_message;
34551 : 3467343 : saved_message_arg = parser->type_definition_forbidden_message_arg;
34552 : 3467343 : parser->type_definition_forbidden_message
34553 : 3467343 : = G_("types may not be defined in %qs expressions");
34554 : 3467343 : parser->type_definition_forbidden_message_arg
34555 : 3467343 : = IDENTIFIER_POINTER (ridpointers[keyword]);
34556 : :
34557 : : /* The restrictions on constant-expressions do not apply inside
34558 : : sizeof expressions. */
34559 : 3467343 : saved_integral_constant_expression_p
34560 : 3467343 : = parser->integral_constant_expression_p;
34561 : 3467343 : saved_non_integral_constant_expression_p
34562 : 3467343 : = parser->non_integral_constant_expression_p;
34563 : 3467343 : parser->integral_constant_expression_p = false;
34564 : :
34565 : 3467343 : auto cleanup = make_temp_override
34566 : 3467343 : (parser->auto_is_implicit_function_template_parm_p, false);
34567 : :
34568 : : /* Do not actually evaluate the expression. */
34569 : 3467343 : ++cp_unevaluated_operand;
34570 : 3467343 : ++c_inhibit_evaluation_warnings;
34571 : : /* If it's a `(', then we might be looking at the type-id
34572 : : construction. */
34573 : 3467343 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
34574 : : {
34575 : 3462168 : tree type = NULL_TREE;
34576 : :
34577 : 3462168 : tentative_firewall firewall (parser);
34578 : :
34579 : : /* We can't be sure yet whether we're looking at a type-id or an
34580 : : expression. */
34581 : 3462168 : cp_parser_parse_tentatively (parser);
34582 : :
34583 : 3462168 : matching_parens parens;
34584 : 3462168 : parens.consume_open (parser);
34585 : :
34586 : : /* Note: as a GNU Extension, compound literals are considered
34587 : : postfix-expressions as they are in C99, so they are valid
34588 : : arguments to sizeof. See comment in cp_parser_cast_expression
34589 : : for details. */
34590 : 3462168 : if (cp_parser_compound_literal_p (parser))
34591 : 3462189 : cp_parser_simulate_error (parser);
34592 : : else
34593 : : {
34594 : 3462147 : type_id_in_expr_sentinel s (parser);
34595 : : /* Look for the type-id. */
34596 : 3462147 : type = cp_parser_type_id (parser);
34597 : : /* Look for the closing `)'. */
34598 : 3462147 : parens.require_close (parser);
34599 : 3462147 : }
34600 : :
34601 : : /* If all went well, then we're done. */
34602 : 3462168 : if (cp_parser_parse_definitely (parser))
34603 : : expr = type;
34604 : : else
34605 : : {
34606 : : /* Commit to the tentative_firewall so we get syntax errors. */
34607 : 601190 : cp_parser_commit_to_tentative_parse (parser);
34608 : :
34609 : 601190 : expr = cp_parser_unary_expression (parser);
34610 : : }
34611 : 3462168 : }
34612 : : else
34613 : 5175 : expr = cp_parser_unary_expression (parser);
34614 : :
34615 : : /* Go back to evaluating expressions. */
34616 : 3467343 : --cp_unevaluated_operand;
34617 : 3467343 : --c_inhibit_evaluation_warnings;
34618 : :
34619 : : /* And restore the old one. */
34620 : 3467343 : parser->type_definition_forbidden_message = saved_message;
34621 : 3467343 : parser->type_definition_forbidden_message_arg = saved_message_arg;
34622 : 3467343 : parser->integral_constant_expression_p
34623 : 3467343 : = saved_integral_constant_expression_p;
34624 : 3467343 : parser->non_integral_constant_expression_p
34625 : 3467343 : = saved_non_integral_constant_expression_p;
34626 : :
34627 : 3467343 : return expr;
34628 : 3467343 : }
34629 : :
34630 : : /* If the current declaration has no declarator, return true. */
34631 : :
34632 : : static bool
34633 : 57445259 : cp_parser_declares_only_class_p (cp_parser *parser)
34634 : : {
34635 : : /* If the next token is a `;' or a `,' then there is no
34636 : : declarator. */
34637 : 57445259 : return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
34638 : 57445259 : || cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
34639 : : }
34640 : :
34641 : : /* Update the DECL_SPECS to reflect the storage class indicated by
34642 : : KEYWORD. */
34643 : :
34644 : : static void
34645 : 47454269 : cp_parser_set_storage_class (cp_parser *parser,
34646 : : cp_decl_specifier_seq *decl_specs,
34647 : : enum rid keyword,
34648 : : cp_token *token)
34649 : : {
34650 : 47454269 : cp_storage_class storage_class;
34651 : :
34652 : 47454269 : switch (keyword)
34653 : : {
34654 : : case RID_AUTO:
34655 : : storage_class = sc_auto;
34656 : : break;
34657 : 486 : case RID_REGISTER:
34658 : 486 : storage_class = sc_register;
34659 : 486 : break;
34660 : 17929204 : case RID_STATIC:
34661 : 17929204 : storage_class = sc_static;
34662 : 17929204 : break;
34663 : 29297661 : case RID_EXTERN:
34664 : 29297661 : storage_class = sc_extern;
34665 : 29297661 : break;
34666 : 226902 : case RID_MUTABLE:
34667 : 226902 : storage_class = sc_mutable;
34668 : 226902 : break;
34669 : 0 : default:
34670 : 0 : gcc_unreachable ();
34671 : : }
34672 : :
34673 : 47454269 : if (parser->in_unbraced_linkage_specification_p)
34674 : : {
34675 : 13 : error_at (token->location, "invalid use of %qD in linkage specification",
34676 : 13 : ridpointers[keyword]);
34677 : 13 : return;
34678 : : }
34679 : 47454256 : else if (decl_specs->storage_class != sc_none)
34680 : : {
34681 : 27 : if (decl_specs->conflicting_specifiers_p)
34682 : : return;
34683 : 27 : gcc_rich_location richloc (token->location);
34684 : 27 : richloc.add_location_if_nearby (*global_dc,
34685 : : decl_specs->locations[ds_storage_class]);
34686 : 27 : if (decl_specs->storage_class == storage_class)
34687 : 9 : error_at (&richloc, "duplicate %qD specifier", ridpointers[keyword]);
34688 : : else
34689 : 18 : error_at (&richloc,
34690 : : "%qD specifier conflicts with %qs",
34691 : 18 : ridpointers[keyword],
34692 : 18 : cp_storage_class_name[decl_specs->storage_class]);
34693 : 27 : decl_specs->conflicting_specifiers_p = true;
34694 : 27 : return;
34695 : 27 : }
34696 : :
34697 : 47454229 : if ((keyword == RID_EXTERN || keyword == RID_STATIC)
34698 : 47226841 : && decl_spec_seq_has_spec_p (decl_specs, ds_thread)
34699 : 47454241 : && decl_specs->gnu_thread_keyword_p)
34700 : : {
34701 : 9 : pedwarn (decl_specs->locations[ds_thread], 0,
34702 : 9 : "%<__thread%> before %qD", ridpointers[keyword]);
34703 : : }
34704 : :
34705 : 47454229 : decl_specs->storage_class = storage_class;
34706 : 47454229 : set_and_check_decl_spec_loc (decl_specs, ds_storage_class, token);
34707 : :
34708 : : /* A storage class specifier cannot be applied alongside a typedef
34709 : : specifier. If there is a typedef specifier present then set
34710 : : conflicting_specifiers_p which will trigger an error later
34711 : : on in grokdeclarator. */
34712 : 47454229 : if (decl_spec_seq_has_spec_p (decl_specs, ds_typedef)
34713 : 47454229 : && !decl_specs->conflicting_specifiers_p)
34714 : : {
34715 : 10 : gcc_rich_location richloc (token->location);
34716 : 10 : richloc.add_location_if_nearby (*global_dc,
34717 : : decl_specs->locations[ds_typedef]);
34718 : 10 : error_at (&richloc,
34719 : : "%qD specifier conflicts with %<typedef%>",
34720 : 10 : ridpointers[keyword]);
34721 : 10 : decl_specs->conflicting_specifiers_p = true;
34722 : 10 : }
34723 : : }
34724 : :
34725 : : /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
34726 : : is true, the type is a class or enum definition. */
34727 : :
34728 : : static void
34729 : 917920805 : cp_parser_set_decl_spec_type (cp_decl_specifier_seq *decl_specs,
34730 : : tree type_spec,
34731 : : cp_token *token,
34732 : : bool type_definition_p)
34733 : : {
34734 : 917920805 : decl_specs->any_specifiers_p = true;
34735 : :
34736 : : /* If the user tries to redeclare bool, char8_t, char16_t, char32_t, or
34737 : : wchar_t (with, for example, in "typedef int wchar_t;") we remember that
34738 : : this is what happened. In system headers, we ignore these
34739 : : declarations so that G++ can work with system headers that are not
34740 : : C++-safe. */
34741 : 917920805 : if (decl_spec_seq_has_spec_p (decl_specs, ds_typedef)
34742 : 25395937 : && !type_definition_p
34743 : 24933508 : && TYPE_P (type_spec)
34744 : 10841206 : && (type_spec == boolean_type_node
34745 : 10676615 : || type_spec == char8_type_node
34746 : 10667476 : || type_spec == char16_type_node
34747 : 10605707 : || type_spec == char32_type_node
34748 : 10543938 : || extended_float_type_p (type_spec)
34749 : 10512223 : || type_spec == wchar_type_node)
34750 : 918320559 : && (decl_specs->type
34751 : 399736 : || decl_spec_seq_has_spec_p (decl_specs, ds_long)
34752 : 399733 : || decl_spec_seq_has_spec_p (decl_specs, ds_short)
34753 : 399733 : || decl_spec_seq_has_spec_p (decl_specs, ds_unsigned)
34754 : 399733 : || decl_spec_seq_has_spec_p (decl_specs, ds_signed)))
34755 : : {
34756 : 21 : decl_specs->redefined_builtin_type = type_spec;
34757 : 21 : set_and_check_decl_spec_loc (decl_specs,
34758 : : ds_redefined_builtin_type_spec,
34759 : : token);
34760 : 21 : if (!decl_specs->type)
34761 : : {
34762 : 3 : decl_specs->type = type_spec;
34763 : 3 : decl_specs->type_definition_p = false;
34764 : 3 : set_and_check_decl_spec_loc (decl_specs,ds_type_spec, token);
34765 : : }
34766 : : }
34767 : 917920784 : else if (decl_specs->type)
34768 : 1577 : decl_specs->multiple_types_p = true;
34769 : : else
34770 : : {
34771 : 917919207 : decl_specs->type = type_spec;
34772 : 917919207 : decl_specs->type_definition_p = type_definition_p;
34773 : 917919207 : decl_specs->redefined_builtin_type = NULL_TREE;
34774 : 917919207 : set_and_check_decl_spec_loc (decl_specs, ds_type_spec, token);
34775 : : }
34776 : 917920805 : }
34777 : :
34778 : : /* True iff TOKEN is the GNU keyword __thread. */
34779 : :
34780 : : static bool
34781 : 19470 : token_is__thread (cp_token *token)
34782 : : {
34783 : 19470 : gcc_assert (token->keyword == RID_THREAD);
34784 : 19470 : return id_equal (token->u.value, "__thread");
34785 : : }
34786 : :
34787 : : /* Set the location for a declarator specifier and check if it is
34788 : : duplicated.
34789 : :
34790 : : DECL_SPECS is the sequence of declarator specifiers onto which to
34791 : : set the location.
34792 : :
34793 : : DS is the single declarator specifier to set which location is to
34794 : : be set onto the existing sequence of declarators.
34795 : :
34796 : : LOCATION is the location for the declarator specifier to
34797 : : consider. */
34798 : :
34799 : : static void
34800 : 1236238927 : set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
34801 : : cp_decl_spec ds, cp_token *token)
34802 : : {
34803 : 1236238927 : gcc_assert (ds < ds_last);
34804 : :
34805 : 1236238927 : if (decl_specs == NULL)
34806 : : return;
34807 : :
34808 : 1236084246 : location_t location = token->location;
34809 : :
34810 : 1236084246 : if (decl_specs->locations[ds] == 0)
34811 : : {
34812 : 1233037748 : decl_specs->locations[ds] = location;
34813 : 1233037748 : if (ds == ds_thread)
34814 : 19458 : decl_specs->gnu_thread_keyword_p = token_is__thread (token);
34815 : : }
34816 : : else
34817 : : {
34818 : 3046498 : if (ds == ds_long)
34819 : : {
34820 : 3046375 : if (decl_specs->locations[ds_long_long] != 0)
34821 : 3 : error_at (location,
34822 : : "%<long long long%> is too long for GCC");
34823 : : else
34824 : : {
34825 : 3046372 : decl_specs->locations[ds_long_long] = location;
34826 : 3046372 : pedwarn_cxx98 (location,
34827 : : OPT_Wlong_long,
34828 : : "ISO C++ 1998 does not support %<long long%>");
34829 : : }
34830 : : }
34831 : 123 : else if (ds == ds_thread)
34832 : : {
34833 : 12 : bool gnu = token_is__thread (token);
34834 : 12 : gcc_rich_location richloc (location);
34835 : 12 : if (gnu != decl_specs->gnu_thread_keyword_p)
34836 : : {
34837 : 6 : richloc.add_range (decl_specs->locations[ds_thread]);
34838 : 6 : error_at (&richloc,
34839 : : "both %<__thread%> and %<thread_local%> specified");
34840 : : }
34841 : : else
34842 : : {
34843 : 6 : richloc.add_fixit_remove ();
34844 : 6 : error_at (&richloc, "duplicate %qD", token->u.value);
34845 : : }
34846 : 12 : }
34847 : : else
34848 : : {
34849 : : /* These correspond to cp-tree.h:cp_decl_spec,
34850 : : changes here should also be reflected there. */
34851 : 111 : static const char *const decl_spec_names[] = {
34852 : : "signed",
34853 : : "unsigned",
34854 : : "short",
34855 : : "long",
34856 : : "const",
34857 : : "volatile",
34858 : : "restrict",
34859 : : "inline",
34860 : : "virtual",
34861 : : "explicit",
34862 : : "friend",
34863 : : "typedef",
34864 : : "using",
34865 : : "constexpr",
34866 : : "__complex",
34867 : : "constinit",
34868 : : "consteval",
34869 : : "this"
34870 : : };
34871 : 111 : gcc_rich_location richloc (location);
34872 : 111 : richloc.add_fixit_remove ();
34873 : 111 : error_at (&richloc, "duplicate %qs", decl_spec_names[ds]);
34874 : 111 : }
34875 : : }
34876 : : }
34877 : :
34878 : : /* Return true iff the declarator specifier DS is present in the
34879 : : sequence of declarator specifiers DECL_SPECS. */
34880 : :
34881 : : bool
34882 : 20434510423 : decl_spec_seq_has_spec_p (const cp_decl_specifier_seq * decl_specs,
34883 : : cp_decl_spec ds)
34884 : : {
34885 : 20434510423 : gcc_assert (ds < ds_last);
34886 : :
34887 : 20434510423 : if (decl_specs == NULL)
34888 : : return false;
34889 : :
34890 : 20434510423 : return decl_specs->locations[ds] != 0;
34891 : : }
34892 : :
34893 : : /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
34894 : : Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
34895 : :
34896 : : static bool
34897 : 446265977 : cp_parser_friend_p (const cp_decl_specifier_seq *decl_specifiers)
34898 : : {
34899 : 446265977 : return decl_spec_seq_has_spec_p (decl_specifiers, ds_friend);
34900 : : }
34901 : :
34902 : : /* Issue an error message indicating that TOKEN_DESC was expected.
34903 : : If KEYWORD is true, it indicated this function is called by
34904 : : cp_parser_require_keword and the required token can only be
34905 : : a indicated keyword.
34906 : :
34907 : : If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
34908 : : within any error as the location of an "opening" token matching
34909 : : the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
34910 : : RT_CLOSE_PAREN). */
34911 : :
34912 : : static void
34913 : 2689 : cp_parser_required_error (cp_parser *parser,
34914 : : required_token token_desc,
34915 : : bool keyword,
34916 : : location_t matching_location)
34917 : : {
34918 : 5378 : if (cp_parser_simulate_error (parser))
34919 : 0 : return;
34920 : :
34921 : 2689 : const char *gmsgid = NULL;
34922 : 2689 : switch (token_desc)
34923 : : {
34924 : 0 : case RT_NEW:
34925 : 0 : gmsgid = G_("expected %<new%>");
34926 : 0 : break;
34927 : 0 : case RT_DELETE:
34928 : 0 : gmsgid = G_("expected %<delete%>");
34929 : 0 : break;
34930 : 0 : case RT_RETURN:
34931 : 0 : gmsgid = G_("expected %<return%>");
34932 : 0 : break;
34933 : 2 : case RT_WHILE:
34934 : 2 : gmsgid = G_("expected %<while%>");
34935 : 2 : break;
34936 : 0 : case RT_EXTERN:
34937 : 0 : gmsgid = G_("expected %<extern%>");
34938 : 0 : break;
34939 : 0 : case RT_STATIC_ASSERT:
34940 : 0 : gmsgid = G_("expected %<static_assert%>");
34941 : 0 : break;
34942 : 0 : case RT_DECLTYPE:
34943 : 0 : gmsgid = G_("expected %<decltype%>");
34944 : 0 : break;
34945 : 0 : case RT_OPERATOR:
34946 : 0 : gmsgid = G_("expected %<operator%>");
34947 : 0 : break;
34948 : 0 : case RT_CLASS:
34949 : 0 : gmsgid = G_("expected %<class%>");
34950 : 0 : break;
34951 : 0 : case RT_TEMPLATE:
34952 : 0 : gmsgid = G_("expected %<template%>");
34953 : 0 : break;
34954 : 0 : case RT_NAMESPACE:
34955 : 0 : gmsgid = G_("expected %<namespace%>");
34956 : 0 : break;
34957 : 0 : case RT_USING:
34958 : 0 : gmsgid = G_("expected %<using%>");
34959 : 0 : break;
34960 : 0 : case RT_ASM:
34961 : 0 : gmsgid = G_("expected %<asm%>");
34962 : 0 : break;
34963 : 0 : case RT_TRY:
34964 : 0 : gmsgid = G_("expected %<try%>");
34965 : 0 : break;
34966 : 3 : case RT_CATCH:
34967 : 3 : gmsgid = G_("expected %<catch%>");
34968 : 3 : break;
34969 : 0 : case RT_THROW:
34970 : 0 : gmsgid = G_("expected %<throw%>");
34971 : 0 : break;
34972 : 0 : case RT_AUTO:
34973 : 0 : gmsgid = G_("expected %<auto%>");
34974 : 0 : break;
34975 : 0 : case RT_LABEL:
34976 : 0 : gmsgid = G_("expected %<__label__%>");
34977 : 0 : break;
34978 : 0 : case RT_AT_TRY:
34979 : 0 : gmsgid = G_("expected %<@try%>");
34980 : 0 : break;
34981 : 0 : case RT_AT_SYNCHRONIZED:
34982 : 0 : gmsgid = G_("expected %<@synchronized%>");
34983 : 0 : break;
34984 : 0 : case RT_AT_THROW:
34985 : 0 : gmsgid = G_("expected %<@throw%>");
34986 : 0 : break;
34987 : 0 : case RT_TRANSACTION_ATOMIC:
34988 : 0 : gmsgid = G_("expected %<__transaction_atomic%>");
34989 : 0 : break;
34990 : 0 : case RT_TRANSACTION_RELAXED:
34991 : 0 : gmsgid = G_("expected %<__transaction_relaxed%>");
34992 : 0 : break;
34993 : 0 : case RT_CO_YIELD:
34994 : 0 : gmsgid = G_("expected %<co_yield%>");
34995 : 0 : break;
34996 : : default:
34997 : : break;
34998 : : }
34999 : :
35000 : 2689 : if (!gmsgid && !keyword)
35001 : : {
35002 : 2684 : switch (token_desc)
35003 : : {
35004 : : case RT_SEMICOLON:
35005 : : gmsgid = G_("expected %<;%>");
35006 : : break;
35007 : 243 : case RT_OPEN_PAREN:
35008 : 243 : gmsgid = G_("expected %<(%>");
35009 : 243 : break;
35010 : : case RT_CLOSE_BRACE:
35011 : : gmsgid = G_("expected %<}%>");
35012 : : break;
35013 : 180 : case RT_OPEN_BRACE:
35014 : 180 : gmsgid = G_("expected %<{%>");
35015 : 180 : break;
35016 : 106 : case RT_CLOSE_SQUARE:
35017 : 106 : gmsgid = G_("expected %<]%>");
35018 : 106 : break;
35019 : 0 : case RT_OPEN_SQUARE:
35020 : 0 : gmsgid = G_("expected %<[%>");
35021 : 0 : break;
35022 : 30 : case RT_COMMA:
35023 : 30 : gmsgid = G_("expected %<,%>");
35024 : 30 : break;
35025 : 0 : case RT_SCOPE:
35026 : 0 : gmsgid = G_("expected %<::%>");
35027 : 0 : break;
35028 : 4 : case RT_LESS:
35029 : 4 : gmsgid = G_("expected %<<%>");
35030 : 4 : break;
35031 : 81 : case RT_GREATER:
35032 : 81 : gmsgid = G_("expected %<>%>");
35033 : 81 : break;
35034 : 27 : case RT_EQ:
35035 : 27 : gmsgid = G_("expected %<=%>");
35036 : 27 : break;
35037 : 0 : case RT_ELLIPSIS:
35038 : 0 : gmsgid = G_("expected %<...%>");
35039 : 0 : break;
35040 : 0 : case RT_MULT:
35041 : 0 : gmsgid = G_("expected %<*%>");
35042 : 0 : break;
35043 : 0 : case RT_COMPL:
35044 : 0 : gmsgid = G_("expected %<~%>");
35045 : 0 : break;
35046 : 57 : case RT_COLON:
35047 : 57 : gmsgid = G_("expected %<:%>");
35048 : 57 : break;
35049 : 15 : case RT_COLON_SCOPE:
35050 : 15 : gmsgid = G_("expected %<:%> or %<::%>");
35051 : 15 : break;
35052 : 1082 : case RT_CLOSE_PAREN:
35053 : 1082 : gmsgid = G_("expected %<)%>");
35054 : 1082 : break;
35055 : 9 : case RT_COMMA_CLOSE_PAREN:
35056 : 9 : gmsgid = G_("expected %<,%> or %<)%>");
35057 : 9 : break;
35058 : 142 : case RT_PRAGMA_EOL:
35059 : 142 : gmsgid = G_("expected end of line");
35060 : 142 : break;
35061 : 252 : case RT_NAME:
35062 : 252 : gmsgid = G_("expected identifier");
35063 : 252 : break;
35064 : 0 : case RT_SELECT:
35065 : 0 : gmsgid = G_("expected selection-statement");
35066 : 0 : break;
35067 : 0 : case RT_ITERATION:
35068 : 0 : gmsgid = G_("expected iteration-statement");
35069 : 0 : break;
35070 : 0 : case RT_JUMP:
35071 : 0 : gmsgid = G_("expected jump-statement");
35072 : 0 : break;
35073 : 0 : case RT_CLASS_KEY:
35074 : 0 : gmsgid = G_("expected class-key");
35075 : 0 : break;
35076 : 0 : case RT_CLASS_TYPENAME_TEMPLATE:
35077 : 0 : gmsgid = G_("expected %<class%>, %<typename%>, or %<template%>");
35078 : 0 : break;
35079 : 0 : default:
35080 : 0 : gcc_unreachable ();
35081 : : }
35082 : : }
35083 : :
35084 : 2515 : if (gmsgid)
35085 : 2689 : cp_parser_error_1 (parser, gmsgid, token_desc, matching_location);
35086 : : }
35087 : :
35088 : :
35089 : : /* If the next token is of the indicated TYPE, consume it. Otherwise,
35090 : : issue an error message indicating that TOKEN_DESC was expected.
35091 : :
35092 : : Returns the token consumed, if the token had the appropriate type.
35093 : : Otherwise, returns NULL.
35094 : :
35095 : : If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
35096 : : within any error as the location of an "opening" token matching
35097 : : the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
35098 : : RT_CLOSE_PAREN). */
35099 : :
35100 : : static cp_token *
35101 : 9341996847 : cp_parser_require (cp_parser* parser,
35102 : : enum cpp_ttype type,
35103 : : required_token token_desc,
35104 : : location_t matching_location)
35105 : : {
35106 : 9341996847 : if (cp_lexer_next_token_is (parser->lexer, type))
35107 : 7823399161 : return cp_lexer_consume_token (parser->lexer);
35108 : : else
35109 : : {
35110 : : /* Output the MESSAGE -- unless we're parsing tentatively. */
35111 : 1518595003 : if (!cp_parser_simulate_error (parser))
35112 : 2683 : cp_parser_required_error (parser, token_desc, /*keyword=*/false,
35113 : : matching_location);
35114 : 1518597686 : return NULL;
35115 : : }
35116 : : }
35117 : :
35118 : : /* Skip an entire parameter list from start to finish. The next token must
35119 : : be the initial "<" of the parameter list. Returns true on success and
35120 : : false otherwise. */
35121 : :
35122 : : static bool
35123 : 237420 : cp_parser_skip_entire_template_parameter_list (cp_parser* parser)
35124 : : {
35125 : : /* Consume the "<" because cp_parser_skip_to_end_of_template_parameter_list
35126 : : requires it. */
35127 : 237420 : cp_lexer_consume_token (parser->lexer);
35128 : 237420 : return cp_parser_skip_to_end_of_template_parameter_list (parser);
35129 : : }
35130 : :
35131 : : /* Ensure we are at the end of a template parameter list. If we are, return.
35132 : : If we are not, something has gone wrong, in which case issue an error and
35133 : : skip to end of the parameter list. */
35134 : :
35135 : : static void
35136 : 258682423 : cp_parser_require_end_of_template_parameter_list (cp_parser* parser)
35137 : : {
35138 : : /* Are we ready, yet? If not, issue error message. */
35139 : 258682423 : if (cp_parser_require (parser, CPP_GREATER, RT_GREATER))
35140 : : return;
35141 : :
35142 : 286 : cp_parser_skip_to_end_of_template_parameter_list (parser);
35143 : : }
35144 : :
35145 : : /* You should only call this function from inside a template parameter list
35146 : : (i.e. the current token should at least be the initial "<" of the
35147 : : parameter list). If you are skipping the entire list, it may be better to
35148 : : use cp_parser_skip_entire_template_parameter_list.
35149 : :
35150 : : Tokens are skipped until the final ">" is found, or if we see
35151 : : '{', '}', ';', or if we find an unbalanced ')' or ']'.
35152 : :
35153 : : Returns true if we successfully reached the end, and false if
35154 : : something unexpected happened (e.g. end of file). */
35155 : :
35156 : : static bool
35157 : 237706 : cp_parser_skip_to_end_of_template_parameter_list (cp_parser* parser)
35158 : : {
35159 : : /* Current level of '< ... >'. */
35160 : 237706 : unsigned level = 0;
35161 : : /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
35162 : 237706 : unsigned nesting_depth = 0;
35163 : :
35164 : : /* Skip tokens until the desired token is found. */
35165 : 1937288 : while (true)
35166 : : {
35167 : : /* Peek at the next token. */
35168 : 1087497 : switch (cp_lexer_peek_token (parser->lexer)->type)
35169 : : {
35170 : 22854 : case CPP_LESS:
35171 : 22854 : if (!nesting_depth)
35172 : 2698 : ++level;
35173 : : break;
35174 : :
35175 : 2 : case CPP_RSHIFT:
35176 : 2 : if (cxx_dialect == cxx98)
35177 : : /* C++0x views the `>>' operator as two `>' tokens, but
35178 : : C++98 does not. */
35179 : : break;
35180 : 0 : else if (!nesting_depth && level-- == 0)
35181 : : {
35182 : : /* We've hit a `>>' where the first `>' closes the
35183 : : template argument list, and the second `>' is
35184 : : spurious. Just consume the `>>' and stop; we've
35185 : : already produced at least one error. */
35186 : 0 : cp_lexer_consume_token (parser->lexer);
35187 : 0 : return false;
35188 : : }
35189 : : /* Fall through for C++0x, so we handle the second `>' in
35190 : : the `>>'. */
35191 : 89522 : gcc_fallthrough ();
35192 : :
35193 : 89522 : case CPP_GREATER:
35194 : 89522 : if (!nesting_depth && level-- == 0)
35195 : : {
35196 : : /* We've reached the token we want, consume it and stop. */
35197 : 86829 : cp_lexer_consume_token (parser->lexer);
35198 : 86829 : return true;
35199 : : }
35200 : : break;
35201 : :
35202 : 48415 : case CPP_OPEN_PAREN:
35203 : 48415 : case CPP_OPEN_SQUARE:
35204 : 48415 : ++nesting_depth;
35205 : 48415 : break;
35206 : :
35207 : 118374 : case CPP_CLOSE_PAREN:
35208 : 118374 : case CPP_CLOSE_SQUARE:
35209 : 118374 : if (nesting_depth-- == 0)
35210 : : return false;
35211 : : break;
35212 : :
35213 : : case CPP_EOF:
35214 : : case CPP_PRAGMA_EOL:
35215 : : case CPP_SEMICOLON:
35216 : : case CPP_OPEN_BRACE:
35217 : : case CPP_CLOSE_BRACE:
35218 : : /* The '>' was probably forgotten, don't look further. */
35219 : : return false;
35220 : :
35221 : : default:
35222 : : break;
35223 : : }
35224 : :
35225 : : /* Consume this token. */
35226 : 849791 : cp_lexer_consume_token (parser->lexer);
35227 : : }
35228 : : }
35229 : :
35230 : : /* If the next token is the indicated keyword, consume it. Otherwise,
35231 : : issue an error message indicating that TOKEN_DESC was expected.
35232 : :
35233 : : Returns the token consumed, if the token had the appropriate type.
35234 : : Otherwise, returns NULL. */
35235 : :
35236 : : static cp_token *
35237 : 118831983 : cp_parser_require_keyword (cp_parser* parser,
35238 : : enum rid keyword,
35239 : : required_token token_desc)
35240 : : {
35241 : 118831983 : cp_token *token = cp_parser_require (parser, CPP_KEYWORD, token_desc);
35242 : :
35243 : 118831983 : if (token && token->keyword != keyword)
35244 : : {
35245 : 0 : cp_parser_required_error (parser, token_desc, /*keyword=*/true,
35246 : : UNKNOWN_LOCATION);
35247 : 0 : return NULL;
35248 : : }
35249 : :
35250 : : return token;
35251 : : }
35252 : :
35253 : : /* Returns TRUE iff TOKEN is a token that can begin the body of a
35254 : : function-definition. */
35255 : :
35256 : : static bool
35257 : 198529193 : cp_parser_token_starts_function_definition_p (cp_token* token)
35258 : : {
35259 : 198529193 : return (/* An ordinary function-body begins with an `{'. */
35260 : 198529193 : token->type == CPP_OPEN_BRACE
35261 : : /* A ctor-initializer begins with a `:'. */
35262 : 110441228 : || token->type == CPP_COLON
35263 : : /* A function-try-block begins with `try'. */
35264 : 97264254 : || token->keyword == RID_TRY
35265 : : /* A function-transaction-block begins with `__transaction_atomic'
35266 : : or `__transaction_relaxed'. */
35267 : 97263980 : || token->keyword == RID_TRANSACTION_ATOMIC
35268 : 97263959 : || token->keyword == RID_TRANSACTION_RELAXED
35269 : : /* The named return value extension begins with `return'. */
35270 : 295793152 : || token->keyword == RID_RETURN);
35271 : : }
35272 : :
35273 : : /* Returns TRUE iff the next token is the ":" or "{" beginning a class
35274 : : definition. */
35275 : :
35276 : : static bool
35277 : 38814062 : cp_parser_next_token_starts_class_definition_p (cp_parser *parser)
35278 : : {
35279 : 38814062 : cp_token *token;
35280 : :
35281 : 38814062 : token = cp_lexer_peek_token (parser->lexer);
35282 : 38814062 : return (token->type == CPP_OPEN_BRACE
35283 : 38814062 : || (token->type == CPP_COLON
35284 : 10052555 : && !parser->colon_doesnt_start_class_def_p));
35285 : : }
35286 : :
35287 : : /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
35288 : : C++0x) ending a template-argument. */
35289 : :
35290 : : static bool
35291 : 341190567 : cp_parser_next_token_ends_template_argument_p (cp_parser *parser)
35292 : : {
35293 : 341190567 : cp_token *token;
35294 : :
35295 : 341190567 : token = cp_lexer_peek_token (parser->lexer);
35296 : 341190567 : return (token->type == CPP_COMMA
35297 : : || token->type == CPP_GREATER
35298 : : || token->type == CPP_ELLIPSIS
35299 : 51147146 : || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)
35300 : : /* For better diagnostics, treat >>= like that too, that
35301 : : shouldn't appear non-nested in template arguments. */
35302 : 40758890 : || token->type == CPP_RSHIFT_EQ);
35303 : : }
35304 : :
35305 : : /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
35306 : : (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
35307 : :
35308 : : static bool
35309 : 7773012432 : cp_parser_nth_token_starts_template_argument_list_p (cp_parser * parser,
35310 : : size_t n)
35311 : : {
35312 : 7773012432 : cp_token *token;
35313 : :
35314 : 7773012432 : token = cp_lexer_peek_nth_token (parser->lexer, n);
35315 : 7773012432 : if (token->type == CPP_LESS)
35316 : : return true;
35317 : : /* Check for the sequence `<::' in the original code. It would be lexed as
35318 : : `[:', where `[' is a digraph, and there is no whitespace before
35319 : : `:'. */
35320 : 6894688955 : if (token->type == CPP_OPEN_SQUARE && token->flags & DIGRAPH)
35321 : : {
35322 : 6 : cp_token *token2;
35323 : 6 : token2 = cp_lexer_peek_nth_token (parser->lexer, n+1);
35324 : 6 : if (token2->type == CPP_COLON && !(token2->flags & PREV_WHITE))
35325 : 3 : return true;
35326 : : }
35327 : : return false;
35328 : : }
35329 : :
35330 : : /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
35331 : : or none_type otherwise. */
35332 : :
35333 : : static enum tag_types
35334 : 47774317 : cp_parser_token_is_class_key (cp_token* token)
35335 : : {
35336 : 47774317 : switch (token->keyword)
35337 : : {
35338 : : case RID_CLASS:
35339 : : return class_type;
35340 : 35933234 : case RID_STRUCT:
35341 : 35933234 : return record_type;
35342 : 536144 : case RID_UNION:
35343 : 536144 : return union_type;
35344 : :
35345 : 0 : default:
35346 : 0 : return none_type;
35347 : : }
35348 : : }
35349 : :
35350 : : /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
35351 : : or none_type otherwise or if the token is null. */
35352 : :
35353 : : static enum tag_types
35354 : 305651 : cp_parser_token_is_type_parameter_key (cp_token* token)
35355 : : {
35356 : 305651 : if (!token)
35357 : : return none_type;
35358 : :
35359 : 305651 : switch (token->keyword)
35360 : : {
35361 : : case RID_CLASS:
35362 : : return class_type;
35363 : 0 : case RID_TYPENAME:
35364 : 0 : return typename_type;
35365 : :
35366 : : default:
35367 : : return none_type;
35368 : : }
35369 : : }
35370 : :
35371 : : /* Diagnose redundant enum-keys. */
35372 : :
35373 : : static void
35374 : 26108 : cp_parser_maybe_warn_enum_key (cp_parser *parser, location_t key_loc,
35375 : : tree type, rid scoped_key)
35376 : : {
35377 : 26108 : if (!warn_redundant_tags)
35378 : 26011 : return;
35379 : :
35380 : 151 : tree type_decl = TYPE_MAIN_DECL (type);
35381 : 151 : tree name = DECL_NAME (type_decl);
35382 : : /* Look up the NAME to see if it unambiguously refers to the TYPE. */
35383 : 151 : push_deferring_access_checks (dk_no_check);
35384 : 151 : tree decl = cp_parser_lookup_name_simple (parser, name, input_location);
35385 : 151 : pop_deferring_access_checks ();
35386 : :
35387 : : /* The enum-key is redundant for uses of the TYPE that are not
35388 : : declarations and for which name lookup returns just the type
35389 : : itself. */
35390 : 151 : if (decl != type_decl)
35391 : : return;
35392 : :
35393 : 121 : if (scoped_key != RID_CLASS
35394 : 121 : && scoped_key != RID_STRUCT
35395 : 79 : && current_lang_name != lang_name_cplusplus
35396 : 33 : && current_namespace == global_namespace)
35397 : : {
35398 : : /* Avoid issuing the diagnostic for apparently redundant (unscoped)
35399 : : enum tag in shared C/C++ code in files (such as headers) included
35400 : : in the main source file. */
35401 : 27 : const line_map_ordinary *map = NULL;
35402 : 27 : linemap_resolve_location (line_table, key_loc,
35403 : : LRK_MACRO_DEFINITION_LOCATION,
35404 : : &map);
35405 : 27 : if (!MAIN_FILE_P (map))
35406 : 24 : return;
35407 : : }
35408 : :
35409 : 97 : gcc_rich_location richloc (key_loc);
35410 : 97 : richloc.add_fixit_remove (key_loc);
35411 : 174 : warning_at (&richloc, OPT_Wredundant_tags,
35412 : : "redundant enum-key %<enum%s%> in reference to %q#T",
35413 : : (scoped_key == RID_CLASS ? " class"
35414 : 77 : : scoped_key == RID_STRUCT ? " struct" : ""), type);
35415 : 97 : }
35416 : :
35417 : : /* Describes the set of declarations of a struct, class, or class template
35418 : : or its specializations. Used for -Wmismatched-tags. */
35419 : :
35420 : : class class_decl_loc_t
35421 : : {
35422 : : public:
35423 : :
35424 : 685 : class_decl_loc_t ()
35425 : 685 : : locvec (), idxdef (), def_class_key ()
35426 : : {
35427 : 685 : locvec.create (4);
35428 : 685 : }
35429 : :
35430 : : /* Constructs an object for a single declaration of a class with
35431 : : CLASS_KEY at the current location in the current function (or
35432 : : at another scope). KEY_REDUNDANT is true if the class-key may
35433 : : be omitted in the current context without an ambiguity with
35434 : : another symbol with the same name.
35435 : : DEF_P is true for a class declaration that is a definition.
35436 : : CURLOC is the associated location. */
35437 : 685 : class_decl_loc_t (tag_types class_key, bool key_redundant, bool def_p,
35438 : : location_t curloc = input_location)
35439 : 685 : : locvec (), idxdef (def_p ? 0 : UINT_MAX), def_class_key (class_key)
35440 : : {
35441 : 685 : locvec.create (4);
35442 : 685 : class_key_loc_t ckl (current_function_decl, curloc, class_key,
35443 : 685 : key_redundant);
35444 : 1370 : locvec.quick_push (ckl);
35445 : 685 : }
35446 : :
35447 : : /* Copy, assign, and destroy the object. Necessary because LOCVEC
35448 : : isn't safely copyable and assignable and doesn't release storage
35449 : : on its own. */
35450 : 442 : class_decl_loc_t (const class_decl_loc_t &rhs)
35451 : 442 : : locvec (rhs.locvec.copy ()), idxdef (rhs.idxdef),
35452 : 442 : def_class_key (rhs.def_class_key)
35453 : : { }
35454 : :
35455 : 685 : class_decl_loc_t& operator= (const class_decl_loc_t &rhs)
35456 : : {
35457 : 685 : if (this == &rhs)
35458 : : return *this;
35459 : 685 : locvec.release ();
35460 : 685 : locvec = rhs.locvec.copy ();
35461 : 685 : idxdef = rhs.idxdef;
35462 : 685 : def_class_key = rhs.def_class_key;
35463 : 685 : return *this;
35464 : : }
35465 : :
35466 : 1812 : ~class_decl_loc_t ()
35467 : : {
35468 : 1127 : locvec.release ();
35469 : 685 : }
35470 : :
35471 : : /* Issues -Wmismatched-tags for a single class. */
35472 : : void diag_mismatched_tags (tree);
35473 : :
35474 : : /* Issues -Wmismatched-tags for all classes. */
35475 : : static void diag_mismatched_tags ();
35476 : :
35477 : : /* Adds TYPE_DECL to the collection of class decls and diagnoses
35478 : : redundant tags (if -Wredundant-tags is enabled). */
35479 : : static void add (cp_parser *, location_t, tag_types, tree, bool, bool);
35480 : :
35481 : : /* Either adds this decl to the collection of class decls
35482 : : or diagnoses it, whichever is appropriate. */
35483 : : void add_or_diag_mismatched_tag (tree, tag_types, bool, bool);
35484 : :
35485 : : private:
35486 : :
35487 : 306 : tree function (unsigned i) const
35488 : : {
35489 : 306 : return locvec[i].func;
35490 : : }
35491 : :
35492 : 546 : location_t location (unsigned i) const
35493 : : {
35494 : 240 : return locvec[i].loc;
35495 : : }
35496 : :
35497 : 306 : bool key_redundant (unsigned i) const
35498 : : {
35499 : 306 : return locvec[i].key_redundant;
35500 : : }
35501 : :
35502 : 1140 : tag_types class_key (unsigned i) const
35503 : : {
35504 : 2280 : return locvec[i].class_key;
35505 : : }
35506 : :
35507 : : /* True if a definition for the class has been seen. */
35508 : 336 : bool def_p () const
35509 : : {
35510 : 1008 : return idxdef < locvec.length ();
35511 : : }
35512 : :
35513 : : /* The location of a single mention of a class type with the given
35514 : : class-key. */
35515 : : struct class_key_loc_t
35516 : : {
35517 : 1315 : class_key_loc_t (tree func, location_t loc, tag_types key, bool redundant)
35518 : 685 : : func (func), loc (loc), class_key (key), key_redundant (redundant)
35519 : : { }
35520 : :
35521 : : /* The function the type is mentioned in. */
35522 : : tree func;
35523 : : /* The exact location. */
35524 : : location_t loc;
35525 : : /* The class-key used in the mention of the type. */
35526 : : tag_types class_key;
35527 : : /* True when the class-key could be omitted at this location
35528 : : without an ambiguity with another symbol of the same name. */
35529 : : bool key_redundant;
35530 : : };
35531 : : /* Avoid using auto_vec here since it's not safe to copy due to pr90904. */
35532 : : vec <class_key_loc_t> locvec;
35533 : : /* LOCVEC index of the definition or UINT_MAX if none exists. */
35534 : : unsigned idxdef;
35535 : : /* The class-key the class was last declared with or none_type when
35536 : : it has been declared with a mismatched key. */
35537 : : tag_types def_class_key;
35538 : :
35539 : : /* A mapping between a TYPE_DECL for a class and the class_decl_loc_t
35540 : : description above. */
35541 : : typedef hash_map<tree_decl_hash, class_decl_loc_t> class_to_loc_map_t;
35542 : : static class_to_loc_map_t class2loc;
35543 : : };
35544 : :
35545 : : class_decl_loc_t::class_to_loc_map_t class_decl_loc_t::class2loc;
35546 : :
35547 : : /* Issue an error message if the CLASS_KEY does not match the TYPE.
35548 : : DEF_P is expected to be set for a definition of class TYPE. DECL_P
35549 : : is set for a declaration of class TYPE and clear for a reference to
35550 : : it that is not a declaration of it. */
35551 : :
35552 : : static void
35553 : 35865271 : cp_parser_check_class_key (cp_parser *parser, location_t key_loc,
35554 : : tag_types class_key, tree type, bool def_p,
35555 : : bool decl_p)
35556 : : {
35557 : 35865271 : if (type == error_mark_node)
35558 : : return;
35559 : :
35560 : 35864311 : bool seen_as_union = TREE_CODE (type) == UNION_TYPE;
35561 : 35864311 : if (seen_as_union != (class_key == union_type))
35562 : : {
35563 : 18 : auto_diagnostic_group d;
35564 : 24 : if (permerror (input_location, "%qs tag used in naming %q#T",
35565 : : class_key == union_type ? "union"
35566 : 6 : : class_key == record_type ? "struct" : "class",
35567 : : type))
35568 : 18 : inform (DECL_SOURCE_LOCATION (TYPE_NAME (type)),
35569 : : "%q#T was previously declared here", type);
35570 : 18 : return;
35571 : 18 : }
35572 : :
35573 : 35864293 : if (!warn_mismatched_tags && !warn_redundant_tags)
35574 : : return;
35575 : :
35576 : : /* Only consider the true class-keys below and ignore typename_type,
35577 : : etc. that are not C++ class-keys. */
35578 : 1580 : if (class_key != class_type
35579 : : && class_key != record_type
35580 : 1580 : && class_key != union_type)
35581 : : return;
35582 : :
35583 : 1559 : class_decl_loc_t::add (parser, key_loc, class_key, type, def_p, decl_p);
35584 : : }
35585 : :
35586 : : /* Returns the template or specialization of one to which the RECORD_TYPE
35587 : : TYPE corresponds. */
35588 : :
35589 : : static tree
35590 : 78 : specialization_of (tree type)
35591 : : {
35592 : 78 : tree ret = type;
35593 : :
35594 : : /* Determine the template or its partial specialization to which TYPE
35595 : : corresponds. */
35596 : 78 : if (tree ti = most_specialized_partial_spec (type, tf_none))
35597 : 42 : if (ti != error_mark_node)
35598 : 42 : ret = TREE_TYPE (TI_TEMPLATE (ti));
35599 : :
35600 : 78 : if (ret == type)
35601 : 36 : ret = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (type);
35602 : :
35603 : 78 : return TYPE_MAIN_DECL (ret);
35604 : : }
35605 : :
35606 : :
35607 : : /* Adds the class TYPE to the collection of class decls and diagnoses
35608 : : redundant tags (if -Wredundant-tags is enabled).
35609 : : DEF_P is expected to be set for a definition of class TYPE. DECL_P
35610 : : is set for a (likely, based on syntactic context) declaration of class
35611 : : TYPE and clear for a reference to it that is not a declaration of it. */
35612 : :
35613 : : void
35614 : 1559 : class_decl_loc_t::add (cp_parser *parser, location_t key_loc,
35615 : : tag_types class_key, tree type, bool def_p, bool decl_p)
35616 : : {
35617 : 1559 : tree type_decl = TYPE_MAIN_DECL (type);
35618 : 1559 : tree name = DECL_NAME (type_decl);
35619 : : /* Look up the NAME to see if it unambiguously refers to the TYPE
35620 : : and set KEY_REDUNDANT if so. */
35621 : 1559 : push_deferring_access_checks (dk_no_check);
35622 : 1559 : tree decl = cp_parser_lookup_name_simple (parser, name, input_location);
35623 : 1559 : pop_deferring_access_checks ();
35624 : :
35625 : : /* The class-key is redundant for uses of the CLASS_TYPE that are
35626 : : neither definitions of it nor declarations, and for which name
35627 : : lookup returns just the type itself. */
35628 : 1559 : bool key_redundant = (!def_p && !decl_p
35629 : 1559 : && (decl == type_decl
35630 : 375 : || TREE_CODE (decl) == TEMPLATE_DECL
35631 : 39 : || (CLASS_TYPE_P (type)
35632 : 36 : && TYPE_BEING_DEFINED (type))));
35633 : :
35634 : 1559 : if (key_redundant
35635 : 1559 : && class_key != class_type
35636 : 435 : && current_lang_name != lang_name_cplusplus
35637 : 57 : && current_namespace == global_namespace)
35638 : : {
35639 : : /* Avoid issuing the diagnostic for apparently redundant struct
35640 : : and union class-keys in shared C/C++ code in files (such as
35641 : : headers) included in the main source file. */
35642 : 45 : const line_map_ordinary *map = NULL;
35643 : 45 : linemap_resolve_location (line_table, key_loc,
35644 : : LRK_MACRO_DEFINITION_LOCATION,
35645 : : &map);
35646 : 45 : if (!MAIN_FILE_P (map))
35647 : 39 : key_redundant = false;
35648 : : }
35649 : :
35650 : : /* Set if a declaration of TYPE has previously been seen or if it must
35651 : : exist in a precompiled header. */
35652 : 1559 : bool exist;
35653 : 1559 : class_decl_loc_t *rdl = &class2loc.get_or_insert (type_decl, &exist);
35654 : 1559 : if (!exist)
35655 : : {
35656 : 685 : tree type = TREE_TYPE (type_decl);
35657 : 685 : if (def_p || !COMPLETE_TYPE_P (type))
35658 : : {
35659 : : /* TYPE_DECL is the first declaration or definition of the type
35660 : : (outside precompiled headers -- see below). Just create
35661 : : a new entry for it and return unless it's a declaration
35662 : : involving a template that may need to be diagnosed by
35663 : : -Wredundant-tags. */
35664 : 679 : *rdl = class_decl_loc_t (class_key, false, def_p);
35665 : 679 : if (TREE_CODE (decl) != TEMPLATE_DECL)
35666 : 929 : return;
35667 : : }
35668 : : else
35669 : : {
35670 : : /* TYPE was previously defined in some unknown precompiled header.
35671 : : Simply add a record of its definition at an unknown location and
35672 : : proceed below to add a reference to it at the current location.
35673 : : (Declarations in precompiled headers that are not definitions
35674 : : are ignored.) */
35675 : 6 : tag_types def_key
35676 : 6 : = CLASSTYPE_DECLARED_CLASS (type) ? class_type : record_type;
35677 : 6 : location_t def_loc = DECL_SOURCE_LOCATION (type_decl);
35678 : 6 : *rdl = class_decl_loc_t (def_key, false, true, def_loc);
35679 : 6 : exist = true;
35680 : : }
35681 : : }
35682 : :
35683 : : /* A prior declaration of TYPE_DECL has been seen. */
35684 : :
35685 : 1255 : if (key_redundant)
35686 : : {
35687 : 670 : gcc_rich_location richloc (key_loc);
35688 : 670 : richloc.add_fixit_remove (key_loc);
35689 : 1286 : warning_at (&richloc, OPT_Wredundant_tags,
35690 : : "redundant class-key %qs in reference to %q#T",
35691 : : class_key == union_type ? "union"
35692 : 616 : : class_key == record_type ? "struct" : "class",
35693 : : type);
35694 : 670 : }
35695 : :
35696 : 1255 : if (!exist)
35697 : : /* Do nothing if this is the first declaration of the type. */
35698 : : return;
35699 : :
35700 : 880 : if (rdl->idxdef != UINT_MAX && rdl->def_class_key == class_key)
35701 : : /* Do nothing if the class-key in this declaration matches
35702 : : the definition. */
35703 : : return;
35704 : :
35705 : 630 : rdl->add_or_diag_mismatched_tag (type_decl, class_key, key_redundant,
35706 : : def_p);
35707 : : }
35708 : :
35709 : : /* Either adds this DECL corresponding to the TYPE_DECL to the collection
35710 : : of class decls or diagnoses it, whichever is appropriate. */
35711 : :
35712 : : void
35713 : 630 : class_decl_loc_t::add_or_diag_mismatched_tag (tree type_decl,
35714 : : tag_types class_key,
35715 : : bool redundant,
35716 : : bool def_p)
35717 : : {
35718 : : /* Reset the CLASS_KEY associated with this type on mismatch.
35719 : : This is an optimization that lets the diagnostic code skip
35720 : : over classes that use the same class-key in all declarations. */
35721 : 630 : if (def_class_key != class_key)
35722 : 429 : def_class_key = none_type;
35723 : :
35724 : : /* Set IDXDEF to the index of the vector corresponding to
35725 : : the definition. */
35726 : 630 : if (def_p)
35727 : 84 : idxdef = locvec.length ();
35728 : :
35729 : : /* Append a record of this declaration to the vector. */
35730 : 630 : class_key_loc_t ckl (current_function_decl, input_location, class_key,
35731 : 630 : redundant);
35732 : 630 : locvec.safe_push (ckl);
35733 : :
35734 : 630 : if (idxdef == UINT_MAX)
35735 : 504 : return;
35736 : :
35737 : : /* As a space optimization diagnose declarations of a class
35738 : : whose definition has been seen and purge the LOCVEC of
35739 : : all entries except the definition. */
35740 : 126 : diag_mismatched_tags (type_decl);
35741 : 126 : if (idxdef)
35742 : : {
35743 : 42 : class_decl_loc_t::class_key_loc_t ent = locvec[idxdef];
35744 : 42 : locvec.release ();
35745 : 42 : locvec.reserve (2);
35746 : 42 : locvec.safe_push (ent);
35747 : 42 : idxdef = 0;
35748 : : }
35749 : : else
35750 : : /* Pop the entry pushed above for this declaration. */
35751 : 84 : locvec.pop ();
35752 : : }
35753 : :
35754 : : /* Issues -Wmismatched-tags for a single class. */
35755 : :
35756 : : void
35757 : 627 : class_decl_loc_t::diag_mismatched_tags (tree type_decl)
35758 : : {
35759 : 627 : if (!warn_mismatched_tags)
35760 : 381 : return;
35761 : :
35762 : : /* Number of uses of the class. */
35763 : 624 : const unsigned ndecls = locvec.length ();
35764 : :
35765 : : /* The class (or template) declaration guiding the decisions about
35766 : : the diagnostic. For ordinary classes it's the same as THIS. For
35767 : : uses of instantiations of templates other than their declarations
35768 : : it points to the record for the declaration of the corresponding
35769 : : primary template or partial specialization. */
35770 : 624 : class_decl_loc_t *cdlguide = this;
35771 : :
35772 : 624 : tree type = TREE_TYPE (type_decl);
35773 : 624 : if (CLASS_TYPE_P (type) && CLASSTYPE_IMPLICIT_INSTANTIATION (type))
35774 : : {
35775 : : /* For implicit instantiations of a primary template look up
35776 : : the primary or partial specialization and use it as
35777 : : the expected class-key rather than using the class-key of
35778 : : the first reference to the instantiation. The primary must
35779 : : be (and inevitably is) at index zero. */
35780 : 78 : tree spec = specialization_of (type);
35781 : 78 : cdlguide = class2loc.get (spec);
35782 : : /* It's possible that we didn't find SPEC. Consider:
35783 : :
35784 : : template<typename T> struct A {
35785 : : template<typename U> struct W { };
35786 : : };
35787 : : struct A<int>::W<int> w; // #1
35788 : :
35789 : : where while parsing A and #1 we've stashed
35790 : : A<T>
35791 : : A<T>::W<U>
35792 : : A<int>::W<int>
35793 : : into CLASS2LOC. If TYPE is A<int>::W<int>, specialization_of
35794 : : will yield A<int>::W<U> which may be in CLASS2LOC if we had
35795 : : an A<int> class specialization, but otherwise won't be in it.
35796 : : So try to look up A<T>::W<U>. */
35797 : 78 : if (!cdlguide)
35798 : : {
35799 : 3 : spec = DECL_TEMPLATE_RESULT (most_general_template (spec));
35800 : 3 : cdlguide = class2loc.get (spec);
35801 : : }
35802 : : /* Now we really should have found something. */
35803 : 3 : gcc_assert (cdlguide != NULL);
35804 : : }
35805 : : /* Skip declarations that consistently use the same class-key. */
35806 : 546 : else if (def_class_key != none_type)
35807 : : return;
35808 : :
35809 : : /* Set if a definition for the class has been seen. */
35810 : 336 : const bool def_p = cdlguide->def_p ();
35811 : :
35812 : : /* The index of the declaration whose class-key this declaration
35813 : : is expected to match. It's either the class-key of the class
35814 : : definition if one exists or the first declaration otherwise. */
35815 : 336 : const unsigned idxguide = def_p ? cdlguide->idxdef : 0;
35816 : :
35817 : : /* The class-key the class is expected to be declared with: it's
35818 : : either the key used in its definition or the first declaration
35819 : : if no definition has been provided.
35820 : : For implicit instantiations of a primary template it's
35821 : : the class-key used to declare the primary with. The primary
35822 : : must be at index zero. */
35823 : 336 : const tag_types xpect_key = cdlguide->class_key (idxguide);
35824 : :
35825 : 336 : unsigned idx = 0;
35826 : : /* Advance IDX to the first declaration that either is not
35827 : : a definition or that doesn't match the first declaration
35828 : : if no definition is provided. */
35829 : 606 : while (class_key (idx) == xpect_key)
35830 : 360 : if (++idx == ndecls)
35831 : : return;
35832 : :
35833 : : /* Save the current function before changing it below. */
35834 : 246 : tree save_func = current_function_decl;
35835 : : /* Set the function declaration to print in diagnostic context. */
35836 : 246 : current_function_decl = function (idx);
35837 : :
35838 : 246 : const char *xmatchkstr = xpect_key == record_type ? "class" : "struct";
35839 : 138 : const char *xpectkstr = xpect_key == record_type ? "struct" : "class";
35840 : :
35841 : 246 : location_t loc = location (idx);
35842 : 246 : bool key_redundant_p = key_redundant (idx);
35843 : 246 : auto_diagnostic_group d;
35844 : : /* Issue a warning for the first mismatched declaration.
35845 : : Avoid using "%#qT" since the class-key for the same type will
35846 : : be the same regardless of which one was used in the declaraion. */
35847 : 246 : if (warning_at (loc, OPT_Wmismatched_tags,
35848 : : "%qT declared with a mismatched class-key %qs",
35849 : : type_decl, xmatchkstr))
35850 : : {
35851 : : /* Suggest how to avoid the warning for each instance since
35852 : : the guidance may be different depending on context. */
35853 : 381 : inform (loc,
35854 : : (key_redundant_p
35855 : : ? G_("remove the class-key or replace it with %qs")
35856 : : : G_("replace the class-key with %qs")),
35857 : : xpectkstr);
35858 : :
35859 : : /* Also point to the first declaration or definition that guided
35860 : : the decision to issue the warning above. */
35861 : 480 : inform (cdlguide->location (idxguide),
35862 : : (def_p
35863 : : ? G_("%qT defined as %qs here")
35864 : : : G_("%qT first declared as %qs here")),
35865 : : type_decl, xpectkstr);
35866 : : }
35867 : :
35868 : : /* Issue warnings for the remaining inconsistent declarations. */
35869 : 444 : for (unsigned i = idx + 1; i != ndecls; ++i)
35870 : : {
35871 : 198 : tag_types clskey = class_key (i);
35872 : : /* Skip over the declarations that match either the definition
35873 : : if one was provided or the first declaration. */
35874 : 198 : if (clskey == xpect_key)
35875 : 138 : continue;
35876 : :
35877 : 60 : loc = location (i);
35878 : 60 : key_redundant_p = key_redundant (i);
35879 : : /* Set the function declaration to print in diagnostic context. */
35880 : 60 : current_function_decl = function (i);
35881 : 60 : if (warning_at (loc, OPT_Wmismatched_tags,
35882 : : "%qT declared with a mismatched class-key %qs",
35883 : : type_decl, xmatchkstr))
35884 : : /* Suggest how to avoid the warning for each instance since
35885 : : the guidance may be different depending on context. */
35886 : 66 : inform (loc,
35887 : : (key_redundant_p
35888 : : ? G_("remove the class-key or replace it with %qs")
35889 : : : G_("replace the class-key with %qs")),
35890 : : xpectkstr);
35891 : : }
35892 : :
35893 : : /* Restore the current function in case it was replaced above. */
35894 : 246 : current_function_decl = save_func;
35895 : 246 : }
35896 : :
35897 : : /* Issues -Wmismatched-tags for all classes. Called at the end
35898 : : of processing a translation unit, after declarations of all class
35899 : : types and their uses have been recorded. */
35900 : :
35901 : : void
35902 : 90658 : class_decl_loc_t::diag_mismatched_tags ()
35903 : : {
35904 : : /* CLASS2LOC should be empty if both -Wmismatched-tags and
35905 : : -Wredundant-tags are disabled. */
35906 : 90658 : gcc_assert (warn_mismatched_tags
35907 : : || warn_redundant_tags
35908 : : || class2loc.is_empty ());
35909 : :
35910 : : /* Save the current function before changing on return. It should
35911 : : be null at this point. */
35912 : 90658 : temp_override<tree> cleanup (current_function_decl);
35913 : :
35914 : 90658 : if (warn_mismatched_tags)
35915 : : {
35916 : : /* Iterate over the collected class/struct/template declarations. */
35917 : 39 : typedef class_to_loc_map_t::iterator iter_t;
35918 : 1080 : for (iter_t it = class2loc.begin (); it != class2loc.end (); ++it)
35919 : : {
35920 : 501 : tree type_decl = (*it).first;
35921 : 501 : class_decl_loc_t &recloc = (*it).second;
35922 : 501 : recloc.diag_mismatched_tags (type_decl);
35923 : : }
35924 : : }
35925 : :
35926 : 90658 : class2loc.empty ();
35927 : 90658 : }
35928 : :
35929 : : /* Issue an error message if DECL is redeclared with different
35930 : : access than its original declaration [class.access.spec/3].
35931 : : This applies to nested classes, nested class templates and
35932 : : enumerations [class.mem/1]. */
35933 : :
35934 : : static void
35935 : 3078588 : cp_parser_check_access_in_redeclaration (tree decl, location_t location)
35936 : : {
35937 : 3078588 : if (!decl
35938 : 3078588 : || (!(CLASS_TYPE_P (TREE_TYPE (decl))
35939 : 2245602 : && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
35940 : 1330627 : && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE))
35941 : : return;
35942 : :
35943 : 2580947 : if ((TREE_PRIVATE (decl)
35944 : 2580947 : != (current_access_specifier == access_private_node))
35945 : 2580935 : || (TREE_PROTECTED (decl)
35946 : 2580935 : != (current_access_specifier == access_protected_node)))
35947 : 12 : error_at (location, "%qD redeclared with different access", decl);
35948 : : }
35949 : :
35950 : : /* Look for the `template' keyword, as a syntactic disambiguator.
35951 : : Return TRUE iff it is present, in which case it will be
35952 : : consumed. */
35953 : :
35954 : : static bool
35955 : 462317805 : cp_parser_optional_template_keyword (cp_parser *parser)
35956 : : {
35957 : 462317805 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
35958 : : {
35959 : : /* In C++98 the `template' keyword can only be used within templates;
35960 : : outside templates the parser can always figure out what is a
35961 : : template and what is not. In C++11, per the resolution of DR 468,
35962 : : `template' is allowed in cases where it is not strictly necessary. */
35963 : 1964268 : if (!processing_template_decl
35964 : 180 : && pedantic && cxx_dialect == cxx98)
35965 : : {
35966 : 6 : cp_token *token = cp_lexer_peek_token (parser->lexer);
35967 : 6 : pedwarn (token->location, OPT_Wpedantic,
35968 : : "in C++98 %<template%> (as a disambiguator) is only "
35969 : : "allowed within templates");
35970 : : /* If this part of the token stream is rescanned, the same
35971 : : error message would be generated. So, we purge the token
35972 : : from the stream. */
35973 : 6 : cp_lexer_purge_token (parser->lexer);
35974 : 6 : return false;
35975 : : }
35976 : : else
35977 : : {
35978 : : /* Consume the `template' keyword. */
35979 : 1964262 : cp_lexer_consume_token (parser->lexer);
35980 : 1964262 : return true;
35981 : : }
35982 : : }
35983 : : return false;
35984 : : }
35985 : :
35986 : : /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
35987 : : set PARSER->SCOPE, and perform other related actions. */
35988 : :
35989 : : static void
35990 : 140242267 : cp_parser_pre_parsed_nested_name_specifier (cp_parser *parser)
35991 : : {
35992 : 140242267 : struct tree_check *check_value;
35993 : :
35994 : : /* Get the stored value. */
35995 : 140242267 : check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
35996 : : /* Set the scope from the stored value. */
35997 : 140242267 : parser->scope = saved_checks_value (check_value);
35998 : 140242267 : parser->qualifying_scope = check_value->qualifying_scope;
35999 : 140242267 : parser->object_scope = parser->context->object_type;
36000 : 140242267 : parser->context->object_type = NULL_TREE;
36001 : 140242267 : }
36002 : :
36003 : : /* Consume tokens up through a non-nested END token. Returns TRUE if we
36004 : : encounter the end of a block before what we were looking for. */
36005 : :
36006 : : static bool
36007 : 312499941 : cp_parser_cache_group (cp_parser *parser,
36008 : : enum cpp_ttype end,
36009 : : unsigned depth)
36010 : : {
36011 : 1375849259 : while (true)
36012 : : {
36013 : 1375849259 : cp_token *token = cp_lexer_peek_token (parser->lexer);
36014 : :
36015 : : /* Abort a parenthesized expression if we encounter a semicolon. */
36016 : 1375849259 : if ((end == CPP_CLOSE_PAREN || depth == 0)
36017 : 710539371 : && token->type == CPP_SEMICOLON)
36018 : : return true;
36019 : : /* If we've reached the end of the file, stop. */
36020 : 1375050814 : if (token->type == CPP_EOF
36021 : 1375050802 : || (end != CPP_PRAGMA_EOL
36022 : 1374964524 : && token->type == CPP_PRAGMA_EOL))
36023 : : return true;
36024 : 1375050802 : if (token->type == CPP_CLOSE_BRACE && depth == 0)
36025 : : /* We've hit the end of an enclosing block, so there's been some
36026 : : kind of syntax error. */
36027 : : return true;
36028 : :
36029 : : /* Consume the token. */
36030 : 1375050792 : cp_lexer_consume_token (parser->lexer);
36031 : : /* See if it starts a new group. */
36032 : 1375050792 : if (token->type == CPP_OPEN_BRACE)
36033 : : {
36034 : 74597865 : cp_parser_cache_group (parser, CPP_CLOSE_BRACE, depth + 1);
36035 : : /* In theory this should probably check end == '}', but
36036 : : cp_parser_save_member_function_body needs it to exit
36037 : : after either '}' or ')' when called with ')'. */
36038 : 74597865 : if (depth == 0)
36039 : : return false;
36040 : : }
36041 : 1300452927 : else if (token->type == CPP_OPEN_PAREN)
36042 : : {
36043 : 152995402 : cp_parser_cache_group (parser, CPP_CLOSE_PAREN, depth + 1);
36044 : 152995402 : if (depth == 0 && end == CPP_CLOSE_PAREN)
36045 : : return false;
36046 : : }
36047 : 1147457525 : else if (token->type == CPP_PRAGMA)
36048 : 36899 : cp_parser_cache_group (parser, CPP_PRAGMA_EOL, depth + 1);
36049 : 1147420626 : else if (token->type == end)
36050 : : return false;
36051 : : }
36052 : : }
36053 : :
36054 : : /* Like above, for caching a default argument or NSDMI. Both of these are
36055 : : terminated by a non-nested comma, but it can be unclear whether or not a
36056 : : comma is nested in a template argument list unless we do more parsing.
36057 : : In order to handle this ambiguity, when we encounter a ',' after a '<'
36058 : : we try to parse what follows as a parameter-declaration-list (in the
36059 : : case of a default argument) or a member-declarator (in the case of an
36060 : : NSDMI). If that succeeds, then we stop caching. */
36061 : :
36062 : : static tree
36063 : 6751161 : cp_parser_cache_defarg (cp_parser *parser, bool nsdmi)
36064 : : {
36065 : 6751161 : unsigned depth = 0;
36066 : 6751161 : int maybe_template_id = 0;
36067 : 6751161 : cp_token *first_token;
36068 : 6751161 : cp_token *token;
36069 : 6751161 : tree default_argument;
36070 : :
36071 : : /* Add tokens until we have processed the entire default
36072 : : argument. We add the range [first_token, token). */
36073 : 6751161 : first_token = cp_lexer_peek_token (parser->lexer);
36074 : 6751161 : if (first_token->type == CPP_OPEN_BRACE)
36075 : : {
36076 : : /* For list-initialization, this is straightforward. */
36077 : 163091 : cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
36078 : 163091 : token = cp_lexer_peek_token (parser->lexer);
36079 : : }
36080 : 52542372 : else while (true)
36081 : : {
36082 : 29565221 : bool done = false;
36083 : :
36084 : : /* Peek at the next token. */
36085 : 29565221 : token = cp_lexer_peek_token (parser->lexer);
36086 : : /* What we do depends on what token we have. */
36087 : 29565221 : switch (token->type)
36088 : : {
36089 : : /* In valid code, a default argument must be
36090 : : immediately followed by a `,' `)', or `...'. */
36091 : 2093159 : case CPP_COMMA:
36092 : 2093159 : if (depth == 0 && maybe_template_id)
36093 : : {
36094 : : /* If we've seen a '<', we might be in a
36095 : : template-argument-list. Until Core issue 325 is
36096 : : resolved, we don't know how this situation ought
36097 : : to be handled, so try to DTRT. We check whether
36098 : : what comes after the comma is a valid parameter
36099 : : declaration list. If it is, then the comma ends
36100 : : the default argument; otherwise the default
36101 : : argument continues. */
36102 : 1223 : bool error = false;
36103 : 1223 : cp_token *peek;
36104 : :
36105 : : /* Set ITALP so cp_parser_parameter_declaration_list
36106 : : doesn't decide to commit to this parse. */
36107 : 1223 : bool saved_italp = parser->in_template_argument_list_p;
36108 : 1223 : parser->in_template_argument_list_p = true;
36109 : :
36110 : 1223 : cp_parser_parse_tentatively (parser);
36111 : :
36112 : 1223 : if (nsdmi)
36113 : : {
36114 : : /* Parse declarators until we reach a non-comma or
36115 : : somthing that cannot be an initializer.
36116 : : Just checking whether we're looking at a single
36117 : : declarator is insufficient. Consider:
36118 : : int var = tuple<T,U>::x;
36119 : : The template parameter 'U' looks exactly like a
36120 : : declarator. */
36121 : 1197 : do
36122 : : {
36123 : 1197 : int ctor_dtor_or_conv_p;
36124 : 1197 : cp_lexer_consume_token (parser->lexer);
36125 : 1197 : cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
36126 : : CP_PARSER_FLAGS_NONE,
36127 : : &ctor_dtor_or_conv_p,
36128 : : /*parenthesized_p=*/NULL,
36129 : : /*member_p=*/true,
36130 : : /*friend_p=*/false,
36131 : : /*static_p=*/false);
36132 : 1197 : peek = cp_lexer_peek_token (parser->lexer);
36133 : 6 : if (cp_parser_error_occurred (parser))
36134 : : break;
36135 : : }
36136 : 1191 : while (peek->type == CPP_COMMA);
36137 : : /* If we met an '=' or ';' then the original comma
36138 : : was the end of the NSDMI. Otherwise assume
36139 : : we're still in the NSDMI. */
36140 : 1197 : error = (peek->type != CPP_EQ
36141 : 1197 : && peek->type != CPP_SEMICOLON);
36142 : : }
36143 : : else
36144 : : {
36145 : 26 : cp_lexer_consume_token (parser->lexer);
36146 : 26 : begin_scope (sk_function_parms, NULL_TREE);
36147 : 26 : tree t = cp_parser_parameter_declaration_list
36148 : 26 : (parser, CP_PARSER_FLAGS_NONE,
36149 : : /*pending_decls*/nullptr);
36150 : 26 : if (t == error_mark_node)
36151 : 0 : error = true;
36152 : 26 : pop_bindings_and_leave_scope ();
36153 : : }
36154 : 1194 : if (!cp_parser_error_occurred (parser) && !error)
36155 : 1223 : done = true;
36156 : 1223 : cp_parser_abort_tentative_parse (parser);
36157 : :
36158 : 1223 : parser->in_template_argument_list_p = saved_italp;
36159 : 1223 : break;
36160 : : }
36161 : : /* FALLTHRU */
36162 : 10496396 : case CPP_CLOSE_PAREN:
36163 : 10496396 : case CPP_ELLIPSIS:
36164 : : /* If we run into a non-nested `;', `}', or `]',
36165 : : then the code is invalid -- but the default
36166 : : argument is certainly over. */
36167 : 10496396 : case CPP_SEMICOLON:
36168 : 10496396 : case CPP_CLOSE_BRACE:
36169 : 10496396 : case CPP_CLOSE_SQUARE:
36170 : 10496396 : if (depth == 0
36171 : : /* Handle correctly int n = sizeof ... ( p ); */
36172 : 6588067 : && token->type != CPP_ELLIPSIS)
36173 : : done = true;
36174 : : /* Update DEPTH, if necessary. */
36175 : 3908335 : else if (token->type == CPP_CLOSE_PAREN
36176 : : || token->type == CPP_CLOSE_BRACE
36177 : : || token->type == CPP_CLOSE_SQUARE)
36178 : 2746541 : --depth;
36179 : : break;
36180 : :
36181 : 2746541 : case CPP_OPEN_PAREN:
36182 : 2746541 : case CPP_OPEN_SQUARE:
36183 : 2746541 : case CPP_OPEN_BRACE:
36184 : 2746541 : ++depth;
36185 : 2746541 : break;
36186 : :
36187 : 107562 : case CPP_LESS:
36188 : 107562 : if (depth == 0)
36189 : : /* This might be the comparison operator, or it might
36190 : : start a template argument list. */
36191 : 107524 : ++maybe_template_id;
36192 : : break;
36193 : :
36194 : 2065 : case CPP_RSHIFT:
36195 : 2065 : if (cxx_dialect == cxx98)
36196 : : break;
36197 : : /* Fall through for C++0x, which treats the `>>'
36198 : : operator like two `>' tokens in certain
36199 : : cases. */
36200 : 105493 : gcc_fallthrough ();
36201 : :
36202 : 105493 : case CPP_GREATER:
36203 : 105493 : if (depth == 0)
36204 : : {
36205 : : /* This might be an operator, or it might close a
36206 : : template argument list. But if a previous '<'
36207 : : started a template argument list, this will have
36208 : : closed it, so we can't be in one anymore. */
36209 : 105450 : maybe_template_id -= 1 + (token->type == CPP_RSHIFT);
36210 : 105450 : if (maybe_template_id < 0)
36211 : : maybe_template_id = 0;
36212 : : }
36213 : : break;
36214 : :
36215 : : /* If we run out of tokens, issue an error message. */
36216 : 3 : case CPP_EOF:
36217 : 3 : case CPP_PRAGMA_EOL:
36218 : 3 : error_at (token->location, "file ends in default argument");
36219 : 3 : return error_mark_node;
36220 : :
36221 : : case CPP_NAME:
36222 : : case CPP_SCOPE:
36223 : : /* In these cases, we should look for template-ids.
36224 : : For example, if the default argument is
36225 : : `X<int, double>()', we need to do name lookup to
36226 : : figure out whether or not `X' is a template; if
36227 : : so, the `,' does not end the default argument.
36228 : :
36229 : : That is not yet done. */
36230 : : break;
36231 : :
36232 : : default:
36233 : : break;
36234 : : }
36235 : :
36236 : : /* If we've reached the end, stop. */
36237 : 5601829 : if (done)
36238 : : break;
36239 : :
36240 : : /* Add the token to the token block. */
36241 : 22977151 : token = cp_lexer_consume_token (parser->lexer);
36242 : 22977151 : }
36243 : :
36244 : : /* Create a DEFERRED_PARSE to represent the unparsed default
36245 : : argument. */
36246 : 6751158 : default_argument = make_node (DEFERRED_PARSE);
36247 : 6751158 : DEFPARSE_TOKENS (default_argument)
36248 : 6751158 : = cp_token_cache_new (first_token, token);
36249 : 6751158 : DEFPARSE_INSTANTIATIONS (default_argument) = NULL;
36250 : :
36251 : 6751158 : return default_argument;
36252 : : }
36253 : :
36254 : : /* A location to use for diagnostics about an unparsed DEFERRED_PARSE. */
36255 : :
36256 : : location_t
36257 : 26 : defparse_location (tree default_argument)
36258 : : {
36259 : 26 : cp_token_cache *tokens = DEFPARSE_TOKENS (default_argument);
36260 : 26 : location_t start = tokens->first->location;
36261 : 26 : location_t end = tokens->last->location;
36262 : 26 : return make_location (start, start, end);
36263 : : }
36264 : :
36265 : : /* Begin parsing tentatively. We always save tokens while parsing
36266 : : tentatively so that if the tentative parsing fails we can restore the
36267 : : tokens. */
36268 : :
36269 : : static void
36270 : 13512047857 : cp_parser_parse_tentatively (cp_parser* parser)
36271 : : {
36272 : : /* Enter a new parsing context. */
36273 : 13512047857 : parser->context = cp_parser_context_new (parser->context);
36274 : : /* Begin saving tokens. */
36275 : 13512047857 : cp_lexer_save_tokens (parser->lexer);
36276 : : /* In order to avoid repetitive access control error messages,
36277 : : access checks are queued up until we are no longer parsing
36278 : : tentatively. */
36279 : 13512047857 : push_deferring_access_checks (dk_deferred);
36280 : 13512047857 : }
36281 : :
36282 : : /* Commit to the currently active tentative parse. */
36283 : :
36284 : : static void
36285 : 354294443 : cp_parser_commit_to_tentative_parse (cp_parser* parser)
36286 : : {
36287 : 354294443 : cp_parser_context *context;
36288 : 354294443 : cp_lexer *lexer;
36289 : :
36290 : : /* Mark all of the levels as committed. */
36291 : 354294443 : lexer = parser->lexer;
36292 : 515629352 : for (context = parser->context; context->next; context = context->next)
36293 : : {
36294 : 272769671 : if (context->status == CP_PARSER_STATUS_KIND_COMMITTED)
36295 : : break;
36296 : 161334909 : context->status = CP_PARSER_STATUS_KIND_COMMITTED;
36297 : 161334909 : while (!cp_lexer_saving_tokens (lexer))
36298 : 0 : lexer = lexer->next;
36299 : 161334909 : cp_lexer_commit_tokens (lexer);
36300 : : }
36301 : 354294443 : }
36302 : :
36303 : : /* Commit to the topmost currently active tentative parse.
36304 : :
36305 : : Note that this function shouldn't be called when there are
36306 : : irreversible side-effects while in a tentative state. For
36307 : : example, we shouldn't create a permanent entry in the symbol
36308 : : table, or issue an error message that might not apply if the
36309 : : tentative parse is aborted. */
36310 : :
36311 : : static void
36312 : 211307530 : cp_parser_commit_to_topmost_tentative_parse (cp_parser* parser)
36313 : : {
36314 : 211307530 : cp_parser_context *context = parser->context;
36315 : 211307530 : cp_lexer *lexer = parser->lexer;
36316 : :
36317 : 211307530 : if (context)
36318 : : {
36319 : 211307530 : if (context->status == CP_PARSER_STATUS_KIND_COMMITTED)
36320 : : return;
36321 : 211307515 : context->status = CP_PARSER_STATUS_KIND_COMMITTED;
36322 : :
36323 : 211307515 : while (!cp_lexer_saving_tokens (lexer))
36324 : 0 : lexer = lexer->next;
36325 : 211307515 : cp_lexer_commit_tokens (lexer);
36326 : : }
36327 : : }
36328 : :
36329 : : /* Abort the currently active tentative parse. All consumed tokens
36330 : : will be rolled back, and no diagnostics will be issued. */
36331 : :
36332 : : static void
36333 : 274163955 : cp_parser_abort_tentative_parse (cp_parser* parser)
36334 : : {
36335 : 274163955 : gcc_assert (parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED
36336 : : || errorcount > 0);
36337 : 548327910 : cp_parser_simulate_error (parser);
36338 : : /* Now, pretend that we want to see if the construct was
36339 : : successfully parsed. */
36340 : 274163955 : cp_parser_parse_definitely (parser);
36341 : 274163955 : }
36342 : :
36343 : : /* Stop parsing tentatively. If a parse error has occurred, restore the
36344 : : token stream. Otherwise, commit to the tokens we have consumed.
36345 : : Returns true if no error occurred; false otherwise. */
36346 : :
36347 : : static bool
36348 : 13512047815 : cp_parser_parse_definitely (cp_parser* parser)
36349 : : {
36350 : 13512047815 : bool error_occurred;
36351 : 13512047815 : cp_parser_context *context;
36352 : :
36353 : : /* Remember whether or not an error occurred, since we are about to
36354 : : destroy that information. */
36355 : 27024095630 : error_occurred = cp_parser_error_occurred (parser);
36356 : : /* Remove the topmost context from the stack. */
36357 : 13512047815 : context = parser->context;
36358 : 13512047815 : parser->context = context->next;
36359 : : /* If no parse errors occurred, commit to the tentative parse. */
36360 : 13512047815 : if (!error_occurred)
36361 : : {
36362 : : /* Commit to the tokens read tentatively, unless that was
36363 : : already done. */
36364 : 3631174581 : if (context->status != CP_PARSER_STATUS_KIND_COMMITTED)
36365 : 3258532181 : cp_lexer_commit_tokens (parser->lexer);
36366 : :
36367 : 3631174581 : pop_to_parent_deferring_access_checks ();
36368 : : }
36369 : : /* Otherwise, if errors occurred, roll back our state so that things
36370 : : are just as they were before we began the tentative parse. */
36371 : : else
36372 : : {
36373 : 9880873234 : cp_lexer_rollback_tokens (parser->lexer);
36374 : 9880873234 : pop_deferring_access_checks ();
36375 : : }
36376 : : /* Add the context to the front of the free list. */
36377 : 13512047815 : context->next = cp_parser_context_free_list;
36378 : 13512047815 : cp_parser_context_free_list = context;
36379 : :
36380 : 13512047815 : return !error_occurred;
36381 : : }
36382 : :
36383 : : /* Returns true if we are parsing tentatively and are not committed to
36384 : : this tentative parse. */
36385 : :
36386 : : static bool
36387 : 17727592201 : cp_parser_uncommitted_to_tentative_parse_p (cp_parser* parser)
36388 : : {
36389 : 7355834 : return (cp_parser_parsing_tentatively (parser)
36390 : 17727592177 : && parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED);
36391 : : }
36392 : :
36393 : : /* Returns nonzero iff an error has occurred during the most recent
36394 : : tentative parse. */
36395 : :
36396 : : static bool
36397 : 18303754812 : cp_parser_error_occurred (cp_parser* parser)
36398 : : {
36399 : 18303754812 : return (cp_parser_parsing_tentatively (parser)
36400 : 18303754812 : && parser->context->status == CP_PARSER_STATUS_KIND_ERROR);
36401 : : }
36402 : :
36403 : : /* Returns nonzero if GNU extensions are allowed. */
36404 : :
36405 : : static bool
36406 : 3218611452 : cp_parser_allow_gnu_extensions_p (cp_parser* parser)
36407 : : {
36408 : 3218611452 : return parser->allow_gnu_extensions_p;
36409 : : }
36410 : :
36411 : : /* Objective-C++ Productions */
36412 : :
36413 : :
36414 : : /* Parse an Objective-C expression, which feeds into a primary-expression
36415 : : above.
36416 : :
36417 : : objc-expression:
36418 : : objc-message-expression
36419 : : objc-string-literal
36420 : : objc-encode-expression
36421 : : objc-protocol-expression
36422 : : objc-selector-expression
36423 : :
36424 : : Returns a tree representation of the expression. */
36425 : :
36426 : : static cp_expr
36427 : 0 : cp_parser_objc_expression (cp_parser* parser)
36428 : : {
36429 : : /* Try to figure out what kind of declaration is present. */
36430 : 0 : cp_token *kwd = cp_lexer_peek_token (parser->lexer);
36431 : :
36432 : 0 : switch (kwd->type)
36433 : : {
36434 : 0 : case CPP_OPEN_SQUARE:
36435 : 0 : return cp_parser_objc_message_expression (parser);
36436 : :
36437 : 0 : case CPP_OBJC_STRING:
36438 : 0 : kwd = cp_lexer_consume_token (parser->lexer);
36439 : 0 : return objc_build_string_object (kwd->u.value);
36440 : :
36441 : 0 : case CPP_KEYWORD:
36442 : 0 : switch (kwd->keyword)
36443 : : {
36444 : 0 : case RID_AT_ENCODE:
36445 : 0 : return cp_parser_objc_encode_expression (parser);
36446 : :
36447 : 0 : case RID_AT_PROTOCOL:
36448 : 0 : return cp_parser_objc_protocol_expression (parser);
36449 : :
36450 : 0 : case RID_AT_SELECTOR:
36451 : 0 : return cp_parser_objc_selector_expression (parser);
36452 : :
36453 : : default:
36454 : : break;
36455 : : }
36456 : : /* FALLTHRU */
36457 : 0 : default:
36458 : 0 : error_at (kwd->location,
36459 : : "misplaced %<@%D%> Objective-C++ construct",
36460 : : kwd->u.value);
36461 : 0 : cp_parser_skip_to_end_of_block_or_statement (parser);
36462 : : }
36463 : :
36464 : 0 : return error_mark_node;
36465 : : }
36466 : :
36467 : : /* Parse an Objective-C message expression.
36468 : :
36469 : : objc-message-expression:
36470 : : [ objc-message-receiver objc-message-args ]
36471 : :
36472 : : Returns a representation of an Objective-C message. */
36473 : :
36474 : : static tree
36475 : 0 : cp_parser_objc_message_expression (cp_parser* parser)
36476 : : {
36477 : 0 : tree receiver, messageargs;
36478 : :
36479 : 0 : parser->objective_c_message_context_p = true;
36480 : 0 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
36481 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '['. */
36482 : 0 : receiver = cp_parser_objc_message_receiver (parser);
36483 : 0 : messageargs = cp_parser_objc_message_args (parser);
36484 : 0 : location_t end_loc = cp_lexer_peek_token (parser->lexer)->location;
36485 : 0 : cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
36486 : :
36487 : 0 : tree result = objc_build_message_expr (receiver, messageargs);
36488 : :
36489 : : /* Construct a location e.g.
36490 : : [self func1:5]
36491 : : ^~~~~~~~~~~~~~
36492 : : ranging from the '[' to the ']', with the caret at the start. */
36493 : 0 : location_t combined_loc = make_location (start_loc, start_loc, end_loc);
36494 : 0 : protected_set_expr_location (result, combined_loc);
36495 : :
36496 : 0 : parser->objective_c_message_context_p = false;
36497 : 0 : return result;
36498 : : }
36499 : :
36500 : : /* Parse an objc-message-receiver.
36501 : :
36502 : : objc-message-receiver:
36503 : : expression
36504 : : simple-type-specifier
36505 : :
36506 : : Returns a representation of the type or expression. */
36507 : :
36508 : : static tree
36509 : 0 : cp_parser_objc_message_receiver (cp_parser* parser)
36510 : : {
36511 : 0 : tree rcv;
36512 : :
36513 : : /* An Objective-C message receiver may be either (1) a type
36514 : : or (2) an expression. */
36515 : 0 : cp_parser_parse_tentatively (parser);
36516 : 0 : rcv = cp_parser_expression (parser);
36517 : :
36518 : : /* If that worked out, fine. */
36519 : 0 : if (cp_parser_parse_definitely (parser))
36520 : : return rcv;
36521 : :
36522 : 0 : cp_parser_parse_tentatively (parser);
36523 : 0 : rcv = cp_parser_simple_type_specifier (parser,
36524 : : /*decl_specs=*/NULL,
36525 : : CP_PARSER_FLAGS_NONE);
36526 : :
36527 : 0 : if (cp_parser_parse_definitely (parser))
36528 : 0 : return objc_get_class_reference (rcv);
36529 : :
36530 : 0 : cp_parser_error (parser, "objective-c++ message receiver expected");
36531 : 0 : return error_mark_node;
36532 : : }
36533 : :
36534 : : /* Parse the arguments and selectors comprising an Objective-C message.
36535 : :
36536 : : objc-message-args:
36537 : : objc-selector
36538 : : objc-selector-args
36539 : : objc-selector-args , objc-comma-args
36540 : :
36541 : : objc-selector-args:
36542 : : objc-selector [opt] : assignment-expression
36543 : : objc-selector-args objc-selector [opt] : assignment-expression
36544 : :
36545 : : objc-comma-args:
36546 : : assignment-expression
36547 : : objc-comma-args , assignment-expression
36548 : :
36549 : : Returns a TREE_LIST, with TREE_PURPOSE containing a list of
36550 : : selector arguments and TREE_VALUE containing a list of comma
36551 : : arguments. */
36552 : :
36553 : : static tree
36554 : 0 : cp_parser_objc_message_args (cp_parser* parser)
36555 : : {
36556 : 0 : tree sel_args = NULL_TREE, addl_args = NULL_TREE;
36557 : 0 : bool maybe_unary_selector_p = true;
36558 : 0 : cp_token *token = cp_lexer_peek_token (parser->lexer);
36559 : :
36560 : 0 : while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
36561 : : {
36562 : 0 : tree selector = NULL_TREE, arg;
36563 : :
36564 : 0 : if (token->type != CPP_COLON)
36565 : 0 : selector = cp_parser_objc_selector (parser);
36566 : :
36567 : : /* Detect if we have a unary selector. */
36568 : 0 : if (maybe_unary_selector_p
36569 : 0 : && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
36570 : 0 : return build_tree_list (selector, NULL_TREE);
36571 : :
36572 : 0 : maybe_unary_selector_p = false;
36573 : 0 : cp_parser_require (parser, CPP_COLON, RT_COLON);
36574 : 0 : arg = cp_parser_assignment_expression (parser);
36575 : :
36576 : 0 : sel_args
36577 : 0 : = chainon (sel_args,
36578 : : build_tree_list (selector, arg));
36579 : :
36580 : 0 : token = cp_lexer_peek_token (parser->lexer);
36581 : : }
36582 : :
36583 : : /* Handle non-selector arguments, if any. */
36584 : 0 : while (token->type == CPP_COMMA)
36585 : : {
36586 : 0 : tree arg;
36587 : :
36588 : 0 : cp_lexer_consume_token (parser->lexer);
36589 : 0 : arg = cp_parser_assignment_expression (parser);
36590 : :
36591 : 0 : addl_args
36592 : 0 : = chainon (addl_args,
36593 : : build_tree_list (NULL_TREE, arg));
36594 : :
36595 : 0 : token = cp_lexer_peek_token (parser->lexer);
36596 : : }
36597 : :
36598 : 0 : if (sel_args == NULL_TREE && addl_args == NULL_TREE)
36599 : : {
36600 : 0 : cp_parser_error (parser, "objective-c++ message argument(s) are expected");
36601 : 0 : return build_tree_list (error_mark_node, error_mark_node);
36602 : : }
36603 : :
36604 : 0 : return build_tree_list (sel_args, addl_args);
36605 : : }
36606 : :
36607 : : /* Parse an Objective-C encode expression.
36608 : :
36609 : : objc-encode-expression:
36610 : : @encode objc-typename
36611 : :
36612 : : Returns an encoded representation of the type argument. */
36613 : :
36614 : : static cp_expr
36615 : 0 : cp_parser_objc_encode_expression (cp_parser* parser)
36616 : : {
36617 : 0 : tree type;
36618 : 0 : cp_token *token;
36619 : 0 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
36620 : :
36621 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@encode'. */
36622 : 0 : matching_parens parens;
36623 : 0 : parens.require_open (parser);
36624 : 0 : token = cp_lexer_peek_token (parser->lexer);
36625 : 0 : type = complete_type (cp_parser_type_id (parser));
36626 : 0 : parens.require_close (parser);
36627 : :
36628 : 0 : if (!type)
36629 : : {
36630 : 0 : error_at (token->location,
36631 : : "%<@encode%> must specify a type as an argument");
36632 : 0 : return error_mark_node;
36633 : : }
36634 : :
36635 : : /* This happens if we find @encode(T) (where T is a template
36636 : : typename or something dependent on a template typename) when
36637 : : parsing a template. In that case, we can't compile it
36638 : : immediately, but we rather create an AT_ENCODE_EXPR which will
36639 : : need to be instantiated when the template is used.
36640 : : */
36641 : 0 : if (dependent_type_p (type))
36642 : : {
36643 : 0 : tree value = build_min (AT_ENCODE_EXPR, size_type_node, type);
36644 : 0 : TREE_READONLY (value) = 1;
36645 : 0 : return value;
36646 : : }
36647 : :
36648 : :
36649 : : /* Build a location of the form:
36650 : : @encode(int)
36651 : : ^~~~~~~~~~~~
36652 : : with caret==start at the @ token, finishing at the close paren. */
36653 : 0 : location_t combined_loc = make_location (start_loc, start_loc, parser->lexer);
36654 : :
36655 : 0 : return cp_expr (objc_build_encode_expr (type), combined_loc);
36656 : : }
36657 : :
36658 : : /* Parse an Objective-C @defs expression. */
36659 : :
36660 : : static tree
36661 : 0 : cp_parser_objc_defs_expression (cp_parser *parser)
36662 : : {
36663 : 0 : tree name;
36664 : :
36665 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@defs'. */
36666 : 0 : matching_parens parens;
36667 : 0 : parens.require_open (parser);
36668 : 0 : name = cp_parser_identifier (parser);
36669 : 0 : parens.require_close (parser);
36670 : :
36671 : 0 : return objc_get_class_ivars (name);
36672 : : }
36673 : :
36674 : : /* Parse an Objective-C protocol expression.
36675 : :
36676 : : objc-protocol-expression:
36677 : : @protocol ( identifier )
36678 : :
36679 : : Returns a representation of the protocol expression. */
36680 : :
36681 : : static tree
36682 : 0 : cp_parser_objc_protocol_expression (cp_parser* parser)
36683 : : {
36684 : 0 : tree proto;
36685 : 0 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
36686 : :
36687 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
36688 : 0 : matching_parens parens;
36689 : 0 : parens.require_open (parser);
36690 : 0 : proto = cp_parser_identifier (parser);
36691 : 0 : parens.require_close (parser);
36692 : :
36693 : : /* Build a location of the form:
36694 : : @protocol(prot)
36695 : : ^~~~~~~~~~~~~~~
36696 : : with caret==start at the @ token, finishing at the close paren. */
36697 : 0 : location_t combined_loc = make_location (start_loc, start_loc, parser->lexer);
36698 : 0 : tree result = objc_build_protocol_expr (proto);
36699 : 0 : protected_set_expr_location (result, combined_loc);
36700 : 0 : return result;
36701 : : }
36702 : :
36703 : : /* Parse an Objective-C selector expression.
36704 : :
36705 : : objc-selector-expression:
36706 : : @selector ( objc-method-signature )
36707 : :
36708 : : objc-method-signature:
36709 : : objc-selector
36710 : : objc-selector-seq
36711 : :
36712 : : objc-selector-seq:
36713 : : objc-selector :
36714 : : objc-selector-seq objc-selector :
36715 : :
36716 : : Returns a representation of the method selector. */
36717 : :
36718 : : static tree
36719 : 0 : cp_parser_objc_selector_expression (cp_parser* parser)
36720 : : {
36721 : 0 : tree sel_seq = NULL_TREE;
36722 : 0 : bool maybe_unary_selector_p = true;
36723 : 0 : cp_token *token;
36724 : 0 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
36725 : :
36726 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@selector'. */
36727 : 0 : matching_parens parens;
36728 : 0 : parens.require_open (parser);
36729 : 0 : token = cp_lexer_peek_token (parser->lexer);
36730 : :
36731 : 0 : while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON
36732 : 0 : || token->type == CPP_SCOPE)
36733 : : {
36734 : 0 : tree selector = NULL_TREE;
36735 : :
36736 : 0 : if (token->type != CPP_COLON
36737 : : || token->type == CPP_SCOPE)
36738 : 0 : selector = cp_parser_objc_selector (parser);
36739 : :
36740 : 0 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)
36741 : 0 : && cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
36742 : : {
36743 : : /* Detect if we have a unary selector. */
36744 : 0 : if (maybe_unary_selector_p)
36745 : : {
36746 : 0 : sel_seq = selector;
36747 : 0 : goto finish_selector;
36748 : : }
36749 : : else
36750 : : {
36751 : 0 : cp_parser_error (parser, "expected %<:%>");
36752 : : }
36753 : : }
36754 : 0 : maybe_unary_selector_p = false;
36755 : 0 : token = cp_lexer_consume_token (parser->lexer);
36756 : :
36757 : 0 : if (token->type == CPP_SCOPE)
36758 : : {
36759 : 0 : sel_seq
36760 : 0 : = chainon (sel_seq,
36761 : : build_tree_list (selector, NULL_TREE));
36762 : 0 : sel_seq
36763 : 0 : = chainon (sel_seq,
36764 : : build_tree_list (NULL_TREE, NULL_TREE));
36765 : : }
36766 : : else
36767 : 0 : sel_seq
36768 : 0 : = chainon (sel_seq,
36769 : : build_tree_list (selector, NULL_TREE));
36770 : :
36771 : 0 : token = cp_lexer_peek_token (parser->lexer);
36772 : : }
36773 : :
36774 : 0 : finish_selector:
36775 : 0 : parens.require_close (parser);
36776 : :
36777 : :
36778 : : /* Build a location of the form:
36779 : : @selector(func)
36780 : : ^~~~~~~~~~~~~~~
36781 : : with caret==start at the @ token, finishing at the close paren. */
36782 : 0 : location_t combined_loc = make_location (loc, loc, parser->lexer);
36783 : 0 : tree result = objc_build_selector_expr (combined_loc, sel_seq);
36784 : : /* TODO: objc_build_selector_expr doesn't always honor the location. */
36785 : 0 : protected_set_expr_location (result, combined_loc);
36786 : 0 : return result;
36787 : : }
36788 : :
36789 : : /* Parse a list of identifiers.
36790 : :
36791 : : objc-identifier-list:
36792 : : identifier
36793 : : objc-identifier-list , identifier
36794 : :
36795 : : Returns a TREE_LIST of identifier nodes. */
36796 : :
36797 : : static tree
36798 : 0 : cp_parser_objc_identifier_list (cp_parser* parser)
36799 : : {
36800 : 0 : tree identifier;
36801 : 0 : tree list;
36802 : 0 : cp_token *sep;
36803 : :
36804 : 0 : identifier = cp_parser_identifier (parser);
36805 : 0 : if (identifier == error_mark_node)
36806 : : return error_mark_node;
36807 : :
36808 : 0 : list = build_tree_list (NULL_TREE, identifier);
36809 : 0 : sep = cp_lexer_peek_token (parser->lexer);
36810 : :
36811 : 0 : while (sep->type == CPP_COMMA)
36812 : : {
36813 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat ','. */
36814 : 0 : identifier = cp_parser_identifier (parser);
36815 : 0 : if (identifier == error_mark_node)
36816 : : return list;
36817 : :
36818 : 0 : list = chainon (list, build_tree_list (NULL_TREE,
36819 : : identifier));
36820 : 0 : sep = cp_lexer_peek_token (parser->lexer);
36821 : : }
36822 : :
36823 : : return list;
36824 : : }
36825 : :
36826 : : /* Parse an Objective-C alias declaration.
36827 : :
36828 : : objc-alias-declaration:
36829 : : @compatibility_alias identifier identifier ;
36830 : :
36831 : : This function registers the alias mapping with the Objective-C front end.
36832 : : It returns nothing. */
36833 : :
36834 : : static void
36835 : 0 : cp_parser_objc_alias_declaration (cp_parser* parser)
36836 : : {
36837 : 0 : tree alias, orig;
36838 : :
36839 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@compatibility_alias'. */
36840 : 0 : alias = cp_parser_identifier (parser);
36841 : 0 : orig = cp_parser_identifier (parser);
36842 : 0 : objc_declare_alias (alias, orig);
36843 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
36844 : 0 : }
36845 : :
36846 : : /* Parse an Objective-C class forward-declaration.
36847 : :
36848 : : objc-class-declaration:
36849 : : @class objc-identifier-list ;
36850 : :
36851 : : The function registers the forward declarations with the Objective-C
36852 : : front end. It returns nothing. */
36853 : :
36854 : : static void
36855 : 0 : cp_parser_objc_class_declaration (cp_parser* parser)
36856 : : {
36857 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@class'. */
36858 : 0 : while (true)
36859 : : {
36860 : 0 : tree id;
36861 : :
36862 : 0 : id = cp_parser_identifier (parser);
36863 : 0 : if (id == error_mark_node)
36864 : : break;
36865 : :
36866 : 0 : objc_declare_class (id);
36867 : :
36868 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
36869 : 0 : cp_lexer_consume_token (parser->lexer);
36870 : : else
36871 : : break;
36872 : 0 : }
36873 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
36874 : 0 : }
36875 : :
36876 : : /* Parse a list of Objective-C protocol references.
36877 : :
36878 : : objc-protocol-refs-opt:
36879 : : objc-protocol-refs [opt]
36880 : :
36881 : : objc-protocol-refs:
36882 : : < objc-identifier-list >
36883 : :
36884 : : Returns a TREE_LIST of identifiers, if any. */
36885 : :
36886 : : static tree
36887 : 0 : cp_parser_objc_protocol_refs_opt (cp_parser* parser)
36888 : : {
36889 : 0 : tree protorefs = NULL_TREE;
36890 : :
36891 : 0 : if(cp_lexer_next_token_is (parser->lexer, CPP_LESS))
36892 : : {
36893 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '<'. */
36894 : 0 : protorefs = cp_parser_objc_identifier_list (parser);
36895 : 0 : cp_parser_require (parser, CPP_GREATER, RT_GREATER);
36896 : : }
36897 : :
36898 : 0 : return protorefs;
36899 : : }
36900 : :
36901 : : /* Parse a Objective-C visibility specification. */
36902 : :
36903 : : static void
36904 : 0 : cp_parser_objc_visibility_spec (cp_parser* parser)
36905 : : {
36906 : 0 : cp_token *vis = cp_lexer_peek_token (parser->lexer);
36907 : :
36908 : 0 : switch (vis->keyword)
36909 : : {
36910 : 0 : case RID_AT_PRIVATE:
36911 : 0 : objc_set_visibility (OBJC_IVAR_VIS_PRIVATE);
36912 : 0 : break;
36913 : 0 : case RID_AT_PROTECTED:
36914 : 0 : objc_set_visibility (OBJC_IVAR_VIS_PROTECTED);
36915 : 0 : break;
36916 : 0 : case RID_AT_PUBLIC:
36917 : 0 : objc_set_visibility (OBJC_IVAR_VIS_PUBLIC);
36918 : 0 : break;
36919 : 0 : case RID_AT_PACKAGE:
36920 : 0 : objc_set_visibility (OBJC_IVAR_VIS_PACKAGE);
36921 : 0 : break;
36922 : : default:
36923 : : return;
36924 : : }
36925 : :
36926 : : /* Eat '@private'/'@protected'/'@public'. */
36927 : 0 : cp_lexer_consume_token (parser->lexer);
36928 : : }
36929 : :
36930 : : /* Parse an Objective-C method type. Return 'true' if it is a class
36931 : : (+) method, and 'false' if it is an instance (-) method. */
36932 : :
36933 : : static inline bool
36934 : 0 : cp_parser_objc_method_type (cp_parser* parser)
36935 : : {
36936 : 0 : if (cp_lexer_consume_token (parser->lexer)->type == CPP_PLUS)
36937 : : return true;
36938 : : else
36939 : 0 : return false;
36940 : : }
36941 : :
36942 : : /* Parse an Objective-C protocol qualifier. */
36943 : :
36944 : : static tree
36945 : 0 : cp_parser_objc_protocol_qualifiers (cp_parser* parser)
36946 : : {
36947 : 0 : tree quals = NULL_TREE, node;
36948 : 0 : cp_token *token = cp_lexer_peek_token (parser->lexer);
36949 : :
36950 : 0 : node = token->u.value;
36951 : :
36952 : 0 : while (node && identifier_p (node)
36953 : 0 : && (node == ridpointers [(int) RID_IN]
36954 : 0 : || node == ridpointers [(int) RID_OUT]
36955 : 0 : || node == ridpointers [(int) RID_INOUT]
36956 : 0 : || node == ridpointers [(int) RID_BYCOPY]
36957 : 0 : || node == ridpointers [(int) RID_BYREF]
36958 : 0 : || node == ridpointers [(int) RID_ONEWAY]))
36959 : : {
36960 : 0 : quals = tree_cons (NULL_TREE, node, quals);
36961 : 0 : cp_lexer_consume_token (parser->lexer);
36962 : 0 : token = cp_lexer_peek_token (parser->lexer);
36963 : 0 : node = token->u.value;
36964 : : }
36965 : :
36966 : 0 : return quals;
36967 : : }
36968 : :
36969 : : /* Parse an Objective-C typename. */
36970 : :
36971 : : static tree
36972 : 0 : cp_parser_objc_typename (cp_parser* parser)
36973 : : {
36974 : 0 : tree type_name = NULL_TREE;
36975 : :
36976 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
36977 : : {
36978 : 0 : tree proto_quals, cp_type = NULL_TREE;
36979 : :
36980 : 0 : matching_parens parens;
36981 : 0 : parens.consume_open (parser); /* Eat '('. */
36982 : 0 : proto_quals = cp_parser_objc_protocol_qualifiers (parser);
36983 : :
36984 : : /* An ObjC type name may consist of just protocol qualifiers, in which
36985 : : case the type shall default to 'id'. */
36986 : 0 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
36987 : : {
36988 : 0 : cp_type = cp_parser_type_id (parser);
36989 : :
36990 : : /* If the type could not be parsed, an error has already
36991 : : been produced. For error recovery, behave as if it had
36992 : : not been specified, which will use the default type
36993 : : 'id'. */
36994 : 0 : if (cp_type == error_mark_node)
36995 : : {
36996 : 0 : cp_type = NULL_TREE;
36997 : : /* We need to skip to the closing parenthesis as
36998 : : cp_parser_type_id() does not seem to do it for
36999 : : us. */
37000 : 0 : cp_parser_skip_to_closing_parenthesis (parser,
37001 : : /*recovering=*/true,
37002 : : /*or_comma=*/false,
37003 : : /*consume_paren=*/false);
37004 : : }
37005 : : }
37006 : :
37007 : 0 : parens.require_close (parser);
37008 : 0 : type_name = build_tree_list (proto_quals, cp_type);
37009 : : }
37010 : :
37011 : 0 : return type_name;
37012 : : }
37013 : :
37014 : : /* Check to see if TYPE refers to an Objective-C selector name. */
37015 : :
37016 : : static bool
37017 : 0 : cp_parser_objc_selector_p (enum cpp_ttype type)
37018 : : {
37019 : 0 : return (type == CPP_NAME || type == CPP_KEYWORD
37020 : : || type == CPP_AND_AND || type == CPP_AND_EQ || type == CPP_AND
37021 : : || type == CPP_OR || type == CPP_COMPL || type == CPP_NOT
37022 : : || type == CPP_NOT_EQ || type == CPP_OR_OR || type == CPP_OR_EQ
37023 : 0 : || type == CPP_XOR || type == CPP_XOR_EQ);
37024 : : }
37025 : :
37026 : : /* Parse an Objective-C selector. */
37027 : :
37028 : : static tree
37029 : 0 : cp_parser_objc_selector (cp_parser* parser)
37030 : : {
37031 : 0 : cp_token *token = cp_lexer_consume_token (parser->lexer);
37032 : :
37033 : 0 : if (!cp_parser_objc_selector_p (token->type))
37034 : : {
37035 : 0 : error_at (token->location, "invalid Objective-C++ selector name");
37036 : 0 : return error_mark_node;
37037 : : }
37038 : :
37039 : : /* C++ operator names are allowed to appear in ObjC selectors. */
37040 : 0 : switch (token->type)
37041 : : {
37042 : 0 : case CPP_AND_AND: return get_identifier ("and");
37043 : 0 : case CPP_AND_EQ: return get_identifier ("and_eq");
37044 : 0 : case CPP_AND: return get_identifier ("bitand");
37045 : 0 : case CPP_OR: return get_identifier ("bitor");
37046 : 0 : case CPP_COMPL: return get_identifier ("compl");
37047 : 0 : case CPP_NOT: return get_identifier ("not");
37048 : 0 : case CPP_NOT_EQ: return get_identifier ("not_eq");
37049 : 0 : case CPP_OR_OR: return get_identifier ("or");
37050 : 0 : case CPP_OR_EQ: return get_identifier ("or_eq");
37051 : 0 : case CPP_XOR: return get_identifier ("xor");
37052 : 0 : case CPP_XOR_EQ: return get_identifier ("xor_eq");
37053 : 0 : default: return token->u.value;
37054 : : }
37055 : : }
37056 : :
37057 : : /* Parse an Objective-C params list. */
37058 : :
37059 : : static tree
37060 : 0 : cp_parser_objc_method_keyword_params (cp_parser* parser, tree* attributes)
37061 : : {
37062 : 0 : tree params = NULL_TREE;
37063 : 0 : bool maybe_unary_selector_p = true;
37064 : 0 : cp_token *token = cp_lexer_peek_token (parser->lexer);
37065 : :
37066 : 0 : while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
37067 : : {
37068 : 0 : tree selector = NULL_TREE, type_name, identifier;
37069 : 0 : tree parm_attr = NULL_TREE;
37070 : :
37071 : 0 : if (token->keyword == RID_ATTRIBUTE)
37072 : : break;
37073 : :
37074 : 0 : if (token->type != CPP_COLON)
37075 : 0 : selector = cp_parser_objc_selector (parser);
37076 : :
37077 : : /* Detect if we have a unary selector. */
37078 : 0 : if (maybe_unary_selector_p
37079 : 0 : && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
37080 : : {
37081 : : params = selector; /* Might be followed by attributes. */
37082 : : break;
37083 : : }
37084 : :
37085 : 0 : maybe_unary_selector_p = false;
37086 : 0 : if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
37087 : : {
37088 : : /* Something went quite wrong. There should be a colon
37089 : : here, but there is not. Stop parsing parameters. */
37090 : : break;
37091 : : }
37092 : 0 : type_name = cp_parser_objc_typename (parser);
37093 : : /* New ObjC allows attributes on parameters too. */
37094 : 0 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
37095 : 0 : parm_attr = cp_parser_attributes_opt (parser);
37096 : 0 : identifier = cp_parser_identifier (parser);
37097 : :
37098 : 0 : params
37099 : 0 : = chainon (params,
37100 : : objc_build_keyword_decl (selector,
37101 : : type_name,
37102 : : identifier,
37103 : : parm_attr));
37104 : :
37105 : 0 : token = cp_lexer_peek_token (parser->lexer);
37106 : : }
37107 : :
37108 : 0 : if (params == NULL_TREE)
37109 : : {
37110 : 0 : cp_parser_error (parser, "objective-c++ method declaration is expected");
37111 : 0 : return error_mark_node;
37112 : : }
37113 : :
37114 : : /* We allow tail attributes for the method. */
37115 : 0 : if (token->keyword == RID_ATTRIBUTE)
37116 : : {
37117 : 0 : *attributes = cp_parser_attributes_opt (parser);
37118 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
37119 : 0 : || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
37120 : : return params;
37121 : 0 : cp_parser_error (parser,
37122 : : "method attributes must be specified at the end");
37123 : 0 : return error_mark_node;
37124 : : }
37125 : :
37126 : : if (params == NULL_TREE)
37127 : : {
37128 : : cp_parser_error (parser, "objective-c++ method declaration is expected");
37129 : : return error_mark_node;
37130 : : }
37131 : : return params;
37132 : : }
37133 : :
37134 : : /* Parse the non-keyword Objective-C params. */
37135 : :
37136 : : static tree
37137 : 0 : cp_parser_objc_method_tail_params_opt (cp_parser* parser, bool *ellipsisp,
37138 : : tree* attributes)
37139 : : {
37140 : 0 : tree params = make_node (TREE_LIST);
37141 : 0 : cp_token *token = cp_lexer_peek_token (parser->lexer);
37142 : 0 : *ellipsisp = false; /* Initially, assume no ellipsis. */
37143 : :
37144 : 0 : while (token->type == CPP_COMMA)
37145 : : {
37146 : 0 : cp_parameter_declarator *parmdecl;
37147 : 0 : tree parm;
37148 : :
37149 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat ','. */
37150 : 0 : token = cp_lexer_peek_token (parser->lexer);
37151 : :
37152 : 0 : if (token->type == CPP_ELLIPSIS)
37153 : : {
37154 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '...'. */
37155 : 0 : *ellipsisp = true;
37156 : 0 : token = cp_lexer_peek_token (parser->lexer);
37157 : 0 : break;
37158 : : }
37159 : :
37160 : : /* TODO: parse attributes for tail parameters. */
37161 : 0 : parmdecl = cp_parser_parameter_declaration (parser, CP_PARSER_FLAGS_NONE,
37162 : : false, NULL);
37163 : 0 : parm = grokdeclarator (parmdecl->declarator,
37164 : : &parmdecl->decl_specifiers,
37165 : : PARM, /*initialized=*/0,
37166 : : /*attrlist=*/NULL);
37167 : :
37168 : 0 : chainon (params, build_tree_list (NULL_TREE, parm));
37169 : 0 : token = cp_lexer_peek_token (parser->lexer);
37170 : : }
37171 : :
37172 : : /* We allow tail attributes for the method. */
37173 : 0 : if (token->keyword == RID_ATTRIBUTE)
37174 : : {
37175 : 0 : if (*attributes == NULL_TREE)
37176 : : {
37177 : 0 : *attributes = cp_parser_attributes_opt (parser);
37178 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
37179 : 0 : || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
37180 : : return params;
37181 : : }
37182 : : else
37183 : : /* We have an error, but parse the attributes, so that we can
37184 : : carry on. */
37185 : 0 : *attributes = cp_parser_attributes_opt (parser);
37186 : :
37187 : 0 : cp_parser_error (parser,
37188 : : "method attributes must be specified at the end");
37189 : 0 : return error_mark_node;
37190 : : }
37191 : :
37192 : : return params;
37193 : : }
37194 : :
37195 : : /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
37196 : :
37197 : : static void
37198 : 0 : cp_parser_objc_interstitial_code (cp_parser* parser)
37199 : : {
37200 : 0 : cp_token *token = cp_lexer_peek_token (parser->lexer);
37201 : :
37202 : : /* If the next token is `extern' and the following token is a string
37203 : : literal, then we have a linkage specification. */
37204 : 0 : if (token->keyword == RID_EXTERN
37205 : 0 : && cp_parser_is_pure_string_literal
37206 : 0 : (cp_lexer_peek_nth_token (parser->lexer, 2)))
37207 : 0 : cp_parser_linkage_specification (parser, NULL_TREE);
37208 : : /* Handle #pragma, if any. */
37209 : 0 : else if (token->type == CPP_PRAGMA)
37210 : 0 : cp_parser_pragma (parser, pragma_objc_icode, NULL);
37211 : : /* Allow stray semicolons. */
37212 : 0 : else if (token->type == CPP_SEMICOLON)
37213 : 0 : cp_lexer_consume_token (parser->lexer);
37214 : : /* Mark methods as optional or required, when building protocols. */
37215 : 0 : else if (token->keyword == RID_AT_OPTIONAL)
37216 : : {
37217 : 0 : cp_lexer_consume_token (parser->lexer);
37218 : 0 : objc_set_method_opt (true);
37219 : : }
37220 : 0 : else if (token->keyword == RID_AT_REQUIRED)
37221 : : {
37222 : 0 : cp_lexer_consume_token (parser->lexer);
37223 : 0 : objc_set_method_opt (false);
37224 : : }
37225 : 0 : else if (token->keyword == RID_NAMESPACE)
37226 : 0 : cp_parser_namespace_definition (parser);
37227 : : /* Other stray characters must generate errors. */
37228 : 0 : else if (token->type == CPP_OPEN_BRACE || token->type == CPP_CLOSE_BRACE)
37229 : : {
37230 : 0 : cp_lexer_consume_token (parser->lexer);
37231 : 0 : error ("stray %qs between Objective-C++ methods",
37232 : 0 : token->type == CPP_OPEN_BRACE ? "{" : "}");
37233 : : }
37234 : : /* Finally, try to parse a block-declaration, or a function-definition. */
37235 : : else
37236 : 0 : cp_parser_block_declaration (parser, /*statement_p=*/false);
37237 : 0 : }
37238 : :
37239 : : /* Parse a method signature. */
37240 : :
37241 : : static tree
37242 : 0 : cp_parser_objc_method_signature (cp_parser* parser, tree* attributes)
37243 : : {
37244 : 0 : tree rettype, kwdparms, optparms;
37245 : 0 : bool ellipsis = false;
37246 : 0 : bool is_class_method;
37247 : :
37248 : 0 : is_class_method = cp_parser_objc_method_type (parser);
37249 : 0 : rettype = cp_parser_objc_typename (parser);
37250 : 0 : *attributes = NULL_TREE;
37251 : 0 : kwdparms = cp_parser_objc_method_keyword_params (parser, attributes);
37252 : 0 : if (kwdparms == error_mark_node)
37253 : : return error_mark_node;
37254 : 0 : optparms = cp_parser_objc_method_tail_params_opt (parser, &ellipsis, attributes);
37255 : 0 : if (optparms == error_mark_node)
37256 : : return error_mark_node;
37257 : :
37258 : 0 : return objc_build_method_signature (is_class_method, rettype, kwdparms, optparms, ellipsis);
37259 : : }
37260 : :
37261 : : static bool
37262 : 0 : cp_parser_objc_method_maybe_bad_prefix_attributes (cp_parser* parser)
37263 : : {
37264 : 0 : tree tattr;
37265 : 0 : cp_lexer_save_tokens (parser->lexer);
37266 : 0 : tattr = cp_parser_attributes_opt (parser);
37267 : 0 : gcc_assert (tattr) ;
37268 : :
37269 : : /* If the attributes are followed by a method introducer, this is not allowed.
37270 : : Dump the attributes and flag the situation. */
37271 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_PLUS)
37272 : 0 : || cp_lexer_next_token_is (parser->lexer, CPP_MINUS))
37273 : : return true;
37274 : :
37275 : : /* Otherwise, the attributes introduce some interstitial code, possibly so
37276 : : rewind to allow that check. */
37277 : 0 : cp_lexer_rollback_tokens (parser->lexer);
37278 : 0 : return false;
37279 : : }
37280 : :
37281 : : /* Parse an Objective-C method prototype list. */
37282 : :
37283 : : static void
37284 : 0 : cp_parser_objc_method_prototype_list (cp_parser* parser)
37285 : : {
37286 : 0 : cp_token *token = cp_lexer_peek_token (parser->lexer);
37287 : :
37288 : 0 : while (token->keyword != RID_AT_END && token->type != CPP_EOF)
37289 : : {
37290 : 0 : if (token->type == CPP_PLUS || token->type == CPP_MINUS)
37291 : : {
37292 : 0 : tree attributes, sig;
37293 : 0 : bool is_class_method;
37294 : 0 : if (token->type == CPP_PLUS)
37295 : : is_class_method = true;
37296 : : else
37297 : 0 : is_class_method = false;
37298 : 0 : sig = cp_parser_objc_method_signature (parser, &attributes);
37299 : 0 : if (sig == error_mark_node)
37300 : : {
37301 : 0 : cp_parser_skip_to_end_of_block_or_statement (parser);
37302 : 0 : token = cp_lexer_peek_token (parser->lexer);
37303 : 0 : continue;
37304 : : }
37305 : 0 : objc_add_method_declaration (is_class_method, sig, attributes);
37306 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
37307 : : }
37308 : 0 : else if (token->keyword == RID_AT_PROPERTY)
37309 : 0 : cp_parser_objc_at_property_declaration (parser);
37310 : 0 : else if (token->keyword == RID_ATTRIBUTE
37311 : 0 : && cp_parser_objc_method_maybe_bad_prefix_attributes(parser))
37312 : 0 : warning_at (cp_lexer_peek_token (parser->lexer)->location,
37313 : : OPT_Wattributes,
37314 : : "prefix attributes are ignored for methods");
37315 : : else
37316 : : /* Allow for interspersed non-ObjC++ code. */
37317 : 0 : cp_parser_objc_interstitial_code (parser);
37318 : :
37319 : 0 : token = cp_lexer_peek_token (parser->lexer);
37320 : : }
37321 : :
37322 : 0 : if (token->type != CPP_EOF)
37323 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
37324 : : else
37325 : 0 : cp_parser_error (parser, "expected %<@end%>");
37326 : :
37327 : 0 : objc_finish_interface ();
37328 : 0 : }
37329 : :
37330 : : /* Parse an Objective-C method definition list. */
37331 : :
37332 : : static void
37333 : 0 : cp_parser_objc_method_definition_list (cp_parser* parser)
37334 : : {
37335 : 0 : for (;;)
37336 : : {
37337 : 0 : cp_token *token = cp_lexer_peek_token (parser->lexer);
37338 : :
37339 : 0 : if (token->keyword == RID_AT_END)
37340 : : {
37341 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
37342 : 0 : break;
37343 : : }
37344 : 0 : else if (token->type == CPP_EOF)
37345 : : {
37346 : 0 : cp_parser_error (parser, "expected %<@end%>");
37347 : 0 : break;
37348 : : }
37349 : 0 : else if (token->type == CPP_PLUS || token->type == CPP_MINUS)
37350 : : {
37351 : 0 : bool is_class_method = token->type == CPP_PLUS;
37352 : :
37353 : 0 : push_deferring_access_checks (dk_deferred);
37354 : 0 : tree attribute;
37355 : 0 : tree sig = cp_parser_objc_method_signature (parser, &attribute);
37356 : 0 : if (sig == error_mark_node)
37357 : 0 : cp_parser_skip_to_end_of_block_or_statement (parser);
37358 : : else
37359 : : {
37360 : 0 : objc_start_method_definition (is_class_method, sig,
37361 : : attribute, NULL_TREE);
37362 : :
37363 : : /* For historical reasons, we accept an optional semicolon. */
37364 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
37365 : 0 : cp_lexer_consume_token (parser->lexer);
37366 : :
37367 : 0 : perform_deferred_access_checks (tf_warning_or_error);
37368 : 0 : stop_deferring_access_checks ();
37369 : 0 : tree meth
37370 : 0 : = cp_parser_function_definition_after_declarator (parser, false);
37371 : 0 : pop_deferring_access_checks ();
37372 : 0 : objc_finish_method_definition (meth);
37373 : : }
37374 : : }
37375 : : /* The following case will be removed once @synthesize is
37376 : : completely implemented. */
37377 : 0 : else if (token->keyword == RID_AT_PROPERTY)
37378 : 0 : cp_parser_objc_at_property_declaration (parser);
37379 : 0 : else if (token->keyword == RID_AT_SYNTHESIZE)
37380 : 0 : cp_parser_objc_at_synthesize_declaration (parser);
37381 : 0 : else if (token->keyword == RID_AT_DYNAMIC)
37382 : 0 : cp_parser_objc_at_dynamic_declaration (parser);
37383 : 0 : else if (token->keyword == RID_ATTRIBUTE
37384 : 0 : && cp_parser_objc_method_maybe_bad_prefix_attributes(parser))
37385 : 0 : warning_at (token->location, OPT_Wattributes,
37386 : : "prefix attributes are ignored for methods");
37387 : : else
37388 : : /* Allow for interspersed non-ObjC++ code. */
37389 : 0 : cp_parser_objc_interstitial_code (parser);
37390 : : }
37391 : :
37392 : 0 : objc_finish_implementation ();
37393 : 0 : }
37394 : :
37395 : : /* Parse Objective-C ivars. */
37396 : :
37397 : : static void
37398 : 0 : cp_parser_objc_class_ivars (cp_parser* parser)
37399 : : {
37400 : 0 : cp_token *token = cp_lexer_peek_token (parser->lexer);
37401 : :
37402 : 0 : if (token->type != CPP_OPEN_BRACE)
37403 : : return; /* No ivars specified. */
37404 : :
37405 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '{'. */
37406 : 0 : token = cp_lexer_peek_token (parser->lexer);
37407 : :
37408 : 0 : while (token->type != CPP_CLOSE_BRACE
37409 : 0 : && token->keyword != RID_AT_END && token->type != CPP_EOF)
37410 : : {
37411 : 0 : cp_decl_specifier_seq declspecs;
37412 : 0 : int decl_class_or_enum_p;
37413 : 0 : tree prefix_attributes;
37414 : :
37415 : 0 : cp_parser_objc_visibility_spec (parser);
37416 : :
37417 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
37418 : : break;
37419 : :
37420 : 0 : cp_parser_decl_specifier_seq (parser,
37421 : : CP_PARSER_FLAGS_OPTIONAL,
37422 : : &declspecs,
37423 : : &decl_class_or_enum_p);
37424 : :
37425 : : /* auto, register, static, extern, mutable. */
37426 : 0 : if (declspecs.storage_class != sc_none)
37427 : : {
37428 : 0 : cp_parser_error (parser, "invalid type for instance variable");
37429 : 0 : declspecs.storage_class = sc_none;
37430 : : }
37431 : :
37432 : : /* thread_local. */
37433 : 0 : if (decl_spec_seq_has_spec_p (&declspecs, ds_thread))
37434 : : {
37435 : 0 : cp_parser_error (parser, "invalid type for instance variable");
37436 : 0 : declspecs.locations[ds_thread] = 0;
37437 : : }
37438 : :
37439 : : /* typedef. */
37440 : 0 : if (decl_spec_seq_has_spec_p (&declspecs, ds_typedef))
37441 : : {
37442 : 0 : cp_parser_error (parser, "invalid type for instance variable");
37443 : 0 : declspecs.locations[ds_typedef] = 0;
37444 : : }
37445 : :
37446 : 0 : prefix_attributes = declspecs.attributes;
37447 : 0 : declspecs.attributes = NULL_TREE;
37448 : :
37449 : : /* Keep going until we hit the `;' at the end of the
37450 : : declaration. */
37451 : 0 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
37452 : : {
37453 : 0 : tree width = NULL_TREE, attributes, first_attribute, decl;
37454 : 0 : cp_declarator *declarator = NULL;
37455 : 0 : int ctor_dtor_or_conv_p;
37456 : :
37457 : : /* Check for a (possibly unnamed) bitfield declaration. */
37458 : 0 : token = cp_lexer_peek_token (parser->lexer);
37459 : 0 : if (token->type == CPP_COLON)
37460 : 0 : goto eat_colon;
37461 : :
37462 : 0 : if (token->type == CPP_NAME
37463 : 0 : && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
37464 : : == CPP_COLON))
37465 : : {
37466 : : /* Get the name of the bitfield. */
37467 : 0 : declarator = make_id_declarator (NULL_TREE,
37468 : 0 : cp_parser_identifier (parser),
37469 : : sfk_none, token->location);
37470 : :
37471 : 0 : eat_colon:
37472 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
37473 : : /* Get the width of the bitfield. */
37474 : 0 : width
37475 : 0 : = cp_parser_constant_expression (parser);
37476 : : }
37477 : : else
37478 : : {
37479 : : /* Parse the declarator. */
37480 : 0 : declarator
37481 : 0 : = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
37482 : : CP_PARSER_FLAGS_NONE,
37483 : : &ctor_dtor_or_conv_p,
37484 : : /*parenthesized_p=*/NULL,
37485 : : /*member_p=*/false,
37486 : : /*friend_p=*/false,
37487 : : /*static_p=*/false);
37488 : : }
37489 : :
37490 : : /* Look for attributes that apply to the ivar. */
37491 : 0 : attributes = cp_parser_attributes_opt (parser);
37492 : : /* Remember which attributes are prefix attributes and
37493 : : which are not. */
37494 : 0 : first_attribute = attributes;
37495 : : /* Combine the attributes. */
37496 : 0 : attributes = attr_chainon (prefix_attributes, attributes);
37497 : :
37498 : 0 : if (width)
37499 : : /* Create the bitfield declaration. */
37500 : 0 : decl = grokbitfield (declarator, &declspecs,
37501 : : width, NULL_TREE, attributes);
37502 : : else
37503 : 0 : decl = grokfield (declarator, &declspecs,
37504 : : NULL_TREE, /*init_const_expr_p=*/false,
37505 : : NULL_TREE, attributes);
37506 : :
37507 : : /* Add the instance variable. */
37508 : 0 : if (decl != error_mark_node && decl != NULL_TREE)
37509 : 0 : objc_add_instance_variable (decl);
37510 : :
37511 : : /* Reset PREFIX_ATTRIBUTES. */
37512 : 0 : if (attributes != error_mark_node)
37513 : : {
37514 : 0 : while (attributes && TREE_CHAIN (attributes) != first_attribute)
37515 : 0 : attributes = TREE_CHAIN (attributes);
37516 : 0 : if (attributes)
37517 : 0 : TREE_CHAIN (attributes) = NULL_TREE;
37518 : : }
37519 : :
37520 : 0 : token = cp_lexer_peek_token (parser->lexer);
37521 : :
37522 : 0 : if (token->type == CPP_COMMA)
37523 : : {
37524 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat ','. */
37525 : 0 : continue;
37526 : : }
37527 : 0 : break;
37528 : : }
37529 : :
37530 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
37531 : 0 : token = cp_lexer_peek_token (parser->lexer);
37532 : : }
37533 : :
37534 : 0 : if (token->keyword == RID_AT_END)
37535 : 0 : cp_parser_error (parser, "expected %<}%>");
37536 : :
37537 : : /* Do not consume the RID_AT_END, so it will be read again as terminating
37538 : : the @interface of @implementation. */
37539 : 0 : if (token->keyword != RID_AT_END && token->type != CPP_EOF)
37540 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '}'. */
37541 : :
37542 : : /* For historical reasons, we accept an optional semicolon. */
37543 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
37544 : 0 : cp_lexer_consume_token (parser->lexer);
37545 : : }
37546 : :
37547 : : /* Parse an Objective-C protocol declaration. */
37548 : :
37549 : : static void
37550 : 0 : cp_parser_objc_protocol_declaration (cp_parser* parser, tree attributes)
37551 : : {
37552 : 0 : tree proto, protorefs;
37553 : 0 : cp_token *tok;
37554 : :
37555 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
37556 : 0 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
37557 : : {
37558 : 0 : tok = cp_lexer_peek_token (parser->lexer);
37559 : 0 : error_at (tok->location, "identifier expected after %<@protocol%>");
37560 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
37561 : 0 : return;
37562 : : }
37563 : :
37564 : : /* See if we have a forward declaration or a definition. */
37565 : 0 : tok = cp_lexer_peek_nth_token (parser->lexer, 2);
37566 : :
37567 : : /* Try a forward declaration first. */
37568 : 0 : if (tok->type == CPP_COMMA || tok->type == CPP_SEMICOLON)
37569 : : {
37570 : 0 : while (true)
37571 : : {
37572 : 0 : tree id;
37573 : :
37574 : 0 : id = cp_parser_identifier (parser);
37575 : 0 : if (id == error_mark_node)
37576 : : break;
37577 : :
37578 : 0 : objc_declare_protocol (id, attributes);
37579 : :
37580 : 0 : if(cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
37581 : 0 : cp_lexer_consume_token (parser->lexer);
37582 : : else
37583 : : break;
37584 : 0 : }
37585 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
37586 : 0 : }
37587 : :
37588 : : /* Ok, we got a full-fledged definition (or at least should). */
37589 : : else
37590 : : {
37591 : 0 : proto = cp_parser_identifier (parser);
37592 : 0 : protorefs = cp_parser_objc_protocol_refs_opt (parser);
37593 : 0 : objc_start_protocol (proto, protorefs, attributes);
37594 : 0 : cp_parser_objc_method_prototype_list (parser);
37595 : : }
37596 : : }
37597 : :
37598 : : /* Parse an Objective-C superclass or category. */
37599 : :
37600 : : static void
37601 : 0 : cp_parser_objc_superclass_or_category (cp_parser *parser,
37602 : : bool iface_p,
37603 : : tree *super,
37604 : : tree *categ, bool *is_class_extension)
37605 : : {
37606 : 0 : cp_token *next = cp_lexer_peek_token (parser->lexer);
37607 : :
37608 : 0 : *super = *categ = NULL_TREE;
37609 : 0 : *is_class_extension = false;
37610 : 0 : if (next->type == CPP_COLON)
37611 : : {
37612 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
37613 : 0 : *super = cp_parser_identifier (parser);
37614 : : }
37615 : 0 : else if (next->type == CPP_OPEN_PAREN)
37616 : : {
37617 : 0 : matching_parens parens;
37618 : 0 : parens.consume_open (parser); /* Eat '('. */
37619 : :
37620 : : /* If there is no category name, and this is an @interface, we
37621 : : have a class extension. */
37622 : 0 : if (iface_p && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
37623 : : {
37624 : 0 : *categ = NULL_TREE;
37625 : 0 : *is_class_extension = true;
37626 : : }
37627 : : else
37628 : 0 : *categ = cp_parser_identifier (parser);
37629 : :
37630 : 0 : parens.require_close (parser);
37631 : : }
37632 : 0 : }
37633 : :
37634 : : /* Parse an Objective-C class interface. */
37635 : :
37636 : : static void
37637 : 0 : cp_parser_objc_class_interface (cp_parser* parser, tree attributes)
37638 : : {
37639 : 0 : tree name, super, categ, protos;
37640 : 0 : bool is_class_extension;
37641 : :
37642 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@interface'. */
37643 : 0 : location_t nam_loc = cp_lexer_peek_token (parser->lexer)->location;
37644 : 0 : name = cp_parser_identifier (parser);
37645 : 0 : if (name == error_mark_node)
37646 : : {
37647 : : /* It's hard to recover because even if valid @interface stuff
37648 : : is to follow, we can't compile it (or validate it) if we
37649 : : don't even know which class it refers to. Let's assume this
37650 : : was a stray '@interface' token in the stream and skip it.
37651 : : */
37652 : 0 : return;
37653 : : }
37654 : 0 : cp_parser_objc_superclass_or_category (parser, true, &super, &categ,
37655 : : &is_class_extension);
37656 : 0 : protos = cp_parser_objc_protocol_refs_opt (parser);
37657 : :
37658 : : /* We have either a class or a category on our hands. */
37659 : 0 : if (categ || is_class_extension)
37660 : 0 : objc_start_category_interface (name, categ, protos, attributes);
37661 : : else
37662 : : {
37663 : 0 : objc_start_class_interface (name, nam_loc, super, protos, attributes);
37664 : : /* Handle instance variable declarations, if any. */
37665 : 0 : cp_parser_objc_class_ivars (parser);
37666 : 0 : objc_continue_interface ();
37667 : : }
37668 : :
37669 : 0 : cp_parser_objc_method_prototype_list (parser);
37670 : : }
37671 : :
37672 : : /* Parse an Objective-C class implementation. */
37673 : :
37674 : : static void
37675 : 0 : cp_parser_objc_class_implementation (cp_parser* parser)
37676 : : {
37677 : 0 : tree name, super, categ;
37678 : 0 : bool is_class_extension;
37679 : :
37680 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@implementation'. */
37681 : 0 : name = cp_parser_identifier (parser);
37682 : 0 : if (name == error_mark_node)
37683 : : {
37684 : : /* It's hard to recover because even if valid @implementation
37685 : : stuff is to follow, we can't compile it (or validate it) if
37686 : : we don't even know which class it refers to. Let's assume
37687 : : this was a stray '@implementation' token in the stream and
37688 : : skip it.
37689 : : */
37690 : 0 : return;
37691 : : }
37692 : 0 : cp_parser_objc_superclass_or_category (parser, false, &super, &categ,
37693 : : &is_class_extension);
37694 : :
37695 : : /* We have either a class or a category on our hands. */
37696 : 0 : if (categ)
37697 : 0 : objc_start_category_implementation (name, categ);
37698 : : else
37699 : : {
37700 : 0 : objc_start_class_implementation (name, super);
37701 : : /* Handle instance variable declarations, if any. */
37702 : 0 : cp_parser_objc_class_ivars (parser);
37703 : 0 : objc_continue_implementation ();
37704 : : }
37705 : :
37706 : 0 : cp_parser_objc_method_definition_list (parser);
37707 : : }
37708 : :
37709 : : /* Consume the @end token and finish off the implementation. */
37710 : :
37711 : : static void
37712 : 0 : cp_parser_objc_end_implementation (cp_parser* parser)
37713 : : {
37714 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
37715 : 0 : objc_finish_implementation ();
37716 : 0 : }
37717 : :
37718 : : /* Parse an Objective-C declaration. */
37719 : :
37720 : : static void
37721 : 0 : cp_parser_objc_declaration (cp_parser* parser, tree attributes)
37722 : : {
37723 : : /* Try to figure out what kind of declaration is present. */
37724 : 0 : cp_token *kwd = cp_lexer_peek_token (parser->lexer);
37725 : :
37726 : 0 : if (attributes)
37727 : 0 : switch (kwd->keyword)
37728 : : {
37729 : 0 : case RID_AT_ALIAS:
37730 : 0 : case RID_AT_CLASS:
37731 : 0 : case RID_AT_END:
37732 : 0 : error_at (kwd->location, "attributes may not be specified before"
37733 : : " the %<@%D%> Objective-C++ keyword",
37734 : : kwd->u.value);
37735 : 0 : attributes = NULL;
37736 : 0 : break;
37737 : 0 : case RID_AT_IMPLEMENTATION:
37738 : 0 : warning_at (kwd->location, OPT_Wattributes,
37739 : : "prefix attributes are ignored before %<@%D%>",
37740 : : kwd->u.value);
37741 : 0 : attributes = NULL;
37742 : : default:
37743 : : break;
37744 : : }
37745 : :
37746 : 0 : switch (kwd->keyword)
37747 : : {
37748 : 0 : case RID_AT_ALIAS:
37749 : 0 : cp_parser_objc_alias_declaration (parser);
37750 : 0 : break;
37751 : 0 : case RID_AT_CLASS:
37752 : 0 : cp_parser_objc_class_declaration (parser);
37753 : 0 : break;
37754 : 0 : case RID_AT_PROTOCOL:
37755 : 0 : cp_parser_objc_protocol_declaration (parser, attributes);
37756 : 0 : break;
37757 : 0 : case RID_AT_INTERFACE:
37758 : 0 : cp_parser_objc_class_interface (parser, attributes);
37759 : 0 : break;
37760 : 0 : case RID_AT_IMPLEMENTATION:
37761 : 0 : cp_parser_objc_class_implementation (parser);
37762 : 0 : break;
37763 : 0 : case RID_AT_END:
37764 : 0 : cp_parser_objc_end_implementation (parser);
37765 : 0 : break;
37766 : 0 : default:
37767 : 0 : error_at (kwd->location, "misplaced %<@%D%> Objective-C++ construct",
37768 : : kwd->u.value);
37769 : 0 : cp_parser_skip_to_end_of_block_or_statement (parser);
37770 : : }
37771 : 0 : }
37772 : :
37773 : : /* Parse an Objective-C try-catch-finally statement.
37774 : :
37775 : : objc-try-catch-finally-stmt:
37776 : : @try compound-statement objc-catch-clause-seq [opt]
37777 : : objc-finally-clause [opt]
37778 : :
37779 : : objc-catch-clause-seq:
37780 : : objc-catch-clause objc-catch-clause-seq [opt]
37781 : :
37782 : : objc-catch-clause:
37783 : : @catch ( objc-exception-declaration ) compound-statement
37784 : :
37785 : : objc-finally-clause:
37786 : : @finally compound-statement
37787 : :
37788 : : objc-exception-declaration:
37789 : : parameter-declaration
37790 : : '...'
37791 : :
37792 : : where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
37793 : :
37794 : : Returns NULL_TREE.
37795 : :
37796 : : PS: This function is identical to c_parser_objc_try_catch_finally_statement
37797 : : for C. Keep them in sync. */
37798 : :
37799 : : static tree
37800 : 0 : cp_parser_objc_try_catch_finally_statement (cp_parser *parser)
37801 : : {
37802 : 0 : location_t location;
37803 : 0 : tree stmt;
37804 : :
37805 : 0 : cp_parser_require_keyword (parser, RID_AT_TRY, RT_AT_TRY);
37806 : 0 : location = cp_lexer_peek_token (parser->lexer)->location;
37807 : 0 : objc_maybe_warn_exceptions (location);
37808 : : /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
37809 : : node, lest it get absorbed into the surrounding block. */
37810 : 0 : stmt = push_stmt_list ();
37811 : 0 : cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
37812 : 0 : objc_begin_try_stmt (location, pop_stmt_list (stmt));
37813 : :
37814 : 0 : while (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_CATCH))
37815 : : {
37816 : 0 : cp_parameter_declarator *parm;
37817 : 0 : tree parameter_declaration = error_mark_node;
37818 : 0 : bool seen_open_paren = false;
37819 : 0 : matching_parens parens;
37820 : :
37821 : 0 : cp_lexer_consume_token (parser->lexer);
37822 : 0 : if (parens.require_open (parser))
37823 : : seen_open_paren = true;
37824 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
37825 : : {
37826 : : /* We have "@catch (...)" (where the '...' are literally
37827 : : what is in the code). Skip the '...'.
37828 : : parameter_declaration is set to NULL_TREE, and
37829 : : objc_being_catch_clauses() knows that that means
37830 : : '...'. */
37831 : 0 : cp_lexer_consume_token (parser->lexer);
37832 : 0 : parameter_declaration = NULL_TREE;
37833 : : }
37834 : : else
37835 : : {
37836 : : /* We have "@catch (NSException *exception)" or something
37837 : : like that. Parse the parameter declaration. */
37838 : 0 : parm = cp_parser_parameter_declaration (parser, CP_PARSER_FLAGS_NONE,
37839 : : false, NULL);
37840 : 0 : if (parm == NULL)
37841 : 0 : parameter_declaration = error_mark_node;
37842 : : else
37843 : 0 : parameter_declaration = grokdeclarator (parm->declarator,
37844 : : &parm->decl_specifiers,
37845 : : PARM, /*initialized=*/0,
37846 : : /*attrlist=*/NULL);
37847 : : }
37848 : 0 : if (seen_open_paren)
37849 : 0 : parens.require_close (parser);
37850 : : else
37851 : : {
37852 : : /* If there was no open parenthesis, we are recovering from
37853 : : an error, and we are trying to figure out what mistake
37854 : : the user has made. */
37855 : :
37856 : : /* If there is an immediate closing parenthesis, the user
37857 : : probably forgot the opening one (ie, they typed "@catch
37858 : : NSException *e)". Parse the closing parenthesis and keep
37859 : : going. */
37860 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
37861 : 0 : cp_lexer_consume_token (parser->lexer);
37862 : :
37863 : : /* If these is no immediate closing parenthesis, the user
37864 : : probably doesn't know that parenthesis are required at
37865 : : all (ie, they typed "@catch NSException *e"). So, just
37866 : : forget about the closing parenthesis and keep going. */
37867 : : }
37868 : 0 : objc_begin_catch_clause (parameter_declaration);
37869 : 0 : cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
37870 : 0 : objc_finish_catch_clause ();
37871 : : }
37872 : 0 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_FINALLY))
37873 : : {
37874 : 0 : cp_lexer_consume_token (parser->lexer);
37875 : 0 : location = cp_lexer_peek_token (parser->lexer)->location;
37876 : : /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
37877 : : node, lest it get absorbed into the surrounding block. */
37878 : 0 : stmt = push_stmt_list ();
37879 : 0 : cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
37880 : 0 : objc_build_finally_clause (location, pop_stmt_list (stmt));
37881 : : }
37882 : :
37883 : 0 : return objc_finish_try_stmt ();
37884 : : }
37885 : :
37886 : : /* Parse an Objective-C synchronized statement.
37887 : :
37888 : : objc-synchronized-stmt:
37889 : : @synchronized ( expression ) compound-statement
37890 : :
37891 : : Returns NULL_TREE. */
37892 : :
37893 : : static tree
37894 : 0 : cp_parser_objc_synchronized_statement (cp_parser *parser)
37895 : : {
37896 : 0 : location_t location;
37897 : 0 : tree lock, stmt;
37898 : :
37899 : 0 : cp_parser_require_keyword (parser, RID_AT_SYNCHRONIZED, RT_AT_SYNCHRONIZED);
37900 : :
37901 : 0 : location = cp_lexer_peek_token (parser->lexer)->location;
37902 : 0 : objc_maybe_warn_exceptions (location);
37903 : 0 : matching_parens parens;
37904 : 0 : parens.require_open (parser);
37905 : 0 : lock = cp_parser_expression (parser);
37906 : 0 : parens.require_close (parser);
37907 : :
37908 : : /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
37909 : : node, lest it get absorbed into the surrounding block. */
37910 : 0 : stmt = push_stmt_list ();
37911 : 0 : cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
37912 : :
37913 : 0 : return objc_build_synchronized (location, lock, pop_stmt_list (stmt));
37914 : : }
37915 : :
37916 : : /* Parse an Objective-C throw statement.
37917 : :
37918 : : objc-throw-stmt:
37919 : : @throw assignment-expression [opt] ;
37920 : :
37921 : : Returns a constructed '@throw' statement. */
37922 : :
37923 : : static tree
37924 : 0 : cp_parser_objc_throw_statement (cp_parser *parser)
37925 : : {
37926 : 0 : tree expr = NULL_TREE;
37927 : 0 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
37928 : :
37929 : 0 : cp_parser_require_keyword (parser, RID_AT_THROW, RT_AT_THROW);
37930 : :
37931 : 0 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
37932 : 0 : expr = cp_parser_expression (parser);
37933 : :
37934 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
37935 : :
37936 : 0 : return objc_build_throw_stmt (loc, expr);
37937 : : }
37938 : :
37939 : : /* Parse an Objective-C statement. */
37940 : :
37941 : : static tree
37942 : 0 : cp_parser_objc_statement (cp_parser * parser)
37943 : : {
37944 : : /* Try to figure out what kind of declaration is present. */
37945 : 0 : cp_token *kwd = cp_lexer_peek_token (parser->lexer);
37946 : :
37947 : 0 : switch (kwd->keyword)
37948 : : {
37949 : 0 : case RID_AT_TRY:
37950 : 0 : return cp_parser_objc_try_catch_finally_statement (parser);
37951 : 0 : case RID_AT_SYNCHRONIZED:
37952 : 0 : return cp_parser_objc_synchronized_statement (parser);
37953 : 0 : case RID_AT_THROW:
37954 : 0 : return cp_parser_objc_throw_statement (parser);
37955 : 0 : default:
37956 : 0 : error_at (kwd->location, "misplaced %<@%D%> Objective-C++ construct",
37957 : : kwd->u.value);
37958 : 0 : cp_parser_skip_to_end_of_block_or_statement (parser);
37959 : : }
37960 : :
37961 : 0 : return error_mark_node;
37962 : : }
37963 : :
37964 : : /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
37965 : : look ahead to see if an objc keyword follows the attributes. This
37966 : : is to detect the use of prefix attributes on ObjC @interface and
37967 : : @protocol. */
37968 : :
37969 : : static bool
37970 : 0 : cp_parser_objc_valid_prefix_attributes (cp_parser* parser, tree *attrib)
37971 : : {
37972 : 0 : cp_lexer_save_tokens (parser->lexer);
37973 : 0 : tree addon = cp_parser_attributes_opt (parser);
37974 : 0 : if (addon
37975 : 0 : && OBJC_IS_AT_KEYWORD (cp_lexer_peek_token (parser->lexer)->keyword))
37976 : : {
37977 : 0 : cp_lexer_commit_tokens (parser->lexer);
37978 : 0 : if (*attrib)
37979 : 0 : TREE_CHAIN (*attrib) = addon;
37980 : : else
37981 : 0 : *attrib = addon;
37982 : 0 : return true;
37983 : : }
37984 : 0 : cp_lexer_rollback_tokens (parser->lexer);
37985 : 0 : return false;
37986 : : }
37987 : :
37988 : : /* This routine is a minimal replacement for
37989 : : c_parser_struct_declaration () used when parsing the list of
37990 : : types/names or ObjC++ properties. For example, when parsing the
37991 : : code
37992 : :
37993 : : @property (readonly) int a, b, c;
37994 : :
37995 : : this function is responsible for parsing "int a, int b, int c" and
37996 : : returning the declarations as CHAIN of DECLs.
37997 : :
37998 : : TODO: Share this code with cp_parser_objc_class_ivars. It's very
37999 : : similar parsing. */
38000 : : static tree
38001 : 0 : cp_parser_objc_struct_declaration (cp_parser *parser)
38002 : : {
38003 : 0 : tree decls = NULL_TREE;
38004 : 0 : cp_decl_specifier_seq declspecs;
38005 : 0 : int decl_class_or_enum_p;
38006 : 0 : tree prefix_attributes;
38007 : :
38008 : 0 : cp_parser_decl_specifier_seq (parser,
38009 : : CP_PARSER_FLAGS_NONE,
38010 : : &declspecs,
38011 : : &decl_class_or_enum_p);
38012 : :
38013 : 0 : if (declspecs.type == error_mark_node)
38014 : : return error_mark_node;
38015 : :
38016 : : /* auto, register, static, extern, mutable. */
38017 : 0 : if (declspecs.storage_class != sc_none)
38018 : : {
38019 : 0 : cp_parser_error (parser, "invalid type for property");
38020 : 0 : declspecs.storage_class = sc_none;
38021 : : }
38022 : :
38023 : : /* thread_local. */
38024 : 0 : if (decl_spec_seq_has_spec_p (&declspecs, ds_thread))
38025 : : {
38026 : 0 : cp_parser_error (parser, "invalid type for property");
38027 : 0 : declspecs.locations[ds_thread] = 0;
38028 : : }
38029 : :
38030 : : /* typedef. */
38031 : 0 : if (decl_spec_seq_has_spec_p (&declspecs, ds_typedef))
38032 : : {
38033 : 0 : cp_parser_error (parser, "invalid type for property");
38034 : 0 : declspecs.locations[ds_typedef] = 0;
38035 : : }
38036 : :
38037 : 0 : prefix_attributes = declspecs.attributes;
38038 : 0 : declspecs.attributes = NULL_TREE;
38039 : :
38040 : : /* Keep going until we hit the `;' at the end of the declaration. */
38041 : 0 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
38042 : : {
38043 : 0 : tree attributes, first_attribute, decl;
38044 : 0 : cp_declarator *declarator;
38045 : 0 : cp_token *token;
38046 : :
38047 : : /* Parse the declarator. */
38048 : 0 : declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
38049 : : CP_PARSER_FLAGS_NONE,
38050 : : NULL, NULL, false, false, false);
38051 : :
38052 : : /* Look for attributes that apply to the ivar. */
38053 : 0 : attributes = cp_parser_attributes_opt (parser);
38054 : : /* Remember which attributes are prefix attributes and
38055 : : which are not. */
38056 : 0 : first_attribute = attributes;
38057 : : /* Combine the attributes. */
38058 : 0 : attributes = attr_chainon (prefix_attributes, attributes);
38059 : :
38060 : 0 : decl = grokfield (declarator, &declspecs,
38061 : : NULL_TREE, /*init_const_expr_p=*/false,
38062 : : NULL_TREE, attributes);
38063 : :
38064 : 0 : if (decl == error_mark_node || decl == NULL_TREE)
38065 : : return error_mark_node;
38066 : :
38067 : : /* Reset PREFIX_ATTRIBUTES. */
38068 : 0 : if (attributes != error_mark_node)
38069 : : {
38070 : 0 : while (attributes && TREE_CHAIN (attributes) != first_attribute)
38071 : 0 : attributes = TREE_CHAIN (attributes);
38072 : 0 : if (attributes)
38073 : 0 : TREE_CHAIN (attributes) = NULL_TREE;
38074 : : }
38075 : :
38076 : 0 : DECL_CHAIN (decl) = decls;
38077 : 0 : decls = decl;
38078 : :
38079 : 0 : token = cp_lexer_peek_token (parser->lexer);
38080 : 0 : if (token->type == CPP_COMMA)
38081 : : {
38082 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat ','. */
38083 : 0 : continue;
38084 : : }
38085 : : else
38086 : : break;
38087 : : }
38088 : : return decls;
38089 : : }
38090 : :
38091 : : /* Parse an Objective-C @property declaration. The syntax is:
38092 : :
38093 : : objc-property-declaration:
38094 : : '@property' objc-property-attributes[opt] struct-declaration ;
38095 : :
38096 : : objc-property-attributes:
38097 : : '(' objc-property-attribute-list ')'
38098 : :
38099 : : objc-property-attribute-list:
38100 : : objc-property-attribute
38101 : : objc-property-attribute-list, objc-property-attribute
38102 : :
38103 : : objc-property-attribute
38104 : : 'getter' = identifier
38105 : : 'setter' = identifier
38106 : : 'readonly'
38107 : : 'readwrite'
38108 : : 'assign'
38109 : : 'retain'
38110 : : 'copy'
38111 : : 'nonatomic'
38112 : :
38113 : : For example:
38114 : : @property NSString *name;
38115 : : @property (readonly) id object;
38116 : : @property (retain, nonatomic, getter=getTheName) id name;
38117 : : @property int a, b, c;
38118 : :
38119 : : PS: This function is identical to
38120 : : c_parser_objc_at_property_declaration for C. Keep them in sync. */
38121 : : static void
38122 : 0 : cp_parser_objc_at_property_declaration (cp_parser *parser)
38123 : : {
38124 : : /* Parse the optional attribute list.
38125 : :
38126 : : A list of parsed, but not verified, attributes. */
38127 : 0 : auto_delete_vec<property_attribute_info> prop_attr_list;
38128 : 0 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
38129 : :
38130 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@property'. */
38131 : :
38132 : : /* Parse the optional attribute list... */
38133 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
38134 : : {
38135 : : /* Eat the '('. */
38136 : 0 : matching_parens parens;
38137 : 0 : location_t attr_start = cp_lexer_peek_token (parser->lexer)->location;
38138 : 0 : parens.consume_open (parser);
38139 : 0 : bool syntax_error = false;
38140 : :
38141 : : /* Allow empty @property attribute lists, but with a warning. */
38142 : 0 : location_t attr_end = cp_lexer_peek_token (parser->lexer)->location;
38143 : 0 : location_t attr_comb;
38144 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
38145 : : {
38146 : 0 : attr_comb = make_location (attr_end, attr_start, attr_end);
38147 : 0 : warning_at (attr_comb, OPT_Wattributes,
38148 : : "empty property attribute list");
38149 : : }
38150 : : else
38151 : 0 : while (true)
38152 : : {
38153 : 0 : cp_token *token = cp_lexer_peek_token (parser->lexer);
38154 : 0 : attr_start = token->location;
38155 : 0 : attr_end = get_finish (token->location);
38156 : 0 : attr_comb = make_location (attr_start, attr_start, attr_end);
38157 : :
38158 : 0 : if (token->type == CPP_CLOSE_PAREN || token->type == CPP_COMMA)
38159 : : {
38160 : 0 : warning_at (attr_comb, OPT_Wattributes,
38161 : : "missing property attribute");
38162 : 0 : if (token->type == CPP_CLOSE_PAREN)
38163 : : break;
38164 : 0 : cp_lexer_consume_token (parser->lexer);
38165 : 0 : continue;
38166 : : }
38167 : :
38168 : 0 : tree attr_name = NULL_TREE;
38169 : 0 : if (identifier_p (token->u.value))
38170 : 0 : attr_name = token->u.value;
38171 : :
38172 : 0 : enum rid keyword;
38173 : 0 : if (token->type == CPP_NAME)
38174 : 0 : keyword = C_RID_CODE (token->u.value);
38175 : 0 : else if (token->type == CPP_KEYWORD
38176 : 0 : && token->keyword == RID_CLASS)
38177 : : /* Account for accepting the 'class' keyword in this context. */
38178 : : keyword = RID_CLASS;
38179 : : else
38180 : 0 : keyword = RID_MAX; /* By definition, an unknown property. */
38181 : 0 : cp_lexer_consume_token (parser->lexer);
38182 : :
38183 : 0 : enum objc_property_attribute_kind prop_kind
38184 : 0 : = objc_prop_attr_kind_for_rid (keyword);
38185 : 0 : property_attribute_info *prop
38186 : 0 : = new property_attribute_info (attr_name, attr_comb, prop_kind);
38187 : 0 : prop_attr_list.safe_push (prop);
38188 : :
38189 : 0 : tree meth_name;
38190 : 0 : switch (prop->prop_kind)
38191 : : {
38192 : : default: break;
38193 : 0 : case OBJC_PROPERTY_ATTR_UNKNOWN:
38194 : 0 : if (attr_name)
38195 : 0 : error_at (attr_start, "unknown property attribute %qE",
38196 : : attr_name);
38197 : : else
38198 : 0 : error_at (attr_start, "unknown property attribute");
38199 : 0 : prop->parse_error = syntax_error = true;
38200 : 0 : break;
38201 : :
38202 : 0 : case OBJC_PROPERTY_ATTR_GETTER:
38203 : 0 : case OBJC_PROPERTY_ATTR_SETTER:
38204 : 0 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
38205 : : {
38206 : 0 : attr_comb = make_location (attr_end, attr_start, attr_end);
38207 : 0 : error_at (attr_comb, "expected %<=%> after Objective-C %qE",
38208 : : attr_name);
38209 : 0 : prop->parse_error = syntax_error = true;
38210 : 0 : break;
38211 : : }
38212 : :
38213 : 0 : token = cp_lexer_peek_token (parser->lexer);
38214 : 0 : attr_end = token->location;
38215 : 0 : cp_lexer_consume_token (parser->lexer); /* eat the = */
38216 : :
38217 : 0 : if (!cp_parser_objc_selector_p
38218 : 0 : (cp_lexer_peek_token (parser->lexer)->type))
38219 : : {
38220 : 0 : attr_comb = make_location (attr_end, attr_start, attr_end);
38221 : 0 : error_at (attr_comb, "expected %qE selector name",
38222 : : attr_name);
38223 : 0 : prop->parse_error = syntax_error = true;
38224 : 0 : break;
38225 : : }
38226 : :
38227 : : /* Get the end of the method name, and consume the name. */
38228 : 0 : token = cp_lexer_peek_token (parser->lexer);
38229 : 0 : attr_end = get_finish (token->location);
38230 : : /* Because method names may contain C++ keywords, we have a
38231 : : routine to fetch them (this also consumes the token). */
38232 : 0 : meth_name = cp_parser_objc_selector (parser);
38233 : :
38234 : 0 : if (prop->prop_kind == OBJC_PROPERTY_ATTR_SETTER)
38235 : : {
38236 : 0 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
38237 : : {
38238 : 0 : attr_comb = make_location (attr_end, attr_start,
38239 : : attr_end);
38240 : 0 : error_at (attr_comb, "setter method names must"
38241 : : " terminate with %<:%>");
38242 : 0 : prop->parse_error = syntax_error = true;
38243 : : }
38244 : : else
38245 : : {
38246 : 0 : attr_end = get_finish (cp_lexer_peek_token
38247 : 0 : (parser->lexer)->location);
38248 : 0 : cp_lexer_consume_token (parser->lexer);
38249 : : }
38250 : 0 : attr_comb = make_location (attr_start, attr_start,
38251 : : attr_end);
38252 : : }
38253 : : else
38254 : 0 : attr_comb = make_location (attr_start, attr_start,
38255 : : attr_end);
38256 : 0 : prop->ident = meth_name;
38257 : : /* Updated location including all that was successfully
38258 : : parsed. */
38259 : 0 : prop->prop_loc = attr_comb;
38260 : 0 : break;
38261 : : }
38262 : :
38263 : : /* If we see a comma here, then keep going - even if we already
38264 : : saw a syntax error. For simple mistakes e.g. (asign, getter=x)
38265 : : this makes a more useful output and avoid spurious warnings
38266 : : about missing attributes that are, in fact, specified after the
38267 : : one with the syntax error. */
38268 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
38269 : 0 : cp_lexer_consume_token (parser->lexer);
38270 : : else
38271 : : break;
38272 : : }
38273 : :
38274 : 0 : if (syntax_error || !parens.require_close (parser))
38275 : 0 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
38276 : : /*or_comma=*/false,
38277 : : /*consume_paren=*/true);
38278 : : }
38279 : :
38280 : : /* 'properties' is the list of properties that we read. Usually a
38281 : : single one, but maybe more (eg, in "@property int a, b, c;" there
38282 : : are three).
38283 : : TODO: Update this parsing so that it accepts (erroneous) bitfields so
38284 : : that we can issue a meaningful and consistent (between C/C++) error
38285 : : message from objc_add_property_declaration (). */
38286 : 0 : tree properties = cp_parser_objc_struct_declaration (parser);
38287 : :
38288 : 0 : if (properties == error_mark_node)
38289 : 0 : cp_parser_skip_to_end_of_statement (parser);
38290 : 0 : else if (properties == NULL_TREE)
38291 : 0 : cp_parser_error (parser, "expected identifier");
38292 : : else
38293 : : {
38294 : : /* Comma-separated properties are chained together in reverse order;
38295 : : add them one by one. */
38296 : 0 : properties = nreverse (properties);
38297 : 0 : for (; properties; properties = TREE_CHAIN (properties))
38298 : 0 : objc_add_property_declaration (loc, copy_node (properties),
38299 : : prop_attr_list);
38300 : : }
38301 : :
38302 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
38303 : 0 : }
38304 : :
38305 : : /* Parse an Objective-C++ @synthesize declaration. The syntax is:
38306 : :
38307 : : objc-synthesize-declaration:
38308 : : @synthesize objc-synthesize-identifier-list ;
38309 : :
38310 : : objc-synthesize-identifier-list:
38311 : : objc-synthesize-identifier
38312 : : objc-synthesize-identifier-list, objc-synthesize-identifier
38313 : :
38314 : : objc-synthesize-identifier
38315 : : identifier
38316 : : identifier = identifier
38317 : :
38318 : : For example:
38319 : : @synthesize MyProperty;
38320 : : @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
38321 : :
38322 : : PS: This function is identical to c_parser_objc_at_synthesize_declaration
38323 : : for C. Keep them in sync.
38324 : : */
38325 : : static void
38326 : 0 : cp_parser_objc_at_synthesize_declaration (cp_parser *parser)
38327 : : {
38328 : 0 : tree list = NULL_TREE;
38329 : 0 : location_t loc;
38330 : 0 : loc = cp_lexer_peek_token (parser->lexer)->location;
38331 : :
38332 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@synthesize'. */
38333 : 0 : while (true)
38334 : : {
38335 : 0 : tree property, ivar;
38336 : 0 : property = cp_parser_identifier (parser);
38337 : 0 : if (property == error_mark_node)
38338 : : {
38339 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
38340 : 0 : return;
38341 : : }
38342 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
38343 : : {
38344 : 0 : cp_lexer_consume_token (parser->lexer);
38345 : 0 : ivar = cp_parser_identifier (parser);
38346 : 0 : if (ivar == error_mark_node)
38347 : : {
38348 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
38349 : 0 : return;
38350 : : }
38351 : : }
38352 : : else
38353 : : ivar = NULL_TREE;
38354 : 0 : list = chainon (list, build_tree_list (ivar, property));
38355 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
38356 : 0 : cp_lexer_consume_token (parser->lexer);
38357 : : else
38358 : : break;
38359 : 0 : }
38360 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
38361 : 0 : objc_add_synthesize_declaration (loc, list);
38362 : : }
38363 : :
38364 : : /* Parse an Objective-C++ @dynamic declaration. The syntax is:
38365 : :
38366 : : objc-dynamic-declaration:
38367 : : @dynamic identifier-list ;
38368 : :
38369 : : For example:
38370 : : @dynamic MyProperty;
38371 : : @dynamic MyProperty, AnotherProperty;
38372 : :
38373 : : PS: This function is identical to c_parser_objc_at_dynamic_declaration
38374 : : for C. Keep them in sync.
38375 : : */
38376 : : static void
38377 : 0 : cp_parser_objc_at_dynamic_declaration (cp_parser *parser)
38378 : : {
38379 : 0 : tree list = NULL_TREE;
38380 : 0 : location_t loc;
38381 : 0 : loc = cp_lexer_peek_token (parser->lexer)->location;
38382 : :
38383 : 0 : cp_lexer_consume_token (parser->lexer); /* Eat '@dynamic'. */
38384 : 0 : while (true)
38385 : : {
38386 : 0 : tree property;
38387 : 0 : property = cp_parser_identifier (parser);
38388 : 0 : if (property == error_mark_node)
38389 : : {
38390 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
38391 : 0 : return;
38392 : : }
38393 : 0 : list = chainon (list, build_tree_list (NULL, property));
38394 : 0 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
38395 : 0 : cp_lexer_consume_token (parser->lexer);
38396 : : else
38397 : : break;
38398 : 0 : }
38399 : 0 : cp_parser_consume_semicolon_at_end_of_statement (parser);
38400 : 0 : objc_add_dynamic_declaration (loc, list);
38401 : : }
38402 : :
38403 : :
38404 : : /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 / 4.5 / 5.0 parsing routines. */
38405 : :
38406 : : /* Returns name of the next clause.
38407 : : If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
38408 : : the token is not consumed. Otherwise appropriate pragma_omp_clause is
38409 : : returned and the token is consumed. */
38410 : :
38411 : : static pragma_omp_clause
38412 : 64732 : cp_parser_omp_clause_name (cp_parser *parser)
38413 : : {
38414 : 64732 : pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE;
38415 : :
38416 : 64732 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
38417 : : result = PRAGMA_OACC_CLAUSE_AUTO;
38418 : : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
38419 : : result = PRAGMA_OMP_CLAUSE_IF;
38420 : : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
38421 : : result = PRAGMA_OMP_CLAUSE_DEFAULT;
38422 : : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DELETE))
38423 : : result = PRAGMA_OACC_CLAUSE_DELETE;
38424 : : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
38425 : : result = PRAGMA_OMP_CLAUSE_PRIVATE;
38426 : : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
38427 : : result = PRAGMA_OMP_CLAUSE_FOR;
38428 : 58334 : else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
38429 : : {
38430 : 58262 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
38431 : 58262 : const char *p = IDENTIFIER_POINTER (id);
38432 : :
38433 : 58262 : switch (p[0])
38434 : : {
38435 : 3106 : case 'a':
38436 : 3106 : if (!strcmp ("affinity", p))
38437 : : result = PRAGMA_OMP_CLAUSE_AFFINITY;
38438 : 2644 : else if (!strcmp ("aligned", p))
38439 : : result = PRAGMA_OMP_CLAUSE_ALIGNED;
38440 : 1942 : else if (!strcmp ("allocate", p))
38441 : : result = PRAGMA_OMP_CLAUSE_ALLOCATE;
38442 : 481 : else if (!strcmp ("async", p))
38443 : : result = PRAGMA_OACC_CLAUSE_ASYNC;
38444 : 106 : else if (!strcmp ("attach", p))
38445 : 64732 : result = PRAGMA_OACC_CLAUSE_ATTACH;
38446 : : break;
38447 : 355 : case 'b':
38448 : 355 : if (!strcmp ("bind", p))
38449 : 64732 : result = PRAGMA_OMP_CLAUSE_BIND;
38450 : : break;
38451 : 7461 : case 'c':
38452 : 7461 : if (!strcmp ("collapse", p))
38453 : : result = PRAGMA_OMP_CLAUSE_COLLAPSE;
38454 : 3208 : else if (!strcmp ("copy", p))
38455 : : result = PRAGMA_OACC_CLAUSE_COPY;
38456 : 2050 : else if (!strcmp ("copyin", p))
38457 : : result = PRAGMA_OMP_CLAUSE_COPYIN;
38458 : 1074 : else if (!strcmp ("copyout", p))
38459 : : result = PRAGMA_OACC_CLAUSE_COPYOUT;
38460 : 265 : else if (!strcmp ("copyprivate", p))
38461 : : result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
38462 : 197 : else if (!strcmp ("create", p))
38463 : 64732 : result = PRAGMA_OACC_CLAUSE_CREATE;
38464 : : break;
38465 : 5617 : case 'd':
38466 : 5617 : if (!strcmp ("defaultmap", p))
38467 : : result = PRAGMA_OMP_CLAUSE_DEFAULTMAP;
38468 : 4977 : else if (!strcmp ("depend", p))
38469 : : result = PRAGMA_OMP_CLAUSE_DEPEND;
38470 : 3282 : else if (!strcmp ("destroy", p))
38471 : : result = PRAGMA_OMP_CLAUSE_DESTROY;
38472 : 3195 : else if (!strcmp ("detach", p))
38473 : : result = PRAGMA_OACC_CLAUSE_DETACH;
38474 : 3044 : else if (!strcmp ("device", p))
38475 : : result = PRAGMA_OMP_CLAUSE_DEVICE;
38476 : 2314 : else if (!strcmp ("deviceptr", p))
38477 : : result = PRAGMA_OACC_CLAUSE_DEVICEPTR;
38478 : 2227 : else if (!strcmp ("device_resident", p))
38479 : : result = PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT;
38480 : 2184 : else if (!strcmp ("device_type", p))
38481 : : result = PRAGMA_OMP_CLAUSE_DEVICE_TYPE;
38482 : 2061 : else if (!strcmp ("dist_schedule", p))
38483 : : result = PRAGMA_OMP_CLAUSE_DIST_SCHEDULE;
38484 : 222 : else if (!strcmp ("doacross", p))
38485 : 64732 : result = PRAGMA_OMP_CLAUSE_DOACROSS;
38486 : : break;
38487 : 114 : case 'e':
38488 : 114 : if (!strcmp ("enter", p))
38489 : 64732 : result = PRAGMA_OMP_CLAUSE_ENTER;
38490 : : break;
38491 : 5245 : case 'f':
38492 : 5245 : if (!strcmp ("filter", p))
38493 : : result = PRAGMA_OMP_CLAUSE_FILTER;
38494 : 5068 : else if (!strcmp ("final", p))
38495 : : result = PRAGMA_OMP_CLAUSE_FINAL;
38496 : 4788 : else if (!strcmp ("finalize", p))
38497 : : result = PRAGMA_OACC_CLAUSE_FINALIZE;
38498 : 4752 : else if (!strcmp ("firstprivate", p))
38499 : : result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
38500 : 2673 : else if (!strcmp ("from", p))
38501 : : result = PRAGMA_OMP_CLAUSE_FROM;
38502 : 201 : else if (!strcmp ("full", p))
38503 : 64732 : result = PRAGMA_OMP_CLAUSE_FULL;
38504 : : break;
38505 : 1344 : case 'g':
38506 : 1344 : if (!strcmp ("gang", p))
38507 : : result = PRAGMA_OACC_CLAUSE_GANG;
38508 : 163 : else if (!strcmp ("grainsize", p))
38509 : 64732 : result = PRAGMA_OMP_CLAUSE_GRAINSIZE;
38510 : : break;
38511 : 409 : case 'h':
38512 : 409 : if (!strcmp ("has_device_addr", p))
38513 : : result = PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR;
38514 : 152 : else if (!strcmp ("hint", p))
38515 : : result = PRAGMA_OMP_CLAUSE_HINT;
38516 : 89 : else if (!strcmp ("host", p))
38517 : 64732 : result = PRAGMA_OACC_CLAUSE_HOST;
38518 : : break;
38519 : 1855 : case 'i':
38520 : 1855 : if (!strcmp ("if_present", p))
38521 : : result = PRAGMA_OACC_CLAUSE_IF_PRESENT;
38522 : 1805 : else if (!strcmp ("in_reduction", p))
38523 : : result = PRAGMA_OMP_CLAUSE_IN_REDUCTION;
38524 : 1020 : else if (!strcmp ("inbranch", p))
38525 : : result = PRAGMA_OMP_CLAUSE_INBRANCH;
38526 : 891 : else if (!strcmp ("independent", p))
38527 : : result = PRAGMA_OACC_CLAUSE_INDEPENDENT;
38528 : 814 : else if (!strcmp ("indirect", p))
38529 : : result = PRAGMA_OMP_CLAUSE_INDIRECT;
38530 : 729 : else if (!strcmp ("init", p))
38531 : : result = PRAGMA_OMP_CLAUSE_INIT;
38532 : 372 : else if (!strcmp ("interop", p))
38533 : : result = PRAGMA_OMP_CLAUSE_INTEROP;
38534 : 276 : else if (!strcmp ("is_device_ptr", p))
38535 : 64732 : result = PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR;
38536 : : break;
38537 : 3073 : case 'l':
38538 : 3073 : if (!strcmp ("lastprivate", p))
38539 : : result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
38540 : 1586 : else if (!strcmp ("linear", p))
38541 : : result = PRAGMA_OMP_CLAUSE_LINEAR;
38542 : 113 : else if (!strcmp ("link", p))
38543 : 64732 : result = PRAGMA_OMP_CLAUSE_LINK;
38544 : : break;
38545 : 4089 : case 'm':
38546 : 4089 : if (!strcmp ("map", p))
38547 : : result = PRAGMA_OMP_CLAUSE_MAP;
38548 : 228 : else if (!strcmp ("mergeable", p))
38549 : 64732 : result = PRAGMA_OMP_CLAUSE_MERGEABLE;
38550 : : break;
38551 : 3926 : case 'n':
38552 : 3926 : if (!strcmp ("no_create", p))
38553 : : result = PRAGMA_OACC_CLAUSE_NO_CREATE;
38554 : 3912 : else if (!strcmp ("nocontext", p))
38555 : : result = PRAGMA_OMP_CLAUSE_NOCONTEXT;
38556 : 3844 : else if (!strcmp ("nogroup", p))
38557 : : result = PRAGMA_OMP_CLAUSE_NOGROUP;
38558 : 3803 : else if (!strcmp ("nohost", p))
38559 : : result = PRAGMA_OACC_CLAUSE_NOHOST;
38560 : 3729 : else if (!strcmp ("nontemporal", p))
38561 : : result = PRAGMA_OMP_CLAUSE_NONTEMPORAL;
38562 : 3372 : else if (!strcmp ("notinbranch", p))
38563 : : result = PRAGMA_OMP_CLAUSE_NOTINBRANCH;
38564 : 2926 : else if (!strcmp ("novariants", p))
38565 : : result = PRAGMA_OMP_CLAUSE_NOVARIANTS;
38566 : 2867 : else if (!strcmp ("nowait", p))
38567 : : result = PRAGMA_OMP_CLAUSE_NOWAIT;
38568 : 2267 : else if (!strcmp ("num_gangs", p))
38569 : : result = PRAGMA_OACC_CLAUSE_NUM_GANGS;
38570 : 1831 : else if (!strcmp ("num_tasks", p))
38571 : : result = PRAGMA_OMP_CLAUSE_NUM_TASKS;
38572 : 1699 : else if (!strcmp ("num_teams", p))
38573 : : result = PRAGMA_OMP_CLAUSE_NUM_TEAMS;
38574 : 1097 : else if (!strcmp ("num_threads", p))
38575 : : result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
38576 : 321 : else if (!strcmp ("num_workers", p))
38577 : 64732 : result = PRAGMA_OACC_CLAUSE_NUM_WORKERS;
38578 : : break;
38579 : 1742 : case 'o':
38580 : 1742 : if (!strcmp ("ordered", p))
38581 : : result = PRAGMA_OMP_CLAUSE_ORDERED;
38582 : 1109 : else if (!strcmp ("order", p))
38583 : 64732 : result = PRAGMA_OMP_CLAUSE_ORDER;
38584 : : break;
38585 : 2038 : case 'p':
38586 : 2038 : if (!strcmp ("parallel", p))
38587 : 310 : result = PRAGMA_OMP_CLAUSE_PARALLEL;
38588 : 2038 : if (!strcmp ("partial", p))
38589 : : result = PRAGMA_OMP_CLAUSE_PARTIAL;
38590 : 1580 : else if (!strcmp ("present", p))
38591 : : result = PRAGMA_OACC_CLAUSE_PRESENT;
38592 : 1370 : else if (!strcmp ("present_or_copy", p)
38593 : 1345 : || !strcmp ("pcopy", p))
38594 : : result = PRAGMA_OACC_CLAUSE_COPY;
38595 : 1323 : else if (!strcmp ("present_or_copyin", p)
38596 : 1289 : || !strcmp ("pcopyin", p))
38597 : : result = PRAGMA_OACC_CLAUSE_COPYIN;
38598 : 1269 : else if (!strcmp ("present_or_copyout", p)
38599 : 1202 : || !strcmp ("pcopyout", p))
38600 : : result = PRAGMA_OACC_CLAUSE_COPYOUT;
38601 : 1176 : else if (!strcmp ("present_or_create", p)
38602 : 1146 : || !strcmp ("pcreate", p))
38603 : : result = PRAGMA_OACC_CLAUSE_CREATE;
38604 : 1138 : else if (!strcmp ("priority", p))
38605 : : result = PRAGMA_OMP_CLAUSE_PRIORITY;
38606 : 865 : else if (!strcmp ("proc_bind", p))
38607 : 526 : result = PRAGMA_OMP_CLAUSE_PROC_BIND;
38608 : : break;
38609 : 4739 : case 'r':
38610 : 4739 : if (!strcmp ("reduction", p))
38611 : 64732 : result = PRAGMA_OMP_CLAUSE_REDUCTION;
38612 : : break;
38613 : 7611 : case 's':
38614 : 7611 : if (!strcmp ("safelen", p))
38615 : : result = PRAGMA_OMP_CLAUSE_SAFELEN;
38616 : 7144 : else if (!strcmp ("schedule", p))
38617 : : result = PRAGMA_OMP_CLAUSE_SCHEDULE;
38618 : 3345 : else if (!strcmp ("sections", p))
38619 : : result = PRAGMA_OMP_CLAUSE_SECTIONS;
38620 : 3119 : else if (!strcmp ("self", p))
38621 : : result = PRAGMA_OACC_CLAUSE_SELF;
38622 : 2985 : else if (!strcmp ("seq", p))
38623 : : result = PRAGMA_OACC_CLAUSE_SEQ;
38624 : 2248 : else if (!strcmp ("shared", p))
38625 : : result = PRAGMA_OMP_CLAUSE_SHARED;
38626 : 926 : else if (!strcmp ("simd", p))
38627 : : result = PRAGMA_OMP_CLAUSE_SIMD;
38628 : 758 : else if (!strcmp ("simdlen", p))
38629 : 64732 : result = PRAGMA_OMP_CLAUSE_SIMDLEN;
38630 : : break;
38631 : 2100 : case 't':
38632 : 2100 : if (!strcmp ("task_reduction", p))
38633 : : result = PRAGMA_OMP_CLAUSE_TASK_REDUCTION;
38634 : 1877 : else if (!strcmp ("taskgroup", p))
38635 : : result = PRAGMA_OMP_CLAUSE_TASKGROUP;
38636 : 1560 : else if (!strcmp ("thread_limit", p))
38637 : : result = PRAGMA_OMP_CLAUSE_THREAD_LIMIT;
38638 : 1148 : else if (!strcmp ("threads", p))
38639 : : result = PRAGMA_OMP_CLAUSE_THREADS;
38640 : 1017 : else if (!strcmp ("tile", p))
38641 : : result = PRAGMA_OACC_CLAUSE_TILE;
38642 : 698 : else if (!strcmp ("to", p))
38643 : 64732 : result = PRAGMA_OMP_CLAUSE_TO;
38644 : : break;
38645 : 840 : case 'u':
38646 : 840 : if (!strcmp ("uniform", p))
38647 : : result = PRAGMA_OMP_CLAUSE_UNIFORM;
38648 : 487 : else if (!strcmp ("untied", p))
38649 : : result = PRAGMA_OMP_CLAUSE_UNTIED;
38650 : 245 : else if (!strcmp ("use", p))
38651 : : result = PRAGMA_OMP_CLAUSE_USE;
38652 : 152 : else if (!strcmp ("use_device", p))
38653 : : result = PRAGMA_OACC_CLAUSE_USE_DEVICE;
38654 : 97 : else if (!strcmp ("use_device_addr", p))
38655 : : result = PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR;
38656 : 28 : else if (!strcmp ("use_device_ptr", p))
38657 : 64732 : result = PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR;
38658 : : break;
38659 : 1435 : case 'v':
38660 : 1435 : if (!strcmp ("vector", p))
38661 : : result = PRAGMA_OACC_CLAUSE_VECTOR;
38662 : 328 : else if (!strcmp ("vector_length", p))
38663 : 64732 : result = PRAGMA_OACC_CLAUSE_VECTOR_LENGTH;
38664 : : break;
38665 : 1160 : case 'w':
38666 : 1160 : if (!strcmp ("wait", p))
38667 : : result = PRAGMA_OACC_CLAUSE_WAIT;
38668 : 983 : else if (!strcmp ("worker", p))
38669 : 64732 : result = PRAGMA_OACC_CLAUSE_WORKER;
38670 : : break;
38671 : : }
38672 : : }
38673 : :
38674 : 64732 : if (result != PRAGMA_OMP_CLAUSE_NONE)
38675 : 64604 : cp_lexer_consume_token (parser->lexer);
38676 : :
38677 : 64732 : return result;
38678 : : }
38679 : :
38680 : : /* Validate that a clause of the given type does not already exist. */
38681 : :
38682 : : static void
38683 : 30744 : check_no_duplicate_clause (tree clauses, enum omp_clause_code code,
38684 : : const char *name, location_t location)
38685 : : {
38686 : 30744 : if (omp_find_clause (clauses, code))
38687 : 1041 : error_at (location, "too many %qs clauses", name);
38688 : 30744 : }
38689 : :
38690 : : /* OpenMP 2.5:
38691 : : variable-list:
38692 : : identifier
38693 : : variable-list , identifier
38694 : :
38695 : : In addition, we match a closing parenthesis (or, if COLON is non-NULL,
38696 : : colon). An opening parenthesis will have been consumed by the caller.
38697 : :
38698 : : If KIND is nonzero, create the appropriate node and install the decl
38699 : : in OMP_CLAUSE_DECL and add the node to the head of the list.
38700 : :
38701 : : If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
38702 : : return the list created.
38703 : :
38704 : : COLON can be NULL if only closing parenthesis should end the list,
38705 : : or pointer to bool which will receive false if the list is terminated
38706 : : by closing parenthesis or true if the list is terminated by colon.
38707 : :
38708 : : The optional ALLOW_DEREF argument is true if list items can use the deref
38709 : : (->) operator. */
38710 : :
38711 : : struct omp_dim
38712 : : {
38713 : : tree low_bound, length;
38714 : : location_t loc;
38715 : : bool no_colon;
38716 : 8911 : omp_dim (tree lb, tree len, location_t lo, bool nc)
38717 : 8911 : : low_bound (lb), length (len), loc (lo), no_colon (nc) {}
38718 : : };
38719 : :
38720 : : static tree
38721 : 32821 : cp_parser_omp_var_list_no_open (cp_parser *parser, enum omp_clause_code kind,
38722 : : tree list, bool *colon,
38723 : : bool map_lvalue = false)
38724 : : {
38725 : 32821 : auto_vec<omp_dim> dims;
38726 : 32821 : bool array_section_p;
38727 : 32821 : cp_token *token;
38728 : 32821 : bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
38729 : 32821 : if (colon)
38730 : : {
38731 : 3426 : parser->colon_corrects_to_scope_p = false;
38732 : 3426 : *colon = false;
38733 : : }
38734 : 43361 : while (1)
38735 : : {
38736 : 38091 : tree name, decl;
38737 : :
38738 : 38091 : if (kind == OMP_CLAUSE_DEPEND || kind == OMP_CLAUSE_AFFINITY)
38739 : 2004 : cp_parser_parse_tentatively (parser);
38740 : : /* This condition doesn't include OMP_CLAUSE_DEPEND or
38741 : : OMP_CLAUSE_AFFINITY since lvalue ("locator list") parsing for those is
38742 : : handled further down the function. */
38743 : 36087 : else if (map_lvalue
38744 : 7875 : && (kind == OMP_CLAUSE_MAP
38745 : : || kind == OMP_CLAUSE_TO
38746 : 7875 : || kind == OMP_CLAUSE_FROM))
38747 : : {
38748 : 7875 : auto s = make_temp_override (parser->omp_array_section_p, true);
38749 : 7875 : token = cp_lexer_peek_token (parser->lexer);
38750 : 7875 : location_t loc = token->location;
38751 : 7875 : decl = cp_parser_assignment_expression (parser);
38752 : :
38753 : : /* This code rewrites a parsed expression containing various tree
38754 : : codes used to represent array accesses into a more uniform nest of
38755 : : OMP_ARRAY_SECTION nodes before it is processed by
38756 : : semantics.cc:handle_omp_array_sections_1. It might be more
38757 : : efficient to move this logic to that function instead, analysing
38758 : : the parsed expression directly rather than this preprocessed
38759 : : form. */
38760 : 7875 : dims.truncate (0);
38761 : 7875 : if (TREE_CODE (decl) == OMP_ARRAY_SECTION)
38762 : : {
38763 : 3494 : while (TREE_CODE (decl) == OMP_ARRAY_SECTION)
38764 : : {
38765 : 1911 : tree low_bound = TREE_OPERAND (decl, 1);
38766 : 1911 : tree length = TREE_OPERAND (decl, 2);
38767 : 1911 : dims.safe_push (omp_dim (low_bound, length, loc, false));
38768 : 1911 : decl = TREE_OPERAND (decl, 0);
38769 : : }
38770 : :
38771 : 1620 : while (TREE_CODE (decl) == ARRAY_REF
38772 : : || TREE_CODE (decl) == INDIRECT_REF
38773 : 1620 : || TREE_CODE (decl) == COMPOUND_EXPR)
38774 : : {
38775 : 244 : if (REFERENCE_REF_P (decl))
38776 : : break;
38777 : :
38778 : 37 : if (TREE_CODE (decl) == COMPOUND_EXPR)
38779 : : {
38780 : 4 : decl = TREE_OPERAND (decl, 1);
38781 : 4 : STRIP_NOPS (decl);
38782 : : }
38783 : 33 : else if (TREE_CODE (decl) == INDIRECT_REF)
38784 : : {
38785 : 42 : dims.safe_push (omp_dim (integer_zero_node,
38786 : 21 : integer_one_node, loc, true));
38787 : 21 : decl = TREE_OPERAND (decl, 0);
38788 : : }
38789 : : else /* ARRAY_REF. */
38790 : : {
38791 : 12 : tree index = TREE_OPERAND (decl, 1);
38792 : 24 : dims.safe_push (omp_dim (index, integer_one_node, loc,
38793 : 12 : true));
38794 : 12 : decl = TREE_OPERAND (decl, 0);
38795 : : }
38796 : : }
38797 : :
38798 : : /* Bare references have their own special handling, so remove
38799 : : the explicit dereference added by convert_from_reference. */
38800 : 1583 : if (REFERENCE_REF_P (decl))
38801 : 207 : decl = TREE_OPERAND (decl, 0);
38802 : :
38803 : 5110 : for (int i = dims.length () - 1; i >= 0; i--)
38804 : 1944 : decl = grok_omp_array_section (loc, decl, dims[i].low_bound,
38805 : 1944 : dims[i].length);
38806 : : }
38807 : 6292 : else if (TREE_CODE (decl) == INDIRECT_REF)
38808 : : {
38809 : 467 : bool ref_p = REFERENCE_REF_P (decl);
38810 : :
38811 : : /* If we have "*foo" and
38812 : : - it's an indirection of a reference, "unconvert" it, i.e.
38813 : : strip the indirection (to just "foo").
38814 : : - it's an indirection of a pointer, turn it into
38815 : : "foo[0:1]". */
38816 : 467 : decl = TREE_OPERAND (decl, 0);
38817 : 467 : STRIP_NOPS (decl);
38818 : :
38819 : 467 : if (!ref_p)
38820 : 145 : decl = grok_omp_array_section (loc, decl, integer_zero_node,
38821 : : integer_one_node);
38822 : : }
38823 : 5825 : else if (TREE_CODE (decl) == ARRAY_REF)
38824 : : {
38825 : 78 : tree idx = TREE_OPERAND (decl, 1);
38826 : :
38827 : 78 : decl = TREE_OPERAND (decl, 0);
38828 : 78 : STRIP_NOPS (decl);
38829 : :
38830 : 78 : decl = grok_omp_array_section (loc, decl, idx, integer_one_node);
38831 : : }
38832 : 5747 : else if (TREE_CODE (decl) == NON_LVALUE_EXPR
38833 : 5747 : || CONVERT_EXPR_P (decl))
38834 : 18 : decl = TREE_OPERAND (decl, 0);
38835 : :
38836 : 7875 : goto build_clause;
38837 : 7875 : }
38838 : 30216 : token = cp_lexer_peek_token (parser->lexer);
38839 : 30216 : if (kind != 0
38840 : 30216 : && cp_parser_is_keyword (token, RID_THIS))
38841 : : {
38842 : 214 : decl = finish_this_expr ();
38843 : 214 : if (TREE_CODE (decl) == NON_LVALUE_EXPR
38844 : 214 : || CONVERT_EXPR_P (decl))
38845 : 208 : decl = TREE_OPERAND (decl, 0);
38846 : 214 : cp_lexer_consume_token (parser->lexer);
38847 : : }
38848 : 30002 : else if (cp_parser_is_keyword (token, RID_FUNCTION_NAME)
38849 : 29995 : || cp_parser_is_keyword (token, RID_PRETTY_FUNCTION_NAME)
38850 : 59990 : || cp_parser_is_keyword (token, RID_C99_FUNCTION_NAME))
38851 : : {
38852 : 23 : cp_id_kind idk;
38853 : 23 : decl = cp_parser_primary_expression (parser, false, false, false,
38854 : : &idk);
38855 : : }
38856 : 29979 : else if (kind == OMP_CLAUSE_DEPEND
38857 : 1458 : && cp_parser_is_keyword (token, RID_OMP_ALL_MEMORY)
38858 : 30015 : && (cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA)
38859 : 29 : || cp_lexer_nth_token_is (parser->lexer, 2,
38860 : : CPP_CLOSE_PAREN)))
38861 : : {
38862 : 33 : decl = ridpointers[RID_OMP_ALL_MEMORY];
38863 : 33 : cp_lexer_consume_token (parser->lexer);
38864 : : }
38865 : : else
38866 : : {
38867 : 29946 : name = cp_parser_id_expression (parser, /*template_p=*/false,
38868 : : /*check_dependency_p=*/true,
38869 : : /*template_p=*/NULL,
38870 : : /*declarator_p=*/false,
38871 : : /*optional_p=*/false);
38872 : 29946 : if (name == error_mark_node)
38873 : : {
38874 : 115 : if ((kind == OMP_CLAUSE_DEPEND || kind == OMP_CLAUSE_AFFINITY)
38875 : 115 : && cp_parser_simulate_error (parser))
38876 : 49 : goto depend_lvalue;
38877 : 66 : goto skip_comma;
38878 : : }
38879 : :
38880 : 29831 : if (identifier_p (name))
38881 : 29822 : decl = cp_parser_lookup_name_simple (parser, name, token->location);
38882 : : else
38883 : : decl = name;
38884 : 29831 : if (decl == error_mark_node)
38885 : : {
38886 : 48 : if ((kind == OMP_CLAUSE_DEPEND || kind == OMP_CLAUSE_AFFINITY)
38887 : 48 : && cp_parser_simulate_error (parser))
38888 : 9 : goto depend_lvalue;
38889 : 39 : cp_parser_name_lookup_error (parser, name, decl, NLE_NULL,
38890 : : token->location);
38891 : : }
38892 : : }
38893 : 30092 : if (outer_automatic_var_p (decl))
38894 : 7 : decl = process_outer_var_ref (decl, tf_warning_or_error);
38895 : 30092 : if (decl == error_mark_node)
38896 : : ;
38897 : 30047 : else if (kind != 0)
38898 : : {
38899 : 29530 : switch (kind)
38900 : : {
38901 : 674 : case OMP_CLAUSE__CACHE_:
38902 : : /* The OpenACC cache directive explicitly only allows "array
38903 : : elements or subarrays". */
38904 : 674 : if (cp_lexer_peek_token (parser->lexer)->type != CPP_OPEN_SQUARE)
38905 : : {
38906 : 18 : error_at (token->location, "expected %<[%>");
38907 : 18 : decl = error_mark_node;
38908 : 18 : break;
38909 : : }
38910 : : /* FALLTHROUGH. */
38911 : : case OMP_CLAUSE_MAP:
38912 : : case OMP_CLAUSE_FROM:
38913 : : case OMP_CLAUSE_TO:
38914 : 656 : start_component_ref:
38915 : 5854 : while (cp_lexer_next_token_is (parser->lexer, CPP_DOT)
38916 : 5854 : || cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
38917 : : {
38918 : 432 : cpp_ttype ttype
38919 : 432 : = cp_lexer_next_token_is (parser->lexer, CPP_DOT)
38920 : 432 : ? CPP_DOT : CPP_DEREF;
38921 : 432 : location_t loc
38922 : 432 : = cp_lexer_peek_token (parser->lexer)->location;
38923 : 432 : cp_id_kind idk = CP_ID_KIND_NONE;
38924 : 432 : cp_lexer_consume_token (parser->lexer);
38925 : 432 : decl = convert_from_reference (decl);
38926 : 432 : decl = (cp_parser_postfix_dot_deref_expression
38927 : 432 : (parser, ttype, cp_expr (decl, token->location),
38928 : : false, &idk, loc));
38929 : : }
38930 : : /* FALLTHROUGH. */
38931 : 14552 : case OMP_CLAUSE_AFFINITY:
38932 : 14552 : case OMP_CLAUSE_DEPEND:
38933 : 14552 : case OMP_CLAUSE_REDUCTION:
38934 : 14552 : case OMP_CLAUSE_IN_REDUCTION:
38935 : 14552 : case OMP_CLAUSE_TASK_REDUCTION:
38936 : 14552 : case OMP_CLAUSE_HAS_DEVICE_ADDR:
38937 : 14552 : array_section_p = false;
38938 : 14552 : dims.truncate (0);
38939 : 36071 : while (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
38940 : : {
38941 : 6967 : location_t loc = UNKNOWN_LOCATION;
38942 : 6967 : tree low_bound = NULL_TREE, length = NULL_TREE;
38943 : 6967 : bool no_colon = false;
38944 : :
38945 : 6967 : parser->colon_corrects_to_scope_p = false;
38946 : 6967 : cp_lexer_consume_token (parser->lexer);
38947 : 6967 : if (!cp_lexer_next_token_is (parser->lexer, CPP_COLON))
38948 : : {
38949 : 5659 : loc = cp_lexer_peek_token (parser->lexer)->location;
38950 : 5659 : low_bound = cp_parser_expression (parser);
38951 : : /* Later handling is not prepared to see through these. */
38952 : 5659 : gcc_checking_assert (!location_wrapper_p (low_bound));
38953 : : }
38954 : 6967 : if (!colon)
38955 : 6967 : parser->colon_corrects_to_scope_p
38956 : 6967 : = saved_colon_corrects_to_scope_p;
38957 : 6967 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
38958 : : {
38959 : 986 : length = integer_one_node;
38960 : 986 : no_colon = true;
38961 : : }
38962 : : else
38963 : : {
38964 : : /* Look for `:'. */
38965 : 5981 : if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
38966 : : {
38967 : 0 : if ((kind == OMP_CLAUSE_DEPEND || kind == OMP_CLAUSE_AFFINITY)
38968 : 0 : && cp_parser_simulate_error (parser))
38969 : 0 : goto depend_lvalue;
38970 : 0 : goto skip_comma;
38971 : : }
38972 : 5981 : if (kind == OMP_CLAUSE_DEPEND || kind == OMP_CLAUSE_AFFINITY)
38973 : 1020 : cp_parser_commit_to_tentative_parse (parser);
38974 : : else
38975 : : array_section_p = true;
38976 : 5981 : if (!cp_lexer_next_token_is (parser->lexer,
38977 : : CPP_CLOSE_SQUARE))
38978 : : {
38979 : 5171 : length = cp_parser_expression (parser);
38980 : : /* Later handling is not prepared to see through these. */
38981 : 5171 : gcc_checking_assert (!location_wrapper_p (length));
38982 : : }
38983 : : }
38984 : : /* Look for the closing `]'. */
38985 : 6967 : if (!cp_parser_require (parser, CPP_CLOSE_SQUARE,
38986 : : RT_CLOSE_SQUARE))
38987 : : {
38988 : 0 : if ((kind == OMP_CLAUSE_DEPEND || kind == OMP_CLAUSE_AFFINITY)
38989 : 0 : && cp_parser_simulate_error (parser))
38990 : 0 : goto depend_lvalue;
38991 : 0 : goto skip_comma;
38992 : : }
38993 : :
38994 : 6967 : dims.safe_push (omp_dim (low_bound, length, loc, no_colon));
38995 : : }
38996 : :
38997 : 14552 : if ((kind == OMP_CLAUSE_MAP
38998 : 14552 : || kind == OMP_CLAUSE_FROM
38999 : 9786 : || kind == OMP_CLAUSE_TO)
39000 : 4766 : && !array_section_p
39001 : 17146 : && (cp_lexer_next_token_is (parser->lexer, CPP_DOT)
39002 : 2591 : || cp_lexer_next_token_is (parser->lexer, CPP_DEREF)))
39003 : : {
39004 : 6 : for (unsigned i = 0; i < dims.length (); i++)
39005 : : {
39006 : 3 : gcc_assert (dims[i].length == integer_one_node);
39007 : 3 : decl = build_array_ref (dims[i].loc,
39008 : 3 : decl, dims[i].low_bound);
39009 : : }
39010 : 3 : goto start_component_ref;
39011 : : }
39012 : : else
39013 : 21513 : for (unsigned i = 0; i < dims.length (); i++)
39014 : 13928 : decl = build_omp_array_section (input_location, decl,
39015 : 6964 : dims[i].low_bound,
39016 : 6964 : dims[i].length);
39017 : : break;
39018 : : default:
39019 : : break;
39020 : : }
39021 : :
39022 : 29530 : if (kind == OMP_CLAUSE_DEPEND || kind == OMP_CLAUSE_AFFINITY)
39023 : : {
39024 : 1946 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
39025 : 1824 : && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
39026 : 2052 : && cp_parser_simulate_error (parser))
39027 : : {
39028 : 164 : depend_lvalue:
39029 : 164 : cp_parser_abort_tentative_parse (parser);
39030 : 164 : decl = cp_parser_assignment_expression (parser, NULL,
39031 : : false, false);
39032 : : }
39033 : : else
39034 : 1840 : cp_parser_parse_definitely (parser);
39035 : : }
39036 : :
39037 : 27584 : build_clause:
39038 : 37463 : tree u = build_omp_clause (token->location, kind);
39039 : 37463 : OMP_CLAUSE_DECL (u) = decl;
39040 : 37463 : OMP_CLAUSE_CHAIN (u) = list;
39041 : 37463 : list = u;
39042 : : }
39043 : : else
39044 : 517 : list = tree_cons (decl, NULL_TREE, list);
39045 : :
39046 : 38043 : get_comma:
39047 : 38043 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
39048 : : break;
39049 : 5270 : cp_lexer_consume_token (parser->lexer);
39050 : 5270 : }
39051 : :
39052 : 32773 : if (colon)
39053 : 3432 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
39054 : :
39055 : 3432 : if (colon != NULL && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
39056 : : {
39057 : 1573 : *colon = true;
39058 : 1573 : cp_parser_require (parser, CPP_COLON, RT_COLON);
39059 : 1573 : return list;
39060 : : }
39061 : :
39062 : 31200 : if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
39063 : : {
39064 : 261 : int ending;
39065 : :
39066 : : /* Try to resync to an unnested comma. Copied from
39067 : : cp_parser_parenthesized_expression_list. */
39068 : 195 : skip_comma:
39069 : 261 : if (colon)
39070 : 12 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
39071 : 261 : ending = cp_parser_skip_to_closing_parenthesis (parser,
39072 : : /*recovering=*/true,
39073 : : /*or_comma=*/true,
39074 : : /*consume_paren=*/true);
39075 : 261 : if (ending < 0)
39076 : 18 : goto get_comma;
39077 : : }
39078 : :
39079 : : return list;
39080 : 32821 : }
39081 : :
39082 : : /* Similarly, but expect leading and trailing parenthesis. This is a very
39083 : : common case for omp clauses. */
39084 : :
39085 : : static tree
39086 : 8646 : cp_parser_omp_var_list (cp_parser *parser, enum omp_clause_code kind, tree list,
39087 : : bool map_lvalue = false)
39088 : : {
39089 : 8646 : if (parser->lexer->in_omp_decl_attribute)
39090 : : {
39091 : 115 : if (kind)
39092 : : {
39093 : 60 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
39094 : 60 : tree u = build_omp_clause (loc, kind);
39095 : 60 : OMP_CLAUSE_DECL (u) = parser->lexer->in_omp_decl_attribute;
39096 : 60 : OMP_CLAUSE_CHAIN (u) = list;
39097 : 60 : return u;
39098 : : }
39099 : : else
39100 : 55 : return tree_cons (parser->lexer->in_omp_decl_attribute, NULL_TREE,
39101 : 55 : list);
39102 : : }
39103 : :
39104 : 8531 : if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
39105 : 8519 : return cp_parser_omp_var_list_no_open (parser, kind, list, NULL,
39106 : 8519 : map_lvalue);
39107 : : return list;
39108 : : }
39109 : :
39110 : : /* OpenACC 2.0:
39111 : : copy ( variable-list )
39112 : : copyin ( variable-list )
39113 : : copyout ( variable-list )
39114 : : create ( variable-list )
39115 : : delete ( variable-list )
39116 : : present ( variable-list )
39117 : :
39118 : : OpenACC 2.6:
39119 : : no_create ( variable-list )
39120 : : attach ( variable-list )
39121 : : detach ( variable-list )
39122 : :
39123 : : OpenACC 2.7:
39124 : : copyin (readonly : variable-list )
39125 : : */
39126 : :
39127 : : static tree
39128 : 3924 : cp_parser_oacc_data_clause (cp_parser *parser, pragma_omp_clause c_kind,
39129 : : tree list)
39130 : : {
39131 : 3924 : enum gomp_map_kind kind;
39132 : 3924 : switch (c_kind)
39133 : : {
39134 : : case PRAGMA_OACC_CLAUSE_ATTACH:
39135 : : kind = GOMP_MAP_ATTACH;
39136 : : break;
39137 : 1205 : case PRAGMA_OACC_CLAUSE_COPY:
39138 : 1205 : kind = GOMP_MAP_TOFROM;
39139 : 1205 : break;
39140 : 744 : case PRAGMA_OACC_CLAUSE_COPYIN:
39141 : 744 : kind = GOMP_MAP_TO;
39142 : 744 : break;
39143 : 902 : case PRAGMA_OACC_CLAUSE_COPYOUT:
39144 : 902 : kind = GOMP_MAP_FROM;
39145 : 902 : break;
39146 : 235 : case PRAGMA_OACC_CLAUSE_CREATE:
39147 : 235 : kind = GOMP_MAP_ALLOC;
39148 : 235 : break;
39149 : 143 : case PRAGMA_OACC_CLAUSE_DELETE:
39150 : 143 : kind = GOMP_MAP_RELEASE;
39151 : 143 : break;
39152 : 88 : case PRAGMA_OACC_CLAUSE_DETACH:
39153 : 88 : kind = GOMP_MAP_DETACH;
39154 : 88 : break;
39155 : 68 : case PRAGMA_OACC_CLAUSE_DEVICE:
39156 : 68 : kind = GOMP_MAP_FORCE_TO;
39157 : 68 : break;
39158 : 43 : case PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT:
39159 : 43 : kind = GOMP_MAP_DEVICE_RESIDENT;
39160 : 43 : break;
39161 : 39 : case PRAGMA_OACC_CLAUSE_LINK:
39162 : 39 : kind = GOMP_MAP_LINK;
39163 : 39 : break;
39164 : 14 : case PRAGMA_OACC_CLAUSE_NO_CREATE:
39165 : 14 : kind = GOMP_MAP_IF_PRESENT;
39166 : 14 : break;
39167 : 210 : case PRAGMA_OACC_CLAUSE_PRESENT:
39168 : 210 : kind = GOMP_MAP_FORCE_PRESENT;
39169 : 210 : break;
39170 : 133 : case PRAGMA_OACC_CLAUSE_SELF:
39171 : : /* "The 'host' clause is a synonym for the 'self' clause." */
39172 : 133 : case PRAGMA_OACC_CLAUSE_HOST:
39173 : 133 : kind = GOMP_MAP_FORCE_FROM;
39174 : 133 : break;
39175 : 0 : default:
39176 : 0 : gcc_unreachable ();
39177 : : }
39178 : :
39179 : 3924 : tree nl = list;
39180 : 3924 : bool readonly = false;
39181 : 3924 : if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
39182 : : {
39183 : : /* Turn on readonly modifier parsing for copyin clause. */
39184 : 3924 : if (c_kind == PRAGMA_OACC_CLAUSE_COPYIN)
39185 : : {
39186 : 744 : cp_token *token = cp_lexer_peek_token (parser->lexer);
39187 : 744 : if (token->type == CPP_NAME
39188 : 743 : && !strcmp (IDENTIFIER_POINTER (token->u.value), "readonly")
39189 : 765 : && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
39190 : : {
39191 : 21 : cp_lexer_consume_token (parser->lexer);
39192 : 21 : cp_lexer_consume_token (parser->lexer);
39193 : 21 : readonly = true;
39194 : : }
39195 : : }
39196 : 3924 : nl = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_MAP, list, NULL,
39197 : : false);
39198 : : }
39199 : :
39200 : 8687 : for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
39201 : : {
39202 : 4763 : OMP_CLAUSE_SET_MAP_KIND (c, kind);
39203 : 4763 : if (readonly)
39204 : 39 : OMP_CLAUSE_MAP_READONLY (c) = 1;
39205 : : }
39206 : :
39207 : 3924 : return nl;
39208 : : }
39209 : :
39210 : : /* OpenACC 2.0:
39211 : : deviceptr ( variable-list ) */
39212 : :
39213 : : static tree
39214 : 87 : cp_parser_oacc_data_clause_deviceptr (cp_parser *parser, tree list)
39215 : : {
39216 : 87 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
39217 : 87 : tree vars, t;
39218 : :
39219 : : /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
39220 : : cp_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
39221 : : variable-list must only allow for pointer variables. */
39222 : 87 : vars = cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
39223 : 174 : for (t = vars; t; t = TREE_CHAIN (t))
39224 : : {
39225 : 87 : tree v = TREE_PURPOSE (t);
39226 : 87 : tree u = build_omp_clause (loc, OMP_CLAUSE_MAP);
39227 : 87 : OMP_CLAUSE_SET_MAP_KIND (u, GOMP_MAP_FORCE_DEVICEPTR);
39228 : 87 : OMP_CLAUSE_DECL (u) = v;
39229 : 87 : OMP_CLAUSE_CHAIN (u) = list;
39230 : 87 : list = u;
39231 : : }
39232 : :
39233 : 87 : return list;
39234 : : }
39235 : :
39236 : : /* OpenACC 2.5:
39237 : : auto
39238 : : finalize
39239 : : independent
39240 : : nohost
39241 : : seq */
39242 : :
39243 : : static tree
39244 : 1233 : cp_parser_oacc_simple_clause (location_t loc, enum omp_clause_code code,
39245 : : tree list)
39246 : : {
39247 : 1233 : check_no_duplicate_clause (list, code, omp_clause_code_name[code], loc);
39248 : :
39249 : 1233 : tree c = build_omp_clause (loc, code);
39250 : 1233 : OMP_CLAUSE_CHAIN (c) = list;
39251 : :
39252 : 1233 : return c;
39253 : : }
39254 : :
39255 : : /* OpenACC:
39256 : : num_gangs ( expression )
39257 : : num_workers ( expression )
39258 : : vector_length ( expression ) */
39259 : :
39260 : : static tree
39261 : 1085 : cp_parser_oacc_single_int_clause (cp_parser *parser, omp_clause_code code,
39262 : : const char *str, tree list)
39263 : : {
39264 : 1085 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
39265 : :
39266 : 1085 : matching_parens parens;
39267 : 1085 : if (!parens.require_open (parser))
39268 : : return list;
39269 : :
39270 : 1067 : tree t = cp_parser_assignment_expression (parser, NULL, false, false);
39271 : :
39272 : 1067 : if (t == error_mark_node
39273 : 2062 : || !parens.require_close (parser))
39274 : : {
39275 : 180 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
39276 : : /*or_comma=*/false,
39277 : : /*consume_paren=*/true);
39278 : 180 : return list;
39279 : : }
39280 : :
39281 : 887 : check_no_duplicate_clause (list, code, str, loc);
39282 : :
39283 : 887 : tree c = build_omp_clause (loc, code);
39284 : 887 : OMP_CLAUSE_OPERAND (c, 0) = t;
39285 : 887 : OMP_CLAUSE_CHAIN (c) = list;
39286 : 887 : return c;
39287 : : }
39288 : :
39289 : : /* OpenACC:
39290 : :
39291 : : gang [( gang-arg-list )]
39292 : : worker [( [num:] int-expr )]
39293 : : vector [( [length:] int-expr )]
39294 : :
39295 : : where gang-arg is one of:
39296 : :
39297 : : [num:] int-expr
39298 : : static: size-expr
39299 : :
39300 : : and size-expr may be:
39301 : :
39302 : : *
39303 : : int-expr
39304 : : */
39305 : :
39306 : : static tree
39307 : 3271 : cp_parser_oacc_shape_clause (cp_parser *parser, location_t loc,
39308 : : omp_clause_code kind,
39309 : : const char *str, tree list)
39310 : : {
39311 : 3271 : const char *id = "num";
39312 : 3271 : cp_lexer *lexer = parser->lexer;
39313 : 3271 : tree ops[2] = { NULL_TREE, NULL_TREE }, c;
39314 : :
39315 : 3271 : if (kind == OMP_CLAUSE_VECTOR)
39316 : 1107 : id = "length";
39317 : :
39318 : 3271 : if (cp_lexer_next_token_is (lexer, CPP_OPEN_PAREN))
39319 : : {
39320 : 450 : matching_parens parens;
39321 : 450 : parens.consume_open (parser);
39322 : :
39323 : 495 : do
39324 : : {
39325 : 495 : cp_token *next = cp_lexer_peek_token (lexer);
39326 : 495 : int idx = 0;
39327 : :
39328 : : /* Gang static argument. */
39329 : 495 : if (kind == OMP_CLAUSE_GANG
39330 : 495 : && cp_lexer_next_token_is_keyword (lexer, RID_STATIC))
39331 : : {
39332 : 114 : cp_lexer_consume_token (lexer);
39333 : :
39334 : 114 : if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
39335 : 0 : goto cleanup_error;
39336 : :
39337 : 114 : idx = 1;
39338 : 114 : if (ops[idx] != NULL)
39339 : : {
39340 : 0 : cp_parser_error (parser, "too many %<static%> arguments");
39341 : 0 : goto cleanup_error;
39342 : : }
39343 : :
39344 : : /* Check for the '*' argument. */
39345 : 114 : if (cp_lexer_next_token_is (lexer, CPP_MULT)
39346 : 114 : && (cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA)
39347 : 47 : || cp_lexer_nth_token_is (parser->lexer, 2,
39348 : : CPP_CLOSE_PAREN)))
39349 : : {
39350 : 44 : cp_lexer_consume_token (lexer);
39351 : 44 : ops[idx] = integer_minus_one_node;
39352 : :
39353 : 44 : if (cp_lexer_next_token_is (lexer, CPP_COMMA))
39354 : : {
39355 : 3 : cp_lexer_consume_token (lexer);
39356 : 3 : continue;
39357 : : }
39358 : : else break;
39359 : : }
39360 : : }
39361 : : /* Worker num: argument and vector length: arguments. */
39362 : 381 : else if (cp_lexer_next_token_is (lexer, CPP_NAME)
39363 : 273 : && id_equal (next->u.value, id)
39364 : 630 : && cp_lexer_nth_token_is (lexer, 2, CPP_COLON))
39365 : : {
39366 : 231 : cp_lexer_consume_token (lexer); /* id */
39367 : 231 : cp_lexer_consume_token (lexer); /* ':' */
39368 : : }
39369 : :
39370 : : /* Now collect the actual argument. */
39371 : 451 : if (ops[idx] != NULL_TREE)
39372 : : {
39373 : 15 : cp_parser_error (parser, "unexpected argument");
39374 : 15 : goto cleanup_error;
39375 : : }
39376 : :
39377 : 436 : tree expr = cp_parser_assignment_expression (parser, NULL, false,
39378 : : false);
39379 : 436 : if (expr == error_mark_node)
39380 : 27 : goto cleanup_error;
39381 : :
39382 : 409 : mark_exp_read (expr);
39383 : 409 : ops[idx] = expr;
39384 : :
39385 : 451 : if (kind == OMP_CLAUSE_GANG
39386 : 409 : && cp_lexer_next_token_is (lexer, CPP_COMMA))
39387 : : {
39388 : 42 : cp_lexer_consume_token (lexer);
39389 : 42 : continue;
39390 : : }
39391 : : break;
39392 : : }
39393 : : while (1);
39394 : :
39395 : 408 : if (!parens.require_close (parser))
39396 : 15 : goto cleanup_error;
39397 : : }
39398 : :
39399 : 3214 : check_no_duplicate_clause (list, kind, str, loc);
39400 : :
39401 : 3214 : c = build_omp_clause (loc, kind);
39402 : :
39403 : 3214 : if (ops[1])
39404 : 111 : OMP_CLAUSE_OPERAND (c, 1) = ops[1];
39405 : :
39406 : 3214 : OMP_CLAUSE_OPERAND (c, 0) = ops[0];
39407 : 3214 : OMP_CLAUSE_CHAIN (c) = list;
39408 : :
39409 : 3214 : return c;
39410 : :
39411 : 57 : cleanup_error:
39412 : 57 : cp_parser_skip_to_closing_parenthesis (parser, false, false, true);
39413 : 57 : return list;
39414 : : }
39415 : :
39416 : : /* OpenACC 2.0:
39417 : : tile ( size-expr-list ) */
39418 : :
39419 : : static tree
39420 : 319 : cp_parser_oacc_clause_tile (cp_parser *parser, location_t clause_loc, tree list)
39421 : : {
39422 : 319 : tree c, expr = error_mark_node;
39423 : 319 : tree tile = NULL_TREE;
39424 : :
39425 : : /* Collapse and tile are mutually exclusive. (The spec doesn't say
39426 : : so, but the spec authors never considered such a case and have
39427 : : differing opinions on what it might mean, including 'not
39428 : : allowed'.) */
39429 : 319 : check_no_duplicate_clause (list, OMP_CLAUSE_TILE, "tile", clause_loc);
39430 : 319 : check_no_duplicate_clause (list, OMP_CLAUSE_COLLAPSE, "collapse",
39431 : : clause_loc);
39432 : :
39433 : 319 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
39434 : : return list;
39435 : :
39436 : 423 : do
39437 : : {
39438 : 423 : if (tile && !cp_parser_require (parser, CPP_COMMA, RT_COMMA))
39439 : : return list;
39440 : :
39441 : 423 : if (cp_lexer_next_token_is (parser->lexer, CPP_MULT)
39442 : 423 : && (cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA)
39443 : 143 : || cp_lexer_nth_token_is (parser->lexer, 2, CPP_CLOSE_PAREN)))
39444 : : {
39445 : 160 : cp_lexer_consume_token (parser->lexer);
39446 : 160 : expr = integer_zero_node;
39447 : : }
39448 : 263 : else if (cp_lexer_next_token_is (parser->lexer, CPP_EMBED))
39449 : : {
39450 : : /* Handle #embed in the size-expr-list. */
39451 : 0 : tree raw_data = cp_lexer_peek_token (parser->lexer)->u.value;
39452 : 0 : cp_lexer_consume_token (parser->lexer);
39453 : 0 : for (tree argument : raw_data_range (raw_data))
39454 : 0 : tile = tree_cons (NULL_TREE, argument, tile);
39455 : 0 : continue;
39456 : 0 : }
39457 : : else
39458 : 263 : expr = cp_parser_constant_expression (parser);
39459 : :
39460 : 423 : tile = tree_cons (NULL_TREE, expr, tile);
39461 : : }
39462 : 423 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN));
39463 : :
39464 : : /* Consume the trailing ')'. */
39465 : 304 : cp_lexer_consume_token (parser->lexer);
39466 : :
39467 : 304 : c = build_omp_clause (clause_loc, OMP_CLAUSE_TILE);
39468 : 304 : tile = nreverse (tile);
39469 : 304 : OMP_CLAUSE_TILE_LIST (c) = tile;
39470 : 304 : OMP_CLAUSE_CHAIN (c) = list;
39471 : 304 : return c;
39472 : : }
39473 : :
39474 : : /* OpenACC 2.0
39475 : : Parse wait clause or directive parameters. */
39476 : :
39477 : : static tree
39478 : 199 : cp_parser_oacc_wait_list (cp_parser *parser, location_t clause_loc, tree list)
39479 : : {
39480 : 199 : vec<tree, va_gc> *args;
39481 : 199 : tree t, args_tree;
39482 : :
39483 : 199 : args = cp_parser_parenthesized_expression_list (parser, non_attr,
39484 : : /*cast_p=*/false,
39485 : : /*allow_expansion_p=*/true,
39486 : : /*non_constant_p=*/NULL);
39487 : :
39488 : 199 : if (args == NULL || args->length () == 0)
39489 : : {
39490 : 12 : if (args != NULL)
39491 : : {
39492 : 3 : cp_parser_error (parser, "expected integer expression list");
39493 : 3 : release_tree_vector (args);
39494 : : }
39495 : 12 : return list;
39496 : : }
39497 : :
39498 : 187 : args_tree = build_tree_list_vec (args);
39499 : :
39500 : 187 : release_tree_vector (args);
39501 : :
39502 : 459 : for (t = args_tree; t; t = TREE_CHAIN (t))
39503 : : {
39504 : 272 : tree targ = TREE_VALUE (t);
39505 : :
39506 : 272 : if (targ != error_mark_node)
39507 : : {
39508 : 236 : if (!INTEGRAL_TYPE_P (TREE_TYPE (targ)))
39509 : 18 : error ("%<wait%> expression must be integral");
39510 : : else
39511 : : {
39512 : 218 : tree c = build_omp_clause (clause_loc, OMP_CLAUSE_WAIT);
39513 : :
39514 : 218 : targ = mark_rvalue_use (targ);
39515 : 218 : OMP_CLAUSE_DECL (c) = targ;
39516 : 218 : OMP_CLAUSE_CHAIN (c) = list;
39517 : 218 : list = c;
39518 : : }
39519 : : }
39520 : : }
39521 : :
39522 : : return list;
39523 : : }
39524 : :
39525 : : /* OpenACC:
39526 : : wait [( int-expr-list )] */
39527 : :
39528 : : static tree
39529 : 177 : cp_parser_oacc_clause_wait (cp_parser *parser, tree list)
39530 : : {
39531 : 177 : location_t location = cp_lexer_peek_token (parser->lexer)->location;
39532 : :
39533 : 177 : if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
39534 : 132 : list = cp_parser_oacc_wait_list (parser, location, list);
39535 : : else
39536 : : {
39537 : 45 : tree c = build_omp_clause (location, OMP_CLAUSE_WAIT);
39538 : :
39539 : 45 : OMP_CLAUSE_DECL (c) = build_int_cst (integer_type_node, GOMP_ASYNC_NOVAL);
39540 : 45 : OMP_CLAUSE_CHAIN (c) = list;
39541 : 45 : list = c;
39542 : : }
39543 : :
39544 : 177 : return list;
39545 : : }
39546 : :
39547 : : /* OpenMP 3.0:
39548 : : collapse ( constant-expression ) */
39549 : :
39550 : : static tree
39551 : 4253 : cp_parser_omp_clause_collapse (cp_parser *parser, tree list, location_t location)
39552 : : {
39553 : 4253 : tree c, num;
39554 : 4253 : location_t loc;
39555 : 4253 : HOST_WIDE_INT n;
39556 : :
39557 : 4253 : loc = cp_lexer_peek_token (parser->lexer)->location;
39558 : 4253 : matching_parens parens;
39559 : 4253 : if (!parens.require_open (parser))
39560 : : return list;
39561 : :
39562 : 4253 : num = cp_parser_constant_expression (parser);
39563 : :
39564 : 4253 : if (!parens.require_close (parser))
39565 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
39566 : : /*or_comma=*/false,
39567 : : /*consume_paren=*/true);
39568 : :
39569 : 4253 : if (num == error_mark_node)
39570 : : return list;
39571 : 4253 : num = fold_non_dependent_expr (num);
39572 : 4253 : if (!tree_fits_shwi_p (num)
39573 : 4250 : || !INTEGRAL_TYPE_P (TREE_TYPE (num))
39574 : 4250 : || (n = tree_to_shwi (num)) <= 0
39575 : 8503 : || (int) n != n)
39576 : : {
39577 : 3 : error_at (loc, "collapse argument needs positive constant integer expression");
39578 : 3 : return list;
39579 : : }
39580 : :
39581 : 4250 : check_no_duplicate_clause (list, OMP_CLAUSE_COLLAPSE, "collapse", location);
39582 : 4250 : check_no_duplicate_clause (list, OMP_CLAUSE_TILE, "tile", location);
39583 : 4250 : c = build_omp_clause (loc, OMP_CLAUSE_COLLAPSE);
39584 : 4250 : OMP_CLAUSE_CHAIN (c) = list;
39585 : 4250 : OMP_CLAUSE_COLLAPSE_EXPR (c) = num;
39586 : :
39587 : 4250 : return c;
39588 : : }
39589 : :
39590 : : /* OpenMP 2.5:
39591 : : default ( none | shared )
39592 : :
39593 : : OpenMP 5.1:
39594 : : default ( private | firstprivate )
39595 : :
39596 : : OpenACC:
39597 : : default ( none | present ) */
39598 : :
39599 : : static tree
39600 : 1990 : cp_parser_omp_clause_default (cp_parser *parser, tree list,
39601 : : location_t location, bool is_oacc)
39602 : : {
39603 : 1990 : enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
39604 : 1990 : tree c;
39605 : :
39606 : 1990 : matching_parens parens;
39607 : 1990 : if (!parens.require_open (parser))
39608 : : return list;
39609 : 1984 : if (!is_oacc && cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
39610 : : {
39611 : 26 : kind = OMP_CLAUSE_DEFAULT_PRIVATE;
39612 : 26 : cp_lexer_consume_token (parser->lexer);
39613 : : }
39614 : 1958 : else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
39615 : : {
39616 : 1928 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39617 : 1928 : const char *p = IDENTIFIER_POINTER (id);
39618 : :
39619 : 1928 : switch (p[0])
39620 : : {
39621 : 1048 : case 'n':
39622 : 1048 : if (strcmp ("none", p) != 0)
39623 : 0 : goto invalid_kind;
39624 : : kind = OMP_CLAUSE_DEFAULT_NONE;
39625 : : break;
39626 : :
39627 : 30 : case 'p':
39628 : 30 : if (strcmp ("present", p) != 0 || !is_oacc)
39629 : 0 : goto invalid_kind;
39630 : : kind = OMP_CLAUSE_DEFAULT_PRESENT;
39631 : : break;
39632 : :
39633 : 32 : case 'f':
39634 : 32 : if (strcmp ("firstprivate", p) != 0 || is_oacc)
39635 : 0 : goto invalid_kind;
39636 : : kind = OMP_CLAUSE_DEFAULT_FIRSTPRIVATE;
39637 : : break;
39638 : :
39639 : 806 : case 's':
39640 : 806 : if (strcmp ("shared", p) != 0 || is_oacc)
39641 : 0 : goto invalid_kind;
39642 : : kind = OMP_CLAUSE_DEFAULT_SHARED;
39643 : : break;
39644 : :
39645 : 12 : default:
39646 : 12 : goto invalid_kind;
39647 : : }
39648 : :
39649 : 1904 : cp_lexer_consume_token (parser->lexer);
39650 : : }
39651 : : else
39652 : : {
39653 : 54 : invalid_kind:
39654 : 54 : if (is_oacc)
39655 : 42 : cp_parser_error (parser, "expected %<none%> or %<present%>");
39656 : : else
39657 : 12 : cp_parser_error (parser, "expected %<none%>, %<shared%>, "
39658 : : "%<private%> or %<firstprivate%>");
39659 : : }
39660 : :
39661 : 1984 : if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED
39662 : 1930 : || !parens.require_close (parser))
39663 : 72 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
39664 : : /*or_comma=*/false,
39665 : : /*consume_paren=*/true);
39666 : :
39667 : 1984 : if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED)
39668 : : return list;
39669 : :
39670 : 1930 : check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default", location);
39671 : 1930 : c = build_omp_clause (location, OMP_CLAUSE_DEFAULT);
39672 : 1930 : OMP_CLAUSE_CHAIN (c) = list;
39673 : 1930 : OMP_CLAUSE_DEFAULT_KIND (c) = kind;
39674 : :
39675 : 1930 : return c;
39676 : : }
39677 : :
39678 : : /* OpenMP 3.1:
39679 : : final ( expression ) */
39680 : :
39681 : : static tree
39682 : 280 : cp_parser_omp_clause_final (cp_parser *parser, tree list, location_t location)
39683 : : {
39684 : 280 : tree t, c;
39685 : :
39686 : 280 : matching_parens parens;
39687 : 280 : if (!parens.require_open (parser))
39688 : : return list;
39689 : :
39690 : 280 : t = cp_parser_assignment_expression (parser);
39691 : :
39692 : 280 : if (t == error_mark_node
39693 : 560 : || !parens.require_close (parser))
39694 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
39695 : : /*or_comma=*/false,
39696 : : /*consume_paren=*/true);
39697 : :
39698 : 280 : check_no_duplicate_clause (list, OMP_CLAUSE_FINAL, "final", location);
39699 : :
39700 : 280 : c = build_omp_clause (location, OMP_CLAUSE_FINAL);
39701 : 280 : OMP_CLAUSE_FINAL_EXPR (c) = t;
39702 : 280 : OMP_CLAUSE_CHAIN (c) = list;
39703 : :
39704 : 280 : return c;
39705 : : }
39706 : :
39707 : : /* OpenMP 5.1:
39708 : : indirect [( expression )]
39709 : : */
39710 : :
39711 : : static tree
39712 : 85 : cp_parser_omp_clause_indirect (cp_parser *parser, tree list,
39713 : : location_t location)
39714 : : {
39715 : 85 : tree t;
39716 : :
39717 : 85 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
39718 : : {
39719 : 55 : matching_parens parens;
39720 : 55 : if (!parens.require_open (parser))
39721 : 0 : return list;
39722 : :
39723 : 55 : bool non_constant_p;
39724 : 55 : t = cp_parser_constant_expression (parser, true, &non_constant_p);
39725 : :
39726 : 55 : if (t != error_mark_node && non_constant_p)
39727 : 3 : error_at (location, "expected constant logical expression");
39728 : :
39729 : 55 : if (t == error_mark_node
39730 : 110 : || !parens.require_close (parser))
39731 : 0 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
39732 : : /*or_comma=*/false,
39733 : : /*consume_paren=*/true);
39734 : : }
39735 : : else
39736 : 30 : t = integer_one_node;
39737 : :
39738 : 85 : check_no_duplicate_clause (list, OMP_CLAUSE_INDIRECT, "indirect", location);
39739 : :
39740 : 85 : tree c = build_omp_clause (location, OMP_CLAUSE_INDIRECT);
39741 : 85 : OMP_CLAUSE_INDIRECT_EXPR (c) = t;
39742 : 85 : OMP_CLAUSE_CHAIN (c) = list;
39743 : :
39744 : 85 : return c;
39745 : : }
39746 : :
39747 : : /* OpenMP 2.5:
39748 : : if ( expression )
39749 : :
39750 : : OpenMP 4.5:
39751 : : if ( directive-name-modifier : expression )
39752 : :
39753 : : directive-name-modifier:
39754 : : parallel | task | taskloop | target data | target | target update
39755 : : | target enter data | target exit data
39756 : :
39757 : : OpenMP 5.0:
39758 : : directive-name-modifier:
39759 : : ... | simd | cancel */
39760 : :
39761 : : static tree
39762 : 1986 : cp_parser_omp_clause_if (cp_parser *parser, tree list, location_t location,
39763 : : bool is_omp)
39764 : : {
39765 : 1986 : tree t, c;
39766 : 1986 : enum tree_code if_modifier = ERROR_MARK;
39767 : :
39768 : 1986 : matching_parens parens;
39769 : 1986 : if (!parens.require_open (parser))
39770 : : return list;
39771 : :
39772 : 1986 : if (is_omp && cp_lexer_next_token_is (parser->lexer, CPP_NAME))
39773 : : {
39774 : 1614 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39775 : 1614 : const char *p = IDENTIFIER_POINTER (id);
39776 : 1614 : int n = 2;
39777 : :
39778 : 1614 : if (strcmp ("cancel", p) == 0)
39779 : : if_modifier = VOID_CST;
39780 : 1578 : else if (strcmp ("parallel", p) == 0)
39781 : : if_modifier = OMP_PARALLEL;
39782 : 1167 : else if (strcmp ("simd", p) == 0)
39783 : : if_modifier = OMP_SIMD;
39784 : 944 : else if (strcmp ("task", p) == 0)
39785 : : if_modifier = OMP_TASK;
39786 : 911 : else if (strcmp ("taskloop", p) == 0)
39787 : : if_modifier = OMP_TASKLOOP;
39788 : 758 : else if (strcmp ("target", p) == 0)
39789 : : {
39790 : 300 : if_modifier = OMP_TARGET;
39791 : 300 : if (cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
39792 : : {
39793 : 111 : id = cp_lexer_peek_nth_token (parser->lexer, 2)->u.value;
39794 : 111 : p = IDENTIFIER_POINTER (id);
39795 : 111 : if (strcmp ("data", p) == 0)
39796 : : if_modifier = OMP_TARGET_DATA;
39797 : 87 : else if (strcmp ("update", p) == 0)
39798 : : if_modifier = OMP_TARGET_UPDATE;
39799 : 54 : else if (strcmp ("enter", p) == 0)
39800 : : if_modifier = OMP_TARGET_ENTER_DATA;
39801 : 30 : else if (strcmp ("exit", p) == 0)
39802 : : if_modifier = OMP_TARGET_EXIT_DATA;
39803 : 0 : if (if_modifier != OMP_TARGET)
39804 : : n = 3;
39805 : : else
39806 : : {
39807 : 0 : location_t loc
39808 : 0 : = cp_lexer_peek_nth_token (parser->lexer, 2)->location;
39809 : 0 : error_at (loc, "expected %<data%>, %<update%>, %<enter%> "
39810 : : "or %<exit%>");
39811 : 0 : if_modifier = ERROR_MARK;
39812 : : }
39813 : 0 : if (if_modifier == OMP_TARGET_ENTER_DATA
39814 : 111 : || if_modifier == OMP_TARGET_EXIT_DATA)
39815 : : {
39816 : 54 : if (cp_lexer_nth_token_is (parser->lexer, 3, CPP_NAME))
39817 : : {
39818 : 54 : id = cp_lexer_peek_nth_token (parser->lexer, 3)->u.value;
39819 : 54 : p = IDENTIFIER_POINTER (id);
39820 : 54 : if (strcmp ("data", p) == 0)
39821 : : n = 4;
39822 : : }
39823 : 0 : if (n != 4)
39824 : : {
39825 : 0 : location_t loc
39826 : 0 : = cp_lexer_peek_nth_token (parser->lexer, 3)->location;
39827 : 0 : error_at (loc, "expected %<data%>");
39828 : 0 : if_modifier = ERROR_MARK;
39829 : : }
39830 : : }
39831 : : }
39832 : : }
39833 : 111 : if (if_modifier != ERROR_MARK)
39834 : : {
39835 : 1156 : if (cp_lexer_nth_token_is (parser->lexer, n, CPP_COLON))
39836 : : {
39837 : 3624 : while (n-- > 0)
39838 : 2471 : cp_lexer_consume_token (parser->lexer);
39839 : : }
39840 : : else
39841 : : {
39842 : 3 : if (n > 2)
39843 : : {
39844 : 0 : location_t loc
39845 : 0 : = cp_lexer_peek_nth_token (parser->lexer, n)->location;
39846 : 0 : error_at (loc, "expected %<:%>");
39847 : : }
39848 : : if_modifier = ERROR_MARK;
39849 : : }
39850 : : }
39851 : : }
39852 : :
39853 : 1986 : t = cp_parser_assignment_expression (parser);
39854 : :
39855 : 1986 : if (t == error_mark_node
39856 : 3972 : || !parens.require_close (parser))
39857 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
39858 : : /*or_comma=*/false,
39859 : : /*consume_paren=*/true);
39860 : :
39861 : 10522 : for (c = list; c ; c = OMP_CLAUSE_CHAIN (c))
39862 : 8656 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IF)
39863 : : {
39864 : 516 : if (if_modifier != ERROR_MARK
39865 : 516 : && OMP_CLAUSE_IF_MODIFIER (c) == if_modifier)
39866 : : {
39867 : 27 : const char *p = NULL;
39868 : 27 : switch (if_modifier)
39869 : : {
39870 : : case VOID_CST: p = "cancel"; break;
39871 : 3 : case OMP_PARALLEL: p = "parallel"; break;
39872 : 0 : case OMP_SIMD: p = "simd"; break;
39873 : 3 : case OMP_TASK: p = "task"; break;
39874 : 3 : case OMP_TASKLOOP: p = "taskloop"; break;
39875 : 3 : case OMP_TARGET_DATA: p = "target data"; break;
39876 : 3 : case OMP_TARGET: p = "target"; break;
39877 : 3 : case OMP_TARGET_UPDATE: p = "target update"; break;
39878 : 3 : case OMP_TARGET_ENTER_DATA: p = "target enter data"; break;
39879 : 3 : case OMP_TARGET_EXIT_DATA: p = "target exit data"; break;
39880 : 0 : default: gcc_unreachable ();
39881 : : }
39882 : 27 : error_at (location, "too many %<if%> clauses with %qs modifier",
39883 : : p);
39884 : 27 : return list;
39885 : : }
39886 : 489 : else if (OMP_CLAUSE_IF_MODIFIER (c) == if_modifier)
39887 : : {
39888 : 39 : if (!is_omp)
39889 : 3 : error_at (location, "too many %<if%> clauses");
39890 : : else
39891 : 36 : error_at (location, "too many %<if%> clauses without modifier");
39892 : 39 : return list;
39893 : : }
39894 : 450 : else if (if_modifier == ERROR_MARK
39895 : 450 : || OMP_CLAUSE_IF_MODIFIER (c) == ERROR_MARK)
39896 : : {
39897 : 54 : error_at (location, "if any %<if%> clause has modifier, then all "
39898 : : "%<if%> clauses have to use modifier");
39899 : 54 : return list;
39900 : : }
39901 : : }
39902 : :
39903 : 1866 : c = build_omp_clause (location, OMP_CLAUSE_IF);
39904 : 1866 : OMP_CLAUSE_IF_MODIFIER (c) = if_modifier;
39905 : 1866 : OMP_CLAUSE_IF_EXPR (c) = t;
39906 : 1866 : OMP_CLAUSE_CHAIN (c) = list;
39907 : :
39908 : 1866 : return c;
39909 : : }
39910 : :
39911 : : /* OpenMP 3.1:
39912 : : mergeable */
39913 : :
39914 : : static tree
39915 : 228 : cp_parser_omp_clause_mergeable (cp_parser * /*parser*/,
39916 : : tree list, location_t location)
39917 : : {
39918 : 228 : tree c;
39919 : :
39920 : 228 : check_no_duplicate_clause (list, OMP_CLAUSE_MERGEABLE, "mergeable",
39921 : : location);
39922 : :
39923 : 228 : c = build_omp_clause (location, OMP_CLAUSE_MERGEABLE);
39924 : 228 : OMP_CLAUSE_CHAIN (c) = list;
39925 : 228 : return c;
39926 : : }
39927 : :
39928 : : /* OpenMP 2.5:
39929 : : nowait */
39930 : :
39931 : : static tree
39932 : 600 : cp_parser_omp_clause_nowait (cp_parser * /*parser*/,
39933 : : tree list, location_t location)
39934 : : {
39935 : 600 : tree c;
39936 : :
39937 : 600 : check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait", location);
39938 : :
39939 : 600 : c = build_omp_clause (location, OMP_CLAUSE_NOWAIT);
39940 : 600 : OMP_CLAUSE_CHAIN (c) = list;
39941 : 600 : return c;
39942 : : }
39943 : :
39944 : : /* OpenMP 2.5:
39945 : : num_threads ( expression ) */
39946 : :
39947 : : static tree
39948 : 776 : cp_parser_omp_clause_num_threads (cp_parser *parser, tree list,
39949 : : location_t location)
39950 : : {
39951 : 776 : tree t, c;
39952 : :
39953 : 776 : matching_parens parens;
39954 : 776 : if (!parens.require_open (parser))
39955 : : return list;
39956 : :
39957 : 776 : t = cp_parser_assignment_expression (parser);
39958 : :
39959 : 776 : if (t == error_mark_node
39960 : 1552 : || !parens.require_close (parser))
39961 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
39962 : : /*or_comma=*/false,
39963 : : /*consume_paren=*/true);
39964 : :
39965 : 776 : check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS,
39966 : : "num_threads", location);
39967 : :
39968 : 776 : c = build_omp_clause (location, OMP_CLAUSE_NUM_THREADS);
39969 : 776 : OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
39970 : 776 : OMP_CLAUSE_CHAIN (c) = list;
39971 : :
39972 : 776 : return c;
39973 : : }
39974 : :
39975 : : /* OpenMP 4.5:
39976 : : num_tasks ( expression )
39977 : :
39978 : : OpenMP 5.1:
39979 : : num_tasks ( strict : expression ) */
39980 : :
39981 : : static tree
39982 : 132 : cp_parser_omp_clause_num_tasks (cp_parser *parser, tree list,
39983 : : location_t location)
39984 : : {
39985 : 132 : tree t, c;
39986 : :
39987 : 132 : matching_parens parens;
39988 : 132 : if (!parens.require_open (parser))
39989 : : return list;
39990 : :
39991 : 132 : bool strict = false;
39992 : 132 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
39993 : 132 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
39994 : : {
39995 : 1 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39996 : 1 : if (!strcmp (IDENTIFIER_POINTER (id), "strict"))
39997 : : {
39998 : 1 : strict = true;
39999 : 1 : cp_lexer_consume_token (parser->lexer);
40000 : 1 : cp_lexer_consume_token (parser->lexer);
40001 : : }
40002 : : }
40003 : :
40004 : 132 : t = cp_parser_assignment_expression (parser);
40005 : :
40006 : 132 : if (t == error_mark_node
40007 : 264 : || !parens.require_close (parser))
40008 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40009 : : /*or_comma=*/false,
40010 : : /*consume_paren=*/true);
40011 : :
40012 : 132 : check_no_duplicate_clause (list, OMP_CLAUSE_NUM_TASKS,
40013 : : "num_tasks", location);
40014 : :
40015 : 132 : c = build_omp_clause (location, OMP_CLAUSE_NUM_TASKS);
40016 : 132 : OMP_CLAUSE_NUM_TASKS_EXPR (c) = t;
40017 : 132 : OMP_CLAUSE_NUM_TASKS_STRICT (c) = strict;
40018 : 132 : OMP_CLAUSE_CHAIN (c) = list;
40019 : :
40020 : 132 : return c;
40021 : : }
40022 : :
40023 : : /* OpenMP 4.5:
40024 : : grainsize ( expression )
40025 : :
40026 : : OpenMP 5.1:
40027 : : grainsize ( strict : expression ) */
40028 : :
40029 : : static tree
40030 : 163 : cp_parser_omp_clause_grainsize (cp_parser *parser, tree list,
40031 : : location_t location)
40032 : : {
40033 : 163 : tree t, c;
40034 : :
40035 : 163 : matching_parens parens;
40036 : 163 : if (!parens.require_open (parser))
40037 : : return list;
40038 : :
40039 : 163 : bool strict = false;
40040 : 163 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
40041 : 163 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
40042 : : {
40043 : 1 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40044 : 1 : if (!strcmp (IDENTIFIER_POINTER (id), "strict"))
40045 : : {
40046 : 1 : strict = true;
40047 : 1 : cp_lexer_consume_token (parser->lexer);
40048 : 1 : cp_lexer_consume_token (parser->lexer);
40049 : : }
40050 : : }
40051 : :
40052 : 163 : t = cp_parser_assignment_expression (parser);
40053 : :
40054 : 163 : if (t == error_mark_node
40055 : 326 : || !parens.require_close (parser))
40056 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40057 : : /*or_comma=*/false,
40058 : : /*consume_paren=*/true);
40059 : :
40060 : 163 : check_no_duplicate_clause (list, OMP_CLAUSE_GRAINSIZE,
40061 : : "grainsize", location);
40062 : :
40063 : 163 : c = build_omp_clause (location, OMP_CLAUSE_GRAINSIZE);
40064 : 163 : OMP_CLAUSE_GRAINSIZE_EXPR (c) = t;
40065 : 163 : OMP_CLAUSE_GRAINSIZE_STRICT (c) = strict;
40066 : 163 : OMP_CLAUSE_CHAIN (c) = list;
40067 : :
40068 : 163 : return c;
40069 : : }
40070 : :
40071 : : /* OpenMP 4.5:
40072 : : priority ( expression ) */
40073 : :
40074 : : static tree
40075 : 273 : cp_parser_omp_clause_priority (cp_parser *parser, tree list,
40076 : : location_t location)
40077 : : {
40078 : 273 : tree t, c;
40079 : :
40080 : 273 : matching_parens parens;
40081 : 273 : if (!parens.require_open (parser))
40082 : : return list;
40083 : :
40084 : 273 : t = cp_parser_assignment_expression (parser);
40085 : :
40086 : 273 : if (t == error_mark_node
40087 : 546 : || !parens.require_close (parser))
40088 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40089 : : /*or_comma=*/false,
40090 : : /*consume_paren=*/true);
40091 : :
40092 : 273 : check_no_duplicate_clause (list, OMP_CLAUSE_PRIORITY,
40093 : : "priority", location);
40094 : :
40095 : 273 : c = build_omp_clause (location, OMP_CLAUSE_PRIORITY);
40096 : 273 : OMP_CLAUSE_PRIORITY_EXPR (c) = t;
40097 : 273 : OMP_CLAUSE_CHAIN (c) = list;
40098 : :
40099 : 273 : return c;
40100 : : }
40101 : :
40102 : : /* OpenMP 4.5:
40103 : : hint ( expression ) */
40104 : :
40105 : : static tree
40106 : 180 : cp_parser_omp_clause_hint (cp_parser *parser, tree list, location_t location)
40107 : : {
40108 : 180 : tree t, c;
40109 : :
40110 : 180 : matching_parens parens;
40111 : 180 : if (!parens.require_open (parser))
40112 : : return list;
40113 : :
40114 : 180 : t = cp_parser_assignment_expression (parser);
40115 : :
40116 : 180 : if (t != error_mark_node)
40117 : : {
40118 : 180 : t = fold_non_dependent_expr (t);
40119 : 180 : if (!value_dependent_expression_p (t)
40120 : 180 : && (!INTEGRAL_TYPE_P (TREE_TYPE (t))
40121 : 135 : || !tree_fits_shwi_p (t)
40122 : 125 : || tree_int_cst_sgn (t) == -1))
40123 : 14 : error_at (location, "expected constant integer expression with "
40124 : : "valid sync-hint value");
40125 : : }
40126 : 180 : if (t == error_mark_node
40127 : 360 : || !parens.require_close (parser))
40128 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40129 : : /*or_comma=*/false,
40130 : : /*consume_paren=*/true);
40131 : 180 : check_no_duplicate_clause (list, OMP_CLAUSE_HINT, "hint", location);
40132 : :
40133 : 180 : c = build_omp_clause (location, OMP_CLAUSE_HINT);
40134 : 180 : OMP_CLAUSE_HINT_EXPR (c) = t;
40135 : 180 : OMP_CLAUSE_CHAIN (c) = list;
40136 : :
40137 : 180 : return c;
40138 : : }
40139 : :
40140 : : /* OpenMP 5.1:
40141 : : filter ( integer-expression ) */
40142 : :
40143 : : static tree
40144 : 177 : cp_parser_omp_clause_filter (cp_parser *parser, tree list, location_t location)
40145 : : {
40146 : 177 : tree t, c;
40147 : :
40148 : 177 : matching_parens parens;
40149 : 177 : if (!parens.require_open (parser))
40150 : : return list;
40151 : :
40152 : 177 : t = cp_parser_assignment_expression (parser);
40153 : :
40154 : 177 : if (t == error_mark_node
40155 : 354 : || !parens.require_close (parser))
40156 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40157 : : /*or_comma=*/false,
40158 : : /*consume_paren=*/true);
40159 : 177 : check_no_duplicate_clause (list, OMP_CLAUSE_FILTER, "filter", location);
40160 : :
40161 : 177 : c = build_omp_clause (location, OMP_CLAUSE_FILTER);
40162 : 177 : OMP_CLAUSE_FILTER_EXPR (c) = t;
40163 : 177 : OMP_CLAUSE_CHAIN (c) = list;
40164 : :
40165 : 177 : return c;
40166 : : }
40167 : :
40168 : : /* OpenMP 4.5:
40169 : : defaultmap ( tofrom : scalar )
40170 : :
40171 : : OpenMP 5.0:
40172 : : defaultmap ( implicit-behavior [ : variable-category ] ) */
40173 : :
40174 : : static tree
40175 : 640 : cp_parser_omp_clause_defaultmap (cp_parser *parser, tree list,
40176 : : location_t location)
40177 : : {
40178 : 640 : tree c, id;
40179 : 640 : const char *p;
40180 : 640 : enum omp_clause_defaultmap_kind behavior = OMP_CLAUSE_DEFAULTMAP_DEFAULT;
40181 : 640 : enum omp_clause_defaultmap_kind category
40182 : : = OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED;
40183 : :
40184 : 640 : matching_parens parens;
40185 : 640 : if (!parens.require_open (parser))
40186 : : return list;
40187 : :
40188 : 640 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
40189 : : p = "default";
40190 : 622 : else if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40191 : : {
40192 : 6 : invalid_behavior:
40193 : 9 : cp_parser_error (parser, "expected %<alloc%>, %<to%>, %<from%>, "
40194 : : "%<tofrom%>, %<firstprivate%>, %<none%> "
40195 : : "or %<default%>");
40196 : 9 : goto out_err;
40197 : : }
40198 : : else
40199 : : {
40200 : 616 : id = cp_lexer_peek_token (parser->lexer)->u.value;
40201 : 616 : p = IDENTIFIER_POINTER (id);
40202 : : }
40203 : :
40204 : 634 : switch (p[0])
40205 : : {
40206 : 18 : case 'a':
40207 : 18 : if (strcmp ("alloc", p) == 0)
40208 : : behavior = OMP_CLAUSE_DEFAULTMAP_ALLOC;
40209 : : else
40210 : 0 : goto invalid_behavior;
40211 : : break;
40212 : :
40213 : 18 : case 'd':
40214 : 18 : if (strcmp ("default", p) == 0)
40215 : : behavior = OMP_CLAUSE_DEFAULTMAP_DEFAULT;
40216 : : else
40217 : 0 : goto invalid_behavior;
40218 : : break;
40219 : :
40220 : 69 : case 'f':
40221 : 69 : if (strcmp ("firstprivate", p) == 0)
40222 : : behavior = OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE;
40223 : 9 : else if (strcmp ("from", p) == 0)
40224 : : behavior = OMP_CLAUSE_DEFAULTMAP_FROM;
40225 : : else
40226 : 0 : goto invalid_behavior;
40227 : : break;
40228 : :
40229 : 286 : case 'n':
40230 : 286 : if (strcmp ("none", p) == 0)
40231 : : behavior = OMP_CLAUSE_DEFAULTMAP_NONE;
40232 : : else
40233 : 0 : goto invalid_behavior;
40234 : : break;
40235 : :
40236 : 8 : case 'p':
40237 : 8 : if (strcmp ("present", p) == 0)
40238 : : behavior = OMP_CLAUSE_DEFAULTMAP_PRESENT;
40239 : : else
40240 : 0 : goto invalid_behavior;
40241 : : break;
40242 : :
40243 : 232 : case 't':
40244 : 232 : if (strcmp ("tofrom", p) == 0)
40245 : : behavior = OMP_CLAUSE_DEFAULTMAP_TOFROM;
40246 : 12 : else if (strcmp ("to", p) == 0)
40247 : : behavior = OMP_CLAUSE_DEFAULTMAP_TO;
40248 : : else
40249 : 0 : goto invalid_behavior;
40250 : : break;
40251 : :
40252 : 3 : default:
40253 : 3 : goto invalid_behavior;
40254 : : }
40255 : 631 : cp_lexer_consume_token (parser->lexer);
40256 : :
40257 : 631 : if (!cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
40258 : : {
40259 : 331 : if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
40260 : 9 : goto out_err;
40261 : :
40262 : 322 : if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40263 : : {
40264 : 3 : invalid_category:
40265 : 6 : cp_parser_error (parser, "expected %<scalar%>, %<aggregate%>, "
40266 : : "%<all%>");
40267 : 6 : goto out_err;
40268 : : }
40269 : 319 : id = cp_lexer_peek_token (parser->lexer)->u.value;
40270 : 319 : p = IDENTIFIER_POINTER (id);
40271 : :
40272 : 319 : switch (p[0])
40273 : : {
40274 : 57 : case 'a':
40275 : 57 : if (strcmp ("aggregate", p) == 0)
40276 : : category = OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE;
40277 : 24 : else if (strcmp ("all", p) == 0)
40278 : : category = OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL;
40279 : : else
40280 : 0 : goto invalid_category;
40281 : : break;
40282 : :
40283 : 30 : case 'p':
40284 : 30 : if (strcmp ("pointer", p) == 0)
40285 : : category = OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER;
40286 : : else
40287 : 0 : goto invalid_category;
40288 : : break;
40289 : :
40290 : 229 : case 's':
40291 : 229 : if (strcmp ("scalar", p) == 0)
40292 : : category = OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR;
40293 : : else
40294 : 0 : goto invalid_category;
40295 : : break;
40296 : :
40297 : 3 : default:
40298 : 3 : goto invalid_category;
40299 : : }
40300 : :
40301 : 316 : cp_lexer_consume_token (parser->lexer);
40302 : : }
40303 : 616 : if (!parens.require_close (parser))
40304 : 0 : goto out_err;
40305 : :
40306 : 2046 : for (c = list; c ; c = OMP_CLAUSE_CHAIN (c))
40307 : 1469 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEFAULTMAP
40308 : 1469 : && (category == OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
40309 : : || category == OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL
40310 : 69 : || OMP_CLAUSE_DEFAULTMAP_CATEGORY (c) == category
40311 : 66 : || (OMP_CLAUSE_DEFAULTMAP_CATEGORY (c)
40312 : : == OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED)
40313 : 60 : || (OMP_CLAUSE_DEFAULTMAP_CATEGORY (c)
40314 : : == OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL)))
40315 : : {
40316 : 39 : enum omp_clause_defaultmap_kind cat = category;
40317 : 39 : location_t loc = OMP_CLAUSE_LOCATION (c);
40318 : 39 : if (cat == OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
40319 : 39 : || (cat == OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL
40320 : 9 : && (OMP_CLAUSE_DEFAULTMAP_CATEGORY (c)
40321 : : != OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED)))
40322 : 24 : cat = OMP_CLAUSE_DEFAULTMAP_CATEGORY (c);
40323 : 39 : p = NULL;
40324 : 39 : switch (cat)
40325 : : {
40326 : : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED:
40327 : : p = NULL;
40328 : : break;
40329 : 9 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL:
40330 : 9 : p = "all";
40331 : 9 : break;
40332 : 6 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE:
40333 : 6 : p = "aggregate";
40334 : 6 : break;
40335 : 9 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER:
40336 : 9 : p = "pointer";
40337 : 9 : break;
40338 : : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR:
40339 : : p = "scalar";
40340 : : break;
40341 : 0 : default:
40342 : 0 : gcc_unreachable ();
40343 : : }
40344 : 24 : if (p)
40345 : 30 : error_at (loc, "too many %<defaultmap%> clauses with %qs category",
40346 : : p);
40347 : : else
40348 : 9 : error_at (loc, "too many %<defaultmap%> clauses with unspecified "
40349 : : "category");
40350 : : break;
40351 : : }
40352 : :
40353 : 616 : c = build_omp_clause (location, OMP_CLAUSE_DEFAULTMAP);
40354 : 616 : OMP_CLAUSE_DEFAULTMAP_SET_KIND (c, behavior, category);
40355 : 616 : OMP_CLAUSE_CHAIN (c) = list;
40356 : 616 : return c;
40357 : :
40358 : 24 : out_err:
40359 : 24 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40360 : : /*or_comma=*/false,
40361 : : /*consume_paren=*/true);
40362 : 24 : return list;
40363 : : }
40364 : :
40365 : : /* OpenMP 5.0:
40366 : : order ( concurrent )
40367 : :
40368 : : OpenMP 5.1:
40369 : : order ( order-modifier : concurrent )
40370 : :
40371 : : order-modifier:
40372 : : reproducible
40373 : : unconstrained */
40374 : :
40375 : : static tree
40376 : 1106 : cp_parser_omp_clause_order (cp_parser *parser, tree list, location_t location)
40377 : : {
40378 : 1106 : tree c, id;
40379 : 1106 : const char *p;
40380 : 1106 : bool unconstrained = false;
40381 : 1106 : bool reproducible = false;
40382 : :
40383 : 1106 : matching_parens parens;
40384 : 1106 : if (!parens.require_open (parser))
40385 : : return list;
40386 : :
40387 : 1100 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
40388 : 1100 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
40389 : : {
40390 : 313 : id = cp_lexer_peek_token (parser->lexer)->u.value;
40391 : 313 : p = IDENTIFIER_POINTER (id);
40392 : 313 : if (strcmp (p, "unconstrained") == 0)
40393 : : unconstrained = true;
40394 : 160 : else if (strcmp (p, "reproducible") == 0)
40395 : : reproducible = true;
40396 : : else
40397 : : {
40398 : 3 : cp_parser_error (parser, "expected %<reproducible%> or "
40399 : : "%<unconstrained%>");
40400 : 3 : goto out_err;
40401 : : }
40402 : 310 : cp_lexer_consume_token (parser->lexer);
40403 : 310 : cp_lexer_consume_token (parser->lexer);
40404 : : }
40405 : 1097 : if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40406 : : {
40407 : 0 : cp_parser_error (parser, "expected %<concurrent%>");
40408 : 0 : goto out_err;
40409 : : }
40410 : : else
40411 : : {
40412 : 1097 : id = cp_lexer_peek_token (parser->lexer)->u.value;
40413 : 1097 : p = IDENTIFIER_POINTER (id);
40414 : : }
40415 : 1097 : if (strcmp (p, "concurrent") != 0)
40416 : : {
40417 : 3 : cp_parser_error (parser, "expected %<concurrent%>");
40418 : 3 : goto out_err;
40419 : : }
40420 : 1094 : cp_lexer_consume_token (parser->lexer);
40421 : 1094 : if (!parens.require_close (parser))
40422 : 3 : goto out_err;
40423 : :
40424 : 1091 : check_no_duplicate_clause (list, OMP_CLAUSE_ORDER, "order", location);
40425 : 1091 : c = build_omp_clause (location, OMP_CLAUSE_ORDER);
40426 : 1091 : OMP_CLAUSE_ORDER_UNCONSTRAINED (c) = unconstrained;
40427 : 1091 : OMP_CLAUSE_ORDER_REPRODUCIBLE (c) = reproducible;
40428 : 1091 : OMP_CLAUSE_CHAIN (c) = list;
40429 : 1091 : return c;
40430 : :
40431 : 9 : out_err:
40432 : 9 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40433 : : /*or_comma=*/false,
40434 : : /*consume_paren=*/true);
40435 : 9 : return list;
40436 : : }
40437 : :
40438 : : /* OpenMP 5.0:
40439 : : bind ( teams | parallel | thread ) */
40440 : :
40441 : : static tree
40442 : 355 : cp_parser_omp_clause_bind (cp_parser *parser, tree list,
40443 : : location_t location)
40444 : : {
40445 : 355 : tree c;
40446 : 355 : const char *p;
40447 : 355 : enum omp_clause_bind_kind kind = OMP_CLAUSE_BIND_THREAD;
40448 : :
40449 : 355 : matching_parens parens;
40450 : 355 : if (!parens.require_open (parser))
40451 : : return list;
40452 : :
40453 : 349 : if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40454 : : {
40455 : 9 : invalid:
40456 : 12 : cp_parser_error (parser,
40457 : : "expected %<teams%>, %<parallel%> or %<thread%>");
40458 : 12 : goto out_err;
40459 : : }
40460 : : else
40461 : : {
40462 : 340 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40463 : 340 : p = IDENTIFIER_POINTER (id);
40464 : : }
40465 : 340 : if (strcmp (p, "teams") == 0)
40466 : : kind = OMP_CLAUSE_BIND_TEAMS;
40467 : 232 : else if (strcmp (p, "parallel") == 0)
40468 : : kind = OMP_CLAUSE_BIND_PARALLEL;
40469 : 115 : else if (strcmp (p, "thread") != 0)
40470 : 3 : goto invalid;
40471 : 337 : cp_lexer_consume_token (parser->lexer);
40472 : 337 : if (!parens.require_close (parser))
40473 : 3 : goto out_err;
40474 : :
40475 : : /* check_no_duplicate_clause (list, OMP_CLAUSE_BIND, "bind", location); */
40476 : 334 : c = build_omp_clause (location, OMP_CLAUSE_BIND);
40477 : 334 : OMP_CLAUSE_BIND_KIND (c) = kind;
40478 : 334 : OMP_CLAUSE_CHAIN (c) = list;
40479 : 334 : return c;
40480 : :
40481 : 15 : out_err:
40482 : 15 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40483 : : /*or_comma=*/false,
40484 : : /*consume_paren=*/true);
40485 : 15 : return list;
40486 : : }
40487 : :
40488 : : /* OpenMP 2.5:
40489 : : ordered
40490 : :
40491 : : OpenMP 4.5:
40492 : : ordered ( constant-expression ) */
40493 : :
40494 : : static tree
40495 : 633 : cp_parser_omp_clause_ordered (cp_parser *parser,
40496 : : tree list, location_t location)
40497 : : {
40498 : 633 : tree c, num = NULL_TREE;
40499 : 633 : HOST_WIDE_INT n;
40500 : :
40501 : 633 : check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED,
40502 : : "ordered", location);
40503 : :
40504 : 633 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
40505 : : {
40506 : 350 : matching_parens parens;
40507 : 350 : parens.consume_open (parser);
40508 : :
40509 : 350 : num = cp_parser_constant_expression (parser);
40510 : :
40511 : 350 : if (!parens.require_close (parser))
40512 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40513 : : /*or_comma=*/false,
40514 : : /*consume_paren=*/true);
40515 : :
40516 : 350 : if (num == error_mark_node)
40517 : 3 : return list;
40518 : 350 : num = fold_non_dependent_expr (num);
40519 : 350 : if (!tree_fits_shwi_p (num)
40520 : 347 : || !INTEGRAL_TYPE_P (TREE_TYPE (num))
40521 : 347 : || (n = tree_to_shwi (num)) <= 0
40522 : 697 : || (int) n != n)
40523 : : {
40524 : 3 : error_at (location,
40525 : : "ordered argument needs positive constant integer "
40526 : : "expression");
40527 : 3 : return list;
40528 : : }
40529 : : }
40530 : :
40531 : 630 : c = build_omp_clause (location, OMP_CLAUSE_ORDERED);
40532 : 630 : OMP_CLAUSE_ORDERED_EXPR (c) = num;
40533 : 630 : OMP_CLAUSE_CHAIN (c) = list;
40534 : 630 : return c;
40535 : : }
40536 : :
40537 : : /* OpenMP 2.5:
40538 : : reduction ( reduction-operator : variable-list )
40539 : :
40540 : : reduction-operator:
40541 : : One of: + * - & ^ | && ||
40542 : :
40543 : : OpenMP 3.1:
40544 : :
40545 : : reduction-operator:
40546 : : One of: + * - & ^ | && || min max
40547 : :
40548 : : OpenMP 4.0:
40549 : :
40550 : : reduction-operator:
40551 : : One of: + * - & ^ | && ||
40552 : : id-expression
40553 : :
40554 : : OpenMP 5.0:
40555 : : reduction ( reduction-modifier, reduction-operator : variable-list )
40556 : : in_reduction ( reduction-operator : variable-list )
40557 : : task_reduction ( reduction-operator : variable-list ) */
40558 : :
40559 : : static tree
40560 : 5747 : cp_parser_omp_clause_reduction (cp_parser *parser, enum omp_clause_code kind,
40561 : : bool is_omp, tree list)
40562 : : {
40563 : 5747 : enum tree_code code = ERROR_MARK;
40564 : 5747 : tree nlist, c, id = NULL_TREE;
40565 : 5747 : bool task = false;
40566 : 5747 : bool inscan = false;
40567 : :
40568 : 5747 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
40569 : : return list;
40570 : :
40571 : 5747 : if (kind == OMP_CLAUSE_REDUCTION && is_omp)
40572 : : {
40573 : 3132 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT)
40574 : 3132 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA))
40575 : : {
40576 : 256 : cp_lexer_consume_token (parser->lexer);
40577 : 256 : cp_lexer_consume_token (parser->lexer);
40578 : : }
40579 : 2876 : else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
40580 : 2876 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA))
40581 : : {
40582 : 566 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40583 : 566 : const char *p = IDENTIFIER_POINTER (id);
40584 : 566 : if (strcmp (p, "task") == 0)
40585 : : task = true;
40586 : 360 : else if (strcmp (p, "inscan") == 0)
40587 : : inscan = true;
40588 : : if (task || inscan)
40589 : : {
40590 : 566 : cp_lexer_consume_token (parser->lexer);
40591 : 566 : cp_lexer_consume_token (parser->lexer);
40592 : : }
40593 : : }
40594 : : }
40595 : :
40596 : 5747 : switch (cp_lexer_peek_token (parser->lexer)->type)
40597 : : {
40598 : 4389 : case CPP_PLUS: code = PLUS_EXPR; break;
40599 : 389 : case CPP_MULT: code = MULT_EXPR; break;
40600 : 307 : case CPP_MINUS: code = MINUS_EXPR; break;
40601 : 41 : case CPP_AND: code = BIT_AND_EXPR; break;
40602 : 16 : case CPP_XOR: code = BIT_XOR_EXPR; break;
40603 : 49 : case CPP_OR: code = BIT_IOR_EXPR; break;
40604 : 70 : case CPP_AND_AND: code = TRUTH_ANDIF_EXPR; break;
40605 : : case CPP_OR_OR: code = TRUTH_ORIF_EXPR; break;
40606 : : default: break;
40607 : : }
40608 : :
40609 : 5261 : if (code != ERROR_MARK)
40610 : 5335 : cp_lexer_consume_token (parser->lexer);
40611 : : else
40612 : : {
40613 : 412 : bool saved_colon_corrects_to_scope_p;
40614 : 412 : saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
40615 : 412 : parser->colon_corrects_to_scope_p = false;
40616 : 412 : id = cp_parser_id_expression (parser, /*template_p=*/false,
40617 : : /*check_dependency_p=*/true,
40618 : : /*template_p=*/NULL,
40619 : : /*declarator_p=*/false,
40620 : : /*optional_p=*/false);
40621 : 412 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
40622 : 412 : if (identifier_p (id))
40623 : : {
40624 : 409 : const char *p = IDENTIFIER_POINTER (id);
40625 : :
40626 : 409 : if (strcmp (p, "min") == 0)
40627 : : code = MIN_EXPR;
40628 : 357 : else if (strcmp (p, "max") == 0)
40629 : : code = MAX_EXPR;
40630 : 269 : else if (id == ovl_op_identifier (false, PLUS_EXPR))
40631 : : code = PLUS_EXPR;
40632 : 241 : else if (id == ovl_op_identifier (false, MULT_EXPR))
40633 : : code = MULT_EXPR;
40634 : 241 : else if (id == ovl_op_identifier (false, MINUS_EXPR))
40635 : : code = MINUS_EXPR;
40636 : 235 : else if (id == ovl_op_identifier (false, BIT_AND_EXPR))
40637 : : code = BIT_AND_EXPR;
40638 : 235 : else if (id == ovl_op_identifier (false, BIT_IOR_EXPR))
40639 : : code = BIT_IOR_EXPR;
40640 : 235 : else if (id == ovl_op_identifier (false, BIT_XOR_EXPR))
40641 : : code = BIT_XOR_EXPR;
40642 : 235 : else if (id == ovl_op_identifier (false, TRUTH_ANDIF_EXPR))
40643 : : code = TRUTH_ANDIF_EXPR;
40644 : 235 : else if (id == ovl_op_identifier (false, TRUTH_ORIF_EXPR))
40645 : 0 : code = TRUTH_ORIF_EXPR;
40646 : 409 : id = omp_reduction_id (code, id, NULL_TREE);
40647 : 409 : tree scope = parser->scope;
40648 : 409 : if (scope)
40649 : 45 : id = build_qualified_name (NULL_TREE, scope, id, false);
40650 : 409 : parser->scope = NULL_TREE;
40651 : 409 : parser->qualifying_scope = NULL_TREE;
40652 : 409 : parser->object_scope = NULL_TREE;
40653 : : }
40654 : : else
40655 : : {
40656 : 3 : error ("invalid reduction-identifier");
40657 : 3 : resync_fail:
40658 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40659 : : /*or_comma=*/false,
40660 : : /*consume_paren=*/true);
40661 : 3 : return list;
40662 : : }
40663 : : }
40664 : :
40665 : 5744 : if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
40666 : 0 : goto resync_fail;
40667 : :
40668 : 5744 : nlist = cp_parser_omp_var_list_no_open (parser, kind, list,
40669 : : NULL);
40670 : 18411 : for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
40671 : : {
40672 : 6923 : OMP_CLAUSE_REDUCTION_CODE (c) = code;
40673 : 6923 : if (task)
40674 : 316 : OMP_CLAUSE_REDUCTION_TASK (c) = 1;
40675 : 6607 : else if (inscan)
40676 : 369 : OMP_CLAUSE_REDUCTION_INSCAN (c) = 1;
40677 : 6923 : OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = id;
40678 : : }
40679 : :
40680 : : return nlist;
40681 : : }
40682 : :
40683 : : /* OpenMP 2.5:
40684 : : schedule ( schedule-kind )
40685 : : schedule ( schedule-kind , expression )
40686 : :
40687 : : schedule-kind:
40688 : : static | dynamic | guided | runtime | auto
40689 : :
40690 : : OpenMP 4.5:
40691 : : schedule ( schedule-modifier : schedule-kind )
40692 : : schedule ( schedule-modifier [ , schedule-modifier ] : schedule-kind , expression )
40693 : :
40694 : : schedule-modifier:
40695 : : simd
40696 : : monotonic
40697 : : nonmonotonic */
40698 : :
40699 : : static tree
40700 : 3799 : cp_parser_omp_clause_schedule (cp_parser *parser, tree list, location_t location)
40701 : : {
40702 : 3799 : tree c, t;
40703 : 3799 : int modifiers = 0, nmodifiers = 0;
40704 : :
40705 : 3799 : matching_parens parens;
40706 : 3799 : if (!parens.require_open (parser))
40707 : : return list;
40708 : :
40709 : 3793 : c = build_omp_clause (location, OMP_CLAUSE_SCHEDULE);
40710 : :
40711 : 3793 : location_t comma = UNKNOWN_LOCATION;
40712 : 7624 : while (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40713 : : {
40714 : 1848 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40715 : 1848 : const char *p = IDENTIFIER_POINTER (id);
40716 : 1848 : if (strcmp ("simd", p) == 0)
40717 : 53 : OMP_CLAUSE_SCHEDULE_SIMD (c) = 1;
40718 : 1795 : else if (strcmp ("monotonic", p) == 0)
40719 : 97 : modifiers |= OMP_CLAUSE_SCHEDULE_MONOTONIC;
40720 : 1698 : else if (strcmp ("nonmonotonic", p) == 0)
40721 : 118 : modifiers |= OMP_CLAUSE_SCHEDULE_NONMONOTONIC;
40722 : : else
40723 : : break;
40724 : 268 : comma = UNKNOWN_LOCATION;
40725 : 268 : cp_lexer_consume_token (parser->lexer);
40726 : 268 : if (nmodifiers++ == 0
40727 : 268 : && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
40728 : : {
40729 : 38 : comma = cp_lexer_peek_token (parser->lexer)->location;
40730 : 38 : cp_lexer_consume_token (parser->lexer);
40731 : : }
40732 : : else
40733 : : {
40734 : 230 : cp_parser_require (parser, CPP_COLON, RT_COLON);
40735 : 230 : break;
40736 : : }
40737 : : }
40738 : 3793 : if (comma != UNKNOWN_LOCATION)
40739 : 9 : error_at (comma, "expected %<:%>");
40740 : :
40741 : 3793 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40742 : : {
40743 : 1732 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40744 : 1732 : const char *p = IDENTIFIER_POINTER (id);
40745 : :
40746 : 1732 : switch (p[0])
40747 : : {
40748 : 162 : case 'd':
40749 : 162 : if (strcmp ("dynamic", p) != 0)
40750 : 0 : goto invalid_kind;
40751 : 162 : OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
40752 : 162 : break;
40753 : :
40754 : 742 : case 'g':
40755 : 742 : if (strcmp ("guided", p) != 0)
40756 : 0 : goto invalid_kind;
40757 : 742 : OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
40758 : 742 : break;
40759 : :
40760 : 825 : case 'r':
40761 : 825 : if (strcmp ("runtime", p) != 0)
40762 : 0 : goto invalid_kind;
40763 : 825 : OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
40764 : 825 : break;
40765 : :
40766 : 3 : default:
40767 : 3 : goto invalid_kind;
40768 : : }
40769 : : }
40770 : 2061 : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
40771 : 1376 : OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
40772 : 685 : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
40773 : 682 : OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_AUTO;
40774 : : else
40775 : 3 : goto invalid_kind;
40776 : 3787 : cp_lexer_consume_token (parser->lexer);
40777 : :
40778 : 3787 : if ((modifiers & (OMP_CLAUSE_SCHEDULE_MONOTONIC
40779 : : | OMP_CLAUSE_SCHEDULE_NONMONOTONIC))
40780 : : == (OMP_CLAUSE_SCHEDULE_MONOTONIC
40781 : : | OMP_CLAUSE_SCHEDULE_NONMONOTONIC))
40782 : : {
40783 : 6 : error_at (location, "both %<monotonic%> and %<nonmonotonic%> modifiers "
40784 : : "specified");
40785 : 6 : modifiers = 0;
40786 : : }
40787 : :
40788 : 3787 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
40789 : : {
40790 : 2038 : cp_token *token;
40791 : 2038 : cp_lexer_consume_token (parser->lexer);
40792 : :
40793 : 2038 : token = cp_lexer_peek_token (parser->lexer);
40794 : 2038 : t = cp_parser_assignment_expression (parser);
40795 : :
40796 : 2038 : if (t == error_mark_node)
40797 : 0 : goto resync_fail;
40798 : 2038 : else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
40799 : 3 : error_at (token->location, "schedule %<runtime%> does not take "
40800 : : "a %<chunk_size%> parameter");
40801 : 2035 : else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_AUTO)
40802 : 0 : error_at (token->location, "schedule %<auto%> does not take "
40803 : : "a %<chunk_size%> parameter");
40804 : : else
40805 : 2035 : OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
40806 : :
40807 : 2038 : if (!parens.require_close (parser))
40808 : 6 : goto resync_fail;
40809 : : }
40810 : 1749 : else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
40811 : 9 : goto resync_fail;
40812 : :
40813 : 7544 : OMP_CLAUSE_SCHEDULE_KIND (c)
40814 : 7544 : = (enum omp_clause_schedule_kind)
40815 : 3772 : (OMP_CLAUSE_SCHEDULE_KIND (c) | modifiers);
40816 : :
40817 : 3772 : check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule", location);
40818 : 3772 : OMP_CLAUSE_CHAIN (c) = list;
40819 : 3772 : return c;
40820 : :
40821 : 6 : invalid_kind:
40822 : 6 : cp_parser_error (parser, "invalid schedule kind");
40823 : 21 : resync_fail:
40824 : 21 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40825 : : /*or_comma=*/false,
40826 : : /*consume_paren=*/true);
40827 : 21 : return list;
40828 : : }
40829 : :
40830 : : /* OpenMP 3.0:
40831 : : untied */
40832 : :
40833 : : static tree
40834 : 242 : cp_parser_omp_clause_untied (cp_parser * /*parser*/,
40835 : : tree list, location_t location)
40836 : : {
40837 : 242 : tree c;
40838 : :
40839 : 242 : check_no_duplicate_clause (list, OMP_CLAUSE_UNTIED, "untied", location);
40840 : :
40841 : 242 : c = build_omp_clause (location, OMP_CLAUSE_UNTIED);
40842 : 242 : OMP_CLAUSE_CHAIN (c) = list;
40843 : 242 : return c;
40844 : : }
40845 : :
40846 : : /* OpenMP 4.0:
40847 : : inbranch
40848 : : notinbranch */
40849 : :
40850 : : static tree
40851 : 575 : cp_parser_omp_clause_branch (cp_parser * /*parser*/, enum omp_clause_code code,
40852 : : tree list, location_t location)
40853 : : {
40854 : 575 : check_no_duplicate_clause (list, code, omp_clause_code_name[code], location);
40855 : 575 : tree c = build_omp_clause (location, code);
40856 : 575 : OMP_CLAUSE_CHAIN (c) = list;
40857 : 575 : return c;
40858 : : }
40859 : :
40860 : : /* OpenMP 4.0:
40861 : : parallel
40862 : : for
40863 : : sections
40864 : : taskgroup */
40865 : :
40866 : : static tree
40867 : 1087 : cp_parser_omp_clause_cancelkind (cp_parser * /*parser*/,
40868 : : enum omp_clause_code code,
40869 : : tree list, location_t location)
40870 : : {
40871 : 1087 : tree c = build_omp_clause (location, code);
40872 : 1087 : OMP_CLAUSE_CHAIN (c) = list;
40873 : 1087 : return c;
40874 : : }
40875 : :
40876 : : /* OpenMP 4.5:
40877 : : nogroup */
40878 : :
40879 : : static tree
40880 : 41 : cp_parser_omp_clause_nogroup (cp_parser * /*parser*/,
40881 : : tree list, location_t location)
40882 : : {
40883 : 41 : check_no_duplicate_clause (list, OMP_CLAUSE_NOGROUP, "nogroup", location);
40884 : 41 : tree c = build_omp_clause (location, OMP_CLAUSE_NOGROUP);
40885 : 41 : OMP_CLAUSE_CHAIN (c) = list;
40886 : 41 : return c;
40887 : : }
40888 : :
40889 : : /* OpenMP 4.5:
40890 : : simd
40891 : : threads */
40892 : :
40893 : : static tree
40894 : 299 : cp_parser_omp_clause_orderedkind (cp_parser * /*parser*/,
40895 : : enum omp_clause_code code,
40896 : : tree list, location_t location)
40897 : : {
40898 : 299 : check_no_duplicate_clause (list, code, omp_clause_code_name[code], location);
40899 : 299 : tree c = build_omp_clause (location, code);
40900 : 299 : OMP_CLAUSE_CHAIN (c) = list;
40901 : 299 : return c;
40902 : : }
40903 : :
40904 : : /* OpenMP 4.0:
40905 : : num_teams ( expression )
40906 : :
40907 : : OpenMP 5.1:
40908 : : num_teams ( expression : expression ) */
40909 : :
40910 : : static tree
40911 : 602 : cp_parser_omp_clause_num_teams (cp_parser *parser, tree list,
40912 : : location_t location)
40913 : : {
40914 : 602 : tree upper, lower = NULL_TREE, c;
40915 : :
40916 : 602 : matching_parens parens;
40917 : 602 : if (!parens.require_open (parser))
40918 : : return list;
40919 : :
40920 : 602 : bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
40921 : 602 : parser->colon_corrects_to_scope_p = false;
40922 : 602 : upper = cp_parser_assignment_expression (parser);
40923 : 602 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
40924 : :
40925 : 602 : if (upper != error_mark_node
40926 : 602 : && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
40927 : : {
40928 : 213 : lower = upper;
40929 : 213 : cp_lexer_consume_token (parser->lexer);
40930 : 213 : upper = cp_parser_assignment_expression (parser);
40931 : : }
40932 : :
40933 : 602 : if (upper == error_mark_node
40934 : 1204 : || !parens.require_close (parser))
40935 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40936 : : /*or_comma=*/false,
40937 : : /*consume_paren=*/true);
40938 : :
40939 : 602 : check_no_duplicate_clause (list, OMP_CLAUSE_NUM_TEAMS,
40940 : : "num_teams", location);
40941 : :
40942 : 602 : c = build_omp_clause (location, OMP_CLAUSE_NUM_TEAMS);
40943 : 602 : OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR (c) = upper;
40944 : 602 : OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (c) = lower;
40945 : 602 : OMP_CLAUSE_CHAIN (c) = list;
40946 : :
40947 : 602 : return c;
40948 : : }
40949 : :
40950 : : /* OpenMP 4.0:
40951 : : thread_limit ( expression ) */
40952 : :
40953 : : static tree
40954 : 412 : cp_parser_omp_clause_thread_limit (cp_parser *parser, tree list,
40955 : : location_t location)
40956 : : {
40957 : 412 : tree t, c;
40958 : :
40959 : 412 : matching_parens parens;
40960 : 412 : if (!parens.require_open (parser))
40961 : : return list;
40962 : :
40963 : 412 : t = cp_parser_assignment_expression (parser);
40964 : :
40965 : 412 : if (t == error_mark_node
40966 : 824 : || !parens.require_close (parser))
40967 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
40968 : : /*or_comma=*/false,
40969 : : /*consume_paren=*/true);
40970 : :
40971 : 412 : check_no_duplicate_clause (list, OMP_CLAUSE_THREAD_LIMIT,
40972 : : "thread_limit", location);
40973 : :
40974 : 412 : c = build_omp_clause (location, OMP_CLAUSE_THREAD_LIMIT);
40975 : 412 : OMP_CLAUSE_THREAD_LIMIT_EXPR (c) = t;
40976 : 412 : OMP_CLAUSE_CHAIN (c) = list;
40977 : :
40978 : 412 : return c;
40979 : : }
40980 : :
40981 : : /* OpenMP 5.1
40982 : : full */
40983 : :
40984 : : static tree
40985 : 195 : cp_parser_omp_clause_full (tree list, location_t loc)
40986 : : {
40987 : 195 : check_no_duplicate_clause (list, OMP_CLAUSE_FULL, "full", loc);
40988 : :
40989 : 195 : tree c = build_omp_clause (loc, OMP_CLAUSE_FULL);
40990 : 195 : OMP_CLAUSE_CHAIN (c) = list;
40991 : 195 : return c;
40992 : : }
40993 : :
40994 : : /* OpenMP 5.1
40995 : : partial ( constant-expression ) */
40996 : :
40997 : : static tree
40998 : 458 : cp_parser_omp_clause_partial (cp_parser *parser, tree list, location_t loc)
40999 : : {
41000 : 458 : tree num = NULL_TREE;
41001 : 458 : check_no_duplicate_clause (list, OMP_CLAUSE_PARTIAL, "partial", loc);
41002 : :
41003 : 458 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
41004 : : {
41005 : 301 : matching_parens parens;
41006 : 301 : parens.consume_open (parser);
41007 : 301 : num = cp_parser_constant_expression (parser);
41008 : 301 : if (num == error_mark_node
41009 : 596 : || !parens.require_close (parser))
41010 : 6 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41011 : : /*or_comma=*/false,
41012 : : /*consume_paren=*/true);
41013 : 301 : if (num == error_mark_node)
41014 : 6 : return list;
41015 : : }
41016 : :
41017 : 452 : tree c = build_omp_clause (loc, OMP_CLAUSE_PARTIAL);
41018 : 452 : OMP_CLAUSE_PARTIAL_EXPR (c) = num;
41019 : 452 : OMP_CLAUSE_CHAIN (c) = list;
41020 : 452 : return c;
41021 : : }
41022 : :
41023 : : /* OpenMP 5.1
41024 : : novariants ( scalar-expression ) */
41025 : :
41026 : : static tree
41027 : 59 : cp_parser_omp_clause_novariants (cp_parser *parser, tree list, location_t loc)
41028 : : {
41029 : 59 : matching_parens parens;
41030 : 59 : if (!parens.require_open (parser))
41031 : : return list;
41032 : :
41033 : 59 : tree t = cp_parser_assignment_expression (parser);
41034 : 118 : if (t == error_mark_node || !parens.require_close (parser))
41035 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41036 : : /*or_comma=*/false,
41037 : : /*consume_paren=*/true);
41038 : :
41039 : 59 : check_no_duplicate_clause (list, OMP_CLAUSE_NOVARIANTS, "novariants", loc);
41040 : :
41041 : 59 : tree c = build_omp_clause (loc, OMP_CLAUSE_NOVARIANTS);
41042 : 59 : OMP_CLAUSE_NOVARIANTS_EXPR (c) = t;
41043 : 59 : OMP_CLAUSE_CHAIN (c) = list;
41044 : :
41045 : 59 : return c;
41046 : : }
41047 : :
41048 : : /* OpenMP 5.1
41049 : : nocontext ( scalar-expression ) */
41050 : :
41051 : : static tree
41052 : 68 : cp_parser_omp_clause_nocontext (cp_parser *parser, tree list, location_t loc)
41053 : : {
41054 : 68 : matching_parens parens;
41055 : 68 : if (!parens.require_open (parser))
41056 : : return list;
41057 : :
41058 : 68 : tree t = cp_parser_assignment_expression (parser);
41059 : 136 : if (t == error_mark_node || !parens.require_close (parser))
41060 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41061 : : /*or_comma=*/false,
41062 : : /*consume_paren=*/true);
41063 : :
41064 : 68 : check_no_duplicate_clause (list, OMP_CLAUSE_NOCONTEXT, "nocontext", loc);
41065 : :
41066 : 68 : tree c = build_omp_clause (loc, OMP_CLAUSE_NOCONTEXT);
41067 : 68 : OMP_CLAUSE_NOCONTEXT_EXPR (c) = t;
41068 : 68 : OMP_CLAUSE_CHAIN (c) = list;
41069 : :
41070 : 68 : return c;
41071 : : }
41072 : :
41073 : : /* OpenMP 4.0:
41074 : : aligned ( variable-list )
41075 : : aligned ( variable-list : constant-expression ) */
41076 : :
41077 : : static tree
41078 : 702 : cp_parser_omp_clause_aligned (cp_parser *parser, tree list)
41079 : : {
41080 : 702 : tree nlist, c, alignment = NULL_TREE;
41081 : 702 : bool colon;
41082 : :
41083 : 702 : matching_parens parens;
41084 : 702 : if (!parens.require_open (parser))
41085 : : return list;
41086 : :
41087 : 702 : nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_ALIGNED, list,
41088 : : &colon);
41089 : :
41090 : 702 : if (colon)
41091 : : {
41092 : 663 : alignment = cp_parser_constant_expression (parser);
41093 : :
41094 : 663 : if (!parens.require_close (parser))
41095 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41096 : : /*or_comma=*/false,
41097 : : /*consume_paren=*/true);
41098 : :
41099 : 663 : if (alignment == error_mark_node)
41100 : 39 : alignment = NULL_TREE;
41101 : : }
41102 : :
41103 : 1452 : for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
41104 : 750 : OMP_CLAUSE_ALIGNED_ALIGNMENT (c) = alignment;
41105 : :
41106 : : return nlist;
41107 : : }
41108 : :
41109 : : /* OpenMP 5.0:
41110 : : allocate ( variable-list )
41111 : : allocate ( expression : variable-list )
41112 : :
41113 : : OpenMP 5.1:
41114 : : allocate ( allocator-modifier : variable-list )
41115 : : allocate ( allocator-modifier , allocator-modifier : variable-list )
41116 : :
41117 : : allocator-modifier:
41118 : : allocator ( expression )
41119 : : align ( expression ) */
41120 : :
41121 : : static tree
41122 : 1461 : cp_parser_omp_clause_allocate (cp_parser *parser, tree list)
41123 : : {
41124 : 1461 : tree nlist, c, allocator = NULL_TREE, align = NULL_TREE;
41125 : 1461 : bool colon, has_modifiers = false;
41126 : :
41127 : 1461 : matching_parens parens;
41128 : 1461 : if (!parens.require_open (parser))
41129 : : return list;
41130 : :
41131 : 1461 : cp_parser_parse_tentatively (parser);
41132 : 1461 : bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
41133 : 1461 : parser->colon_corrects_to_scope_p = false;
41134 : 1526 : for (int mod = 0; mod < 2; mod++)
41135 : 1526 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
41136 : 1526 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
41137 : : {
41138 : 204 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
41139 : 204 : const char *p = IDENTIFIER_POINTER (id);
41140 : 204 : if (strcmp (p, "allocator") != 0 && strcmp (p, "align") != 0)
41141 : : break;
41142 : 198 : cp_lexer_consume_token (parser->lexer);
41143 : 198 : matching_parens parens2;
41144 : 198 : if (!parens2.require_open (parser))
41145 : : break;
41146 : 198 : if (strcmp (p, "allocator") == 0)
41147 : : {
41148 : 104 : if (allocator != NULL_TREE)
41149 : : break;
41150 : 101 : allocator = cp_parser_assignment_expression (parser);
41151 : : }
41152 : : else
41153 : : {
41154 : 94 : if (align != NULL_TREE)
41155 : : break;
41156 : 91 : align = cp_parser_assignment_expression (parser);
41157 : : }
41158 : 192 : if (!parens2.require_close (parser))
41159 : : break;
41160 : 192 : if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
41161 : : {
41162 : : has_modifiers = true;
41163 : : break;
41164 : : }
41165 : 65 : if (mod != 0 || cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
41166 : : break;
41167 : 65 : cp_lexer_consume_token (parser->lexer);
41168 : : }
41169 : : else
41170 : : break;
41171 : 1461 : if (!has_modifiers)
41172 : : {
41173 : 1334 : cp_parser_abort_tentative_parse (parser);
41174 : 1334 : align = NULL_TREE;
41175 : 1334 : allocator = NULL_TREE;
41176 : 1334 : cp_parser_parse_tentatively (parser);
41177 : 1334 : allocator = cp_parser_assignment_expression (parser);
41178 : : }
41179 : 1461 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
41180 : 1461 : if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
41181 : : {
41182 : 524 : cp_parser_parse_definitely (parser);
41183 : 524 : cp_lexer_consume_token (parser->lexer);
41184 : 524 : if (allocator == error_mark_node)
41185 : 3 : allocator = NULL_TREE;
41186 : 524 : if (align == error_mark_node)
41187 : 0 : align = NULL_TREE;
41188 : : }
41189 : : else
41190 : : {
41191 : 937 : cp_parser_abort_tentative_parse (parser);
41192 : 937 : allocator = NULL_TREE;
41193 : 937 : align = NULL_TREE;
41194 : : }
41195 : :
41196 : 1461 : nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_ALLOCATE, list,
41197 : : &colon);
41198 : :
41199 : 1461 : if (allocator || align)
41200 : 1180 : for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
41201 : : {
41202 : 659 : OMP_CLAUSE_ALLOCATE_ALLOCATOR (c) = allocator;
41203 : 659 : OMP_CLAUSE_ALLOCATE_ALIGN (c) = align;
41204 : : }
41205 : :
41206 : : return nlist;
41207 : : }
41208 : :
41209 : : /* OpenMP 2.5:
41210 : : lastprivate ( variable-list )
41211 : :
41212 : : OpenMP 5.0:
41213 : : lastprivate ( [ lastprivate-modifier : ] variable-list ) */
41214 : :
41215 : : static tree
41216 : 1487 : cp_parser_omp_clause_lastprivate (cp_parser *parser, tree list)
41217 : : {
41218 : 1487 : bool conditional = false;
41219 : :
41220 : 1487 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
41221 : : return list;
41222 : :
41223 : 1487 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
41224 : 1487 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
41225 : : {
41226 : 148 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
41227 : 148 : const char *p = IDENTIFIER_POINTER (id);
41228 : :
41229 : 148 : if (strcmp ("conditional", p) == 0)
41230 : : {
41231 : 148 : conditional = true;
41232 : 148 : cp_lexer_consume_token (parser->lexer);
41233 : 148 : cp_lexer_consume_token (parser->lexer);
41234 : : }
41235 : : }
41236 : :
41237 : 1487 : tree nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_LASTPRIVATE,
41238 : : list, NULL);
41239 : :
41240 : 1487 : if (conditional)
41241 : 337 : for (tree c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
41242 : 189 : OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c) = 1;
41243 : : return nlist;
41244 : : }
41245 : :
41246 : : /* OpenMP 4.0:
41247 : : linear ( variable-list )
41248 : : linear ( variable-list : expression )
41249 : :
41250 : : OpenMP 4.5:
41251 : : linear ( modifier ( variable-list ) )
41252 : : linear ( modifier ( variable-list ) : expression )
41253 : :
41254 : : modifier:
41255 : : val
41256 : : ref
41257 : : uval
41258 : :
41259 : : OpenMP 5.2:
41260 : : linear ( variable-list : modifiers-list )
41261 : :
41262 : : modifiers:
41263 : : val
41264 : : ref
41265 : : uval
41266 : : step ( expression ) */
41267 : :
41268 : : static tree
41269 : 1473 : cp_parser_omp_clause_linear (cp_parser *parser, tree list,
41270 : : bool declare_simd)
41271 : : {
41272 : 1473 : tree nlist, c, step = integer_one_node;
41273 : 1473 : bool colon;
41274 : 1473 : enum omp_clause_linear_kind kind = OMP_CLAUSE_LINEAR_DEFAULT;
41275 : 1473 : bool old_linear_modifier = false;
41276 : :
41277 : 1473 : matching_parens parens;
41278 : 1473 : if (!parens.require_open (parser))
41279 : : return list;
41280 : :
41281 : 1473 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41282 : : {
41283 : 1431 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
41284 : 1431 : const char *p = IDENTIFIER_POINTER (id);
41285 : :
41286 : 1431 : if (strcmp ("ref", p) == 0)
41287 : : kind = OMP_CLAUSE_LINEAR_REF;
41288 : 1359 : else if (strcmp ("val", p) == 0)
41289 : : kind = OMP_CLAUSE_LINEAR_VAL;
41290 : 1284 : else if (strcmp ("uval", p) == 0)
41291 : 63 : kind = OMP_CLAUSE_LINEAR_UVAL;
41292 : 1431 : if (cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
41293 : : {
41294 : 210 : cp_lexer_consume_token (parser->lexer);
41295 : 210 : old_linear_modifier = true;
41296 : : }
41297 : : else
41298 : : kind = OMP_CLAUSE_LINEAR_DEFAULT;
41299 : : }
41300 : :
41301 : 210 : if (kind == OMP_CLAUSE_LINEAR_DEFAULT)
41302 : 1263 : nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_LINEAR, list,
41303 : : &colon);
41304 : : else
41305 : : {
41306 : 210 : nlist = cp_parser_omp_var_list (parser, OMP_CLAUSE_LINEAR, list);
41307 : 210 : colon = cp_lexer_next_token_is (parser->lexer, CPP_COLON);
41308 : 210 : if (colon)
41309 : 180 : cp_parser_require (parser, CPP_COLON, RT_COLON);
41310 : 30 : else if (!parens.require_close (parser))
41311 : 0 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41312 : : /*or_comma=*/false,
41313 : : /*consume_paren=*/true);
41314 : : }
41315 : :
41316 : 1473 : if (colon)
41317 : : {
41318 : 1090 : bool has_modifiers = false;
41319 : 1090 : if (kind == OMP_CLAUSE_LINEAR_DEFAULT
41320 : 1090 : && cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41321 : : {
41322 : 209 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
41323 : 209 : const char *p = IDENTIFIER_POINTER (id);
41324 : 209 : size_t pos = 0;
41325 : 209 : if (strcmp ("ref", p) == 0
41326 : 194 : || strcmp ("val", p) == 0
41327 : 167 : || strcmp ("uval", p) == 0)
41328 : : pos = 2;
41329 : 155 : else if (strcmp ("step", p) == 0
41330 : 155 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
41331 : : {
41332 : 69 : pos = cp_parser_skip_balanced_tokens (parser, 2);
41333 : 69 : if (pos == 2)
41334 : : pos = 0;
41335 : : }
41336 : 69 : if (pos != 0
41337 : 123 : && (cp_lexer_nth_token_is (parser->lexer, pos, CPP_COMMA)
41338 : 60 : || cp_lexer_nth_token_is (parser->lexer, pos,
41339 : : CPP_CLOSE_PAREN)))
41340 : : has_modifiers = true;
41341 : : }
41342 : :
41343 : 985 : step = NULL_TREE;
41344 : : if (has_modifiers)
41345 : : {
41346 : 168 : while (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41347 : : {
41348 : 168 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
41349 : 168 : const char *p = IDENTIFIER_POINTER (id);
41350 : 168 : enum omp_clause_linear_kind nkind = OMP_CLAUSE_LINEAR_DEFAULT;
41351 : 168 : if (strcmp ("ref", p) == 0)
41352 : : nkind = OMP_CLAUSE_LINEAR_REF;
41353 : 150 : else if (strcmp ("val", p) == 0)
41354 : : nkind = OMP_CLAUSE_LINEAR_VAL;
41355 : 114 : else if (strcmp ("uval", p) == 0)
41356 : : nkind = OMP_CLAUSE_LINEAR_UVAL;
41357 : 96 : if (nkind != OMP_CLAUSE_LINEAR_DEFAULT)
41358 : : {
41359 : 72 : if (kind != OMP_CLAUSE_LINEAR_DEFAULT)
41360 : 0 : error_at (cp_lexer_peek_token (parser->lexer)->location,
41361 : : "multiple linear modifiers");
41362 : 72 : kind = nkind;
41363 : 72 : cp_lexer_consume_token (parser->lexer);
41364 : : }
41365 : 96 : else if (strcmp ("step", p) == 0)
41366 : : {
41367 : 96 : location_t step_loc
41368 : 96 : = cp_lexer_peek_token (parser->lexer)->location;
41369 : 96 : cp_lexer_consume_token (parser->lexer);
41370 : 96 : matching_parens parens2;
41371 : 96 : if (parens2.require_open (parser))
41372 : : {
41373 : 96 : if (step)
41374 : 0 : error_at (step_loc, "multiple %<step%> modifiers");
41375 : 96 : if (declare_simd
41376 : 24 : && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
41377 : 102 : && cp_lexer_nth_token_is (parser->lexer, 2,
41378 : : CPP_CLOSE_PAREN))
41379 : : {
41380 : 6 : cp_token *token
41381 : 6 : = cp_lexer_peek_token (parser->lexer);
41382 : 6 : location_t tok_loc = token->location;
41383 : 6 : cp_parser_parse_tentatively (parser);
41384 : 6 : step = cp_parser_id_expression (parser, false, true,
41385 : : NULL, false, false);
41386 : 6 : if (step != error_mark_node)
41387 : 6 : step = cp_parser_lookup_name_simple (parser, step,
41388 : : tok_loc);
41389 : 6 : if (step == error_mark_node)
41390 : : {
41391 : 0 : step = NULL_TREE;
41392 : 0 : cp_parser_abort_tentative_parse (parser);
41393 : : }
41394 : 6 : else if (!cp_parser_parse_definitely (parser))
41395 : : step = NULL_TREE;
41396 : : }
41397 : 96 : if (!step)
41398 : 90 : step = cp_parser_assignment_expression (parser);
41399 : 96 : if (!parens2.require_close (parser))
41400 : 3 : cp_parser_skip_to_closing_parenthesis (parser, true,
41401 : : false, true);
41402 : : }
41403 : : else
41404 : : break;
41405 : : }
41406 : : else
41407 : : break;
41408 : 168 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
41409 : : {
41410 : 63 : cp_lexer_consume_token (parser->lexer);
41411 : 63 : continue;
41412 : : }
41413 : : break;
41414 : : }
41415 : 105 : if (!step)
41416 : 9 : step = integer_one_node;
41417 : : }
41418 : 985 : else if (declare_simd
41419 : 391 : && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
41420 : 1075 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_CLOSE_PAREN))
41421 : : {
41422 : 75 : cp_token *token = cp_lexer_peek_token (parser->lexer);
41423 : 75 : cp_parser_parse_tentatively (parser);
41424 : 75 : step = cp_parser_id_expression (parser, /*template_p=*/false,
41425 : : /*check_dependency_p=*/true,
41426 : : /*template_p=*/NULL,
41427 : : /*declarator_p=*/false,
41428 : : /*optional_p=*/false);
41429 : 75 : if (step != error_mark_node)
41430 : 75 : step = cp_parser_lookup_name_simple (parser, step, token->location);
41431 : 75 : if (step == error_mark_node)
41432 : : {
41433 : 0 : step = NULL_TREE;
41434 : 0 : cp_parser_abort_tentative_parse (parser);
41435 : : }
41436 : 75 : else if (!cp_parser_parse_definitely (parser))
41437 : : step = NULL_TREE;
41438 : : }
41439 : 84 : if (!step)
41440 : 910 : step = cp_parser_assignment_expression (parser);
41441 : :
41442 : 1090 : if (!parens.require_close (parser))
41443 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41444 : : /*or_comma=*/false,
41445 : : /*consume_paren=*/true);
41446 : :
41447 : 1090 : if (step == error_mark_node)
41448 : : return list;
41449 : : }
41450 : :
41451 : 2967 : for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
41452 : : {
41453 : 1506 : OMP_CLAUSE_LINEAR_STEP (c) = step;
41454 : 1506 : OMP_CLAUSE_LINEAR_KIND (c) = kind;
41455 : 1506 : OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (c) = old_linear_modifier;
41456 : : }
41457 : :
41458 : : return nlist;
41459 : : }
41460 : :
41461 : : /* OpenMP 4.0:
41462 : : safelen ( constant-expression ) */
41463 : :
41464 : : static tree
41465 : 467 : cp_parser_omp_clause_safelen (cp_parser *parser, tree list,
41466 : : location_t location)
41467 : : {
41468 : 467 : tree t, c;
41469 : :
41470 : 467 : matching_parens parens;
41471 : 467 : if (!parens.require_open (parser))
41472 : : return list;
41473 : :
41474 : 467 : t = cp_parser_constant_expression (parser);
41475 : :
41476 : 467 : if (t == error_mark_node
41477 : 934 : || !parens.require_close (parser))
41478 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41479 : : /*or_comma=*/false,
41480 : : /*consume_paren=*/true);
41481 : :
41482 : 467 : check_no_duplicate_clause (list, OMP_CLAUSE_SAFELEN, "safelen", location);
41483 : :
41484 : 467 : c = build_omp_clause (location, OMP_CLAUSE_SAFELEN);
41485 : 467 : OMP_CLAUSE_SAFELEN_EXPR (c) = t;
41486 : 467 : OMP_CLAUSE_CHAIN (c) = list;
41487 : :
41488 : 467 : return c;
41489 : : }
41490 : :
41491 : : /* OpenMP 4.0:
41492 : : simdlen ( constant-expression ) */
41493 : :
41494 : : static tree
41495 : 758 : cp_parser_omp_clause_simdlen (cp_parser *parser, tree list,
41496 : : location_t location)
41497 : : {
41498 : 758 : tree t, c;
41499 : :
41500 : 758 : matching_parens parens;
41501 : 758 : if (!parens.require_open (parser))
41502 : : return list;
41503 : :
41504 : 758 : t = cp_parser_constant_expression (parser);
41505 : :
41506 : 758 : if (t == error_mark_node
41507 : 1516 : || !parens.require_close (parser))
41508 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41509 : : /*or_comma=*/false,
41510 : : /*consume_paren=*/true);
41511 : :
41512 : 758 : check_no_duplicate_clause (list, OMP_CLAUSE_SIMDLEN, "simdlen", location);
41513 : :
41514 : 758 : c = build_omp_clause (location, OMP_CLAUSE_SIMDLEN);
41515 : 758 : OMP_CLAUSE_SIMDLEN_EXPR (c) = t;
41516 : 758 : OMP_CLAUSE_CHAIN (c) = list;
41517 : :
41518 : 758 : return c;
41519 : : }
41520 : :
41521 : : /* OpenMP 4.5:
41522 : : vec:
41523 : : identifier [+/- integer]
41524 : : vec , identifier [+/- integer]
41525 : : */
41526 : :
41527 : : static tree
41528 : 331 : cp_parser_omp_clause_doacross_sink (cp_parser *parser, location_t clause_loc,
41529 : : tree list, bool depend_p)
41530 : : {
41531 : 331 : tree vec = NULL;
41532 : :
41533 : 331 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
41534 : : {
41535 : 0 : cp_parser_error (parser, "expected identifier");
41536 : 0 : return list;
41537 : : }
41538 : :
41539 : 331 : if (!depend_p)
41540 : : {
41541 : 114 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
41542 : 114 : if (strcmp (IDENTIFIER_POINTER (id), "omp_cur_iteration") == 0
41543 : 48 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_MINUS)
41544 : 42 : && cp_lexer_nth_token_is (parser->lexer, 3, CPP_NUMBER)
41545 : 153 : && cp_lexer_nth_token_is (parser->lexer, 4, CPP_CLOSE_PAREN))
41546 : : {
41547 : 39 : tree val = cp_lexer_peek_nth_token (parser->lexer, 3)->u.value;
41548 : 39 : if (integer_onep (val))
41549 : : {
41550 : 39 : cp_lexer_consume_token (parser->lexer);
41551 : 39 : cp_lexer_consume_token (parser->lexer);
41552 : 39 : cp_lexer_consume_token (parser->lexer);
41553 : 39 : tree u = build_omp_clause (clause_loc, OMP_CLAUSE_DOACROSS);
41554 : 39 : OMP_CLAUSE_DOACROSS_KIND (u) = OMP_CLAUSE_DOACROSS_SINK;
41555 : 39 : OMP_CLAUSE_CHAIN (u) = list;
41556 : 39 : return u;
41557 : : }
41558 : : }
41559 : : }
41560 : :
41561 : 406 : while (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41562 : : {
41563 : 406 : location_t id_loc = cp_lexer_peek_token (parser->lexer)->location;
41564 : 406 : tree t, identifier = cp_parser_identifier (parser);
41565 : 406 : tree addend = NULL;
41566 : :
41567 : 406 : if (identifier == error_mark_node)
41568 : : t = error_mark_node;
41569 : : else
41570 : : {
41571 : 406 : t = cp_parser_lookup_name_simple
41572 : 812 : (parser, identifier,
41573 : 406 : cp_lexer_peek_token (parser->lexer)->location);
41574 : 406 : if (t == error_mark_node)
41575 : 18 : cp_parser_name_lookup_error (parser, identifier, t, NLE_NULL,
41576 : : id_loc);
41577 : : }
41578 : :
41579 : 406 : bool neg = false;
41580 : 406 : if (cp_lexer_next_token_is (parser->lexer, CPP_MINUS))
41581 : : neg = true;
41582 : 94 : else if (!cp_lexer_next_token_is (parser->lexer, CPP_PLUS))
41583 : : {
41584 : 33 : addend = integer_zero_node;
41585 : 33 : goto add_to_vector;
41586 : : }
41587 : 373 : cp_lexer_consume_token (parser->lexer);
41588 : :
41589 : 373 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_NUMBER))
41590 : : {
41591 : 3 : cp_parser_error (parser, "expected integer");
41592 : 3 : return list;
41593 : : }
41594 : :
41595 : 370 : addend = cp_lexer_peek_token (parser->lexer)->u.value;
41596 : 370 : if (TREE_CODE (addend) != INTEGER_CST)
41597 : : {
41598 : 0 : cp_parser_error (parser, "expected integer");
41599 : 0 : return list;
41600 : : }
41601 : 370 : cp_lexer_consume_token (parser->lexer);
41602 : :
41603 : 403 : add_to_vector:
41604 : 403 : if (t != error_mark_node)
41605 : : {
41606 : 388 : vec = tree_cons (addend, t, vec);
41607 : 388 : if (neg)
41608 : 303 : OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (vec) = 1;
41609 : : }
41610 : :
41611 : 403 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
41612 : 403 : || !cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
41613 : : break;
41614 : :
41615 : 114 : cp_lexer_consume_token (parser->lexer);
41616 : : }
41617 : :
41618 : 289 : if (vec)
41619 : : {
41620 : 277 : tree u = build_omp_clause (clause_loc, OMP_CLAUSE_DOACROSS);
41621 : 277 : OMP_CLAUSE_DOACROSS_KIND (u) = OMP_CLAUSE_DOACROSS_SINK;
41622 : 277 : OMP_CLAUSE_DOACROSS_DEPEND (u) = depend_p;
41623 : 277 : OMP_CLAUSE_DECL (u) = nreverse (vec);
41624 : 277 : OMP_CLAUSE_CHAIN (u) = list;
41625 : 277 : return u;
41626 : : }
41627 : : return list;
41628 : : }
41629 : :
41630 : : /* OpenMP 5.0:
41631 : : detach ( event-handle ) */
41632 : :
41633 : : static tree
41634 : 63 : cp_parser_omp_clause_detach (cp_parser *parser, tree list)
41635 : : {
41636 : 63 : matching_parens parens;
41637 : :
41638 : 63 : if (!parens.require_open (parser))
41639 : : return list;
41640 : :
41641 : 63 : cp_token *token;
41642 : 63 : tree name, decl;
41643 : :
41644 : 63 : token = cp_lexer_peek_token (parser->lexer);
41645 : 63 : name = cp_parser_id_expression (parser, /*template_p=*/false,
41646 : : /*check_dependency_p=*/true,
41647 : : /*template_p=*/NULL,
41648 : : /*declarator_p=*/false,
41649 : : /*optional_p=*/false);
41650 : 63 : if (name == error_mark_node)
41651 : : decl = error_mark_node;
41652 : : else
41653 : : {
41654 : 60 : if (identifier_p (name))
41655 : 60 : decl = cp_parser_lookup_name_simple (parser, name, token->location);
41656 : : else
41657 : : decl = name;
41658 : 60 : if (decl == error_mark_node)
41659 : 0 : cp_parser_name_lookup_error (parser, name, decl, NLE_NULL,
41660 : : token->location);
41661 : : }
41662 : :
41663 : 63 : if (decl == error_mark_node
41664 : 123 : || !parens.require_close (parser))
41665 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41666 : : /*or_comma=*/false,
41667 : : /*consume_paren=*/true);
41668 : :
41669 : 63 : tree u = build_omp_clause (token->location, OMP_CLAUSE_DETACH);
41670 : 63 : OMP_CLAUSE_DECL (u) = decl;
41671 : 63 : OMP_CLAUSE_CHAIN (u) = list;
41672 : :
41673 : 63 : return u;
41674 : : }
41675 : :
41676 : : /* OpenMP 5.0:
41677 : : iterators ( iterators-definition )
41678 : :
41679 : : iterators-definition:
41680 : : iterator-specifier
41681 : : iterator-specifier , iterators-definition
41682 : :
41683 : : iterator-specifier:
41684 : : identifier = range-specification
41685 : : iterator-type identifier = range-specification
41686 : :
41687 : : range-specification:
41688 : : begin : end
41689 : : begin : end : step */
41690 : :
41691 : : static tree
41692 : 474 : cp_parser_omp_iterators (cp_parser *parser)
41693 : : {
41694 : 474 : tree ret = NULL_TREE, *last = &ret;
41695 : 474 : cp_lexer_consume_token (parser->lexer);
41696 : :
41697 : 474 : matching_parens parens;
41698 : 474 : if (!parens.require_open (parser))
41699 : 6 : return error_mark_node;
41700 : :
41701 : 468 : bool saved_colon_corrects_to_scope_p
41702 : : = parser->colon_corrects_to_scope_p;
41703 : 468 : bool saved_colon_doesnt_start_class_def_p
41704 : : = parser->colon_doesnt_start_class_def_p;
41705 : :
41706 : 678 : do
41707 : : {
41708 : 573 : tree iter_type;
41709 : 573 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
41710 : 573 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_EQ))
41711 : 308 : iter_type = integer_type_node;
41712 : : else
41713 : : {
41714 : 265 : const char *saved_message
41715 : : = parser->type_definition_forbidden_message;
41716 : 265 : parser->type_definition_forbidden_message
41717 : 265 : = G_("types may not be defined in iterator type");
41718 : :
41719 : 265 : iter_type = cp_parser_type_id (parser);
41720 : :
41721 : 265 : parser->type_definition_forbidden_message = saved_message;
41722 : : }
41723 : :
41724 : 573 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
41725 : 573 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
41726 : : {
41727 : 45 : cp_parser_error (parser, "expected identifier");
41728 : 45 : break;
41729 : : }
41730 : :
41731 : 528 : tree id = cp_parser_identifier (parser);
41732 : 528 : if (id == error_mark_node)
41733 : : break;
41734 : :
41735 : 528 : if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
41736 : : break;
41737 : :
41738 : 528 : parser->colon_corrects_to_scope_p = false;
41739 : 528 : parser->colon_doesnt_start_class_def_p = true;
41740 : 528 : tree begin = cp_parser_assignment_expression (parser);
41741 : :
41742 : 528 : if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
41743 : : break;
41744 : :
41745 : 519 : tree end = cp_parser_assignment_expression (parser);
41746 : :
41747 : 519 : tree step = integer_one_node;
41748 : 519 : if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
41749 : : {
41750 : 259 : cp_lexer_consume_token (parser->lexer);
41751 : 259 : step = cp_parser_assignment_expression (parser);
41752 : : }
41753 : :
41754 : 519 : tree iter_var = build_decl (loc, VAR_DECL, id, iter_type);
41755 : 519 : DECL_ARTIFICIAL (iter_var) = 1;
41756 : 519 : DECL_CONTEXT (iter_var) = current_function_decl;
41757 : 519 : pushdecl (iter_var);
41758 : :
41759 : 519 : *last = make_tree_vec (6);
41760 : 519 : TREE_VEC_ELT (*last, 0) = iter_var;
41761 : 519 : TREE_VEC_ELT (*last, 1) = begin;
41762 : 519 : TREE_VEC_ELT (*last, 2) = end;
41763 : 519 : TREE_VEC_ELT (*last, 3) = step;
41764 : 519 : last = &TREE_CHAIN (*last);
41765 : :
41766 : 519 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
41767 : : {
41768 : 105 : cp_lexer_consume_token (parser->lexer);
41769 : 105 : continue;
41770 : : }
41771 : : break;
41772 : 105 : }
41773 : : while (1);
41774 : :
41775 : 468 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
41776 : 468 : parser->colon_doesnt_start_class_def_p
41777 : 468 : = saved_colon_doesnt_start_class_def_p;
41778 : :
41779 : 468 : if (!parens.require_close (parser))
41780 : 63 : cp_parser_skip_to_closing_parenthesis (parser,
41781 : : /*recovering=*/true,
41782 : : /*or_comma=*/false,
41783 : : /*consume_paren=*/true);
41784 : :
41785 : 468 : return ret ? ret : error_mark_node;
41786 : : }
41787 : :
41788 : : /* OpenMP 5.0:
41789 : : affinity ( [aff-modifier :] variable-list )
41790 : : aff-modifier:
41791 : : iterator ( iterators-definition ) */
41792 : :
41793 : : static tree
41794 : 462 : cp_parser_omp_clause_affinity (cp_parser *parser, tree list)
41795 : : {
41796 : 462 : tree nlist, c, iterators = NULL_TREE;
41797 : :
41798 : 462 : matching_parens parens;
41799 : 462 : if (!parens.require_open (parser))
41800 : : return list;
41801 : :
41802 : 462 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41803 : : {
41804 : 438 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
41805 : 438 : const char *p = IDENTIFIER_POINTER (id);
41806 : 438 : bool parse_iter = ((strcmp ("iterator", p) == 0)
41807 : 438 : && (cp_lexer_nth_token_is (parser->lexer, 2,
41808 : 156 : CPP_OPEN_PAREN)));
41809 : 156 : if (parse_iter)
41810 : : {
41811 : 156 : size_t n = cp_parser_skip_balanced_tokens (parser, 2);
41812 : 156 : parse_iter = cp_lexer_nth_token_is (parser->lexer, n, CPP_COLON);
41813 : : }
41814 : 156 : if (parse_iter)
41815 : : {
41816 : 147 : begin_scope (sk_omp, NULL);
41817 : 147 : iterators = cp_parser_omp_iterators (parser);
41818 : 147 : if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
41819 : : {
41820 : 0 : if (iterators)
41821 : 0 : poplevel (0, 1, 0);
41822 : 0 : cp_parser_skip_to_closing_parenthesis (parser,
41823 : : /*recovering=*/true,
41824 : : /*or_comma=*/false,
41825 : : /*consume_paren=*/true);
41826 : 0 : return list;
41827 : : }
41828 : : }
41829 : : }
41830 : 462 : nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_AFFINITY,
41831 : : list, NULL);
41832 : 462 : if (iterators)
41833 : : {
41834 : 147 : tree block = poplevel (1, 1, 0);
41835 : 147 : if (iterators != error_mark_node)
41836 : : {
41837 : 135 : TREE_VEC_ELT (iterators, 5) = block;
41838 : 309 : for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
41839 : 348 : OMP_CLAUSE_DECL (c) = build_tree_list (iterators,
41840 : 174 : OMP_CLAUSE_DECL (c));
41841 : : }
41842 : : }
41843 : : return nlist;
41844 : : }
41845 : :
41846 : : /* OpenMP 4.0:
41847 : : depend ( depend-kind : variable-list )
41848 : :
41849 : : depend-kind:
41850 : : in | out | inout
41851 : :
41852 : : OpenMP 4.5:
41853 : : depend ( source )
41854 : :
41855 : : depend ( sink : vec )
41856 : :
41857 : : OpenMP 5.0:
41858 : : depend ( depend-modifier , depend-kind: variable-list )
41859 : :
41860 : : depend-kind:
41861 : : in | out | inout | mutexinoutset | depobj
41862 : :
41863 : : depend-modifier:
41864 : : iterator ( iterators-definition ) */
41865 : :
41866 : : static tree
41867 : 1842 : cp_parser_omp_clause_depend (cp_parser *parser, tree list, location_t loc)
41868 : : {
41869 : 1842 : tree nlist, c, iterators = NULL_TREE;
41870 : 1842 : enum omp_clause_depend_kind kind = OMP_CLAUSE_DEPEND_LAST;
41871 : 1842 : enum omp_clause_doacross_kind dkind = OMP_CLAUSE_DOACROSS_LAST;
41872 : :
41873 : 1842 : matching_parens parens;
41874 : 1842 : if (!parens.require_open (parser))
41875 : : return list;
41876 : :
41877 : 2496 : do
41878 : : {
41879 : 2169 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
41880 : 0 : goto invalid_kind;
41881 : :
41882 : 2169 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
41883 : 2169 : const char *p = IDENTIFIER_POINTER (id);
41884 : :
41885 : 2169 : if (strcmp ("iterator", p) == 0 && iterators == NULL_TREE)
41886 : : {
41887 : 327 : begin_scope (sk_omp, NULL);
41888 : 327 : iterators = cp_parser_omp_iterators (parser);
41889 : 327 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
41890 : 327 : continue;
41891 : : }
41892 : 1842 : if (strcmp ("in", p) == 0)
41893 : : kind = OMP_CLAUSE_DEPEND_IN;
41894 : 1330 : else if (strcmp ("inout", p) == 0)
41895 : : kind = OMP_CLAUSE_DEPEND_INOUT;
41896 : 792 : else if (strcmp ("inoutset", p) == 0)
41897 : : kind = OMP_CLAUSE_DEPEND_INOUTSET;
41898 : 771 : else if (strcmp ("mutexinoutset", p) == 0)
41899 : : kind = OMP_CLAUSE_DEPEND_MUTEXINOUTSET;
41900 : 736 : else if (strcmp ("out", p) == 0)
41901 : : kind = OMP_CLAUSE_DEPEND_OUT;
41902 : 500 : else if (strcmp ("depobj", p) == 0)
41903 : : kind = OMP_CLAUSE_DEPEND_DEPOBJ;
41904 : 432 : else if (strcmp ("sink", p) == 0)
41905 : : dkind = OMP_CLAUSE_DOACROSS_SINK;
41906 : 215 : else if (strcmp ("source", p) == 0)
41907 : : dkind = OMP_CLAUSE_DOACROSS_SOURCE;
41908 : : else
41909 : 12 : goto invalid_kind;
41910 : 1830 : break;
41911 : 327 : }
41912 : : while (1);
41913 : :
41914 : 1830 : cp_lexer_consume_token (parser->lexer);
41915 : :
41916 : 1830 : if (iterators
41917 : 1830 : && (dkind == OMP_CLAUSE_DOACROSS_SOURCE
41918 : 1830 : || dkind == OMP_CLAUSE_DOACROSS_SINK))
41919 : : {
41920 : 12 : poplevel (0, 1, 0);
41921 : 12 : error_at (loc, "%<iterator%> modifier incompatible with %qs",
41922 : : dkind == OMP_CLAUSE_DOACROSS_SOURCE ? "source" : "sink");
41923 : 12 : iterators = NULL_TREE;
41924 : : }
41925 : :
41926 : 1830 : if (dkind == OMP_CLAUSE_DOACROSS_SOURCE)
41927 : : {
41928 : 203 : c = build_omp_clause (loc, OMP_CLAUSE_DOACROSS);
41929 : 203 : OMP_CLAUSE_DOACROSS_KIND (c) = dkind;
41930 : 203 : OMP_CLAUSE_DOACROSS_DEPEND (c) = 1;
41931 : 203 : OMP_CLAUSE_DECL (c) = NULL_TREE;
41932 : 203 : OMP_CLAUSE_CHAIN (c) = list;
41933 : 203 : if (!parens.require_close (parser))
41934 : 0 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41935 : : /*or_comma=*/false,
41936 : : /*consume_paren=*/true);
41937 : 203 : return c;
41938 : : }
41939 : :
41940 : 1627 : if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
41941 : 0 : goto resync_fail;
41942 : :
41943 : 1627 : if (dkind == OMP_CLAUSE_DOACROSS_SINK)
41944 : : {
41945 : 217 : nlist = cp_parser_omp_clause_doacross_sink (parser, loc, list, true);
41946 : 217 : if (!parens.require_close (parser))
41947 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41948 : : /*or_comma=*/false,
41949 : : /*consume_paren=*/true);
41950 : : }
41951 : : else
41952 : : {
41953 : 1410 : nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_DEPEND,
41954 : : list, NULL);
41955 : :
41956 : 1410 : if (iterators)
41957 : : {
41958 : 303 : tree block = poplevel (1, 1, 0);
41959 : 303 : if (iterators == error_mark_node)
41960 : : iterators = NULL_TREE;
41961 : : else
41962 : 273 : TREE_VEC_ELT (iterators, 5) = block;
41963 : : }
41964 : :
41965 : 2889 : for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
41966 : : {
41967 : 1479 : OMP_CLAUSE_DEPEND_KIND (c) = kind;
41968 : 1479 : if (iterators)
41969 : 624 : OMP_CLAUSE_DECL (c)
41970 : 624 : = build_tree_list (iterators, OMP_CLAUSE_DECL (c));
41971 : : }
41972 : : }
41973 : : return nlist;
41974 : :
41975 : 12 : invalid_kind:
41976 : 12 : cp_parser_error (parser, "invalid depend kind");
41977 : 12 : resync_fail:
41978 : 12 : if (iterators)
41979 : 12 : poplevel (0, 1, 0);
41980 : 12 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
41981 : : /*or_comma=*/false,
41982 : : /*consume_paren=*/true);
41983 : 12 : return list;
41984 : : }
41985 : :
41986 : : /* OpenMP 5.2:
41987 : : doacross ( source : )
41988 : : doacross ( source : omp_cur_iteration )
41989 : :
41990 : : doacross ( sink : vec )
41991 : : doacross ( sink : omp_cur_iteration - logical_iteration ) */
41992 : :
41993 : : static tree
41994 : 219 : cp_parser_omp_clause_doacross (cp_parser *parser, tree list, location_t loc)
41995 : : {
41996 : 219 : tree nlist;
41997 : 219 : enum omp_clause_doacross_kind kind = OMP_CLAUSE_DOACROSS_LAST;
41998 : :
41999 : 219 : matching_parens parens;
42000 : 219 : if (!parens.require_open (parser))
42001 : : return list;
42002 : :
42003 : 219 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
42004 : : {
42005 : 0 : invalid_kind:
42006 : 0 : cp_parser_error (parser, "invalid doacross kind");
42007 : 12 : resync_fail:
42008 : 12 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
42009 : : /*or_comma=*/false,
42010 : : /*consume_paren=*/true);
42011 : 12 : return list;
42012 : : }
42013 : :
42014 : 219 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42015 : 219 : const char *p = IDENTIFIER_POINTER (id);
42016 : :
42017 : 219 : if (strcmp ("sink", p) == 0)
42018 : : kind = OMP_CLAUSE_DOACROSS_SINK;
42019 : 99 : else if (strcmp ("source", p) == 0)
42020 : : kind = OMP_CLAUSE_DOACROSS_SOURCE;
42021 : : else
42022 : 0 : goto invalid_kind;
42023 : :
42024 : 219 : cp_lexer_consume_token (parser->lexer);
42025 : :
42026 : 219 : if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
42027 : 12 : goto resync_fail;
42028 : :
42029 : 207 : if (kind == OMP_CLAUSE_DOACROSS_SOURCE)
42030 : : {
42031 : 93 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42032 : : {
42033 : 45 : id = cp_lexer_peek_token (parser->lexer)->u.value;
42034 : 45 : p = IDENTIFIER_POINTER (id);
42035 : 45 : if (strcmp (p, "omp_cur_iteration") == 0)
42036 : 39 : cp_lexer_consume_token (parser->lexer);
42037 : : }
42038 : 93 : nlist = build_omp_clause (loc, OMP_CLAUSE_DOACROSS);
42039 : 93 : OMP_CLAUSE_DOACROSS_KIND (nlist) = OMP_CLAUSE_DOACROSS_SOURCE;
42040 : 93 : OMP_CLAUSE_DECL (nlist) = NULL_TREE;
42041 : 93 : OMP_CLAUSE_CHAIN (nlist) = list;
42042 : : }
42043 : : else
42044 : 114 : nlist = cp_parser_omp_clause_doacross_sink (parser, loc, list, false);
42045 : :
42046 : 207 : if (!parens.require_close (parser))
42047 : 9 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
42048 : : /*or_comma=*/false,
42049 : : /*consume_paren=*/true);
42050 : : return nlist;
42051 : : }
42052 : :
42053 : : /* OpenMP 4.0:
42054 : : from ( variable-list )
42055 : : to ( variable-list )
42056 : :
42057 : : OpenMP 5.1:
42058 : : from ( [present :] variable-list )
42059 : : to ( [present :] variable-list ) */
42060 : :
42061 : : static tree
42062 : 2939 : cp_parser_omp_clause_from_to (cp_parser *parser, enum omp_clause_code kind,
42063 : : tree list)
42064 : : {
42065 : 2939 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
42066 : : return list;
42067 : :
42068 : 2939 : bool present = false;
42069 : 2939 : cp_token *token = cp_lexer_peek_token (parser->lexer);
42070 : :
42071 : 2939 : if (token->type == CPP_NAME
42072 : 2913 : && strcmp (IDENTIFIER_POINTER (token->u.value), "present") == 0
42073 : 2948 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
42074 : : {
42075 : 9 : present = true;
42076 : 9 : cp_lexer_consume_token (parser->lexer);
42077 : 9 : cp_lexer_consume_token (parser->lexer);
42078 : : }
42079 : :
42080 : 2939 : tree nl = cp_parser_omp_var_list_no_open (parser, kind, list, NULL, true);
42081 : 2939 : if (present)
42082 : 18 : for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
42083 : 9 : OMP_CLAUSE_MOTION_PRESENT (c) = 1;
42084 : :
42085 : : return nl;
42086 : : }
42087 : :
42088 : : /* OpenMP 4.0:
42089 : : map ( map-kind : variable-list )
42090 : : map ( variable-list )
42091 : :
42092 : : map-kind:
42093 : : alloc | to | from | tofrom
42094 : :
42095 : : OpenMP 4.5:
42096 : : map-kind:
42097 : : alloc | to | from | tofrom | release | delete
42098 : :
42099 : : map ( always [,] map-kind: variable-list )
42100 : :
42101 : : OpenMP 5.0:
42102 : : map ( [map-type-modifier[,] ...] map-kind: variable-list )
42103 : :
42104 : : map-type-modifier:
42105 : : always | close */
42106 : :
42107 : : static tree
42108 : 3861 : cp_parser_omp_clause_map (cp_parser *parser, tree list)
42109 : : {
42110 : 3861 : tree nlist, c;
42111 : 3861 : enum gomp_map_kind kind = GOMP_MAP_TOFROM;
42112 : :
42113 : 3861 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
42114 : : return list;
42115 : :
42116 : : int pos = 1;
42117 : 5849 : int map_kind_pos = 0;
42118 : 11698 : while (cp_lexer_peek_nth_token (parser->lexer, pos)->type == CPP_NAME
42119 : 5849 : || cp_lexer_peek_nth_token (parser->lexer, pos)->keyword == RID_DELETE)
42120 : : {
42121 : 4457 : if (cp_lexer_peek_nth_token (parser->lexer, pos + 1)->type == CPP_COLON)
42122 : : {
42123 : : map_kind_pos = pos;
42124 : : break;
42125 : : }
42126 : :
42127 : 1988 : if (cp_lexer_peek_nth_token (parser->lexer, pos + 1)->type == CPP_COMMA)
42128 : 476 : pos++;
42129 : 1988 : pos++;
42130 : : }
42131 : :
42132 : 3861 : bool always_modifier = false;
42133 : 3861 : bool close_modifier = false;
42134 : 3861 : bool present_modifier = false;
42135 : 4736 : for (int pos = 1; pos < map_kind_pos; ++pos)
42136 : : {
42137 : 926 : cp_token *tok = cp_lexer_peek_token (parser->lexer);
42138 : 926 : if (tok->type == CPP_COMMA)
42139 : : {
42140 : 375 : cp_lexer_consume_token (parser->lexer);
42141 : 375 : continue;
42142 : : }
42143 : :
42144 : 551 : const char *p = IDENTIFIER_POINTER (tok->u.value);
42145 : 551 : if (strcmp ("always", p) == 0)
42146 : : {
42147 : 212 : if (always_modifier)
42148 : : {
42149 : 12 : cp_parser_error (parser, "too many %<always%> modifiers");
42150 : 12 : cp_parser_skip_to_closing_parenthesis (parser,
42151 : : /*recovering=*/true,
42152 : : /*or_comma=*/false,
42153 : : /*consume_paren=*/true);
42154 : 12 : return list;
42155 : : }
42156 : : always_modifier = true;
42157 : : }
42158 : 339 : else if (strcmp ("close", p) == 0)
42159 : : {
42160 : 183 : if (close_modifier)
42161 : : {
42162 : 12 : cp_parser_error (parser, "too many %<close%> modifiers");
42163 : 12 : cp_parser_skip_to_closing_parenthesis (parser,
42164 : : /*recovering=*/true,
42165 : : /*or_comma=*/false,
42166 : : /*consume_paren=*/true);
42167 : 12 : return list;
42168 : : }
42169 : : close_modifier = true;
42170 : : }
42171 : 156 : else if (strcmp ("present", p) == 0)
42172 : : {
42173 : 141 : if (present_modifier)
42174 : : {
42175 : 12 : cp_parser_error (parser, "too many %<present%> modifiers");
42176 : 12 : cp_parser_skip_to_closing_parenthesis (parser,
42177 : : /*recovering=*/true,
42178 : : /*or_comma=*/false,
42179 : : /*consume_paren=*/true);
42180 : 12 : return list;
42181 : : }
42182 : : present_modifier = true;
42183 : : }
42184 : : else
42185 : : {
42186 : 15 : cp_parser_error (parser, "%<map%> clause with map-type modifier other"
42187 : : " than %<always%>, %<close%> or %<present%>");
42188 : 15 : cp_parser_skip_to_closing_parenthesis (parser,
42189 : : /*recovering=*/true,
42190 : : /*or_comma=*/false,
42191 : : /*consume_paren=*/true);
42192 : 15 : return list;
42193 : : }
42194 : :
42195 : 500 : cp_lexer_consume_token (parser->lexer);
42196 : : }
42197 : :
42198 : 3810 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
42199 : 3810 : && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
42200 : : {
42201 : 2378 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42202 : 2378 : const char *p = IDENTIFIER_POINTER (id);
42203 : 2378 : int always_present_modifier = always_modifier && present_modifier;
42204 : :
42205 : 2378 : if (strcmp ("alloc", p) == 0)
42206 : 266 : kind = present_modifier ? GOMP_MAP_PRESENT_ALLOC : GOMP_MAP_ALLOC;
42207 : 2112 : else if (strcmp ("to", p) == 0)
42208 : 826 : kind = (always_present_modifier ? GOMP_MAP_ALWAYS_PRESENT_TO
42209 : 819 : : present_modifier ? GOMP_MAP_PRESENT_TO
42210 : 799 : : always_modifier ? GOMP_MAP_ALWAYS_TO
42211 : : : GOMP_MAP_TO);
42212 : 1286 : else if (strcmp ("from", p) == 0)
42213 : 522 : kind = (always_present_modifier ? GOMP_MAP_ALWAYS_PRESENT_FROM
42214 : 509 : : present_modifier ? GOMP_MAP_PRESENT_FROM
42215 : 500 : : always_modifier ? GOMP_MAP_ALWAYS_FROM
42216 : : : GOMP_MAP_FROM);
42217 : 764 : else if (strcmp ("tofrom", p) == 0)
42218 : 600 : kind = (always_present_modifier ? GOMP_MAP_ALWAYS_PRESENT_TOFROM
42219 : 588 : : present_modifier ? GOMP_MAP_PRESENT_TOFROM
42220 : 572 : : always_modifier ? GOMP_MAP_ALWAYS_TOFROM
42221 : : : GOMP_MAP_TOFROM);
42222 : 164 : else if (strcmp ("release", p) == 0)
42223 : : kind = GOMP_MAP_RELEASE;
42224 : : else
42225 : : {
42226 : 0 : cp_parser_error (parser, "invalid map kind");
42227 : 0 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
42228 : : /*or_comma=*/false,
42229 : : /*consume_paren=*/true);
42230 : 0 : return list;
42231 : : }
42232 : 2378 : cp_lexer_consume_token (parser->lexer);
42233 : 2378 : cp_lexer_consume_token (parser->lexer);
42234 : : }
42235 : 1432 : else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DELETE)
42236 : 1432 : && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
42237 : : {
42238 : 40 : kind = GOMP_MAP_DELETE;
42239 : 40 : cp_lexer_consume_token (parser->lexer);
42240 : 40 : cp_lexer_consume_token (parser->lexer);
42241 : : }
42242 : :
42243 : : /* We introduce a scope here so that errors parsing e.g. "always", "close"
42244 : : tokens do not propagate to later directives that might use them
42245 : : legally. */
42246 : 3810 : begin_scope (sk_omp, NULL);
42247 : 3810 : nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_MAP, list,
42248 : : NULL, true);
42249 : 3810 : finish_scope ();
42250 : :
42251 : 12458 : for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
42252 : 4838 : OMP_CLAUSE_SET_MAP_KIND (c, kind);
42253 : :
42254 : : return nlist;
42255 : : }
42256 : :
42257 : : /* OpenMP 4.0:
42258 : : device ( expression )
42259 : :
42260 : : OpenMP 5.0:
42261 : : device ( [device-modifier :] integer-expression )
42262 : :
42263 : : device-modifier:
42264 : : ancestor | device_num */
42265 : :
42266 : : static tree
42267 : 662 : cp_parser_omp_clause_device (cp_parser *parser, tree list,
42268 : : location_t location)
42269 : : {
42270 : 662 : tree t, c;
42271 : 662 : bool ancestor = false;
42272 : :
42273 : 662 : matching_parens parens;
42274 : 662 : if (!parens.require_open (parser))
42275 : : return list;
42276 : :
42277 : 662 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
42278 : 662 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
42279 : : {
42280 : 116 : cp_token *tok = cp_lexer_peek_token (parser->lexer);
42281 : 116 : const char *p = IDENTIFIER_POINTER (tok->u.value);
42282 : 116 : if (strcmp ("ancestor", p) == 0)
42283 : : {
42284 : 69 : ancestor = true;
42285 : :
42286 : : /* A requires directive with the reverse_offload clause must be
42287 : : specified. */
42288 : 69 : if ((omp_requires_mask & OMP_REQUIRES_REVERSE_OFFLOAD) == 0)
42289 : : {
42290 : 3 : error_at (tok->location, "%<ancestor%> device modifier not "
42291 : : "preceded by %<requires%> directive "
42292 : : "with %<reverse_offload%> clause");
42293 : 3 : cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
42294 : 3 : return list;
42295 : : }
42296 : : }
42297 : 47 : else if (strcmp ("device_num", p) == 0)
42298 : : ;
42299 : : else
42300 : : {
42301 : 3 : error_at (tok->location, "expected %<ancestor%> or %<device_num%>");
42302 : 3 : cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
42303 : 3 : return list;
42304 : : }
42305 : 110 : cp_lexer_consume_token (parser->lexer);
42306 : 110 : cp_lexer_consume_token (parser->lexer);
42307 : : }
42308 : :
42309 : 656 : t = cp_parser_assignment_expression (parser);
42310 : :
42311 : 656 : if (t == error_mark_node
42312 : 1312 : || !parens.require_close (parser))
42313 : 6 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
42314 : : /*or_comma=*/false,
42315 : : /*consume_paren=*/true);
42316 : :
42317 : 656 : check_no_duplicate_clause (list, OMP_CLAUSE_DEVICE,
42318 : : "device", location);
42319 : :
42320 : 656 : c = build_omp_clause (location, OMP_CLAUSE_DEVICE);
42321 : 656 : OMP_CLAUSE_DEVICE_ID (c) = t;
42322 : 656 : OMP_CLAUSE_CHAIN (c) = list;
42323 : 656 : OMP_CLAUSE_DEVICE_ANCESTOR (c) = ancestor;
42324 : :
42325 : 656 : return c;
42326 : : }
42327 : :
42328 : : /* OpenMP 4.0:
42329 : : dist_schedule ( static )
42330 : : dist_schedule ( static , expression ) */
42331 : :
42332 : : static tree
42333 : 1839 : cp_parser_omp_clause_dist_schedule (cp_parser *parser, tree list,
42334 : : location_t location)
42335 : : {
42336 : 1839 : tree c, t;
42337 : :
42338 : 1839 : matching_parens parens;
42339 : 1839 : if (!parens.require_open (parser))
42340 : : return list;
42341 : :
42342 : 1839 : c = build_omp_clause (location, OMP_CLAUSE_DIST_SCHEDULE);
42343 : :
42344 : 1839 : if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
42345 : 0 : goto invalid_kind;
42346 : 1839 : cp_lexer_consume_token (parser->lexer);
42347 : :
42348 : 1839 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
42349 : : {
42350 : 1818 : cp_lexer_consume_token (parser->lexer);
42351 : :
42352 : 1818 : t = cp_parser_assignment_expression (parser);
42353 : :
42354 : 1818 : if (t == error_mark_node)
42355 : 0 : goto resync_fail;
42356 : 1818 : OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c) = t;
42357 : :
42358 : 1818 : if (!parens.require_close (parser))
42359 : 3 : goto resync_fail;
42360 : : }
42361 : 21 : else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
42362 : 0 : goto resync_fail;
42363 : :
42364 : : /* check_no_duplicate_clause (list, OMP_CLAUSE_DIST_SCHEDULE,
42365 : : "dist_schedule", location); */
42366 : 1836 : if (omp_find_clause (list, OMP_CLAUSE_DIST_SCHEDULE))
42367 : 6 : warning_at (location, OPT_Wopenmp, "too many %qs clauses", "dist_schedule");
42368 : 1836 : OMP_CLAUSE_CHAIN (c) = list;
42369 : 1836 : return c;
42370 : :
42371 : 0 : invalid_kind:
42372 : 0 : cp_parser_error (parser, "invalid dist_schedule kind");
42373 : 3 : resync_fail:
42374 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
42375 : : /*or_comma=*/false,
42376 : : /*consume_paren=*/true);
42377 : 3 : return list;
42378 : : }
42379 : :
42380 : : /* OpenMP 4.0:
42381 : : proc_bind ( proc-bind-kind )
42382 : :
42383 : : proc-bind-kind:
42384 : : primary | master | close | spread
42385 : : where OpenMP 5.1 added 'primary' and deprecated the alias 'master'. */
42386 : :
42387 : : static tree
42388 : 526 : cp_parser_omp_clause_proc_bind (cp_parser *parser, tree list,
42389 : : location_t location)
42390 : : {
42391 : 526 : tree c;
42392 : 526 : enum omp_clause_proc_bind_kind kind;
42393 : :
42394 : 526 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
42395 : : return list;
42396 : :
42397 : 526 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42398 : : {
42399 : 526 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42400 : 526 : const char *p = IDENTIFIER_POINTER (id);
42401 : :
42402 : 526 : if (strcmp ("primary", p) == 0)
42403 : : kind = OMP_CLAUSE_PROC_BIND_PRIMARY;
42404 : 523 : else if (strcmp ("master", p) == 0)
42405 : : kind = OMP_CLAUSE_PROC_BIND_MASTER;
42406 : 487 : else if (strcmp ("close", p) == 0)
42407 : : kind = OMP_CLAUSE_PROC_BIND_CLOSE;
42408 : 473 : else if (strcmp ("spread", p) == 0)
42409 : : kind = OMP_CLAUSE_PROC_BIND_SPREAD;
42410 : : else
42411 : 0 : goto invalid_kind;
42412 : : }
42413 : : else
42414 : 0 : goto invalid_kind;
42415 : :
42416 : 526 : cp_lexer_consume_token (parser->lexer);
42417 : 526 : if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
42418 : 0 : goto resync_fail;
42419 : :
42420 : 526 : c = build_omp_clause (location, OMP_CLAUSE_PROC_BIND);
42421 : 526 : check_no_duplicate_clause (list, OMP_CLAUSE_PROC_BIND, "proc_bind",
42422 : : location);
42423 : 526 : OMP_CLAUSE_PROC_BIND_KIND (c) = kind;
42424 : 526 : OMP_CLAUSE_CHAIN (c) = list;
42425 : 526 : return c;
42426 : :
42427 : 0 : invalid_kind:
42428 : 0 : cp_parser_error (parser, "invalid depend kind");
42429 : 0 : resync_fail:
42430 : 0 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
42431 : : /*or_comma=*/false,
42432 : : /*consume_paren=*/true);
42433 : 0 : return list;
42434 : : }
42435 : :
42436 : : /* OpenMP 5.1:
42437 : : interop (var-list) */
42438 : :
42439 : : static tree
42440 : 96 : cp_parser_omp_clause_interop (cp_parser *parser, tree list,
42441 : : location_t location)
42442 : : {
42443 : 96 : check_no_duplicate_clause (list, OMP_CLAUSE_INTEROP, "interop", location);
42444 : 96 : tree nl = cp_parser_omp_var_list (parser, OMP_CLAUSE_INTEROP, list);
42445 : 237 : for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
42446 : : {
42447 : 141 : TREE_USED (OMP_CLAUSE_DECL (c)) = 1;
42448 : 141 : DECL_READ_P (OMP_CLAUSE_DECL (c)) = 1;
42449 : : }
42450 : 96 : return nl;
42451 : : }
42452 : :
42453 : : /* OpenMP 5.0:
42454 : : device_type ( host | nohost | any ) */
42455 : :
42456 : : static tree
42457 : 123 : cp_parser_omp_clause_device_type (cp_parser *parser, tree list,
42458 : : location_t location)
42459 : : {
42460 : 123 : tree c;
42461 : 123 : enum omp_clause_device_type_kind kind;
42462 : :
42463 : 123 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
42464 : : return list;
42465 : :
42466 : 123 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42467 : : {
42468 : 123 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42469 : 123 : const char *p = IDENTIFIER_POINTER (id);
42470 : :
42471 : 123 : if (strcmp ("host", p) == 0)
42472 : : kind = OMP_CLAUSE_DEVICE_TYPE_HOST;
42473 : 75 : else if (strcmp ("nohost", p) == 0)
42474 : : kind = OMP_CLAUSE_DEVICE_TYPE_NOHOST;
42475 : 51 : else if (strcmp ("any", p) == 0)
42476 : : kind = OMP_CLAUSE_DEVICE_TYPE_ANY;
42477 : : else
42478 : 0 : goto invalid_kind;
42479 : : }
42480 : : else
42481 : 0 : goto invalid_kind;
42482 : :
42483 : 123 : cp_lexer_consume_token (parser->lexer);
42484 : 123 : if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
42485 : 0 : goto resync_fail;
42486 : :
42487 : 123 : c = build_omp_clause (location, OMP_CLAUSE_DEVICE_TYPE);
42488 : 123 : check_no_duplicate_clause (list, OMP_CLAUSE_DEVICE_TYPE, "device_type",
42489 : : location);
42490 : 123 : OMP_CLAUSE_DEVICE_TYPE_KIND (c) = kind;
42491 : 123 : OMP_CLAUSE_CHAIN (c) = list;
42492 : 123 : return c;
42493 : :
42494 : 0 : invalid_kind:
42495 : 0 : cp_parser_error (parser, "invalid depend kind");
42496 : 0 : resync_fail:
42497 : 0 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
42498 : : /*or_comma=*/false,
42499 : : /*consume_paren=*/true);
42500 : 0 : return list;
42501 : : }
42502 : :
42503 : : /* OpenMP 5.1:
42504 : : prefer_type ( const-int-expr-or-string-literal-list )
42505 : :
42506 : : OpenMP 6.0:
42507 : : prefer_type ( { preference-selector-list }, { ... } )
42508 : :
42509 : : with preference-selector being:
42510 : : fr ( identifier-or-string-literal-list )
42511 : : attr ( string-list )
42512 : :
42513 : : Data format:
42514 : : For the foreign runtime identifiers, string values are converted to
42515 : : their integer value; unknown string or integer values are set to
42516 : : GOMP_INTEROP_IFR_KNOWN.
42517 : :
42518 : : Each item (a) GOMP_INTEROP_IFR_SEPARATOR
42519 : : (b) for any 'fr', its integer value.
42520 : : Note: Spec only permits 1 'fr' entry (6.0; changed after TR13)
42521 : : (c) GOMP_INTEROP_IFR_SEPARATOR
42522 : : (d) list of \0-terminated non-empty strings for 'attr'
42523 : : (e) '\0'
42524 : : Tailing '\0'.
42525 : :
42526 : : When processing a template:
42527 : : attr and fr strings are processed normally.
42528 : : for integer expressions, set fr to UNKNOWN and keep a separate list
42529 : : of those expressions - and store it as
42530 : : tree_cons (bytestring, fr_tree list). */
42531 : :
42532 : : static tree
42533 : 234 : cp_parser_omp_modifier_prefer_type (cp_parser *parser)
42534 : : {
42535 : 234 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
42536 : 0 : return error_mark_node;
42537 : :
42538 : 234 : unsigned fr_cnt = 0;
42539 : 234 : auto_vec<tree> fr_list;
42540 : 234 : std::string str;
42541 : :
42542 : : /* Old Format: const-int-expr-or-string-literal-list */
42543 : 234 : if (cp_lexer_peek_token (parser->lexer)->type != CPP_OPEN_BRACE)
42544 : 342 : while (true)
42545 : : {
42546 : 228 : str += (char) GOMP_INTEROP_IFR_SEPARATOR;
42547 : 228 : if (cp_lexer_peek_token (parser->lexer)->type == CPP_STRING)
42548 : : {
42549 : 87 : cp_expr cval = cp_parser_unevaluated_string_literal (parser);
42550 : 87 : if (*cval == error_mark_node)
42551 : 3 : return error_mark_node;
42552 : 87 : if ((size_t) TREE_STRING_LENGTH (*cval)
42553 : 87 : != strlen (TREE_STRING_POINTER (*cval)) + 1)
42554 : : {
42555 : 3 : error_at (cval.get_location (), "string literal must "
42556 : : "not contain %<\\0%>");
42557 : 3 : return error_mark_node;
42558 : : }
42559 : 84 : char c = omp_get_fr_id_from_name (TREE_STRING_POINTER (*cval));
42560 : 84 : if (c == GOMP_INTEROP_IFR_UNKNOWN)
42561 : 15 : warning_at (cval.get_location (), OPT_Wopenmp,
42562 : : "unknown foreign runtime identifier %qs",
42563 : 15 : TREE_STRING_POINTER (*cval));
42564 : 84 : str += c;
42565 : : }
42566 : : else
42567 : : {
42568 : 141 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
42569 : 141 : tree value = cp_parser_assignment_expression (parser);
42570 : 141 : value = cp_fully_fold (value);
42571 : 141 : if (!processing_template_decl)
42572 : : {
42573 : 78 : if (TREE_CODE (value) != INTEGER_CST
42574 : 69 : || !tree_fits_shwi_p (value))
42575 : : {
42576 : 9 : cp_parser_error (parser,
42577 : : "expected string literal or constant "
42578 : : "integer expression");
42579 : 9 : return error_mark_node;
42580 : : }
42581 : 69 : HOST_WIDE_INT n = tree_to_shwi (value);
42582 : 69 : if (n < 1 || n > GOMP_INTEROP_IFR_LAST)
42583 : : {
42584 : 18 : warning_at (EXPR_LOC_OR_LOC (value, loc), OPT_Wopenmp,
42585 : : "unknown foreign runtime identifier %qwd", n);
42586 : 9 : n = GOMP_INTEROP_IFR_UNKNOWN;
42587 : : }
42588 : 69 : str += (char) n;
42589 : : }
42590 : : else
42591 : : {
42592 : 63 : str += (char) GOMP_INTEROP_IFR_UNKNOWN;
42593 : 144 : for (unsigned n = fr_list.length (); n < fr_cnt; n++)
42594 : 18 : fr_list.safe_push (NULL_TREE);
42595 : 63 : if (EXPR_LOCATION (value) == UNKNOWN_LOCATION)
42596 : 18 : value = build1_loc (loc, NOP_EXPR, TREE_TYPE (value), value);
42597 : 63 : fr_list.safe_push (value);
42598 : : }
42599 : : }
42600 : 216 : fr_cnt++;
42601 : 216 : str += (char) GOMP_INTEROP_IFR_SEPARATOR;
42602 : 216 : str += '\0';
42603 : 216 : if (cp_lexer_peek_token (parser->lexer)->type == CPP_COMMA)
42604 : : {
42605 : 114 : cp_lexer_consume_token (parser->lexer);
42606 : 114 : continue;
42607 : : }
42608 : 102 : if (cp_lexer_peek_token (parser->lexer)->type != CPP_CLOSE_PAREN)
42609 : : {
42610 : 0 : cp_parser_error (parser, "expected %<,%> or %<)%>");
42611 : 0 : return error_mark_node;
42612 : : }
42613 : 102 : cp_lexer_consume_token (parser->lexer);
42614 : 102 : str += '\0';
42615 : 102 : tree res = build_string (str.length (), str.data ());
42616 : 102 : TREE_TYPE (res) = build_array_type_nelts (unsigned_char_type_node,
42617 : 102 : str.length ());
42618 : 102 : if (!fr_list.is_empty ())
42619 : : {
42620 : 30 : tree t = make_tree_vec (fr_list.length ());
42621 : 111 : for (unsigned i = 0; i < fr_list.length (); i++)
42622 : 81 : TREE_VEC_ELT (t, i) = fr_list[i];
42623 : 30 : res = tree_cons (res, t, NULL_TREE);
42624 : : }
42625 : 102 : return res;
42626 : 114 : }
42627 : :
42628 : : /* New format. */
42629 : 120 : std::string str2;
42630 : 306 : while (true)
42631 : : {
42632 : 213 : if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
42633 : 3 : return error_mark_node;
42634 : 210 : str += (char) GOMP_INTEROP_IFR_SEPARATOR;
42635 : 210 : str2.clear ();
42636 : 210 : bool has_fr = false;
42637 : 372 : while (true)
42638 : : {
42639 : 291 : cp_token *tok = cp_lexer_peek_token (parser->lexer);
42640 : 291 : if (tok->type != CPP_NAME
42641 : 291 : || (strcmp("fr", IDENTIFIER_POINTER (tok->u.value)) != 0
42642 : 117 : && strcmp("attr", IDENTIFIER_POINTER (tok->u.value)) != 0))
42643 : : {
42644 : 0 : cp_parser_error (parser, "expected %<fr%> or %<attr%> preference "
42645 : : "selector");
42646 : 0 : return error_mark_node;
42647 : : }
42648 : 291 : cp_lexer_consume_token (parser->lexer);
42649 : 291 : bool is_fr = IDENTIFIER_POINTER (tok->u.value)[0] == 'f';
42650 : 291 : if (is_fr && has_fr)
42651 : : {
42652 : 3 : cp_parser_error (parser, "duplicated %<fr%> preference selector");
42653 : 3 : return error_mark_node;
42654 : : }
42655 : 288 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
42656 : 0 : return error_mark_node;
42657 : 312 : while (true)
42658 : : {
42659 : 300 : if (cp_lexer_peek_token (parser->lexer)->type == CPP_STRING)
42660 : : {
42661 : 204 : cp_expr cval = cp_parser_unevaluated_string_literal (parser);
42662 : 204 : if (*cval == error_mark_node)
42663 : 15 : return error_mark_node;
42664 : 204 : if ((size_t) TREE_STRING_LENGTH (*cval)
42665 : 204 : != strlen (TREE_STRING_POINTER (*cval)) + 1)
42666 : : {
42667 : 6 : error_at (cval.get_location (), "string literal must "
42668 : : "not contain %<\\0%>");
42669 : 6 : return error_mark_node;
42670 : : }
42671 : 198 : if (!is_fr)
42672 : : {
42673 : 126 : if (!startswith (TREE_STRING_POINTER (*cval), "ompx_"))
42674 : : {
42675 : 3 : error_at (cval.get_location (),
42676 : : "%<attr%> string literal must start with "
42677 : : "%<ompx_%>");
42678 : 3 : return error_mark_node;
42679 : : }
42680 : 123 : if (strchr (TREE_STRING_POINTER (*cval), ','))
42681 : : {
42682 : 3 : error_at (cval.get_location (),
42683 : : "%<attr%> string literal must not contain "
42684 : : "a comma");
42685 : 3 : return error_mark_node;
42686 : : }
42687 : 120 : str2 += TREE_STRING_POINTER (*cval);
42688 : 120 : str2 += '\0';
42689 : : }
42690 : : else
42691 : : {
42692 : 72 : if (*TREE_STRING_POINTER (*cval) == '\0')
42693 : : {
42694 : 3 : cp_parser_error (parser,
42695 : : "non-empty string literal expected");
42696 : 3 : return error_mark_node;
42697 : : }
42698 : 69 : char c
42699 : 69 : = omp_get_fr_id_from_name (TREE_STRING_POINTER (*cval));
42700 : 69 : if (c == GOMP_INTEROP_IFR_UNKNOWN)
42701 : 9 : warning_at (cval.get_location (), OPT_Wopenmp,
42702 : : "unknown foreign runtime identifier %qs",
42703 : 9 : TREE_STRING_POINTER (*cval));
42704 : 69 : str += c;
42705 : 69 : has_fr = true;
42706 : : }
42707 : : }
42708 : 96 : else if (!is_fr)
42709 : : {
42710 : 3 : cp_parser_error (parser, "expected string literal");
42711 : 3 : return error_mark_node;
42712 : : }
42713 : : else
42714 : : {
42715 : 93 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
42716 : 93 : tree value = cp_parser_assignment_expression (parser);
42717 : 93 : value = cp_fully_fold (value);
42718 : 93 : if (!processing_template_decl)
42719 : : {
42720 : 54 : if (TREE_CODE (value) != INTEGER_CST
42721 : 45 : || !tree_fits_shwi_p (value))
42722 : : {
42723 : 9 : cp_parser_error (parser,
42724 : : "expected string literal or "
42725 : : "constant integer expression");
42726 : 9 : return error_mark_node;
42727 : : }
42728 : 45 : HOST_WIDE_INT n = tree_to_shwi (value);
42729 : 45 : if (n < 1 || n > GOMP_INTEROP_IFR_LAST)
42730 : : {
42731 : 0 : warning_at (EXPR_LOC_OR_LOC (value, loc), OPT_Wopenmp,
42732 : : "unknown foreign runtime identifier %qwd",
42733 : : n);
42734 : 0 : n = GOMP_INTEROP_IFR_UNKNOWN;
42735 : : }
42736 : 45 : str += (char) n;
42737 : : }
42738 : : else
42739 : : {
42740 : 39 : str += (char) GOMP_INTEROP_IFR_UNKNOWN;
42741 : 81 : for (unsigned n = fr_list.length (); n < fr_cnt; n++)
42742 : 3 : fr_list.safe_push (NULL_TREE);
42743 : 39 : if (EXPR_LOCATION (value) == UNKNOWN_LOCATION)
42744 : 3 : value = build1_loc (loc, NOP_EXPR, TREE_TYPE (value),
42745 : : value);
42746 : 39 : fr_list.safe_push (value);
42747 : : }
42748 : 84 : has_fr = true;
42749 : : }
42750 : 285 : if (!is_fr
42751 : 273 : && cp_lexer_peek_token (parser->lexer)->type == CPP_COMMA)
42752 : : {
42753 : 12 : cp_lexer_consume_token (parser->lexer);
42754 : 12 : continue;
42755 : : }
42756 : 261 : if (cp_lexer_peek_token (parser->lexer)->type != CPP_CLOSE_PAREN)
42757 : : {
42758 : 9 : cp_parser_error (parser,
42759 : : is_fr ? G_("expected %<)%>")
42760 : : : G_("expected %<)%> or %<,%>"));
42761 : 9 : return error_mark_node;
42762 : : }
42763 : 252 : cp_lexer_consume_token (parser->lexer);
42764 : 252 : break;
42765 : 12 : }
42766 : 252 : if (cp_lexer_peek_token (parser->lexer)->type == CPP_COMMA)
42767 : : {
42768 : 81 : cp_lexer_consume_token (parser->lexer);
42769 : 81 : continue;
42770 : : }
42771 : 171 : if (cp_lexer_peek_token (parser->lexer)->type != CPP_CLOSE_BRACE)
42772 : : {
42773 : 0 : cp_parser_error (parser, "expected %<,%> or %<}%>");
42774 : 0 : return error_mark_node;
42775 : : }
42776 : 171 : cp_lexer_consume_token (parser->lexer);
42777 : 171 : break;
42778 : 81 : }
42779 : 171 : fr_cnt++;
42780 : 171 : str += (char) GOMP_INTEROP_IFR_SEPARATOR;
42781 : 171 : str += str2;
42782 : 171 : str += '\0';
42783 : 171 : if (cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
42784 : : break;
42785 : 96 : if (cp_lexer_peek_token (parser->lexer)->type != CPP_COMMA)
42786 : : {
42787 : 3 : cp_parser_error (parser, "expected %<)%> or %<,%>");
42788 : 3 : return error_mark_node;
42789 : : }
42790 : 93 : cp_lexer_consume_token (parser->lexer);
42791 : 93 : }
42792 : 75 : cp_lexer_consume_token (parser->lexer);
42793 : 75 : str += '\0';
42794 : 75 : tree res = build_string (str.length (), str.data ());
42795 : 75 : TREE_TYPE (res) = build_array_type_nelts (unsigned_char_type_node,
42796 : 75 : str.length ());
42797 : 141 : if (!fr_list.is_empty ())
42798 : : {
42799 : 21 : tree t = make_tree_vec (fr_list.length ());
42800 : 63 : for (unsigned i = 0; i < fr_list.length (); i++)
42801 : 42 : TREE_VEC_ELT (t, i) = fr_list[i];
42802 : 21 : res = tree_cons (res, t, NULL_TREE);
42803 : : }
42804 : : return res;
42805 : 354 : }
42806 : :
42807 : : /* OpenMP 5.1
42808 : : modifiers of the 'init' clause, used by the 'init' and the
42809 : : 'append_args' clauses.
42810 : :
42811 : : Modifiers:
42812 : : target
42813 : : targetsync
42814 : : prefer_type (preference-specification)
42815 : :
42816 : : Returns 'false' if an error has been issued. */
42817 : :
42818 : : static bool
42819 : 369 : cp_parser_omp_clause_init_modifiers (cp_parser *parser, bool *target,
42820 : : bool *targetsync, tree *prefer_type_tree)
42821 : : {
42822 : 369 : *target = false;
42823 : 369 : *targetsync = false;
42824 : 369 : *prefer_type_tree = NULL_TREE;
42825 : :
42826 : 717 : do
42827 : : {
42828 : 543 : cp_token *tok = cp_lexer_peek_token (parser->lexer);
42829 : 543 : if (tok->type != CPP_NAME)
42830 : 0 : goto fail;
42831 : 543 : const char *p = IDENTIFIER_POINTER (tok->u.value);
42832 : 543 : if (strcmp ("targetsync", p) == 0)
42833 : : {
42834 : 159 : if (*targetsync)
42835 : 6 : error_at (tok->location, "duplicate %<targetsync%> modifier");
42836 : 159 : *targetsync = true;
42837 : 159 : cp_lexer_consume_token (parser->lexer);
42838 : : }
42839 : 384 : else if (strcmp ("target", p) == 0)
42840 : : {
42841 : 147 : if (*target)
42842 : 6 : error_at (tok->location, "duplicate %<target%> modifier");
42843 : 147 : *target = true;
42844 : 147 : cp_lexer_consume_token (parser->lexer);
42845 : : }
42846 : 237 : else if (strcmp ("prefer_type", p) == 0)
42847 : : {
42848 : 234 : if (*prefer_type_tree != NULL_TREE)
42849 : 3 : error_at (tok->location, "duplicate %<prefer_type%> modifier");
42850 : 234 : cp_lexer_consume_token (parser->lexer);
42851 : 234 : *prefer_type_tree = cp_parser_omp_modifier_prefer_type (parser);
42852 : 234 : if (*prefer_type_tree == error_mark_node)
42853 : : return false;
42854 : : }
42855 : : else
42856 : 3 : goto fail;
42857 : 483 : tok = cp_lexer_peek_token (parser->lexer);
42858 : 483 : if (tok->type == CPP_COMMA)
42859 : : {
42860 : 174 : cp_lexer_consume_token (parser->lexer);
42861 : 174 : continue;
42862 : : }
42863 : : /* Unknown token - either done or an error; handle it in the caller. */
42864 : : return true;
42865 : 174 : }
42866 : : while (true);
42867 : :
42868 : 3 : fail:
42869 : 3 : cp_parser_error (parser, "%<init%> clause with modifier other than "
42870 : : "%<prefer_type%>, %<target%> or %<targetsync%>");
42871 : 3 : return false;
42872 : : }
42873 : :
42874 : : /* OpenMP 5.1:
42875 : : init ( [init-modifier-list : ] variable-list )
42876 : :
42877 : : Modifiers:
42878 : : target
42879 : : targetsync
42880 : : prefer_type (preference-specification) */
42881 : :
42882 : : static tree
42883 : 357 : cp_parser_omp_clause_init (cp_parser *parser, tree list)
42884 : : {
42885 : 357 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
42886 : : return list;
42887 : :
42888 : : unsigned raw_pos = 1;
42889 : 522 : while (cp_lexer_peek_nth_token (parser->lexer, raw_pos)->type == CPP_NAME)
42890 : : {
42891 : 516 : raw_pos++;
42892 : 516 : if (cp_lexer_peek_nth_token (parser->lexer, raw_pos)->type
42893 : : == CPP_OPEN_PAREN)
42894 : : {
42895 : 195 : unsigned n = cp_parser_skip_balanced_tokens (parser, raw_pos);
42896 : 195 : if (n == raw_pos)
42897 : : {
42898 : : raw_pos = 0;
42899 : : break;
42900 : : }
42901 : : raw_pos = n;
42902 : : }
42903 : 507 : if (cp_lexer_peek_nth_token (parser->lexer, raw_pos)->type == CPP_COLON)
42904 : : break;
42905 : 258 : if (cp_lexer_peek_nth_token (parser->lexer, raw_pos)->type != CPP_COMMA)
42906 : : {
42907 : : raw_pos = 0;
42908 : : break;
42909 : : }
42910 : 165 : raw_pos++;
42911 : : }
42912 : :
42913 : 357 : bool target = false;
42914 : 357 : bool targetsync = false;
42915 : 357 : tree prefer_type_tree = NULL_TREE;
42916 : :
42917 : 357 : if (raw_pos > 1
42918 : 357 : && (!cp_parser_omp_clause_init_modifiers (parser, &target, &targetsync,
42919 : : &prefer_type_tree)
42920 : 189 : || !cp_parser_require (parser, CPP_COLON, RT_COLON)))
42921 : : {
42922 : 60 : if (prefer_type_tree == error_mark_node)
42923 : : return error_mark_node;
42924 : 3 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
42925 : : /*or_comma=*/false,
42926 : : /*consume_paren=*/true);
42927 : 3 : return list;
42928 : : }
42929 : :
42930 : 297 : tree nl = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_INIT, list,
42931 : : NULL, false);
42932 : 696 : for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
42933 : : {
42934 : 399 : if (target)
42935 : 114 : OMP_CLAUSE_INIT_TARGET (c) = 1;
42936 : 399 : if (targetsync)
42937 : 132 : OMP_CLAUSE_INIT_TARGETSYNC (c) = 1;
42938 : 399 : if (prefer_type_tree)
42939 : 144 : OMP_CLAUSE_INIT_PREFER_TYPE (c) = prefer_type_tree;
42940 : : }
42941 : : return nl;
42942 : : }
42943 : :
42944 : : /* OpenACC:
42945 : : async [( int-expr )] */
42946 : :
42947 : : static tree
42948 : 375 : cp_parser_oacc_clause_async (cp_parser *parser, tree list)
42949 : : {
42950 : 375 : tree c, t;
42951 : 375 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
42952 : :
42953 : 375 : t = build_int_cst (integer_type_node, GOMP_ASYNC_NOVAL);
42954 : :
42955 : 375 : if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
42956 : : {
42957 : 262 : matching_parens parens;
42958 : 262 : parens.consume_open (parser);
42959 : :
42960 : 262 : t = cp_parser_assignment_expression (parser);
42961 : 262 : if (t == error_mark_node
42962 : 509 : || !parens.require_close (parser))
42963 : 57 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
42964 : : /*or_comma=*/false,
42965 : : /*consume_paren=*/true);
42966 : : }
42967 : :
42968 : 375 : check_no_duplicate_clause (list, OMP_CLAUSE_ASYNC, "async", loc);
42969 : :
42970 : 375 : c = build_omp_clause (loc, OMP_CLAUSE_ASYNC);
42971 : 375 : OMP_CLAUSE_ASYNC_EXPR (c) = t;
42972 : 375 : OMP_CLAUSE_CHAIN (c) = list;
42973 : 375 : list = c;
42974 : :
42975 : 375 : return list;
42976 : : }
42977 : :
42978 : : /* OpenACC 2.7:
42979 : : self [( expression )] */
42980 : :
42981 : : static tree
42982 : 90 : cp_parser_oacc_compute_clause_self (cp_parser *parser, tree list)
42983 : : {
42984 : 90 : tree t;
42985 : 90 : location_t location = cp_lexer_peek_token (parser->lexer)->location;
42986 : 90 : if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
42987 : : {
42988 : 72 : matching_parens parens;
42989 : 72 : parens.consume_open (parser);
42990 : 72 : t = cp_parser_assignment_expression (parser);
42991 : 72 : if (t == error_mark_node
42992 : 144 : || !parens.require_close (parser))
42993 : : {
42994 : 0 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
42995 : : /*or_comma=*/false,
42996 : : /*consume_paren=*/true);
42997 : 0 : return list;
42998 : : }
42999 : : }
43000 : : else
43001 : 18 : t = truthvalue_true_node;
43002 : :
43003 : 120 : for (tree c = list; c; c = OMP_CLAUSE_CHAIN (c))
43004 : 48 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SELF)
43005 : : {
43006 : 18 : error_at (location, "too many %<self%> clauses");
43007 : 18 : return list;
43008 : : }
43009 : :
43010 : 72 : tree c = build_omp_clause (location, OMP_CLAUSE_SELF);
43011 : 72 : OMP_CLAUSE_SELF_EXPR (c) = t;
43012 : 72 : OMP_CLAUSE_CHAIN (c) = list;
43013 : 72 : return c;
43014 : : }
43015 : :
43016 : : /* Parse all OpenACC clauses. The set clauses allowed by the directive
43017 : : is a bitmask in MASK. Return the list of clauses found. */
43018 : :
43019 : : static tree
43020 : 10273 : cp_parser_oacc_all_clauses (cp_parser *parser, omp_clause_mask mask,
43021 : : const char *where, cp_token *pragma_tok,
43022 : : bool finish_p = true, bool target_p = false)
43023 : : {
43024 : 10273 : tree clauses = NULL;
43025 : 10273 : bool first = true;
43026 : :
43027 : : /* Don't create location wrapper nodes within OpenACC clauses. */
43028 : 10273 : auto_suppress_location_wrappers sentinel;
43029 : :
43030 : 23362 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
43031 : : {
43032 : 13116 : location_t here;
43033 : 13116 : pragma_omp_clause c_kind;
43034 : 13116 : omp_clause_code code;
43035 : 13116 : const char *c_name;
43036 : 13116 : tree prev = clauses;
43037 : :
43038 : 13116 : if (!first && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
43039 : 0 : cp_lexer_consume_token (parser->lexer);
43040 : :
43041 : 13116 : here = cp_lexer_peek_token (parser->lexer)->location;
43042 : 13116 : c_kind = cp_parser_omp_clause_name (parser);
43043 : :
43044 : 13116 : switch (c_kind)
43045 : : {
43046 : 375 : case PRAGMA_OACC_CLAUSE_ASYNC:
43047 : 375 : clauses = cp_parser_oacc_clause_async (parser, clauses);
43048 : 375 : c_name = "async";
43049 : 375 : break;
43050 : 259 : case PRAGMA_OACC_CLAUSE_AUTO:
43051 : 259 : clauses = cp_parser_oacc_simple_clause (here, OMP_CLAUSE_AUTO,
43052 : : clauses);
43053 : 259 : c_name = "auto";
43054 : 259 : break;
43055 : 100 : case PRAGMA_OACC_CLAUSE_ATTACH:
43056 : 100 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43057 : 100 : c_name = "attach";
43058 : 100 : break;
43059 : 97 : case PRAGMA_OACC_CLAUSE_COLLAPSE:
43060 : 97 : clauses = cp_parser_omp_clause_collapse (parser, clauses, here);
43061 : 97 : c_name = "collapse";
43062 : 97 : break;
43063 : 1205 : case PRAGMA_OACC_CLAUSE_COPY:
43064 : 1205 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43065 : 1205 : c_name = "copy";
43066 : 1205 : break;
43067 : 744 : case PRAGMA_OACC_CLAUSE_COPYIN:
43068 : 744 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43069 : 744 : c_name = "copyin";
43070 : 744 : break;
43071 : 902 : case PRAGMA_OACC_CLAUSE_COPYOUT:
43072 : 902 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43073 : 902 : c_name = "copyout";
43074 : 902 : break;
43075 : 235 : case PRAGMA_OACC_CLAUSE_CREATE:
43076 : 235 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43077 : 235 : c_name = "create";
43078 : 235 : break;
43079 : 143 : case PRAGMA_OACC_CLAUSE_DELETE:
43080 : 143 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43081 : 143 : c_name = "delete";
43082 : 143 : break;
43083 : 161 : case PRAGMA_OMP_CLAUSE_DEFAULT:
43084 : 161 : clauses = cp_parser_omp_clause_default (parser, clauses, here, true);
43085 : 161 : c_name = "default";
43086 : 161 : break;
43087 : 88 : case PRAGMA_OACC_CLAUSE_DETACH:
43088 : 88 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43089 : 88 : c_name = "detach";
43090 : 88 : break;
43091 : 68 : case PRAGMA_OACC_CLAUSE_DEVICE:
43092 : 68 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43093 : 68 : c_name = "device";
43094 : 68 : break;
43095 : 87 : case PRAGMA_OACC_CLAUSE_DEVICEPTR:
43096 : 87 : clauses = cp_parser_oacc_data_clause_deviceptr (parser, clauses);
43097 : 87 : c_name = "deviceptr";
43098 : 87 : break;
43099 : 43 : case PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT:
43100 : 43 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43101 : 43 : c_name = "device_resident";
43102 : 43 : break;
43103 : 36 : case PRAGMA_OACC_CLAUSE_FINALIZE:
43104 : 36 : clauses = cp_parser_oacc_simple_clause (here, OMP_CLAUSE_FINALIZE,
43105 : : clauses);
43106 : 36 : c_name = "finalize";
43107 : 36 : break;
43108 : 347 : case PRAGMA_OACC_CLAUSE_FIRSTPRIVATE:
43109 : 347 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE,
43110 : : clauses);
43111 : 347 : c_name = "firstprivate";
43112 : 347 : break;
43113 : 1181 : case PRAGMA_OACC_CLAUSE_GANG:
43114 : 1181 : c_name = "gang";
43115 : 1181 : clauses = cp_parser_oacc_shape_clause (parser, here, OMP_CLAUSE_GANG,
43116 : : c_name, clauses);
43117 : 1181 : break;
43118 : 89 : case PRAGMA_OACC_CLAUSE_HOST:
43119 : 89 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43120 : 89 : c_name = "host";
43121 : 89 : break;
43122 : 159 : case PRAGMA_OACC_CLAUSE_IF:
43123 : 159 : clauses = cp_parser_omp_clause_if (parser, clauses, here, false);
43124 : 159 : c_name = "if";
43125 : 159 : break;
43126 : 50 : case PRAGMA_OACC_CLAUSE_IF_PRESENT:
43127 : 50 : clauses = cp_parser_oacc_simple_clause (here, OMP_CLAUSE_IF_PRESENT,
43128 : : clauses);
43129 : 50 : c_name = "if_present";
43130 : 50 : break;
43131 : 77 : case PRAGMA_OACC_CLAUSE_INDEPENDENT:
43132 : 77 : clauses = cp_parser_oacc_simple_clause (here, OMP_CLAUSE_INDEPENDENT,
43133 : : clauses);
43134 : 77 : c_name = "independent";
43135 : 77 : break;
43136 : 39 : case PRAGMA_OACC_CLAUSE_LINK:
43137 : 39 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43138 : 39 : c_name = "link";
43139 : 39 : break;
43140 : 14 : case PRAGMA_OACC_CLAUSE_NO_CREATE:
43141 : 14 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43142 : 14 : c_name = "no_create";
43143 : 14 : break;
43144 : 74 : case PRAGMA_OACC_CLAUSE_NOHOST:
43145 : 74 : clauses = cp_parser_oacc_simple_clause (here, OMP_CLAUSE_NOHOST,
43146 : : clauses);
43147 : 74 : c_name = "nohost";
43148 : 74 : break;
43149 : 436 : case PRAGMA_OACC_CLAUSE_NUM_GANGS:
43150 : 436 : code = OMP_CLAUSE_NUM_GANGS;
43151 : 436 : c_name = "num_gangs";
43152 : 436 : clauses = cp_parser_oacc_single_int_clause (parser, code, c_name,
43153 : : clauses);
43154 : 436 : break;
43155 : 321 : case PRAGMA_OACC_CLAUSE_NUM_WORKERS:
43156 : 321 : c_name = "num_workers";
43157 : 321 : code = OMP_CLAUSE_NUM_WORKERS;
43158 : 321 : clauses = cp_parser_oacc_single_int_clause (parser, code, c_name,
43159 : : clauses);
43160 : 321 : break;
43161 : 210 : case PRAGMA_OACC_CLAUSE_PRESENT:
43162 : 210 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43163 : 210 : c_name = "present";
43164 : 210 : break;
43165 : 102 : case PRAGMA_OACC_CLAUSE_PRIVATE:
43166 : 102 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE,
43167 : : clauses);
43168 : 102 : c_name = "private";
43169 : 102 : break;
43170 : 1607 : case PRAGMA_OACC_CLAUSE_REDUCTION:
43171 : 1607 : clauses
43172 : 1607 : = cp_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
43173 : : false, clauses);
43174 : 1607 : c_name = "reduction";
43175 : 1607 : break;
43176 : 134 : case PRAGMA_OACC_CLAUSE_SELF:
43177 : 134 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST)) == 0)
43178 : : /* OpenACC compute construct */
43179 : 90 : clauses = cp_parser_oacc_compute_clause_self (parser, clauses);
43180 : : else
43181 : : /* OpenACC 'update' directive */
43182 : 44 : clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
43183 : : c_name = "self";
43184 : : break;
43185 : 737 : case PRAGMA_OACC_CLAUSE_SEQ:
43186 : 737 : clauses = cp_parser_oacc_simple_clause (here, OMP_CLAUSE_SEQ,
43187 : : clauses);
43188 : 737 : c_name = "seq";
43189 : 737 : break;
43190 : 319 : case PRAGMA_OACC_CLAUSE_TILE:
43191 : 319 : clauses = cp_parser_oacc_clause_tile (parser, here, clauses);
43192 : 319 : c_name = "tile";
43193 : 319 : break;
43194 : 55 : case PRAGMA_OACC_CLAUSE_USE_DEVICE:
43195 : 55 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_USE_DEVICE_PTR,
43196 : : clauses);
43197 : 55 : c_name = "use_device";
43198 : 55 : break;
43199 : 1107 : case PRAGMA_OACC_CLAUSE_VECTOR:
43200 : 1107 : c_name = "vector";
43201 : 1107 : clauses = cp_parser_oacc_shape_clause (parser, here,
43202 : : OMP_CLAUSE_VECTOR,
43203 : : c_name, clauses);
43204 : 1107 : break;
43205 : 328 : case PRAGMA_OACC_CLAUSE_VECTOR_LENGTH:
43206 : 328 : c_name = "vector_length";
43207 : 328 : code = OMP_CLAUSE_VECTOR_LENGTH;
43208 : 328 : clauses = cp_parser_oacc_single_int_clause (parser, code, c_name,
43209 : : clauses);
43210 : 328 : break;
43211 : 177 : case PRAGMA_OACC_CLAUSE_WAIT:
43212 : 177 : clauses = cp_parser_oacc_clause_wait (parser, clauses);
43213 : 177 : c_name = "wait";
43214 : 177 : break;
43215 : 983 : case PRAGMA_OACC_CLAUSE_WORKER:
43216 : 983 : c_name = "worker";
43217 : 983 : clauses = cp_parser_oacc_shape_clause (parser, here,
43218 : : OMP_CLAUSE_WORKER,
43219 : : c_name, clauses);
43220 : 983 : break;
43221 : 27 : default:
43222 : 27 : cp_parser_error (parser, "expected an OpenACC clause");
43223 : 27 : goto saw_error;
43224 : : }
43225 : :
43226 : 13089 : first = false;
43227 : :
43228 : 13089 : if (((mask >> c_kind) & 1) == 0)
43229 : : {
43230 : : /* Remove the invalid clause(s) from the list to avoid
43231 : : confusing the rest of the compiler. */
43232 : 66 : clauses = prev;
43233 : 66 : error_at (here, "%qs is not valid for %qs", c_name, where);
43234 : : }
43235 : : }
43236 : :
43237 : 10246 : saw_error:
43238 : 10273 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
43239 : :
43240 : 10273 : if (finish_p)
43241 : 15476 : return finish_omp_clauses (clauses, target_p ? C_ORT_ACC_TARGET
43242 : 9192 : : C_ORT_ACC);
43243 : :
43244 : : return clauses;
43245 : : }
43246 : :
43247 : : /* Parse all OpenMP clauses. The set clauses allowed by the directive
43248 : : is a bitmask in MASK. Return the list of clauses found.
43249 : : FINISH_P set if finish_omp_clauses should be called.
43250 : : NESTED non-zero if clauses should be terminated by closing paren instead
43251 : : of end of pragma. If it is 2, additionally commas are required in between
43252 : : the clauses. */
43253 : :
43254 : : static tree
43255 : 33757 : cp_parser_omp_all_clauses (cp_parser *parser, omp_clause_mask mask,
43256 : : const char *where, cp_token *pragma_tok,
43257 : : bool finish_p = true, int nested = 0)
43258 : : {
43259 : 33757 : tree clauses = NULL;
43260 : 33757 : bool first = true;
43261 : 33757 : cp_token *token = NULL;
43262 : :
43263 : : /* Don't create location wrapper nodes within OpenMP clauses. */
43264 : 33757 : auto_suppress_location_wrappers sentinel;
43265 : :
43266 : 85215 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
43267 : : {
43268 : 51664 : pragma_omp_clause c_kind;
43269 : 51664 : const char *c_name;
43270 : 51664 : tree prev = clauses;
43271 : :
43272 : 51664 : if (nested && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
43273 : : break;
43274 : :
43275 : 51616 : if (!first || nested != 2)
43276 : : {
43277 : 51565 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
43278 : 7953 : cp_lexer_consume_token (parser->lexer);
43279 : 43612 : else if (nested == 2)
43280 : 9 : error_at (cp_lexer_peek_token (parser->lexer)->location,
43281 : : "clauses in %<simd%> trait should be separated "
43282 : : "by %<,%>");
43283 : : }
43284 : :
43285 : 51616 : token = cp_lexer_peek_token (parser->lexer);
43286 : 51616 : c_kind = cp_parser_omp_clause_name (parser);
43287 : :
43288 : 51616 : switch (c_kind)
43289 : : {
43290 : 355 : case PRAGMA_OMP_CLAUSE_BIND:
43291 : 355 : clauses = cp_parser_omp_clause_bind (parser, clauses,
43292 : : token->location);
43293 : 355 : c_name = "bind";
43294 : 355 : break;
43295 : 4156 : case PRAGMA_OMP_CLAUSE_COLLAPSE:
43296 : 4156 : clauses = cp_parser_omp_clause_collapse (parser, clauses,
43297 : : token->location);
43298 : 4156 : c_name = "collapse";
43299 : 4156 : break;
43300 : 286 : case PRAGMA_OMP_CLAUSE_COPYIN:
43301 : 286 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYIN, clauses);
43302 : 286 : c_name = "copyin";
43303 : 286 : break;
43304 : 68 : case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
43305 : 68 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYPRIVATE,
43306 : : clauses);
43307 : 68 : c_name = "copyprivate";
43308 : 68 : break;
43309 : 1829 : case PRAGMA_OMP_CLAUSE_DEFAULT:
43310 : 1829 : clauses = cp_parser_omp_clause_default (parser, clauses,
43311 : : token->location, false);
43312 : 1829 : c_name = "default";
43313 : 1829 : break;
43314 : 177 : case PRAGMA_OMP_CLAUSE_FILTER:
43315 : 177 : clauses = cp_parser_omp_clause_filter (parser, clauses,
43316 : : token->location);
43317 : 177 : c_name = "filter";
43318 : 177 : break;
43319 : 280 : case PRAGMA_OMP_CLAUSE_FINAL:
43320 : 280 : clauses = cp_parser_omp_clause_final (parser, clauses, token->location);
43321 : 280 : c_name = "final";
43322 : 280 : break;
43323 : 1732 : case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
43324 : 1732 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE,
43325 : : clauses);
43326 : 1732 : c_name = "firstprivate";
43327 : 1732 : break;
43328 : 163 : case PRAGMA_OMP_CLAUSE_GRAINSIZE:
43329 : 163 : clauses = cp_parser_omp_clause_grainsize (parser, clauses,
43330 : : token->location);
43331 : 163 : c_name = "grainsize";
43332 : 163 : break;
43333 : 63 : case PRAGMA_OMP_CLAUSE_HINT:
43334 : 63 : clauses = cp_parser_omp_clause_hint (parser, clauses,
43335 : : token->location);
43336 : 63 : c_name = "hint";
43337 : 63 : break;
43338 : 640 : case PRAGMA_OMP_CLAUSE_DEFAULTMAP:
43339 : 640 : clauses = cp_parser_omp_clause_defaultmap (parser, clauses,
43340 : : token->location);
43341 : 640 : c_name = "defaultmap";
43342 : 640 : break;
43343 : 28 : case PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR:
43344 : 28 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_USE_DEVICE_PTR,
43345 : : clauses);
43346 : 28 : c_name = "use_device_ptr";
43347 : 28 : break;
43348 : 69 : case PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR:
43349 : 69 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_USE_DEVICE_ADDR,
43350 : : clauses);
43351 : 69 : c_name = "use_device_addr";
43352 : 69 : break;
43353 : 276 : case PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR:
43354 : 276 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_IS_DEVICE_PTR,
43355 : : clauses);
43356 : 276 : c_name = "is_device_ptr";
43357 : 276 : break;
43358 : 257 : case PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR:
43359 : 257 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_HAS_DEVICE_ADDR,
43360 : : clauses);
43361 : 257 : c_name = "has_device_addr";
43362 : 257 : break;
43363 : 1827 : case PRAGMA_OMP_CLAUSE_IF:
43364 : 1827 : clauses = cp_parser_omp_clause_if (parser, clauses, token->location,
43365 : : true);
43366 : 1827 : c_name = "if";
43367 : 1827 : break;
43368 : 785 : case PRAGMA_OMP_CLAUSE_IN_REDUCTION:
43369 : 785 : clauses
43370 : 785 : = cp_parser_omp_clause_reduction (parser, OMP_CLAUSE_IN_REDUCTION,
43371 : : true, clauses);
43372 : 785 : c_name = "in_reduction";
43373 : 785 : break;
43374 : 85 : case PRAGMA_OMP_CLAUSE_INDIRECT:
43375 : 85 : clauses = cp_parser_omp_clause_indirect (parser, clauses,
43376 : : token->location);
43377 : 85 : c_name = "indirect";
43378 : 85 : break;
43379 : 1487 : case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
43380 : 1487 : clauses = cp_parser_omp_clause_lastprivate (parser, clauses);
43381 : 1487 : c_name = "lastprivate";
43382 : 1487 : break;
43383 : 228 : case PRAGMA_OMP_CLAUSE_MERGEABLE:
43384 : 228 : clauses = cp_parser_omp_clause_mergeable (parser, clauses,
43385 : : token->location);
43386 : 228 : c_name = "mergeable";
43387 : 228 : break;
43388 : 600 : case PRAGMA_OMP_CLAUSE_NOWAIT:
43389 : 600 : clauses = cp_parser_omp_clause_nowait (parser, clauses,
43390 : : token->location);
43391 : 600 : c_name = "nowait";
43392 : 600 : break;
43393 : 132 : case PRAGMA_OMP_CLAUSE_NUM_TASKS:
43394 : 132 : clauses = cp_parser_omp_clause_num_tasks (parser, clauses,
43395 : : token->location);
43396 : 132 : c_name = "num_tasks";
43397 : 132 : break;
43398 : 776 : case PRAGMA_OMP_CLAUSE_NUM_THREADS:
43399 : 776 : clauses = cp_parser_omp_clause_num_threads (parser, clauses,
43400 : : token->location);
43401 : 776 : c_name = "num_threads";
43402 : 776 : break;
43403 : 1106 : case PRAGMA_OMP_CLAUSE_ORDER:
43404 : 1106 : clauses = cp_parser_omp_clause_order (parser, clauses,
43405 : : token->location);
43406 : 1106 : c_name = "order";
43407 : 1106 : break;
43408 : 633 : case PRAGMA_OMP_CLAUSE_ORDERED:
43409 : 633 : clauses = cp_parser_omp_clause_ordered (parser, clauses,
43410 : : token->location);
43411 : 633 : c_name = "ordered";
43412 : 633 : break;
43413 : 273 : case PRAGMA_OMP_CLAUSE_PRIORITY:
43414 : 273 : clauses = cp_parser_omp_clause_priority (parser, clauses,
43415 : : token->location);
43416 : 273 : c_name = "priority";
43417 : 273 : break;
43418 : 1684 : case PRAGMA_OMP_CLAUSE_PRIVATE:
43419 : 1684 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE,
43420 : : clauses);
43421 : 1684 : c_name = "private";
43422 : 1684 : break;
43423 : 3132 : case PRAGMA_OMP_CLAUSE_REDUCTION:
43424 : 3132 : clauses
43425 : 3132 : = cp_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
43426 : : true, clauses);
43427 : 3132 : c_name = "reduction";
43428 : 3132 : break;
43429 : 3799 : case PRAGMA_OMP_CLAUSE_SCHEDULE:
43430 : 3799 : clauses = cp_parser_omp_clause_schedule (parser, clauses,
43431 : : token->location);
43432 : 3799 : c_name = "schedule";
43433 : 3799 : break;
43434 : 1322 : case PRAGMA_OMP_CLAUSE_SHARED:
43435 : 1322 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_SHARED,
43436 : : clauses);
43437 : 1322 : c_name = "shared";
43438 : 1322 : break;
43439 : 223 : case PRAGMA_OMP_CLAUSE_TASK_REDUCTION:
43440 : 223 : clauses
43441 : 223 : = cp_parser_omp_clause_reduction (parser,
43442 : : OMP_CLAUSE_TASK_REDUCTION,
43443 : : true, clauses);
43444 : 223 : c_name = "task_reduction";
43445 : 223 : break;
43446 : 242 : case PRAGMA_OMP_CLAUSE_UNTIED:
43447 : 242 : clauses = cp_parser_omp_clause_untied (parser, clauses,
43448 : : token->location);
43449 : 242 : c_name = "untied";
43450 : 242 : break;
43451 : 129 : case PRAGMA_OMP_CLAUSE_INBRANCH:
43452 : 129 : clauses = cp_parser_omp_clause_branch (parser, OMP_CLAUSE_INBRANCH,
43453 : : clauses, token->location);
43454 : 129 : c_name = "inbranch";
43455 : 129 : break;
43456 : 357 : case PRAGMA_OMP_CLAUSE_NONTEMPORAL:
43457 : 357 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_NONTEMPORAL,
43458 : : clauses);
43459 : 357 : c_name = "nontemporal";
43460 : 357 : break;
43461 : 446 : case PRAGMA_OMP_CLAUSE_NOTINBRANCH:
43462 : 446 : clauses = cp_parser_omp_clause_branch (parser,
43463 : : OMP_CLAUSE_NOTINBRANCH,
43464 : : clauses, token->location);
43465 : 446 : c_name = "notinbranch";
43466 : 446 : break;
43467 : 310 : case PRAGMA_OMP_CLAUSE_PARALLEL:
43468 : 310 : clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_PARALLEL,
43469 : : clauses, token->location);
43470 : 310 : c_name = "parallel";
43471 : 310 : if (!first)
43472 : : {
43473 : 0 : clause_not_first:
43474 : 0 : error_at (token->location, "%qs must be the first clause of %qs",
43475 : : c_name, where);
43476 : 0 : clauses = prev;
43477 : : }
43478 : : break;
43479 : 234 : case PRAGMA_OMP_CLAUSE_FOR:
43480 : 234 : clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_FOR,
43481 : : clauses, token->location);
43482 : 234 : c_name = "for";
43483 : 234 : if (!first)
43484 : 0 : goto clause_not_first;
43485 : : break;
43486 : 226 : case PRAGMA_OMP_CLAUSE_SECTIONS:
43487 : 226 : clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_SECTIONS,
43488 : : clauses, token->location);
43489 : 226 : c_name = "sections";
43490 : 226 : if (!first)
43491 : 0 : goto clause_not_first;
43492 : : break;
43493 : 317 : case PRAGMA_OMP_CLAUSE_TASKGROUP:
43494 : 317 : clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_TASKGROUP,
43495 : : clauses, token->location);
43496 : 317 : c_name = "taskgroup";
43497 : 317 : if (!first)
43498 : 0 : goto clause_not_first;
43499 : : break;
43500 : 74 : case PRAGMA_OMP_CLAUSE_LINK:
43501 : 74 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LINK, clauses);
43502 : 74 : c_name = "link";
43503 : 74 : break;
43504 : 695 : case PRAGMA_OMP_CLAUSE_TO:
43505 : 695 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK)) != 0)
43506 : : {
43507 : 228 : tree nl = cp_parser_omp_var_list (parser, OMP_CLAUSE_ENTER,
43508 : : clauses);
43509 : 501 : for (tree c = nl; c != clauses; c = OMP_CLAUSE_CHAIN (c))
43510 : 273 : OMP_CLAUSE_ENTER_TO (c) = 1;
43511 : : clauses = nl;
43512 : : }
43513 : : else
43514 : 467 : clauses = cp_parser_omp_clause_from_to (parser, OMP_CLAUSE_TO,
43515 : : clauses);
43516 : : c_name = "to";
43517 : : break;
43518 : 2472 : case PRAGMA_OMP_CLAUSE_FROM:
43519 : 2472 : clauses = cp_parser_omp_clause_from_to (parser, OMP_CLAUSE_FROM,
43520 : : clauses);
43521 : 2472 : c_name = "from";
43522 : 2472 : break;
43523 : 353 : case PRAGMA_OMP_CLAUSE_UNIFORM:
43524 : 353 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_UNIFORM,
43525 : : clauses);
43526 : 353 : c_name = "uniform";
43527 : 353 : break;
43528 : 602 : case PRAGMA_OMP_CLAUSE_NUM_TEAMS:
43529 : 602 : clauses = cp_parser_omp_clause_num_teams (parser, clauses,
43530 : : token->location);
43531 : 602 : c_name = "num_teams";
43532 : 602 : break;
43533 : 412 : case PRAGMA_OMP_CLAUSE_THREAD_LIMIT:
43534 : 412 : clauses = cp_parser_omp_clause_thread_limit (parser, clauses,
43535 : : token->location);
43536 : 412 : c_name = "thread_limit";
43537 : 412 : break;
43538 : 702 : case PRAGMA_OMP_CLAUSE_ALIGNED:
43539 : 702 : clauses = cp_parser_omp_clause_aligned (parser, clauses);
43540 : 702 : c_name = "aligned";
43541 : 702 : break;
43542 : 1461 : case PRAGMA_OMP_CLAUSE_ALLOCATE:
43543 : 1461 : clauses = cp_parser_omp_clause_allocate (parser, clauses);
43544 : 1461 : c_name = "allocate";
43545 : 1461 : break;
43546 : 1473 : case PRAGMA_OMP_CLAUSE_LINEAR:
43547 : 1473 : {
43548 : 1473 : bool declare_simd = false;
43549 : 1473 : if (((mask >> PRAGMA_OMP_CLAUSE_UNIFORM) & 1) != 0)
43550 : : declare_simd = true;
43551 : 1473 : clauses = cp_parser_omp_clause_linear (parser, clauses, declare_simd);
43552 : : }
43553 : 1473 : c_name = "linear";
43554 : 1473 : break;
43555 : 462 : case PRAGMA_OMP_CLAUSE_AFFINITY:
43556 : 462 : clauses = cp_parser_omp_clause_affinity (parser, clauses);
43557 : 462 : c_name = "affinity";
43558 : 462 : break;
43559 : 1695 : case PRAGMA_OMP_CLAUSE_DEPEND:
43560 : 1695 : clauses = cp_parser_omp_clause_depend (parser, clauses,
43561 : : token->location);
43562 : 1695 : c_name = "depend";
43563 : 1695 : break;
43564 : 219 : case PRAGMA_OMP_CLAUSE_DOACROSS:
43565 : 219 : clauses = cp_parser_omp_clause_doacross (parser, clauses,
43566 : : token->location);
43567 : 219 : c_name = "doacross";
43568 : 219 : break;
43569 : 87 : case PRAGMA_OMP_CLAUSE_DESTROY:
43570 : 87 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_DESTROY,
43571 : : clauses);
43572 : 87 : c_name = "destroy";
43573 : 87 : break;
43574 : 357 : case PRAGMA_OMP_CLAUSE_INIT:
43575 : 357 : {
43576 : : /* prefer_type parsing fails often such that many follow-up errors
43577 : : are printed and recovery by cp_parser_skip_to_closing_parenthesis
43578 : : will might skip to EOF, leading to an ICE elsewhere. */
43579 : 357 : tree nc = cp_parser_omp_clause_init (parser, clauses);
43580 : 357 : if (nc == error_mark_node)
43581 : 57 : goto saw_error;
43582 : : clauses = nc;
43583 : : }
43584 : : c_name = "init";
43585 : : break;
43586 : 93 : case PRAGMA_OMP_CLAUSE_USE:
43587 : 93 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_USE, clauses);
43588 : 93 : c_name = "use";
43589 : 93 : break;
43590 : 96 : case PRAGMA_OMP_CLAUSE_INTEROP:
43591 : 96 : clauses = cp_parser_omp_clause_interop (parser, clauses,
43592 : : token->location);
43593 : 96 : c_name = "interop";
43594 : 96 : break;
43595 : 63 : case PRAGMA_OMP_CLAUSE_DETACH:
43596 : 63 : clauses = cp_parser_omp_clause_detach (parser, clauses);
43597 : 63 : c_name = "detach";
43598 : 63 : break;
43599 : 3861 : case PRAGMA_OMP_CLAUSE_MAP:
43600 : 3861 : clauses = cp_parser_omp_clause_map (parser, clauses);
43601 : 3861 : c_name = "map";
43602 : 3861 : break;
43603 : 662 : case PRAGMA_OMP_CLAUSE_DEVICE:
43604 : 662 : clauses = cp_parser_omp_clause_device (parser, clauses,
43605 : : token->location);
43606 : 662 : c_name = "device";
43607 : 662 : break;
43608 : 1839 : case PRAGMA_OMP_CLAUSE_DIST_SCHEDULE:
43609 : 1839 : clauses = cp_parser_omp_clause_dist_schedule (parser, clauses,
43610 : : token->location);
43611 : 1839 : c_name = "dist_schedule";
43612 : 1839 : break;
43613 : 526 : case PRAGMA_OMP_CLAUSE_PROC_BIND:
43614 : 526 : clauses = cp_parser_omp_clause_proc_bind (parser, clauses,
43615 : : token->location);
43616 : 526 : c_name = "proc_bind";
43617 : 526 : break;
43618 : 123 : case PRAGMA_OMP_CLAUSE_DEVICE_TYPE:
43619 : 123 : clauses = cp_parser_omp_clause_device_type (parser, clauses,
43620 : : token->location);
43621 : 123 : c_name = "device_type";
43622 : 123 : break;
43623 : 467 : case PRAGMA_OMP_CLAUSE_SAFELEN:
43624 : 467 : clauses = cp_parser_omp_clause_safelen (parser, clauses,
43625 : : token->location);
43626 : 467 : c_name = "safelen";
43627 : 467 : break;
43628 : 758 : case PRAGMA_OMP_CLAUSE_SIMDLEN:
43629 : 758 : clauses = cp_parser_omp_clause_simdlen (parser, clauses,
43630 : : token->location);
43631 : 758 : c_name = "simdlen";
43632 : 758 : break;
43633 : 41 : case PRAGMA_OMP_CLAUSE_NOGROUP:
43634 : 41 : clauses = cp_parser_omp_clause_nogroup (parser, clauses,
43635 : : token->location);
43636 : 41 : c_name = "nogroup";
43637 : 41 : break;
43638 : 131 : case PRAGMA_OMP_CLAUSE_THREADS:
43639 : 131 : clauses
43640 : 131 : = cp_parser_omp_clause_orderedkind (parser, OMP_CLAUSE_THREADS,
43641 : : clauses, token->location);
43642 : 131 : c_name = "threads";
43643 : 131 : break;
43644 : 168 : case PRAGMA_OMP_CLAUSE_SIMD:
43645 : 168 : clauses
43646 : 168 : = cp_parser_omp_clause_orderedkind (parser, OMP_CLAUSE_SIMD,
43647 : : clauses, token->location);
43648 : 168 : c_name = "simd";
43649 : 168 : break;
43650 : 111 : case PRAGMA_OMP_CLAUSE_ENTER:
43651 : 111 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_ENTER,
43652 : : clauses);
43653 : 111 : c_name = "enter";
43654 : 111 : break;
43655 : 458 : case PRAGMA_OMP_CLAUSE_PARTIAL:
43656 : 458 : clauses = cp_parser_omp_clause_partial (parser, clauses,
43657 : : token->location);
43658 : 458 : c_name = "partial";
43659 : 458 : break;
43660 : 195 : case PRAGMA_OMP_CLAUSE_FULL:
43661 : 195 : clauses = cp_parser_omp_clause_full (clauses, token->location);
43662 : 195 : c_name = "full";
43663 : 195 : break;
43664 : 59 : case PRAGMA_OMP_CLAUSE_NOVARIANTS:
43665 : 59 : clauses = cp_parser_omp_clause_novariants (parser, clauses,
43666 : : token->location);
43667 : 59 : c_name = "novariants";
43668 : 59 : break;
43669 : 68 : case PRAGMA_OMP_CLAUSE_NOCONTEXT:
43670 : 68 : clauses
43671 : 68 : = cp_parser_omp_clause_nocontext (parser, clauses, token->location);
43672 : 68 : c_name = "nocontext";
43673 : 68 : break;
43674 : 101 : default:
43675 : 101 : cp_parser_error (parser, "expected an OpenMP clause");
43676 : 101 : goto saw_error;
43677 : : }
43678 : :
43679 : 51458 : first = false;
43680 : :
43681 : 51458 : if (((mask >> c_kind) & 1) == 0)
43682 : : {
43683 : : /* Remove the invalid clause(s) from the list to avoid
43684 : : confusing the rest of the compiler. */
43685 : 81 : clauses = prev;
43686 : 81 : error_at (token->location, "%qs is not valid for %qs", c_name, where);
43687 : : }
43688 : : }
43689 : 33551 : saw_error:
43690 : 33757 : if (!nested)
43691 : 33706 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
43692 : 33757 : if (finish_p)
43693 : : {
43694 : 20980 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM)) != 0)
43695 : 1109 : return finish_omp_clauses (clauses, C_ORT_OMP_DECLARE_SIMD);
43696 : 19871 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE)) != 0)
43697 : 345 : return finish_omp_clauses (clauses, C_ORT_OMP_INTEROP);
43698 : 19526 : return finish_omp_clauses (clauses, C_ORT_OMP);
43699 : : }
43700 : : return clauses;
43701 : : }
43702 : :
43703 : : /* OpenMP 2.5:
43704 : : structured-block:
43705 : : statement
43706 : :
43707 : : In practice, we're also interested in adding the statement to an
43708 : : outer node. So it is convenient if we work around the fact that
43709 : : cp_parser_statement calls add_stmt. */
43710 : :
43711 : : static unsigned
43712 : 53115 : cp_parser_begin_omp_structured_block (cp_parser *parser)
43713 : : {
43714 : 53115 : unsigned save = parser->in_statement;
43715 : :
43716 : : /* Only move the values to IN_OMP_BLOCK if they weren't false.
43717 : : This preserves the "not within loop or switch" style error messages
43718 : : for nonsense cases like
43719 : : void foo() {
43720 : : #pragma omp single
43721 : : break;
43722 : : }
43723 : : */
43724 : 0 : if (parser->in_statement)
43725 : 4063 : parser->in_statement = IN_OMP_BLOCK;
43726 : :
43727 : 53115 : return save;
43728 : : }
43729 : :
43730 : : static void
43731 : 53115 : cp_parser_end_omp_structured_block (cp_parser *parser, unsigned save)
43732 : : {
43733 : 53115 : parser->in_statement = save;
43734 : 0 : }
43735 : :
43736 : : static tree
43737 : 7643 : cp_parser_omp_structured_block (cp_parser *parser, bool *if_p)
43738 : : {
43739 : 7643 : tree stmt = begin_omp_structured_block ();
43740 : 7643 : unsigned int save = cp_parser_begin_omp_structured_block (parser);
43741 : :
43742 : 7643 : parser->omp_attrs_forbidden_p = true;
43743 : 7643 : cp_parser_statement (parser, NULL_TREE, false, if_p);
43744 : :
43745 : 7643 : cp_parser_end_omp_structured_block (parser, save);
43746 : 7643 : return finish_omp_structured_block (stmt);
43747 : : }
43748 : :
43749 : : /* OpenMP 5.x:
43750 : : # pragma omp allocate (list) clauses
43751 : :
43752 : : OpenMP 5.0 clause:
43753 : : allocator (omp_allocator_handle_t expression)
43754 : :
43755 : : OpenMP 5.1 additional clause:
43756 : : align (constant-expression)] */
43757 : :
43758 : : static void
43759 : 120 : cp_parser_omp_allocate (cp_parser *parser, cp_token *pragma_tok)
43760 : : {
43761 : 120 : tree allocator = NULL_TREE;
43762 : 120 : tree alignment = NULL_TREE;
43763 : 120 : location_t loc = pragma_tok->location;
43764 : 120 : tree nl = cp_parser_omp_var_list (parser, OMP_CLAUSE_ALLOCATE, NULL_TREE);
43765 : :
43766 : 432 : do
43767 : : {
43768 : 276 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
43769 : 276 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
43770 : 15 : cp_lexer_consume_token (parser->lexer);
43771 : :
43772 : 276 : if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
43773 : : break;
43774 : 165 : matching_parens parens;
43775 : 165 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
43776 : 165 : const char *p = IDENTIFIER_POINTER (id);
43777 : 165 : location_t cloc = cp_lexer_peek_token (parser->lexer)->location;
43778 : 165 : cp_lexer_consume_token (parser->lexer);
43779 : 165 : if (strcmp (p, "allocator") != 0 && strcmp (p, "align") != 0)
43780 : : {
43781 : 3 : error_at (cloc, "expected %<allocator%> or %<align%>");
43782 : 3 : break;
43783 : : }
43784 : 162 : if (!parens.require_open (parser))
43785 : : break;
43786 : 162 : tree expr = cp_parser_assignment_expression (parser);
43787 : 162 : if (p[2] == 'i' && alignment)
43788 : : {
43789 : 3 : error_at (cloc, "too many %qs clauses", "align");
43790 : 3 : break;
43791 : : }
43792 : 159 : else if (p[2] == 'i')
43793 : : {
43794 : 78 : if (expr != error_mark_node)
43795 : 78 : alignment = expr;
43796 : : /* FIXME: Remove when adding check to semantics.cc; cf FIXME below. */
43797 : 78 : if (alignment
43798 : 78 : && !type_dependent_expression_p (alignment)
43799 : 156 : && !INTEGRAL_TYPE_P (TREE_TYPE (alignment)))
43800 : : {
43801 : 3 : error_at (cloc, "%<align%> clause argument needs to be "
43802 : : "positive constant power of two integer "
43803 : : "expression");
43804 : 3 : alignment = NULL_TREE;
43805 : : }
43806 : 75 : else if (alignment)
43807 : : {
43808 : 75 : alignment = mark_rvalue_use (alignment);
43809 : 75 : if (!processing_template_decl)
43810 : : {
43811 : 75 : alignment = maybe_constant_value (alignment);
43812 : 75 : if (TREE_CODE (alignment) != INTEGER_CST
43813 : 75 : || !tree_fits_uhwi_p (alignment)
43814 : 147 : || !integer_pow2p (alignment))
43815 : : {
43816 : 9 : error_at (cloc, "%<align%> clause argument needs to be "
43817 : : "positive constant power of two integer "
43818 : : "expression");
43819 : 9 : alignment = NULL_TREE;
43820 : : }
43821 : : }
43822 : : }
43823 : : }
43824 : 81 : else if (allocator)
43825 : : {
43826 : 3 : error_at (cloc, "too many %qs clauses", "allocator");
43827 : 3 : break;
43828 : : }
43829 : : else
43830 : : {
43831 : 78 : if (expr != error_mark_node)
43832 : 75 : allocator = expr;
43833 : : }
43834 : 156 : parens.require_close (parser);
43835 : 156 : } while (true);
43836 : 120 : cp_parser_require_pragma_eol (parser, pragma_tok);
43837 : :
43838 : 120 : if (allocator || alignment)
43839 : 165 : for (tree c = nl; c != NULL_TREE; c = OMP_CLAUSE_CHAIN (c))
43840 : : {
43841 : 81 : OMP_CLAUSE_ALLOCATE_ALLOCATOR (c) = allocator;
43842 : 81 : OMP_CLAUSE_ALLOCATE_ALIGN (c) = alignment;
43843 : : }
43844 : :
43845 : : /* FIXME: When implementing properly, delete the align/allocate expr error
43846 : : check above and add one in semantics.cc (to properly handle templates).
43847 : : Base this on the allocator/align modifiers check for the 'allocate' clause
43848 : : in semantics.cc's finish_omp_clauses. */
43849 : 120 : sorry_at (loc, "%<#pragma omp allocate%> not yet supported");
43850 : 120 : }
43851 : :
43852 : : /* OpenMP 2.5:
43853 : : # pragma omp atomic new-line
43854 : : expression-stmt
43855 : :
43856 : : expression-stmt:
43857 : : x binop= expr | x++ | ++x | x-- | --x
43858 : : binop:
43859 : : +, *, -, /, &, ^, |, <<, >>
43860 : :
43861 : : where x is an lvalue expression with scalar type.
43862 : :
43863 : : OpenMP 3.1:
43864 : : # pragma omp atomic new-line
43865 : : update-stmt
43866 : :
43867 : : # pragma omp atomic read new-line
43868 : : read-stmt
43869 : :
43870 : : # pragma omp atomic write new-line
43871 : : write-stmt
43872 : :
43873 : : # pragma omp atomic update new-line
43874 : : update-stmt
43875 : :
43876 : : # pragma omp atomic capture new-line
43877 : : capture-stmt
43878 : :
43879 : : # pragma omp atomic capture new-line
43880 : : capture-block
43881 : :
43882 : : read-stmt:
43883 : : v = x
43884 : : write-stmt:
43885 : : x = expr
43886 : : update-stmt:
43887 : : expression-stmt | x = x binop expr
43888 : : capture-stmt:
43889 : : v = expression-stmt
43890 : : capture-block:
43891 : : { v = x; update-stmt; } | { update-stmt; v = x; }
43892 : :
43893 : : OpenMP 4.0:
43894 : : update-stmt:
43895 : : expression-stmt | x = x binop expr | x = expr binop x
43896 : : capture-stmt:
43897 : : v = update-stmt
43898 : : capture-block:
43899 : : { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
43900 : :
43901 : : OpenMP 5.1:
43902 : : # pragma omp atomic compare new-line
43903 : : conditional-update-atomic
43904 : :
43905 : : # pragma omp atomic compare capture new-line
43906 : : conditional-update-capture-atomic
43907 : :
43908 : : conditional-update-atomic:
43909 : : cond-expr-stmt | cond-update-stmt
43910 : : cond-expr-stmt:
43911 : : x = expr ordop x ? expr : x;
43912 : : x = x ordop expr ? expr : x;
43913 : : x = x == e ? d : x;
43914 : : cond-update-stmt:
43915 : : if (expr ordop x) { x = expr; }
43916 : : if (x ordop expr) { x = expr; }
43917 : : if (x == e) { x = d; }
43918 : : ordop:
43919 : : <, >
43920 : : conditional-update-capture-atomic:
43921 : : v = cond-expr-stmt
43922 : : { v = x; cond-expr-stmt }
43923 : : { cond-expr-stmt v = x; }
43924 : : { v = x; cond-update-stmt }
43925 : : { cond-update-stmt v = x; }
43926 : : if (x == e) { x = d; } else { v = x; }
43927 : : { r = x == e; if (r) { x = d; } }
43928 : : { r = x == e; if (r) { x = d; } else { v = x; } }
43929 : :
43930 : : where x, r and v are lvalue expressions with scalar type,
43931 : : expr, e and d are expressions with scalar type and e might be
43932 : : the same as v. */
43933 : :
43934 : : static void
43935 : 2961 : cp_parser_omp_atomic (cp_parser *parser, cp_token *pragma_tok, bool openacc)
43936 : : {
43937 : 2961 : tree lhs = NULL_TREE, rhs = NULL_TREE, v = NULL_TREE, lhs1 = NULL_TREE;
43938 : 2961 : tree rhs1 = NULL_TREE, orig_lhs, r = NULL_TREE;
43939 : 2961 : location_t loc = pragma_tok->location;
43940 : 2961 : enum tree_code code = ERROR_MARK, opcode = NOP_EXPR;
43941 : 2961 : enum omp_memory_order memory_order = OMP_MEMORY_ORDER_UNSPECIFIED;
43942 : 2961 : bool structured_block = false;
43943 : 2961 : tree clauses = NULL_TREE;
43944 : 2961 : bool capture = false;
43945 : 2961 : bool compare = false;
43946 : 2961 : bool weak = false;
43947 : 2961 : enum omp_memory_order fail = OMP_MEMORY_ORDER_UNSPECIFIED;
43948 : 2961 : bool no_semicolon = false;
43949 : 2961 : bool extra_scope = false;
43950 : :
43951 : 6202 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
43952 : : {
43953 : 3265 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
43954 : 3265 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
43955 : 284 : cp_lexer_consume_token (parser->lexer);
43956 : :
43957 : 3265 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
43958 : : {
43959 : 3259 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
43960 : 3259 : location_t cloc = cp_lexer_peek_token (parser->lexer)->location;
43961 : 3259 : const char *p = IDENTIFIER_POINTER (id);
43962 : 3259 : enum tree_code new_code = ERROR_MARK;
43963 : 3259 : enum omp_memory_order new_memory_order
43964 : : = OMP_MEMORY_ORDER_UNSPECIFIED;
43965 : 3259 : bool new_capture = false;
43966 : 3259 : bool new_compare = false;
43967 : 3259 : bool new_weak = false;
43968 : 3259 : enum omp_memory_order new_fail = OMP_MEMORY_ORDER_UNSPECIFIED;
43969 : :
43970 : 3259 : if (!strcmp (p, "read"))
43971 : : new_code = OMP_ATOMIC_READ;
43972 : 2829 : else if (!strcmp (p, "write"))
43973 : : new_code = NOP_EXPR;
43974 : 2603 : else if (!strcmp (p, "update"))
43975 : : new_code = OMP_ATOMIC;
43976 : 2308 : else if (openacc && !strcmp (p, "capture"))
43977 : : new_code = OMP_ATOMIC_CAPTURE_NEW;
43978 : 12 : else if (openacc)
43979 : : {
43980 : 12 : p = NULL;
43981 : 12 : error_at (cloc, "expected %<read%>, %<write%>, %<update%>, "
43982 : : "or %<capture%> clause");
43983 : : }
43984 : 2047 : else if (!strcmp (p, "capture"))
43985 : : new_capture = true;
43986 : 1418 : else if (!strcmp (p, "compare"))
43987 : : new_compare = true;
43988 : 787 : else if (!strcmp (p, "weak"))
43989 : : new_weak = true;
43990 : 742 : else if (!strcmp (p, "fail"))
43991 : : {
43992 : 117 : matching_parens parens;
43993 : :
43994 : 117 : cp_lexer_consume_token (parser->lexer);
43995 : 117 : if (!parens.require_open (parser))
43996 : 3 : continue;
43997 : :
43998 : 114 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
43999 : : {
44000 : 108 : id = cp_lexer_peek_token (parser->lexer)->u.value;
44001 : 108 : const char *q = IDENTIFIER_POINTER (id);
44002 : :
44003 : 108 : if (!strcmp (q, "seq_cst"))
44004 : : new_fail = OMP_MEMORY_ORDER_SEQ_CST;
44005 : 84 : else if (!strcmp (q, "acquire"))
44006 : : new_fail = OMP_MEMORY_ORDER_ACQUIRE;
44007 : 57 : else if (!strcmp (q, "relaxed"))
44008 : : new_fail = OMP_MEMORY_ORDER_RELAXED;
44009 : : }
44010 : :
44011 : : if (new_fail != OMP_MEMORY_ORDER_UNSPECIFIED)
44012 : : {
44013 : 99 : cp_lexer_consume_token (parser->lexer);
44014 : 99 : if (fail != OMP_MEMORY_ORDER_UNSPECIFIED)
44015 : 6 : error_at (cloc, "too many %qs clauses", "fail");
44016 : : else
44017 : : fail = new_fail;
44018 : : }
44019 : : else
44020 : 15 : cp_parser_error (parser, "expected %<seq_cst%>, %<acquire%> "
44021 : : "or %<relaxed%>");
44022 : 114 : if (new_fail == OMP_MEMORY_ORDER_UNSPECIFIED
44023 : 213 : || !parens.require_close (parser))
44024 : 18 : cp_parser_skip_to_closing_parenthesis (parser,
44025 : : /*recovering=*/true,
44026 : : /*or_comma=*/false,
44027 : : /*consume_paren=*/true);
44028 : 114 : continue;
44029 : 114 : }
44030 : 625 : else if (!strcmp (p, "seq_cst"))
44031 : : new_memory_order = OMP_MEMORY_ORDER_SEQ_CST;
44032 : 402 : else if (!strcmp (p, "acq_rel"))
44033 : : new_memory_order = OMP_MEMORY_ORDER_ACQ_REL;
44034 : 360 : else if (!strcmp (p, "release"))
44035 : : new_memory_order = OMP_MEMORY_ORDER_RELEASE;
44036 : 258 : else if (!strcmp (p, "acquire"))
44037 : : new_memory_order = OMP_MEMORY_ORDER_ACQUIRE;
44038 : 213 : else if (!strcmp (p, "relaxed"))
44039 : : new_memory_order = OMP_MEMORY_ORDER_RELAXED;
44040 : 123 : else if (!strcmp (p, "hint"))
44041 : : {
44042 : 117 : cp_lexer_consume_token (parser->lexer);
44043 : 117 : clauses = cp_parser_omp_clause_hint (parser, clauses, cloc);
44044 : 117 : continue;
44045 : : }
44046 : : else
44047 : : {
44048 : 6 : p = NULL;
44049 : 6 : error_at (cloc, "expected %<read%>, %<write%>, %<update%>, "
44050 : : "%<capture%>, %<compare%>, %<weak%>, %<fail%>, "
44051 : : "%<seq_cst%>, %<acq_rel%>, %<release%>, "
44052 : : "%<relaxed%> or %<hint%> clause");
44053 : : }
44054 : 18 : if (p)
44055 : : {
44056 : 3007 : if (new_code != ERROR_MARK)
44057 : : {
44058 : : /* OpenACC permits 'update capture'. */
44059 : 1200 : if (openacc
44060 : 1200 : && code == OMP_ATOMIC
44061 : 12 : && new_code == OMP_ATOMIC_CAPTURE_NEW)
44062 : : code = new_code;
44063 : 1191 : else if (code != ERROR_MARK)
44064 : 15 : error_at (cloc, "too many atomic clauses");
44065 : : else
44066 : : code = new_code;
44067 : : }
44068 : 1807 : else if (new_memory_order != OMP_MEMORY_ORDER_UNSPECIFIED)
44069 : : {
44070 : 502 : if (memory_order != OMP_MEMORY_ORDER_UNSPECIFIED)
44071 : 105 : error_at (cloc, "too many memory order clauses");
44072 : : else
44073 : : memory_order = new_memory_order;
44074 : : }
44075 : 1305 : else if (new_capture)
44076 : : {
44077 : 629 : if (capture)
44078 : 3 : error_at (cloc, "too many %qs clauses", "capture");
44079 : : else
44080 : : capture = true;
44081 : : }
44082 : 676 : else if (new_compare)
44083 : : {
44084 : 631 : if (compare)
44085 : 3 : error_at (cloc, "too many %qs clauses", "compare");
44086 : : else
44087 : : compare = true;
44088 : : }
44089 : 45 : else if (new_weak)
44090 : : {
44091 : 45 : if (weak)
44092 : 3 : error_at (cloc, "too many %qs clauses", "weak");
44093 : : else
44094 : : weak = true;
44095 : : }
44096 : 3007 : cp_lexer_consume_token (parser->lexer);
44097 : 3007 : continue;
44098 : : }
44099 : : }
44100 : : break;
44101 : : }
44102 : 2961 : cp_parser_require_pragma_eol (parser, pragma_tok);
44103 : :
44104 : 2961 : if (code == ERROR_MARK)
44105 : 1785 : code = OMP_ATOMIC;
44106 : 2961 : if (capture)
44107 : : {
44108 : 626 : if (code != OMP_ATOMIC)
44109 : 6 : error_at (loc, "%qs clause is incompatible with %<read%> or %<write%> "
44110 : : "clauses", "capture");
44111 : : else
44112 : : code = OMP_ATOMIC_CAPTURE_NEW;
44113 : : }
44114 : 2961 : if (compare && code != OMP_ATOMIC && code != OMP_ATOMIC_CAPTURE_NEW)
44115 : : {
44116 : 6 : error_at (loc, "%qs clause is incompatible with %<read%> or %<write%> "
44117 : : "clauses", "compare");
44118 : 6 : compare = false;
44119 : : }
44120 : 2961 : if (fail != OMP_MEMORY_ORDER_UNSPECIFIED && !compare)
44121 : : {
44122 : 15 : error_at (loc, "%qs clause requires %qs clause", "fail", "compare");
44123 : 15 : fail = OMP_MEMORY_ORDER_UNSPECIFIED;
44124 : : }
44125 : 2961 : if (weak && !compare)
44126 : : {
44127 : 15 : error_at (loc, "%qs clause requires %qs clause", "weak", "compare");
44128 : 15 : weak = false;
44129 : : }
44130 : 2961 : if (openacc)
44131 : : memory_order = OMP_MEMORY_ORDER_RELAXED;
44132 : 2598 : else if (memory_order == OMP_MEMORY_ORDER_UNSPECIFIED)
44133 : : {
44134 : 2201 : omp_requires_mask
44135 : 2201 : = (enum omp_requires) (omp_requires_mask
44136 : : | OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER_USED);
44137 : 2201 : switch ((enum omp_memory_order)
44138 : : (omp_requires_mask & OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER))
44139 : : {
44140 : : case OMP_MEMORY_ORDER_UNSPECIFIED:
44141 : : case OMP_MEMORY_ORDER_RELAXED:
44142 : : memory_order = OMP_MEMORY_ORDER_RELAXED;
44143 : : break;
44144 : : case OMP_MEMORY_ORDER_SEQ_CST:
44145 : 27 : memory_order = OMP_MEMORY_ORDER_SEQ_CST;
44146 : : break;
44147 : 12 : case OMP_MEMORY_ORDER_ACQUIRE:
44148 : 12 : if (code == NOP_EXPR) /* atomic write */
44149 : : {
44150 : 3 : error_at (loc, "%<#pragma omp atomic write%> incompatible with "
44151 : : "%<acquire%> clause implicitly provided by a "
44152 : : "%<requires%> directive");
44153 : 3 : memory_order = OMP_MEMORY_ORDER_SEQ_CST;
44154 : : }
44155 : : else
44156 : : memory_order = OMP_MEMORY_ORDER_ACQUIRE;
44157 : : break;
44158 : 9 : case OMP_MEMORY_ORDER_RELEASE:
44159 : 9 : if (code == OMP_ATOMIC_READ)
44160 : : {
44161 : 3 : error_at (loc, "%<#pragma omp atomic read%> incompatible with "
44162 : : "%<release%> clause implicitly provided by a "
44163 : : "%<requires%> directive");
44164 : 3 : memory_order = OMP_MEMORY_ORDER_SEQ_CST;
44165 : : }
44166 : : else
44167 : : memory_order = OMP_MEMORY_ORDER_RELEASE;
44168 : : break;
44169 : 33 : case OMP_MEMORY_ORDER_ACQ_REL:
44170 : 33 : switch (code)
44171 : : {
44172 : : case OMP_ATOMIC_READ:
44173 : : memory_order = OMP_MEMORY_ORDER_ACQUIRE;
44174 : : break;
44175 : : case NOP_EXPR: /* atomic write */
44176 : 15 : memory_order = OMP_MEMORY_ORDER_RELEASE;
44177 : : break;
44178 : : default:
44179 : 2961 : memory_order = OMP_MEMORY_ORDER_ACQ_REL;
44180 : : break;
44181 : : }
44182 : : break;
44183 : 0 : default:
44184 : 0 : gcc_unreachable ();
44185 : : }
44186 : : }
44187 : : else
44188 : 397 : switch (code)
44189 : : {
44190 : 67 : case OMP_ATOMIC_READ:
44191 : 67 : if (memory_order == OMP_MEMORY_ORDER_RELEASE)
44192 : : {
44193 : 3 : error_at (loc, "%<#pragma omp atomic read%> incompatible with "
44194 : : "%<release%> clause");
44195 : 3 : memory_order = OMP_MEMORY_ORDER_SEQ_CST;
44196 : : }
44197 : 64 : else if (memory_order == OMP_MEMORY_ORDER_ACQ_REL)
44198 : 18 : memory_order = OMP_MEMORY_ORDER_ACQUIRE;
44199 : : break;
44200 : 51 : case NOP_EXPR: /* atomic write */
44201 : 51 : if (memory_order == OMP_MEMORY_ORDER_ACQUIRE)
44202 : : {
44203 : 3 : error_at (loc, "%<#pragma omp atomic write%> incompatible with "
44204 : : "%<acquire%> clause");
44205 : 3 : memory_order = OMP_MEMORY_ORDER_SEQ_CST;
44206 : : }
44207 : 48 : else if (memory_order == OMP_MEMORY_ORDER_ACQ_REL)
44208 : 15 : memory_order = OMP_MEMORY_ORDER_RELEASE;
44209 : : break;
44210 : : default:
44211 : : break;
44212 : : }
44213 : 2961 : if (fail != OMP_MEMORY_ORDER_UNSPECIFIED)
44214 : 78 : memory_order
44215 : 78 : = (enum omp_memory_order) (memory_order
44216 : : | (fail << OMP_FAIL_MEMORY_ORDER_SHIFT));
44217 : :
44218 : 2961 : switch (code)
44219 : : {
44220 : 653 : case OMP_ATOMIC_READ:
44221 : 653 : case NOP_EXPR: /* atomic write */
44222 : 653 : v = cp_parser_unary_expression (parser);
44223 : 653 : if (v == error_mark_node)
44224 : 0 : goto saw_error;
44225 : 653 : if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
44226 : 0 : goto saw_error;
44227 : 653 : if (code == NOP_EXPR)
44228 : 223 : lhs = cp_parser_expression (parser);
44229 : : else
44230 : 430 : lhs = cp_parser_unary_expression (parser);
44231 : 653 : if (lhs == error_mark_node)
44232 : 0 : goto saw_error;
44233 : 653 : if (code == NOP_EXPR)
44234 : : {
44235 : : /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
44236 : : opcode. */
44237 : 223 : code = OMP_ATOMIC;
44238 : 223 : rhs = lhs;
44239 : 223 : lhs = v;
44240 : 223 : v = NULL_TREE;
44241 : : }
44242 : 653 : goto done;
44243 : 863 : case OMP_ATOMIC_CAPTURE_NEW:
44244 : 863 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
44245 : : {
44246 : 538 : cp_lexer_consume_token (parser->lexer);
44247 : 538 : structured_block = true;
44248 : : }
44249 : 325 : else if (compare
44250 : 325 : && cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
44251 : : break;
44252 : : else
44253 : : {
44254 : 268 : v = cp_parser_unary_expression (parser);
44255 : 268 : if (v == error_mark_node)
44256 : 0 : goto saw_error;
44257 : 268 : if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
44258 : 0 : goto saw_error;
44259 : 268 : if (compare
44260 : 268 : && cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
44261 : : {
44262 : 3 : location_t eloc = cp_lexer_peek_token (parser->lexer)->location;
44263 : 3 : error_at (eloc, "expected expression");
44264 : 3 : goto saw_error;
44265 : : }
44266 : : }
44267 : : default:
44268 : : break;
44269 : : }
44270 : :
44271 : 2305 : restart:
44272 : 2628 : if (compare && cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
44273 : : {
44274 : 297 : cp_lexer_consume_token (parser->lexer);
44275 : :
44276 : 297 : matching_parens parens;
44277 : 297 : if (!parens.require_open (parser))
44278 : 84 : goto saw_error;
44279 : 294 : location_t eloc = cp_lexer_peek_token (parser->lexer)->location;
44280 : 294 : tree cmp_expr;
44281 : 294 : if (r)
44282 : 63 : cmp_expr = cp_parser_unary_expression (parser);
44283 : : else
44284 : 231 : cmp_expr = cp_parser_binary_expression (parser, false, true,
44285 : : PREC_NOT_OPERATOR, NULL);
44286 : 294 : if (!parens.require_close (parser))
44287 : 0 : cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
44288 : 294 : if (cmp_expr == error_mark_node)
44289 : 0 : goto saw_error;
44290 : 294 : if (r)
44291 : : {
44292 : 63 : if (!cp_tree_equal (cmp_expr, r))
44293 : 3 : goto bad_if;
44294 : 60 : cmp_expr = rhs;
44295 : 60 : rhs = NULL_TREE;
44296 : 60 : gcc_assert (TREE_CODE (cmp_expr) == EQ_EXPR);
44297 : : }
44298 : 291 : if (TREE_CODE (cmp_expr) == EQ_EXPR)
44299 : : ;
44300 : 114 : else if (!structured_block && code == OMP_ATOMIC_CAPTURE_NEW)
44301 : : {
44302 : 6 : error_at (EXPR_LOC_OR_LOC (cmp_expr, eloc),
44303 : : "expected %<==%> comparison in %<if%> condition");
44304 : 6 : goto saw_error;
44305 : : }
44306 : 108 : else if (TREE_CODE (cmp_expr) != GT_EXPR
44307 : 63 : && TREE_CODE (cmp_expr) != LT_EXPR)
44308 : : {
44309 : 12 : error_at (EXPR_LOC_OR_LOC (cmp_expr, eloc),
44310 : : "expected %<==%>, %<<%> or %<>%> comparison in %<if%> "
44311 : : "condition");
44312 : 12 : goto saw_error;
44313 : : }
44314 : 273 : if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
44315 : 6 : goto saw_error;
44316 : :
44317 : 267 : extra_scope = true;
44318 : 267 : eloc = cp_lexer_peek_token (parser->lexer)->location;
44319 : 267 : lhs = cp_parser_unary_expression (parser);
44320 : 267 : orig_lhs = lhs;
44321 : 267 : if (lhs == error_mark_node)
44322 : 0 : goto saw_error;
44323 : 267 : if (!cp_lexer_next_token_is (parser->lexer, CPP_EQ))
44324 : : {
44325 : 3 : cp_parser_error (parser, "expected %<=%>");
44326 : 3 : goto saw_error;
44327 : : }
44328 : 264 : cp_lexer_consume_token (parser->lexer);
44329 : 264 : eloc = cp_lexer_peek_token (parser->lexer)->location;
44330 : 264 : if (TREE_CODE (cmp_expr) == EQ_EXPR)
44331 : 174 : rhs1 = cp_parser_expression (parser);
44332 : : else
44333 : 90 : rhs1 = cp_parser_simple_cast_expression (parser);
44334 : :
44335 : 264 : if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
44336 : 3 : goto saw_error;
44337 : :
44338 : 261 : if (!cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE))
44339 : 3 : goto saw_error;
44340 : :
44341 : 258 : extra_scope = false;
44342 : 258 : no_semicolon = true;
44343 : :
44344 : 258 : if (cp_tree_equal (TREE_OPERAND (cmp_expr, 0), lhs))
44345 : : {
44346 : 225 : if (TREE_CODE (cmp_expr) == EQ_EXPR)
44347 : : {
44348 : 168 : opcode = COND_EXPR;
44349 : 168 : rhs = TREE_OPERAND (cmp_expr, 1);
44350 : : }
44351 : 57 : else if (cp_tree_equal (TREE_OPERAND (cmp_expr, 1), rhs1))
44352 : : {
44353 : 102 : opcode = (TREE_CODE (cmp_expr) == GT_EXPR
44354 : 51 : ? MIN_EXPR : MAX_EXPR);
44355 : 51 : rhs = rhs1;
44356 : 51 : rhs1 = TREE_OPERAND (cmp_expr, 0);
44357 : : }
44358 : : else
44359 : 6 : goto bad_if;
44360 : : }
44361 : 33 : else if (TREE_CODE (cmp_expr) == EQ_EXPR)
44362 : 6 : goto bad_if;
44363 : 27 : else if (cp_tree_equal (TREE_OPERAND (cmp_expr, 1), lhs)
44364 : 27 : && cp_tree_equal (TREE_OPERAND (cmp_expr, 0), rhs1))
44365 : : {
44366 : 42 : opcode = (TREE_CODE (cmp_expr) == GT_EXPR
44367 : 21 : ? MAX_EXPR : MIN_EXPR);
44368 : 21 : rhs = rhs1;
44369 : 21 : rhs1 = TREE_OPERAND (cmp_expr, 1);
44370 : : }
44371 : : else
44372 : : {
44373 : 24 : bad_if:
44374 : 24 : cp_parser_error (parser,
44375 : : "invalid form of %<#pragma omp atomic compare%>");
44376 : 24 : goto saw_error;
44377 : : }
44378 : :
44379 : 240 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ELSE))
44380 : : {
44381 : 84 : if (code != OMP_ATOMIC_CAPTURE_NEW
44382 : 78 : || (structured_block && r == NULL_TREE)
44383 : 75 : || TREE_CODE (cmp_expr) != EQ_EXPR)
44384 : : {
44385 : 9 : eloc = cp_lexer_peek_token (parser->lexer)->location;
44386 : 9 : error_at (eloc, "unexpected %<else%>");
44387 : 9 : goto saw_error;
44388 : : }
44389 : :
44390 : 75 : cp_lexer_consume_token (parser->lexer);
44391 : :
44392 : 75 : if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
44393 : 3 : goto saw_error;
44394 : :
44395 : 72 : extra_scope = true;
44396 : 72 : v = cp_parser_unary_expression (parser);
44397 : 72 : if (v == error_mark_node)
44398 : 0 : goto saw_error;
44399 : 72 : if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
44400 : 3 : goto saw_error;
44401 : :
44402 : 69 : tree expr = cp_parser_simple_cast_expression (parser);
44403 : :
44404 : 69 : if (!cp_tree_equal (expr, lhs))
44405 : 3 : goto bad_if;
44406 : :
44407 : 66 : if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
44408 : 3 : goto saw_error;
44409 : :
44410 : 63 : if (!cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE))
44411 : 0 : goto saw_error;
44412 : :
44413 : 63 : extra_scope = false;
44414 : 63 : code = OMP_ATOMIC_CAPTURE_OLD;
44415 : 63 : if (r == NULL_TREE)
44416 : : /* Signal to c_finish_omp_atomic that in
44417 : : if (x == e) { x = d; } else { v = x; }
44418 : : case the store to v should be conditional. */
44419 : 36 : r = void_list_node;
44420 : : }
44421 : 156 : else if (code == OMP_ATOMIC_CAPTURE_NEW && !structured_block)
44422 : : {
44423 : 3 : cp_parser_error (parser, "expected %<else%>");
44424 : 3 : goto saw_error;
44425 : : }
44426 : 153 : else if (code == OMP_ATOMIC_CAPTURE_NEW
44427 : 153 : && r != NULL_TREE
44428 : 33 : && v == NULL_TREE)
44429 : 216 : code = OMP_ATOMIC;
44430 : 216 : goto stmt_done;
44431 : : }
44432 : 2331 : lhs = cp_parser_unary_expression (parser);
44433 : 2331 : orig_lhs = lhs;
44434 : 2331 : switch (TREE_CODE (lhs))
44435 : : {
44436 : 18 : case ERROR_MARK:
44437 : 18 : goto saw_error;
44438 : :
44439 : 376 : case POSTINCREMENT_EXPR:
44440 : 376 : if (code == OMP_ATOMIC_CAPTURE_NEW && !structured_block)
44441 : 47 : code = OMP_ATOMIC_CAPTURE_OLD;
44442 : : /* FALLTHROUGH */
44443 : 451 : case PREINCREMENT_EXPR:
44444 : 451 : lhs = TREE_OPERAND (lhs, 0);
44445 : 451 : opcode = PLUS_EXPR;
44446 : 451 : rhs = integer_one_node;
44447 : 451 : if (compare)
44448 : 6 : goto invalid_compare;
44449 : : break;
44450 : :
44451 : 49 : case POSTDECREMENT_EXPR:
44452 : 49 : if (code == OMP_ATOMIC_CAPTURE_NEW && !structured_block)
44453 : 2 : code = OMP_ATOMIC_CAPTURE_OLD;
44454 : : /* FALLTHROUGH */
44455 : 90 : case PREDECREMENT_EXPR:
44456 : 90 : lhs = TREE_OPERAND (lhs, 0);
44457 : 90 : opcode = MINUS_EXPR;
44458 : 90 : rhs = integer_one_node;
44459 : 90 : if (compare)
44460 : 6 : goto invalid_compare;
44461 : : break;
44462 : :
44463 : 6 : case COMPOUND_EXPR:
44464 : 6 : if (TREE_CODE (TREE_OPERAND (lhs, 0)) == SAVE_EXPR
44465 : 6 : && TREE_CODE (TREE_OPERAND (lhs, 1)) == COMPOUND_EXPR
44466 : 6 : && TREE_CODE (TREE_OPERAND (TREE_OPERAND (lhs, 1), 0)) == MODIFY_EXPR
44467 : 6 : && TREE_OPERAND (TREE_OPERAND (lhs, 1), 1) == TREE_OPERAND (lhs, 0)
44468 : 12 : && TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND
44469 : : (TREE_OPERAND (lhs, 1), 0), 0)))
44470 : : == BOOLEAN_TYPE)
44471 : : /* Undo effects of boolean_increment for post {in,de}crement. */
44472 : 6 : lhs = TREE_OPERAND (TREE_OPERAND (lhs, 1), 0);
44473 : : /* FALLTHRU */
44474 : 12 : case MODIFY_EXPR:
44475 : 12 : if (TREE_CODE (lhs) == MODIFY_EXPR
44476 : 12 : && TREE_CODE (TREE_TYPE (TREE_OPERAND (lhs, 0))) == BOOLEAN_TYPE)
44477 : : {
44478 : : /* Undo effects of boolean_increment. */
44479 : 12 : if (integer_onep (TREE_OPERAND (lhs, 1)))
44480 : : {
44481 : : /* This is pre or post increment. */
44482 : 12 : rhs = TREE_OPERAND (lhs, 1);
44483 : 12 : lhs = TREE_OPERAND (lhs, 0);
44484 : 12 : opcode = NOP_EXPR;
44485 : 12 : if (code == OMP_ATOMIC_CAPTURE_NEW
44486 : 12 : && !structured_block
44487 : 2 : && TREE_CODE (orig_lhs) == COMPOUND_EXPR)
44488 : 1 : code = OMP_ATOMIC_CAPTURE_OLD;
44489 : 12 : if (compare)
44490 : 0 : goto invalid_compare;
44491 : : break;
44492 : : }
44493 : : }
44494 : : /* FALLTHRU */
44495 : 1760 : default:
44496 : 1760 : if (compare && !cp_lexer_next_token_is (parser->lexer, CPP_EQ))
44497 : : {
44498 : 21 : cp_parser_error (parser, "expected %<=%>");
44499 : 21 : goto saw_error;
44500 : : }
44501 : 1739 : switch (cp_lexer_peek_token (parser->lexer)->type)
44502 : : {
44503 : : case CPP_MULT_EQ:
44504 : : opcode = MULT_EXPR;
44505 : : break;
44506 : : case CPP_DIV_EQ:
44507 : : opcode = TRUNC_DIV_EXPR;
44508 : : break;
44509 : : case CPP_PLUS_EQ:
44510 : : opcode = PLUS_EXPR;
44511 : : break;
44512 : : case CPP_MINUS_EQ:
44513 : : opcode = MINUS_EXPR;
44514 : : break;
44515 : : case CPP_LSHIFT_EQ:
44516 : : opcode = LSHIFT_EXPR;
44517 : : break;
44518 : : case CPP_RSHIFT_EQ:
44519 : : opcode = RSHIFT_EXPR;
44520 : : break;
44521 : : case CPP_AND_EQ:
44522 : : opcode = BIT_AND_EXPR;
44523 : : break;
44524 : : case CPP_OR_EQ:
44525 : : opcode = BIT_IOR_EXPR;
44526 : : break;
44527 : : case CPP_XOR_EQ:
44528 : : opcode = BIT_XOR_EXPR;
44529 : : break;
44530 : 1124 : case CPP_EQ:
44531 : 1124 : enum cp_parser_prec oprec;
44532 : 1124 : cp_token *token;
44533 : 1124 : cp_lexer_consume_token (parser->lexer);
44534 : 1124 : cp_parser_parse_tentatively (parser);
44535 : 1124 : rhs1 = cp_parser_simple_cast_expression (parser);
44536 : 1124 : if (rhs1 == error_mark_node)
44537 : : {
44538 : 0 : cp_parser_abort_tentative_parse (parser);
44539 : 0 : cp_parser_simple_cast_expression (parser);
44540 : 0 : goto saw_error;
44541 : : }
44542 : 1124 : token = cp_lexer_peek_token (parser->lexer);
44543 : 1124 : if (token->type != CPP_SEMICOLON
44544 : 849 : && (!compare || token->type != CPP_QUERY)
44545 : 1964 : && !cp_tree_equal (lhs, rhs1))
44546 : : {
44547 : 325 : cp_parser_abort_tentative_parse (parser);
44548 : 325 : cp_parser_parse_tentatively (parser);
44549 : 325 : rhs = cp_parser_binary_expression (parser, false, true,
44550 : : PREC_NOT_OPERATOR, NULL);
44551 : 325 : if (rhs == error_mark_node)
44552 : : {
44553 : 0 : cp_parser_abort_tentative_parse (parser);
44554 : 0 : cp_parser_binary_expression (parser, false, true,
44555 : : PREC_NOT_OPERATOR, NULL);
44556 : 0 : goto saw_error;
44557 : : }
44558 : 325 : switch (TREE_CODE (rhs))
44559 : : {
44560 : 162 : case MULT_EXPR:
44561 : 162 : case TRUNC_DIV_EXPR:
44562 : 162 : case RDIV_EXPR:
44563 : 162 : case PLUS_EXPR:
44564 : 162 : case MINUS_EXPR:
44565 : 162 : case LSHIFT_EXPR:
44566 : 162 : case RSHIFT_EXPR:
44567 : 162 : case BIT_AND_EXPR:
44568 : 162 : case BIT_IOR_EXPR:
44569 : 162 : case BIT_XOR_EXPR:
44570 : 162 : if (compare)
44571 : : break;
44572 : 153 : if (cp_tree_equal (lhs, TREE_OPERAND (rhs, 1)))
44573 : : {
44574 : 139 : if (cp_parser_parse_definitely (parser))
44575 : : {
44576 : 139 : opcode = TREE_CODE (rhs);
44577 : 139 : rhs1 = TREE_OPERAND (rhs, 0);
44578 : 139 : rhs = TREE_OPERAND (rhs, 1);
44579 : 139 : goto stmt_done;
44580 : : }
44581 : : else
44582 : 0 : goto saw_error;
44583 : : }
44584 : : break;
44585 : 69 : case EQ_EXPR:
44586 : 69 : if (!compare
44587 : 69 : || code != OMP_ATOMIC_CAPTURE_NEW
44588 : 63 : || !structured_block
44589 : 63 : || v
44590 : 63 : || r)
44591 : : break;
44592 : 63 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
44593 : 63 : && cp_lexer_nth_token_is_keyword (parser->lexer,
44594 : : 2, RID_IF))
44595 : : {
44596 : 63 : if (cp_parser_parse_definitely (parser))
44597 : : {
44598 : 63 : r = lhs;
44599 : 63 : lhs = NULL_TREE;
44600 : 63 : rhs1 = NULL_TREE;
44601 : 63 : cp_lexer_consume_token (parser->lexer);
44602 : 63 : goto restart;
44603 : : }
44604 : : }
44605 : : break;
44606 : 75 : case GT_EXPR:
44607 : 75 : case LT_EXPR:
44608 : 75 : if (compare
44609 : 75 : && cp_lexer_next_token_is (parser->lexer, CPP_QUERY)
44610 : 69 : && cp_tree_equal (lhs, TREE_OPERAND (rhs, 1))
44611 : 144 : && cp_parser_parse_definitely (parser))
44612 : : {
44613 : 69 : opcode = TREE_CODE (rhs);
44614 : 69 : rhs1 = TREE_OPERAND (rhs, 0);
44615 : 69 : rhs = TREE_OPERAND (rhs, 1);
44616 : 226 : cond_expr:
44617 : 226 : cp_lexer_consume_token (parser->lexer);
44618 : 226 : bool saved_colon_corrects_to_scope_p
44619 : : = parser->colon_corrects_to_scope_p;
44620 : 226 : parser->colon_corrects_to_scope_p = false;
44621 : 226 : tree e1 = cp_parser_expression (parser);
44622 : 226 : parser->colon_corrects_to_scope_p
44623 : 226 : = saved_colon_corrects_to_scope_p;
44624 : 226 : cp_parser_require (parser, CPP_COLON, RT_COLON);
44625 : 226 : tree e2 = cp_parser_simple_cast_expression (parser);
44626 : 226 : if (cp_tree_equal (lhs, e2))
44627 : : {
44628 : 214 : if (cp_tree_equal (lhs, rhs1))
44629 : : {
44630 : 145 : if (opcode == EQ_EXPR)
44631 : : {
44632 : 85 : opcode = COND_EXPR;
44633 : 85 : rhs1 = e1;
44634 : 85 : goto stmt_done;
44635 : : }
44636 : 60 : if (cp_tree_equal (rhs, e1))
44637 : : {
44638 : 54 : opcode
44639 : 54 : = opcode == GT_EXPR ? MIN_EXPR : MAX_EXPR;
44640 : 54 : rhs = e1;
44641 : 54 : goto stmt_done;
44642 : : }
44643 : : }
44644 : : else
44645 : : {
44646 : 69 : gcc_assert (opcode != EQ_EXPR);
44647 : 69 : if (cp_tree_equal (rhs1, e1))
44648 : : {
44649 : 69 : opcode
44650 : 69 : = opcode == GT_EXPR ? MAX_EXPR : MIN_EXPR;
44651 : 69 : rhs1 = rhs;
44652 : 69 : rhs = e1;
44653 : 69 : goto stmt_done;
44654 : : }
44655 : : }
44656 : : }
44657 : 18 : cp_parser_error (parser,
44658 : : "invalid form of "
44659 : : "%<#pragma omp atomic compare%>");
44660 : 18 : goto saw_error;
44661 : : }
44662 : : break;
44663 : : default:
44664 : : break;
44665 : : }
44666 : 54 : cp_parser_abort_tentative_parse (parser);
44667 : 54 : if (structured_block
44668 : 54 : && code == OMP_ATOMIC_CAPTURE_OLD
44669 : 21 : && !compare)
44670 : : {
44671 : 18 : rhs = cp_parser_expression (parser);
44672 : 18 : if (rhs == error_mark_node)
44673 : 0 : goto saw_error;
44674 : 18 : opcode = NOP_EXPR;
44675 : 18 : rhs1 = NULL_TREE;
44676 : 18 : goto stmt_done;
44677 : : }
44678 : 36 : cp_parser_error (parser,
44679 : : "invalid form of %<#pragma omp atomic%>");
44680 : 36 : goto saw_error;
44681 : : }
44682 : 799 : if (!cp_parser_parse_definitely (parser))
44683 : 0 : goto saw_error;
44684 : 799 : switch (token->type)
44685 : : {
44686 : 275 : case CPP_SEMICOLON:
44687 : 275 : if (structured_block && code == OMP_ATOMIC_CAPTURE_NEW)
44688 : : {
44689 : 260 : code = OMP_ATOMIC_CAPTURE_OLD;
44690 : 260 : v = lhs;
44691 : 260 : lhs = NULL_TREE;
44692 : 260 : lhs1 = rhs1;
44693 : 260 : rhs1 = NULL_TREE;
44694 : 260 : cp_lexer_consume_token (parser->lexer);
44695 : 260 : goto restart;
44696 : : }
44697 : 15 : else if (structured_block && !compare)
44698 : : {
44699 : 9 : opcode = NOP_EXPR;
44700 : 9 : rhs = rhs1;
44701 : 9 : rhs1 = NULL_TREE;
44702 : 9 : goto stmt_done;
44703 : : }
44704 : 6 : cp_parser_error (parser,
44705 : : "invalid form of %<#pragma omp atomic%>");
44706 : 6 : goto saw_error;
44707 : : case CPP_MULT:
44708 : : opcode = MULT_EXPR;
44709 : : break;
44710 : : case CPP_DIV:
44711 : : opcode = TRUNC_DIV_EXPR;
44712 : : break;
44713 : : case CPP_PLUS:
44714 : : opcode = PLUS_EXPR;
44715 : : break;
44716 : : case CPP_MINUS:
44717 : : opcode = MINUS_EXPR;
44718 : : break;
44719 : : case CPP_LSHIFT:
44720 : : opcode = LSHIFT_EXPR;
44721 : : break;
44722 : : case CPP_RSHIFT:
44723 : : opcode = RSHIFT_EXPR;
44724 : : break;
44725 : : case CPP_AND:
44726 : : opcode = BIT_AND_EXPR;
44727 : : break;
44728 : : case CPP_OR:
44729 : : opcode = BIT_IOR_EXPR;
44730 : : break;
44731 : : case CPP_XOR:
44732 : : opcode = BIT_XOR_EXPR;
44733 : : break;
44734 : : case CPP_EQ_EQ:
44735 : : opcode = EQ_EXPR;
44736 : : break;
44737 : : case CPP_GREATER:
44738 : : opcode = GT_EXPR;
44739 : : break;
44740 : : case CPP_LESS:
44741 : : opcode = LT_EXPR;
44742 : : break;
44743 : 18 : default:
44744 : 18 : cp_parser_error (parser,
44745 : : "invalid operator for %<#pragma omp atomic%>");
44746 : 18 : goto saw_error;
44747 : : }
44748 : 506 : if (compare
44749 : 169 : && TREE_CODE_CLASS (opcode) != tcc_comparison)
44750 : : {
44751 : 12 : cp_parser_error (parser,
44752 : : "invalid form of "
44753 : : "%<#pragma omp atomic compare%>");
44754 : 12 : goto saw_error;
44755 : : }
44756 : 494 : oprec = TOKEN_PRECEDENCE (token);
44757 : 494 : gcc_assert (oprec != PREC_NOT_OPERATOR);
44758 : 494 : if (commutative_tree_code (opcode))
44759 : 357 : oprec = (enum cp_parser_prec) (oprec - 1);
44760 : 494 : cp_lexer_consume_token (parser->lexer);
44761 : 494 : rhs = cp_parser_binary_expression (parser, false, false,
44762 : : oprec, NULL);
44763 : 494 : if (rhs == error_mark_node)
44764 : 0 : goto saw_error;
44765 : 494 : if (compare)
44766 : : {
44767 : 157 : if (!cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
44768 : : {
44769 : 0 : cp_parser_error (parser,
44770 : : "invalid form of "
44771 : : "%<#pragma omp atomic compare%>");
44772 : 0 : goto saw_error;
44773 : : }
44774 : 157 : goto cond_expr;
44775 : : }
44776 : 337 : goto stmt_done;
44777 : 9 : default:
44778 : 9 : cp_parser_error (parser,
44779 : : "invalid operator for %<#pragma omp atomic%>");
44780 : 9 : goto saw_error;
44781 : : }
44782 : 606 : cp_lexer_consume_token (parser->lexer);
44783 : :
44784 : 606 : rhs = cp_parser_expression (parser);
44785 : 606 : if (rhs == error_mark_node)
44786 : 0 : goto saw_error;
44787 : : break;
44788 : : }
44789 : 2074 : stmt_done:
44790 : 2074 : if (structured_block && code == OMP_ATOMIC_CAPTURE_NEW && r == NULL_TREE)
44791 : : {
44792 : 194 : if (!no_semicolon
44793 : 194 : && !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
44794 : 12 : goto saw_error;
44795 : 182 : no_semicolon = false;
44796 : 182 : v = cp_parser_unary_expression (parser);
44797 : 182 : if (v == error_mark_node)
44798 : 0 : goto saw_error;
44799 : 182 : if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
44800 : 0 : goto saw_error;
44801 : 182 : lhs1 = cp_parser_unary_expression (parser);
44802 : 182 : if (lhs1 == error_mark_node)
44803 : 0 : goto saw_error;
44804 : : }
44805 : 2062 : if (structured_block)
44806 : : {
44807 : 496 : if (!no_semicolon)
44808 : 400 : cp_parser_consume_semicolon_at_end_of_statement (parser);
44809 : 496 : cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
44810 : : }
44811 : 1566 : done:
44812 : 2715 : if (weak && opcode != COND_EXPR)
44813 : : {
44814 : 3 : error_at (loc, "%<weak%> clause requires atomic equality comparison");
44815 : 3 : weak = false;
44816 : : }
44817 : 2715 : clauses = finish_omp_clauses (clauses, C_ORT_OMP);
44818 : 2715 : finish_omp_atomic (pragma_tok->location, code, opcode, lhs, rhs, v, lhs1,
44819 : : rhs1, r, clauses, memory_order, weak);
44820 : 2715 : if (!structured_block && !no_semicolon)
44821 : 2138 : cp_parser_consume_semicolon_at_end_of_statement (parser);
44822 : : return;
44823 : :
44824 : 12 : invalid_compare:
44825 : 12 : error ("invalid form of %<pragma omp atomic compare%>");
44826 : : /* FALLTHRU */
44827 : 246 : saw_error:
44828 : 246 : cp_parser_skip_to_end_of_block_or_statement (parser);
44829 : 246 : if (extra_scope && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
44830 : 18 : cp_lexer_consume_token (parser->lexer);
44831 : 246 : if (structured_block)
44832 : : {
44833 : 42 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
44834 : 9 : cp_lexer_consume_token (parser->lexer);
44835 : 33 : else if (code == OMP_ATOMIC_CAPTURE_NEW)
44836 : : {
44837 : 33 : cp_parser_skip_to_end_of_block_or_statement (parser);
44838 : 33 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
44839 : 33 : cp_lexer_consume_token (parser->lexer);
44840 : : }
44841 : : }
44842 : : }
44843 : :
44844 : :
44845 : : /* OpenMP 2.5:
44846 : : # pragma omp barrier new-line */
44847 : :
44848 : : static void
44849 : 359 : cp_parser_omp_barrier (cp_parser *parser, cp_token *pragma_tok)
44850 : : {
44851 : 0 : cp_parser_require_pragma_eol (parser, pragma_tok);
44852 : 0 : finish_omp_barrier ();
44853 : 0 : }
44854 : :
44855 : : /* OpenMP 2.5:
44856 : : # pragma omp critical [(name)] new-line
44857 : : structured-block
44858 : :
44859 : : OpenMP 4.5:
44860 : : # pragma omp critical [(name) [hint(expression)]] new-line
44861 : : structured-block */
44862 : :
44863 : : #define OMP_CRITICAL_CLAUSE_MASK \
44864 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HINT) )
44865 : :
44866 : : static tree
44867 : 264 : cp_parser_omp_critical (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
44868 : : {
44869 : 264 : tree stmt, name = NULL_TREE, clauses = NULL_TREE;
44870 : :
44871 : 264 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
44872 : : {
44873 : 75 : matching_parens parens;
44874 : 75 : parens.consume_open (parser);
44875 : :
44876 : 75 : name = cp_parser_identifier (parser);
44877 : :
44878 : 75 : if (name == error_mark_node
44879 : 147 : || !parens.require_close (parser))
44880 : 9 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
44881 : : /*or_comma=*/false,
44882 : : /*consume_paren=*/true);
44883 : 75 : if (name == error_mark_node)
44884 : 3 : name = NULL;
44885 : :
44886 : 75 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
44887 : 75 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
44888 : 21 : cp_lexer_consume_token (parser->lexer);
44889 : : }
44890 : :
44891 : 264 : clauses = cp_parser_omp_all_clauses (parser, OMP_CRITICAL_CLAUSE_MASK,
44892 : : "#pragma omp critical", pragma_tok);
44893 : :
44894 : 264 : stmt = cp_parser_omp_structured_block (parser, if_p);
44895 : 264 : return c_finish_omp_critical (input_location, stmt, name, clauses);
44896 : : }
44897 : :
44898 : : /* OpenMP 5.0:
44899 : : # pragma omp depobj ( depobj ) depobj-clause new-line
44900 : :
44901 : : depobj-clause:
44902 : : depend (dependence-type : locator)
44903 : : destroy
44904 : : update (dependence-type)
44905 : :
44906 : : OpenMP 5.2 additionally:
44907 : : destroy ( depobj )
44908 : :
44909 : : dependence-type:
44910 : : in
44911 : : out
44912 : : inout
44913 : : mutexinout */
44914 : :
44915 : : static void
44916 : 296 : cp_parser_omp_depobj (cp_parser *parser, cp_token *pragma_tok)
44917 : : {
44918 : 296 : location_t loc = pragma_tok->location;
44919 : 296 : matching_parens parens;
44920 : 296 : if (!parens.require_open (parser))
44921 : : {
44922 : 15 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
44923 : 15 : return;
44924 : : }
44925 : :
44926 : 281 : tree depobj = cp_parser_assignment_expression (parser);
44927 : :
44928 : 281 : if (!parens.require_close (parser))
44929 : 0 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
44930 : : /*or_comma=*/false,
44931 : : /*consume_paren=*/true);
44932 : :
44933 : 281 : tree clause = NULL_TREE;
44934 : 281 : enum omp_clause_depend_kind kind = OMP_CLAUSE_DEPEND_INVALID;
44935 : 281 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
44936 : 9 : cp_lexer_consume_token (parser->lexer);
44937 : 281 : location_t c_loc = cp_lexer_peek_token (parser->lexer)->location;
44938 : 281 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
44939 : : {
44940 : 275 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
44941 : 275 : const char *p = IDENTIFIER_POINTER (id);
44942 : :
44943 : 275 : cp_lexer_consume_token (parser->lexer);
44944 : 275 : if (!strcmp ("depend", p))
44945 : : {
44946 : : /* Don't create location wrapper nodes within the depend clause. */
44947 : 147 : auto_suppress_location_wrappers sentinel;
44948 : 147 : clause = cp_parser_omp_clause_depend (parser, NULL_TREE, c_loc);
44949 : 147 : if (clause)
44950 : 147 : clause = finish_omp_clauses (clause, C_ORT_OMP);
44951 : 147 : if (!clause)
44952 : 9 : clause = error_mark_node;
44953 : : }
44954 : 128 : else if (!strcmp ("destroy", p))
44955 : : {
44956 : 75 : kind = OMP_CLAUSE_DEPEND_LAST;
44957 : 75 : matching_parens c_parens;
44958 : 75 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
44959 : 75 : && c_parens.require_open (parser))
44960 : : {
44961 : 21 : tree destobj = cp_parser_assignment_expression (parser);
44962 : 21 : if (depobj != error_mark_node
44963 : 18 : && destobj != error_mark_node
44964 : 39 : && !operand_equal_p (destobj, depobj, OEP_MATCH_SIDE_EFFECTS
44965 : : | OEP_LEXICOGRAPHIC))
44966 : 9 : warning_at (EXPR_LOC_OR_LOC (destobj, c_loc), OPT_Wopenmp,
44967 : : "the %<destroy%> expression %qE should be the same "
44968 : : "as the %<depobj%> argument %qE", destobj, depobj);
44969 : 21 : if (!c_parens.require_close (parser))
44970 : 0 : cp_parser_skip_to_closing_parenthesis (parser,
44971 : : /*recovering=*/true,
44972 : : /*or_comma=*/false,
44973 : : /*consume_paren=*/true);
44974 : : }
44975 : : }
44976 : 53 : else if (!strcmp ("update", p))
44977 : : {
44978 : 47 : matching_parens c_parens;
44979 : 47 : if (c_parens.require_open (parser))
44980 : : {
44981 : 47 : location_t c2_loc
44982 : 47 : = cp_lexer_peek_token (parser->lexer)->location;
44983 : 47 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
44984 : : {
44985 : 47 : tree id2 = cp_lexer_peek_token (parser->lexer)->u.value;
44986 : 47 : const char *p2 = IDENTIFIER_POINTER (id2);
44987 : :
44988 : 47 : cp_lexer_consume_token (parser->lexer);
44989 : 47 : if (!strcmp ("in", p2))
44990 : : kind = OMP_CLAUSE_DEPEND_IN;
44991 : 39 : else if (!strcmp ("out", p2))
44992 : : kind = OMP_CLAUSE_DEPEND_OUT;
44993 : 37 : else if (!strcmp ("inout", p2))
44994 : : kind = OMP_CLAUSE_DEPEND_INOUT;
44995 : 13 : else if (!strcmp ("mutexinoutset", p2))
44996 : : kind = OMP_CLAUSE_DEPEND_MUTEXINOUTSET;
44997 : 10 : else if (!strcmp ("inoutset", p2))
44998 : : kind = OMP_CLAUSE_DEPEND_INOUTSET;
44999 : : }
45000 : : if (kind == OMP_CLAUSE_DEPEND_INVALID)
45001 : : {
45002 : 6 : clause = error_mark_node;
45003 : 6 : error_at (c2_loc, "expected %<in%>, %<out%>, %<inout%>, "
45004 : : "%<mutexinoutset%> or %<inoutset%>");
45005 : : }
45006 : 47 : if (!c_parens.require_close (parser))
45007 : 0 : cp_parser_skip_to_closing_parenthesis (parser,
45008 : : /*recovering=*/true,
45009 : : /*or_comma=*/false,
45010 : : /*consume_paren=*/true);
45011 : : }
45012 : : else
45013 : 0 : clause = error_mark_node;
45014 : : }
45015 : : }
45016 : 281 : if (!clause && kind == OMP_CLAUSE_DEPEND_INVALID)
45017 : : {
45018 : 12 : clause = error_mark_node;
45019 : 12 : error_at (c_loc, "expected %<depend%>, %<destroy%> or %<update%> clause");
45020 : : }
45021 : 281 : cp_parser_require_pragma_eol (parser, pragma_tok);
45022 : :
45023 : 281 : finish_omp_depobj (loc, depobj, kind, clause);
45024 : : }
45025 : :
45026 : :
45027 : : /* OpenMP 2.5:
45028 : : # pragma omp flush flush-vars[opt] new-line
45029 : :
45030 : : flush-vars:
45031 : : ( variable-list )
45032 : :
45033 : : OpenMP 5.0:
45034 : : # pragma omp flush memory-order-clause new-line */
45035 : :
45036 : : static void
45037 : 156 : cp_parser_omp_flush (cp_parser *parser, cp_token *pragma_tok)
45038 : : {
45039 : 156 : enum memmodel mo = MEMMODEL_LAST;
45040 : 156 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
45041 : 156 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
45042 : 24 : cp_lexer_consume_token (parser->lexer);
45043 : 156 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
45044 : : {
45045 : 81 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
45046 : 81 : const char *p = IDENTIFIER_POINTER (id);
45047 : 81 : if (!strcmp (p, "seq_cst"))
45048 : : mo = MEMMODEL_SEQ_CST;
45049 : 63 : else if (!strcmp (p, "acq_rel"))
45050 : : mo = MEMMODEL_ACQ_REL;
45051 : 45 : else if (!strcmp (p, "release"))
45052 : : mo = MEMMODEL_RELEASE;
45053 : 27 : else if (!strcmp (p, "acquire"))
45054 : : mo = MEMMODEL_ACQUIRE;
45055 : : else
45056 : 9 : error_at (cp_lexer_peek_token (parser->lexer)->location,
45057 : : "expected %<seq_cst%>, %<acq_rel%>, %<release%> or "
45058 : : "%<acquire%>");
45059 : 81 : cp_lexer_consume_token (parser->lexer);
45060 : : }
45061 : 156 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
45062 : : {
45063 : 42 : if (mo != MEMMODEL_LAST)
45064 : 12 : error_at (cp_lexer_peek_token (parser->lexer)->location,
45065 : : "%<flush%> list specified together with memory order "
45066 : : "clause");
45067 : 42 : (void) cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
45068 : : }
45069 : 156 : cp_parser_require_pragma_eol (parser, pragma_tok);
45070 : :
45071 : 156 : finish_omp_flush (mo);
45072 : 156 : }
45073 : :
45074 : : /* Helper function, to parse omp for increment expression. */
45075 : :
45076 : : static tree
45077 : 23958 : cp_parser_omp_for_cond (cp_parser *parser, tree decl, enum tree_code code)
45078 : : {
45079 : 23958 : tree cond = cp_parser_binary_expression (parser, false, true,
45080 : : PREC_NOT_OPERATOR, NULL);
45081 : 23958 : if (cond == error_mark_node
45082 : 23958 : || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
45083 : : {
45084 : 12 : cp_parser_skip_to_end_of_statement (parser);
45085 : 12 : return error_mark_node;
45086 : : }
45087 : :
45088 : 23946 : switch (TREE_CODE (cond))
45089 : : {
45090 : : case GT_EXPR:
45091 : : case GE_EXPR:
45092 : : case LT_EXPR:
45093 : : case LE_EXPR:
45094 : : break;
45095 : 2883 : case NE_EXPR:
45096 : 2883 : if (code != OACC_LOOP)
45097 : : break;
45098 : : gcc_fallthrough ();
45099 : : default:
45100 : : return error_mark_node;
45101 : : }
45102 : :
45103 : : /* If decl is an iterator, preserve LHS and RHS of the relational
45104 : : expr until finish_omp_for. */
45105 : 23925 : if (decl
45106 : 23925 : && (type_dependent_expression_p (decl)
45107 : 8035 : || CLASS_TYPE_P (TREE_TYPE (decl))))
45108 : : return cond;
45109 : :
45110 : 23042 : return build_x_binary_op (cp_expr_loc_or_input_loc (cond),
45111 : 23042 : TREE_CODE (cond),
45112 : 23042 : TREE_OPERAND (cond, 0), ERROR_MARK,
45113 : 23042 : TREE_OPERAND (cond, 1), ERROR_MARK,
45114 : : NULL_TREE, /*overload=*/NULL, tf_warning_or_error);
45115 : : }
45116 : :
45117 : : /* Helper function, to parse omp for increment expression. */
45118 : :
45119 : : static tree
45120 : 1665 : cp_parser_omp_for_incr (cp_parser *parser, tree decl)
45121 : : {
45122 : 1665 : cp_token *token = cp_lexer_peek_token (parser->lexer);
45123 : 1665 : enum tree_code op;
45124 : 1665 : tree lhs, rhs;
45125 : 1665 : cp_id_kind idk;
45126 : 1665 : bool decl_first;
45127 : :
45128 : 1665 : if (token->type == CPP_PLUS_PLUS || token->type == CPP_MINUS_MINUS)
45129 : : {
45130 : 452 : op = (token->type == CPP_PLUS_PLUS
45131 : 226 : ? PREINCREMENT_EXPR : PREDECREMENT_EXPR);
45132 : 226 : cp_lexer_consume_token (parser->lexer);
45133 : 226 : lhs = cp_parser_simple_cast_expression (parser);
45134 : 226 : if (lhs != decl
45135 : 226 : && (!processing_template_decl || !cp_tree_equal (lhs, decl)))
45136 : 0 : return error_mark_node;
45137 : 226 : return build2 (op, TREE_TYPE (decl), decl, NULL_TREE);
45138 : : }
45139 : :
45140 : 1439 : lhs = cp_parser_primary_expression (parser, false, false, false, &idk);
45141 : 1439 : if (lhs != decl
45142 : 1439 : && (!processing_template_decl || !cp_tree_equal (lhs, decl)))
45143 : 3 : return error_mark_node;
45144 : :
45145 : 1436 : token = cp_lexer_peek_token (parser->lexer);
45146 : 1436 : if (token->type == CPP_PLUS_PLUS || token->type == CPP_MINUS_MINUS)
45147 : : {
45148 : 1728 : op = (token->type == CPP_PLUS_PLUS
45149 : 864 : ? POSTINCREMENT_EXPR : POSTDECREMENT_EXPR);
45150 : 864 : cp_lexer_consume_token (parser->lexer);
45151 : 864 : return build2 (op, TREE_TYPE (decl), decl, NULL_TREE);
45152 : : }
45153 : :
45154 : 572 : op = cp_parser_assignment_operator_opt (parser);
45155 : 572 : if (op == ERROR_MARK)
45156 : 0 : return error_mark_node;
45157 : :
45158 : 572 : if (op != NOP_EXPR)
45159 : : {
45160 : 246 : rhs = cp_parser_assignment_expression (parser);
45161 : 246 : rhs = build2 (op, TREE_TYPE (decl), decl, rhs);
45162 : 246 : return build2 (MODIFY_EXPR, TREE_TYPE (decl), decl, rhs);
45163 : : }
45164 : :
45165 : 326 : lhs = cp_parser_binary_expression (parser, false, false,
45166 : : PREC_ADDITIVE_EXPRESSION, NULL);
45167 : 326 : token = cp_lexer_peek_token (parser->lexer);
45168 : 326 : decl_first = (lhs == decl
45169 : 326 : || (processing_template_decl && cp_tree_equal (lhs, decl)));
45170 : : if (decl_first)
45171 : : lhs = NULL_TREE;
45172 : 326 : if (token->type != CPP_PLUS
45173 : 326 : && token->type != CPP_MINUS)
45174 : 0 : return error_mark_node;
45175 : :
45176 : 384 : do
45177 : : {
45178 : 384 : op = token->type == CPP_PLUS ? PLUS_EXPR : MINUS_EXPR;
45179 : 384 : cp_lexer_consume_token (parser->lexer);
45180 : 384 : rhs = cp_parser_binary_expression (parser, false, false,
45181 : : PREC_ADDITIVE_EXPRESSION, NULL);
45182 : 384 : token = cp_lexer_peek_token (parser->lexer);
45183 : 384 : if (token->type == CPP_PLUS || token->type == CPP_MINUS || decl_first)
45184 : : {
45185 : 269 : if (lhs == NULL_TREE)
45186 : : {
45187 : 211 : if (op == PLUS_EXPR)
45188 : : lhs = rhs;
45189 : : else
45190 : 40 : lhs = build_x_unary_op (input_location, NEGATE_EXPR, rhs,
45191 : : NULL_TREE, tf_warning_or_error);
45192 : : }
45193 : : else
45194 : 58 : lhs = build_x_binary_op (input_location, op,
45195 : : lhs, ERROR_MARK,
45196 : : rhs, ERROR_MARK,
45197 : : NULL_TREE, NULL, tf_warning_or_error);
45198 : : }
45199 : : }
45200 : 384 : while (token->type == CPP_PLUS || token->type == CPP_MINUS);
45201 : :
45202 : 326 : if (!decl_first)
45203 : : {
45204 : 115 : if ((rhs != decl
45205 : 0 : && (!processing_template_decl || !cp_tree_equal (rhs, decl)))
45206 : 115 : || op == MINUS_EXPR)
45207 : 0 : return error_mark_node;
45208 : 115 : rhs = build2 (op, TREE_TYPE (decl), lhs, decl);
45209 : : }
45210 : : else
45211 : 211 : rhs = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, lhs);
45212 : :
45213 : 326 : return build2 (MODIFY_EXPR, TREE_TYPE (decl), decl, rhs);
45214 : : }
45215 : :
45216 : : /* Parse the initialization statement of an OpenMP for loop. Range-for
45217 : : is handled separately in cp_convert_omp_range_for.
45218 : :
45219 : : On entry SL is the current statement list. Parsing of some forms
45220 : : of initialization pops this list and stores its contents in either INIT
45221 : : or THIS_PRE_BODY, and sets SL to null. Initialization for class
45222 : : iterators is added directly to SL and it is not popped until later.
45223 : :
45224 : : On return, DECL is set if the initialization is by binding the
45225 : : iteration variable. If the initialization is by assignment, REAL_DECL
45226 : : is set to point to a variable in an outer scope. ORIG_INIT is set
45227 : : if the iteration variable is of class type; this is a copy saved for
45228 : : error checking in finish_omp_for.
45229 : :
45230 : : Return true if the resulting construct should have an
45231 : : OMP_CLAUSE_PRIVATE added to it. */
45232 : :
45233 : : static tree
45234 : 23970 : cp_parser_omp_for_loop_init (cp_parser *parser,
45235 : : tree &this_pre_body,
45236 : : tree &sl,
45237 : : tree &init,
45238 : : tree &orig_init,
45239 : : tree &decl,
45240 : : tree &real_decl)
45241 : : {
45242 : 23970 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
45243 : : return NULL_TREE;
45244 : :
45245 : 23967 : tree add_private_clause = NULL_TREE;
45246 : :
45247 : : /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
45248 : :
45249 : : init-expr:
45250 : : var = lb
45251 : : integer-type var = lb
45252 : : random-access-iterator-type var = lb
45253 : : pointer-type var = lb
45254 : : */
45255 : 23967 : cp_decl_specifier_seq type_specifiers;
45256 : :
45257 : : /* First, try to parse as an initialized declaration. See
45258 : : cp_parser_condition, from whence the bulk of this is copied. */
45259 : :
45260 : 23967 : cp_parser_parse_tentatively (parser);
45261 : 23967 : cp_parser_type_specifier_seq (parser, CP_PARSER_FLAGS_NONE,
45262 : : /*is_declaration=*/true,
45263 : : /*is_trailing_return=*/false,
45264 : : &type_specifiers);
45265 : 23967 : if (cp_parser_parse_definitely (parser))
45266 : : {
45267 : : /* If parsing a type specifier seq succeeded, then this
45268 : : MUST be a initialized declaration. */
45269 : 7869 : tree asm_specification, attributes;
45270 : 7869 : cp_declarator *declarator;
45271 : :
45272 : 7869 : declarator = cp_parser_declarator (parser,
45273 : : CP_PARSER_DECLARATOR_NAMED,
45274 : : CP_PARSER_FLAGS_NONE,
45275 : : /*ctor_dtor_or_conv_p=*/NULL,
45276 : : /*parenthesized_p=*/NULL,
45277 : : /*member_p=*/false,
45278 : : /*friend_p=*/false,
45279 : : /*static_p=*/false);
45280 : 7869 : attributes = cp_parser_attributes_opt (parser);
45281 : 7869 : asm_specification = cp_parser_asm_specification_opt (parser);
45282 : :
45283 : 7869 : if (declarator == cp_error_declarator)
45284 : 0 : cp_parser_skip_to_end_of_statement (parser);
45285 : :
45286 : : else
45287 : : {
45288 : 7869 : tree pushed_scope, auto_node;
45289 : :
45290 : 7869 : decl = start_decl (declarator, &type_specifiers,
45291 : : SD_INITIALIZED, attributes,
45292 : : /*prefix_attributes=*/NULL_TREE,
45293 : : &pushed_scope);
45294 : :
45295 : 7869 : auto_node = type_uses_auto (TREE_TYPE (decl));
45296 : 7869 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
45297 : : {
45298 : 6 : if (cp_lexer_next_token_is (parser->lexer,
45299 : : CPP_OPEN_PAREN))
45300 : 3 : error ("parenthesized initialization is not allowed in "
45301 : : "OpenMP %<for%> loop");
45302 : : else
45303 : : /* Trigger an error. */
45304 : 3 : cp_parser_require (parser, CPP_EQ, RT_EQ);
45305 : :
45306 : 6 : init = error_mark_node;
45307 : 6 : cp_parser_skip_to_end_of_statement (parser);
45308 : : }
45309 : 15726 : else if (CLASS_TYPE_P (TREE_TYPE (decl))
45310 : 7639 : || type_dependent_expression_p (decl)
45311 : 15277 : || auto_node)
45312 : : {
45313 : 464 : bool is_non_constant_init;
45314 : :
45315 : 464 : init = cp_parser_initializer (parser,
45316 : : /*is_direct_init=*/nullptr,
45317 : : &is_non_constant_init);
45318 : :
45319 : 464 : if (auto_node)
45320 : : {
45321 : 22 : TREE_TYPE (decl)
45322 : 22 : = do_auto_deduction (TREE_TYPE (decl), init,
45323 : : auto_node);
45324 : :
45325 : 44 : if (!CLASS_TYPE_P (TREE_TYPE (decl))
45326 : 31 : && !type_dependent_expression_p (decl))
45327 : 4 : goto non_class;
45328 : : }
45329 : :
45330 : 460 : cp_finish_decl (decl, init, !is_non_constant_init,
45331 : : asm_specification,
45332 : : LOOKUP_ONLYCONVERTING);
45333 : 460 : orig_init = init;
45334 : :
45335 : : /* In the case of a class iterator, do not pop sl here.
45336 : : Both class initialization and finalization must happen in
45337 : : the enclosing init block scope. For now set the init
45338 : : expression to null; it'll be filled in properly in
45339 : : finish_omp_for before stuffing it in the OMP_FOR. */
45340 : 460 : if (CLASS_TYPE_P (TREE_TYPE (decl)))
45341 : 237 : init = NULL_TREE;
45342 : : else /* It is a parameterized type. */
45343 : : {
45344 : 223 : init = pop_stmt_list (sl);
45345 : 223 : sl = NULL_TREE;
45346 : 223 : if (init && TREE_CODE (init) == STATEMENT_LIST)
45347 : : {
45348 : 2 : tree_stmt_iterator i = tsi_start (init);
45349 : : /* Move lambda DECL_EXPRs to the enclosing block. */
45350 : 7 : while (!tsi_end_p (i))
45351 : : {
45352 : 5 : tree t = tsi_stmt (i);
45353 : 8 : if (TREE_CODE (t) == DECL_EXPR
45354 : 5 : && TREE_CODE (DECL_EXPR_DECL (t)) == TYPE_DECL)
45355 : : {
45356 : 3 : tsi_delink (&i);
45357 : 3 : add_stmt (t);
45358 : 3 : continue;
45359 : : }
45360 : : break;
45361 : : }
45362 : 4 : if (tsi_one_before_end_p (i))
45363 : : {
45364 : 2 : tree t = tsi_stmt (i);
45365 : 2 : tsi_delink (&i);
45366 : 2 : free_stmt_list (init);
45367 : 2 : init = t;
45368 : : }
45369 : : }
45370 : : }
45371 : : }
45372 : : else
45373 : : /* This is an initialized declaration of non-class,
45374 : : non-parameterized type iteration variable. */
45375 : : {
45376 : : /* Consume '='. */
45377 : 7399 : cp_lexer_consume_token (parser->lexer);
45378 : 7399 : init = cp_parser_assignment_expression (parser);
45379 : :
45380 : 7403 : non_class:
45381 : 7403 : if (TYPE_REF_P (TREE_TYPE (decl)))
45382 : 6 : init = error_mark_node;
45383 : : else
45384 : 7397 : cp_finish_decl (decl, NULL_TREE,
45385 : : /*init_const_expr_p=*/false,
45386 : : asm_specification,
45387 : : LOOKUP_ONLYCONVERTING);
45388 : 7403 : this_pre_body = pop_stmt_list (sl);
45389 : 7403 : sl = NULL_TREE;
45390 : : }
45391 : :
45392 : 7869 : if (pushed_scope)
45393 : 0 : pop_scope (pushed_scope);
45394 : : }
45395 : : }
45396 : : else
45397 : : {
45398 : 16098 : cp_id_kind idk;
45399 : : /* If parsing a type specifier sequence failed, then
45400 : : this MUST be a simple expression. */
45401 : 16098 : cp_parser_parse_tentatively (parser);
45402 : 16098 : decl = cp_parser_primary_expression (parser, false, false,
45403 : : false, &idk);
45404 : 16098 : cp_token *last_tok = cp_lexer_peek_token (parser->lexer);
45405 : 16098 : if (!cp_parser_error_occurred (parser)
45406 : 16098 : && decl
45407 : 16098 : && (TREE_CODE (decl) == COMPONENT_REF
45408 : 16083 : || (TREE_CODE (decl) == SCOPE_REF && TREE_TYPE (decl))))
45409 : : {
45410 : 19 : cp_parser_abort_tentative_parse (parser);
45411 : 19 : cp_parser_parse_tentatively (parser);
45412 : 19 : cp_token *token = cp_lexer_peek_token (parser->lexer);
45413 : 19 : tree name = cp_parser_id_expression (parser, /*template_p=*/false,
45414 : : /*check_dependency_p=*/true,
45415 : : /*template_p=*/NULL,
45416 : : /*declarator_p=*/false,
45417 : : /*optional_p=*/false);
45418 : 19 : if (name != error_mark_node
45419 : 19 : && last_tok == cp_lexer_peek_token (parser->lexer))
45420 : : {
45421 : 19 : decl = cp_parser_lookup_name_simple (parser, name,
45422 : : token->location);
45423 : 19 : if (TREE_CODE (decl) == FIELD_DECL)
45424 : 19 : add_private_clause = omp_privatize_field (decl, false);
45425 : : }
45426 : 19 : cp_parser_abort_tentative_parse (parser);
45427 : 19 : cp_parser_parse_tentatively (parser);
45428 : 19 : decl = cp_parser_primary_expression (parser, false, false,
45429 : : false, &idk);
45430 : : }
45431 : 16098 : if (!cp_parser_error_occurred (parser)
45432 : 16098 : && decl
45433 : 16098 : && DECL_P (decl)
45434 : 16071 : && CLASS_TYPE_P (TREE_TYPE (decl)))
45435 : : {
45436 : 432 : tree rhs;
45437 : :
45438 : 432 : cp_parser_parse_definitely (parser);
45439 : 432 : cp_parser_require (parser, CPP_EQ, RT_EQ);
45440 : 432 : rhs = cp_parser_assignment_expression (parser);
45441 : 432 : orig_init = rhs;
45442 : 432 : finish_expr_stmt (build_x_modify_expr (EXPR_LOCATION (rhs),
45443 : : decl, NOP_EXPR,
45444 : : rhs, NULL_TREE,
45445 : : tf_warning_or_error));
45446 : 432 : if (!add_private_clause)
45447 : 427 : add_private_clause = decl;
45448 : : }
45449 : : else
45450 : : {
45451 : 15666 : decl = NULL;
45452 : 15666 : cp_parser_abort_tentative_parse (parser);
45453 : 15666 : init = cp_parser_expression (parser);
45454 : 15666 : if (init)
45455 : : {
45456 : 15666 : if (TREE_CODE (init) == MODIFY_EXPR
45457 : 413 : || TREE_CODE (init) == MODOP_EXPR)
45458 : 15642 : real_decl = TREE_OPERAND (init, 0);
45459 : : }
45460 : : }
45461 : 16098 : this_pre_body = pop_stmt_list (sl);
45462 : 16098 : sl = NULL_TREE;
45463 : : }
45464 : : return add_private_clause;
45465 : : }
45466 : :
45467 : : /* Helper for cp_parser_omp_loop_nest, handle one range-for loop
45468 : : including introducing new temporaries for the range start and end,
45469 : : doing auto deduction, and processing decomposition variables.
45470 : :
45471 : : This function is also called from pt.cc during template instantiation.
45472 : : In that case SL is NULL_TREE, otherwise it is the current statement
45473 : : list. */
45474 : : void
45475 : 442 : cp_convert_omp_range_for (tree &this_pre_body, tree &sl,
45476 : : tree &decl, tree &orig_decl, tree &init,
45477 : : tree &orig_init, tree &cond, tree &incr,
45478 : : bool tmpl_p)
45479 : : {
45480 : 442 : tree begin, end, range_temp_decl = NULL_TREE;
45481 : 442 : tree iter_type, begin_expr, end_expr;
45482 : 442 : bool clear_has_value_expr = false;
45483 : :
45484 : 442 : if (processing_template_decl)
45485 : : {
45486 : 170 : if (check_for_bare_parameter_packs (init))
45487 : 0 : init = error_mark_node;
45488 : 170 : if (!type_dependent_expression_p (init)
45489 : : /* do_auto_deduction doesn't mess with template init-lists. */
45490 : 170 : && !BRACE_ENCLOSED_INITIALIZER_P (init))
45491 : : {
45492 : 114 : tree d = decl;
45493 : 114 : cp_decomp decomp_d, *decomp = NULL;
45494 : 114 : if (decl != error_mark_node && DECL_HAS_VALUE_EXPR_P (decl))
45495 : : {
45496 : 21 : tree v = DECL_VALUE_EXPR (decl);
45497 : 21 : if (TREE_CODE (v) == ARRAY_REF
45498 : 21 : && DECL_DECOMPOSITION_P (TREE_OPERAND (v, 0)))
45499 : : {
45500 : 21 : d = TREE_OPERAND (v, 0);
45501 : 21 : decomp = &decomp_d;
45502 : 21 : decomp->count = tree_to_uhwi (TREE_OPERAND (v, 1)) + 1;
45503 : 21 : decomp->decl = decl;
45504 : : }
45505 : : }
45506 : 114 : do_range_for_auto_deduction (d, init, decomp);
45507 : : }
45508 : 170 : cond = global_namespace;
45509 : 170 : incr = NULL_TREE;
45510 : 170 : orig_init = init;
45511 : 170 : if (sl)
45512 : : {
45513 : 165 : this_pre_body = pop_stmt_list (sl);
45514 : 165 : sl = NULL_TREE;
45515 : : }
45516 : 170 : return;
45517 : : }
45518 : :
45519 : 272 : init = mark_lvalue_use (init);
45520 : :
45521 : 272 : if (decl == error_mark_node || init == error_mark_node)
45522 : : /* If an error happened previously do nothing or else a lot of
45523 : : unhelpful errors would be issued. */
45524 : 2 : begin_expr = end_expr = iter_type = error_mark_node;
45525 : : else
45526 : : {
45527 : 270 : tree range_temp;
45528 : :
45529 : 270 : if (VAR_P (init)
45530 : 270 : && array_of_runtime_bound_p (TREE_TYPE (init)))
45531 : : /* Can't bind a reference to an array of runtime bound. */
45532 : 0 : range_temp = init;
45533 : : else
45534 : : {
45535 : 270 : range_temp = build_range_temp (init);
45536 : 270 : tree name = DECL_NAME (range_temp);
45537 : : /* Temporarily clear DECL_NAME of the __for_range temporary.
45538 : : While it contains a space at the end and outside of templates
45539 : : it works even without doing this, when cp_convert_omp_range_for
45540 : : is called from tsubst_omp_for_iterator, all the associated loops
45541 : : are in a single scope and so loop nests with 2 or more range
45542 : : based for loops would error. */
45543 : 270 : if (tmpl_p)
45544 : 157 : DECL_NAME (range_temp) = NULL_TREE;
45545 : 270 : pushdecl (range_temp);
45546 : : /* Restore the name back. This is needed for cp_finish_decl
45547 : : lifetime extension of temporaries, and can be helpful for user
45548 : : during debugging after the DECL_NAME is changed to __for_range
45549 : : without space at the end. */
45550 : 270 : if (tmpl_p)
45551 : 157 : DECL_NAME (range_temp) = name;
45552 : 270 : cp_finish_decl (range_temp, init,
45553 : : /*is_constant_init*/false, NULL_TREE,
45554 : : LOOKUP_ONLYCONVERTING);
45555 : : /* And clear the name again. pop_scope requires that the name
45556 : : used during pushdecl didn't change. */
45557 : 270 : if (tmpl_p)
45558 : 157 : DECL_NAME (range_temp) = NULL_TREE;
45559 : 270 : range_temp_decl = range_temp;
45560 : 270 : range_temp = convert_from_reference (range_temp);
45561 : : }
45562 : 270 : iter_type = cp_parser_perform_range_for_lookup (range_temp,
45563 : : &begin_expr, &end_expr);
45564 : : }
45565 : :
45566 : 272 : tree end_iter_type = iter_type;
45567 : 272 : if (cxx_dialect >= cxx17)
45568 : 243 : end_iter_type = cv_unqualified (TREE_TYPE (end_expr));
45569 : 272 : end = build_decl (input_location, VAR_DECL, NULL_TREE, end_iter_type);
45570 : 272 : TREE_USED (end) = 1;
45571 : 272 : DECL_ARTIFICIAL (end) = 1;
45572 : 272 : pushdecl (end);
45573 : 272 : cp_finish_decl (end, end_expr,
45574 : : /*is_constant_init*/false, NULL_TREE,
45575 : : LOOKUP_ONLYCONVERTING);
45576 : :
45577 : : /* The new for initialization statement. */
45578 : 272 : begin = build_decl (input_location, VAR_DECL, NULL_TREE, iter_type);
45579 : 272 : TREE_USED (begin) = 1;
45580 : 272 : DECL_ARTIFICIAL (begin) = 1;
45581 : 272 : pushdecl (begin);
45582 : 272 : orig_init = init;
45583 : 272 : if (CLASS_TYPE_P (iter_type))
45584 : 116 : init = NULL_TREE;
45585 : : else
45586 : : {
45587 : 156 : init = begin_expr;
45588 : 156 : begin_expr = NULL_TREE;
45589 : : }
45590 : 272 : cp_finish_decl (begin, begin_expr,
45591 : : /*is_constant_init*/false, NULL_TREE,
45592 : : LOOKUP_ONLYCONVERTING);
45593 : :
45594 : : /* The new for condition. */
45595 : 272 : if (CLASS_TYPE_P (iter_type))
45596 : 116 : cond = build2 (NE_EXPR, boolean_type_node, begin, end);
45597 : : else
45598 : 156 : cond = build_x_binary_op (input_location, NE_EXPR,
45599 : : begin, ERROR_MARK,
45600 : : end, ERROR_MARK,
45601 : : NULL_TREE, NULL, tf_warning_or_error);
45602 : :
45603 : : /* The new increment expression. */
45604 : 272 : if (CLASS_TYPE_P (iter_type))
45605 : 116 : incr = build2 (PREINCREMENT_EXPR, iter_type, begin, NULL_TREE);
45606 : : else
45607 : 156 : incr = finish_unary_op_expr (input_location,
45608 : : PREINCREMENT_EXPR, begin,
45609 : : tf_warning_or_error);
45610 : :
45611 : 272 : orig_decl = decl;
45612 : 272 : decl = begin;
45613 : : /* Defer popping sl here. */
45614 : :
45615 : 272 : cp_decomp decomp_d, *decomp = NULL;
45616 : 272 : if (orig_decl != error_mark_node && DECL_HAS_VALUE_EXPR_P (orig_decl))
45617 : : {
45618 : 65 : tree v = DECL_VALUE_EXPR (orig_decl);
45619 : 65 : if (TREE_CODE (v) == ARRAY_REF
45620 : 65 : && DECL_DECOMPOSITION_P (TREE_OPERAND (v, 0)))
45621 : : {
45622 : 65 : tree d = orig_decl;
45623 : 65 : orig_decl = TREE_OPERAND (v, 0);
45624 : 65 : decomp = &decomp_d;
45625 : 65 : decomp->count = tree_to_uhwi (TREE_OPERAND (v, 1)) + 1;
45626 : 65 : decomp->decl = d;
45627 : : }
45628 : : }
45629 : :
45630 : 272 : tree auto_node = type_uses_auto (TREE_TYPE (orig_decl));
45631 : 272 : if (auto_node)
45632 : : {
45633 : 147 : tree t = build_x_indirect_ref (input_location, begin, RO_UNARY_STAR,
45634 : : NULL_TREE, tf_none);
45635 : 147 : if (!error_operand_p (t))
45636 : : {
45637 : 147 : TREE_TYPE (orig_decl) = do_auto_deduction (TREE_TYPE (orig_decl),
45638 : : t, auto_node);
45639 : 147 : if (decomp)
45640 : : {
45641 : 46 : ++processing_template_decl;
45642 : 46 : cp_finish_decomp (orig_decl, decomp);
45643 : 46 : --processing_template_decl;
45644 : 46 : if (!processing_template_decl)
45645 : 171 : clear_has_value_expr = true;
45646 : : }
45647 : : }
45648 : : }
45649 : :
45650 : : /* The output ORIG_DECL is not a decl. Instead, it is a tree structure
45651 : : that holds decls for variables implementing the iterator, represented
45652 : : as a TREE_LIST whose TREE_CHAIN is a vector. The first two elements
45653 : : of the vector are decls of scratch variables for the range start and
45654 : : end that will eventually be bound in the implicit scope surrounding
45655 : : the whole loop nest. The remaining elements are decls of derived
45656 : : decomposition variables that are bound inside the loop body. This
45657 : : structure is further mangled by finish_omp_for into the form required
45658 : : for the OMP_FOR_ORIG_DECLS field of the OMP_FOR tree node. */
45659 : 171 : unsigned decomp_cnt = decomp ? decomp->count : 0;
45660 : 272 : tree v = make_tree_vec (decomp_cnt + 3);
45661 : 272 : TREE_VEC_ELT (v, 0) = range_temp_decl;
45662 : 272 : TREE_VEC_ELT (v, 1) = end;
45663 : 272 : TREE_VEC_ELT (v, 2) = orig_decl;
45664 : 272 : if (clear_has_value_expr)
45665 : 46 : TREE_PUBLIC (v) = 1;
45666 : 463 : for (unsigned i = 0; i < decomp_cnt; i++)
45667 : : {
45668 : 191 : if (clear_has_value_expr)
45669 : : {
45670 : : /* If cp_finish_decomp was called with processing_template_decl
45671 : : temporarily set to 1, then decomp names will have deduced
45672 : : name but the DECL_VALUE_EXPR will be dependent. Hide those
45673 : : from folding of other loop initializers e.g. for warning
45674 : : purposes until cp_finish_omp_range_for. */
45675 : 137 : gcc_checking_assert (DECL_HAS_VALUE_EXPR_P (decomp->decl)
45676 : : || (TREE_TYPE (decomp->decl)
45677 : : == error_mark_node));
45678 : 137 : DECL_HAS_VALUE_EXPR_P (decomp->decl) = 0;
45679 : : }
45680 : 191 : TREE_VEC_ELT (v, i + 3) = decomp->decl;
45681 : 191 : decomp->decl = DECL_CHAIN (decomp->decl);
45682 : : }
45683 : 272 : orig_decl = tree_cons (NULL_TREE, NULL_TREE, v);
45684 : : }
45685 : :
45686 : : /* Helper for cp_parser_omp_for_loop, finalize part of range for
45687 : : inside of the collapsed body. */
45688 : :
45689 : : void
45690 : 272 : cp_finish_omp_range_for (tree orig, tree begin)
45691 : : {
45692 : 272 : gcc_assert (TREE_CODE (orig) == TREE_LIST
45693 : : && TREE_CODE (TREE_CHAIN (orig)) == TREE_VEC);
45694 : 272 : tree decl = TREE_VEC_ELT (TREE_CHAIN (orig), 2);
45695 : 272 : cp_decomp decomp_d, *decomp = NULL;
45696 : :
45697 : 272 : if (DECL_DECOMPOSITION_P (decl))
45698 : : {
45699 : 65 : decomp = &decomp_d;
45700 : 65 : decomp_d.decl = TREE_VEC_ELT (TREE_CHAIN (orig), 3);
45701 : 65 : decomp_d.count = TREE_VEC_LENGTH (TREE_CHAIN (orig)) - 3;
45702 : 65 : if (TREE_PUBLIC (TREE_CHAIN (orig)))
45703 : : {
45704 : : /* Undo temporary clearing of DECL_HAS_VALUE_EXPR_P done
45705 : : by cp_convert_omp_range_for above. */
45706 : 46 : TREE_PUBLIC (TREE_CHAIN (orig)) = 0;
45707 : 46 : tree d = decomp_d.decl;
45708 : 183 : for (unsigned i = 0; i < decomp_d.count; i++)
45709 : : {
45710 : 137 : if (TREE_TYPE (d) != error_mark_node)
45711 : 135 : DECL_HAS_VALUE_EXPR_P (d) = 1;
45712 : 137 : d = DECL_CHAIN (d);
45713 : : }
45714 : : }
45715 : : }
45716 : :
45717 : : /* The declaration is initialized with *__begin inside the loop body. */
45718 : 272 : cp_finish_decl (decl,
45719 : : build_x_indirect_ref (input_location, begin, RO_UNARY_STAR,
45720 : : NULL_TREE, tf_warning_or_error),
45721 : : /*is_constant_init*/false, NULL_TREE,
45722 : : LOOKUP_ONLYCONVERTING, decomp);
45723 : 272 : }
45724 : :
45725 : : /* Return true if next tokens contain a standard attribute that contains
45726 : : omp::directive (DIRECTIVE). */
45727 : :
45728 : : static bool
45729 : 867 : cp_parser_omp_section_scan (cp_parser *parser, const char *directive,
45730 : : bool tentative)
45731 : : {
45732 : 867 : size_t n = cp_parser_skip_attributes_opt (parser, 1), i;
45733 : 867 : if (n < 10)
45734 : : return false;
45735 : 312 : for (i = 5; i < n - 4; i++)
45736 : 309 : if (cp_lexer_nth_token_is (parser->lexer, i, CPP_NAME)
45737 : 198 : && cp_lexer_nth_token_is (parser->lexer, i + 1, CPP_OPEN_PAREN)
45738 : 468 : && cp_lexer_nth_token_is (parser->lexer, i + 2, CPP_NAME))
45739 : : {
45740 : 159 : tree first = cp_lexer_peek_nth_token (parser->lexer, i)->u.value;
45741 : 159 : tree second = cp_lexer_peek_nth_token (parser->lexer, i + 2)->u.value;
45742 : 159 : if (strcmp (IDENTIFIER_POINTER (first), "directive")
45743 : 159 : && strcmp (IDENTIFIER_POINTER (first), "__directive__"))
45744 : 42 : continue;
45745 : 117 : if (strcmp (IDENTIFIER_POINTER (second), directive) == 0)
45746 : : break;
45747 : : }
45748 : 111 : if (i == n - 4)
45749 : : return false;
45750 : 108 : cp_parser_parse_tentatively (parser);
45751 : 108 : location_t first_loc = cp_lexer_peek_token (parser->lexer)->location;
45752 : 108 : location_t last_loc
45753 : 108 : = cp_lexer_peek_nth_token (parser->lexer, n - 1)->location;
45754 : 108 : location_t middle_loc = UNKNOWN_LOCATION;
45755 : 108 : tree std_attrs = cp_parser_std_attribute_spec_seq (parser);
45756 : 108 : int cnt = 0;
45757 : 108 : bool seen = false;
45758 : 228 : for (tree attr = std_attrs; attr; attr = TREE_CHAIN (attr))
45759 : 120 : if (get_attribute_namespace (attr) == omp_identifier
45760 : 120 : && is_attribute_p ("directive", get_attribute_name (attr)))
45761 : : {
45762 : 228 : for (tree a = TREE_VALUE (attr); a; a = TREE_CHAIN (a))
45763 : : {
45764 : 120 : tree d = TREE_VALUE (a);
45765 : 120 : gcc_assert (TREE_CODE (d) == DEFERRED_PARSE);
45766 : 120 : cp_token *first = DEFPARSE_TOKENS (d)->first;
45767 : 120 : cnt++;
45768 : 120 : if (first->type == CPP_NAME
45769 : 120 : && strcmp (IDENTIFIER_POINTER (first->u.value),
45770 : : directive) == 0)
45771 : : {
45772 : 108 : seen = true;
45773 : 108 : if (middle_loc == UNKNOWN_LOCATION)
45774 : 108 : middle_loc = first->location;
45775 : : }
45776 : : }
45777 : : }
45778 : 108 : if (!seen || tentative)
45779 : : {
45780 : 6 : cp_parser_abort_tentative_parse (parser);
45781 : 6 : return seen;
45782 : : }
45783 : 102 : if (cnt != 1 || TREE_CHAIN (std_attrs))
45784 : : {
45785 : 24 : error_at (make_location (first_loc, last_loc, middle_loc),
45786 : : "%<[[omp::directive(%s)]]%> must be the only specified "
45787 : : "attribute on a statement", directive);
45788 : 24 : cp_parser_abort_tentative_parse (parser);
45789 : 24 : return false;
45790 : : }
45791 : 78 : if (!cp_parser_parse_definitely (parser))
45792 : : return false;
45793 : 78 : cp_parser_handle_statement_omp_attributes (parser, std_attrs);
45794 : 78 : return true;
45795 : : }
45796 : :
45797 : : /* Parse an OpenMP structured block sequence. KIND is the corresponding
45798 : : separating directive. */
45799 : :
45800 : : static tree
45801 : 1234 : cp_parser_omp_structured_block_sequence (cp_parser *parser,
45802 : : enum pragma_kind kind)
45803 : : {
45804 : 1234 : tree stmt = begin_omp_structured_block ();
45805 : 1234 : unsigned int save = cp_parser_begin_omp_structured_block (parser);
45806 : :
45807 : 1234 : cp_parser_statement (parser, NULL_TREE, false, NULL);
45808 : 1494 : while (true)
45809 : : {
45810 : 1364 : cp_token *token = cp_lexer_peek_token (parser->lexer);
45811 : :
45812 : 1364 : if (token->type == CPP_CLOSE_BRACE
45813 : 725 : || token->type == CPP_EOF
45814 : 725 : || token->type == CPP_PRAGMA_EOL
45815 : 725 : || (token->type == CPP_KEYWORD && token->keyword == RID_AT_END)
45816 : 2089 : || (kind != PRAGMA_NONE
45817 : 699 : && cp_parser_pragma_kind (token) == kind))
45818 : : break;
45819 : :
45820 : 202 : if (kind != PRAGMA_NONE
45821 : 310 : && cp_parser_omp_section_scan (parser,
45822 : : kind == PRAGMA_OMP_SCAN
45823 : : ? "scan" : "section", false))
45824 : : break;
45825 : :
45826 : 130 : cp_parser_statement (parser, NULL_TREE, false, NULL);
45827 : 130 : }
45828 : :
45829 : 1234 : cp_parser_end_omp_structured_block (parser, save);
45830 : 1234 : return finish_omp_structured_block (stmt);
45831 : : }
45832 : :
45833 : :
45834 : : /* OpenMP 5.0:
45835 : :
45836 : : scan-loop-body:
45837 : : { structured-block scan-directive structured-block } */
45838 : :
45839 : : static void
45840 : 294 : cp_parser_omp_scan_loop_body (cp_parser *parser)
45841 : : {
45842 : 294 : tree substmt, clauses = NULL_TREE;
45843 : 294 : bool found_scan = false;
45844 : :
45845 : 294 : matching_braces braces;
45846 : 294 : if (!braces.require_open (parser))
45847 : 3 : return;
45848 : :
45849 : 291 : cp_token *tok = cp_lexer_peek_token (parser->lexer);
45850 : 291 : if (cp_parser_pragma_kind (tok) != PRAGMA_OMP_SCAN)
45851 : 285 : substmt = cp_parser_omp_structured_block_sequence (parser, PRAGMA_OMP_SCAN);
45852 : : else
45853 : : {
45854 : 6 : warning_at (tok->location, OPT_Wopenmp,
45855 : : "%<#pragma omp scan%> with zero preceding executable "
45856 : : "statements");
45857 : 6 : substmt = build_empty_stmt (tok->location);
45858 : : }
45859 : 291 : substmt = build2 (OMP_SCAN, void_type_node, substmt, NULL_TREE);
45860 : 291 : add_stmt (substmt);
45861 : :
45862 : 291 : tok = cp_lexer_peek_token (parser->lexer);
45863 : 291 : if (cp_parser_pragma_kind (tok) == PRAGMA_OMP_SCAN)
45864 : : {
45865 : 270 : enum omp_clause_code clause = OMP_CLAUSE_ERROR;
45866 : 270 : found_scan = true;
45867 : :
45868 : 270 : cp_lexer_consume_token (parser->lexer);
45869 : :
45870 : 270 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
45871 : 18 : cp_lexer_consume_token (parser->lexer);
45872 : :
45873 : 270 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
45874 : : {
45875 : 264 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
45876 : 264 : const char *p = IDENTIFIER_POINTER (id);
45877 : 264 : if (strcmp (p, "inclusive") == 0)
45878 : : clause = OMP_CLAUSE_INCLUSIVE;
45879 : 132 : else if (strcmp (p, "exclusive") == 0)
45880 : : clause = OMP_CLAUSE_EXCLUSIVE;
45881 : : }
45882 : : if (clause != OMP_CLAUSE_ERROR)
45883 : : {
45884 : 264 : cp_lexer_consume_token (parser->lexer);
45885 : 264 : clauses = cp_parser_omp_var_list (parser, clause, NULL_TREE);
45886 : : }
45887 : : else
45888 : 6 : cp_parser_error (parser, "expected %<inclusive%> or "
45889 : : "%<exclusive%> clause");
45890 : :
45891 : 270 : cp_parser_require_pragma_eol (parser, tok);
45892 : : }
45893 : : else
45894 : 21 : error ("expected %<#pragma omp scan%>");
45895 : :
45896 : 291 : clauses = finish_omp_clauses (clauses, C_ORT_OMP);
45897 : 291 : if (!cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
45898 : 264 : substmt = cp_parser_omp_structured_block_sequence (parser, PRAGMA_NONE);
45899 : : else
45900 : : {
45901 : 27 : if (found_scan)
45902 : 6 : warning_at (tok->location, OPT_Wopenmp,
45903 : : "%<#pragma omp scan%> with zero succeeding executable "
45904 : : "statements");
45905 : 27 : substmt = build_empty_stmt (tok->location);
45906 : : }
45907 : 291 : substmt = build2_loc (tok->location, OMP_SCAN, void_type_node, substmt,
45908 : : clauses);
45909 : 291 : add_stmt (substmt);
45910 : :
45911 : 291 : braces.require_close (parser);
45912 : : }
45913 : :
45914 : :
45915 : : /* Check that the next token starts a loop nest. Return true if yes,
45916 : : otherwise diagnose an error if ERROR_P is true and return false. */
45917 : : static bool
45918 : 26464 : cp_parser_next_tokens_can_be_canon_loop (cp_parser *parser, enum tree_code code,
45919 : : bool error_p)
45920 : : {
45921 : 26464 : if (code == OACC_LOOP)
45922 : : {
45923 : 4574 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
45924 : : return true;
45925 : 39 : if (error_p)
45926 : 12 : cp_parser_error (parser, "for statement expected");
45927 : : }
45928 : : else
45929 : : {
45930 : 21890 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
45931 : : return true;
45932 : 2189 : if (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA)
45933 : 2189 : && ((cp_parser_pragma_kind (cp_lexer_peek_token (parser->lexer))
45934 : : == PRAGMA_OMP_UNROLL)
45935 : 775 : || (cp_parser_pragma_kind (cp_lexer_peek_token (parser->lexer))
45936 : : == PRAGMA_OMP_TILE)))
45937 : : return true;
45938 : : /* Skip standard attributes on next for in case they are
45939 : : [[omp::directive (unroll partial (4))]] or
45940 : : [[omp::directive (tile sizes (1, 2, 3))]] etc. */
45941 : 1027 : size_t n = cp_parser_skip_std_attribute_spec_seq (parser, 1);
45942 : 1027 : if (cp_lexer_nth_token_is_keyword (parser->lexer, n, RID_FOR))
45943 : : return true;
45944 : 991 : if (error_p)
45945 : : {
45946 : 12 : if (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
45947 : 3 : error_at (cp_lexer_peek_token (parser->lexer)->location,
45948 : : "loop nest expected");
45949 : : else
45950 : 9 : cp_parser_error (parser, "loop nest expected");
45951 : : }
45952 : : }
45953 : : return false;
45954 : : }
45955 : :
45956 : : static tree cp_parser_omp_unroll (cp_parser *, cp_token *, bool *);
45957 : : static tree cp_parser_omp_tile (cp_parser *, cp_token *, bool *);
45958 : :
45959 : : /* This function parses a single level of a loop nest, invoking itself
45960 : : recursively if necessary.
45961 : :
45962 : : loop-nest :: for (...) loop-body
45963 : : loop-body :: loop-nest
45964 : : | { [intervening-code] loop-body [intervening-code] }
45965 : : | final-loop-body
45966 : : intervening-code :: structured-block-sequence
45967 : : final-loop-body :: structured-block
45968 : :
45969 : : For a collapsed loop nest, only a single OMP_FOR is built, pulling out
45970 : : all the iterator information from the inner loops into vectors in the
45971 : : parser->omp_for_parse_state structure.
45972 : :
45973 : : In the "range for" case, it is transformed into a regular "for" iterator
45974 : : by introducing some temporary variables for the begin/end,
45975 : : as well as bindings of the actual iteration variables which are
45976 : : injected into the body of the loop.
45977 : :
45978 : : Initialization code for iterator variables may end up either in the
45979 : : init vector (simple assignments), in omp_for_parse_state->pre_body
45980 : : (decl_exprs for iterators bound in the for statement), or in the
45981 : : scope surrounding this level of loop initialization.
45982 : :
45983 : : The scopes of class iterator variables and their finalizers need to
45984 : : be adjusted after parsing so that all of the initialization happens
45985 : : in a scope surrounding all of the intervening and body code. For
45986 : : this reason we separately store the initialization and body blocks
45987 : : for each level of loops in the omp_for_parse_state structure and
45988 : : reassemble/reorder them in cp_parser_omp_for. See additional
45989 : : comments there about the use of placeholders, etc. */
45990 : :
45991 : : static tree
45992 : 25434 : cp_parser_omp_loop_nest (cp_parser *parser, bool *if_p)
45993 : : {
45994 : 25434 : tree decl = NULL_TREE, cond = NULL_TREE, incr = NULL_TREE, init = NULL_TREE;
45995 : 25434 : tree orig_init = NULL_TREE, real_decl = NULL_TREE, orig_decl = NULL_TREE;
45996 : 25434 : tree init_block, body_block;
45997 : 25434 : tree init_placeholder, body_placeholder;
45998 : 25434 : tree init_scope;
45999 : 25434 : tree this_pre_body = NULL_TREE;
46000 : 25434 : bool moreloops;
46001 : 25434 : unsigned char save_in_statement;
46002 : 25434 : tree add_private_clause = NULL_TREE;
46003 : 25434 : location_t loc;
46004 : 25434 : bool is_range_for = false;
46005 : 25434 : tree sl = NULL_TREE;
46006 : 25434 : struct omp_for_parse_data *omp_for_parse_state
46007 : : = parser->omp_for_parse_state;
46008 : 25434 : gcc_assert (omp_for_parse_state);
46009 : 25434 : int depth = omp_for_parse_state->depth;
46010 : :
46011 : : /* Handle loop transformations first. Note that when we get here
46012 : : omp_for_parse_state->depth has already been incremented to indicate
46013 : : the depth of the *next* loop, not the level of the loop body the
46014 : : transformation directive appears in. */
46015 : :
46016 : : /* Arrange for C++ standard attribute syntax to be parsed as regular
46017 : : pragmas. Give an error if there are other random attributes present. */
46018 : 25434 : cp_token *token = cp_lexer_peek_token (parser->lexer);
46019 : 25434 : tree std_attrs = cp_parser_std_attribute_spec_seq (parser);
46020 : 25434 : std_attrs = cp_parser_handle_statement_omp_attributes (parser, std_attrs);
46021 : 25434 : if (std_attrs)
46022 : 0 : error_at (token->location,
46023 : : "attributes other than OpenMP directives "
46024 : : "are not allowed on %<for%> in loop nest");
46025 : :
46026 : 25434 : if (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
46027 : : {
46028 : 1186 : tree transform = NULL_TREE, sizes, body = NULL_TREE;
46029 : 1186 : int count = 0;
46030 : 1186 : cp_token *pragma_tok;
46031 : 1186 : tree stmt;
46032 : 1186 : loc = cp_lexer_peek_token (parser->lexer)->location;
46033 : 1186 : switch (cp_parser_pragma_kind (cp_lexer_peek_token (parser->lexer)))
46034 : : {
46035 : 417 : case PRAGMA_OMP_UNROLL:
46036 : 417 : pragma_tok = cp_lexer_consume_token (parser->lexer);
46037 : 417 : parser->lexer->in_pragma = true;
46038 : 417 : body = push_stmt_list ();
46039 : 417 : stmt = push_omp_privatization_clauses (false);
46040 : 417 : transform = cp_parser_omp_unroll (parser, pragma_tok, if_p);
46041 : 417 : pop_omp_privatization_clauses (stmt);
46042 : 417 : body = pop_stmt_list (body);
46043 : 417 : if (transform == NULL_TREE || transform == error_mark_node)
46044 : : {
46045 : 21 : transform = error_mark_node;
46046 : 21 : break;
46047 : : }
46048 : 396 : gcc_assert (TREE_CODE (transform) == OMP_UNROLL);
46049 : 396 : if (omp_find_clause (OMP_FOR_CLAUSES (transform),
46050 : : OMP_CLAUSE_PARTIAL))
46051 : : {
46052 : 312 : if (omp_for_parse_state->count - depth > 1)
46053 : : {
46054 : 28 : error_at (loc, "%<unroll%> construct with %<partial%> "
46055 : : "clause generates just one loop with "
46056 : : "canonical form but %d loops are needed",
46057 : : omp_for_parse_state->count - depth);
46058 : 28 : transform = error_mark_node;
46059 : : }
46060 : : else
46061 : 1186 : count = 1;
46062 : : }
46063 : : else
46064 : : {
46065 : 84 : error_at (loc, "generated loop of %<unroll%> construct "
46066 : : "without %<partial%> clause does not have "
46067 : : "canonical form");
46068 : 84 : transform = error_mark_node;
46069 : : }
46070 : : break;
46071 : 763 : case PRAGMA_OMP_TILE:
46072 : 763 : pragma_tok = cp_lexer_consume_token (parser->lexer);
46073 : 763 : parser->lexer->in_pragma = true;
46074 : 763 : body = push_stmt_list ();
46075 : 763 : stmt = push_omp_privatization_clauses (false);
46076 : 763 : transform = cp_parser_omp_tile (parser, pragma_tok, if_p);
46077 : 763 : pop_omp_privatization_clauses (stmt);
46078 : 763 : body = pop_stmt_list (body);
46079 : 763 : if (transform == NULL_TREE || transform == error_mark_node)
46080 : : {
46081 : 120 : transform = error_mark_node;
46082 : 120 : break;
46083 : : }
46084 : 643 : gcc_assert (TREE_CODE (transform) == OMP_TILE);
46085 : 643 : sizes = omp_find_clause (OMP_FOR_CLAUSES (transform),
46086 : : OMP_CLAUSE_SIZES);
46087 : 643 : gcc_assert (sizes);
46088 : 643 : count = list_length (OMP_CLAUSE_SIZES_LIST (sizes));
46089 : 643 : if (depth + count < omp_for_parse_state->count)
46090 : : {
46091 : 47 : error_at (loc, "%<tile%> construct generates %d loops "
46092 : : "with canonical form but %d loops are needed",
46093 : : count, omp_for_parse_state->count - depth);
46094 : 47 : transform = error_mark_node;
46095 : : }
46096 : : break;
46097 : 6 : default:
46098 : 6 : cp_parser_pragma (parser, pragma_stmt, NULL);
46099 : 6 : break;
46100 : : }
46101 : 1186 : if (transform == NULL_TREE)
46102 : 6 : error_at (loc, "expected %<for%> loop or OpenMP loop "
46103 : : "transformation construct");
46104 : 1186 : if (transform == NULL_TREE || transform == error_mark_node)
46105 : : {
46106 : 306 : omp_for_parse_state->fail = true;
46107 : 306 : return NULL_TREE;
46108 : : }
46109 : 1945 : for (count = omp_for_parse_state->count; depth < count; ++depth)
46110 : : {
46111 : 1065 : TREE_VEC_ELT (omp_for_parse_state->declv, depth) = global_namespace;
46112 : 1065 : TREE_VEC_ELT (omp_for_parse_state->initv, depth) = NULL_TREE;
46113 : 1065 : TREE_VEC_ELT (omp_for_parse_state->condv, depth) = NULL_TREE;
46114 : 1065 : TREE_VEC_ELT (omp_for_parse_state->incrv, depth) = NULL_TREE;
46115 : 1065 : if (omp_for_parse_state->orig_declv)
46116 : 0 : TREE_VEC_ELT (omp_for_parse_state->incrv, depth) = NULL_TREE;
46117 : 1065 : vec_safe_push (omp_for_parse_state->init_blockv, NULL_TREE);
46118 : 1065 : vec_safe_push (omp_for_parse_state->body_blockv, NULL_TREE);
46119 : 1065 : vec_safe_push (omp_for_parse_state->init_placeholderv, NULL_TREE);
46120 : 1065 : vec_safe_push (omp_for_parse_state->body_placeholderv, NULL_TREE);
46121 : : }
46122 : 880 : omp_for_parse_state->want_nested_loop = false;
46123 : 880 : return body;
46124 : : }
46125 : :
46126 : : /* Diagnose errors if we don't have a "for" loop following the
46127 : : optional loop transforms. Otherwise, consume the token. */
46128 : 24248 : if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
46129 : : {
46130 : 0 : omp_for_parse_state->fail = true;
46131 : 0 : cp_token *token = cp_lexer_peek_token (parser->lexer);
46132 : : /* Don't call cp_parser_error here since it overrides the
46133 : : provided message with a more confusing one if there was
46134 : : a bad pragma or attribute directive. */
46135 : 0 : error_at (token->location, "loop nest expected");
46136 : : /* See if we can recover by skipping over bad pragma(s). */
46137 : 0 : while (token->type == CPP_PRAGMA)
46138 : : {
46139 : 0 : cp_parser_skip_to_pragma_eol (parser, token);
46140 : 0 : if (cp_parser_next_tokens_can_be_canon_loop (parser, omp_for_parse_state->code,
46141 : : false))
46142 : 0 : return cp_parser_omp_loop_nest (parser, if_p);
46143 : 0 : token = cp_lexer_peek_token (parser->lexer);
46144 : : }
46145 : : return NULL_TREE;
46146 : : }
46147 : 24248 : loc = cp_lexer_consume_token (parser->lexer)->location;
46148 : :
46149 : : /* Forbid break/continue in the loop initializer, condition, and
46150 : : increment expressions. */
46151 : 24248 : save_in_statement = parser->in_statement;
46152 : 24248 : parser->in_statement = IN_OMP_BLOCK;
46153 : :
46154 : : /* We are not in intervening code now. */
46155 : 24248 : omp_for_parse_state->in_intervening_code = false;
46156 : :
46157 : : /* Don't create location wrapper nodes within an OpenMP "for"
46158 : : statement. */
46159 : 24248 : auto_suppress_location_wrappers sentinel;
46160 : :
46161 : 24248 : matching_parens parens;
46162 : 24248 : if (!parens.require_open (parser))
46163 : : return NULL;
46164 : :
46165 : 24248 : init_placeholder = build_stmt (input_location, EXPR_STMT,
46166 : : integer_zero_node);
46167 : 24248 : vec_safe_push (omp_for_parse_state->init_placeholderv, init_placeholder);
46168 : :
46169 : : /* The init_block acts as a container for this level of loop goo. */
46170 : 24248 : init_block = push_stmt_list ();
46171 : 24248 : vec_safe_push (omp_for_parse_state->init_blockv, init_block);
46172 : :
46173 : : /* Wrap a scope around this entire level of loop to hold bindings
46174 : : of loop iteration variables. We can't insert them directly
46175 : : in the containing scope because that would cause their visibility to
46176 : : be incorrect with respect to intervening code after this loop.
46177 : : We will combine the nested init_scopes in postprocessing after the
46178 : : entire loop is parsed. */
46179 : 24248 : init_scope = begin_compound_stmt (0);
46180 : :
46181 : : /* Now we need another level of statement list container to capture the
46182 : : initialization (and possible finalization) bits. In some cases this
46183 : : container may be popped off during initializer parsing to store code in
46184 : : INIT or THIS_PRE_BODY, depending on the form of initialization. If
46185 : : we have a class iterator we will pop it at the end of parsing this
46186 : : level, so the cleanups are handled correctly. */
46187 : 24248 : sl = push_stmt_list ();
46188 : :
46189 : 24248 : if (omp_for_parse_state->code != OACC_LOOP && cxx_dialect >= cxx11)
46190 : : {
46191 : : /* Save tokens so that we can put them back. */
46192 : 16815 : cp_lexer_save_tokens (parser->lexer);
46193 : :
46194 : : /* Look for ':' that is not nested in () or {}. */
46195 : 16815 : is_range_for
46196 : 16815 : = (cp_parser_skip_to_closing_parenthesis_1 (parser,
46197 : : /*recovering=*/false,
46198 : : CPP_COLON,
46199 : : /*consume_paren=*/
46200 : : false) == -1);
46201 : :
46202 : : /* Roll back the tokens we skipped. */
46203 : 16815 : cp_lexer_rollback_tokens (parser->lexer);
46204 : :
46205 : 16815 : if (is_range_for)
46206 : : {
46207 : 278 : bool saved_colon_corrects_to_scope_p
46208 : : = parser->colon_corrects_to_scope_p;
46209 : :
46210 : : /* A colon is used in range-based for. */
46211 : 278 : parser->colon_corrects_to_scope_p = false;
46212 : :
46213 : : /* Parse the declaration. */
46214 : 278 : cp_parser_simple_declaration (parser,
46215 : : /*function_definition_allowed_p=*/
46216 : : false, &decl);
46217 : 278 : parser->colon_corrects_to_scope_p
46218 : 278 : = saved_colon_corrects_to_scope_p;
46219 : :
46220 : 278 : cp_parser_require (parser, CPP_COLON, RT_COLON);
46221 : :
46222 : 278 : init = cp_parser_range_for (parser, NULL_TREE, NULL_TREE, decl,
46223 : : false, NULL_TREE, false, true);
46224 : :
46225 : 278 : cp_convert_omp_range_for (this_pre_body, sl, decl,
46226 : : orig_decl, init, orig_init,
46227 : : cond, incr, false);
46228 : :
46229 : 278 : if (omp_for_parse_state->ordered_cl)
46230 : 6 : error_at (OMP_CLAUSE_LOCATION (omp_for_parse_state->ordered_cl),
46231 : : "%<ordered%> clause with parameter on "
46232 : : "range-based %<for%> loop");
46233 : :
46234 : 278 : goto parse_close_paren;
46235 : : }
46236 : : }
46237 : :
46238 : 23970 : add_private_clause
46239 : 23970 : = cp_parser_omp_for_loop_init (parser, this_pre_body, sl,
46240 : : init, orig_init, decl, real_decl);
46241 : :
46242 : 23970 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
46243 : :
46244 : : /* If the iteration variable was introduced via a declaration in the
46245 : : for statement, DECL points at it. Otherwise DECL is null and
46246 : : REAL_DECL is a variable previously declared in an outer scope.
46247 : : Make REAL_DECL point at the iteration variable no matter where it
46248 : : was introduced. */
46249 : 23970 : if (decl)
46250 : 8301 : real_decl = decl;
46251 : :
46252 : : /* Some clauses treat iterator variables specially. */
46253 : 23970 : if (omp_for_parse_state->cclauses != NULL
46254 : 10863 : && omp_for_parse_state->cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL] != NULL
46255 : 1691 : && real_decl != NULL_TREE
46256 : 1691 : && omp_for_parse_state->code != OMP_LOOP)
46257 : : {
46258 : 1606 : tree *c;
46259 : 1606 : for (c = &(omp_for_parse_state->cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL]);
46260 : 7558 : *c ; )
46261 : 5952 : if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE
46262 : 5952 : && OMP_CLAUSE_DECL (*c) == real_decl)
46263 : : {
46264 : 3 : error_at (loc, "iteration variable %qD"
46265 : : " should not be firstprivate", real_decl);
46266 : 3 : *c = OMP_CLAUSE_CHAIN (*c);
46267 : : }
46268 : 5949 : else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_LASTPRIVATE
46269 : 5949 : && OMP_CLAUSE_DECL (*c) == real_decl)
46270 : : {
46271 : : /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
46272 : 108 : tree l = *c;
46273 : 108 : *c = OMP_CLAUSE_CHAIN (*c);
46274 : 108 : if (omp_for_parse_state->code == OMP_SIMD)
46275 : : {
46276 : 42 : OMP_CLAUSE_CHAIN (l)
46277 : 42 : = omp_for_parse_state->cclauses[C_OMP_CLAUSE_SPLIT_FOR];
46278 : 42 : omp_for_parse_state->cclauses[C_OMP_CLAUSE_SPLIT_FOR] = l;
46279 : : }
46280 : : else
46281 : : {
46282 : 66 : OMP_CLAUSE_CHAIN (l) = omp_for_parse_state->clauses;
46283 : 66 : omp_for_parse_state->clauses = l;
46284 : : }
46285 : : add_private_clause = NULL_TREE;
46286 : : }
46287 : : else
46288 : : {
46289 : 5841 : if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_PRIVATE
46290 : 5841 : && OMP_CLAUSE_DECL (*c) == real_decl)
46291 : : add_private_clause = NULL_TREE;
46292 : 5841 : c = &OMP_CLAUSE_CHAIN (*c);
46293 : : }
46294 : : }
46295 : :
46296 : 23970 : if (add_private_clause)
46297 : : {
46298 : 411 : tree c;
46299 : 728 : for (c = omp_for_parse_state->clauses; c ; c = OMP_CLAUSE_CHAIN (c))
46300 : : {
46301 : 372 : if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
46302 : 302 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
46303 : 441 : && OMP_CLAUSE_DECL (c) == decl)
46304 : : break;
46305 : 317 : else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
46306 : 317 : && OMP_CLAUSE_DECL (c) == decl)
46307 : 0 : error_at (loc, "iteration variable %qD "
46308 : : "should not be firstprivate",
46309 : : decl);
46310 : 317 : else if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
46311 : 317 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION)
46312 : 317 : && OMP_CLAUSE_DECL (c) == decl)
46313 : 0 : error_at (loc, "iteration variable %qD should not be reduction",
46314 : : decl);
46315 : : }
46316 : 411 : if (c == NULL)
46317 : : {
46318 : 356 : if ((omp_for_parse_state->code == OMP_SIMD
46319 : 10 : && omp_for_parse_state->count != 1)
46320 : 350 : || omp_for_parse_state->code == OMP_LOOP)
46321 : 13 : c = build_omp_clause (loc, OMP_CLAUSE_LASTPRIVATE);
46322 : 343 : else if (omp_for_parse_state->code != OMP_SIMD)
46323 : 339 : c = build_omp_clause (loc, OMP_CLAUSE_PRIVATE);
46324 : : else
46325 : 4 : c = build_omp_clause (loc, OMP_CLAUSE_LINEAR);
46326 : 356 : OMP_CLAUSE_DECL (c) = add_private_clause;
46327 : 356 : c = finish_omp_clauses (c, C_ORT_OMP);
46328 : 356 : if (c)
46329 : : {
46330 : 332 : OMP_CLAUSE_CHAIN (c) = omp_for_parse_state->clauses;
46331 : 332 : omp_for_parse_state->clauses = c;
46332 : : /* For linear, signal that we need to fill up
46333 : : the so far unknown linear step. */
46334 : 332 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR)
46335 : 4 : OMP_CLAUSE_LINEAR_STEP (c) = NULL_TREE;
46336 : : }
46337 : : }
46338 : : }
46339 : :
46340 : 23970 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
46341 : 23958 : cond = cp_parser_omp_for_cond (parser, decl, omp_for_parse_state->code);
46342 : 23970 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
46343 : :
46344 : 23970 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
46345 : : {
46346 : : /* If decl is an iterator, preserve the operator on decl
46347 : : until finish_omp_for. */
46348 : 23961 : if (real_decl
46349 : 23961 : && ((processing_template_decl
46350 : 1175 : && (TREE_TYPE (real_decl) == NULL_TREE
46351 : 1166 : || !INDIRECT_TYPE_P (TREE_TYPE (real_decl))))
46352 : 22782 : || CLASS_TYPE_P (TREE_TYPE (real_decl))))
46353 : 1665 : incr = cp_parser_omp_for_incr (parser, real_decl);
46354 : : else
46355 : 22296 : incr = cp_parser_expression (parser);
46356 : 23961 : protected_set_expr_location_if_unset (incr, input_location);
46357 : : }
46358 : :
46359 : 9 : parse_close_paren:
46360 : 24248 : if (!parens.require_close (parser))
46361 : 9 : cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
46362 : : /*or_comma=*/false,
46363 : : /*consume_paren=*/true);
46364 : :
46365 : : /* We've parsed all the for (...) stuff now. Store the bits. */
46366 : 24248 : TREE_VEC_ELT (omp_for_parse_state->declv, depth) = decl;
46367 : 24248 : TREE_VEC_ELT (omp_for_parse_state->initv, depth) = init;
46368 : 24248 : TREE_VEC_ELT (omp_for_parse_state->condv, depth) = cond;
46369 : 24248 : TREE_VEC_ELT (omp_for_parse_state->incrv, depth) = incr;
46370 : 24248 : if (orig_init)
46371 : : {
46372 : 1170 : omp_for_parse_state->orig_inits.safe_grow_cleared (depth + 1, true);
46373 : 1170 : omp_for_parse_state->orig_inits[depth] = orig_init;
46374 : : }
46375 : 24248 : if (orig_decl)
46376 : : {
46377 : 113 : if (!omp_for_parse_state->orig_declv)
46378 : 106 : omp_for_parse_state->orig_declv
46379 : 106 : = copy_node (omp_for_parse_state->declv);
46380 : 113 : TREE_VEC_ELT (omp_for_parse_state->orig_declv, depth) = orig_decl;
46381 : : }
46382 : 24135 : else if (omp_for_parse_state->orig_declv)
46383 : 18 : TREE_VEC_ELT (omp_for_parse_state->orig_declv, depth) = decl;
46384 : 24248 : if (this_pre_body)
46385 : 23666 : append_to_statement_list_force (this_pre_body,
46386 : : &(omp_for_parse_state->pre_body));
46387 : :
46388 : : /* Start a nested block for the loop body. */
46389 : 24248 : body_placeholder = build_stmt (input_location, EXPR_STMT,
46390 : : integer_zero_node);
46391 : 24248 : vec_safe_push (omp_for_parse_state->body_placeholderv, body_placeholder);
46392 : 24248 : body_block = push_stmt_list ();
46393 : 24248 : vec_safe_push (omp_for_parse_state->body_blockv, body_block);
46394 : :
46395 : 24248 : moreloops = depth < omp_for_parse_state->count - 1;
46396 : 24248 : omp_for_parse_state->want_nested_loop = moreloops;
46397 : 24248 : if (moreloops
46398 : 24248 : && cp_parser_next_tokens_can_be_canon_loop (parser,
46399 : : omp_for_parse_state->code,
46400 : : false))
46401 : : {
46402 : 5686 : omp_for_parse_state->depth++;
46403 : 5686 : tree nest = cp_parser_omp_loop_nest (parser, if_p);
46404 : 5686 : if (nest)
46405 : 5668 : add_stmt (nest);
46406 : 5686 : omp_for_parse_state->depth--;
46407 : : }
46408 : 18562 : else if (moreloops
46409 : 18562 : && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
46410 : : {
46411 : : /* This is the open brace in the loop-body grammar production. Rather
46412 : : than trying to special-case braces, just parse it as a compound
46413 : : statement and handle the nested loop-body case there. Note that
46414 : : when we see a further open brace inside the compound statement
46415 : : loop-body, we don't know whether it is the start of intervening
46416 : : code that is a compound statement, or a level of braces
46417 : : surrounding a nested loop-body. Use the WANT_NESTED_LOOP state
46418 : : bit to ensure we have only one nested loop at each level. */
46419 : :
46420 : 393 : omp_for_parse_state->in_intervening_code = true;
46421 : 393 : cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
46422 : 393 : omp_for_parse_state->in_intervening_code = false;
46423 : :
46424 : 393 : if (omp_for_parse_state->want_nested_loop)
46425 : : {
46426 : : /* We have already parsed the whole loop body and not found a
46427 : : nested loop. */
46428 : 36 : error_at (omp_for_parse_state->for_loc,
46429 : : "not enough nested loops");
46430 : 36 : omp_for_parse_state->fail = true;
46431 : : }
46432 : 24248 : if_p = NULL;
46433 : : }
46434 : : else
46435 : : {
46436 : : /* This is the final-loop-body case in the grammar: we have something
46437 : : that is not a FOR and not an open brace. */
46438 : 18169 : if (moreloops)
46439 : : {
46440 : : /* If we were expecting a nested loop, give an error and mark
46441 : : that parsing has failed, and try to recover by parsing the
46442 : : body as regular code without further collapsing. */
46443 : 32 : error_at (omp_for_parse_state->for_loc,
46444 : : "not enough nested loops");
46445 : 32 : omp_for_parse_state->fail = true;
46446 : : }
46447 : 18169 : parser->in_statement = IN_OMP_FOR;
46448 : :
46449 : : /* Generate the parts of range for that belong in the loop body,
46450 : : to be executed on every iteration. This includes setting the
46451 : : user-declared decomposition variables from the compiler-generated
46452 : : temporaries that are the real iteration variables for OMP_FOR.
46453 : : FIXME: Not sure if this is correct with respect to visibility
46454 : : of the variables from intervening code. However, putting this
46455 : : code in each level of loop instead of all around the innermost
46456 : : body also makes the decomposition variables visible to the
46457 : : inner for init/bound/step exressions, which is not supposed to
46458 : : happen and causes test failures. */
46459 : 18169 : if (omp_for_parse_state->orig_declv)
46460 : 243 : for (int i = 0; i < omp_for_parse_state->count; i++)
46461 : : {
46462 : 137 : tree o = TREE_VEC_ELT (omp_for_parse_state->orig_declv, i);
46463 : 137 : tree d = TREE_VEC_ELT (omp_for_parse_state->declv, i);
46464 : 137 : if (o != d)
46465 : 113 : cp_finish_omp_range_for (o, d);
46466 : : }
46467 : :
46468 : : /* Now parse the final-loop-body for the innermost loop. */
46469 : 18169 : parser->omp_for_parse_state = NULL;
46470 : 18169 : if (omp_for_parse_state->inscan)
46471 : 294 : cp_parser_omp_scan_loop_body (parser);
46472 : : else
46473 : 17875 : cp_parser_statement (parser, NULL_TREE, false, if_p);
46474 : 18169 : parser->omp_for_parse_state = omp_for_parse_state;
46475 : : }
46476 : 24248 : parser->in_statement = save_in_statement;
46477 : 24248 : omp_for_parse_state->want_nested_loop = false;
46478 : 24248 : omp_for_parse_state->in_intervening_code = true;
46479 : :
46480 : : /* Pop and remember the body block. Add the body placeholder
46481 : : to the surrounding statement list instead. This is just a unique
46482 : : token that will be replaced when we reassemble the generated
46483 : : code for the entire omp for statement. */
46484 : 24248 : body_block = pop_stmt_list (body_block);
46485 : 24248 : omp_for_parse_state->body_blockv[depth] = body_block;
46486 : 24248 : add_stmt (body_placeholder);
46487 : :
46488 : : /* Pop and remember the init block. */
46489 : 24248 : if (sl)
46490 : : {
46491 : 359 : sl = pop_stmt_list (sl);
46492 : : /* P2718R0 - Add CLEANUP_POINT_EXPR so that temporaries in
46493 : : for-range-initializer whose lifetime is extended are destructed
46494 : : here. */
46495 : 359 : if (flag_range_for_ext_temps
46496 : 146 : && is_range_for
46497 : 31 : && !processing_template_decl)
46498 : 31 : sl = maybe_cleanup_point_expr_void (sl);
46499 : 359 : add_stmt (sl);
46500 : : }
46501 : 24248 : tree range_for_decl[3] = { NULL_TREE, NULL_TREE, NULL_TREE };
46502 : 24248 : if (is_range_for && !processing_template_decl)
46503 : 113 : find_range_for_decls (range_for_decl);
46504 : 24248 : finish_compound_stmt (init_scope);
46505 : 24248 : init_block = pop_stmt_list (init_block);
46506 : 24248 : omp_for_parse_state->init_blockv[depth] = init_block;
46507 : :
46508 : 24248 : if (is_range_for && !processing_template_decl)
46509 : 452 : for (int i = 0; i < 3; i++)
46510 : 339 : if (range_for_decl[i])
46511 : 113 : DECL_NAME (range_for_decl[i])
46512 : 113 : = cp_global_trees[CPTI_FOR_RANGE_IDENTIFIER + i];
46513 : :
46514 : : /* Return the init placeholder rather than the remembered init block.
46515 : : Again, this is just a unique cookie that will be used to reassemble
46516 : : code pieces when the entire omp for statement has been parsed. */
46517 : : return init_placeholder;
46518 : : }
46519 : :
46520 : : /* Worker for find_structured_blocks. *TP points to a STATEMENT_LIST
46521 : : and ITER is the element that is or contains a nested loop. This
46522 : : function moves the statements before and after ITER into
46523 : : OMP_STRUCTURED_BLOCKs and modifies *TP. */
46524 : : static void
46525 : 158 : insert_structured_blocks (tree *tp, tree_stmt_iterator iter)
46526 : : {
46527 : 158 : tree sl = push_stmt_list ();
46528 : 917 : for (tree_stmt_iterator i = tsi_start (*tp); !tsi_end_p (i); )
46529 : 759 : if (i == iter)
46530 : : {
46531 : 158 : sl = pop_stmt_list (sl);
46532 : 158 : if (TREE_CODE (sl) != STATEMENT_LIST || !tsi_end_p (tsi_start (sl)))
46533 : 155 : tsi_link_before (&i,
46534 : : build1 (OMP_STRUCTURED_BLOCK, void_type_node, sl),
46535 : : TSI_SAME_STMT);
46536 : 158 : i++;
46537 : 158 : sl = push_stmt_list ();
46538 : : }
46539 : : else
46540 : : {
46541 : 601 : tree s = tsi_stmt (i);
46542 : 601 : tsi_delink (&i); /* Advances i to next statement. */
46543 : 601 : add_stmt (s);
46544 : : }
46545 : 158 : sl = pop_stmt_list (sl);
46546 : 158 : if (TREE_CODE (sl) != STATEMENT_LIST || !tsi_end_p (tsi_start (sl)))
46547 : 114 : tsi_link_after (&iter,
46548 : : build1 (OMP_STRUCTURED_BLOCK, void_type_node, sl),
46549 : : TSI_SAME_STMT);
46550 : 158 : }
46551 : :
46552 : : /* Helper to find and mark structured blocks in intervening code for a
46553 : : single loop level with markers for later error checking. *TP is the
46554 : : piece of code to be marked and INNER is the inner loop placeholder.
46555 : : Returns true if INNER was found (recursively) in *TP. */
46556 : : static bool
46557 : 6235 : find_structured_blocks (tree *tp, tree inner)
46558 : : {
46559 : 6403 : if (*tp == inner)
46560 : : return true;
46561 : 693 : else if (TREE_CODE (*tp) == BIND_EXPR)
46562 : 166 : return find_structured_blocks (&(BIND_EXPR_BODY (*tp)), inner);
46563 : 527 : else if (TREE_CODE (*tp) == STATEMENT_LIST)
46564 : : {
46565 : 525 : for (tree_stmt_iterator i = tsi_start (*tp); !tsi_end_p (i); ++i)
46566 : : {
46567 : 525 : tree *p = tsi_stmt_ptr (i);
46568 : : /* The normal case is that there is no intervening code and we
46569 : : do not have to insert any OMP_STRUCTURED_BLOCK markers. */
46570 : 525 : if (find_structured_blocks (p, inner))
46571 : : {
46572 : 161 : if (!(i == tsi_start (*tp) && i == tsi_last (*tp)))
46573 : 158 : insert_structured_blocks (tp, i);
46574 : 158 : return true;
46575 : : }
46576 : : }
46577 : : return false;
46578 : : }
46579 : 369 : else if (TREE_CODE (*tp) == TRY_FINALLY_EXPR)
46580 : 0 : return find_structured_blocks (&(TREE_OPERAND (*tp, 0)), inner);
46581 : 369 : else if (TREE_CODE (*tp) == CLEANUP_STMT)
46582 : 2 : return find_structured_blocks (&(CLEANUP_BODY (*tp)), inner);
46583 : : else
46584 : : return false;
46585 : : }
46586 : :
46587 : : /* Helpers used for relinking tree structures: In tree rooted at
46588 : : CONTEXT, replace ORIG with REPLACEMENT. If FLATTEN is true, try to combine
46589 : : nested BIND_EXPRs. Gives an assertion if it fails to find ORIG. */
46590 : :
46591 : : struct sit_data {
46592 : : tree orig;
46593 : : tree repl;
46594 : : bool flatten;
46595 : : };
46596 : :
46597 : : static tree
46598 : 60262 : substitute_in_tree_walker (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
46599 : : void *dp)
46600 : : {
46601 : 60262 : struct sit_data *sit = (struct sit_data *)dp;
46602 : 60262 : if (*tp == sit->orig)
46603 : : {
46604 : 24908 : *tp = sit->repl;
46605 : 24908 : return *tp;
46606 : : }
46607 : : /* Remove redundant BIND_EXPRs with no bindings even when not specifically
46608 : : trying to flatten. */
46609 : 35354 : else if (TREE_CODE (*tp) == BIND_EXPR
46610 : 9715 : && BIND_EXPR_BODY (*tp) == sit->orig
46611 : 9244 : && !BIND_EXPR_VARS (*tp)
46612 : 37909 : && (sit->flatten || TREE_CODE (sit->repl) == BIND_EXPR))
46613 : : {
46614 : 2523 : *tp = sit->repl;
46615 : 2523 : return *tp;
46616 : : }
46617 : 32831 : else if (sit->flatten
46618 : 30660 : && TREE_CODE (*tp) == BIND_EXPR
46619 : 7016 : && TREE_CODE (sit->repl) == BIND_EXPR)
46620 : : {
46621 : 1427 : if (BIND_EXPR_BODY (*tp) == sit->orig)
46622 : : {
46623 : : /* Merge binding lists for two directly nested BIND_EXPRs,
46624 : : keeping the outer one. */
46625 : 1343 : BIND_EXPR_VARS (*tp) = chainon (BIND_EXPR_VARS (*tp),
46626 : 1343 : BIND_EXPR_VARS (sit->repl));
46627 : 1343 : BIND_EXPR_BODY (*tp) = BIND_EXPR_BODY (sit->repl);
46628 : 1343 : return *tp;
46629 : : }
46630 : 84 : else if (TREE_CODE (BIND_EXPR_BODY (*tp)) == STATEMENT_LIST)
46631 : : /* There might be a statement list containing cleanup_points
46632 : : etc between the two levels of BIND_EXPR. We can still merge
46633 : : them, again keeping the outer BIND_EXPR. */
46634 : 309 : for (tree_stmt_iterator i = tsi_start (BIND_EXPR_BODY (*tp));
46635 : 309 : !tsi_end_p (i); ++i)
46636 : : {
46637 : 254 : tree *p = tsi_stmt_ptr (i);
46638 : 254 : if (*p == sit->orig)
46639 : : {
46640 : 23 : BIND_EXPR_VARS (*tp) = chainon (BIND_EXPR_VARS (*tp),
46641 : 23 : BIND_EXPR_VARS (sit->repl));
46642 : 23 : *p = BIND_EXPR_BODY (sit->repl);
46643 : 23 : return *tp;
46644 : : }
46645 : : }
46646 : : }
46647 : : return NULL;
46648 : : }
46649 : :
46650 : : static void
46651 : 28797 : substitute_in_tree (tree *context, tree orig, tree repl, bool flatten)
46652 : : {
46653 : 28797 : struct sit_data data;
46654 : :
46655 : 28797 : gcc_assert (*context && orig && repl);
46656 : 28797 : if (TREE_CODE (repl) == BIND_EXPR && !BIND_EXPR_VARS (repl))
46657 : 345 : repl = BIND_EXPR_BODY (repl);
46658 : 28797 : data.orig = orig;
46659 : 28797 : data.repl = repl;
46660 : 28797 : data.flatten = flatten;
46661 : :
46662 : 28797 : tree result = cp_walk_tree (context, substitute_in_tree_walker,
46663 : : (void *)&data, NULL);
46664 : 28797 : gcc_assert (result != NULL_TREE);
46665 : 28797 : }
46666 : :
46667 : : /* Walker to patch up the BLOCK_NODE hierarchy after the above surgery.
46668 : : *DP is the parent block. */
46669 : :
46670 : : static tree
46671 : 834066 : fixup_blocks_walker (tree *tp, int *walk_subtrees, void *dp)
46672 : : {
46673 : 834066 : tree superblock = *(tree *)dp;
46674 : :
46675 : : /* BIND_EXPR_BLOCK may be null if the expression is not a
46676 : : full-expression; if there's no block, no patching is necessary
46677 : : for this node. */
46678 : 834066 : if (TREE_CODE (*tp) == BIND_EXPR && BIND_EXPR_BLOCK (*tp))
46679 : : {
46680 : 9322 : tree block = BIND_EXPR_BLOCK (*tp);
46681 : 9322 : if (superblock)
46682 : : {
46683 : 2808 : BLOCK_SUPERCONTEXT (block) = superblock;
46684 : 2808 : BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (superblock);
46685 : 2808 : BLOCK_SUBBLOCKS (superblock) = block;
46686 : : }
46687 : 9322 : BLOCK_SUBBLOCKS (block) = NULL_TREE;
46688 : 9322 : cp_walk_tree (&BIND_EXPR_BODY (*tp), fixup_blocks_walker,
46689 : : (void *)&block, NULL);
46690 : 9322 : *walk_subtrees = 0;
46691 : : }
46692 : :
46693 : 834066 : return NULL;
46694 : : }
46695 : :
46696 : : /* Parse the restricted form of the for statement allowed by OpenMP. */
46697 : :
46698 : : static tree
46699 : 19415 : cp_parser_omp_for_loop (cp_parser *parser, enum tree_code code, tree clauses,
46700 : : tree *cclauses, bool *if_p)
46701 : : {
46702 : 19415 : tree ret;
46703 : 19415 : tree cl, ordered_cl = NULL_TREE;
46704 : 19415 : int collapse = 1, ordered = 0;
46705 : 19415 : unsigned int count;
46706 : 19415 : bool oacc_tiling = false;
46707 : 19415 : bool inscan = false;
46708 : 19415 : struct omp_for_parse_data data;
46709 : 19415 : struct omp_for_parse_data *save_data = parser->omp_for_parse_state;
46710 : 19415 : tree result;
46711 : 19415 : location_t loc_first = cp_lexer_peek_token (parser->lexer)->location;
46712 : :
46713 : 46381 : for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
46714 : 26966 : if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
46715 : 4250 : collapse = tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (cl));
46716 : 22716 : else if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_TILE)
46717 : : {
46718 : 235 : oacc_tiling = true;
46719 : 235 : collapse = list_length (OMP_CLAUSE_TILE_LIST (cl));
46720 : : }
46721 : 22481 : else if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_SIZES)
46722 : 991 : collapse = list_length (OMP_CLAUSE_SIZES_LIST (cl));
46723 : 21490 : else if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_ORDERED
46724 : 21490 : && OMP_CLAUSE_ORDERED_EXPR (cl))
46725 : : {
46726 : 323 : ordered_cl = cl;
46727 : 323 : ordered = tree_to_shwi (OMP_CLAUSE_ORDERED_EXPR (cl));
46728 : : }
46729 : 21167 : else if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_REDUCTION
46730 : 3489 : && OMP_CLAUSE_REDUCTION_INSCAN (cl)
46731 : 21488 : && (code == OMP_SIMD || code == OMP_FOR))
46732 : : inscan = true;
46733 : :
46734 : 19415 : if (ordered && ordered < collapse)
46735 : : {
46736 : 6 : error_at (OMP_CLAUSE_LOCATION (ordered_cl),
46737 : : "%<ordered%> clause parameter is less than %<collapse%>");
46738 : 6 : OMP_CLAUSE_ORDERED_EXPR (ordered_cl)
46739 : 6 : = build_int_cst (NULL_TREE, collapse);
46740 : 6 : ordered = collapse;
46741 : : }
46742 : :
46743 : 19415 : gcc_assert (oacc_tiling || (collapse >= 1 && ordered >= 0));
46744 : 19415 : count = ordered ? ordered : collapse;
46745 : :
46746 : 19415 : if (!cp_parser_next_tokens_can_be_canon_loop (parser, code, true))
46747 : : return NULL;
46748 : :
46749 : : /* Initialize parse state for recursive descent. */
46750 : 19391 : data.declv = make_tree_vec (count);
46751 : 19391 : data.initv = make_tree_vec (count);
46752 : 19391 : data.condv = make_tree_vec (count);
46753 : 19391 : data.incrv = make_tree_vec (count);
46754 : 19391 : data.pre_body = NULL_TREE;
46755 : 19391 : data.for_loc = cp_lexer_peek_token (parser->lexer)->location;
46756 : 19391 : data.count = count;
46757 : 19391 : data.depth = 0;
46758 : 19391 : data.want_nested_loop = true;
46759 : 19391 : data.ordered = ordered > 0;
46760 : 19391 : data.in_intervening_code = false;
46761 : 19391 : data.perfect_nesting_fail = false;
46762 : 19391 : data.fail = false;
46763 : 19391 : data.inscan = inscan;
46764 : 19391 : data.saw_intervening_code = false;
46765 : 19391 : data.code = code;
46766 : 19391 : data.orig_declv = NULL_TREE;
46767 : 19391 : data.clauses = clauses;
46768 : 19391 : data.cclauses = cclauses;
46769 : 19391 : data.ordered_cl = ordered_cl;
46770 : 19391 : parser->omp_for_parse_state = &data;
46771 : :
46772 : 19391 : tree body = cp_parser_omp_loop_nest (parser, if_p);
46773 : :
46774 : : /* Bomb out early if there was an error (not enough loops, etc). */
46775 : 19391 : if (data.fail || data.declv == NULL_TREE)
46776 : : {
46777 : 444 : parser->omp_for_parse_state = save_data;
46778 : 444 : return NULL_TREE;
46779 : : }
46780 : :
46781 : : /* Relink the init and body blocks that were built during parsing. At
46782 : : this point we have a structure nested like
46783 : : init 0
46784 : : body 0
46785 : : init 1
46786 : : body 1
46787 : : init 2
46788 : : body 2
46789 : : and we want to turn it into
46790 : : init 0
46791 : : init 1
46792 : : init 2
46793 : : omp_for
46794 : : body 0
46795 : : body 1
46796 : : body 2
46797 : : We also need to flatten the init blocks, as some code for later
46798 : : processing of combined directives gets confused otherwise. */
46799 : :
46800 : 18947 : gcc_assert (vec_safe_length (data.init_blockv) == count);
46801 : 18947 : gcc_assert (vec_safe_length (data.body_blockv) == count);
46802 : 18947 : gcc_assert (vec_safe_length (data.init_placeholderv) == count);
46803 : 18947 : gcc_assert (vec_safe_length (data.body_placeholderv) == count);
46804 : :
46805 : : /* First insert markers for structured blocks for intervening code in
46806 : : the loop bodies. */
46807 : 25037 : for (unsigned int i = 0; i < count - 1; i++)
46808 : 6090 : if (data.body_blockv[i])
46809 : 6160 : for (unsigned int j = i + 1; j < count; j++)
46810 : 5965 : if (data.init_placeholderv[j])
46811 : : {
46812 : 11420 : bool good = find_structured_blocks (&data.body_blockv[i],
46813 : 5710 : data.init_placeholderv[j]);
46814 : 5710 : gcc_assert (good);
46815 : : break;
46816 : : }
46817 : :
46818 : : /* Do the substitution from the inside out. */
46819 : 25037 : for (unsigned int i = count - 1; i > 0; i--)
46820 : 6090 : if (data.init_placeholderv[i])
46821 : 5710 : for (unsigned int j = i; j > 0; j--)
46822 : 5710 : if (data.body_blockv[j - 1])
46823 : : {
46824 : 11420 : substitute_in_tree (&data.body_blockv[j - 1],
46825 : 5710 : data.init_placeholderv[i],
46826 : 5710 : data.body_blockv[i], false);
46827 : 22840 : substitute_in_tree (&data.init_blockv[j - 1],
46828 : 5710 : data.body_placeholderv[j - 1],
46829 : 5710 : data.init_blockv[i], true);
46830 : 5710 : break;
46831 : : }
46832 : :
46833 : 19754 : for (unsigned int i = 0; i < count; ++i)
46834 : 19072 : if (data.body_blockv[i])
46835 : : {
46836 : : body = data.body_blockv[i];
46837 : : break;
46838 : : }
46839 : :
46840 : : /* Generate the OMP_FOR. Note finish_omp_for adds the OMP_FOR
46841 : : (and possibly other stuff) to the current statement list but
46842 : : returns a pointer to the OMP_FOR itself, or null in case of error. */
46843 : 18947 : result = push_stmt_list ();
46844 : 18947 : ret = finish_omp_for (loc_first, code, data.declv, data.orig_declv,
46845 : : data.initv, data.condv, data.incrv, body,
46846 : : data.pre_body, &data.orig_inits, data.clauses);
46847 : 18947 : result = pop_stmt_list (result);
46848 : :
46849 : : /* Check for errors involving lb/ub/incr expressions referencing
46850 : : variables declared in intervening code. */
46851 : 18947 : if (data.saw_intervening_code
46852 : 135 : && ret
46853 : 19082 : && !c_omp_check_loop_binding_exprs (ret, &data.orig_inits))
46854 : : ret = NULL_TREE;
46855 : :
46856 : 18899 : if (ret)
46857 : 18866 : for (unsigned int i = 0; i < count; ++i)
46858 : 18184 : if (data.init_blockv[i])
46859 : : {
46860 : 17377 : int j;
46861 : 17560 : for (j = count - 1; j >= 0; --j)
46862 : 17560 : if (data.body_placeholderv[j])
46863 : : break;
46864 : 17377 : gcc_assert (j >= 0);
46865 : :
46866 : : /* Splice the omp_for into the nest of init blocks. */
46867 : 34754 : substitute_in_tree (&data.init_blockv[i],
46868 : 17377 : data.body_placeholderv[j],
46869 : : result, true);
46870 : :
46871 : : /* Some later processing for combined directives assumes
46872 : : that the BIND_EXPR containing range for variables appears
46873 : : at top level in the OMP_FOR body. Fix that up if it's
46874 : : not the case, e.g. because there is intervening code. */
46875 : 17377 : if (code != OACC_LOOP)
46876 : 13053 : finish_omp_for_block (data.init_blockv[i], ret);
46877 : :
46878 : : /* Clean up the block subblock/superblock links. Per comment in
46879 : : begin_compound_stmt, "we don't build BLOCK nodes when processing
46880 : : templates", so skip this step in that case. */
46881 : 17377 : if (!processing_template_decl)
46882 : : {
46883 : 16516 : tree superblock = NULL_TREE;
46884 : 16516 : cp_walk_tree (&data.init_blockv[i], fixup_blocks_walker,
46885 : : (void *)&superblock, NULL);
46886 : : }
46887 : :
46888 : : /* Finally record the result. */
46889 : 17377 : add_stmt (data.init_blockv[0]);
46890 : 17377 : result = NULL_TREE;
46891 : 17377 : break;
46892 : : }
46893 : 18947 : if (ret && result)
46894 : 682 : add_stmt (result);
46895 : :
46896 : 18947 : parser->omp_for_parse_state = save_data;
46897 : 18947 : return ret;
46898 : 19415 : }
46899 : :
46900 : : /* Helper function for OpenMP parsing, split clauses and call
46901 : : finish_omp_clauses on each of the set of clauses afterwards. */
46902 : :
46903 : : static void
46904 : 9019 : cp_omp_split_clauses (location_t loc, enum tree_code code,
46905 : : omp_clause_mask mask, tree clauses, tree *cclauses)
46906 : : {
46907 : 9019 : int i;
46908 : 9019 : c_omp_split_clauses (loc, code, mask, clauses, cclauses);
46909 : 72152 : for (i = 0; i < C_OMP_CLAUSE_SPLIT_COUNT; i++)
46910 : 54114 : if (cclauses[i])
46911 : 29560 : cclauses[i] = finish_omp_clauses (cclauses[i],
46912 : : i == C_OMP_CLAUSE_SPLIT_TARGET
46913 : : ? C_ORT_OMP_TARGET : C_ORT_OMP);
46914 : 9019 : }
46915 : :
46916 : : /* OpenMP 5.0:
46917 : : #pragma omp loop loop-clause[optseq] new-line
46918 : : for-loop */
46919 : :
46920 : : #define OMP_LOOP_CLAUSE_MASK \
46921 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46922 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
46923 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46924 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
46925 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_BIND) \
46926 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
46927 : :
46928 : : static tree
46929 : 694 : cp_parser_omp_loop (cp_parser *parser, cp_token *pragma_tok,
46930 : : char *p_name, omp_clause_mask mask, tree *cclauses,
46931 : : bool *if_p)
46932 : : {
46933 : 694 : tree clauses, sb, ret;
46934 : 694 : unsigned int save;
46935 : 694 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
46936 : :
46937 : 694 : strcat (p_name, " loop");
46938 : 694 : mask |= OMP_LOOP_CLAUSE_MASK;
46939 : :
46940 : 694 : clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
46941 : : cclauses == NULL);
46942 : 694 : if (cclauses)
46943 : : {
46944 : 215 : cp_omp_split_clauses (loc, OMP_LOOP, mask, clauses, cclauses);
46945 : 215 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_LOOP];
46946 : : }
46947 : :
46948 : 694 : keep_next_level (true);
46949 : 694 : sb = begin_omp_structured_block ();
46950 : 694 : save = cp_parser_begin_omp_structured_block (parser);
46951 : :
46952 : 694 : ret = cp_parser_omp_for_loop (parser, OMP_LOOP, clauses, cclauses, if_p);
46953 : :
46954 : 694 : cp_parser_end_omp_structured_block (parser, save);
46955 : 694 : add_stmt (finish_omp_structured_block (sb));
46956 : :
46957 : 694 : return ret;
46958 : : }
46959 : :
46960 : : /* OpenMP 4.0:
46961 : : #pragma omp simd simd-clause[optseq] new-line
46962 : : for-loop */
46963 : :
46964 : : #define OMP_SIMD_CLAUSE_MASK \
46965 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
46966 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
46967 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
46968 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
46969 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46970 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
46971 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46972 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
46973 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46974 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NONTEMPORAL) \
46975 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
46976 : :
46977 : : static tree
46978 : 4708 : cp_parser_omp_simd (cp_parser *parser, cp_token *pragma_tok,
46979 : : char *p_name, omp_clause_mask mask, tree *cclauses,
46980 : : bool *if_p)
46981 : : {
46982 : 4708 : tree clauses, sb, ret;
46983 : 4708 : unsigned int save;
46984 : 4708 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
46985 : :
46986 : 4708 : strcat (p_name, " simd");
46987 : 4708 : mask |= OMP_SIMD_CLAUSE_MASK;
46988 : :
46989 : 4708 : clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
46990 : : cclauses == NULL);
46991 : 4708 : if (cclauses)
46992 : : {
46993 : 3718 : cp_omp_split_clauses (loc, OMP_SIMD, mask, clauses, cclauses);
46994 : 3718 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_SIMD];
46995 : : }
46996 : :
46997 : 4708 : keep_next_level (true);
46998 : 4708 : sb = begin_omp_structured_block ();
46999 : 4708 : save = cp_parser_begin_omp_structured_block (parser);
47000 : :
47001 : 4708 : ret = cp_parser_omp_for_loop (parser, OMP_SIMD, clauses, cclauses, if_p);
47002 : :
47003 : 4708 : cp_parser_end_omp_structured_block (parser, save);
47004 : 4708 : add_stmt (finish_omp_structured_block (sb));
47005 : :
47006 : 4708 : return ret;
47007 : : }
47008 : :
47009 : : /* OpenMP 2.5:
47010 : : #pragma omp for for-clause[optseq] new-line
47011 : : for-loop
47012 : :
47013 : : OpenMP 4.0:
47014 : : #pragma omp for simd for-simd-clause[optseq] new-line
47015 : : for-loop */
47016 : :
47017 : : #define OMP_FOR_CLAUSE_MASK \
47018 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
47019 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
47020 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
47021 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
47022 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
47023 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
47024 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
47025 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
47026 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
47027 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
47028 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
47029 : :
47030 : : static tree
47031 : 9627 : cp_parser_omp_for (cp_parser *parser, cp_token *pragma_tok,
47032 : : char *p_name, omp_clause_mask mask, tree *cclauses,
47033 : : bool *if_p)
47034 : : {
47035 : 9627 : tree clauses, sb, ret;
47036 : 9627 : unsigned int save;
47037 : 9627 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
47038 : :
47039 : 9627 : strcat (p_name, " for");
47040 : 9627 : mask |= OMP_FOR_CLAUSE_MASK;
47041 : : /* parallel for{, simd} disallows nowait clause, but for
47042 : : target {teams distribute ,}parallel for{, simd} it should be accepted. */
47043 : 9627 : if (cclauses && (mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP)) == 0)
47044 : 4326 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT);
47045 : : /* Composite distribute parallel for{, simd} disallows ordered clause. */
47046 : 9627 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
47047 : 3250 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED);
47048 : :
47049 : 9627 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
47050 : : {
47051 : 7458 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
47052 : 7458 : const char *p = IDENTIFIER_POINTER (id);
47053 : :
47054 : 7458 : if (strcmp (p, "simd") == 0)
47055 : : {
47056 : 2697 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
47057 : 2697 : if (cclauses == NULL)
47058 : 508 : cclauses = cclauses_buf;
47059 : :
47060 : 2697 : cp_lexer_consume_token (parser->lexer);
47061 : 2697 : if (!flag_openmp) /* flag_openmp_simd */
47062 : 39 : return cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
47063 : 39 : cclauses, if_p);
47064 : 2658 : sb = begin_omp_structured_block ();
47065 : 2658 : save = cp_parser_begin_omp_structured_block (parser);
47066 : 2658 : ret = cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
47067 : : cclauses, if_p);
47068 : 2658 : cp_parser_end_omp_structured_block (parser, save);
47069 : 2658 : tree body = finish_omp_structured_block (sb);
47070 : 2658 : if (ret == NULL)
47071 : : return ret;
47072 : 2643 : ret = make_node (OMP_FOR);
47073 : 2643 : TREE_TYPE (ret) = void_type_node;
47074 : 2643 : OMP_FOR_BODY (ret) = body;
47075 : 2643 : OMP_FOR_CLAUSES (ret) = cclauses[C_OMP_CLAUSE_SPLIT_FOR];
47076 : 2643 : SET_EXPR_LOCATION (ret, loc);
47077 : 2643 : add_stmt (ret);
47078 : 2643 : return ret;
47079 : : }
47080 : : }
47081 : 6930 : if (!flag_openmp) /* flag_openmp_simd */
47082 : : {
47083 : 27 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
47084 : 27 : return NULL_TREE;
47085 : : }
47086 : :
47087 : : /* Composite distribute parallel for disallows linear clause. */
47088 : 6903 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
47089 : 1686 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR);
47090 : :
47091 : 6903 : clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
47092 : : cclauses == NULL);
47093 : 6903 : if (cclauses)
47094 : : {
47095 : 3356 : cp_omp_split_clauses (loc, OMP_FOR, mask, clauses, cclauses);
47096 : 3356 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_FOR];
47097 : : }
47098 : :
47099 : 6903 : keep_next_level (true);
47100 : 6903 : sb = begin_omp_structured_block ();
47101 : 6903 : save = cp_parser_begin_omp_structured_block (parser);
47102 : :
47103 : 6903 : ret = cp_parser_omp_for_loop (parser, OMP_FOR, clauses, cclauses, if_p);
47104 : :
47105 : 6903 : cp_parser_end_omp_structured_block (parser, save);
47106 : 6903 : add_stmt (finish_omp_structured_block (sb));
47107 : :
47108 : 6903 : return ret;
47109 : : }
47110 : :
47111 : : static tree cp_parser_omp_taskloop (cp_parser *, cp_token *, char *,
47112 : : omp_clause_mask, tree *, bool *);
47113 : :
47114 : : /* OpenMP 2.5:
47115 : : # pragma omp master new-line
47116 : : structured-block */
47117 : :
47118 : : static tree
47119 : 523 : cp_parser_omp_master (cp_parser *parser, cp_token *pragma_tok,
47120 : : char *p_name, omp_clause_mask mask, tree *cclauses,
47121 : : bool *if_p)
47122 : : {
47123 : 523 : tree clauses, sb, ret;
47124 : 523 : unsigned int save;
47125 : 523 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
47126 : :
47127 : 523 : strcat (p_name, " master");
47128 : :
47129 : 523 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
47130 : : {
47131 : 286 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
47132 : 286 : const char *p = IDENTIFIER_POINTER (id);
47133 : :
47134 : 286 : if (strcmp (p, "taskloop") == 0)
47135 : : {
47136 : 269 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
47137 : 269 : if (cclauses == NULL)
47138 : 131 : cclauses = cclauses_buf;
47139 : :
47140 : 269 : cp_lexer_consume_token (parser->lexer);
47141 : 269 : if (!flag_openmp) /* flag_openmp_simd */
47142 : 12 : return cp_parser_omp_taskloop (parser, pragma_tok, p_name, mask,
47143 : 12 : cclauses, if_p);
47144 : 257 : sb = begin_omp_structured_block ();
47145 : 257 : save = cp_parser_begin_omp_structured_block (parser);
47146 : 257 : ret = cp_parser_omp_taskloop (parser, pragma_tok, p_name, mask,
47147 : : cclauses, if_p);
47148 : 257 : cp_parser_end_omp_structured_block (parser, save);
47149 : 257 : tree body = finish_omp_structured_block (sb);
47150 : 257 : if (ret == NULL)
47151 : : return ret;
47152 : 254 : ret = c_finish_omp_master (loc, body);
47153 : 254 : OMP_MASTER_COMBINED (ret) = 1;
47154 : 254 : return ret;
47155 : : }
47156 : : }
47157 : 254 : if (!flag_openmp) /* flag_openmp_simd */
47158 : : {
47159 : 6 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
47160 : 6 : return NULL_TREE;
47161 : : }
47162 : :
47163 : 248 : if (cclauses)
47164 : : {
47165 : 54 : clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
47166 : : false);
47167 : 54 : cp_omp_split_clauses (loc, OMP_MASTER, mask, clauses, cclauses);
47168 : : }
47169 : : else
47170 : 194 : cp_parser_require_pragma_eol (parser, pragma_tok);
47171 : :
47172 : 248 : return c_finish_omp_master (loc,
47173 : 248 : cp_parser_omp_structured_block (parser, if_p));
47174 : : }
47175 : :
47176 : : /* OpenMP 5.1:
47177 : : # pragma omp masked masked-clauses new-line
47178 : : structured-block */
47179 : :
47180 : : #define OMP_MASKED_CLAUSE_MASK \
47181 : : (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FILTER)
47182 : :
47183 : : static tree
47184 : 261 : cp_parser_omp_masked (cp_parser *parser, cp_token *pragma_tok,
47185 : : char *p_name, omp_clause_mask mask, tree *cclauses,
47186 : : bool *if_p)
47187 : : {
47188 : 261 : tree clauses, sb, ret;
47189 : 261 : unsigned int save;
47190 : 261 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
47191 : :
47192 : 261 : strcat (p_name, " masked");
47193 : 261 : mask |= OMP_MASKED_CLAUSE_MASK;
47194 : :
47195 : 261 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
47196 : : {
47197 : 191 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
47198 : 191 : const char *p = IDENTIFIER_POINTER (id);
47199 : :
47200 : 191 : if (strcmp (p, "taskloop") == 0)
47201 : : {
47202 : 147 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
47203 : 147 : if (cclauses == NULL)
47204 : 58 : cclauses = cclauses_buf;
47205 : :
47206 : 147 : cp_lexer_consume_token (parser->lexer);
47207 : 147 : if (!flag_openmp) /* flag_openmp_simd */
47208 : 0 : return cp_parser_omp_taskloop (parser, pragma_tok, p_name, mask,
47209 : 0 : cclauses, if_p);
47210 : 147 : sb = begin_omp_structured_block ();
47211 : 147 : save = cp_parser_begin_omp_structured_block (parser);
47212 : 147 : ret = cp_parser_omp_taskloop (parser, pragma_tok, p_name, mask,
47213 : : cclauses, if_p);
47214 : 147 : cp_parser_end_omp_structured_block (parser, save);
47215 : 147 : tree body = finish_omp_structured_block (sb);
47216 : 147 : if (ret == NULL)
47217 : : return ret;
47218 : 147 : ret = c_finish_omp_masked (loc, body,
47219 : : cclauses[C_OMP_CLAUSE_SPLIT_MASKED]);
47220 : 147 : OMP_MASKED_COMBINED (ret) = 1;
47221 : 147 : return ret;
47222 : : }
47223 : : }
47224 : 114 : if (!flag_openmp) /* flag_openmp_simd */
47225 : : {
47226 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
47227 : 0 : return NULL_TREE;
47228 : : }
47229 : :
47230 : 114 : clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
47231 : : cclauses == NULL);
47232 : 114 : if (cclauses)
47233 : : {
47234 : 23 : cp_omp_split_clauses (loc, OMP_MASTER, mask, clauses, cclauses);
47235 : 23 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_MASKED];
47236 : : }
47237 : :
47238 : 114 : return c_finish_omp_masked (loc,
47239 : : cp_parser_omp_structured_block (parser, if_p),
47240 : 114 : clauses);
47241 : : }
47242 : :
47243 : : /* OpenMP 2.5:
47244 : : # pragma omp ordered new-line
47245 : : structured-block
47246 : :
47247 : : OpenMP 4.5:
47248 : : # pragma omp ordered ordered-clauses new-line
47249 : : structured-block */
47250 : :
47251 : : #define OMP_ORDERED_CLAUSE_MASK \
47252 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREADS) \
47253 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMD))
47254 : :
47255 : : #define OMP_ORDERED_DEPEND_CLAUSE_MASK \
47256 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
47257 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DOACROSS))
47258 : :
47259 : : static bool
47260 : 1093 : cp_parser_omp_ordered (cp_parser *parser, cp_token *pragma_tok,
47261 : : enum pragma_context context, bool *if_p)
47262 : : {
47263 : 1093 : location_t loc = pragma_tok->location;
47264 : 1093 : int n = 1;
47265 : :
47266 : 1093 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
47267 : 24 : n = 2;
47268 : :
47269 : 1093 : if (cp_lexer_nth_token_is (parser->lexer, n, CPP_NAME))
47270 : : {
47271 : 905 : tree id = cp_lexer_peek_nth_token (parser->lexer, n)->u.value;
47272 : 905 : const char *p = IDENTIFIER_POINTER (id);
47273 : :
47274 : 905 : if (strcmp (p, "depend") == 0 || strcmp (p, "doacross") == 0)
47275 : : {
47276 : 660 : if (!flag_openmp) /* flag_openmp_simd */
47277 : : {
47278 : 6 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
47279 : 6 : return false;
47280 : : }
47281 : 654 : if (context == pragma_stmt)
47282 : : {
47283 : 48 : error_at (pragma_tok->location, "%<#pragma omp ordered%> with "
47284 : : "%qs clause may only be used in compound "
47285 : : "statements", p);
47286 : 48 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
47287 : 48 : return true;
47288 : : }
47289 : 606 : tree clauses
47290 : 606 : = cp_parser_omp_all_clauses (parser,
47291 : 606 : OMP_ORDERED_DEPEND_CLAUSE_MASK,
47292 : : "#pragma omp ordered", pragma_tok);
47293 : 606 : c_finish_omp_ordered (loc, clauses, NULL_TREE);
47294 : 606 : return false;
47295 : : }
47296 : : }
47297 : :
47298 : 433 : tree clauses
47299 : 433 : = cp_parser_omp_all_clauses (parser, OMP_ORDERED_CLAUSE_MASK,
47300 : : "#pragma omp ordered", pragma_tok);
47301 : :
47302 : 433 : if (!flag_openmp /* flag_openmp_simd */
47303 : 433 : && omp_find_clause (clauses, OMP_CLAUSE_SIMD) == NULL_TREE)
47304 : : return false;
47305 : :
47306 : 427 : c_finish_omp_ordered (loc, clauses,
47307 : : cp_parser_omp_structured_block (parser, if_p));
47308 : 427 : return true;
47309 : : }
47310 : :
47311 : : /* OpenMP 2.5:
47312 : :
47313 : : section-scope:
47314 : : { section-sequence }
47315 : :
47316 : : section-sequence:
47317 : : section-directive[opt] structured-block
47318 : : section-sequence section-directive structured-block */
47319 : :
47320 : : static tree
47321 : 360 : cp_parser_omp_sections_scope (cp_parser *parser)
47322 : : {
47323 : 360 : tree stmt, substmt;
47324 : 360 : bool error_suppress = false;
47325 : 360 : cp_token *tok;
47326 : :
47327 : 360 : matching_braces braces;
47328 : 360 : if (!braces.require_open (parser))
47329 : : return NULL_TREE;
47330 : :
47331 : 354 : stmt = push_stmt_list ();
47332 : :
47333 : 354 : if (cp_parser_pragma_kind (cp_lexer_peek_token (parser->lexer))
47334 : : != PRAGMA_OMP_SECTION
47335 : 354 : && !cp_parser_omp_section_scan (parser, "section", true))
47336 : : {
47337 : 225 : substmt = cp_parser_omp_structured_block_sequence (parser,
47338 : : PRAGMA_OMP_SECTION);
47339 : 225 : substmt = build1 (OMP_SECTION, void_type_node, substmt);
47340 : 225 : add_stmt (substmt);
47341 : : }
47342 : :
47343 : 1274 : while (1)
47344 : : {
47345 : 460 : tok = cp_lexer_peek_token (parser->lexer);
47346 : 814 : if (tok->type == CPP_CLOSE_BRACE)
47347 : : break;
47348 : 460 : if (tok->type == CPP_EOF)
47349 : : break;
47350 : :
47351 : 460 : if (cp_parser_omp_section_scan (parser, "section", false))
47352 : 6 : tok = cp_lexer_peek_token (parser->lexer);
47353 : 460 : if (cp_parser_pragma_kind (tok) == PRAGMA_OMP_SECTION)
47354 : : {
47355 : 460 : cp_lexer_consume_token (parser->lexer);
47356 : 460 : cp_parser_require_pragma_eol (parser, tok);
47357 : 460 : error_suppress = false;
47358 : : }
47359 : 0 : else if (!error_suppress)
47360 : : {
47361 : 0 : cp_parser_error (parser, "expected %<#pragma omp section%> or %<}%>");
47362 : 0 : error_suppress = true;
47363 : : }
47364 : :
47365 : 460 : substmt = cp_parser_omp_structured_block_sequence (parser,
47366 : : PRAGMA_OMP_SECTION);
47367 : 460 : substmt = build1 (OMP_SECTION, void_type_node, substmt);
47368 : 460 : add_stmt (substmt);
47369 : : }
47370 : 354 : braces.require_close (parser);
47371 : :
47372 : 354 : substmt = pop_stmt_list (stmt);
47373 : :
47374 : 354 : stmt = make_node (OMP_SECTIONS);
47375 : 354 : TREE_TYPE (stmt) = void_type_node;
47376 : 354 : OMP_SECTIONS_BODY (stmt) = substmt;
47377 : :
47378 : 354 : add_stmt (stmt);
47379 : 354 : return stmt;
47380 : : }
47381 : :
47382 : : /* OpenMP 2.5:
47383 : : # pragma omp sections sections-clause[optseq] newline
47384 : : sections-scope */
47385 : :
47386 : : #define OMP_SECTIONS_CLAUSE_MASK \
47387 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
47388 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
47389 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
47390 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
47391 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
47392 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
47393 : :
47394 : : static tree
47395 : 360 : cp_parser_omp_sections (cp_parser *parser, cp_token *pragma_tok,
47396 : : char *p_name, omp_clause_mask mask, tree *cclauses)
47397 : : {
47398 : 360 : tree clauses, ret;
47399 : 360 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
47400 : :
47401 : 360 : strcat (p_name, " sections");
47402 : 360 : mask |= OMP_SECTIONS_CLAUSE_MASK;
47403 : 360 : if (cclauses)
47404 : 119 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT);
47405 : :
47406 : 360 : clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
47407 : : cclauses == NULL);
47408 : 360 : if (cclauses)
47409 : : {
47410 : 119 : cp_omp_split_clauses (loc, OMP_SECTIONS, mask, clauses, cclauses);
47411 : 119 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_SECTIONS];
47412 : : }
47413 : :
47414 : 360 : ret = cp_parser_omp_sections_scope (parser);
47415 : 360 : if (ret)
47416 : 354 : OMP_SECTIONS_CLAUSES (ret) = clauses;
47417 : :
47418 : 360 : return ret;
47419 : : }
47420 : :
47421 : : /* OpenMP 2.5:
47422 : : # pragma omp parallel parallel-clause[optseq] new-line
47423 : : structured-block
47424 : : # pragma omp parallel for parallel-for-clause[optseq] new-line
47425 : : structured-block
47426 : : # pragma omp parallel sections parallel-sections-clause[optseq] new-line
47427 : : structured-block
47428 : :
47429 : : OpenMP 4.0:
47430 : : # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
47431 : : structured-block */
47432 : :
47433 : : #define OMP_PARALLEL_CLAUSE_MASK \
47434 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
47435 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
47436 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
47437 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
47438 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
47439 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
47440 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
47441 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
47442 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
47443 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
47444 : :
47445 : : static tree
47446 : 8369 : cp_parser_omp_parallel (cp_parser *parser, cp_token *pragma_tok,
47447 : : char *p_name, omp_clause_mask mask, tree *cclauses,
47448 : : bool *if_p)
47449 : : {
47450 : 8369 : tree stmt, clauses, block;
47451 : 8369 : unsigned int save;
47452 : 8369 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
47453 : :
47454 : 8369 : strcat (p_name, " parallel");
47455 : 8369 : mask |= OMP_PARALLEL_CLAUSE_MASK;
47456 : : /* #pragma omp target parallel{, for, for simd} disallow copyin clause. */
47457 : 8369 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP)) != 0
47458 : 1348 : && (mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) == 0)
47459 : 584 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN);
47460 : :
47461 : 8369 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
47462 : : {
47463 : 5569 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
47464 : 5569 : if (cclauses == NULL)
47465 : 1840 : cclauses = cclauses_buf;
47466 : :
47467 : 5569 : cp_lexer_consume_token (parser->lexer);
47468 : 5569 : if (!flag_openmp) /* flag_openmp_simd */
47469 : 57 : return cp_parser_omp_for (parser, pragma_tok, p_name, mask, cclauses,
47470 : 57 : if_p);
47471 : 5512 : block = begin_omp_parallel ();
47472 : 5512 : save = cp_parser_begin_omp_structured_block (parser);
47473 : 5512 : tree ret = cp_parser_omp_for (parser, pragma_tok, p_name, mask, cclauses,
47474 : : if_p);
47475 : 5512 : cp_parser_end_omp_structured_block (parser, save);
47476 : 5512 : stmt = finish_omp_parallel (cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
47477 : : block);
47478 : 5512 : if (ret == NULL_TREE)
47479 : : return ret;
47480 : 5359 : OMP_PARALLEL_COMBINED (stmt) = 1;
47481 : 5359 : return stmt;
47482 : : }
47483 : : /* When combined with distribute, parallel has to be followed by for.
47484 : : #pragma omp target parallel is allowed though. */
47485 : 2800 : else if (cclauses
47486 : 2800 : && (mask & (OMP_CLAUSE_MASK_1
47487 : 105 : << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
47488 : : {
47489 : 0 : error_at (loc, "expected %<for%> after %qs", p_name);
47490 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
47491 : 0 : return NULL_TREE;
47492 : : }
47493 : 2800 : else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
47494 : : {
47495 : 1534 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
47496 : 1534 : const char *p = IDENTIFIER_POINTER (id);
47497 : 1534 : if (cclauses == NULL && strcmp (p, "masked") == 0)
47498 : : {
47499 : 112 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
47500 : 112 : cclauses = cclauses_buf;
47501 : :
47502 : 112 : cp_lexer_consume_token (parser->lexer);
47503 : 112 : if (!flag_openmp) /* flag_openmp_simd */
47504 : 0 : return cp_parser_omp_masked (parser, pragma_tok, p_name, mask,
47505 : 0 : cclauses, if_p);
47506 : 112 : block = begin_omp_parallel ();
47507 : 112 : save = cp_parser_begin_omp_structured_block (parser);
47508 : 112 : tree ret = cp_parser_omp_masked (parser, pragma_tok, p_name, mask,
47509 : : cclauses, if_p);
47510 : 112 : cp_parser_end_omp_structured_block (parser, save);
47511 : 112 : stmt = finish_omp_parallel (cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
47512 : : block);
47513 : 112 : if (ret == NULL_TREE)
47514 : : return ret;
47515 : : /* masked does have just filter clause, but during gimplification
47516 : : isn't represented by a gimplification omp context, so for
47517 : : #pragma omp parallel masked don't set OMP_PARALLEL_COMBINED,
47518 : : so that
47519 : : #pragma omp parallel masked
47520 : : #pragma omp taskloop simd lastprivate (x)
47521 : : isn't confused with
47522 : : #pragma omp parallel masked taskloop simd lastprivate (x) */
47523 : 112 : if (OMP_MASKED_COMBINED (ret))
47524 : 89 : OMP_PARALLEL_COMBINED (stmt) = 1;
47525 : 112 : return stmt;
47526 : : }
47527 : 1335 : else if (cclauses == NULL && strcmp (p, "master") == 0)
47528 : : {
47529 : 195 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
47530 : 195 : cclauses = cclauses_buf;
47531 : :
47532 : 195 : cp_lexer_consume_token (parser->lexer);
47533 : 195 : if (!flag_openmp) /* flag_openmp_simd */
47534 : 9 : return cp_parser_omp_master (parser, pragma_tok, p_name, mask,
47535 : 9 : cclauses, if_p);
47536 : 186 : block = begin_omp_parallel ();
47537 : 186 : save = cp_parser_begin_omp_structured_block (parser);
47538 : 186 : tree ret = cp_parser_omp_master (parser, pragma_tok, p_name, mask,
47539 : : cclauses, if_p);
47540 : 186 : cp_parser_end_omp_structured_block (parser, save);
47541 : 186 : stmt = finish_omp_parallel (cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
47542 : : block);
47543 : 186 : if (ret == NULL_TREE)
47544 : : return ret;
47545 : : /* master doesn't have any clauses and during gimplification
47546 : : isn't represented by a gimplification omp context, so for
47547 : : #pragma omp parallel master don't set OMP_PARALLEL_COMBINED,
47548 : : so that
47549 : : #pragma omp parallel master
47550 : : #pragma omp taskloop simd lastprivate (x)
47551 : : isn't confused with
47552 : : #pragma omp parallel master taskloop simd lastprivate (x) */
47553 : 183 : if (OMP_MASTER_COMBINED (ret))
47554 : 129 : OMP_PARALLEL_COMBINED (stmt) = 1;
47555 : 183 : return stmt;
47556 : : }
47557 : 1227 : else if (strcmp (p, "loop") == 0)
47558 : : {
47559 : 115 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
47560 : 115 : if (cclauses == NULL)
47561 : 66 : cclauses = cclauses_buf;
47562 : :
47563 : 115 : cp_lexer_consume_token (parser->lexer);
47564 : 115 : if (!flag_openmp) /* flag_openmp_simd */
47565 : 6 : return cp_parser_omp_loop (parser, pragma_tok, p_name, mask,
47566 : 6 : cclauses, if_p);
47567 : 109 : block = begin_omp_parallel ();
47568 : 109 : save = cp_parser_begin_omp_structured_block (parser);
47569 : 109 : tree ret = cp_parser_omp_loop (parser, pragma_tok, p_name, mask,
47570 : : cclauses, if_p);
47571 : 109 : cp_parser_end_omp_structured_block (parser, save);
47572 : 109 : stmt = finish_omp_parallel (cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
47573 : : block);
47574 : 109 : if (ret == NULL_TREE)
47575 : : return ret;
47576 : 109 : OMP_PARALLEL_COMBINED (stmt) = 1;
47577 : 109 : return stmt;
47578 : : }
47579 : 1112 : else if (!flag_openmp) /* flag_openmp_simd */
47580 : : {
47581 : 3 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
47582 : 3 : return NULL_TREE;
47583 : : }
47584 : 1109 : else if (cclauses == NULL && strcmp (p, "sections") == 0)
47585 : : {
47586 : 119 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
47587 : 119 : cclauses = cclauses_buf;
47588 : :
47589 : 119 : cp_lexer_consume_token (parser->lexer);
47590 : 119 : block = begin_omp_parallel ();
47591 : 119 : save = cp_parser_begin_omp_structured_block (parser);
47592 : 119 : cp_parser_omp_sections (parser, pragma_tok, p_name, mask, cclauses);
47593 : 119 : cp_parser_end_omp_structured_block (parser, save);
47594 : 119 : stmt = finish_omp_parallel (cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
47595 : : block);
47596 : 119 : OMP_PARALLEL_COMBINED (stmt) = 1;
47597 : 119 : return stmt;
47598 : : }
47599 : : }
47600 : 1266 : else if (!flag_openmp) /* flag_openmp_simd */
47601 : : {
47602 : 3 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
47603 : 3 : return NULL_TREE;
47604 : : }
47605 : :
47606 : 2253 : clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
47607 : : cclauses == NULL);
47608 : 2253 : if (cclauses)
47609 : : {
47610 : 53 : cp_omp_split_clauses (loc, OMP_PARALLEL, mask, clauses, cclauses);
47611 : 53 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL];
47612 : : }
47613 : :
47614 : 2253 : block = begin_omp_parallel ();
47615 : 2253 : save = cp_parser_begin_omp_structured_block (parser);
47616 : 2253 : parser->omp_attrs_forbidden_p = true;
47617 : 2253 : cp_parser_statement (parser, NULL_TREE, false, if_p);
47618 : 2253 : cp_parser_end_omp_structured_block (parser, save);
47619 : 2253 : stmt = finish_omp_parallel (clauses, block);
47620 : 2253 : return stmt;
47621 : : }
47622 : :
47623 : : /* OpenMP 2.5:
47624 : : # pragma omp single single-clause[optseq] new-line
47625 : : structured-block */
47626 : :
47627 : : #define OMP_SINGLE_CLAUSE_MASK \
47628 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
47629 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
47630 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
47631 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
47632 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
47633 : :
47634 : : static tree
47635 : 375 : cp_parser_omp_single (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
47636 : : {
47637 : 375 : tree stmt = make_node (OMP_SINGLE);
47638 : 375 : TREE_TYPE (stmt) = void_type_node;
47639 : 375 : SET_EXPR_LOCATION (stmt, pragma_tok->location);
47640 : :
47641 : 750 : OMP_SINGLE_CLAUSES (stmt)
47642 : 375 : = cp_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
47643 : : "#pragma omp single", pragma_tok);
47644 : 375 : OMP_SINGLE_BODY (stmt) = cp_parser_omp_structured_block (parser, if_p);
47645 : :
47646 : 375 : return add_stmt (stmt);
47647 : : }
47648 : :
47649 : : /* OpenMP 5.1:
47650 : : # pragma omp scope scope-clause[optseq] new-line
47651 : : structured-block */
47652 : :
47653 : : #define OMP_SCOPE_CLAUSE_MASK \
47654 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
47655 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
47656 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
47657 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
47658 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
47659 : :
47660 : : static tree
47661 : 102 : cp_parser_omp_scope (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
47662 : : {
47663 : 102 : tree stmt = make_node (OMP_SCOPE);
47664 : 102 : TREE_TYPE (stmt) = void_type_node;
47665 : 102 : SET_EXPR_LOCATION (stmt, pragma_tok->location);
47666 : :
47667 : 204 : OMP_SCOPE_CLAUSES (stmt)
47668 : 102 : = cp_parser_omp_all_clauses (parser, OMP_SCOPE_CLAUSE_MASK,
47669 : : "#pragma omp scope", pragma_tok);
47670 : 102 : OMP_SCOPE_BODY (stmt) = cp_parser_omp_structured_block (parser, if_p);
47671 : :
47672 : 102 : return add_stmt (stmt);
47673 : : }
47674 : :
47675 : : /* OpenMP 3.0:
47676 : : # pragma omp task task-clause[optseq] new-line
47677 : : structured-block */
47678 : :
47679 : : #define OMP_TASK_CLAUSE_MASK \
47680 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
47681 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
47682 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
47683 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
47684 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
47685 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
47686 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
47687 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
47688 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
47689 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
47690 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
47691 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
47692 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DETACH) \
47693 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_AFFINITY))
47694 : :
47695 : : static tree
47696 : 1966 : cp_parser_omp_task (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
47697 : : {
47698 : 1966 : tree clauses, block;
47699 : 1966 : unsigned int save;
47700 : :
47701 : 1966 : clauses = cp_parser_omp_all_clauses (parser, OMP_TASK_CLAUSE_MASK,
47702 : : "#pragma omp task", pragma_tok);
47703 : 1966 : block = begin_omp_task ();
47704 : 1966 : save = cp_parser_begin_omp_structured_block (parser);
47705 : 1966 : parser->omp_attrs_forbidden_p = true;
47706 : 1966 : cp_parser_statement (parser, NULL_TREE, false, if_p);
47707 : 1966 : cp_parser_end_omp_structured_block (parser, save);
47708 : 1966 : return finish_omp_task (clauses, block);
47709 : : }
47710 : :
47711 : : /* OpenMP 3.0:
47712 : : # pragma omp taskwait new-line
47713 : :
47714 : : OpenMP 5.0:
47715 : : # pragma omp taskwait taskwait-clause[opt] new-line */
47716 : :
47717 : : #define OMP_TASKWAIT_CLAUSE_MASK \
47718 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
47719 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
47720 : :
47721 : : static void
47722 : 143 : cp_parser_omp_taskwait (cp_parser *parser, cp_token *pragma_tok)
47723 : : {
47724 : 143 : tree clauses
47725 : 143 : = cp_parser_omp_all_clauses (parser, OMP_TASKWAIT_CLAUSE_MASK,
47726 : : "#pragma omp taskwait", pragma_tok);
47727 : :
47728 : 143 : if (clauses)
47729 : : {
47730 : 36 : tree stmt = make_node (OMP_TASK);
47731 : 36 : TREE_TYPE (stmt) = void_node;
47732 : 36 : OMP_TASK_CLAUSES (stmt) = clauses;
47733 : 36 : OMP_TASK_BODY (stmt) = NULL_TREE;
47734 : 36 : SET_EXPR_LOCATION (stmt, pragma_tok->location);
47735 : 36 : add_stmt (stmt);
47736 : : }
47737 : : else
47738 : 107 : finish_omp_taskwait ();
47739 : 143 : }
47740 : :
47741 : : /* OpenMP 3.1:
47742 : : # pragma omp taskyield new-line */
47743 : :
47744 : : static void
47745 : 16 : cp_parser_omp_taskyield (cp_parser *parser, cp_token *pragma_tok)
47746 : : {
47747 : 0 : cp_parser_require_pragma_eol (parser, pragma_tok);
47748 : 0 : finish_omp_taskyield ();
47749 : 0 : }
47750 : :
47751 : : /* OpenMP 4.0:
47752 : : # pragma omp taskgroup new-line
47753 : : structured-block
47754 : :
47755 : : OpenMP 5.0:
47756 : : # pragma omp taskgroup taskgroup-clause[optseq] new-line */
47757 : :
47758 : : #define OMP_TASKGROUP_CLAUSE_MASK \
47759 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
47760 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASK_REDUCTION))
47761 : :
47762 : : static tree
47763 : 292 : cp_parser_omp_taskgroup (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
47764 : : {
47765 : 292 : tree clauses
47766 : 292 : = cp_parser_omp_all_clauses (parser, OMP_TASKGROUP_CLAUSE_MASK,
47767 : : "#pragma omp taskgroup", pragma_tok);
47768 : 292 : return c_finish_omp_taskgroup (input_location,
47769 : : cp_parser_omp_structured_block (parser,
47770 : : if_p),
47771 : 292 : clauses);
47772 : : }
47773 : :
47774 : :
47775 : : /* OpenMP 2.5:
47776 : : # pragma omp threadprivate (variable-list) */
47777 : :
47778 : : static void
47779 : 238 : cp_parser_omp_threadprivate (cp_parser *parser, cp_token *pragma_tok)
47780 : : {
47781 : 238 : tree vars;
47782 : :
47783 : 238 : vars = cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
47784 : 238 : cp_parser_require_pragma_eol (parser, pragma_tok);
47785 : :
47786 : 238 : finish_omp_threadprivate (vars);
47787 : 238 : }
47788 : :
47789 : : /* OpenMP 4.0:
47790 : : # pragma omp cancel cancel-clause[optseq] new-line */
47791 : :
47792 : : #define OMP_CANCEL_CLAUSE_MASK \
47793 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
47794 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
47795 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
47796 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
47797 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
47798 : :
47799 : : static void
47800 : 596 : cp_parser_omp_cancel (cp_parser *parser, cp_token *pragma_tok)
47801 : : {
47802 : 596 : tree clauses = cp_parser_omp_all_clauses (parser, OMP_CANCEL_CLAUSE_MASK,
47803 : : "#pragma omp cancel", pragma_tok);
47804 : 596 : finish_omp_cancel (clauses);
47805 : 596 : }
47806 : :
47807 : : /* OpenMP 4.0:
47808 : : # pragma omp cancellation point cancelpt-clause[optseq] new-line */
47809 : :
47810 : : #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
47811 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
47812 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
47813 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
47814 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
47815 : :
47816 : : static bool
47817 : 530 : cp_parser_omp_cancellation_point (cp_parser *parser, cp_token *pragma_tok,
47818 : : enum pragma_context context)
47819 : : {
47820 : 530 : tree clauses;
47821 : 530 : bool point_seen = false;
47822 : :
47823 : 530 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
47824 : : {
47825 : 530 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
47826 : 530 : const char *p = IDENTIFIER_POINTER (id);
47827 : :
47828 : 530 : if (strcmp (p, "point") == 0)
47829 : : {
47830 : 524 : cp_lexer_consume_token (parser->lexer);
47831 : 524 : point_seen = true;
47832 : : }
47833 : : }
47834 : 524 : if (!point_seen)
47835 : : {
47836 : 6 : cp_parser_error (parser, "expected %<point%>");
47837 : 6 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
47838 : 6 : return false;
47839 : : }
47840 : :
47841 : 524 : if (context != pragma_compound)
47842 : : {
47843 : 30 : if (context == pragma_stmt)
47844 : 27 : error_at (pragma_tok->location,
47845 : : "%<#pragma %s%> may only be used in compound statements",
47846 : : "omp cancellation point");
47847 : : else
47848 : 3 : cp_parser_error (parser, "expected declaration specifiers");
47849 : 30 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
47850 : 30 : return true;
47851 : : }
47852 : :
47853 : 494 : clauses = cp_parser_omp_all_clauses (parser,
47854 : 494 : OMP_CANCELLATION_POINT_CLAUSE_MASK,
47855 : : "#pragma omp cancellation point",
47856 : : pragma_tok);
47857 : 494 : finish_omp_cancellation_point (clauses);
47858 : 494 : return true;
47859 : : }
47860 : :
47861 : : /* OpenMP 4.0:
47862 : : #pragma omp distribute distribute-clause[optseq] new-line
47863 : : for-loop */
47864 : :
47865 : : #define OMP_DISTRIBUTE_CLAUSE_MASK \
47866 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
47867 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
47868 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
47869 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
47870 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
47871 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
47872 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
47873 : :
47874 : : static tree
47875 : 4231 : cp_parser_omp_distribute (cp_parser *parser, cp_token *pragma_tok,
47876 : : char *p_name, omp_clause_mask mask, tree *cclauses,
47877 : : bool *if_p)
47878 : : {
47879 : 4231 : tree clauses, sb, ret;
47880 : 4231 : unsigned int save;
47881 : 4231 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
47882 : :
47883 : 4231 : strcat (p_name, " distribute");
47884 : 4231 : mask |= OMP_DISTRIBUTE_CLAUSE_MASK;
47885 : :
47886 : 4231 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
47887 : : {
47888 : 4081 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
47889 : 4081 : const char *p = IDENTIFIER_POINTER (id);
47890 : 4081 : bool simd = false;
47891 : 4081 : bool parallel = false;
47892 : :
47893 : 4081 : if (strcmp (p, "simd") == 0)
47894 : : simd = true;
47895 : : else
47896 : 3581 : parallel = strcmp (p, "parallel") == 0;
47897 : 3581 : if (parallel || simd)
47898 : : {
47899 : 3750 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
47900 : 3750 : if (cclauses == NULL)
47901 : 1395 : cclauses = cclauses_buf;
47902 : 3750 : cp_lexer_consume_token (parser->lexer);
47903 : 3750 : if (!flag_openmp) /* flag_openmp_simd */
47904 : : {
47905 : 45 : if (simd)
47906 : 18 : return cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
47907 : 18 : cclauses, if_p);
47908 : : else
47909 : 27 : return cp_parser_omp_parallel (parser, pragma_tok, p_name, mask,
47910 : 27 : cclauses, if_p);
47911 : : }
47912 : 3705 : sb = begin_omp_structured_block ();
47913 : 3705 : save = cp_parser_begin_omp_structured_block (parser);
47914 : 3705 : if (simd)
47915 : 482 : ret = cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
47916 : : cclauses, if_p);
47917 : : else
47918 : 3223 : ret = cp_parser_omp_parallel (parser, pragma_tok, p_name, mask,
47919 : : cclauses, if_p);
47920 : 3705 : cp_parser_end_omp_structured_block (parser, save);
47921 : 3705 : tree body = finish_omp_structured_block (sb);
47922 : 3705 : if (ret == NULL)
47923 : : return ret;
47924 : 3702 : ret = make_node (OMP_DISTRIBUTE);
47925 : 3702 : TREE_TYPE (ret) = void_type_node;
47926 : 3702 : OMP_FOR_BODY (ret) = body;
47927 : 3702 : OMP_FOR_CLAUSES (ret) = cclauses[C_OMP_CLAUSE_SPLIT_DISTRIBUTE];
47928 : 3702 : SET_EXPR_LOCATION (ret, loc);
47929 : 3702 : add_stmt (ret);
47930 : 3702 : return ret;
47931 : : }
47932 : : }
47933 : 481 : if (!flag_openmp) /* flag_openmp_simd */
47934 : : {
47935 : 6 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
47936 : 6 : return NULL_TREE;
47937 : : }
47938 : :
47939 : 475 : clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
47940 : : cclauses == NULL);
47941 : 475 : if (cclauses)
47942 : : {
47943 : 262 : cp_omp_split_clauses (loc, OMP_DISTRIBUTE, mask, clauses, cclauses);
47944 : 262 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_DISTRIBUTE];
47945 : : }
47946 : :
47947 : 475 : keep_next_level (true);
47948 : 475 : sb = begin_omp_structured_block ();
47949 : 475 : save = cp_parser_begin_omp_structured_block (parser);
47950 : :
47951 : 475 : ret = cp_parser_omp_for_loop (parser, OMP_DISTRIBUTE, clauses, NULL, if_p);
47952 : :
47953 : 475 : cp_parser_end_omp_structured_block (parser, save);
47954 : 475 : add_stmt (finish_omp_structured_block (sb));
47955 : :
47956 : 475 : return ret;
47957 : : }
47958 : :
47959 : : /* OpenMP 4.0:
47960 : : # pragma omp teams teams-clause[optseq] new-line
47961 : : structured-block */
47962 : :
47963 : : #define OMP_TEAMS_CLAUSE_MASK \
47964 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
47965 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
47966 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
47967 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
47968 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
47969 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
47970 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
47971 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
47972 : :
47973 : : static tree
47974 : 4650 : cp_parser_omp_teams (cp_parser *parser, cp_token *pragma_tok,
47975 : : char *p_name, omp_clause_mask mask, tree *cclauses,
47976 : : bool *if_p)
47977 : : {
47978 : 4650 : tree clauses, sb, ret;
47979 : 4650 : unsigned int save;
47980 : 4650 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
47981 : :
47982 : 4650 : strcat (p_name, " teams");
47983 : 4650 : mask |= OMP_TEAMS_CLAUSE_MASK;
47984 : :
47985 : 4650 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
47986 : : {
47987 : 3138 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
47988 : 3138 : const char *p = IDENTIFIER_POINTER (id);
47989 : 3138 : if (strcmp (p, "distribute") == 0)
47990 : : {
47991 : 2623 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
47992 : 2623 : if (cclauses == NULL)
47993 : 1618 : cclauses = cclauses_buf;
47994 : :
47995 : 2623 : cp_lexer_consume_token (parser->lexer);
47996 : 2623 : if (!flag_openmp) /* flag_openmp_simd */
47997 : 36 : return cp_parser_omp_distribute (parser, pragma_tok, p_name, mask,
47998 : 36 : cclauses, if_p);
47999 : 2587 : keep_next_level (true);
48000 : 2587 : sb = begin_omp_structured_block ();
48001 : 2587 : save = cp_parser_begin_omp_structured_block (parser);
48002 : 2587 : ret = cp_parser_omp_distribute (parser, pragma_tok, p_name, mask,
48003 : : cclauses, if_p);
48004 : 2587 : cp_parser_end_omp_structured_block (parser, save);
48005 : 2587 : tree body = finish_omp_structured_block (sb);
48006 : 2587 : if (ret == NULL)
48007 : : return ret;
48008 : 2587 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
48009 : 2587 : ret = make_node (OMP_TEAMS);
48010 : 2587 : TREE_TYPE (ret) = void_type_node;
48011 : 2587 : OMP_TEAMS_CLAUSES (ret) = clauses;
48012 : 2587 : OMP_TEAMS_BODY (ret) = body;
48013 : 2587 : OMP_TEAMS_COMBINED (ret) = 1;
48014 : 2587 : SET_EXPR_LOCATION (ret, loc);
48015 : 2587 : return add_stmt (ret);
48016 : : }
48017 : 515 : else if (strcmp (p, "loop") == 0)
48018 : : {
48019 : 100 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
48020 : 100 : if (cclauses == NULL)
48021 : 53 : cclauses = cclauses_buf;
48022 : :
48023 : 100 : cp_lexer_consume_token (parser->lexer);
48024 : 100 : if (!flag_openmp) /* flag_openmp_simd */
48025 : 6 : return cp_parser_omp_loop (parser, pragma_tok, p_name, mask,
48026 : 6 : cclauses, if_p);
48027 : 94 : keep_next_level (true);
48028 : 94 : sb = begin_omp_structured_block ();
48029 : 94 : save = cp_parser_begin_omp_structured_block (parser);
48030 : 94 : ret = cp_parser_omp_loop (parser, pragma_tok, p_name, mask,
48031 : : cclauses, if_p);
48032 : 94 : cp_parser_end_omp_structured_block (parser, save);
48033 : 94 : tree body = finish_omp_structured_block (sb);
48034 : 94 : if (ret == NULL)
48035 : : return ret;
48036 : 94 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
48037 : 94 : ret = make_node (OMP_TEAMS);
48038 : 94 : TREE_TYPE (ret) = void_type_node;
48039 : 94 : OMP_TEAMS_CLAUSES (ret) = clauses;
48040 : 94 : OMP_TEAMS_BODY (ret) = body;
48041 : 94 : OMP_TEAMS_COMBINED (ret) = 1;
48042 : 94 : SET_EXPR_LOCATION (ret, loc);
48043 : 94 : return add_stmt (ret);
48044 : : }
48045 : : }
48046 : 1927 : if (!flag_openmp) /* flag_openmp_simd */
48047 : : {
48048 : 6 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
48049 : 6 : return NULL_TREE;
48050 : : }
48051 : :
48052 : 1921 : clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
48053 : : cclauses == NULL);
48054 : 1921 : if (cclauses)
48055 : : {
48056 : 1053 : cp_omp_split_clauses (loc, OMP_TEAMS, mask, clauses, cclauses);
48057 : 1053 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
48058 : : }
48059 : :
48060 : 1921 : tree stmt = make_node (OMP_TEAMS);
48061 : 1921 : TREE_TYPE (stmt) = void_type_node;
48062 : 1921 : OMP_TEAMS_CLAUSES (stmt) = clauses;
48063 : 1921 : keep_next_level (true);
48064 : 1921 : OMP_TEAMS_BODY (stmt) = cp_parser_omp_structured_block (parser, if_p);
48065 : 1921 : SET_EXPR_LOCATION (stmt, loc);
48066 : :
48067 : 1921 : return add_stmt (stmt);
48068 : : }
48069 : :
48070 : : /* OpenMP 4.0:
48071 : : # pragma omp target data target-data-clause[optseq] new-line
48072 : : structured-block */
48073 : :
48074 : : #define OMP_TARGET_DATA_CLAUSE_MASK \
48075 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
48076 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
48077 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
48078 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR) \
48079 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR))
48080 : :
48081 : : static tree
48082 : 316 : cp_parser_omp_target_data (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
48083 : : {
48084 : 316 : if (flag_openmp)
48085 : 316 : omp_requires_mask
48086 : 316 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
48087 : :
48088 : 316 : tree clauses
48089 : 316 : = cp_parser_omp_all_clauses (parser, OMP_TARGET_DATA_CLAUSE_MASK,
48090 : 316 : "#pragma omp target data", pragma_tok);
48091 : 316 : c_omp_adjust_map_clauses (clauses, false);
48092 : 316 : int map_seen = 0;
48093 : 891 : for (tree *pc = &clauses; *pc;)
48094 : : {
48095 : 575 : if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_MAP)
48096 : 422 : switch (OMP_CLAUSE_MAP_KIND (*pc))
48097 : : {
48098 : : case GOMP_MAP_TO:
48099 : : case GOMP_MAP_ALWAYS_TO:
48100 : : case GOMP_MAP_PRESENT_TO:
48101 : : case GOMP_MAP_ALWAYS_PRESENT_TO:
48102 : : case GOMP_MAP_FROM:
48103 : : case GOMP_MAP_ALWAYS_FROM:
48104 : : case GOMP_MAP_PRESENT_FROM:
48105 : : case GOMP_MAP_ALWAYS_PRESENT_FROM:
48106 : : case GOMP_MAP_TOFROM:
48107 : : case GOMP_MAP_ALWAYS_TOFROM:
48108 : : case GOMP_MAP_PRESENT_TOFROM:
48109 : : case GOMP_MAP_ALWAYS_PRESENT_TOFROM:
48110 : : case GOMP_MAP_ALLOC:
48111 : : case GOMP_MAP_PRESENT_ALLOC:
48112 : 575 : map_seen = 3;
48113 : : break;
48114 : : case GOMP_MAP_FIRSTPRIVATE_POINTER:
48115 : : case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
48116 : : case GOMP_MAP_ALWAYS_POINTER:
48117 : : case GOMP_MAP_ATTACH_DETACH:
48118 : : case GOMP_MAP_ATTACH:
48119 : : break;
48120 : 0 : default:
48121 : 0 : map_seen |= 1;
48122 : 0 : error_at (OMP_CLAUSE_LOCATION (*pc),
48123 : : "%<#pragma omp target data%> with map-type other "
48124 : : "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
48125 : : "on %<map%> clause");
48126 : 0 : *pc = OMP_CLAUSE_CHAIN (*pc);
48127 : 0 : continue;
48128 : : }
48129 : 153 : else if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_USE_DEVICE_PTR
48130 : 153 : || OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_USE_DEVICE_ADDR)
48131 : : map_seen = 3;
48132 : 575 : pc = &OMP_CLAUSE_CHAIN (*pc);
48133 : : }
48134 : :
48135 : 316 : if (map_seen != 3)
48136 : : {
48137 : 6 : if (map_seen == 0)
48138 : 6 : error_at (pragma_tok->location,
48139 : : "%<#pragma omp target data%> must contain at least "
48140 : : "one %<map%>, %<use_device_ptr%> or %<use_device_addr%> "
48141 : : "clause");
48142 : 6 : return NULL_TREE;
48143 : : }
48144 : :
48145 : 310 : tree stmt = make_node (OMP_TARGET_DATA);
48146 : 310 : TREE_TYPE (stmt) = void_type_node;
48147 : 310 : OMP_TARGET_DATA_CLAUSES (stmt) = clauses;
48148 : :
48149 : 310 : keep_next_level (true);
48150 : 310 : OMP_TARGET_DATA_BODY (stmt) = cp_parser_omp_structured_block (parser, if_p);
48151 : :
48152 : 310 : SET_EXPR_LOCATION (stmt, pragma_tok->location);
48153 : 310 : return add_stmt (stmt);
48154 : : }
48155 : :
48156 : : /* OpenMP 4.5:
48157 : : # pragma omp target enter data target-enter-data-clause[optseq] new-line
48158 : : structured-block */
48159 : :
48160 : : #define OMP_TARGET_ENTER_DATA_CLAUSE_MASK \
48161 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
48162 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
48163 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
48164 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
48165 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
48166 : :
48167 : : static bool
48168 : 365 : cp_parser_omp_target_enter_data (cp_parser *parser, cp_token *pragma_tok,
48169 : : enum pragma_context context)
48170 : : {
48171 : 365 : bool data_seen = false;
48172 : 365 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
48173 : : {
48174 : 365 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
48175 : 365 : const char *p = IDENTIFIER_POINTER (id);
48176 : :
48177 : 365 : if (strcmp (p, "data") == 0)
48178 : : {
48179 : 365 : cp_lexer_consume_token (parser->lexer);
48180 : 365 : data_seen = true;
48181 : : }
48182 : : }
48183 : 365 : if (!data_seen)
48184 : : {
48185 : 0 : cp_parser_error (parser, "expected %<data%>");
48186 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
48187 : 0 : return false;
48188 : : }
48189 : :
48190 : 365 : if (context == pragma_stmt)
48191 : : {
48192 : 24 : error_at (pragma_tok->location,
48193 : : "%<#pragma %s%> may only be used in compound statements",
48194 : : "omp target enter data");
48195 : 24 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
48196 : 24 : return true;
48197 : : }
48198 : :
48199 : 341 : if (flag_openmp)
48200 : 341 : omp_requires_mask
48201 : 341 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
48202 : :
48203 : 341 : tree clauses
48204 : 341 : = cp_parser_omp_all_clauses (parser, OMP_TARGET_ENTER_DATA_CLAUSE_MASK,
48205 : 341 : "#pragma omp target enter data", pragma_tok);
48206 : 341 : c_omp_adjust_map_clauses (clauses, false);
48207 : 341 : int map_seen = 0;
48208 : 1043 : for (tree *pc = &clauses; *pc;)
48209 : : {
48210 : 702 : if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_MAP)
48211 : 631 : switch (OMP_CLAUSE_MAP_KIND (*pc))
48212 : : {
48213 : : case GOMP_MAP_TO:
48214 : : case GOMP_MAP_ALWAYS_TO:
48215 : : case GOMP_MAP_PRESENT_TO:
48216 : : case GOMP_MAP_ALWAYS_PRESENT_TO:
48217 : : case GOMP_MAP_ALLOC:
48218 : : case GOMP_MAP_PRESENT_ALLOC:
48219 : 516 : map_seen = 3;
48220 : : break;
48221 : 31 : case GOMP_MAP_TOFROM:
48222 : 31 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_TO);
48223 : 31 : map_seen = 3;
48224 : 31 : break;
48225 : 9 : case GOMP_MAP_ALWAYS_TOFROM:
48226 : 9 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_ALWAYS_TO);
48227 : 9 : map_seen = 3;
48228 : 9 : break;
48229 : 6 : case GOMP_MAP_PRESENT_TOFROM:
48230 : 6 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_PRESENT_TO);
48231 : 6 : map_seen = 3;
48232 : 6 : break;
48233 : 6 : case GOMP_MAP_ALWAYS_PRESENT_TOFROM:
48234 : 6 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_ALWAYS_PRESENT_TO);
48235 : 6 : map_seen = 3;
48236 : 6 : break;
48237 : : case GOMP_MAP_FIRSTPRIVATE_POINTER:
48238 : : case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
48239 : : case GOMP_MAP_ALWAYS_POINTER:
48240 : : case GOMP_MAP_ATTACH_DETACH:
48241 : : case GOMP_MAP_ATTACH:
48242 : : break;
48243 : 6 : default:
48244 : 6 : map_seen |= 1;
48245 : 6 : error_at (OMP_CLAUSE_LOCATION (*pc),
48246 : : "%<#pragma omp target enter data%> with map-type other "
48247 : : "than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause");
48248 : 6 : *pc = OMP_CLAUSE_CHAIN (*pc);
48249 : 6 : continue;
48250 : : }
48251 : 696 : pc = &OMP_CLAUSE_CHAIN (*pc);
48252 : : }
48253 : :
48254 : 341 : if (map_seen != 3)
48255 : : {
48256 : 6 : if (map_seen == 0)
48257 : 0 : error_at (pragma_tok->location,
48258 : : "%<#pragma omp target enter data%> must contain at least "
48259 : : "one %<map%> clause");
48260 : 6 : return true;
48261 : : }
48262 : :
48263 : 335 : tree stmt = make_node (OMP_TARGET_ENTER_DATA);
48264 : 335 : TREE_TYPE (stmt) = void_type_node;
48265 : 335 : OMP_TARGET_ENTER_DATA_CLAUSES (stmt) = clauses;
48266 : 335 : SET_EXPR_LOCATION (stmt, pragma_tok->location);
48267 : 335 : add_stmt (stmt);
48268 : 335 : return true;
48269 : : }
48270 : :
48271 : : /* OpenMP 4.5:
48272 : : # pragma omp target exit data target-enter-data-clause[optseq] new-line
48273 : : structured-block */
48274 : :
48275 : : #define OMP_TARGET_EXIT_DATA_CLAUSE_MASK \
48276 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
48277 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
48278 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
48279 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
48280 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
48281 : :
48282 : : static bool
48283 : 318 : cp_parser_omp_target_exit_data (cp_parser *parser, cp_token *pragma_tok,
48284 : : enum pragma_context context)
48285 : : {
48286 : 318 : bool data_seen = false;
48287 : 318 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
48288 : : {
48289 : 318 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
48290 : 318 : const char *p = IDENTIFIER_POINTER (id);
48291 : :
48292 : 318 : if (strcmp (p, "data") == 0)
48293 : : {
48294 : 318 : cp_lexer_consume_token (parser->lexer);
48295 : 318 : data_seen = true;
48296 : : }
48297 : : }
48298 : 318 : if (!data_seen)
48299 : : {
48300 : 0 : cp_parser_error (parser, "expected %<data%>");
48301 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
48302 : 0 : return false;
48303 : : }
48304 : :
48305 : 318 : if (context == pragma_stmt)
48306 : : {
48307 : 24 : error_at (pragma_tok->location,
48308 : : "%<#pragma %s%> may only be used in compound statements",
48309 : : "omp target exit data");
48310 : 24 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
48311 : 24 : return true;
48312 : : }
48313 : :
48314 : 294 : if (flag_openmp)
48315 : 294 : omp_requires_mask
48316 : 294 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
48317 : :
48318 : 294 : tree clauses
48319 : 294 : = cp_parser_omp_all_clauses (parser, OMP_TARGET_EXIT_DATA_CLAUSE_MASK,
48320 : : "#pragma omp target exit data", pragma_tok,
48321 : : false);
48322 : 294 : clauses = finish_omp_clauses (clauses, C_ORT_OMP_EXIT_DATA);
48323 : 294 : c_omp_adjust_map_clauses (clauses, false);
48324 : 294 : int map_seen = 0;
48325 : 925 : for (tree *pc = &clauses; *pc;)
48326 : : {
48327 : 631 : if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_MAP)
48328 : 562 : switch (OMP_CLAUSE_MAP_KIND (*pc))
48329 : : {
48330 : : case GOMP_MAP_FROM:
48331 : : case GOMP_MAP_ALWAYS_FROM:
48332 : : case GOMP_MAP_PRESENT_FROM:
48333 : : case GOMP_MAP_ALWAYS_PRESENT_FROM:
48334 : : case GOMP_MAP_RELEASE:
48335 : : case GOMP_MAP_DELETE:
48336 : 464 : map_seen = 3;
48337 : : break;
48338 : 23 : case GOMP_MAP_TOFROM:
48339 : 23 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_FROM);
48340 : 23 : map_seen = 3;
48341 : 23 : break;
48342 : 3 : case GOMP_MAP_ALWAYS_TOFROM:
48343 : 3 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_ALWAYS_FROM);
48344 : 3 : map_seen = 3;
48345 : 3 : break;
48346 : 0 : case GOMP_MAP_PRESENT_TOFROM:
48347 : 0 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_PRESENT_FROM);
48348 : 0 : map_seen = 3;
48349 : 0 : break;
48350 : 0 : case GOMP_MAP_ALWAYS_PRESENT_TOFROM:
48351 : 0 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_ALWAYS_PRESENT_FROM);
48352 : 0 : map_seen = 3;
48353 : 0 : break;
48354 : : case GOMP_MAP_FIRSTPRIVATE_POINTER:
48355 : : case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
48356 : : case GOMP_MAP_ALWAYS_POINTER:
48357 : : case GOMP_MAP_ATTACH_DETACH:
48358 : : case GOMP_MAP_DETACH:
48359 : : break;
48360 : 6 : default:
48361 : 6 : map_seen |= 1;
48362 : 6 : error_at (OMP_CLAUSE_LOCATION (*pc),
48363 : : "%<#pragma omp target exit data%> with map-type other "
48364 : : "than %<from%>, %<tofrom%>, %<release%> or %<delete%> "
48365 : : "on %<map%> clause");
48366 : 6 : *pc = OMP_CLAUSE_CHAIN (*pc);
48367 : 6 : continue;
48368 : : }
48369 : 625 : pc = &OMP_CLAUSE_CHAIN (*pc);
48370 : : }
48371 : :
48372 : 294 : if (map_seen != 3)
48373 : : {
48374 : 6 : if (map_seen == 0)
48375 : 0 : error_at (pragma_tok->location,
48376 : : "%<#pragma omp target exit data%> must contain at least "
48377 : : "one %<map%> clause");
48378 : 6 : return true;
48379 : : }
48380 : :
48381 : 288 : tree stmt = make_node (OMP_TARGET_EXIT_DATA);
48382 : 288 : TREE_TYPE (stmt) = void_type_node;
48383 : 288 : OMP_TARGET_EXIT_DATA_CLAUSES (stmt) = clauses;
48384 : 288 : SET_EXPR_LOCATION (stmt, pragma_tok->location);
48385 : 288 : add_stmt (stmt);
48386 : 288 : return true;
48387 : : }
48388 : :
48389 : : /* OpenMP 4.0:
48390 : : # pragma omp target update target-update-clause[optseq] new-line */
48391 : :
48392 : : #define OMP_TARGET_UPDATE_CLAUSE_MASK \
48393 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
48394 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
48395 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
48396 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
48397 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
48398 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
48399 : :
48400 : : static bool
48401 : 2932 : cp_parser_omp_target_update (cp_parser *parser, cp_token *pragma_tok,
48402 : : enum pragma_context context)
48403 : : {
48404 : 2932 : if (context == pragma_stmt)
48405 : : {
48406 : 24 : error_at (pragma_tok->location,
48407 : : "%<#pragma %s%> may only be used in compound statements",
48408 : : "omp target update");
48409 : 24 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
48410 : 24 : return true;
48411 : : }
48412 : :
48413 : 2908 : tree clauses
48414 : 2908 : = cp_parser_omp_all_clauses (parser, OMP_TARGET_UPDATE_CLAUSE_MASK,
48415 : : "#pragma omp target update", pragma_tok);
48416 : 2908 : if (omp_find_clause (clauses, OMP_CLAUSE_TO) == NULL_TREE
48417 : 2908 : && omp_find_clause (clauses, OMP_CLAUSE_FROM) == NULL_TREE)
48418 : : {
48419 : 0 : error_at (pragma_tok->location,
48420 : : "%<#pragma omp target update%> must contain at least one "
48421 : : "%<from%> or %<to%> clauses");
48422 : 0 : return true;
48423 : : }
48424 : :
48425 : 2908 : if (flag_openmp)
48426 : 2908 : omp_requires_mask
48427 : 2908 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
48428 : :
48429 : 2908 : tree stmt = make_node (OMP_TARGET_UPDATE);
48430 : 2908 : TREE_TYPE (stmt) = void_type_node;
48431 : 2908 : OMP_TARGET_UPDATE_CLAUSES (stmt) = clauses;
48432 : 2908 : SET_EXPR_LOCATION (stmt, pragma_tok->location);
48433 : 2908 : add_stmt (stmt);
48434 : 2908 : return true;
48435 : : }
48436 : :
48437 : : /* OpenMP 4.0:
48438 : : # pragma omp target target-clause[optseq] new-line
48439 : : structured-block */
48440 : :
48441 : : #define OMP_TARGET_CLAUSE_MASK \
48442 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
48443 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
48444 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
48445 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
48446 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
48447 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
48448 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
48449 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULTMAP) \
48450 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
48451 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
48452 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
48453 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR)\
48454 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR))
48455 : :
48456 : : static bool
48457 : 10207 : cp_parser_omp_target (cp_parser *parser, cp_token *pragma_tok,
48458 : : enum pragma_context context, bool *if_p)
48459 : : {
48460 : 10207 : if (flag_openmp)
48461 : 10165 : omp_requires_mask
48462 : 10165 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
48463 : :
48464 : 10207 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
48465 : : {
48466 : 9033 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
48467 : 9033 : const char *p = IDENTIFIER_POINTER (id);
48468 : 9033 : enum tree_code ccode = ERROR_MARK;
48469 : :
48470 : 9033 : if (strcmp (p, "teams") == 0)
48471 : : ccode = OMP_TEAMS;
48472 : 6925 : else if (strcmp (p, "parallel") == 0)
48473 : : ccode = OMP_PARALLEL;
48474 : 6341 : else if (strcmp (p, "simd") == 0)
48475 : : ccode = OMP_SIMD;
48476 : 6224 : if (ccode != ERROR_MARK)
48477 : : {
48478 : 2809 : tree cclauses[C_OMP_CLAUSE_SPLIT_COUNT];
48479 : 2809 : char p_name[sizeof ("#pragma omp target teams distribute "
48480 : : "parallel for simd")];
48481 : :
48482 : 2809 : cp_lexer_consume_token (parser->lexer);
48483 : 2809 : strcpy (p_name, "#pragma omp target");
48484 : 2809 : if (!flag_openmp) /* flag_openmp_simd */
48485 : : {
48486 : 39 : tree stmt;
48487 : 39 : switch (ccode)
48488 : : {
48489 : 24 : case OMP_TEAMS:
48490 : 24 : stmt = cp_parser_omp_teams (parser, pragma_tok, p_name,
48491 : 24 : OMP_TARGET_CLAUSE_MASK,
48492 : : cclauses, if_p);
48493 : 24 : break;
48494 : 12 : case OMP_PARALLEL:
48495 : 12 : stmt = cp_parser_omp_parallel (parser, pragma_tok, p_name,
48496 : 12 : OMP_TARGET_CLAUSE_MASK,
48497 : : cclauses, if_p);
48498 : 12 : break;
48499 : 3 : case OMP_SIMD:
48500 : 3 : stmt = cp_parser_omp_simd (parser, pragma_tok, p_name,
48501 : 3 : OMP_TARGET_CLAUSE_MASK,
48502 : : cclauses, if_p);
48503 : 3 : break;
48504 : 0 : default:
48505 : 0 : gcc_unreachable ();
48506 : : }
48507 : 39 : return stmt != NULL_TREE;
48508 : : }
48509 : 2770 : keep_next_level (true);
48510 : 2770 : tree sb = begin_omp_structured_block (), ret;
48511 : 2770 : unsigned save = cp_parser_begin_omp_structured_block (parser);
48512 : 2770 : switch (ccode)
48513 : : {
48514 : 2084 : case OMP_TEAMS:
48515 : 2084 : ret = cp_parser_omp_teams (parser, pragma_tok, p_name,
48516 : 2084 : OMP_TARGET_CLAUSE_MASK, cclauses,
48517 : : if_p);
48518 : 2084 : break;
48519 : 572 : case OMP_PARALLEL:
48520 : 572 : ret = cp_parser_omp_parallel (parser, pragma_tok, p_name,
48521 : 572 : OMP_TARGET_CLAUSE_MASK, cclauses,
48522 : : if_p);
48523 : 572 : break;
48524 : 114 : case OMP_SIMD:
48525 : 114 : ret = cp_parser_omp_simd (parser, pragma_tok, p_name,
48526 : 114 : OMP_TARGET_CLAUSE_MASK, cclauses,
48527 : : if_p);
48528 : 114 : break;
48529 : 0 : default:
48530 : 0 : gcc_unreachable ();
48531 : : }
48532 : 2770 : cp_parser_end_omp_structured_block (parser, save);
48533 : 2770 : tree body = finish_omp_structured_block (sb);
48534 : 2770 : if (ret == NULL_TREE)
48535 : : return false;
48536 : 2746 : if (ccode == OMP_TEAMS && !processing_template_decl)
48537 : : /* For combined target teams, ensure the num_teams and
48538 : : thread_limit clause expressions are evaluated on the host,
48539 : : before entering the target construct. */
48540 : 3221 : for (tree c = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
48541 : 3221 : c; c = OMP_CLAUSE_CHAIN (c))
48542 : 1217 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_NUM_TEAMS
48543 : 1217 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_THREAD_LIMIT)
48544 : 528 : for (int i = 0;
48545 : 870 : i <= (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_NUM_TEAMS); ++i)
48546 : 528 : if (OMP_CLAUSE_OPERAND (c, i)
48547 : 528 : && TREE_CODE (OMP_CLAUSE_OPERAND (c, i)) != INTEGER_CST)
48548 : : {
48549 : 349 : tree expr = OMP_CLAUSE_OPERAND (c, i);
48550 : 349 : expr = force_target_expr (TREE_TYPE (expr), expr,
48551 : : tf_none);
48552 : 349 : if (expr == error_mark_node)
48553 : 0 : continue;
48554 : 349 : tree tmp = TARGET_EXPR_SLOT (expr);
48555 : 349 : add_stmt (expr);
48556 : 349 : OMP_CLAUSE_OPERAND (c, i) = expr;
48557 : 349 : tree tc = build_omp_clause (OMP_CLAUSE_LOCATION (c),
48558 : : OMP_CLAUSE_FIRSTPRIVATE);
48559 : 349 : OMP_CLAUSE_DECL (tc) = tmp;
48560 : 349 : OMP_CLAUSE_CHAIN (tc)
48561 : 349 : = cclauses[C_OMP_CLAUSE_SPLIT_TARGET];
48562 : 349 : cclauses[C_OMP_CLAUSE_SPLIT_TARGET] = tc;
48563 : : }
48564 : 2746 : c_omp_adjust_map_clauses (cclauses[C_OMP_CLAUSE_SPLIT_TARGET], true);
48565 : 2746 : finish_omp_target (pragma_tok->location,
48566 : : cclauses[C_OMP_CLAUSE_SPLIT_TARGET], body, true);
48567 : 2746 : return true;
48568 : : }
48569 : 6224 : else if (!flag_openmp) /* flag_openmp_simd */
48570 : : {
48571 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
48572 : 0 : return false;
48573 : : }
48574 : 6224 : else if (strcmp (p, "data") == 0)
48575 : : {
48576 : 316 : cp_lexer_consume_token (parser->lexer);
48577 : 316 : cp_parser_omp_target_data (parser, pragma_tok, if_p);
48578 : 316 : return true;
48579 : : }
48580 : 5908 : else if (strcmp (p, "enter") == 0)
48581 : : {
48582 : 365 : cp_lexer_consume_token (parser->lexer);
48583 : 365 : return cp_parser_omp_target_enter_data (parser, pragma_tok, context);
48584 : : }
48585 : 5543 : else if (strcmp (p, "exit") == 0)
48586 : : {
48587 : 318 : cp_lexer_consume_token (parser->lexer);
48588 : 318 : return cp_parser_omp_target_exit_data (parser, pragma_tok, context);
48589 : : }
48590 : 5225 : else if (strcmp (p, "update") == 0)
48591 : : {
48592 : 2932 : cp_lexer_consume_token (parser->lexer);
48593 : 2932 : return cp_parser_omp_target_update (parser, pragma_tok, context);
48594 : : }
48595 : : }
48596 : 3467 : if (!flag_openmp) /* flag_openmp_simd */
48597 : : {
48598 : 3 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
48599 : 3 : return false;
48600 : : }
48601 : :
48602 : 3464 : tree clauses = cp_parser_omp_all_clauses (parser, OMP_TARGET_CLAUSE_MASK,
48603 : : "#pragma omp target", pragma_tok,
48604 : : false);
48605 : 7707 : for (tree c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
48606 : 4243 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION)
48607 : : {
48608 : 110 : tree nc = build_omp_clause (OMP_CLAUSE_LOCATION (c), OMP_CLAUSE_MAP);
48609 : 110 : OMP_CLAUSE_DECL (nc) = OMP_CLAUSE_DECL (c);
48610 : 110 : OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_ALWAYS_TOFROM);
48611 : 110 : OMP_CLAUSE_CHAIN (nc) = OMP_CLAUSE_CHAIN (c);
48612 : 110 : OMP_CLAUSE_CHAIN (c) = nc;
48613 : : }
48614 : 3464 : clauses = finish_omp_clauses (clauses, C_ORT_OMP_TARGET);
48615 : :
48616 : 3464 : c_omp_adjust_map_clauses (clauses, true);
48617 : 3464 : keep_next_level (true);
48618 : 3464 : tree body = cp_parser_omp_structured_block (parser, if_p);
48619 : :
48620 : 3464 : finish_omp_target (pragma_tok->location, clauses, body, false);
48621 : 3464 : return true;
48622 : : }
48623 : :
48624 : :
48625 : : /* OpenMP 5.1: Parse sizes list for "omp tile sizes"
48626 : : sizes ( size-expr-list ) */
48627 : : static tree
48628 : 1032 : cp_parser_omp_tile_sizes (cp_parser *parser, location_t loc)
48629 : : {
48630 : 1032 : tree sizes = NULL_TREE;
48631 : :
48632 : 1032 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
48633 : 5 : cp_lexer_consume_token (parser->lexer);
48634 : :
48635 : 1032 : cp_token *tok = cp_lexer_peek_token (parser->lexer);
48636 : 1032 : if (tok->type != CPP_NAME
48637 : 1032 : || strcmp ("sizes", IDENTIFIER_POINTER (tok->u.value)))
48638 : : {
48639 : 3 : cp_parser_error (parser, "expected %<sizes%>");
48640 : 3 : return error_mark_node;
48641 : : }
48642 : 1029 : cp_lexer_consume_token (parser->lexer);
48643 : :
48644 : 1029 : matching_parens parens;
48645 : 1029 : if (!parens.require_open (parser))
48646 : 11 : return error_mark_node;
48647 : :
48648 : 1625 : do
48649 : : {
48650 : 1625 : if (sizes && !cp_parser_require (parser, CPP_COMMA, RT_COMMA))
48651 : 6 : return error_mark_node;
48652 : :
48653 : 1619 : if (cp_lexer_next_token_is (parser->lexer, CPP_EMBED))
48654 : : {
48655 : : /* Handle #embed in the size-expr-list. */
48656 : 0 : tree raw_data = cp_lexer_peek_token (parser->lexer)->u.value;
48657 : 0 : cp_lexer_consume_token (parser->lexer);
48658 : 0 : for (tree argument : raw_data_range (raw_data))
48659 : 0 : sizes = tree_cons (NULL_TREE, argument, sizes);
48660 : 0 : continue;
48661 : 0 : }
48662 : :
48663 : 1619 : tree expr = cp_parser_constant_expression (parser);
48664 : 1619 : if (expr == error_mark_node)
48665 : : {
48666 : 21 : cp_parser_skip_to_closing_parenthesis (parser,
48667 : : /*recovering=*/true,
48668 : : /*or_comma=*/false,
48669 : : /*consume_paren=*/true);
48670 : 21 : return error_mark_node;
48671 : : }
48672 : :
48673 : 1598 : sizes = tree_cons (NULL_TREE, expr, sizes);
48674 : : }
48675 : 1598 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN));
48676 : 991 : parens.require_close (parser);
48677 : :
48678 : 991 : gcc_assert (sizes);
48679 : 991 : tree c = build_omp_clause (loc, OMP_CLAUSE_SIZES);
48680 : 991 : OMP_CLAUSE_SIZES_LIST (c) = nreverse (sizes);
48681 : 991 : return c;
48682 : : }
48683 : :
48684 : : /* OpenMP 5.1:
48685 : : #pragma omp tile sizes ( size-expr-list ) */
48686 : :
48687 : : static tree
48688 : 1032 : cp_parser_omp_tile (cp_parser *parser, cp_token *tok, bool *if_p)
48689 : : {
48690 : 1032 : tree clauses = cp_parser_omp_tile_sizes (parser, tok->location);
48691 : 1032 : cp_parser_require_pragma_eol (parser, tok);
48692 : :
48693 : 1032 : if (!clauses || clauses == error_mark_node)
48694 : 41 : return error_mark_node;
48695 : :
48696 : 991 : tree block = begin_omp_structured_block ();
48697 : 991 : clauses = finish_omp_clauses (clauses, C_ORT_OMP);
48698 : 991 : tree ret = cp_parser_omp_for_loop (parser, OMP_TILE, clauses, NULL, if_p);
48699 : 991 : block = finish_omp_structured_block (block);
48700 : 991 : add_stmt (block);
48701 : :
48702 : 991 : return ret;
48703 : : }
48704 : :
48705 : : #define OMP_UNROLL_CLAUSE_MASK \
48706 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARTIAL) \
48707 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FULL))
48708 : :
48709 : : /* OpenMP 5.1:
48710 : : #pragma omp unroll unroll-clause[optseq] */
48711 : :
48712 : : static tree
48713 : 694 : cp_parser_omp_unroll (cp_parser *parser, cp_token *tok, bool *if_p)
48714 : : {
48715 : 694 : tree clauses = cp_parser_omp_all_clauses (parser, OMP_UNROLL_CLAUSE_MASK,
48716 : : "#pragma omp unroll", tok, true);
48717 : :
48718 : 694 : tree block = begin_omp_structured_block ();
48719 : 694 : tree ret = cp_parser_omp_for_loop (parser, OMP_UNROLL, clauses, NULL, if_p);
48720 : 694 : block = finish_omp_structured_block (block);
48721 : 694 : add_stmt (block);
48722 : :
48723 : 694 : return ret;
48724 : : }
48725 : :
48726 : : /* OpenACC 2.0:
48727 : : # pragma acc cache (variable-list) new-line
48728 : :
48729 : : OpenACC 2.7:
48730 : : # pragma acc cache (readonly: variable-list) new-line
48731 : : */
48732 : :
48733 : : static tree
48734 : 678 : cp_parser_oacc_cache (cp_parser *parser, cp_token *pragma_tok)
48735 : : {
48736 : : /* Don't create location wrapper nodes within 'OMP_CLAUSE__CACHE_'
48737 : : clauses. */
48738 : 678 : auto_suppress_location_wrappers sentinel;
48739 : :
48740 : 678 : tree stmt, clauses = NULL_TREE;
48741 : 678 : bool readonly = false;
48742 : :
48743 : 678 : if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
48744 : : {
48745 : 666 : cp_token *token = cp_lexer_peek_token (parser->lexer);
48746 : 666 : if (token->type == CPP_NAME
48747 : 642 : && !strcmp (IDENTIFIER_POINTER (token->u.value), "readonly")
48748 : 678 : && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
48749 : : {
48750 : 12 : cp_lexer_consume_token (parser->lexer);
48751 : 12 : cp_lexer_consume_token (parser->lexer);
48752 : 12 : readonly = true;
48753 : : }
48754 : 666 : clauses = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE__CACHE_,
48755 : : NULL, NULL);
48756 : : }
48757 : :
48758 : 666 : if (readonly)
48759 : 24 : for (tree c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
48760 : 12 : OMP_CLAUSE__CACHE__READONLY (c) = 1;
48761 : :
48762 : 678 : clauses = finish_omp_clauses (clauses, C_ORT_ACC);
48763 : :
48764 : 678 : cp_parser_require_pragma_eol (parser, cp_lexer_peek_token (parser->lexer));
48765 : :
48766 : 678 : stmt = make_node (OACC_CACHE);
48767 : 678 : TREE_TYPE (stmt) = void_type_node;
48768 : 678 : OACC_CACHE_CLAUSES (stmt) = clauses;
48769 : 678 : SET_EXPR_LOCATION (stmt, pragma_tok->location);
48770 : 678 : add_stmt (stmt);
48771 : :
48772 : 678 : return stmt;
48773 : : }
48774 : :
48775 : : /* OpenACC 2.0:
48776 : : # pragma acc data oacc-data-clause[optseq] new-line
48777 : : structured-block */
48778 : :
48779 : : #define OACC_DATA_CLAUSE_MASK \
48780 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
48781 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
48782 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
48783 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
48784 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
48785 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
48786 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
48787 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
48788 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
48789 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
48790 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
48791 : :
48792 : : static tree
48793 : 675 : cp_parser_oacc_data (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
48794 : : {
48795 : 675 : tree stmt, clauses, block;
48796 : 675 : unsigned int save;
48797 : :
48798 : 675 : clauses = cp_parser_oacc_all_clauses (parser, OACC_DATA_CLAUSE_MASK,
48799 : : "#pragma acc data", pragma_tok);
48800 : :
48801 : 675 : block = begin_omp_parallel ();
48802 : 675 : save = cp_parser_begin_omp_structured_block (parser);
48803 : 675 : cp_parser_statement (parser, NULL_TREE, false, if_p);
48804 : 675 : cp_parser_end_omp_structured_block (parser, save);
48805 : 675 : stmt = finish_oacc_data (clauses, block);
48806 : 675 : return stmt;
48807 : : }
48808 : :
48809 : : /* OpenACC 2.0:
48810 : : # pragma acc host_data <clauses> new-line
48811 : : structured-block */
48812 : :
48813 : : #define OACC_HOST_DATA_CLAUSE_MASK \
48814 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_USE_DEVICE) \
48815 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
48816 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) )
48817 : :
48818 : : static tree
48819 : 61 : cp_parser_oacc_host_data (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
48820 : : {
48821 : 61 : tree stmt, clauses, block;
48822 : 61 : unsigned int save;
48823 : :
48824 : 61 : clauses = cp_parser_oacc_all_clauses (parser, OACC_HOST_DATA_CLAUSE_MASK,
48825 : : "#pragma acc host_data", pragma_tok,
48826 : : false);
48827 : 61 : if (!omp_find_clause (clauses, OMP_CLAUSE_USE_DEVICE_PTR))
48828 : : {
48829 : 6 : error_at (pragma_tok->location,
48830 : : "%<host_data%> construct requires %<use_device%> clause");
48831 : 6 : return error_mark_node;
48832 : : }
48833 : 55 : clauses = finish_omp_clauses (clauses, C_ORT_ACC);
48834 : 55 : block = begin_omp_parallel ();
48835 : 55 : save = cp_parser_begin_omp_structured_block (parser);
48836 : 55 : cp_parser_statement (parser, NULL_TREE, false, if_p);
48837 : 55 : cp_parser_end_omp_structured_block (parser, save);
48838 : 55 : stmt = finish_oacc_host_data (clauses, block);
48839 : 55 : return stmt;
48840 : : }
48841 : :
48842 : : /* OpenACC 2.0:
48843 : : # pragma acc declare oacc-data-clause[optseq] new-line
48844 : : */
48845 : :
48846 : : #define OACC_DECLARE_CLAUSE_MASK \
48847 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
48848 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
48849 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
48850 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
48851 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
48852 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT) \
48853 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_LINK) \
48854 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
48855 : :
48856 : : static tree
48857 : 411 : cp_parser_oacc_declare (cp_parser *parser, cp_token *pragma_tok)
48858 : : {
48859 : 411 : tree clauses, stmt;
48860 : 411 : bool error = false;
48861 : 411 : bool found_in_scope = global_bindings_p ();
48862 : :
48863 : 411 : clauses = cp_parser_oacc_all_clauses (parser, OACC_DECLARE_CLAUSE_MASK,
48864 : : "#pragma acc declare", pragma_tok);
48865 : :
48866 : :
48867 : 411 : if (omp_find_clause (clauses, OMP_CLAUSE_MAP) == NULL_TREE)
48868 : : {
48869 : 6 : error_at (pragma_tok->location,
48870 : : "no valid clauses specified in %<#pragma acc declare%>");
48871 : 6 : return NULL_TREE;
48872 : : }
48873 : :
48874 : 846 : for (tree t = clauses; t; t = OMP_CLAUSE_CHAIN (t))
48875 : : {
48876 : 441 : location_t loc = OMP_CLAUSE_LOCATION (t);
48877 : 441 : tree decl = OMP_CLAUSE_DECL (t);
48878 : 441 : if (!DECL_P (decl))
48879 : : {
48880 : 3 : error_at (loc, "array section in %<#pragma acc declare%>");
48881 : 3 : error = true;
48882 : 3 : continue;
48883 : : }
48884 : 438 : gcc_assert (OMP_CLAUSE_CODE (t) == OMP_CLAUSE_MAP);
48885 : 438 : switch (OMP_CLAUSE_MAP_KIND (t))
48886 : : {
48887 : : case GOMP_MAP_FIRSTPRIVATE_POINTER:
48888 : : case GOMP_MAP_ALLOC:
48889 : : case GOMP_MAP_TO:
48890 : : case GOMP_MAP_FORCE_DEVICEPTR:
48891 : : case GOMP_MAP_DEVICE_RESIDENT:
48892 : : break;
48893 : :
48894 : 39 : case GOMP_MAP_LINK:
48895 : 39 : if (!global_bindings_p ()
48896 : 39 : && (TREE_STATIC (decl)
48897 : 18 : || !DECL_EXTERNAL (decl)))
48898 : : {
48899 : 6 : error_at (loc,
48900 : : "%qD must be a global variable in "
48901 : : "%<#pragma acc declare link%>",
48902 : : decl);
48903 : 6 : error = true;
48904 : 6 : continue;
48905 : : }
48906 : : break;
48907 : :
48908 : 115 : default:
48909 : 115 : if (global_bindings_p ())
48910 : : {
48911 : 15 : error_at (loc, "invalid OpenACC clause at file scope");
48912 : 15 : error = true;
48913 : 15 : continue;
48914 : : }
48915 : 100 : if (DECL_EXTERNAL (decl))
48916 : : {
48917 : 30 : error_at (loc,
48918 : : "invalid use of %<extern%> variable %qD "
48919 : : "in %<#pragma acc declare%>", decl);
48920 : 30 : error = true;
48921 : 30 : continue;
48922 : : }
48923 : 70 : else if (TREE_PUBLIC (decl))
48924 : : {
48925 : 6 : error_at (loc,
48926 : : "invalid use of %<global%> variable %qD "
48927 : : "in %<#pragma acc declare%>", decl);
48928 : 6 : error = true;
48929 : 6 : continue;
48930 : : }
48931 : : break;
48932 : : }
48933 : :
48934 : 381 : if (!found_in_scope)
48935 : : /* This seems to ignore the existence of cleanup scopes?
48936 : : What is the meaning for local extern decls? The local
48937 : : extern is in this scope, but it is referring to a decl that
48938 : : is namespace scope. */
48939 : 264 : for (tree d = current_binding_level->names; d; d = TREE_CHAIN (d))
48940 : 252 : if (d == decl)
48941 : : {
48942 : : found_in_scope = true;
48943 : : break;
48944 : : }
48945 : 248 : if (!found_in_scope)
48946 : : {
48947 : 12 : error_at (loc,
48948 : : "%qD must be a variable declared in the same scope as "
48949 : : "%<#pragma acc declare%>", decl);
48950 : 12 : error = true;
48951 : 12 : continue;
48952 : : }
48953 : :
48954 : 369 : if (!error)
48955 : : {
48956 : 369 : if (DECL_LOCAL_DECL_P (decl))
48957 : : /* We need to mark the aliased decl, as that is the entity
48958 : : that is being referred to. This won't work for
48959 : : dependent variables, but it didn't work for them before
48960 : : DECL_LOCAL_DECL_P was a thing either. But then
48961 : : dependent local extern variable decls are as rare as
48962 : : hen's teeth. */
48963 : 93 : if (auto alias = DECL_LOCAL_DECL_ALIAS (decl))
48964 : 93 : if (alias != error_mark_node)
48965 : 369 : decl = alias;
48966 : :
48967 : 369 : if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl))
48968 : 696 : || lookup_attribute ("omp declare target link",
48969 : 327 : DECL_ATTRIBUTES (decl)))
48970 : : {
48971 : 51 : error_at (loc, "variable %qD used more than once with "
48972 : : "%<#pragma acc declare%>", decl);
48973 : 51 : error = true;
48974 : 51 : continue;
48975 : : }
48976 : :
48977 : 318 : tree id;
48978 : 318 : if (OMP_CLAUSE_MAP_KIND (t) == GOMP_MAP_LINK)
48979 : 21 : id = get_identifier ("omp declare target link");
48980 : : else
48981 : 297 : id = get_identifier ("omp declare target");
48982 : :
48983 : 318 : DECL_ATTRIBUTES (decl)
48984 : 318 : = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (decl));
48985 : 318 : if (current_binding_level->kind == sk_namespace)
48986 : : {
48987 : 126 : symtab_node *node = symtab_node::get (decl);
48988 : 126 : if (node != NULL)
48989 : : {
48990 : 90 : node->offloadable = 1;
48991 : 90 : if (ENABLE_OFFLOADING)
48992 : : {
48993 : : g->have_offload = true;
48994 : : if (is_a <varpool_node *> (node))
48995 : : vec_safe_push (offload_vars, decl);
48996 : : }
48997 : : }
48998 : : }
48999 : : }
49000 : : }
49001 : :
49002 : 405 : if (error || current_binding_level->kind == sk_namespace)
49003 : : return NULL_TREE;
49004 : :
49005 : 186 : stmt = make_node (OACC_DECLARE);
49006 : 186 : TREE_TYPE (stmt) = void_type_node;
49007 : 186 : OACC_DECLARE_CLAUSES (stmt) = clauses;
49008 : 186 : SET_EXPR_LOCATION (stmt, pragma_tok->location);
49009 : :
49010 : 186 : add_stmt (stmt);
49011 : :
49012 : 186 : return NULL_TREE;
49013 : : }
49014 : :
49015 : : /* OpenACC 2.0:
49016 : : # pragma acc enter data oacc-enter-data-clause[optseq] new-line
49017 : :
49018 : : or
49019 : :
49020 : : # pragma acc exit data oacc-exit-data-clause[optseq] new-line
49021 : :
49022 : : LOC is the location of the #pragma token.
49023 : : */
49024 : :
49025 : : #define OACC_ENTER_DATA_CLAUSE_MASK \
49026 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
49027 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
49028 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
49029 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
49030 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
49031 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
49032 : :
49033 : : #define OACC_EXIT_DATA_CLAUSE_MASK \
49034 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
49035 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
49036 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
49037 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
49038 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
49039 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FINALIZE) \
49040 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
49041 : :
49042 : : static tree
49043 : 639 : cp_parser_oacc_enter_exit_data (cp_parser *parser, cp_token *pragma_tok,
49044 : : bool enter)
49045 : : {
49046 : 639 : location_t loc = pragma_tok->location;
49047 : 639 : tree stmt, clauses;
49048 : 639 : const char *p = "";
49049 : :
49050 : 639 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
49051 : 618 : p = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
49052 : :
49053 : 639 : if (strcmp (p, "data") != 0)
49054 : : {
49055 : 60 : error_at (loc, "expected %<data%> after %<#pragma acc %s%>",
49056 : : enter ? "enter" : "exit");
49057 : 42 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
49058 : 42 : return NULL_TREE;
49059 : : }
49060 : :
49061 : 597 : cp_lexer_consume_token (parser->lexer);
49062 : :
49063 : 597 : if (enter)
49064 : 297 : clauses = cp_parser_oacc_all_clauses (parser, OACC_ENTER_DATA_CLAUSE_MASK,
49065 : : "#pragma acc enter data", pragma_tok);
49066 : : else
49067 : 300 : clauses = cp_parser_oacc_all_clauses (parser, OACC_EXIT_DATA_CLAUSE_MASK,
49068 : : "#pragma acc exit data", pragma_tok);
49069 : :
49070 : 597 : if (omp_find_clause (clauses, OMP_CLAUSE_MAP) == NULL_TREE)
49071 : : {
49072 : 99 : error_at (loc, "%<#pragma acc %s data%> has no data movement clause",
49073 : : enter ? "enter" : "exit");
49074 : 99 : return NULL_TREE;
49075 : : }
49076 : :
49077 : 498 : stmt = enter ? make_node (OACC_ENTER_DATA) : make_node (OACC_EXIT_DATA);
49078 : 498 : TREE_TYPE (stmt) = void_type_node;
49079 : 498 : OMP_STANDALONE_CLAUSES (stmt) = clauses;
49080 : 498 : SET_EXPR_LOCATION (stmt, loc);
49081 : 498 : add_stmt (stmt);
49082 : 498 : return stmt;
49083 : : }
49084 : :
49085 : : /* OpenACC 2.0:
49086 : : # pragma acc loop oacc-loop-clause[optseq] new-line
49087 : : structured-block */
49088 : :
49089 : : #define OACC_LOOP_CLAUSE_MASK \
49090 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
49091 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
49092 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
49093 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
49094 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
49095 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
49096 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_AUTO) \
49097 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_INDEPENDENT) \
49098 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
49099 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_TILE))
49100 : :
49101 : : static tree
49102 : 4363 : cp_parser_oacc_loop (cp_parser *parser, cp_token *pragma_tok, char *p_name,
49103 : : omp_clause_mask mask, tree *cclauses, bool *if_p)
49104 : : {
49105 : 4363 : bool is_parallel = ((mask >> PRAGMA_OACC_CLAUSE_REDUCTION) & 1) == 1;
49106 : :
49107 : 4363 : strcat (p_name, " loop");
49108 : 4363 : mask |= OACC_LOOP_CLAUSE_MASK;
49109 : :
49110 : 4363 : tree clauses = cp_parser_oacc_all_clauses (parser, mask, p_name, pragma_tok,
49111 : : /*finish_p=*/cclauses == NULL,
49112 : : /*target=*/is_parallel);
49113 : 4363 : if (cclauses)
49114 : : {
49115 : 1020 : clauses = c_oacc_split_loop_clauses (clauses, cclauses, is_parallel);
49116 : 1020 : if (*cclauses)
49117 : 222 : *cclauses = finish_omp_clauses (*cclauses, C_ORT_ACC_TARGET);
49118 : 1020 : if (clauses)
49119 : 560 : clauses = finish_omp_clauses (clauses, C_ORT_ACC);
49120 : : }
49121 : :
49122 : 4363 : tree block = begin_omp_structured_block ();
49123 : 4363 : int save = cp_parser_begin_omp_structured_block (parser);
49124 : 4363 : tree stmt = cp_parser_omp_for_loop (parser, OACC_LOOP, clauses, NULL, if_p);
49125 : 4363 : cp_parser_end_omp_structured_block (parser, save);
49126 : :
49127 : : /* Later processing of combined acc loop constructs gets confused
49128 : : by an extra level of empty nested BIND_EXPRs, so flatten them. */
49129 : 4363 : block = finish_omp_structured_block (block);
49130 : 4363 : if (TREE_CODE (block) == BIND_EXPR
49131 : 1257 : && TREE_CODE (BIND_EXPR_BODY (block)) == BIND_EXPR
49132 : 5256 : && !BIND_EXPR_VARS (block))
49133 : 893 : block = BIND_EXPR_BODY (block);
49134 : 4363 : add_stmt (block);
49135 : :
49136 : 4363 : return stmt;
49137 : : }
49138 : :
49139 : : /* OpenACC 2.0:
49140 : : # pragma acc kernels oacc-kernels-clause[optseq] new-line
49141 : : structured-block
49142 : :
49143 : : or
49144 : :
49145 : : # pragma acc parallel oacc-parallel-clause[optseq] new-line
49146 : : structured-block
49147 : :
49148 : : OpenACC 2.6:
49149 : :
49150 : : # pragma acc serial oacc-serial-clause[optseq] new-line
49151 : : */
49152 : :
49153 : : #define OACC_KERNELS_CLAUSE_MASK \
49154 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
49155 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
49156 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
49157 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
49158 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
49159 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
49160 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
49161 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
49162 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
49163 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
49164 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
49165 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
49166 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
49167 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
49168 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
49169 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
49170 : :
49171 : : #define OACC_PARALLEL_CLAUSE_MASK \
49172 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
49173 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
49174 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
49175 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
49176 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
49177 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
49178 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
49179 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
49180 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
49181 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
49182 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
49183 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
49184 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
49185 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
49186 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
49187 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
49188 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
49189 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
49190 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
49191 : :
49192 : : #define OACC_SERIAL_CLAUSE_MASK \
49193 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
49194 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
49195 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
49196 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
49197 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
49198 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
49199 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
49200 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
49201 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
49202 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
49203 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
49204 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
49205 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
49206 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
49207 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
49208 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
49209 : :
49210 : : static tree
49211 : 3928 : cp_parser_oacc_compute (cp_parser *parser, cp_token *pragma_tok,
49212 : : char *p_name, bool *if_p)
49213 : : {
49214 : 3928 : omp_clause_mask mask;
49215 : 3928 : enum tree_code code;
49216 : 3928 : switch (cp_parser_pragma_kind (pragma_tok))
49217 : : {
49218 : 1195 : case PRAGMA_OACC_KERNELS:
49219 : 1195 : strcat (p_name, " kernels");
49220 : 1195 : mask = OACC_KERNELS_CLAUSE_MASK;
49221 : 1195 : code = OACC_KERNELS;
49222 : 1195 : break;
49223 : 2676 : case PRAGMA_OACC_PARALLEL:
49224 : 2676 : strcat (p_name, " parallel");
49225 : 2676 : mask = OACC_PARALLEL_CLAUSE_MASK;
49226 : 2676 : code = OACC_PARALLEL;
49227 : 2676 : break;
49228 : 57 : case PRAGMA_OACC_SERIAL:
49229 : 57 : strcat (p_name, " serial");
49230 : 57 : mask = OACC_SERIAL_CLAUSE_MASK;
49231 : 57 : code = OACC_SERIAL;
49232 : 57 : break;
49233 : 0 : default:
49234 : 0 : gcc_unreachable ();
49235 : : }
49236 : :
49237 : 3928 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
49238 : : {
49239 : 3007 : const char *p
49240 : 3007 : = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
49241 : 3007 : if (strcmp (p, "loop") == 0)
49242 : : {
49243 : 1020 : cp_lexer_consume_token (parser->lexer);
49244 : 1020 : tree block = begin_omp_parallel ();
49245 : 1020 : tree clauses;
49246 : 1020 : tree stmt = cp_parser_oacc_loop (parser, pragma_tok, p_name, mask,
49247 : : &clauses, if_p);
49248 : 1020 : protected_set_expr_location (stmt, pragma_tok->location);
49249 : 1020 : return finish_omp_construct (code, block, clauses);
49250 : : }
49251 : : }
49252 : :
49253 : 2908 : tree clauses = cp_parser_oacc_all_clauses (parser, mask, p_name, pragma_tok,
49254 : : /*finish_p=*/true,
49255 : : /*target=*/true);
49256 : :
49257 : 2908 : tree block = begin_omp_parallel ();
49258 : 2908 : unsigned int save = cp_parser_begin_omp_structured_block (parser);
49259 : 2908 : cp_parser_statement (parser, NULL_TREE, false, if_p);
49260 : 2908 : cp_parser_end_omp_structured_block (parser, save);
49261 : 2908 : return finish_omp_construct (code, block, clauses);
49262 : : }
49263 : :
49264 : : /* OpenACC 2.0:
49265 : : # pragma acc update oacc-update-clause[optseq] new-line
49266 : : */
49267 : :
49268 : : #define OACC_UPDATE_CLAUSE_MASK \
49269 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
49270 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
49271 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
49272 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
49273 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) \
49274 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
49275 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
49276 : :
49277 : : static tree
49278 : 192 : cp_parser_oacc_update (cp_parser *parser, cp_token *pragma_tok)
49279 : : {
49280 : 192 : tree stmt, clauses;
49281 : :
49282 : 192 : clauses = cp_parser_oacc_all_clauses (parser, OACC_UPDATE_CLAUSE_MASK,
49283 : : "#pragma acc update", pragma_tok);
49284 : :
49285 : 192 : if (omp_find_clause (clauses, OMP_CLAUSE_MAP) == NULL_TREE)
49286 : : {
49287 : 3 : error_at (pragma_tok->location,
49288 : : "%<#pragma acc update%> must contain at least one "
49289 : : "%<device%> or %<host%> or %<self%> clause");
49290 : 3 : return NULL_TREE;
49291 : : }
49292 : :
49293 : 189 : stmt = make_node (OACC_UPDATE);
49294 : 189 : TREE_TYPE (stmt) = void_type_node;
49295 : 189 : OACC_UPDATE_CLAUSES (stmt) = clauses;
49296 : 189 : SET_EXPR_LOCATION (stmt, pragma_tok->location);
49297 : 189 : add_stmt (stmt);
49298 : 189 : return stmt;
49299 : : }
49300 : :
49301 : : /* OpenACC 2.0:
49302 : : # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
49303 : :
49304 : : LOC is the location of the #pragma token.
49305 : : */
49306 : :
49307 : : #define OACC_WAIT_CLAUSE_MASK \
49308 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC))
49309 : :
49310 : : static tree
49311 : 137 : cp_parser_oacc_wait (cp_parser *parser, cp_token *pragma_tok)
49312 : : {
49313 : 137 : tree clauses, list = NULL_TREE, stmt = NULL_TREE;
49314 : 137 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
49315 : :
49316 : 137 : if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
49317 : 67 : list = cp_parser_oacc_wait_list (parser, loc, list);
49318 : :
49319 : 137 : clauses = cp_parser_oacc_all_clauses (parser, OACC_WAIT_CLAUSE_MASK,
49320 : : "#pragma acc wait", pragma_tok);
49321 : :
49322 : 137 : stmt = c_finish_oacc_wait (loc, list, clauses);
49323 : 137 : stmt = finish_expr_stmt (stmt);
49324 : :
49325 : 137 : return stmt;
49326 : : }
49327 : :
49328 : : /* OpenMP 4.0:
49329 : : # pragma omp declare simd declare-simd-clauses[optseq] new-line */
49330 : :
49331 : : #define OMP_DECLARE_SIMD_CLAUSE_MASK \
49332 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
49333 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
49334 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
49335 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
49336 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
49337 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
49338 : :
49339 : : static void
49340 : 2188 : cp_parser_omp_declare_simd (cp_parser *parser, cp_token *pragma_tok,
49341 : : enum pragma_context context,
49342 : : bool variant_p)
49343 : : {
49344 : 2188 : bool first_p = parser->omp_declare_simd == NULL;
49345 : 2188 : cp_omp_declare_simd_data data;
49346 : 2188 : if (first_p)
49347 : : {
49348 : 1970 : data.error_seen = false;
49349 : 1970 : data.fndecl_seen = false;
49350 : 1970 : data.variant_p = variant_p;
49351 : 1970 : data.tokens = vNULL;
49352 : 1970 : data.attribs[0] = NULL;
49353 : 1970 : data.attribs[1] = NULL;
49354 : 1970 : data.loc = UNKNOWN_LOCATION;
49355 : : /* It is safe to take the address of a local variable; it will only be
49356 : : used while this scope is live. */
49357 : 1970 : parser->omp_declare_simd = &data;
49358 : : }
49359 : 218 : else if (parser->omp_declare_simd->variant_p != variant_p)
49360 : : {
49361 : 0 : error_at (pragma_tok->location,
49362 : : "%<#pragma omp declare %s%> followed by "
49363 : : "%<#pragma omp declare %s%>",
49364 : : parser->omp_declare_simd->variant_p ? "variant" : "simd",
49365 : : parser->omp_declare_simd->variant_p ? "simd" : "variant");
49366 : 0 : parser->omp_declare_simd->error_seen = true;
49367 : : }
49368 : :
49369 : : /* Store away all pragma tokens. */
49370 : 34148 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
49371 : 31960 : cp_lexer_consume_token (parser->lexer);
49372 : 2188 : cp_parser_require_pragma_eol (parser, pragma_tok);
49373 : 2188 : struct cp_token_cache *cp
49374 : 2188 : = cp_token_cache_new (pragma_tok, cp_lexer_peek_token (parser->lexer));
49375 : 2188 : parser->omp_declare_simd->tokens.safe_push (cp);
49376 : :
49377 : 2188 : if (first_p)
49378 : : {
49379 : 2197 : while (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
49380 : 227 : cp_parser_pragma (parser, context, NULL);
49381 : 1970 : switch (context)
49382 : : {
49383 : 1702 : case pragma_external:
49384 : 1702 : cp_parser_declaration (parser, NULL_TREE);
49385 : 1702 : break;
49386 : 229 : case pragma_member:
49387 : 229 : cp_parser_member_declaration (parser);
49388 : 229 : break;
49389 : 0 : case pragma_objc_icode:
49390 : 0 : cp_parser_block_declaration (parser, /*statement_p=*/false);
49391 : 0 : break;
49392 : 39 : default:
49393 : 39 : cp_parser_declaration_statement (parser);
49394 : 39 : break;
49395 : : }
49396 : 1970 : if (parser->omp_declare_simd
49397 : 1628 : && !parser->omp_declare_simd->error_seen
49398 : 1622 : && !parser->omp_declare_simd->fndecl_seen)
49399 : 12 : error_at (pragma_tok->location,
49400 : : "%<#pragma omp declare %s%> not immediately followed by "
49401 : : "function declaration or definition",
49402 : 12 : parser->omp_declare_simd->variant_p ? "variant" : "simd");
49403 : 1970 : data.tokens.release ();
49404 : 1970 : parser->omp_declare_simd = NULL;
49405 : : }
49406 : 2188 : }
49407 : :
49408 : : /* OpenMP 5.0:
49409 : :
49410 : : trait-selector:
49411 : : trait-selector-name[([trait-score:]trait-property[,trait-property[,...]])]
49412 : :
49413 : : trait-score:
49414 : : score(score-expression)
49415 : :
49416 : : Note that this function returns a list of trait selectors for the
49417 : : trait-selector-set SET. */
49418 : :
49419 : : static tree
49420 : 1397 : cp_parser_omp_context_selector (cp_parser *parser, enum omp_tss_code set,
49421 : : bool has_parms_p)
49422 : : {
49423 : 1397 : tree ret = NULL_TREE;
49424 : 1703 : do
49425 : : {
49426 : 1703 : tree selector;
49427 : 1703 : if (cp_lexer_next_token_is (parser->lexer, CPP_KEYWORD)
49428 : 1703 : || cp_lexer_next_token_is (parser->lexer, CPP_NAME))
49429 : 1697 : selector = cp_lexer_peek_token (parser->lexer)->u.value;
49430 : : else
49431 : : {
49432 : 6 : cp_parser_error (parser, "expected trait selector name");
49433 : 6 : return error_mark_node;
49434 : : }
49435 : :
49436 : 1697 : enum omp_ts_code sel
49437 : 1697 : = omp_lookup_ts_code (set, IDENTIFIER_POINTER (selector));
49438 : :
49439 : 1697 : if (sel == OMP_TRAIT_INVALID)
49440 : : {
49441 : : /* Per the spec, "Implementations can ignore specified selectors
49442 : : that are not those described in this section"; however, we
49443 : : must record such selectors because they cause match failures. */
49444 : 54 : warning_at (cp_lexer_peek_token (parser->lexer)->location,
49445 : : OPT_Wopenmp,
49446 : : "unknown selector %qs for context selector set %qs",
49447 : 54 : IDENTIFIER_POINTER (selector), omp_tss_map[set]);
49448 : 54 : cp_lexer_consume_token (parser->lexer);
49449 : 54 : ret = make_trait_selector (sel, NULL_TREE, NULL_TREE, ret);
49450 : 54 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
49451 : 72 : for (size_t n = cp_parser_skip_balanced_tokens (parser, 1) - 1;
49452 : 72 : n; --n)
49453 : 57 : cp_lexer_consume_token (parser->lexer);
49454 : 54 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
49455 : : {
49456 : 3 : cp_lexer_consume_token (parser->lexer);
49457 : 3 : continue;
49458 : : }
49459 : : else
49460 : : break;
49461 : : }
49462 : :
49463 : 1643 : cp_lexer_consume_token (parser->lexer);
49464 : :
49465 : 1643 : tree properties = NULL_TREE;
49466 : 1643 : tree scoreval = NULL_TREE;
49467 : 1643 : enum omp_tp_type property_kind = omp_ts_map[sel].tp_type;
49468 : 1643 : bool allow_score = omp_ts_map[sel].allow_score;
49469 : 1643 : tree t;
49470 : :
49471 : 1643 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
49472 : : {
49473 : 1011 : if (property_kind == OMP_TRAIT_PROPERTY_NONE)
49474 : : {
49475 : 18 : error ("selector %qs does not accept any properties",
49476 : 18 : IDENTIFIER_POINTER (selector));
49477 : 49 : return error_mark_node;
49478 : : }
49479 : :
49480 : 993 : matching_parens parens;
49481 : 993 : parens.consume_open (parser);
49482 : :
49483 : 993 : cp_token *token = cp_lexer_peek_token (parser->lexer);
49484 : 993 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
49485 : 629 : && strcmp (IDENTIFIER_POINTER (token->u.value), "score") == 0
49486 : 1206 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
49487 : : {
49488 : 213 : cp_lexer_save_tokens (parser->lexer);
49489 : 213 : cp_lexer_consume_token (parser->lexer);
49490 : 213 : cp_lexer_consume_token (parser->lexer);
49491 : 213 : if (cp_parser_skip_to_closing_parenthesis (parser, false, false,
49492 : : true)
49493 : 213 : && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
49494 : : {
49495 : 207 : cp_lexer_rollback_tokens (parser->lexer);
49496 : 207 : cp_lexer_consume_token (parser->lexer);
49497 : :
49498 : 207 : matching_parens parens2;
49499 : 207 : parens2.require_open (parser);
49500 : 207 : tree score = cp_parser_constant_expression (parser);
49501 : 207 : if (!parens2.require_close (parser))
49502 : 0 : cp_parser_skip_to_closing_parenthesis (parser, true,
49503 : : false, true);
49504 : 207 : cp_parser_require (parser, CPP_COLON, RT_COLON);
49505 : 207 : if (!allow_score)
49506 : 12 : error_at (token->location,
49507 : : "%<score%> cannot be specified in traits "
49508 : : "in the %qs trait-selector-set",
49509 : : omp_tss_map[set]);
49510 : 195 : else if (score != error_mark_node)
49511 : : {
49512 : 194 : score = fold_non_dependent_expr (score);
49513 : 194 : if (value_dependent_expression_p (score))
49514 : : scoreval = score;
49515 : 334 : else if (!INTEGRAL_TYPE_P (TREE_TYPE (score))
49516 : 332 : || TREE_CODE (score) != INTEGER_CST)
49517 : 2 : error_at (token->location, "%<score%> argument must "
49518 : : "be constant integer expression");
49519 : 165 : else if (tree_int_cst_sgn (score) < 0)
49520 : 3 : error_at (token->location, "%<score%> argument must "
49521 : : "be non-negative");
49522 : : else
49523 : : scoreval = score;
49524 : : }
49525 : : }
49526 : : else
49527 : 6 : cp_lexer_rollback_tokens (parser->lexer);
49528 : :
49529 : 213 : token = cp_lexer_peek_token (parser->lexer);
49530 : : }
49531 : :
49532 : 993 : switch (property_kind)
49533 : : {
49534 : 69 : case OMP_TRAIT_PROPERTY_ID:
49535 : 69 : if (cp_lexer_next_token_is (parser->lexer, CPP_KEYWORD)
49536 : 69 : || cp_lexer_next_token_is (parser->lexer, CPP_NAME))
49537 : : {
49538 : 66 : tree prop = cp_lexer_peek_token (parser->lexer)->u.value;
49539 : 66 : cp_lexer_consume_token (parser->lexer);
49540 : 66 : properties = make_trait_property (prop, NULL_TREE,
49541 : : properties);
49542 : : }
49543 : : else
49544 : : {
49545 : 3 : cp_parser_error (parser, "expected identifier");
49546 : 3 : return error_mark_node;
49547 : : }
49548 : 66 : break;
49549 : 677 : case OMP_TRAIT_PROPERTY_NAME_LIST:
49550 : 848 : do
49551 : : {
49552 : 677 : tree prop = OMP_TP_NAMELIST_NODE;
49553 : 677 : tree value = NULL_TREE;
49554 : 677 : if (cp_lexer_next_token_is (parser->lexer, CPP_KEYWORD)
49555 : 677 : || cp_lexer_next_token_is (parser->lexer, CPP_NAME))
49556 : : {
49557 : 527 : value = cp_lexer_peek_token (parser->lexer)->u.value;
49558 : 527 : cp_lexer_consume_token (parser->lexer);
49559 : : }
49560 : 150 : else if (cp_lexer_next_token_is (parser->lexer, CPP_STRING))
49561 : 135 : value = cp_parser_string_literal (parser,
49562 : : /*translate=*/false,
49563 : : /*wide_ok=*/false);
49564 : : else
49565 : : {
49566 : 15 : cp_parser_error (parser, "expected identifier or "
49567 : : "string literal");
49568 : 15 : return error_mark_node;
49569 : : }
49570 : :
49571 : 662 : properties = make_trait_property (prop, value, properties);
49572 : :
49573 : 662 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
49574 : 171 : cp_lexer_consume_token (parser->lexer);
49575 : : else
49576 : : break;
49577 : 171 : }
49578 : : while (1);
49579 : : break;
49580 : 367 : case OMP_TRAIT_PROPERTY_DEV_NUM_EXPR:
49581 : 367 : case OMP_TRAIT_PROPERTY_BOOL_EXPR:
49582 : : /* FIXME: this is bogus, the expression need
49583 : : not be constant. */
49584 : 367 : t = cp_parser_constant_expression (parser);
49585 : 367 : if (t != error_mark_node)
49586 : : {
49587 : 354 : t = fold_non_dependent_expr (t);
49588 : 354 : if (!value_dependent_expression_p (t)
49589 : 354 : && (!INTEGRAL_TYPE_P (TREE_TYPE (t))
49590 : 325 : || !tree_fits_shwi_p (t)))
49591 : 2 : error_at (token->location, "property must be "
49592 : : "constant integer expression");
49593 : : else
49594 : 352 : properties = make_trait_property (NULL_TREE, t,
49595 : : properties);
49596 : : }
49597 : : else
49598 : : return error_mark_node;
49599 : : break;
49600 : 51 : case OMP_TRAIT_PROPERTY_CLAUSE_LIST:
49601 : 51 : if (sel == OMP_TRAIT_CONSTRUCT_SIMD)
49602 : : {
49603 : 51 : if (!has_parms_p)
49604 : : {
49605 : 0 : error_at (token->location, "properties for %<simd%> "
49606 : : "selector may not be specified in "
49607 : : "%<metadirective%>");
49608 : 0 : return error_mark_node;
49609 : : }
49610 : 51 : properties
49611 : 51 : = cp_parser_omp_all_clauses (parser,
49612 : 51 : OMP_DECLARE_SIMD_CLAUSE_MASK,
49613 : : "simd", NULL, true, 2);
49614 : : }
49615 : 0 : else if (sel == OMP_TRAIT_IMPLEMENTATION_REQUIRES)
49616 : : {
49617 : : /* FIXME: The "requires" selector was added in OpenMP 5.1.
49618 : : Currently only the now-deprecated syntax
49619 : : from OpenMP 5.0 is supported. */
49620 : 0 : sorry_at (token->location,
49621 : : "%<requires%> selector is not supported yet");
49622 : 0 : return error_mark_node;
49623 : : }
49624 : : else
49625 : 0 : gcc_unreachable ();
49626 : 51 : break;
49627 : 0 : default:
49628 : 0 : gcc_unreachable ();
49629 : : }
49630 : :
49631 : 962 : if (!parens.require_close (parser))
49632 : 9 : cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
49633 : :
49634 : 962 : properties = nreverse (properties);
49635 : : }
49636 : 632 : else if (property_kind != OMP_TRAIT_PROPERTY_NONE
49637 : 632 : && property_kind != OMP_TRAIT_PROPERTY_CLAUSE_LIST
49638 : 24 : && property_kind != OMP_TRAIT_PROPERTY_EXTENSION)
49639 : : {
49640 : 24 : cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
49641 : 24 : return error_mark_node;
49642 : : }
49643 : :
49644 : 1570 : ret = make_trait_selector (sel, scoreval, properties, ret);
49645 : :
49646 : 1570 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
49647 : 303 : cp_lexer_consume_token (parser->lexer);
49648 : : else
49649 : : break;
49650 : : }
49651 : : while (1);
49652 : :
49653 : 1318 : return nreverse (ret);
49654 : : }
49655 : :
49656 : : /* OpenMP 5.0:
49657 : :
49658 : : trait-set-selector[,trait-set-selector[,...]]
49659 : :
49660 : : trait-set-selector:
49661 : : trait-set-selector-name = { trait-selector[, trait-selector[, ...]] }
49662 : :
49663 : : trait-set-selector-name:
49664 : : constructor
49665 : : device
49666 : : implementation
49667 : : user */
49668 : :
49669 : : static tree
49670 : 1301 : cp_parser_omp_context_selector_specification (cp_parser *parser,
49671 : : bool has_parms_p)
49672 : : {
49673 : 1301 : tree ret = NULL_TREE;
49674 : 1541 : do
49675 : : {
49676 : 1421 : const char *setp = "";
49677 : 1421 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
49678 : 1415 : setp
49679 : 1415 : = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
49680 : 1421 : enum omp_tss_code set = omp_lookup_tss_code (setp);
49681 : :
49682 : 1421 : if (set == OMP_TRAIT_SET_INVALID)
49683 : : {
49684 : 15 : cp_parser_error (parser, "expected context selector set name");
49685 : 24 : return error_mark_node;
49686 : : }
49687 : :
49688 : 1406 : cp_lexer_consume_token (parser->lexer);
49689 : :
49690 : 1406 : if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
49691 : 3 : return error_mark_node;
49692 : :
49693 : 1403 : matching_braces braces;
49694 : 1403 : if (!braces.require_open (parser))
49695 : 6 : return error_mark_node;
49696 : :
49697 : 1397 : tree selectors
49698 : 1397 : = cp_parser_omp_context_selector (parser, set, has_parms_p);
49699 : 1397 : if (selectors == error_mark_node)
49700 : : {
49701 : 79 : cp_parser_skip_to_closing_brace (parser);
49702 : 79 : ret = error_mark_node;
49703 : : }
49704 : 1318 : else if (ret != error_mark_node)
49705 : 1318 : ret = make_trait_set_selector (set, selectors, ret);
49706 : :
49707 : 1397 : braces.require_close (parser);
49708 : :
49709 : 1397 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
49710 : 120 : cp_lexer_consume_token (parser->lexer);
49711 : : else
49712 : : break;
49713 : 120 : }
49714 : : while (1);
49715 : :
49716 : 1277 : if (ret == error_mark_node)
49717 : : return ret;
49718 : 1198 : return nreverse (ret);
49719 : : }
49720 : :
49721 : : /* Assumption clauses:
49722 : : OpenMP 5.1
49723 : : absent (directive-name-list)
49724 : : contains (directive-name-list)
49725 : : holds (expression)
49726 : : no_openmp
49727 : : no_openmp_routines
49728 : : no_parallelism */
49729 : :
49730 : : static void
49731 : 372 : cp_parser_omp_assumption_clauses (cp_parser *parser, cp_token *pragma_tok,
49732 : : bool is_assume)
49733 : : {
49734 : 372 : bool no_openmp = false;
49735 : 372 : bool no_openmp_routines = false;
49736 : 372 : bool no_parallelism = false;
49737 : 372 : bitmap_head absent_head, contains_head;
49738 : :
49739 : 372 : bitmap_obstack_initialize (NULL);
49740 : 372 : bitmap_initialize (&absent_head, &bitmap_default_obstack);
49741 : 372 : bitmap_initialize (&contains_head, &bitmap_default_obstack);
49742 : :
49743 : 372 : if (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA_EOL))
49744 : 9 : error_at (cp_lexer_peek_token (parser->lexer)->location,
49745 : : "expected at least one assumption clause");
49746 : :
49747 : 1029 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
49748 : : {
49749 : 666 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
49750 : 666 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
49751 : 159 : cp_lexer_consume_token (parser->lexer);
49752 : :
49753 : 666 : if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
49754 : : break;
49755 : :
49756 : 666 : const char *p
49757 : 666 : = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
49758 : 666 : location_t cloc = cp_lexer_peek_token (parser->lexer)->location;
49759 : :
49760 : 666 : if (!strcmp (p, "no_openmp"))
49761 : : {
49762 : 48 : cp_lexer_consume_token (parser->lexer);
49763 : 48 : if (no_openmp)
49764 : 9 : error_at (cloc, "too many %qs clauses", "no_openmp");
49765 : : no_openmp = true;
49766 : : }
49767 : 618 : else if (!strcmp (p, "no_openmp_routines"))
49768 : : {
49769 : 48 : cp_lexer_consume_token (parser->lexer);
49770 : 48 : if (no_openmp_routines)
49771 : 9 : error_at (cloc, "too many %qs clauses", "no_openmp_routines");
49772 : : no_openmp_routines = true;
49773 : : }
49774 : 570 : else if (!strcmp (p, "no_parallelism"))
49775 : : {
49776 : 54 : cp_lexer_consume_token (parser->lexer);
49777 : 54 : if (no_parallelism)
49778 : 9 : error_at (cloc, "too many %qs clauses", "no_parallelism");
49779 : : no_parallelism = true;
49780 : : }
49781 : 516 : else if (!strcmp (p, "holds"))
49782 : : {
49783 : 54 : cp_lexer_consume_token (parser->lexer);
49784 : 54 : matching_parens parens;
49785 : 54 : if (parens.require_open (parser))
49786 : : {
49787 : 54 : location_t eloc = cp_lexer_peek_token (parser->lexer)->location;
49788 : 54 : tree t = cp_parser_assignment_expression (parser);
49789 : 54 : if (!type_dependent_expression_p (t))
49790 : 54 : t = contextual_conv_bool (t, tf_warning_or_error);
49791 : 54 : if (is_assume && !error_operand_p (t))
49792 : 30 : finish_expr_stmt (build_assume_call (eloc, t));
49793 : 54 : if (!parens.require_close (parser))
49794 : 0 : cp_parser_skip_to_closing_parenthesis (parser,
49795 : : /*recovering=*/true,
49796 : : /*or_comma=*/false,
49797 : : /*consume_paren=*/true);
49798 : : }
49799 : : }
49800 : 462 : else if (!strcmp (p, "absent") || !strcmp (p, "contains"))
49801 : : {
49802 : 435 : cp_lexer_consume_token (parser->lexer);
49803 : 435 : matching_parens parens;
49804 : 435 : if (parens.require_open (parser))
49805 : : {
49806 : 1809 : do
49807 : : {
49808 : 1122 : const char *directive[3] = {};
49809 : 1122 : int i;
49810 : 1122 : location_t dloc
49811 : 1122 : = cp_lexer_peek_token (parser->lexer)->location;
49812 : 2523 : for (i = 0; i < 3; i++)
49813 : : {
49814 : 2424 : tree id;
49815 : 2424 : if (cp_lexer_nth_token_is (parser->lexer, i + 1, CPP_NAME))
49816 : 1365 : id = cp_lexer_peek_nth_token (parser->lexer,
49817 : : i + 1)->u.value;
49818 : 1059 : else if (cp_lexer_nth_token_is (parser->lexer, i + 1,
49819 : : CPP_KEYWORD))
49820 : : {
49821 : 36 : enum rid rid
49822 : : = cp_lexer_peek_nth_token (parser->lexer,
49823 : 36 : i + 1)->keyword;
49824 : 36 : id = ridpointers[rid];
49825 : : }
49826 : : else
49827 : : break;
49828 : 1401 : directive[i] = IDENTIFIER_POINTER (id);
49829 : : }
49830 : 1122 : if (i == 0)
49831 : 0 : error_at (dloc, "expected directive name");
49832 : : else
49833 : : {
49834 : 1122 : const struct c_omp_directive *dir
49835 : 1122 : = c_omp_categorize_directive (directive[0],
49836 : : directive[1],
49837 : : directive[2]);
49838 : 1122 : if (dir == NULL
49839 : 1113 : || dir->kind == C_OMP_DIR_DECLARATIVE
49840 : 1104 : || dir->kind == C_OMP_DIR_INFORMATIONAL
49841 : 1068 : || dir->id == PRAGMA_OMP_END
49842 : 1068 : || (!dir->second && directive[1])
49843 : 1041 : || (!dir->third && directive[2]))
49844 : 81 : error_at (dloc, "unknown OpenMP directive name in "
49845 : : "%qs clause argument", p);
49846 : : else
49847 : : {
49848 : 1041 : int id = dir - c_omp_directives;
49849 : 1176 : if (bitmap_bit_p (p[0] == 'a' ? &contains_head
49850 : : : &absent_head, id))
49851 : 54 : error_at (dloc, "%<%s%s%s%s%s%> directive "
49852 : : "mentioned in both %<absent%> and "
49853 : : "%<contains%> clauses",
49854 : : directive[0],
49855 : : directive[1] ? " " : "",
49856 : : directive[1] ? directive[1] : "",
49857 : : directive[2] ? " " : "",
49858 : : directive[2] ? directive[2] : "");
49859 : 1149 : else if (!bitmap_set_bit (p[0] == 'a'
49860 : : ? &absent_head
49861 : : : &contains_head, id))
49862 : 108 : error_at (dloc, "%<%s%s%s%s%s%> directive "
49863 : : "mentioned multiple times in %qs "
49864 : : "clauses",
49865 : : directive[0],
49866 : : directive[1] ? " " : "",
49867 : : directive[1] ? directive[1] : "",
49868 : : directive[2] ? " " : "",
49869 : : directive[2] ? directive[2] : "", p);
49870 : : }
49871 : 2523 : for (; i; --i)
49872 : 1401 : cp_lexer_consume_token (parser->lexer);
49873 : : }
49874 : 1122 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
49875 : 687 : cp_lexer_consume_token (parser->lexer);
49876 : : else
49877 : : break;
49878 : 687 : }
49879 : : while (1);
49880 : 435 : if (!parens.require_close (parser))
49881 : 0 : cp_parser_skip_to_closing_parenthesis (parser,
49882 : : /*recovering=*/true,
49883 : : /*or_comma=*/false,
49884 : : /*consume_paren=*/true);
49885 : : }
49886 : 435 : }
49887 : 27 : else if (startswith (p, "ext_"))
49888 : : {
49889 : 18 : warning_at (cloc, OPT_Wopenmp, "unknown assumption clause %qs", p);
49890 : 18 : cp_lexer_consume_token (parser->lexer);
49891 : 18 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
49892 : 90 : for (size_t n = cp_parser_skip_balanced_tokens (parser, 1) - 1;
49893 : 90 : n; --n)
49894 : 81 : cp_lexer_consume_token (parser->lexer);
49895 : : }
49896 : : else
49897 : : {
49898 : 9 : cp_lexer_consume_token (parser->lexer);
49899 : 9 : error_at (cloc, "expected assumption clause");
49900 : 9 : break;
49901 : : }
49902 : : }
49903 : 372 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
49904 : 372 : }
49905 : :
49906 : : /* OpenMP 5.1
49907 : : # pragma omp assume clauses[optseq] new-line */
49908 : :
49909 : : static void
49910 : 126 : cp_parser_omp_assume (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
49911 : : {
49912 : 126 : cp_parser_omp_assumption_clauses (parser, pragma_tok, true);
49913 : 126 : add_stmt (cp_parser_omp_structured_block (parser, if_p));
49914 : 126 : }
49915 : :
49916 : : /* OpenMP 5.1
49917 : : # pragma omp assumes clauses[optseq] new-line */
49918 : :
49919 : : static bool
49920 : 111 : cp_parser_omp_assumes (cp_parser *parser, cp_token *pragma_tok)
49921 : : {
49922 : 0 : cp_parser_omp_assumption_clauses (parser, pragma_tok, false);
49923 : 111 : return false;
49924 : : }
49925 : :
49926 : : /* Parse a function dispatch structured block:
49927 : :
49928 : : lvalue-expression = target-call ( [expression-list] );
49929 : : or
49930 : : target-call ( [expression-list] );
49931 : :
49932 : : Inspired from cp_parser_assignment_expression and
49933 : : cp_parser_postfix_expression.
49934 : : */
49935 : :
49936 : : static tree
49937 : 446 : cp_parser_omp_dispatch_body (cp_parser *parser)
49938 : : {
49939 : : /* Parse the binary expressions (lvalue-expression or target-call). */
49940 : 446 : cp_expr expr = cp_parser_binary_expression (parser, false, false, false,
49941 : : PREC_NOT_OPERATOR, NULL);
49942 : 446 : if (TREE_CODE (STRIP_REFERENCE_REF (expr.get_value ())) == CALL_EXPR
49943 : 446 : || TREE_CODE (expr) == ERROR_MARK)
49944 : : return expr;
49945 : :
49946 : : /* We have the lvalue, now deal with the assignment. */
49947 : :
49948 : 137 : if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
49949 : 3 : return error_mark_node;
49950 : :
49951 : : /* Peek at the next token. */
49952 : 134 : cp_token *token = cp_lexer_peek_token (parser->lexer);
49953 : 134 : location_t loc = token->location;
49954 : :
49955 : : /* Parse function call. */
49956 : 134 : cp_expr rhs = cp_parser_postfix_expression (parser, false, false, false,
49957 : : false, nullptr);
49958 : 134 : if (rhs == error_mark_node)
49959 : : return rhs;
49960 : :
49961 : 256 : if (TREE_CODE (STRIP_REFERENCE_REF (rhs.get_value ())) != CALL_EXPR)
49962 : : {
49963 : 3 : error_at (EXPR_LOC_OR_LOC (rhs, rhs.get_location ()),
49964 : : "expected target-function call");
49965 : 3 : return error_mark_node;
49966 : : }
49967 : :
49968 : : /* Build the assignment expression. Its default
49969 : : location:
49970 : : LHS = RHS
49971 : : ~~~~^~~~~
49972 : : is the location of the '=' token as the
49973 : : caret, ranging from the start of the lhs to the
49974 : : end of the rhs. */
49975 : 128 : loc = make_location (loc, expr.get_start (), rhs.get_finish ());
49976 : 128 : expr = build_x_modify_expr (loc, expr, NOP_EXPR, rhs, NULL_TREE,
49977 : : complain_flags (false));
49978 : : /* TODO: build_x_modify_expr doesn't honor the location,
49979 : : so we must set it here. */
49980 : 128 : expr.set_location (loc);
49981 : :
49982 : 128 : return expr;
49983 : : }
49984 : :
49985 : : /* OpenMP 5.1:
49986 : : # pragma omp dispatch dispatch-clause[optseq] new-line
49987 : : expression-stmt
49988 : :
49989 : : LOC is the location of the #pragma.
49990 : : */
49991 : :
49992 : : #define OMP_DISPATCH_CLAUSE_MASK \
49993 : : ((OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
49994 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
49995 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOVARIANTS) \
49996 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOCONTEXT) \
49997 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR) \
49998 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INTEROP) \
49999 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR) \
50000 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
50001 : :
50002 : : static tree
50003 : 446 : cp_parser_omp_dispatch (cp_parser *parser, cp_token *pragma_tok)
50004 : : {
50005 : 446 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
50006 : 446 : tree stmt = make_node (OMP_DISPATCH);
50007 : 446 : SET_EXPR_LOCATION (stmt, loc);
50008 : 446 : TREE_TYPE (stmt) = void_type_node;
50009 : :
50010 : 892 : OMP_DISPATCH_CLAUSES (stmt)
50011 : 446 : = cp_parser_omp_all_clauses (parser, OMP_DISPATCH_CLAUSE_MASK,
50012 : : "#pragma omp dispatch", pragma_tok);
50013 : :
50014 : : // Extract depend clauses and create taskwait
50015 : 446 : tree depend_clauses = NULL_TREE;
50016 : 446 : tree *depend_clauses_ptr = &depend_clauses;
50017 : 842 : for (tree c = OMP_DISPATCH_CLAUSES (stmt); c; c = OMP_CLAUSE_CHAIN (c))
50018 : : {
50019 : 396 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND)
50020 : : {
50021 : 15 : *depend_clauses_ptr = c;
50022 : 15 : depend_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
50023 : : }
50024 : : }
50025 : 446 : if (depend_clauses != NULL_TREE)
50026 : : {
50027 : 15 : tree stmt = make_node (OMP_TASK);
50028 : 15 : TREE_TYPE (stmt) = void_node;
50029 : 15 : OMP_TASK_CLAUSES (stmt) = depend_clauses;
50030 : 15 : OMP_TASK_BODY (stmt) = NULL_TREE;
50031 : 15 : SET_EXPR_LOCATION (stmt, loc);
50032 : 15 : add_stmt (stmt);
50033 : : }
50034 : :
50035 : : // Parse expression statement
50036 : 446 : loc = cp_lexer_peek_token (parser->lexer)->location;
50037 : 446 : tree dispatch_body = cp_parser_omp_dispatch_body (parser);
50038 : 446 : if (dispatch_body == error_mark_node)
50039 : : {
50040 : 18 : inform (loc,
50041 : : "%<#pragma omp dispatch%> must be followed by a direct function "
50042 : : "call with optional assignment");
50043 : 18 : cp_parser_skip_to_end_of_block_or_statement (parser);
50044 : 18 : return NULL_TREE;
50045 : : }
50046 : :
50047 : : // Walk the tree to find the dispatch function call and wrap it into an IFN
50048 : 428 : tree *dispatch_call;
50049 : 853 : switch (TREE_CODE (STRIP_REFERENCE_REF (dispatch_body)))
50050 : : {
50051 : 116 : case MODIFY_EXPR:
50052 : 116 : dispatch_call = &TREE_OPERAND (dispatch_body, 1);
50053 : 116 : break;
50054 : 12 : case MODOP_EXPR:
50055 : 12 : dispatch_call = &TREE_OPERAND (dispatch_body, 2);
50056 : 12 : break;
50057 : : case CALL_EXPR:
50058 : : dispatch_call = &dispatch_body;
50059 : : break;
50060 : 0 : default:
50061 : 0 : gcc_unreachable ();
50062 : : }
50063 : 428 : if (TREE_CODE (*dispatch_call) == FLOAT_EXPR
50064 : 422 : || TREE_CODE (*dispatch_call) == CONVERT_EXPR)
50065 : 12 : dispatch_call = &TREE_OPERAND (*dispatch_call, 0);
50066 : 428 : *dispatch_call = build_call_expr_internal_loc (loc, IFN_GOMP_DISPATCH,
50067 : 428 : TREE_TYPE (*dispatch_call), 1,
50068 : : *dispatch_call);
50069 : :
50070 : 428 : cp_parser_consume_semicolon_at_end_of_statement (parser);
50071 : 428 : OMP_DISPATCH_BODY (stmt) = dispatch_body;
50072 : :
50073 : 428 : return add_stmt (stmt);
50074 : : }
50075 : :
50076 : : /* Finalize #pragma omp declare variant after a fndecl has been parsed, and put
50077 : : that into "omp declare variant base" attribute. */
50078 : :
50079 : : static tree
50080 : 1334 : cp_finish_omp_declare_variant (cp_parser *parser, cp_token *pragma_tok,
50081 : : tree attrs, tree parms)
50082 : : {
50083 : 1334 : matching_parens parens;
50084 : 1334 : if (!parens.require_open (parser))
50085 : : {
50086 : 9 : fail:
50087 : 142 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
50088 : 142 : return attrs;
50089 : : }
50090 : :
50091 : 1325 : bool template_p;
50092 : 1325 : cp_id_kind idk = CP_ID_KIND_NONE;
50093 : 1325 : cp_token *varid_token = cp_lexer_peek_token (parser->lexer);
50094 : 1325 : cp_expr varid
50095 : 1325 : = cp_parser_id_expression (parser, /*template_keyword_p=*/false,
50096 : : /*check_dependency_p=*/true,
50097 : : /*template_p=*/&template_p,
50098 : : /*declarator_p=*/false,
50099 : : /*optional_p=*/false);
50100 : 1325 : parens.require_close (parser);
50101 : :
50102 : 1325 : tree variant;
50103 : 1325 : if (TREE_CODE (varid) == TEMPLATE_ID_EXPR
50104 : 1301 : || TREE_CODE (varid) == TYPE_DECL
50105 : 2626 : || varid == error_mark_node)
50106 : : variant = varid;
50107 : 1289 : else if (varid_token->type == CPP_NAME && varid_token->error_reported)
50108 : : variant = NULL_TREE;
50109 : : else
50110 : : {
50111 : 1289 : tree ambiguous_decls;
50112 : 1289 : variant = cp_parser_lookup_name (parser, varid, none_type,
50113 : : template_p, /*is_namespace=*/false,
50114 : : /*check_dependency=*/true,
50115 : : &ambiguous_decls,
50116 : : varid.get_location ());
50117 : 1289 : if (ambiguous_decls)
50118 : 0 : variant = NULL_TREE;
50119 : : }
50120 : 1325 : if (variant == NULL_TREE)
50121 : 0 : variant = error_mark_node;
50122 : 1325 : else if (TREE_CODE (variant) != SCOPE_REF)
50123 : : {
50124 : 1325 : const char *error_msg;
50125 : 1325 : variant
50126 : 1325 : = finish_id_expression (varid, variant, parser->scope,
50127 : : &idk, false, true,
50128 : : &parser->non_integral_constant_expression_p,
50129 : : template_p, true, false, false, &error_msg,
50130 : : varid.get_location ());
50131 : 1325 : if (error_msg)
50132 : 0 : cp_parser_error (parser, error_msg);
50133 : : }
50134 : 1325 : location_t caret_loc = get_pure_location (varid.get_location ());
50135 : 1325 : location_t start_loc = get_start (varid_token->location);
50136 : 1325 : location_t finish_loc = get_finish (varid.get_location ());
50137 : 1325 : location_t varid_loc = make_location (caret_loc, start_loc, finish_loc);
50138 : :
50139 : 1325 : tree append_args_tree = NULL_TREE;
50140 : 1325 : tree append_args_last;
50141 : 1325 : vec<tree> adjust_args_list = vNULL;
50142 : 1325 : bool has_match = false, has_adjust_args = false;
50143 : 1325 : location_t adjust_args_loc = UNKNOWN_LOCATION;
50144 : 1325 : location_t append_args_loc = UNKNOWN_LOCATION;
50145 : 1325 : tree need_device_ptr_list = NULL_TREE;
50146 : 1325 : tree ctx = NULL_TREE;
50147 : :
50148 : 1543 : do
50149 : : {
50150 : 1543 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
50151 : 1543 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
50152 : 18 : cp_lexer_consume_token (parser->lexer);
50153 : :
50154 : 1543 : const char *clause = "";
50155 : 1543 : location_t match_loc = cp_lexer_peek_token (parser->lexer)->location;
50156 : 1543 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
50157 : 1528 : clause
50158 : 1528 : = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
50159 : :
50160 : 1543 : enum clause
50161 : : {
50162 : : match,
50163 : : adjust_args,
50164 : : append_args
50165 : : } ccode;
50166 : :
50167 : 1543 : if (strcmp (clause, "match") == 0)
50168 : : ccode = match;
50169 : 239 : else if (strcmp (clause, "adjust_args") == 0)
50170 : : {
50171 : : ccode = adjust_args;
50172 : : adjust_args_loc = match_loc;
50173 : : }
50174 : 93 : else if (strcmp (clause, "append_args") == 0)
50175 : : {
50176 : : ccode = append_args;
50177 : : append_args_loc = match_loc;
50178 : : }
50179 : : else
50180 : : {
50181 : 18 : cp_parser_error (parser, "expected %<match%>, %<adjust_args%> or "
50182 : : "%<append_args%> clause");
50183 : 18 : goto fail;
50184 : : }
50185 : :
50186 : 1525 : cp_lexer_consume_token (parser->lexer);
50187 : :
50188 : 1525 : if (!parens.require_open (parser))
50189 : 3 : goto fail;
50190 : :
50191 : 1522 : if (ccode == match)
50192 : : {
50193 : 1301 : if (has_match)
50194 : 3 : error_at (match_loc, "too many %<match%> clauses");
50195 : 1301 : has_match = true;
50196 : 1301 : ctx = cp_parser_omp_context_selector_specification (parser, true);
50197 : 1301 : if (ctx == error_mark_node)
50198 : 103 : goto fail;
50199 : 1198 : ctx = omp_check_context_selector (match_loc, ctx);
50200 : 1198 : if (ctx != error_mark_node && variant != error_mark_node)
50201 : : {
50202 : 1138 : tree match_loc_node
50203 : 1138 : = maybe_wrap_with_location (integer_zero_node, match_loc);
50204 : 1138 : tree loc_node
50205 : 1138 : = maybe_wrap_with_location (integer_zero_node, varid_loc);
50206 : 1138 : loc_node
50207 : 1138 : = tree_cons (match_loc_node,
50208 : 1138 : build_int_cst (integer_type_node, idk),
50209 : : build_tree_list (loc_node, integer_zero_node));
50210 : 1138 : attrs = tree_cons (get_identifier ("omp declare variant base"),
50211 : : tree_cons (variant, ctx, loc_node), attrs);
50212 : 1138 : if (processing_template_decl)
50213 : 99 : ATTR_IS_DEPENDENT (attrs) = 1;
50214 : : }
50215 : 1198 : if (!parens.require_close (parser))
50216 : 0 : goto fail;
50217 : : }
50218 : 221 : else if (ccode == adjust_args)
50219 : : {
50220 : 146 : has_adjust_args = true;
50221 : 146 : cp_token *adjust_op_tok = cp_lexer_peek_token (parser->lexer);
50222 : 146 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
50223 : 146 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
50224 : : {
50225 : 140 : const char *p = IDENTIFIER_POINTER (adjust_op_tok->u.value);
50226 : 140 : if (strcmp (p, "need_device_ptr") == 0
50227 : 45 : || strcmp (p, "nothing") == 0)
50228 : : {
50229 : 137 : cp_lexer_consume_token (parser->lexer); // need_device_ptr
50230 : 137 : cp_lexer_consume_token (parser->lexer); // :
50231 : 137 : location_t arg_loc
50232 : 137 : = cp_lexer_peek_token (parser->lexer)->location;
50233 : :
50234 : 137 : tree arg;
50235 : 137 : tree list
50236 : 137 : = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_ERROR,
50237 : : NULL_TREE, NULL);
50238 : :
50239 : 294 : for (tree c = list; c != NULL_TREE; c = TREE_CHAIN (c))
50240 : : {
50241 : 157 : tree decl = TREE_PURPOSE (c);
50242 : 157 : int idx;
50243 : 246 : for (arg = parms, idx = 0; arg != NULL;
50244 : 89 : arg = TREE_CHAIN (arg), idx++)
50245 : 243 : if (TREE_VALUE (arg) == decl)
50246 : : break;
50247 : 157 : if (arg == NULL_TREE)
50248 : : {
50249 : 3 : error_at (arg_loc, "%qD is not a function argument",
50250 : : decl);
50251 : 160 : continue;
50252 : : }
50253 : 154 : arg = TREE_VALUE (arg);
50254 : 154 : if (adjust_args_list.contains (arg))
50255 : : {
50256 : : // TODO fix location
50257 : 6 : error_at (arg_loc, "%qD is specified more than once",
50258 : : decl);
50259 : 6 : continue;
50260 : : }
50261 : 148 : if (strcmp (p, "need_device_ptr") == 0)
50262 : : {
50263 : 115 : bool is_ptr_or_template
50264 : 215 : = TEMPLATE_PARM_P (TREE_TYPE (arg))
50265 : 215 : || POINTER_TYPE_P (TREE_TYPE (arg));
50266 : 6 : if (!is_ptr_or_template)
50267 : : {
50268 : 3 : error_at (arg_loc, "%qD is not a C pointer",
50269 : : decl);
50270 : 3 : continue;
50271 : : }
50272 : : }
50273 : 145 : adjust_args_list.safe_push (arg);
50274 : 145 : if (strcmp (p, "need_device_ptr") == 0)
50275 : : {
50276 : 112 : need_device_ptr_list = chainon (
50277 : : need_device_ptr_list,
50278 : : build_tree_list (
50279 : : NULL_TREE,
50280 : 112 : build_int_cst (
50281 : : integer_type_node,
50282 : : idx))); // Store 0-based argument index,
50283 : : // as in gimplify_call_expr
50284 : : }
50285 : : }
50286 : : }
50287 : : else
50288 : : {
50289 : 3 : error_at (adjust_op_tok->location,
50290 : : "expected %<nothing%> or %<need_device_ptr%>");
50291 : 3 : goto fail;
50292 : : }
50293 : : }
50294 : : else
50295 : : {
50296 : 6 : error_at (adjust_op_tok->location,
50297 : : "expected %<nothing%> or %<need_device_ptr%> followed "
50298 : : "by %<:%>");
50299 : 6 : goto fail;
50300 : : }
50301 : : }
50302 : 75 : else if (ccode == append_args)
50303 : : {
50304 : 75 : if (append_args_tree)
50305 : 3 : error_at (append_args_loc, "too many %qs clauses", "append_args");
50306 : 165 : do
50307 : : {
50308 : 120 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
50309 : 120 : if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME)
50310 : 120 : || strcmp ("interop",
50311 : 120 : IDENTIFIER_POINTER (
50312 : : cp_lexer_peek_token (parser->lexer)->u.value)))
50313 : : {
50314 : 0 : error_at (loc, "expected %<interop%>");
50315 : 0 : goto fail;
50316 : : }
50317 : 120 : cp_lexer_consume_token (parser->lexer); // :
50318 : :
50319 : 120 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
50320 : 0 : goto fail;
50321 : 120 : bool target = false;
50322 : 120 : bool targetsync = false;
50323 : 120 : tree prefer_type_tree = NULL_TREE;
50324 : 120 : if (!cp_parser_omp_clause_init_modifiers (parser, &target,
50325 : : &targetsync,
50326 : : &prefer_type_tree))
50327 : 0 : goto fail;
50328 : 120 : tree t = build_omp_clause (loc, OMP_CLAUSE_INIT);
50329 : 120 : if (append_args_tree)
50330 : 48 : OMP_CLAUSE_CHAIN (append_args_last) = t;
50331 : : else
50332 : : append_args_tree = append_args_last = t;
50333 : 120 : if (target)
50334 : 63 : OMP_CLAUSE_INIT_TARGET (t) = 1;
50335 : 120 : if (targetsync)
50336 : 60 : OMP_CLAUSE_INIT_TARGETSYNC (t) = 1;
50337 : 120 : if (prefer_type_tree)
50338 : 57 : OMP_CLAUSE_INIT_PREFER_TYPE (t) = prefer_type_tree;
50339 : 120 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
50340 : : {
50341 : 0 : cp_parser_error (parser, "expected %<)%> or %<,%>");
50342 : 0 : goto fail;
50343 : : }
50344 : 120 : cp_lexer_consume_token (parser->lexer); // ')'
50345 : 120 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
50346 : : {
50347 : 75 : cp_lexer_consume_token (parser->lexer); // ','
50348 : 75 : break;
50349 : : }
50350 : 45 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
50351 : : {
50352 : 0 : cp_parser_error (parser, "expected %<)%> or %<,%>");
50353 : 0 : goto fail;
50354 : : }
50355 : 45 : cp_lexer_consume_token (parser->lexer); // ','
50356 : 45 : }
50357 : : while (true);
50358 : : }
50359 : 1410 : } while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL));
50360 : :
50361 : 1192 : if ((ctx != error_mark_node && variant != error_mark_node)
50362 : 1132 : && (has_adjust_args || append_args_tree))
50363 : : {
50364 : 167 : if (!has_match)
50365 : : {
50366 : 6 : error_at (has_adjust_args ? adjust_args_loc : append_args_loc,
50367 : : "an %qs clause requires a %<match%> clause",
50368 : : has_adjust_args ? "adjust_args" : "append_args");
50369 : : }
50370 : : else
50371 : : {
50372 : 161 : gcc_assert (TREE_PURPOSE (attrs)
50373 : : == get_identifier ("omp declare variant base"));
50374 : 161 : gcc_assert (TREE_PURPOSE (TREE_VALUE (attrs)) == variant);
50375 : 161 : ctx = TREE_VALUE (TREE_VALUE (attrs));
50376 : 161 : if (!omp_get_context_selector (ctx, OMP_TRAIT_SET_CONSTRUCT,
50377 : : OMP_TRAIT_CONSTRUCT_DISPATCH))
50378 : 3 : error_at (has_adjust_args ? adjust_args_loc : append_args_loc,
50379 : : "an %qs clause can only be specified if the %<dispatch%> "
50380 : : "selector of the construct selector set appears "
50381 : : "in the %<match%> clause",
50382 : : has_adjust_args ? "adjust_args" : "append_args");
50383 : : // We might not have a DECL for the variant yet. So we store the
50384 : : // need_device_ptr list in the base function attribute, after loc
50385 : : // nodes.
50386 : 161 : tree t = build_tree_list (need_device_ptr_list,
50387 : : NULL_TREE /* need_device_addr */);
50388 : 161 : TREE_CHAIN (t) = append_args_tree;
50389 : 161 : TREE_VALUE (attrs) = chainon (TREE_VALUE (attrs),
50390 : : build_tree_list ( NULL_TREE, t));
50391 : : }
50392 : : }
50393 : :
50394 : 1192 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
50395 : 1192 : return attrs;
50396 : : }
50397 : :
50398 : :
50399 : : /* Finalize #pragma omp declare simd clauses after direct declarator has
50400 : : been parsed, and put that into "omp declare simd" attribute. */
50401 : :
50402 : : static tree
50403 : 2111 : cp_parser_late_parsing_omp_declare_simd (cp_parser *parser, tree attrs,
50404 : : tree parms)
50405 : : {
50406 : 2111 : struct cp_token_cache *ce;
50407 : 2111 : cp_omp_declare_simd_data *data = parser->omp_declare_simd;
50408 : 2111 : int i;
50409 : :
50410 : 2111 : if (!data->error_seen && data->fndecl_seen)
50411 : : {
50412 : 6 : error ("%<#pragma omp declare %s%> not immediately followed by "
50413 : : "a single function declaration or definition",
50414 : 6 : data->variant_p ? "variant" : "simd");
50415 : 6 : data->error_seen = true;
50416 : : }
50417 : 2111 : if (data->error_seen)
50418 : : return attrs;
50419 : :
50420 : 4215 : FOR_EACH_VEC_ELT (data->tokens, i, ce)
50421 : : {
50422 : 2110 : tree c, cl;
50423 : :
50424 : 2110 : cp_parser_push_lexer_for_tokens (parser, ce);
50425 : 2110 : parser->lexer->in_pragma = true;
50426 : 2110 : gcc_assert (cp_lexer_peek_token (parser->lexer)->type == CPP_PRAGMA);
50427 : 2110 : cp_token *pragma_tok = cp_lexer_consume_token (parser->lexer);
50428 : 2110 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
50429 : 2110 : const char *kind = IDENTIFIER_POINTER (id);
50430 : 2110 : cp_lexer_consume_token (parser->lexer);
50431 : 2110 : if (strcmp (kind, "simd") == 0)
50432 : : {
50433 : 806 : cl = cp_parser_omp_all_clauses (parser, OMP_DECLARE_SIMD_CLAUSE_MASK,
50434 : : "#pragma omp declare simd",
50435 : : pragma_tok);
50436 : 806 : if (cl)
50437 : 680 : cl = tree_cons (NULL_TREE, cl, NULL_TREE);
50438 : 806 : c = build_tree_list (get_identifier ("omp declare simd"), cl);
50439 : 806 : TREE_CHAIN (c) = attrs;
50440 : 806 : if (processing_template_decl)
50441 : 132 : ATTR_IS_DEPENDENT (c) = 1;
50442 : : attrs = c;
50443 : : }
50444 : : else
50445 : : {
50446 : 1304 : gcc_assert (strcmp (kind, "variant") == 0);
50447 : 1304 : attrs
50448 : 1304 : = cp_finish_omp_declare_variant (parser, pragma_tok, attrs, parms);
50449 : : }
50450 : 2110 : cp_parser_pop_lexer (parser);
50451 : : }
50452 : :
50453 : : cp_lexer *lexer = NULL;
50454 : 6315 : for (int i = 0; i < 2; i++)
50455 : : {
50456 : 4210 : if (data->attribs[i] == NULL)
50457 : 3988 : continue;
50458 : 546 : for (tree *pa = data->attribs[i]; *pa; )
50459 : 324 : if (get_attribute_namespace (*pa) == omp_identifier
50460 : 324 : && is_attribute_p ("directive", get_attribute_name (*pa)))
50461 : : {
50462 : 648 : for (tree a = TREE_VALUE (*pa); a; a = TREE_CHAIN (a))
50463 : : {
50464 : 330 : tree d = TREE_VALUE (a);
50465 : 330 : gcc_assert (TREE_CODE (d) == DEFERRED_PARSE);
50466 : 330 : cp_token *first = DEFPARSE_TOKENS (d)->first;
50467 : 330 : cp_token *last = DEFPARSE_TOKENS (d)->last;
50468 : 330 : const char *directive[3] = {};
50469 : 1020 : for (int j = 0; j < 3; j++)
50470 : : {
50471 : 942 : tree id = NULL_TREE;
50472 : 942 : if (first + j == last)
50473 : : break;
50474 : 840 : if (first[j].type == CPP_NAME)
50475 : 690 : id = first[j].u.value;
50476 : 150 : else if (first[j].type == CPP_KEYWORD)
50477 : 0 : id = ridpointers[(int) first[j].keyword];
50478 : : else
50479 : : break;
50480 : 690 : directive[j] = IDENTIFIER_POINTER (id);
50481 : : }
50482 : 330 : const c_omp_directive *dir = NULL;
50483 : 330 : if (directive[0])
50484 : 330 : dir = c_omp_categorize_directive (directive[0], directive[1],
50485 : : directive[2]);
50486 : 330 : if (dir == NULL)
50487 : : {
50488 : 24 : error_at (first->location,
50489 : : "unknown OpenMP directive name in "
50490 : : "%qs attribute argument",
50491 : 24 : TREE_PUBLIC (d)
50492 : : ? "omp::decl" : "omp::directive");
50493 : 48 : continue;
50494 : : }
50495 : 306 : if (dir->id != PRAGMA_OMP_DECLARE
50496 : 282 : || (strcmp (directive[1], "simd") != 0
50497 : 30 : && strcmp (directive[1], "variant") != 0))
50498 : : {
50499 : 24 : error_at (first->location,
50500 : : "OpenMP directive other than %<declare simd%> "
50501 : : "or %<declare variant%> appertains to a "
50502 : : "declaration");
50503 : 24 : continue;
50504 : : }
50505 : :
50506 : 282 : if (parser->omp_attrs_forbidden_p)
50507 : : {
50508 : 6 : error_at (first->location,
50509 : : "mixing OpenMP directives with attribute and "
50510 : : "pragma syntax on the same statement");
50511 : 6 : parser->omp_attrs_forbidden_p = false;
50512 : : }
50513 : :
50514 : 282 : if (!flag_openmp && strcmp (directive[1], "simd") != 0)
50515 : 0 : continue;
50516 : 282 : if (lexer == NULL)
50517 : : {
50518 : 204 : lexer = cp_lexer_alloc ();
50519 : 204 : lexer->debugging_p = parser->lexer->debugging_p;
50520 : : }
50521 : 282 : vec_safe_reserve (lexer->buffer, (last - first) + 2);
50522 : 282 : cp_token tok = {};
50523 : 282 : tok.type = CPP_PRAGMA;
50524 : 282 : tok.keyword = RID_MAX;
50525 : 282 : tok.u.value = build_int_cst (NULL, PRAGMA_OMP_DECLARE);
50526 : 282 : tok.location = first->location;
50527 : 282 : lexer->buffer->quick_push (tok);
50528 : 3015 : while (++first < last)
50529 : 2451 : lexer->buffer->quick_push (*first);
50530 : 282 : tok = {};
50531 : 282 : tok.type = CPP_PRAGMA_EOL;
50532 : 282 : tok.keyword = RID_MAX;
50533 : 282 : tok.location = last->location;
50534 : 282 : lexer->buffer->quick_push (tok);
50535 : 282 : tok = {};
50536 : 282 : tok.type = CPP_EOF;
50537 : 282 : tok.keyword = RID_MAX;
50538 : 282 : tok.location = last->location;
50539 : 282 : lexer->buffer->quick_push (tok);
50540 : 282 : lexer->next = parser->lexer;
50541 : 282 : lexer->next_token = lexer->buffer->address ();
50542 : 282 : lexer->last_token = lexer->next_token
50543 : 282 : + lexer->buffer->length ()
50544 : 282 : - 1;
50545 : 282 : lexer->in_omp_attribute_pragma = true;
50546 : 282 : parser->lexer = lexer;
50547 : : /* Move the current source position to that of the first token
50548 : : in the new lexer. */
50549 : 282 : cp_lexer_set_source_position_from_token (lexer->next_token);
50550 : :
50551 : 282 : cp_token *pragma_tok = cp_lexer_consume_token (parser->lexer);
50552 : 282 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
50553 : 282 : const char *kind = IDENTIFIER_POINTER (id);
50554 : 282 : cp_lexer_consume_token (parser->lexer);
50555 : :
50556 : 282 : tree c, cl;
50557 : 282 : if (strcmp (kind, "simd") == 0)
50558 : : {
50559 : 252 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
50560 : 252 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
50561 : 96 : cp_lexer_consume_token (parser->lexer);
50562 : :
50563 : 252 : omp_clause_mask mask = OMP_DECLARE_SIMD_CLAUSE_MASK;
50564 : 252 : cl = cp_parser_omp_all_clauses (parser, mask,
50565 : : "#pragma omp declare simd",
50566 : : pragma_tok);
50567 : 252 : if (cl)
50568 : 174 : cl = tree_cons (NULL_TREE, cl, NULL_TREE);
50569 : 252 : c = build_tree_list (get_identifier ("omp declare simd"),
50570 : : cl);
50571 : 252 : TREE_CHAIN (c) = attrs;
50572 : 252 : if (processing_template_decl)
50573 : 0 : ATTR_IS_DEPENDENT (c) = 1;
50574 : 252 : attrs = c;
50575 : : }
50576 : : else
50577 : : {
50578 : 30 : gcc_assert (strcmp (kind, "variant") == 0);
50579 : 30 : attrs = cp_finish_omp_declare_variant (parser, pragma_tok,
50580 : : attrs, parms);
50581 : : }
50582 : 282 : gcc_assert (parser->lexer != lexer);
50583 : 564 : vec_safe_truncate (lexer->buffer, 0);
50584 : : }
50585 : 318 : *pa = TREE_CHAIN (*pa);
50586 : : }
50587 : : else
50588 : 6 : pa = &TREE_CHAIN (*pa);
50589 : : }
50590 : 2105 : if (lexer)
50591 : 204 : cp_lexer_destroy (lexer);
50592 : :
50593 : 2105 : data->fndecl_seen = true;
50594 : 2105 : return attrs;
50595 : : }
50596 : :
50597 : : /* D should be DEFERRED_PARSE from omp::decl attribute. If it contains
50598 : : a threadprivate, groupprivate, allocate or declare target directive,
50599 : : return true and parse it for DECL. */
50600 : :
50601 : : bool
50602 : 128 : cp_maybe_parse_omp_decl (tree decl, tree d)
50603 : : {
50604 : 128 : gcc_assert (TREE_CODE (d) == DEFERRED_PARSE);
50605 : 128 : cp_token *first = DEFPARSE_TOKENS (d)->first;
50606 : 128 : cp_token *last = DEFPARSE_TOKENS (d)->last;
50607 : 128 : const char *directive[3] = {};
50608 : 364 : for (int j = 0; j < 3; j++)
50609 : : {
50610 : 326 : tree id = NULL_TREE;
50611 : 326 : if (first + j == last)
50612 : : break;
50613 : 256 : if (first[j].type == CPP_NAME)
50614 : 236 : id = first[j].u.value;
50615 : 20 : else if (first[j].type == CPP_KEYWORD)
50616 : 0 : id = ridpointers[(int) first[j].keyword];
50617 : : else
50618 : : break;
50619 : 236 : directive[j] = IDENTIFIER_POINTER (id);
50620 : : }
50621 : 128 : const c_omp_directive *dir = NULL;
50622 : 128 : if (directive[0])
50623 : 128 : dir = c_omp_categorize_directive (directive[0], directive[1],
50624 : : directive[2]);
50625 : 128 : if (dir == NULL)
50626 : : {
50627 : 3 : error_at (first->location,
50628 : : "unknown OpenMP directive name in "
50629 : : "%qs attribute argument", "omp::decl");
50630 : 3 : return false;
50631 : : }
50632 : 125 : if (dir->id != PRAGMA_OMP_THREADPRIVATE
50633 : : /* && dir->id != PRAGMA_OMP_GROUPPRIVATE */
50634 : 70 : && dir->id != PRAGMA_OMP_ALLOCATE
50635 : 67 : && (dir->id != PRAGMA_OMP_DECLARE
50636 : 67 : || strcmp (directive[1], "target") != 0))
50637 : : return false;
50638 : :
50639 : 125 : if (!flag_openmp && !dir->simd)
50640 : : return true;
50641 : :
50642 : 125 : cp_parser *parser = the_parser;
50643 : 125 : cp_lexer *lexer = cp_lexer_alloc ();
50644 : 125 : lexer->debugging_p = parser->lexer->debugging_p;
50645 : 125 : lexer->in_omp_decl_attribute = decl;
50646 : 125 : vec_safe_reserve (lexer->buffer, last - first + 3, true);
50647 : 125 : cp_token tok = {};
50648 : 125 : tok.type = CPP_PRAGMA;
50649 : 125 : tok.keyword = RID_MAX;
50650 : 125 : tok.u.value = build_int_cst (NULL, dir->id);
50651 : 125 : tok.location = first->location;
50652 : 125 : lexer->buffer->quick_push (tok);
50653 : 521 : while (++first < last)
50654 : 271 : lexer->buffer->quick_push (*first);
50655 : 125 : tok = {};
50656 : 125 : tok.type = CPP_PRAGMA_EOL;
50657 : 125 : tok.keyword = RID_MAX;
50658 : 125 : tok.location = last->location;
50659 : 125 : lexer->buffer->quick_push (tok);
50660 : 125 : tok = {};
50661 : 125 : tok.type = CPP_EOF;
50662 : 125 : tok.keyword = RID_MAX;
50663 : 125 : tok.location = last->location;
50664 : 125 : lexer->buffer->quick_push (tok);
50665 : 125 : lexer->next = parser->lexer;
50666 : 125 : lexer->next_token = lexer->buffer->address ();
50667 : 125 : lexer->last_token = lexer->next_token
50668 : 125 : + lexer->buffer->length ()
50669 : 125 : - 1;
50670 : 125 : lexer->in_omp_attribute_pragma = true;
50671 : 125 : parser->lexer = lexer;
50672 : : /* Move the current source position to that of the first token in the
50673 : : new lexer. */
50674 : 125 : cp_lexer_set_source_position_from_token (lexer->next_token);
50675 : 125 : cp_parser_pragma (parser, pragma_external, NULL);
50676 : :
50677 : 125 : return true;
50678 : : }
50679 : :
50680 : : /* Helper for cp_parser_omp_declare_target, handle one to or link clause
50681 : : on #pragma omp declare target. Return false if errors were reported. */
50682 : :
50683 : : static bool
50684 : 514 : handle_omp_declare_target_clause (tree c, tree t, int device_type,
50685 : : bool indirect)
50686 : : {
50687 : 514 : tree at1 = lookup_attribute ("omp declare target", DECL_ATTRIBUTES (t));
50688 : 514 : tree at2 = lookup_attribute ("omp declare target link", DECL_ATTRIBUTES (t));
50689 : 514 : tree id;
50690 : 514 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINK)
50691 : : {
50692 : 67 : id = get_identifier ("omp declare target link");
50693 : 67 : std::swap (at1, at2);
50694 : : }
50695 : : else
50696 : 447 : id = get_identifier ("omp declare target");
50697 : 514 : if (at2)
50698 : : {
50699 : 18 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_ENTER)
50700 : 9 : error_at (OMP_CLAUSE_LOCATION (c),
50701 : : "%qD specified both in declare target %<link%> and %qs"
50702 : 9 : " clauses", t, OMP_CLAUSE_ENTER_TO (c) ? "to" : "enter");
50703 : : else
50704 : 9 : error_at (OMP_CLAUSE_LOCATION (c),
50705 : : "%qD specified both in declare target %<link%> and "
50706 : : "%<to%> or %<enter%> clauses", t);
50707 : 18 : return false;
50708 : : }
50709 : 496 : if (!at1)
50710 : : {
50711 : 388 : DECL_ATTRIBUTES (t) = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (t));
50712 : 388 : if (TREE_CODE (t) != FUNCTION_DECL && !is_global_var (t))
50713 : : return true;
50714 : :
50715 : 385 : symtab_node *node = symtab_node::get (t);
50716 : 385 : if (node != NULL)
50717 : : {
50718 : 240 : node->offloadable = 1;
50719 : 240 : if (ENABLE_OFFLOADING)
50720 : : {
50721 : : g->have_offload = true;
50722 : : if (is_a <varpool_node *> (node))
50723 : : vec_safe_push (offload_vars, t);
50724 : : }
50725 : : }
50726 : : }
50727 : 493 : if (TREE_CODE (t) != FUNCTION_DECL)
50728 : : return true;
50729 : 204 : if ((device_type & OMP_CLAUSE_DEVICE_TYPE_HOST) != 0)
50730 : : {
50731 : 39 : tree at3 = lookup_attribute ("omp declare target host",
50732 : 39 : DECL_ATTRIBUTES (t));
50733 : 39 : if (at3 == NULL_TREE)
50734 : : {
50735 : 33 : id = get_identifier ("omp declare target host");
50736 : 33 : DECL_ATTRIBUTES (t) = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (t));
50737 : : }
50738 : : }
50739 : 204 : if ((device_type & OMP_CLAUSE_DEVICE_TYPE_NOHOST) != 0)
50740 : : {
50741 : 36 : tree at3 = lookup_attribute ("omp declare target nohost",
50742 : 36 : DECL_ATTRIBUTES (t));
50743 : 36 : if (at3 == NULL_TREE)
50744 : : {
50745 : 30 : id = get_identifier ("omp declare target nohost");
50746 : 30 : DECL_ATTRIBUTES (t) = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (t));
50747 : : }
50748 : : }
50749 : 204 : if (indirect)
50750 : : {
50751 : 37 : tree at4 = lookup_attribute ("omp declare target indirect",
50752 : 37 : DECL_ATTRIBUTES (t));
50753 : 37 : if (at4 == NULL_TREE)
50754 : : {
50755 : 37 : id = get_identifier ("omp declare target indirect");
50756 : 37 : DECL_ATTRIBUTES (t)
50757 : 74 : = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (t));
50758 : : }
50759 : : }
50760 : : return true;
50761 : : }
50762 : :
50763 : : /* OpenMP 4.0:
50764 : : # pragma omp declare target new-line
50765 : : declarations and definitions
50766 : : # pragma omp end declare target new-line
50767 : :
50768 : : OpenMP 4.5:
50769 : : # pragma omp declare target ( extended-list ) new-line
50770 : :
50771 : : # pragma omp declare target declare-target-clauses[seq] new-line */
50772 : :
50773 : : #define OMP_DECLARE_TARGET_CLAUSE_MASK \
50774 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
50775 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ENTER) \
50776 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK) \
50777 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \
50778 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT))
50779 : :
50780 : : static void
50781 : 640 : cp_parser_omp_declare_target (cp_parser *parser, cp_token *pragma_tok)
50782 : : {
50783 : 640 : tree clauses = NULL_TREE;
50784 : 640 : int device_type = 0;
50785 : 640 : bool indirect = false;
50786 : 640 : bool only_device_type_or_indirect = true;
50787 : 640 : if (flag_openmp)
50788 : 640 : omp_requires_mask
50789 : 640 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
50790 : 640 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
50791 : 640 : || (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
50792 : 17 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME)))
50793 : 375 : clauses
50794 : 375 : = cp_parser_omp_all_clauses (parser, OMP_DECLARE_TARGET_CLAUSE_MASK,
50795 : : "#pragma omp declare target", pragma_tok);
50796 : 265 : else if (parser->lexer->in_omp_decl_attribute
50797 : 265 : || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
50798 : : {
50799 : 60 : clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_ENTER,
50800 : : clauses);
50801 : 60 : clauses = finish_omp_clauses (clauses, C_ORT_OMP);
50802 : 60 : cp_parser_require_pragma_eol (parser, pragma_tok);
50803 : : }
50804 : : else
50805 : : {
50806 : 205 : cp_omp_declare_target_attr a
50807 : 205 : = { parser->lexer->in_omp_attribute_pragma, -1, false };
50808 : 205 : vec_safe_push (scope_chain->omp_declare_target_attribute, a);
50809 : 205 : cp_parser_require_pragma_eol (parser, pragma_tok);
50810 : 205 : return;
50811 : : }
50812 : 1080 : for (tree c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
50813 : : {
50814 : 645 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEVICE_TYPE)
50815 : 78 : device_type |= OMP_CLAUSE_DEVICE_TYPE_KIND (c);
50816 : 645 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_INDIRECT)
50817 : 59 : indirect |= !integer_zerop (OMP_CLAUSE_INDIRECT_EXPR (c));
50818 : : }
50819 : 1080 : for (tree c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
50820 : : {
50821 : 645 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEVICE_TYPE
50822 : 645 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_INDIRECT)
50823 : 137 : continue;
50824 : 508 : tree t = OMP_CLAUSE_DECL (c);
50825 : 508 : only_device_type_or_indirect = false;
50826 : 508 : if (!handle_omp_declare_target_clause (c, t, device_type, indirect))
50827 : 18 : continue;
50828 : 204 : if (VAR_OR_FUNCTION_DECL_P (t)
50829 : 490 : && DECL_LOCAL_DECL_P (t)
50830 : 6 : && DECL_LANG_SPECIFIC (t)
50831 : 6 : && DECL_LOCAL_DECL_ALIAS (t)
50832 : 496 : && DECL_LOCAL_DECL_ALIAS (t) != error_mark_node)
50833 : 6 : handle_omp_declare_target_clause (c, DECL_LOCAL_DECL_ALIAS (t),
50834 : : device_type, indirect);
50835 : : }
50836 : 435 : if ((device_type || indirect) && only_device_type_or_indirect)
50837 : 13 : error_at (OMP_CLAUSE_LOCATION (clauses),
50838 : : "directive with only %<device_type%> or %<indirect%> clauses");
50839 : 435 : if (indirect && device_type && device_type != OMP_CLAUSE_DEVICE_TYPE_ANY)
50840 : 3 : error_at (OMP_CLAUSE_LOCATION (clauses),
50841 : : "%<device_type%> clause must specify 'any' when used with "
50842 : : "an %<indirect%> clause");
50843 : : }
50844 : :
50845 : : /* OpenMP 5.1
50846 : : # pragma omp begin assumes clauses[optseq] new-line
50847 : :
50848 : : # pragma omp begin declare target clauses[optseq] new-line */
50849 : :
50850 : : #define OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK \
50851 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \
50852 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT))
50853 : :
50854 : : static void
50855 : 260 : cp_parser_omp_begin (cp_parser *parser, cp_token *pragma_tok)
50856 : : {
50857 : 260 : const char *p = "";
50858 : 260 : bool in_omp_attribute_pragma = parser->lexer->in_omp_attribute_pragma;
50859 : 260 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
50860 : : {
50861 : 260 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
50862 : 260 : p = IDENTIFIER_POINTER (id);
50863 : : }
50864 : 260 : if (strcmp (p, "declare") == 0)
50865 : : {
50866 : 125 : cp_lexer_consume_token (parser->lexer);
50867 : 125 : p = "";
50868 : 125 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
50869 : : {
50870 : 125 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
50871 : 125 : p = IDENTIFIER_POINTER (id);
50872 : : }
50873 : 125 : if (strcmp (p, "target") == 0)
50874 : : {
50875 : 125 : cp_lexer_consume_token (parser->lexer);
50876 : 125 : tree clauses
50877 : 125 : = cp_parser_omp_all_clauses (parser,
50878 : 125 : OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK,
50879 : : "#pragma omp begin declare target",
50880 : : pragma_tok);
50881 : 125 : int device_type = 0;
50882 : 125 : bool indirect = 0;
50883 : 196 : for (tree c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
50884 : : {
50885 : 71 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEVICE_TYPE)
50886 : 45 : device_type |= OMP_CLAUSE_DEVICE_TYPE_KIND (c);
50887 : 71 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_INDIRECT)
50888 : 26 : indirect |= !integer_zerop (OMP_CLAUSE_INDIRECT_EXPR (c));
50889 : : }
50890 : 125 : cp_omp_declare_target_attr a
50891 : 125 : = { in_omp_attribute_pragma, device_type, indirect };
50892 : 125 : vec_safe_push (scope_chain->omp_declare_target_attribute, a);
50893 : : }
50894 : : else
50895 : : {
50896 : 0 : cp_parser_error (parser, "expected %<target%>");
50897 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
50898 : : }
50899 : : }
50900 : 135 : else if (strcmp (p, "assumes") == 0)
50901 : : {
50902 : 135 : cp_lexer_consume_token (parser->lexer);
50903 : 135 : cp_parser_omp_assumption_clauses (parser, pragma_tok, false);
50904 : 135 : cp_omp_begin_assumes_data a = { in_omp_attribute_pragma };
50905 : 135 : vec_safe_push (scope_chain->omp_begin_assumes, a);
50906 : : }
50907 : : else
50908 : : {
50909 : 0 : cp_parser_error (parser, "expected %<declare target%> or %<assumes%>");
50910 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
50911 : : }
50912 : 260 : }
50913 : :
50914 : : /* OpenMP 4.0:
50915 : : # pragma omp end declare target new-line
50916 : :
50917 : : OpenMP 5.1:
50918 : : # pragma omp end assumes new-line */
50919 : :
50920 : : static void
50921 : 459 : cp_parser_omp_end (cp_parser *parser, cp_token *pragma_tok)
50922 : : {
50923 : 459 : const char *p = "";
50924 : 459 : bool in_omp_attribute_pragma = parser->lexer->in_omp_attribute_pragma;
50925 : 459 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
50926 : : {
50927 : 459 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
50928 : 459 : p = IDENTIFIER_POINTER (id);
50929 : : }
50930 : 459 : if (strcmp (p, "declare") == 0)
50931 : : {
50932 : 324 : cp_lexer_consume_token (parser->lexer);
50933 : 324 : p = "";
50934 : 324 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
50935 : : {
50936 : 324 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
50937 : 324 : p = IDENTIFIER_POINTER (id);
50938 : : }
50939 : 324 : if (strcmp (p, "target") == 0)
50940 : 324 : cp_lexer_consume_token (parser->lexer);
50941 : : else
50942 : : {
50943 : 0 : cp_parser_error (parser, "expected %<target%>");
50944 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
50945 : 0 : return;
50946 : : }
50947 : 324 : cp_parser_require_pragma_eol (parser, pragma_tok);
50948 : 324 : if (!vec_safe_length (scope_chain->omp_declare_target_attribute))
50949 : 6 : error_at (pragma_tok->location,
50950 : : "%<#pragma omp end declare target%> without corresponding "
50951 : : "%<#pragma omp declare target%> or "
50952 : : "%<#pragma omp begin declare target%>");
50953 : : else
50954 : : {
50955 : 318 : cp_omp_declare_target_attr
50956 : 318 : a = scope_chain->omp_declare_target_attribute->pop ();
50957 : 318 : if (a.attr_syntax != in_omp_attribute_pragma)
50958 : : {
50959 : 48 : if (a.attr_syntax)
50960 : 36 : error_at (pragma_tok->location,
50961 : : "%qs in attribute syntax terminated "
50962 : : "with %qs in pragma syntax",
50963 : : a.device_type >= 0 ? "begin declare target"
50964 : : : "declare target",
50965 : : "end declare target");
50966 : : else
50967 : 36 : error_at (pragma_tok->location,
50968 : : "%qs in pragma syntax terminated "
50969 : : "with %qs in attribute syntax",
50970 : : a.device_type >= 0 ? "begin declare target"
50971 : : : "declare target",
50972 : : "end declare target");
50973 : : }
50974 : : }
50975 : : }
50976 : 135 : else if (strcmp (p, "assumes") == 0)
50977 : : {
50978 : 135 : cp_lexer_consume_token (parser->lexer);
50979 : 135 : cp_parser_require_pragma_eol (parser, pragma_tok);
50980 : 135 : if (!vec_safe_length (scope_chain->omp_begin_assumes))
50981 : 3 : error_at (pragma_tok->location,
50982 : : "%qs without corresponding %qs",
50983 : : "#pragma omp end assumes", "#pragma omp begin assumes");
50984 : : else
50985 : : {
50986 : 132 : cp_omp_begin_assumes_data
50987 : 132 : a = scope_chain->omp_begin_assumes->pop ();
50988 : 132 : if (a.attr_syntax != in_omp_attribute_pragma)
50989 : : {
50990 : 24 : if (a.attr_syntax)
50991 : 12 : error_at (pragma_tok->location,
50992 : : "%qs in attribute syntax terminated "
50993 : : "with %qs in pragma syntax",
50994 : : "begin assumes", "end assumes");
50995 : : else
50996 : 12 : error_at (pragma_tok->location,
50997 : : "%qs in pragma syntax terminated "
50998 : : "with %qs in attribute syntax",
50999 : : "begin assumes", "end assumes");
51000 : : }
51001 : : }
51002 : : }
51003 : : else
51004 : : {
51005 : 0 : cp_parser_error (parser, "expected %<declare%> or %<assumes%>");
51006 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
51007 : 0 : return;
51008 : : }
51009 : : }
51010 : :
51011 : : /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
51012 : : expression and optional initializer clause of
51013 : : #pragma omp declare reduction. We store the expression(s) as
51014 : : either 3, 6 or 7 special statements inside of the artificial function's
51015 : : body. The first two statements are DECL_EXPRs for the artificial
51016 : : OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
51017 : : expression that uses those variables.
51018 : : If there was any INITIALIZER clause, this is followed by further statements,
51019 : : the fourth and fifth statements are DECL_EXPRs for the artificial
51020 : : OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
51021 : : constructor variant (first token after open paren is not omp_priv),
51022 : : then the sixth statement is a statement with the function call expression
51023 : : that uses the OMP_PRIV and optionally OMP_ORIG variable.
51024 : : Otherwise, the sixth statement is whatever statement cp_finish_decl emits
51025 : : to initialize the OMP_PRIV artificial variable and there is seventh
51026 : : statement, a DECL_EXPR of the OMP_PRIV statement again. */
51027 : :
51028 : : static bool
51029 : 743 : cp_parser_omp_declare_reduction_exprs (tree fndecl, cp_parser *parser)
51030 : : {
51031 : 743 : tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)));
51032 : 743 : gcc_assert (TYPE_REF_P (type));
51033 : 743 : type = TREE_TYPE (type);
51034 : 743 : tree omp_out = build_lang_decl (VAR_DECL, get_identifier ("omp_out"), type);
51035 : 743 : DECL_ARTIFICIAL (omp_out) = 1;
51036 : 743 : pushdecl (omp_out);
51037 : 743 : add_decl_expr (omp_out);
51038 : 743 : tree omp_in = build_lang_decl (VAR_DECL, get_identifier ("omp_in"), type);
51039 : 743 : DECL_ARTIFICIAL (omp_in) = 1;
51040 : 743 : pushdecl (omp_in);
51041 : 743 : add_decl_expr (omp_in);
51042 : 743 : tree combiner;
51043 : 743 : tree omp_priv = NULL_TREE, omp_orig = NULL_TREE, initializer = NULL_TREE;
51044 : :
51045 : 743 : keep_next_level (true);
51046 : 743 : tree block = begin_omp_structured_block ();
51047 : 743 : combiner = cp_parser_expression (parser);
51048 : 743 : finish_expr_stmt (combiner);
51049 : 743 : block = finish_omp_structured_block (block);
51050 : 743 : if (processing_template_decl)
51051 : 260 : block = build_stmt (input_location, EXPR_STMT, block);
51052 : 743 : add_stmt (block);
51053 : :
51054 : 743 : if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
51055 : : return false;
51056 : :
51057 : 740 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
51058 : 740 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
51059 : 6 : cp_lexer_consume_token (parser->lexer);
51060 : :
51061 : 740 : const char *p = "";
51062 : 740 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
51063 : : {
51064 : 312 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
51065 : 312 : p = IDENTIFIER_POINTER (id);
51066 : : }
51067 : :
51068 : 740 : if (strcmp (p, "initializer") == 0)
51069 : : {
51070 : 312 : cp_lexer_consume_token (parser->lexer);
51071 : 312 : matching_parens parens;
51072 : 312 : if (!parens.require_open (parser))
51073 : 6 : return false;
51074 : :
51075 : 312 : p = "";
51076 : 312 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
51077 : : {
51078 : 310 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
51079 : 310 : p = IDENTIFIER_POINTER (id);
51080 : : }
51081 : :
51082 : 312 : omp_priv = build_lang_decl (VAR_DECL, get_identifier ("omp_priv"), type);
51083 : 312 : DECL_ARTIFICIAL (omp_priv) = 1;
51084 : 312 : pushdecl (omp_priv);
51085 : 312 : add_decl_expr (omp_priv);
51086 : 312 : omp_orig = build_lang_decl (VAR_DECL, get_identifier ("omp_orig"), type);
51087 : 312 : DECL_ARTIFICIAL (omp_orig) = 1;
51088 : 312 : pushdecl (omp_orig);
51089 : 312 : add_decl_expr (omp_orig);
51090 : :
51091 : 312 : keep_next_level (true);
51092 : 312 : block = begin_omp_structured_block ();
51093 : :
51094 : 312 : bool ctor = false;
51095 : 312 : if (strcmp (p, "omp_priv") == 0)
51096 : : {
51097 : 184 : bool is_non_constant_init;
51098 : 184 : ctor = true;
51099 : 184 : cp_lexer_consume_token (parser->lexer);
51100 : : /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
51101 : 184 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
51102 : 184 : || (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
51103 : 80 : && cp_lexer_peek_nth_token (parser->lexer, 2)->type
51104 : : == CPP_CLOSE_PAREN
51105 : 3 : && cp_lexer_peek_nth_token (parser->lexer, 3)->type
51106 : : == CPP_CLOSE_PAREN))
51107 : : {
51108 : 6 : finish_omp_structured_block (block);
51109 : 6 : error ("invalid initializer clause");
51110 : 6 : return false;
51111 : : }
51112 : 178 : initializer = cp_parser_initializer (parser,
51113 : : /*is_direct_init=*/nullptr,
51114 : : &is_non_constant_init);
51115 : 178 : cp_finish_decl (omp_priv, initializer, !is_non_constant_init,
51116 : : NULL_TREE, LOOKUP_ONLYCONVERTING);
51117 : : }
51118 : : else
51119 : : {
51120 : 128 : cp_parser_parse_tentatively (parser);
51121 : : /* Don't create location wrapper nodes here. */
51122 : 128 : auto_suppress_location_wrappers sentinel;
51123 : 128 : tree fn_name = cp_parser_id_expression (parser, /*template_p=*/false,
51124 : : /*check_dependency_p=*/true,
51125 : : /*template_p=*/NULL,
51126 : : /*declarator_p=*/false,
51127 : : /*optional_p=*/false);
51128 : 128 : vec<tree, va_gc> *args;
51129 : 128 : if (fn_name == error_mark_node
51130 : 128 : || cp_parser_error_occurred (parser)
51131 : 128 : || !cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
51132 : 128 : || ((args = cp_parser_parenthesized_expression_list
51133 : 128 : (parser, non_attr, /*cast_p=*/false,
51134 : : /*allow_expansion_p=*/true,
51135 : : /*non_constant_p=*/NULL)),
51136 : 134 : cp_parser_error_occurred (parser)))
51137 : : {
51138 : 0 : finish_omp_structured_block (block);
51139 : 0 : cp_parser_abort_tentative_parse (parser);
51140 : 0 : cp_parser_error (parser, "expected id-expression (arguments)");
51141 : 0 : return false;
51142 : : }
51143 : : unsigned int i;
51144 : : tree arg;
51145 : 134 : FOR_EACH_VEC_SAFE_ELT (args, i, arg)
51146 : 128 : if (arg == omp_priv
51147 : 128 : || (TREE_CODE (arg) == ADDR_EXPR
51148 : 50 : && TREE_OPERAND (arg, 0) == omp_priv))
51149 : : break;
51150 : 128 : cp_parser_abort_tentative_parse (parser);
51151 : 128 : if (arg == NULL_TREE)
51152 : 6 : error ("one of the initializer call arguments should be %<omp_priv%>"
51153 : : " or %<&omp_priv%>");
51154 : 128 : initializer = cp_parser_postfix_expression (parser, false, false, false,
51155 : : false, NULL);
51156 : 128 : finish_expr_stmt (initializer);
51157 : : }
51158 : :
51159 : 306 : block = finish_omp_structured_block (block);
51160 : 306 : cp_walk_tree (&block, cp_remove_omp_priv_cleanup_stmt, omp_priv, NULL);
51161 : 306 : if (processing_template_decl)
51162 : 84 : block = build_stmt (input_location, EXPR_STMT, block);
51163 : 306 : add_stmt (block);
51164 : :
51165 : 306 : if (ctor)
51166 : 178 : add_decl_expr (omp_orig);
51167 : :
51168 : 306 : if (!parens.require_close (parser))
51169 : : return false;
51170 : : }
51171 : :
51172 : 734 : if (!cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA_EOL))
51173 : 0 : cp_parser_required_error (parser, RT_PRAGMA_EOL, /*keyword=*/false,
51174 : : UNKNOWN_LOCATION);
51175 : :
51176 : : return true;
51177 : : }
51178 : :
51179 : : /* OpenMP 4.0
51180 : : #pragma omp declare reduction (reduction-id : typename-list : expression) \
51181 : : initializer-clause[opt] new-line
51182 : :
51183 : : initializer-clause:
51184 : : initializer (omp_priv initializer)
51185 : : initializer (function-name (argument-list)) */
51186 : :
51187 : : static void
51188 : 772 : cp_parser_omp_declare_reduction (cp_parser *parser, cp_token *pragma_tok,
51189 : : enum pragma_context)
51190 : : {
51191 : 772 : auto_vec<tree> types;
51192 : 772 : enum tree_code reduc_code = ERROR_MARK;
51193 : 772 : tree reduc_id = NULL_TREE, orig_reduc_id = NULL_TREE, type;
51194 : 772 : unsigned int i;
51195 : 772 : cp_token *first_token;
51196 : 772 : cp_token_cache *cp;
51197 : 772 : int errs;
51198 : 772 : void *p;
51199 : :
51200 : : /* Get the high-water mark for the DECLARATOR_OBSTACK. */
51201 : 772 : p = obstack_alloc (&declarator_obstack, 0);
51202 : :
51203 : 772 : if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
51204 : 3 : goto fail;
51205 : :
51206 : 769 : switch (cp_lexer_peek_token (parser->lexer)->type)
51207 : : {
51208 : : case CPP_PLUS:
51209 : : reduc_code = PLUS_EXPR;
51210 : : break;
51211 : : case CPP_MULT:
51212 : : reduc_code = MULT_EXPR;
51213 : : break;
51214 : : case CPP_MINUS:
51215 : : reduc_code = MINUS_EXPR;
51216 : : break;
51217 : : case CPP_AND:
51218 : : reduc_code = BIT_AND_EXPR;
51219 : : break;
51220 : : case CPP_XOR:
51221 : : reduc_code = BIT_XOR_EXPR;
51222 : : break;
51223 : : case CPP_OR:
51224 : : reduc_code = BIT_IOR_EXPR;
51225 : : break;
51226 : : case CPP_AND_AND:
51227 : : reduc_code = TRUTH_ANDIF_EXPR;
51228 : : break;
51229 : : case CPP_OR_OR:
51230 : : reduc_code = TRUTH_ORIF_EXPR;
51231 : : break;
51232 : 457 : case CPP_NAME:
51233 : 457 : reduc_id = orig_reduc_id = cp_parser_identifier (parser);
51234 : 457 : break;
51235 : 0 : default:
51236 : 0 : cp_parser_error (parser, "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, "
51237 : : "%<|%>, %<&&%>, %<||%> or identifier");
51238 : 0 : goto fail;
51239 : : }
51240 : :
51241 : 457 : if (reduc_code != ERROR_MARK)
51242 : 312 : cp_lexer_consume_token (parser->lexer);
51243 : :
51244 : 769 : reduc_id = omp_reduction_id (reduc_code, reduc_id, NULL_TREE);
51245 : 769 : if (reduc_id == error_mark_node)
51246 : 0 : goto fail;
51247 : :
51248 : 769 : if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
51249 : 0 : goto fail;
51250 : :
51251 : : /* Types may not be defined in declare reduction type list. */
51252 : 769 : const char *saved_message;
51253 : 769 : saved_message = parser->type_definition_forbidden_message;
51254 : 769 : parser->type_definition_forbidden_message
51255 : 769 : = G_("types may not be defined in declare reduction type list");
51256 : 769 : bool saved_colon_corrects_to_scope_p;
51257 : 769 : saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
51258 : 769 : parser->colon_corrects_to_scope_p = false;
51259 : 769 : bool saved_colon_doesnt_start_class_def_p;
51260 : 769 : saved_colon_doesnt_start_class_def_p
51261 : 769 : = parser->colon_doesnt_start_class_def_p;
51262 : 769 : parser->colon_doesnt_start_class_def_p = true;
51263 : :
51264 : 801 : while (true)
51265 : : {
51266 : 785 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
51267 : 785 : type = cp_parser_type_id (parser);
51268 : 785 : if (type == error_mark_node)
51269 : : ;
51270 : 785 : else if (ARITHMETIC_TYPE_P (type)
51271 : 192 : && (orig_reduc_id == NULL_TREE
51272 : 183 : || (TREE_CODE (type) != COMPLEX_TYPE
51273 : 177 : && (id_equal (orig_reduc_id, "min")
51274 : 174 : || id_equal (orig_reduc_id, "max")))))
51275 : 12 : error_at (loc, "predeclared arithmetic type %qT in "
51276 : : "%<#pragma omp declare reduction%>", type);
51277 : 773 : else if (FUNC_OR_METHOD_TYPE_P (type)
51278 : 764 : || TREE_CODE (type) == ARRAY_TYPE)
51279 : 15 : error_at (loc, "function or array type %qT in "
51280 : : "%<#pragma omp declare reduction%>", type);
51281 : 758 : else if (TYPE_REF_P (type))
51282 : 3 : error_at (loc, "reference type %qT in "
51283 : : "%<#pragma omp declare reduction%>", type);
51284 : 755 : else if (TYPE_QUALS_NO_ADDR_SPACE (type))
51285 : 12 : error_at (loc, "%<const%>, %<volatile%> or %<__restrict%>-qualified "
51286 : : "type %qT in %<#pragma omp declare reduction%>", type);
51287 : : else
51288 : 743 : types.safe_push (type);
51289 : :
51290 : 785 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
51291 : 16 : cp_lexer_consume_token (parser->lexer);
51292 : : else
51293 : : break;
51294 : 16 : }
51295 : :
51296 : : /* Restore the saved message. */
51297 : 769 : parser->type_definition_forbidden_message = saved_message;
51298 : 769 : parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
51299 : 769 : parser->colon_doesnt_start_class_def_p
51300 : 769 : = saved_colon_doesnt_start_class_def_p;
51301 : :
51302 : 769 : if (!cp_parser_require (parser, CPP_COLON, RT_COLON)
51303 : 769 : || types.is_empty ())
51304 : : {
51305 : 54 : fail:
51306 : 54 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
51307 : 54 : goto done;
51308 : : }
51309 : :
51310 : 727 : first_token = cp_lexer_peek_token (parser->lexer);
51311 : 727 : cp = NULL;
51312 : 727 : errs = errorcount;
51313 : 1344 : FOR_EACH_VEC_ELT (types, i, type)
51314 : : {
51315 : 743 : tree fntype
51316 : 743 : = build_function_type_list (void_type_node,
51317 : : cp_build_reference_type (type, false),
51318 : : NULL_TREE);
51319 : 743 : tree this_reduc_id = reduc_id;
51320 : 743 : if (!dependent_type_p (type))
51321 : 534 : this_reduc_id = omp_reduction_id (ERROR_MARK, reduc_id, type);
51322 : 743 : tree fndecl = build_lang_decl (FUNCTION_DECL, this_reduc_id, fntype);
51323 : 743 : DECL_SOURCE_LOCATION (fndecl) = pragma_tok->location;
51324 : 743 : DECL_ARTIFICIAL (fndecl) = 1;
51325 : 743 : DECL_EXTERNAL (fndecl) = 1;
51326 : 743 : DECL_DECLARED_INLINE_P (fndecl) = 1;
51327 : 743 : DECL_IGNORED_P (fndecl) = 1;
51328 : 743 : DECL_OMP_DECLARE_REDUCTION_P (fndecl) = 1;
51329 : 743 : SET_DECL_ASSEMBLER_NAME (fndecl, get_identifier ("<udr>"));
51330 : 743 : DECL_ATTRIBUTES (fndecl)
51331 : 743 : = tree_cons (get_identifier ("gnu_inline"), NULL_TREE,
51332 : 743 : DECL_ATTRIBUTES (fndecl));
51333 : 743 : bool block_scope = false;
51334 : 743 : if (current_function_decl)
51335 : : {
51336 : 191 : block_scope = true;
51337 : 191 : DECL_CONTEXT (fndecl) = current_function_decl;
51338 : 191 : DECL_LOCAL_DECL_P (fndecl) = true;
51339 : : }
51340 : :
51341 : 743 : if (processing_template_decl)
51342 : 260 : fndecl = push_template_decl (fndecl);
51343 : :
51344 : 743 : if (block_scope)
51345 : : {
51346 : 191 : if (!processing_template_decl)
51347 : 61 : pushdecl (fndecl);
51348 : : }
51349 : 552 : else if (current_class_type)
51350 : : {
51351 : 185 : if (cp == NULL)
51352 : : {
51353 : 2017 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
51354 : 1836 : cp_lexer_consume_token (parser->lexer);
51355 : 181 : cp = cp_token_cache_new (first_token,
51356 : : cp_lexer_peek_nth_token (parser->lexer,
51357 : : 2));
51358 : : }
51359 : 185 : DECL_STATIC_FUNCTION_P (fndecl) = 1;
51360 : 185 : finish_member_declaration (fndecl);
51361 : 185 : DECL_PENDING_INLINE_INFO (fndecl) = cp;
51362 : 185 : DECL_PENDING_INLINE_P (fndecl) = 1;
51363 : 185 : vec_safe_push (unparsed_funs_with_definitions, fndecl);
51364 : 185 : continue;
51365 : 185 : }
51366 : : else
51367 : : {
51368 : 367 : DECL_CONTEXT (fndecl) = current_namespace;
51369 : 367 : tree d = pushdecl (fndecl);
51370 : : /* We should never meet a matched duplicate decl. */
51371 : 367 : gcc_checking_assert (d == error_mark_node || d == fndecl);
51372 : : }
51373 : :
51374 : 558 : tree block = NULL_TREE;
51375 : 558 : if (!block_scope)
51376 : 367 : start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
51377 : : else
51378 : 191 : block = begin_omp_structured_block ();
51379 : 558 : if (cp)
51380 : : {
51381 : 12 : cp_parser_push_lexer_for_tokens (parser, cp);
51382 : 12 : parser->lexer->in_pragma = true;
51383 : : }
51384 : :
51385 : 558 : bool ok = cp_parser_omp_declare_reduction_exprs (fndecl, parser);
51386 : :
51387 : 558 : if (cp)
51388 : 12 : cp_parser_pop_lexer (parser);
51389 : 558 : if (!block_scope)
51390 : 367 : finish_function (/*inline_p=*/false);
51391 : : else
51392 : : {
51393 : 191 : DECL_CONTEXT (fndecl) = current_function_decl;
51394 : 191 : if (DECL_TEMPLATE_INFO (fndecl))
51395 : 0 : DECL_CONTEXT (DECL_TI_TEMPLATE (fndecl)) = current_function_decl;
51396 : : }
51397 : 558 : if (!ok)
51398 : 9 : goto fail;
51399 : :
51400 : 549 : if (block_scope)
51401 : : {
51402 : 188 : block = finish_omp_structured_block (block);
51403 : 188 : if (TREE_CODE (block) == BIND_EXPR)
51404 : 58 : DECL_SAVED_TREE (fndecl) = BIND_EXPR_BODY (block);
51405 : 130 : else if (TREE_CODE (block) == STATEMENT_LIST)
51406 : 130 : DECL_SAVED_TREE (fndecl) = block;
51407 : 188 : if (processing_template_decl)
51408 : 130 : add_decl_expr (fndecl);
51409 : : }
51410 : :
51411 : 549 : cp_check_omp_declare_reduction (fndecl);
51412 : 549 : if (cp == NULL && types.length () > 1)
51413 : 8 : cp = cp_token_cache_new (first_token,
51414 : : cp_lexer_peek_nth_token (parser->lexer, 2));
51415 : 549 : if (errs != errorcount)
51416 : : break;
51417 : : }
51418 : :
51419 : 718 : cp_parser_require_pragma_eol (parser, pragma_tok);
51420 : :
51421 : 772 : done:
51422 : : /* Free any declarators allocated. */
51423 : 772 : obstack_free (&declarator_obstack, p);
51424 : 772 : }
51425 : :
51426 : : /* OpenMP 4.0
51427 : : #pragma omp declare simd declare-simd-clauses[optseq] new-line
51428 : : #pragma omp declare reduction (reduction-id : typename-list : expression) \
51429 : : initializer-clause[opt] new-line
51430 : : #pragma omp declare target new-line
51431 : :
51432 : : OpenMP 5.0
51433 : : #pragma omp declare variant (identifier) match (context-selector)
51434 : :
51435 : : OpenMP 5.1
51436 : : #pragma omp declare variant (identifier) match (context-selector) \
51437 : : adjust_args (adjust-op:argument-list) append_args(interop-list) */
51438 : :
51439 : : static bool
51440 : 3600 : cp_parser_omp_declare (cp_parser *parser, cp_token *pragma_tok,
51441 : : enum pragma_context context)
51442 : : {
51443 : 3600 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
51444 : : {
51445 : 3600 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
51446 : 3600 : const char *p = IDENTIFIER_POINTER (id);
51447 : :
51448 : 3600 : if (strcmp (p, "simd") == 0)
51449 : : {
51450 : 836 : cp_lexer_consume_token (parser->lexer);
51451 : 836 : cp_parser_omp_declare_simd (parser, pragma_tok,
51452 : : context, false);
51453 : 836 : return true;
51454 : : }
51455 : 2764 : if (flag_openmp && strcmp (p, "variant") == 0)
51456 : : {
51457 : 1352 : cp_lexer_consume_token (parser->lexer);
51458 : 1352 : cp_parser_omp_declare_simd (parser, pragma_tok,
51459 : : context, true);
51460 : 1352 : return true;
51461 : : }
51462 : 1412 : cp_ensure_no_omp_declare_simd (parser);
51463 : 1412 : if (strcmp (p, "reduction") == 0)
51464 : : {
51465 : 772 : cp_lexer_consume_token (parser->lexer);
51466 : 772 : cp_parser_omp_declare_reduction (parser, pragma_tok,
51467 : : context);
51468 : 772 : return false;
51469 : : }
51470 : 640 : if (!flag_openmp) /* flag_openmp_simd */
51471 : : {
51472 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
51473 : 0 : return false;
51474 : : }
51475 : 640 : if (strcmp (p, "target") == 0)
51476 : : {
51477 : 640 : cp_lexer_consume_token (parser->lexer);
51478 : 640 : cp_parser_omp_declare_target (parser, pragma_tok);
51479 : 640 : return false;
51480 : : }
51481 : : }
51482 : 0 : cp_parser_error (parser, "expected %<simd%>, %<reduction%>, "
51483 : : "%<target%> or %<variant%>");
51484 : 0 : cp_parser_require_pragma_eol (parser, pragma_tok);
51485 : 0 : return false;
51486 : : }
51487 : :
51488 : : /* OpenMP 5.1:
51489 : : # pragma omp interop clauses[opt] new-line */
51490 : :
51491 : : #define OMP_INTEROP_CLAUSE_MASK \
51492 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
51493 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DESTROY) \
51494 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
51495 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INIT) \
51496 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
51497 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE))
51498 : :
51499 : : static void
51500 : 345 : cp_parser_omp_interop (cp_parser *parser, cp_token *pragma_tok)
51501 : : {
51502 : 345 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
51503 : 345 : tree clauses = cp_parser_omp_all_clauses (parser, OMP_INTEROP_CLAUSE_MASK,
51504 : : "#pragma omp interop", pragma_tok);
51505 : 345 : tree stmt = make_node (OMP_INTEROP);
51506 : 345 : TREE_TYPE (stmt) = void_type_node;
51507 : 345 : OMP_INTEROP_CLAUSES (stmt) = clauses;
51508 : 345 : SET_EXPR_LOCATION (stmt, loc);
51509 : 345 : add_stmt (stmt);
51510 : 345 : }
51511 : :
51512 : : /* OpenMP 5.0
51513 : : #pragma omp requires clauses[optseq] new-line */
51514 : :
51515 : : static bool
51516 : 155 : cp_parser_omp_requires (cp_parser *parser, cp_token *pragma_tok)
51517 : : {
51518 : 155 : enum omp_requires new_req = (enum omp_requires) 0;
51519 : :
51520 : 155 : location_t loc = pragma_tok->location;
51521 : 345 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
51522 : : {
51523 : 202 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
51524 : 202 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
51525 : 29 : cp_lexer_consume_token (parser->lexer);
51526 : :
51527 : 202 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
51528 : : {
51529 : 199 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
51530 : 199 : const char *p = IDENTIFIER_POINTER (id);
51531 : 199 : location_t cloc = cp_lexer_peek_token (parser->lexer)->location;
51532 : 199 : enum omp_requires this_req = (enum omp_requires) 0;
51533 : :
51534 : 199 : if (!strcmp (p, "unified_address"))
51535 : : this_req = OMP_REQUIRES_UNIFIED_ADDRESS;
51536 : 162 : else if (!strcmp (p, "unified_shared_memory"))
51537 : : this_req = OMP_REQUIRES_UNIFIED_SHARED_MEMORY;
51538 : 125 : else if (!strcmp (p, "self_maps"))
51539 : : this_req = OMP_REQUIRES_SELF_MAPS;
51540 : 121 : else if (!strcmp (p, "dynamic_allocators"))
51541 : : this_req = OMP_REQUIRES_DYNAMIC_ALLOCATORS;
51542 : 106 : else if (!strcmp (p, "reverse_offload"))
51543 : : this_req = OMP_REQUIRES_REVERSE_OFFLOAD;
51544 : 66 : else if (!strcmp (p, "atomic_default_mem_order"))
51545 : : {
51546 : 63 : cp_lexer_consume_token (parser->lexer);
51547 : :
51548 : 63 : matching_parens parens;
51549 : 63 : if (parens.require_open (parser))
51550 : : {
51551 : 63 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
51552 : : {
51553 : 60 : id = cp_lexer_peek_token (parser->lexer)->u.value;
51554 : 60 : p = IDENTIFIER_POINTER (id);
51555 : :
51556 : 60 : if (!strcmp (p, "seq_cst"))
51557 : : this_req
51558 : : = (enum omp_requires) OMP_MEMORY_ORDER_SEQ_CST;
51559 : 33 : else if (!strcmp (p, "relaxed"))
51560 : : this_req
51561 : : = (enum omp_requires) OMP_MEMORY_ORDER_RELAXED;
51562 : 30 : else if (!strcmp (p, "release"))
51563 : : this_req
51564 : : = (enum omp_requires) OMP_MEMORY_ORDER_RELEASE;
51565 : 24 : else if (!strcmp (p, "acq_rel"))
51566 : : this_req
51567 : : = (enum omp_requires) OMP_MEMORY_ORDER_ACQ_REL;
51568 : 12 : else if (!strcmp (p, "acquire"))
51569 : : this_req
51570 : : = (enum omp_requires) OMP_MEMORY_ORDER_ACQUIRE;
51571 : : }
51572 : : if (this_req == 0)
51573 : : {
51574 : 6 : error_at (cp_lexer_peek_token (parser->lexer)->location,
51575 : : "expected %<acq_rel%>, %<acquire%>, "
51576 : : "%<relaxed%>, %<release%> or %<seq_cst%>");
51577 : 6 : switch (cp_lexer_peek_token (parser->lexer)->type)
51578 : : {
51579 : : case CPP_EOF:
51580 : : case CPP_PRAGMA_EOL:
51581 : : case CPP_CLOSE_PAREN:
51582 : : break;
51583 : 3 : default:
51584 : 3 : if (cp_lexer_nth_token_is (parser->lexer, 2,
51585 : : CPP_CLOSE_PAREN))
51586 : 3 : cp_lexer_consume_token (parser->lexer);
51587 : : break;
51588 : : }
51589 : : }
51590 : : else
51591 : 57 : cp_lexer_consume_token (parser->lexer);
51592 : :
51593 : 63 : if (!parens.require_close (parser))
51594 : 3 : cp_parser_skip_to_closing_parenthesis (parser,
51595 : : /*recovering=*/true,
51596 : : /*or_comma=*/false,
51597 : : /*consume_paren=*/
51598 : : true);
51599 : :
51600 : 63 : if (this_req == 0)
51601 : : {
51602 : 6 : cp_parser_require_pragma_eol (parser, pragma_tok);
51603 : 6 : return false;
51604 : : }
51605 : : }
51606 : 57 : p = NULL;
51607 : : }
51608 : : else
51609 : : {
51610 : 3 : error_at (cloc, "expected %<unified_address%>, "
51611 : : "%<unified_shared_memory%>, "
51612 : : "%<self_maps%>, "
51613 : : "%<dynamic_allocators%>, "
51614 : : "%<reverse_offload%> "
51615 : : "or %<atomic_default_mem_order%> clause");
51616 : 3 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
51617 : 3 : return false;
51618 : : }
51619 : 57 : if (p)
51620 : 133 : cp_lexer_consume_token (parser->lexer);
51621 : 190 : if (this_req)
51622 : : {
51623 : 190 : if ((this_req & ~OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER) != 0)
51624 : : {
51625 : 133 : if ((this_req & new_req) != 0)
51626 : 12 : error_at (cloc, "too many %qs clauses", p);
51627 : 133 : if (this_req != OMP_REQUIRES_DYNAMIC_ALLOCATORS
51628 : 118 : && (omp_requires_mask & OMP_REQUIRES_TARGET_USED) != 0)
51629 : 12 : error_at (cloc, "%qs clause used lexically after first "
51630 : : "target construct or offloading API", p);
51631 : : }
51632 : 57 : else if ((new_req & OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER) != 0)
51633 : : {
51634 : 3 : error_at (cloc, "too many %qs clauses",
51635 : : "atomic_default_mem_order");
51636 : 3 : this_req = (enum omp_requires) 0;
51637 : : }
51638 : 54 : else if ((omp_requires_mask
51639 : : & OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER) != 0)
51640 : : {
51641 : 6 : error_at (cloc, "more than one %<atomic_default_mem_order%>"
51642 : : " clause in a single compilation unit");
51643 : 6 : this_req
51644 : 6 : = (enum omp_requires)
51645 : 6 : (omp_requires_mask
51646 : : & OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER);
51647 : : }
51648 : 48 : else if ((omp_requires_mask
51649 : : & OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER_USED) != 0)
51650 : 3 : error_at (cloc, "%<atomic_default_mem_order%> clause used "
51651 : : "lexically after first %<atomic%> construct "
51652 : : "without memory order clause");
51653 : 190 : new_req = (enum omp_requires) (new_req | this_req);
51654 : 190 : omp_requires_mask
51655 : 190 : = (enum omp_requires) (omp_requires_mask | this_req);
51656 : 190 : continue;
51657 : : }
51658 : : }
51659 : : break;
51660 : : }
51661 : 146 : cp_parser_require_pragma_eol (parser, pragma_tok);
51662 : :
51663 : 146 : if (new_req == 0)
51664 : 3 : error_at (loc, "%<pragma omp requires%> requires at least one clause");
51665 : : return false;
51666 : : }
51667 : :
51668 : :
51669 : : /* OpenMP 5.1:
51670 : : #pragma omp nothing new-line */
51671 : :
51672 : : static void
51673 : 51 : cp_parser_omp_nothing (cp_parser *parser, cp_token *pragma_tok)
51674 : : {
51675 : 0 : cp_parser_require_pragma_eol (parser, pragma_tok);
51676 : 0 : }
51677 : :
51678 : :
51679 : : /* OpenMP 5.1
51680 : : #pragma omp error clauses[optseq] new-line */
51681 : :
51682 : : static bool
51683 : 268 : cp_parser_omp_error (cp_parser *parser, cp_token *pragma_tok,
51684 : : enum pragma_context context)
51685 : : {
51686 : 268 : int at_compilation = -1;
51687 : 268 : int severity_fatal = -1;
51688 : 268 : tree message = NULL_TREE;
51689 : 268 : bool bad = false;
51690 : 268 : location_t loc = pragma_tok->location;
51691 : :
51692 : 677 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
51693 : : {
51694 : 418 : if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
51695 : 418 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
51696 : 63 : cp_lexer_consume_token (parser->lexer);
51697 : :
51698 : 418 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
51699 : : break;
51700 : :
51701 : 415 : const char *p
51702 : 415 : = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
51703 : 415 : location_t cloc = cp_lexer_peek_token (parser->lexer)->location;
51704 : 415 : static const char *args[] = {
51705 : : "execution", "compilation", "warning", "fatal"
51706 : : };
51707 : 415 : int *v = NULL;
51708 : 415 : int idx = 0, n = -1;
51709 : 415 : tree m = NULL_TREE;
51710 : :
51711 : 415 : if (!strcmp (p, "at"))
51712 : : v = &at_compilation;
51713 : 268 : else if (!strcmp (p, "severity"))
51714 : : {
51715 : : v = &severity_fatal;
51716 : : idx += 2;
51717 : : }
51718 : 150 : else if (strcmp (p, "message"))
51719 : : {
51720 : 6 : error_at (cloc,
51721 : : "expected %<at%>, %<severity%> or %<message%> clause");
51722 : 6 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
51723 : 6 : return false;
51724 : : }
51725 : :
51726 : 409 : cp_lexer_consume_token (parser->lexer);
51727 : :
51728 : 409 : matching_parens parens;
51729 : 409 : if (parens.require_open (parser))
51730 : : {
51731 : 400 : if (v == NULL)
51732 : : {
51733 : 141 : m = cp_parser_assignment_expression (parser);
51734 : 141 : if (type_dependent_expression_p (m))
51735 : 6 : m = build1 (IMPLICIT_CONV_EXPR, const_string_type_node, m);
51736 : : else
51737 : 135 : m = perform_implicit_conversion_flags (const_string_type_node, m,
51738 : : tf_warning_or_error,
51739 : : LOOKUP_NORMAL);
51740 : : }
51741 : : else
51742 : : {
51743 : 259 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
51744 : : {
51745 : 247 : tree val = cp_lexer_peek_token (parser->lexer)->u.value;
51746 : 247 : const char *q = IDENTIFIER_POINTER (val);
51747 : :
51748 : 247 : if (!strcmp (q, args[idx]))
51749 : : n = 0;
51750 : 119 : else if (!strcmp (q, args[idx + 1]))
51751 : : n = 1;
51752 : : }
51753 : : if (n == -1)
51754 : : {
51755 : 18 : error_at (cp_lexer_peek_token (parser->lexer)->location,
51756 : 18 : "expected %qs or %qs", args[idx], args[idx + 1]);
51757 : 18 : bad = true;
51758 : 18 : switch (cp_lexer_peek_token (parser->lexer)->type)
51759 : : {
51760 : : case CPP_EOF:
51761 : : case CPP_PRAGMA_EOL:
51762 : : case CPP_CLOSE_PAREN:
51763 : : break;
51764 : 12 : default:
51765 : 12 : if (cp_lexer_nth_token_is (parser->lexer, 2,
51766 : : CPP_CLOSE_PAREN))
51767 : 6 : cp_lexer_consume_token (parser->lexer);
51768 : : break;
51769 : : }
51770 : : }
51771 : : else
51772 : 241 : cp_lexer_consume_token (parser->lexer);
51773 : : }
51774 : :
51775 : 400 : if (!parens.require_close (parser))
51776 : 27 : cp_parser_skip_to_closing_parenthesis (parser,
51777 : : /*recovering=*/true,
51778 : : /*or_comma=*/false,
51779 : : /*consume_paren=*/
51780 : : true);
51781 : :
51782 : 400 : if (v == NULL)
51783 : : {
51784 : 141 : if (message)
51785 : : {
51786 : 3 : error_at (cloc, "too many %qs clauses", p);
51787 : 3 : bad = true;
51788 : : }
51789 : : else
51790 : : message = m;
51791 : : }
51792 : 259 : else if (n != -1)
51793 : : {
51794 : 241 : if (*v != -1)
51795 : : {
51796 : 6 : error_at (cloc, "too many %qs clauses", p);
51797 : 6 : bad = true;
51798 : : }
51799 : : else
51800 : 235 : *v = n;
51801 : : }
51802 : : }
51803 : : else
51804 : : bad = true;
51805 : : }
51806 : 262 : cp_parser_require_pragma_eol (parser, pragma_tok);
51807 : 262 : if (bad)
51808 : : return true;
51809 : :
51810 : 226 : if (at_compilation == -1)
51811 : 100 : at_compilation = 1;
51812 : 226 : if (severity_fatal == -1)
51813 : 129 : severity_fatal = 1;
51814 : 226 : if (!at_compilation)
51815 : : {
51816 : 65 : if (context != pragma_compound)
51817 : : {
51818 : 21 : error_at (loc, "%<#pragma omp error%> with %<at(execution)%> clause "
51819 : : "may only be used in compound statements");
51820 : 21 : return true;
51821 : : }
51822 : 44 : tree fndecl
51823 : 60 : = builtin_decl_explicit (severity_fatal ? BUILT_IN_GOMP_ERROR
51824 : : : BUILT_IN_GOMP_WARNING);
51825 : 44 : if (!message)
51826 : 7 : message = build_zero_cst (const_string_type_node);
51827 : 44 : tree stmt = build_call_expr_loc (loc, fndecl, 2, message,
51828 : : build_all_ones_cst (size_type_node));
51829 : 44 : add_stmt (stmt);
51830 : 44 : return true;
51831 : : }
51832 : :
51833 : 161 : if (in_discarded_stmt)
51834 : : return false;
51835 : :
51836 : 155 : const char *msg = NULL;
51837 : 155 : if (message)
51838 : : {
51839 : 83 : msg = c_getstr (fold_for_warn (message));
51840 : 83 : if (msg == NULL)
51841 : 18 : msg = _("<message unknown at compile time>");
51842 : : }
51843 : 18 : if (msg)
51844 : 118 : emit_diagnostic (severity_fatal ? DK_ERROR : DK_WARNING, loc, 0,
51845 : : "%<pragma omp error%> encountered: %s", msg);
51846 : : else
51847 : 75 : emit_diagnostic (severity_fatal ? DK_ERROR : DK_WARNING, loc, 0,
51848 : : "%<pragma omp error%> encountered");
51849 : : return false;
51850 : : }
51851 : :
51852 : : /* OpenMP 4.5:
51853 : : #pragma omp taskloop taskloop-clause[optseq] new-line
51854 : : for-loop
51855 : :
51856 : : #pragma omp taskloop simd taskloop-simd-clause[optseq] new-line
51857 : : for-loop */
51858 : :
51859 : : #define OMP_TASKLOOP_CLAUSE_MASK \
51860 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
51861 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
51862 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
51863 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
51864 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
51865 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_GRAINSIZE) \
51866 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TASKS) \
51867 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
51868 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
51869 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
51870 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
51871 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
51872 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP) \
51873 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
51874 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
51875 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
51876 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION))
51877 : :
51878 : : static tree
51879 : 997 : cp_parser_omp_taskloop (cp_parser *parser, cp_token *pragma_tok,
51880 : : char *p_name, omp_clause_mask mask, tree *cclauses,
51881 : : bool *if_p)
51882 : : {
51883 : 997 : tree clauses, sb, ret;
51884 : 997 : unsigned int save;
51885 : 997 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
51886 : :
51887 : 997 : strcat (p_name, " taskloop");
51888 : 997 : mask |= OMP_TASKLOOP_CLAUSE_MASK;
51889 : : /* #pragma omp parallel master taskloop{, simd} disallow in_reduction
51890 : : clause. */
51891 : 997 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS)) != 0)
51892 : 227 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION);
51893 : :
51894 : 997 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
51895 : : {
51896 : 711 : tree id = cp_lexer_peek_token (parser->lexer)->u.value;
51897 : 711 : const char *p = IDENTIFIER_POINTER (id);
51898 : :
51899 : 711 : if (strcmp (p, "simd") == 0)
51900 : : {
51901 : 404 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
51902 : 404 : if (cclauses == NULL)
51903 : 160 : cclauses = cclauses_buf;
51904 : :
51905 : 404 : cp_lexer_consume_token (parser->lexer);
51906 : 404 : if (!flag_openmp) /* flag_openmp_simd */
51907 : 9 : return cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
51908 : 9 : cclauses, if_p);
51909 : 395 : sb = begin_omp_structured_block ();
51910 : 395 : save = cp_parser_begin_omp_structured_block (parser);
51911 : 395 : ret = cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
51912 : : cclauses, if_p);
51913 : 395 : cp_parser_end_omp_structured_block (parser, save);
51914 : 395 : tree body = finish_omp_structured_block (sb);
51915 : 395 : if (ret == NULL)
51916 : : return ret;
51917 : 395 : ret = make_node (OMP_TASKLOOP);
51918 : 395 : TREE_TYPE (ret) = void_type_node;
51919 : 395 : OMP_FOR_BODY (ret) = body;
51920 : 395 : OMP_FOR_CLAUSES (ret) = cclauses[C_OMP_CLAUSE_SPLIT_TASKLOOP];
51921 : 395 : SET_EXPR_LOCATION (ret, loc);
51922 : 395 : add_stmt (ret);
51923 : 395 : return ret;
51924 : : }
51925 : : }
51926 : 593 : if (!flag_openmp) /* flag_openmp_simd */
51927 : : {
51928 : 6 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
51929 : 6 : return NULL_TREE;
51930 : : }
51931 : :
51932 : 587 : clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
51933 : : cclauses == NULL);
51934 : 587 : if (cclauses)
51935 : : {
51936 : 166 : cp_omp_split_clauses (loc, OMP_TASKLOOP, mask, clauses, cclauses);
51937 : 166 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_TASKLOOP];
51938 : : }
51939 : :
51940 : 587 : keep_next_level (true);
51941 : 587 : sb = begin_omp_structured_block ();
51942 : 587 : save = cp_parser_begin_omp_structured_block (parser);
51943 : :
51944 : 587 : ret = cp_parser_omp_for_loop (parser, OMP_TASKLOOP, clauses, cclauses,
51945 : : if_p);
51946 : :
51947 : 587 : cp_parser_end_omp_structured_block (parser, save);
51948 : 587 : add_stmt (finish_omp_structured_block (sb));
51949 : :
51950 : 587 : return ret;
51951 : : }
51952 : :
51953 : :
51954 : : /* OpenACC 2.0:
51955 : : # pragma acc routine oacc-routine-clause[optseq] new-line
51956 : : function-definition
51957 : :
51958 : : # pragma acc routine ( name ) oacc-routine-clause[optseq] new-line
51959 : : */
51960 : :
51961 : : #define OACC_ROUTINE_CLAUSE_MASK \
51962 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
51963 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
51964 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
51965 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
51966 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NOHOST) )
51967 : :
51968 : : /* Parse the OpenACC routine pragma. This has an optional '( name )'
51969 : : component, which must resolve to a declared namespace-scope
51970 : : function. The clauses are either processed directly (for a named
51971 : : function), or defered until the immediatley following declaration
51972 : : is parsed. */
51973 : :
51974 : : static void
51975 : 1040 : cp_parser_oacc_routine (cp_parser *parser, cp_token *pragma_tok,
51976 : : enum pragma_context context)
51977 : : {
51978 : 1040 : gcc_checking_assert (context == pragma_external);
51979 : : /* The checking for "another pragma following this one" in the "no optional
51980 : : '( name )'" case makes sure that we dont re-enter. */
51981 : 1040 : gcc_checking_assert (parser->oacc_routine == NULL);
51982 : :
51983 : 1040 : cp_oacc_routine_data data;
51984 : 1040 : data.error_seen = false;
51985 : 1040 : data.fndecl_seen = false;
51986 : 1040 : data.tokens = vNULL;
51987 : 1040 : data.clauses = NULL_TREE;
51988 : 1040 : data.loc = pragma_tok->location;
51989 : : /* It is safe to take the address of a local variable; it will only be
51990 : : used while this scope is live. */
51991 : 1040 : parser->oacc_routine = &data;
51992 : :
51993 : : /* Look for optional '( name )'. */
51994 : 1040 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
51995 : : {
51996 : 453 : matching_parens parens;
51997 : 453 : parens.consume_open (parser); /* '(' */
51998 : :
51999 : : /* We parse the name as an id-expression. If it resolves to
52000 : : anything other than a non-overloaded function at namespace
52001 : : scope, it's an error. */
52002 : 453 : location_t name_loc = cp_lexer_peek_token (parser->lexer)->location;
52003 : 453 : tree name = cp_parser_id_expression (parser,
52004 : : /*template_keyword_p=*/false,
52005 : : /*check_dependency_p=*/false,
52006 : : /*template_p=*/NULL,
52007 : : /*declarator_p=*/false,
52008 : : /*optional_p=*/false);
52009 : 453 : tree decl = (identifier_p (name)
52010 : 429 : ? cp_parser_lookup_name_simple (parser, name, name_loc)
52011 : 453 : : name);
52012 : 453 : if (name != error_mark_node && decl == error_mark_node)
52013 : 15 : cp_parser_name_lookup_error (parser, name, decl, NLE_NULL, name_loc);
52014 : :
52015 : 453 : if (decl == error_mark_node
52016 : 867 : || !parens.require_close (parser))
52017 : : {
52018 : 45 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
52019 : 45 : parser->oacc_routine = NULL;
52020 : 66 : return;
52021 : : }
52022 : :
52023 : 408 : data.clauses
52024 : 408 : = cp_parser_oacc_all_clauses (parser, OACC_ROUTINE_CLAUSE_MASK,
52025 : : "#pragma acc routine",
52026 : : cp_lexer_peek_token (parser->lexer));
52027 : : /* The clauses are in reverse order; fix that to make later diagnostic
52028 : : emission easier. */
52029 : 408 : data.clauses = nreverse (data.clauses);
52030 : :
52031 : 408 : if (decl && is_overloaded_fn (decl)
52032 : 804 : && (TREE_CODE (decl) != FUNCTION_DECL
52033 : : || DECL_FUNCTION_TEMPLATE_P (decl)))
52034 : : {
52035 : 9 : error_at (name_loc,
52036 : : "%<#pragma acc routine%> names a set of overloads");
52037 : 9 : parser->oacc_routine = NULL;
52038 : 9 : return;
52039 : : }
52040 : :
52041 : : /* Perhaps we should use the same rule as declarations in different
52042 : : namespaces? */
52043 : 399 : if (!DECL_NAMESPACE_SCOPE_P (decl))
52044 : : {
52045 : 0 : error_at (name_loc,
52046 : : "%qD does not refer to a namespace scope function", decl);
52047 : 0 : parser->oacc_routine = NULL;
52048 : 0 : return;
52049 : : }
52050 : :
52051 : 399 : if (TREE_CODE (decl) != FUNCTION_DECL)
52052 : : {
52053 : 12 : error_at (name_loc, "%qD does not refer to a function", decl);
52054 : 12 : parser->oacc_routine = NULL;
52055 : 12 : return;
52056 : : }
52057 : :
52058 : 387 : cp_finalize_oacc_routine (parser, decl, false);
52059 : 387 : parser->oacc_routine = NULL;
52060 : : }
52061 : : else /* No optional '( name )'. */
52062 : : {
52063 : : /* Store away all pragma tokens. */
52064 : 1293 : while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
52065 : 706 : cp_lexer_consume_token (parser->lexer);
52066 : 587 : cp_parser_require_pragma_eol (parser, pragma_tok);
52067 : 587 : struct cp_token_cache *cp
52068 : 587 : = cp_token_cache_new (pragma_tok, cp_lexer_peek_token (parser->lexer));
52069 : 587 : parser->oacc_routine->tokens.safe_push (cp);
52070 : :
52071 : : /* Emit a helpful diagnostic if there's another pragma following this
52072 : : one. */
52073 : 587 : if (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
52074 : : {
52075 : 27 : cp_ensure_no_oacc_routine (parser);
52076 : 27 : data.tokens.release ();
52077 : : /* ..., and then just keep going. */
52078 : 27 : return;
52079 : : }
52080 : :
52081 : : /* We only have to consider the pragma_external case here. */
52082 : 560 : cp_parser_declaration (parser, NULL_TREE);
52083 : 560 : if (parser->oacc_routine
52084 : 132 : && !parser->oacc_routine->fndecl_seen)
52085 : 5 : cp_ensure_no_oacc_routine (parser);
52086 : : else
52087 : 555 : parser->oacc_routine = NULL;
52088 : 560 : data.tokens.release ();
52089 : : }
52090 : : }
52091 : :
52092 : : /* Finalize #pragma acc routine clauses after direct declarator has
52093 : : been parsed. */
52094 : :
52095 : : static tree
52096 : 530 : cp_parser_late_parsing_oacc_routine (cp_parser *parser, tree attrs)
52097 : : {
52098 : 530 : struct cp_token_cache *ce;
52099 : 530 : cp_oacc_routine_data *data = parser->oacc_routine;
52100 : :
52101 : 530 : if (!data->error_seen && data->fndecl_seen)
52102 : : {
52103 : 9 : error_at (data->loc,
52104 : : "%<#pragma acc routine%> not immediately followed by "
52105 : : "a single function declaration or definition");
52106 : 9 : data->error_seen = true;
52107 : : }
52108 : 530 : if (data->error_seen)
52109 : : return attrs;
52110 : :
52111 : 521 : gcc_checking_assert (data->tokens.length () == 1);
52112 : 521 : ce = data->tokens[0];
52113 : :
52114 : 521 : cp_parser_push_lexer_for_tokens (parser, ce);
52115 : 521 : parser->lexer->in_pragma = true;
52116 : 521 : gcc_assert (cp_lexer_peek_token (parser->lexer)->type == CPP_PRAGMA);
52117 : :
52118 : 521 : cp_token *pragma_tok = cp_lexer_consume_token (parser->lexer);
52119 : 521 : gcc_checking_assert (parser->oacc_routine->clauses == NULL_TREE);
52120 : 521 : parser->oacc_routine->clauses
52121 : 521 : = cp_parser_oacc_all_clauses (parser, OACC_ROUTINE_CLAUSE_MASK,
52122 : : "#pragma acc routine", pragma_tok);
52123 : : /* The clauses are in reverse order; fix that to make later diagnostic
52124 : : emission easier. */
52125 : 521 : parser->oacc_routine->clauses = nreverse (parser->oacc_routine->clauses);
52126 : 521 : cp_parser_pop_lexer (parser);
52127 : : /* Later, cp_finalize_oacc_routine will process the clauses. */
52128 : 521 : parser->oacc_routine->fndecl_seen = true;
52129 : :
52130 : 521 : return attrs;
52131 : : }
52132 : :
52133 : : /* Apply any saved OpenACC routine clauses to a just-parsed
52134 : : declaration. */
52135 : :
52136 : : static void
52137 : 263858396 : cp_finalize_oacc_routine (cp_parser *parser, tree fndecl, bool is_defn)
52138 : : {
52139 : 263858396 : if (UNLIKELY (parser->oacc_routine != NULL))
52140 : : {
52141 : : /* Keep going if we're in error reporting mode. */
52142 : 945 : if (parser->oacc_routine->error_seen
52143 : 936 : || fndecl == error_mark_node)
52144 : : return;
52145 : :
52146 : 936 : if (TREE_CODE (fndecl) != FUNCTION_DECL)
52147 : : {
52148 : 31 : if (parser->oacc_routine->fndecl_seen)
52149 : : {
52150 : 6 : error_at (parser->oacc_routine->loc,
52151 : : "%<#pragma acc routine%> not immediately followed by"
52152 : : " a single function declaration or definition");
52153 : 6 : parser->oacc_routine = NULL;
52154 : 6 : return;
52155 : : }
52156 : :
52157 : 25 : cp_ensure_no_oacc_routine (parser);
52158 : 25 : return;
52159 : : }
52160 : :
52161 : 905 : int compatible
52162 : 905 : = oacc_verify_routine_clauses (fndecl, &parser->oacc_routine->clauses,
52163 : : parser->oacc_routine->loc,
52164 : : "#pragma acc routine");
52165 : 905 : if (compatible < 0)
52166 : : {
52167 : 138 : parser->oacc_routine = NULL;
52168 : 138 : return;
52169 : : }
52170 : 767 : if (compatible > 0)
52171 : : {
52172 : : }
52173 : : else
52174 : : {
52175 : 816 : if (TREE_USED (fndecl) || (!is_defn && DECL_SAVED_TREE (fndecl)))
52176 : : {
52177 : 9 : error_at (parser->oacc_routine->loc,
52178 : : TREE_USED (fndecl)
52179 : : ? G_("%<#pragma acc routine%> must be applied before"
52180 : : " use")
52181 : : : G_("%<#pragma acc routine%> must be applied before"
52182 : : " definition"));
52183 : 6 : parser->oacc_routine = NULL;
52184 : 6 : return;
52185 : : }
52186 : :
52187 : : /* Set the routine's level of parallelism. */
52188 : 578 : tree dims = oacc_build_routine_dims (parser->oacc_routine->clauses);
52189 : 578 : oacc_replace_fn_attrib (fndecl, dims);
52190 : :
52191 : : /* Add an "omp declare target" attribute. */
52192 : 578 : DECL_ATTRIBUTES (fndecl)
52193 : 1156 : = tree_cons (get_identifier ("omp declare target"),
52194 : 578 : parser->oacc_routine->clauses,
52195 : 578 : DECL_ATTRIBUTES (fndecl));
52196 : : }
52197 : : }
52198 : : }
52199 : :
52200 : : /* Main entry point to OpenMP statement pragmas. */
52201 : :
52202 : : static void
52203 : 31796 : cp_parser_omp_construct (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
52204 : : {
52205 : 31796 : tree stmt;
52206 : 31796 : char p_name[sizeof "#pragma omp teams distribute parallel for simd"];
52207 : 31796 : omp_clause_mask mask (0);
52208 : :
52209 : 31796 : unsigned int id = cp_parser_pragma_kind (pragma_tok);
52210 : 31796 : if (current_function_decl
52211 : 31796 : && DECL_DECLARED_CONSTEXPR_P (current_function_decl)
52212 : : && id >= PRAGMA_OMP__START_
52213 : 31796 : && id <= PRAGMA_OMP__LAST_)
52214 : : {
52215 : 0 : error_at (cp_lexer_peek_token (parser->lexer)->location,
52216 : : "OpenMP directives may not appear in %<constexpr%> functions");
52217 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
52218 : 3087 : return;
52219 : : }
52220 : 31796 : switch (id)
52221 : : {
52222 : 363 : case PRAGMA_OACC_ATOMIC:
52223 : 363 : cp_parser_omp_atomic (parser, pragma_tok, true);
52224 : 363 : return;
52225 : 678 : case PRAGMA_OACC_CACHE:
52226 : 678 : stmt = cp_parser_oacc_cache (parser, pragma_tok);
52227 : 678 : break;
52228 : 675 : case PRAGMA_OACC_DATA:
52229 : 675 : stmt = cp_parser_oacc_data (parser, pragma_tok, if_p);
52230 : 675 : break;
52231 : 321 : case PRAGMA_OACC_ENTER_DATA:
52232 : 321 : stmt = cp_parser_oacc_enter_exit_data (parser, pragma_tok, true);
52233 : 321 : break;
52234 : 318 : case PRAGMA_OACC_EXIT_DATA:
52235 : 318 : stmt = cp_parser_oacc_enter_exit_data (parser, pragma_tok, false);
52236 : 318 : break;
52237 : 61 : case PRAGMA_OACC_HOST_DATA:
52238 : 61 : stmt = cp_parser_oacc_host_data (parser, pragma_tok, if_p);
52239 : 61 : break;
52240 : 3928 : case PRAGMA_OACC_KERNELS:
52241 : 3928 : case PRAGMA_OACC_PARALLEL:
52242 : 3928 : case PRAGMA_OACC_SERIAL:
52243 : 3928 : strcpy (p_name, "#pragma acc");
52244 : 3928 : stmt = cp_parser_oacc_compute (parser, pragma_tok, p_name, if_p);
52245 : 3928 : break;
52246 : 3343 : case PRAGMA_OACC_LOOP:
52247 : 3343 : strcpy (p_name, "#pragma acc");
52248 : 3343 : stmt = cp_parser_oacc_loop (parser, pragma_tok, p_name, mask, NULL,
52249 : : if_p);
52250 : 3343 : break;
52251 : 192 : case PRAGMA_OACC_UPDATE:
52252 : 192 : stmt = cp_parser_oacc_update (parser, pragma_tok);
52253 : 192 : break;
52254 : 137 : case PRAGMA_OACC_WAIT:
52255 : 137 : stmt = cp_parser_oacc_wait (parser, pragma_tok);
52256 : 137 : break;
52257 : 0 : case PRAGMA_OMP_ALLOCATE:
52258 : 0 : cp_parser_omp_allocate (parser, pragma_tok);
52259 : 0 : return;
52260 : 2598 : case PRAGMA_OMP_ATOMIC:
52261 : 2598 : cp_parser_omp_atomic (parser, pragma_tok, false);
52262 : 2598 : return;
52263 : 264 : case PRAGMA_OMP_CRITICAL:
52264 : 264 : stmt = cp_parser_omp_critical (parser, pragma_tok, if_p);
52265 : 264 : break;
52266 : 1608 : case PRAGMA_OMP_DISTRIBUTE:
52267 : 1608 : strcpy (p_name, "#pragma omp");
52268 : 1608 : stmt = cp_parser_omp_distribute (parser, pragma_tok, p_name, mask, NULL,
52269 : : if_p);
52270 : 1608 : break;
52271 : 4058 : case PRAGMA_OMP_FOR:
52272 : 4058 : strcpy (p_name, "#pragma omp");
52273 : 4058 : stmt = cp_parser_omp_for (parser, pragma_tok, p_name, mask, NULL,
52274 : : if_p);
52275 : 4058 : break;
52276 : 479 : case PRAGMA_OMP_LOOP:
52277 : 479 : strcpy (p_name, "#pragma omp");
52278 : 479 : stmt = cp_parser_omp_loop (parser, pragma_tok, p_name, mask, NULL,
52279 : : if_p);
52280 : 479 : break;
52281 : 149 : case PRAGMA_OMP_MASKED:
52282 : 149 : strcpy (p_name, "#pragma omp");
52283 : 149 : stmt = cp_parser_omp_masked (parser, pragma_tok, p_name, mask, NULL,
52284 : : if_p);
52285 : 149 : break;
52286 : 328 : case PRAGMA_OMP_MASTER:
52287 : 328 : strcpy (p_name, "#pragma omp");
52288 : 328 : stmt = cp_parser_omp_master (parser, pragma_tok, p_name, mask, NULL,
52289 : : if_p);
52290 : 328 : break;
52291 : 4535 : case PRAGMA_OMP_PARALLEL:
52292 : 4535 : strcpy (p_name, "#pragma omp");
52293 : 4535 : stmt = cp_parser_omp_parallel (parser, pragma_tok, p_name, mask, NULL,
52294 : : if_p);
52295 : 4535 : break;
52296 : 102 : case PRAGMA_OMP_SCOPE:
52297 : 102 : stmt = cp_parser_omp_scope (parser, pragma_tok, if_p);
52298 : 102 : break;
52299 : 241 : case PRAGMA_OMP_SECTIONS:
52300 : 241 : strcpy (p_name, "#pragma omp");
52301 : 241 : stmt = cp_parser_omp_sections (parser, pragma_tok, p_name, mask, NULL);
52302 : 241 : break;
52303 : 990 : case PRAGMA_OMP_SIMD:
52304 : 990 : strcpy (p_name, "#pragma omp");
52305 : 990 : stmt = cp_parser_omp_simd (parser, pragma_tok, p_name, mask, NULL,
52306 : : if_p);
52307 : 990 : break;
52308 : 375 : case PRAGMA_OMP_SINGLE:
52309 : 375 : stmt = cp_parser_omp_single (parser, pragma_tok, if_p);
52310 : 375 : break;
52311 : 1966 : case PRAGMA_OMP_TASK:
52312 : 1966 : stmt = cp_parser_omp_task (parser, pragma_tok, if_p);
52313 : 1966 : break;
52314 : 292 : case PRAGMA_OMP_TASKGROUP:
52315 : 292 : stmt = cp_parser_omp_taskgroup (parser, pragma_tok, if_p);
52316 : 292 : break;
52317 : 581 : case PRAGMA_OMP_TASKLOOP:
52318 : 581 : strcpy (p_name, "#pragma omp");
52319 : 581 : stmt = cp_parser_omp_taskloop (parser, pragma_tok, p_name, mask, NULL,
52320 : : if_p);
52321 : 581 : break;
52322 : 2542 : case PRAGMA_OMP_TEAMS:
52323 : 2542 : strcpy (p_name, "#pragma omp");
52324 : 2542 : stmt = cp_parser_omp_teams (parser, pragma_tok, p_name, mask, NULL,
52325 : : if_p);
52326 : 2542 : break;
52327 : 126 : case PRAGMA_OMP_ASSUME:
52328 : 126 : cp_parser_omp_assume (parser, pragma_tok, if_p);
52329 : 126 : return;
52330 : 269 : case PRAGMA_OMP_TILE:
52331 : 269 : stmt = cp_parser_omp_tile (parser, pragma_tok, if_p);
52332 : 269 : break;
52333 : 277 : case PRAGMA_OMP_UNROLL:
52334 : 277 : stmt = cp_parser_omp_unroll (parser, pragma_tok, if_p);
52335 : 277 : break;
52336 : 0 : case PRAGMA_OMP_DISPATCH:
52337 : 0 : stmt = cp_parser_omp_dispatch (parser, pragma_tok);
52338 : 0 : break;
52339 : 0 : default:
52340 : 0 : gcc_unreachable ();
52341 : : }
52342 : :
52343 : 28709 : protected_set_expr_location (stmt, pragma_tok->location);
52344 : : }
52345 : :
52346 : : /* Transactional Memory parsing routines. */
52347 : :
52348 : : /* Parse a transaction attribute.
52349 : :
52350 : : txn-attribute:
52351 : : attribute
52352 : : [ [ identifier ] ]
52353 : :
52354 : : We use this instead of cp_parser_attributes_opt for transactions to avoid
52355 : : the pedwarn in C++98 mode. */
52356 : :
52357 : : static tree
52358 : 220 : cp_parser_txn_attribute_opt (cp_parser *parser)
52359 : : {
52360 : 220 : cp_token *token;
52361 : 220 : tree attr_name, attr = NULL;
52362 : :
52363 : 220 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
52364 : 6 : return cp_parser_attributes_opt (parser);
52365 : :
52366 : 214 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
52367 : : return NULL_TREE;
52368 : 21 : cp_lexer_consume_token (parser->lexer);
52369 : 21 : if (!cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE))
52370 : 0 : goto error1;
52371 : :
52372 : 21 : token = cp_lexer_peek_token (parser->lexer);
52373 : 21 : if (token->type == CPP_NAME || token->type == CPP_KEYWORD)
52374 : : {
52375 : 21 : token = cp_lexer_consume_token (parser->lexer);
52376 : :
52377 : 42 : attr_name = (token->type == CPP_KEYWORD
52378 : : /* For keywords, use the canonical spelling,
52379 : : not the parsed identifier. */
52380 : 21 : ? ridpointers[(int) token->keyword]
52381 : : : token->u.value);
52382 : 21 : attr = build_tree_list (attr_name, NULL_TREE);
52383 : : }
52384 : : else
52385 : 0 : cp_parser_error (parser, "expected identifier");
52386 : :
52387 : 21 : cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
52388 : 21 : error1:
52389 : 21 : cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
52390 : 21 : return attr;
52391 : : }
52392 : :
52393 : : /* Parse a __transaction_atomic or __transaction_relaxed statement.
52394 : :
52395 : : transaction-statement:
52396 : : __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
52397 : : compound-statement
52398 : : __transaction_relaxed txn-noexcept-spec[opt] compound-statement
52399 : : */
52400 : :
52401 : : static tree
52402 : 235 : cp_parser_transaction (cp_parser *parser, cp_token *token)
52403 : : {
52404 : 235 : unsigned char old_in = parser->in_transaction;
52405 : 235 : unsigned char this_in = 1, new_in;
52406 : 235 : enum rid keyword = token->keyword;
52407 : 235 : tree stmt, attrs, noex;
52408 : :
52409 : 235 : cp_lexer_consume_token (parser->lexer);
52410 : :
52411 : 235 : if (keyword == RID_TRANSACTION_RELAXED
52412 : 235 : || keyword == RID_SYNCHRONIZED)
52413 : : this_in |= TM_STMT_ATTR_RELAXED;
52414 : : else
52415 : : {
52416 : 187 : attrs = cp_parser_txn_attribute_opt (parser);
52417 : 187 : if (attrs)
52418 : 15 : this_in |= parse_tm_stmt_attr (attrs, TM_STMT_ATTR_OUTER);
52419 : : }
52420 : :
52421 : : /* Parse a noexcept specification. */
52422 : 187 : if (keyword == RID_ATOMIC_NOEXCEPT)
52423 : 3 : noex = boolean_true_node;
52424 : 232 : else if (keyword == RID_ATOMIC_CANCEL)
52425 : : {
52426 : : /* cancel-and-throw is unimplemented. */
52427 : 0 : sorry ("%<atomic_cancel%>");
52428 : 0 : noex = NULL_TREE;
52429 : : }
52430 : : else
52431 : 232 : noex = cp_parser_noexcept_specification_opt (parser,
52432 : : CP_PARSER_FLAGS_NONE,
52433 : : /*require_constexpr=*/true,
52434 : : /*consumed_expr=*/NULL,
52435 : : /*return_cond=*/true);
52436 : :
52437 : : /* Keep track if we're in the lexical scope of an outer transaction. */
52438 : 235 : new_in = this_in | (old_in & TM_STMT_ATTR_OUTER);
52439 : :
52440 : 235 : stmt = begin_transaction_stmt (token->location, NULL, this_in);
52441 : :
52442 : 235 : parser->in_transaction = new_in;
52443 : 235 : cp_parser_compound_statement (parser, NULL, BCS_TRANSACTION, false);
52444 : 235 : parser->in_transaction = old_in;
52445 : :
52446 : 235 : finish_transaction_stmt (stmt, NULL, this_in, noex);
52447 : :
52448 : 235 : return stmt;
52449 : : }
52450 : :
52451 : : /* Parse a __transaction_atomic or __transaction_relaxed expression.
52452 : :
52453 : : transaction-expression:
52454 : : __transaction_atomic txn-noexcept-spec[opt] ( expression )
52455 : : __transaction_relaxed txn-noexcept-spec[opt] ( expression )
52456 : : */
52457 : :
52458 : : static tree
52459 : 83 : cp_parser_transaction_expression (cp_parser *parser, enum rid keyword)
52460 : : {
52461 : 83 : unsigned char old_in = parser->in_transaction;
52462 : 83 : unsigned char this_in = 1;
52463 : 83 : cp_token *token;
52464 : 83 : tree expr, noex;
52465 : 83 : bool noex_expr;
52466 : 83 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
52467 : :
52468 : 83 : gcc_assert (keyword == RID_TRANSACTION_ATOMIC
52469 : : || keyword == RID_TRANSACTION_RELAXED);
52470 : :
52471 : 83 : if (!flag_tm)
52472 : 12 : error_at (loc,
52473 : : keyword == RID_TRANSACTION_RELAXED
52474 : : ? G_("%<__transaction_relaxed%> without transactional memory "
52475 : : "support enabled")
52476 : : : G_("%<__transaction_atomic%> without transactional memory "
52477 : : "support enabled"));
52478 : :
52479 : 87 : token = cp_parser_require_keyword (parser, keyword,
52480 : : (keyword == RID_TRANSACTION_ATOMIC ? RT_TRANSACTION_ATOMIC
52481 : : : RT_TRANSACTION_RELAXED));
52482 : 83 : gcc_assert (token != NULL);
52483 : :
52484 : 83 : if (keyword == RID_TRANSACTION_RELAXED)
52485 : 4 : this_in |= TM_STMT_ATTR_RELAXED;
52486 : :
52487 : : /* Set this early. This might mean that we allow transaction_cancel in
52488 : : an expression that we find out later actually has to be a constexpr.
52489 : : However, we expect that cxx_constant_value will be able to deal with
52490 : : this; also, if the noexcept has no constexpr, then what we parse next
52491 : : really is a transaction's body. */
52492 : 83 : parser->in_transaction = this_in;
52493 : :
52494 : : /* Parse a noexcept specification. */
52495 : 83 : noex = cp_parser_noexcept_specification_opt (parser,
52496 : : CP_PARSER_FLAGS_NONE,
52497 : : /*require_constexpr=*/false,
52498 : : &noex_expr,
52499 : : /*return_cond=*/true);
52500 : :
52501 : 57 : if (!noex || !noex_expr
52502 : 140 : || cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
52503 : : {
52504 : 71 : matching_parens parens;
52505 : 71 : parens.require_open (parser);
52506 : :
52507 : 71 : expr = cp_parser_expression (parser);
52508 : 71 : expr = finish_parenthesized_expr (expr);
52509 : :
52510 : 71 : parens.require_close (parser);
52511 : : }
52512 : : else
52513 : : {
52514 : : /* The only expression that is available got parsed for the noexcept
52515 : : already. noexcept is true then. */
52516 : 12 : expr = noex;
52517 : 12 : noex = boolean_true_node;
52518 : : }
52519 : :
52520 : 83 : expr = build_transaction_expr (token->location, expr, this_in, noex);
52521 : 83 : parser->in_transaction = old_in;
52522 : :
52523 : 83 : if (cp_parser_non_integral_constant_expression (parser, NIC_TRANSACTION))
52524 : 0 : return error_mark_node;
52525 : :
52526 : 83 : return (flag_tm ? expr : error_mark_node);
52527 : : }
52528 : :
52529 : : /* Parse a function-transaction-block.
52530 : :
52531 : : function-transaction-block:
52532 : : __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
52533 : : function-body
52534 : : __transaction_atomic txn-attribute[opt] function-try-block
52535 : : __transaction_relaxed ctor-initializer[opt] function-body
52536 : : __transaction_relaxed function-try-block
52537 : : */
52538 : :
52539 : : static void
52540 : 21 : cp_parser_function_transaction (cp_parser *parser, enum rid keyword)
52541 : : {
52542 : 21 : unsigned char old_in = parser->in_transaction;
52543 : 21 : unsigned char new_in = 1;
52544 : 21 : tree compound_stmt, stmt, attrs;
52545 : 21 : cp_token *token;
52546 : :
52547 : 21 : gcc_assert (keyword == RID_TRANSACTION_ATOMIC
52548 : : || keyword == RID_TRANSACTION_RELAXED);
52549 : 21 : token = cp_parser_require_keyword (parser, keyword,
52550 : : (keyword == RID_TRANSACTION_ATOMIC ? RT_TRANSACTION_ATOMIC
52551 : : : RT_TRANSACTION_RELAXED));
52552 : 21 : gcc_assert (token != NULL);
52553 : :
52554 : 21 : if (keyword == RID_TRANSACTION_RELAXED)
52555 : : new_in |= TM_STMT_ATTR_RELAXED;
52556 : : else
52557 : : {
52558 : 21 : attrs = cp_parser_txn_attribute_opt (parser);
52559 : 21 : if (attrs)
52560 : 12 : new_in |= parse_tm_stmt_attr (attrs, TM_STMT_ATTR_OUTER);
52561 : : }
52562 : :
52563 : 21 : stmt = begin_transaction_stmt (token->location, &compound_stmt, new_in);
52564 : :
52565 : 21 : parser->in_transaction = new_in;
52566 : :
52567 : 21 : if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
52568 : 12 : cp_parser_function_try_block (parser);
52569 : : else
52570 : 9 : cp_parser_ctor_initializer_opt_and_function_body
52571 : 9 : (parser, /*in_function_try_block=*/false);
52572 : :
52573 : 21 : parser->in_transaction = old_in;
52574 : :
52575 : 21 : finish_transaction_stmt (stmt, compound_stmt, new_in, NULL_TREE);
52576 : 21 : }
52577 : :
52578 : : /* Parse a __transaction_cancel statement.
52579 : :
52580 : : cancel-statement:
52581 : : __transaction_cancel txn-attribute[opt] ;
52582 : : __transaction_cancel txn-attribute[opt] throw-expression ;
52583 : :
52584 : : ??? Cancel and throw is not yet implemented. */
52585 : :
52586 : : static tree
52587 : 12 : cp_parser_transaction_cancel (cp_parser *parser)
52588 : : {
52589 : 12 : cp_token *token;
52590 : 12 : bool is_outer = false;
52591 : 12 : tree stmt, attrs;
52592 : :
52593 : 12 : token = cp_parser_require_keyword (parser, RID_TRANSACTION_CANCEL,
52594 : : RT_TRANSACTION_CANCEL);
52595 : 12 : gcc_assert (token != NULL);
52596 : :
52597 : 12 : attrs = cp_parser_txn_attribute_opt (parser);
52598 : 12 : if (attrs)
52599 : 0 : is_outer = (parse_tm_stmt_attr (attrs, TM_STMT_ATTR_OUTER) != 0);
52600 : :
52601 : : /* ??? Parse cancel-and-throw here. */
52602 : :
52603 : 12 : cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
52604 : :
52605 : 12 : if (!flag_tm)
52606 : : {
52607 : 6 : error_at (token->location, "%<__transaction_cancel%> without "
52608 : : "transactional memory support enabled");
52609 : 6 : return error_mark_node;
52610 : : }
52611 : 6 : else if (parser->in_transaction & TM_STMT_ATTR_RELAXED)
52612 : : {
52613 : 0 : error_at (token->location, "%<__transaction_cancel%> within a "
52614 : : "%<__transaction_relaxed%>");
52615 : 0 : return error_mark_node;
52616 : : }
52617 : 6 : else if (is_outer)
52618 : : {
52619 : 0 : if ((parser->in_transaction & TM_STMT_ATTR_OUTER) == 0
52620 : 0 : && !is_tm_may_cancel_outer (current_function_decl))
52621 : : {
52622 : 0 : error_at (token->location, "outer %<__transaction_cancel%> not "
52623 : : "within outer %<__transaction_atomic%>");
52624 : 0 : error_at (token->location,
52625 : : " or a %<transaction_may_cancel_outer%> function");
52626 : 0 : return error_mark_node;
52627 : : }
52628 : : }
52629 : 6 : else if (parser->in_transaction == 0)
52630 : : {
52631 : 0 : error_at (token->location, "%<__transaction_cancel%> not within "
52632 : : "%<__transaction_atomic%>");
52633 : 0 : return error_mark_node;
52634 : : }
52635 : :
52636 : 6 : stmt = build_tm_abort_call (token->location, is_outer);
52637 : 6 : add_stmt (stmt);
52638 : :
52639 : 6 : return stmt;
52640 : : }
52641 : :
52642 : :
52643 : : /* Special handling for the first token or line in the file. The first
52644 : : thing in the file might be #pragma GCC pch_preprocess, which loads a
52645 : : PCH file, which is a GC collection point. So we need to handle this
52646 : : first pragma without benefit of an existing lexer structure.
52647 : :
52648 : : Always returns one token to the caller in *FIRST_TOKEN. This is
52649 : : either the true first token of the file, or the first token after
52650 : : the initial pragma. */
52651 : :
52652 : : static void
52653 : 90748 : cp_parser_initial_pragma (cp_token *first_token)
52654 : : {
52655 : 90748 : if (cp_parser_pragma_kind (first_token) != PRAGMA_GCC_PCH_PREPROCESS)
52656 : : return;
52657 : :
52658 : 6 : cp_lexer_get_preprocessor_token (0, first_token);
52659 : :
52660 : 6 : tree name = NULL;
52661 : 6 : if (first_token->type == CPP_STRING)
52662 : : {
52663 : 6 : name = first_token->u.value;
52664 : :
52665 : 6 : cp_lexer_get_preprocessor_token (0, first_token);
52666 : : }
52667 : :
52668 : : /* Skip to the end of the pragma. */
52669 : 6 : if (first_token->type != CPP_PRAGMA_EOL)
52670 : : {
52671 : 0 : error_at (first_token->location,
52672 : : "malformed %<#pragma GCC pch_preprocess%>");
52673 : 0 : do
52674 : 0 : cp_lexer_get_preprocessor_token (0, first_token);
52675 : 0 : while (first_token->type != CPP_PRAGMA_EOL);
52676 : : }
52677 : :
52678 : : /* Now actually load the PCH file. */
52679 : 6 : if (name)
52680 : 6 : c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name));
52681 : :
52682 : : /* Read one more token to return to our caller. We have to do this
52683 : : after reading the PCH file in, since its pointers have to be
52684 : : live. */
52685 : 6 : cp_lexer_get_preprocessor_token (0, first_token);
52686 : : }
52687 : :
52688 : : /* Parse a pragma GCC ivdep. */
52689 : :
52690 : : static bool
52691 : 58 : cp_parser_pragma_ivdep (cp_parser *parser, cp_token *pragma_tok)
52692 : : {
52693 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
52694 : 58 : return true;
52695 : : }
52696 : :
52697 : : /* Parse a pragma GCC unroll. */
52698 : :
52699 : : static tree
52700 : 12641 : cp_parser_pragma_unroll (cp_parser *parser, cp_token *pragma_tok)
52701 : : {
52702 : 12641 : location_t location = cp_lexer_peek_token (parser->lexer)->location;
52703 : 12641 : tree unroll = cp_parser_constant_expression (parser);
52704 : 12641 : unroll = cp_check_pragma_unroll (location, fold_non_dependent_expr (unroll));
52705 : 12641 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
52706 : 12641 : return unroll;
52707 : : }
52708 : :
52709 : : /* Parse a pragma GCC novector. */
52710 : :
52711 : : static bool
52712 : 155 : cp_parser_pragma_novector (cp_parser *parser, cp_token *pragma_tok)
52713 : : {
52714 : 0 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
52715 : 155 : return true;
52716 : : }
52717 : :
52718 : : /* Normal parsing of a pragma token. Here we can (and must) use the
52719 : : regular lexer. */
52720 : :
52721 : : static bool
52722 : 5111171 : cp_parser_pragma (cp_parser *parser, enum pragma_context context, bool *if_p)
52723 : : {
52724 : 5111171 : cp_token *pragma_tok;
52725 : 5111171 : unsigned int id;
52726 : 5111171 : tree stmt;
52727 : 5111171 : bool ret = false;
52728 : :
52729 : 5111171 : pragma_tok = cp_lexer_consume_token (parser->lexer);
52730 : 5111171 : gcc_assert (pragma_tok->type == CPP_PRAGMA);
52731 : 5111171 : parser->lexer->in_pragma = true;
52732 : :
52733 : 5111171 : id = cp_parser_pragma_kind (pragma_tok);
52734 : 5111171 : if (parser->omp_for_parse_state
52735 : 39 : && parser->omp_for_parse_state->in_intervening_code
52736 : : && id >= PRAGMA_OMP__START_
52737 : 30 : && id <= PRAGMA_OMP__LAST_)
52738 : : {
52739 : 12 : error_at (pragma_tok->location,
52740 : : "intervening code must not contain OpenMP directives");
52741 : 12 : parser->omp_for_parse_state->fail = true;
52742 : 12 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
52743 : 12 : return false;
52744 : : }
52745 : 5111159 : if (current_function_decl
52746 : 399512 : && DECL_DECLARED_CONSTEXPR_P (current_function_decl)
52747 : : && id >= PRAGMA_OMP__START_
52748 : 5129300 : && id <= PRAGMA_OMP__LAST_)
52749 : : {
52750 : 46 : error_at (cp_lexer_peek_token (parser->lexer)->location,
52751 : : "OpenMP directives may not appear in %<constexpr%> functions");
52752 : 46 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
52753 : 46 : return false;
52754 : : }
52755 : :
52756 : 5111113 : if (id != PRAGMA_OMP_DECLARE && id != PRAGMA_OACC_ROUTINE)
52757 : 5106461 : cp_ensure_no_omp_declare_simd (parser);
52758 : 5111113 : switch (id)
52759 : : {
52760 : 3 : case PRAGMA_GCC_PCH_PREPROCESS:
52761 : 3 : error_at (pragma_tok->location,
52762 : : "%<#pragma GCC pch_preprocess%> must be first");
52763 : 3 : break;
52764 : :
52765 : 386 : case PRAGMA_OMP_BARRIER:
52766 : 386 : switch (context)
52767 : : {
52768 : 359 : case pragma_compound:
52769 : 359 : cp_parser_omp_barrier (parser, pragma_tok);
52770 : 359 : return false;
52771 : 27 : case pragma_stmt:
52772 : 27 : error_at (pragma_tok->location, "%<#pragma %s%> may only be "
52773 : : "used in compound statements", "omp barrier");
52774 : 27 : ret = true;
52775 : 27 : break;
52776 : 0 : default:
52777 : 0 : goto bad_stmt;
52778 : : }
52779 : 27 : break;
52780 : :
52781 : 302 : case PRAGMA_OMP_DEPOBJ:
52782 : 302 : switch (context)
52783 : : {
52784 : 296 : case pragma_compound:
52785 : 296 : cp_parser_omp_depobj (parser, pragma_tok);
52786 : 296 : return false;
52787 : 6 : case pragma_stmt:
52788 : 6 : error_at (pragma_tok->location, "%<#pragma %s%> may only be "
52789 : : "used in compound statements", "omp depobj");
52790 : 6 : ret = true;
52791 : 6 : break;
52792 : 0 : default:
52793 : 0 : goto bad_stmt;
52794 : : }
52795 : 6 : break;
52796 : :
52797 : 186 : case PRAGMA_OMP_FLUSH:
52798 : 186 : switch (context)
52799 : : {
52800 : 156 : case pragma_compound:
52801 : 156 : cp_parser_omp_flush (parser, pragma_tok);
52802 : 156 : return false;
52803 : 30 : case pragma_stmt:
52804 : 30 : error_at (pragma_tok->location, "%<#pragma %s%> may only be "
52805 : : "used in compound statements", "omp flush");
52806 : 30 : ret = true;
52807 : 30 : break;
52808 : 0 : default:
52809 : 0 : goto bad_stmt;
52810 : : }
52811 : 30 : break;
52812 : :
52813 : 345 : case PRAGMA_OMP_INTEROP:
52814 : 345 : switch (context)
52815 : : {
52816 : 345 : case pragma_compound:
52817 : 345 : cp_parser_omp_interop (parser, pragma_tok);
52818 : 345 : return false;
52819 : 0 : case pragma_stmt:
52820 : 0 : error_at (pragma_tok->location, "%<#pragma %s%> may only be "
52821 : : "used in compound statements", "omp interop");
52822 : 0 : ret = true;
52823 : 0 : break;
52824 : 0 : default:
52825 : 0 : goto bad_stmt;
52826 : : }
52827 : 0 : break;
52828 : :
52829 : 167 : case PRAGMA_OMP_TASKWAIT:
52830 : 167 : switch (context)
52831 : : {
52832 : 143 : case pragma_compound:
52833 : 143 : cp_parser_omp_taskwait (parser, pragma_tok);
52834 : 143 : return false;
52835 : 24 : case pragma_stmt:
52836 : 24 : error_at (pragma_tok->location,
52837 : : "%<#pragma %s%> may only be used in compound statements",
52838 : : "omp taskwait");
52839 : 24 : ret = true;
52840 : 24 : break;
52841 : 0 : default:
52842 : 0 : goto bad_stmt;
52843 : : }
52844 : 24 : break;
52845 : :
52846 : 40 : case PRAGMA_OMP_TASKYIELD:
52847 : 40 : switch (context)
52848 : : {
52849 : 16 : case pragma_compound:
52850 : 16 : cp_parser_omp_taskyield (parser, pragma_tok);
52851 : 16 : return false;
52852 : 24 : case pragma_stmt:
52853 : 24 : error_at (pragma_tok->location,
52854 : : "%<#pragma %s%> may only be used in compound statements",
52855 : : "omp taskyield");
52856 : 24 : ret = true;
52857 : 24 : break;
52858 : 0 : default:
52859 : 0 : goto bad_stmt;
52860 : : }
52861 : 24 : break;
52862 : :
52863 : 620 : case PRAGMA_OMP_CANCEL:
52864 : 620 : switch (context)
52865 : : {
52866 : 596 : case pragma_compound:
52867 : 596 : cp_parser_omp_cancel (parser, pragma_tok);
52868 : 596 : return false;
52869 : 24 : case pragma_stmt:
52870 : 24 : error_at (pragma_tok->location,
52871 : : "%<#pragma %s%> may only be used in compound statements",
52872 : : "omp cancel");
52873 : 24 : ret = true;
52874 : 24 : break;
52875 : 0 : default:
52876 : 0 : goto bad_stmt;
52877 : : }
52878 : 24 : break;
52879 : :
52880 : 530 : case PRAGMA_OMP_CANCELLATION_POINT:
52881 : 530 : return cp_parser_omp_cancellation_point (parser, pragma_tok, context);
52882 : :
52883 : 238 : case PRAGMA_OMP_THREADPRIVATE:
52884 : 238 : cp_parser_omp_threadprivate (parser, pragma_tok);
52885 : 238 : return false;
52886 : :
52887 : 3600 : case PRAGMA_OMP_DECLARE:
52888 : 3600 : return cp_parser_omp_declare (parser, pragma_tok, context);
52889 : :
52890 : 411 : case PRAGMA_OACC_DECLARE:
52891 : 411 : cp_parser_oacc_declare (parser, pragma_tok);
52892 : 411 : return false;
52893 : :
52894 : 330 : case PRAGMA_OACC_ENTER_DATA:
52895 : 330 : if (context == pragma_stmt)
52896 : : {
52897 : 9 : error_at (pragma_tok->location,
52898 : : "%<#pragma %s%> may only be used in compound statements",
52899 : : "acc enter data");
52900 : 9 : ret = true;
52901 : 9 : break;
52902 : : }
52903 : 321 : else if (context != pragma_compound)
52904 : 0 : goto bad_stmt;
52905 : 321 : cp_parser_omp_construct (parser, pragma_tok, if_p);
52906 : 321 : return true;
52907 : :
52908 : 327 : case PRAGMA_OACC_EXIT_DATA:
52909 : 327 : if (context == pragma_stmt)
52910 : : {
52911 : 9 : error_at (pragma_tok->location,
52912 : : "%<#pragma %s%> may only be used in compound statements",
52913 : : "acc exit data");
52914 : 9 : ret = true;
52915 : 9 : break;
52916 : : }
52917 : 318 : else if (context != pragma_compound)
52918 : 0 : goto bad_stmt;
52919 : 318 : cp_parser_omp_construct (parser, pragma_tok, if_p);
52920 : 318 : return true;
52921 : :
52922 : 1052 : case PRAGMA_OACC_ROUTINE:
52923 : 1052 : if (context != pragma_external)
52924 : : {
52925 : 12 : error_at (pragma_tok->location,
52926 : : "%<#pragma acc routine%> must be at file scope");
52927 : 12 : ret = true;
52928 : 12 : break;
52929 : : }
52930 : 1040 : cp_parser_oacc_routine (parser, pragma_tok, context);
52931 : 1040 : return false;
52932 : :
52933 : 204 : case PRAGMA_OACC_UPDATE:
52934 : 204 : if (context == pragma_stmt)
52935 : : {
52936 : 12 : error_at (pragma_tok->location,
52937 : : "%<#pragma %s%> may only be used in compound statements",
52938 : : "acc update");
52939 : 12 : ret = true;
52940 : 12 : break;
52941 : : }
52942 : 192 : else if (context != pragma_compound)
52943 : 0 : goto bad_stmt;
52944 : 192 : cp_parser_omp_construct (parser, pragma_tok, if_p);
52945 : 192 : return true;
52946 : :
52947 : 146 : case PRAGMA_OACC_WAIT:
52948 : 146 : if (context == pragma_stmt)
52949 : : {
52950 : 9 : error_at (pragma_tok->location,
52951 : : "%<#pragma %s%> may only be used in compound statements",
52952 : : "acc wait");
52953 : 9 : ret = true;
52954 : 9 : break;
52955 : : }
52956 : 137 : else if (context != pragma_compound)
52957 : 0 : goto bad_stmt;
52958 : 137 : cp_parser_omp_construct (parser, pragma_tok, if_p);
52959 : 137 : return true;
52960 : 120 : case PRAGMA_OMP_ALLOCATE:
52961 : 120 : cp_parser_omp_allocate (parser, pragma_tok);
52962 : 120 : return false;
52963 : 30834 : case PRAGMA_OACC_ATOMIC:
52964 : 30834 : case PRAGMA_OACC_CACHE:
52965 : 30834 : case PRAGMA_OACC_DATA:
52966 : 30834 : case PRAGMA_OACC_HOST_DATA:
52967 : 30834 : case PRAGMA_OACC_KERNELS:
52968 : 30834 : case PRAGMA_OACC_LOOP:
52969 : 30834 : case PRAGMA_OACC_PARALLEL:
52970 : 30834 : case PRAGMA_OACC_SERIAL:
52971 : 30834 : case PRAGMA_OMP_ASSUME:
52972 : 30834 : case PRAGMA_OMP_ATOMIC:
52973 : 30834 : case PRAGMA_OMP_CRITICAL:
52974 : 30834 : case PRAGMA_OMP_DISTRIBUTE:
52975 : 30834 : case PRAGMA_OMP_FOR:
52976 : 30834 : case PRAGMA_OMP_LOOP:
52977 : 30834 : case PRAGMA_OMP_MASKED:
52978 : 30834 : case PRAGMA_OMP_MASTER:
52979 : 30834 : case PRAGMA_OMP_PARALLEL:
52980 : 30834 : case PRAGMA_OMP_SCOPE:
52981 : 30834 : case PRAGMA_OMP_SECTIONS:
52982 : 30834 : case PRAGMA_OMP_SIMD:
52983 : 30834 : case PRAGMA_OMP_SINGLE:
52984 : 30834 : case PRAGMA_OMP_TASK:
52985 : 30834 : case PRAGMA_OMP_TASKGROUP:
52986 : 30834 : case PRAGMA_OMP_TASKLOOP:
52987 : 30834 : case PRAGMA_OMP_TEAMS:
52988 : 30834 : case PRAGMA_OMP_TILE:
52989 : 30834 : case PRAGMA_OMP_UNROLL:
52990 : 30834 : if (context != pragma_stmt && context != pragma_compound)
52991 : 6 : goto bad_stmt;
52992 : 30828 : stmt = push_omp_privatization_clauses (false);
52993 : 30828 : cp_parser_omp_construct (parser, pragma_tok, if_p);
52994 : 30828 : pop_omp_privatization_clauses (stmt);
52995 : 30828 : return true;
52996 : :
52997 : 179 : case PRAGMA_OMP_REQUIRES:
52998 : 179 : if (context != pragma_external)
52999 : : {
53000 : 24 : error_at (pragma_tok->location,
53001 : : "%<#pragma omp requires%> may only be used at file or "
53002 : : "namespace scope");
53003 : 24 : ret = true;
53004 : 24 : break;
53005 : : }
53006 : 155 : return cp_parser_omp_requires (parser, pragma_tok);
53007 : :
53008 : 114 : case PRAGMA_OMP_ASSUMES:
53009 : 114 : if (context != pragma_external)
53010 : : {
53011 : 3 : error_at (pragma_tok->location,
53012 : : "%<#pragma omp assumes%> may only be used at file or "
53013 : : "namespace scope");
53014 : 3 : ret = true;
53015 : 3 : break;
53016 : : }
53017 : 111 : return cp_parser_omp_assumes (parser, pragma_tok);
53018 : :
53019 : 51 : case PRAGMA_OMP_NOTHING:
53020 : 51 : cp_parser_omp_nothing (parser, pragma_tok);
53021 : 51 : return false;
53022 : :
53023 : 268 : case PRAGMA_OMP_ERROR:
53024 : 268 : return cp_parser_omp_error (parser, pragma_tok, context);
53025 : :
53026 : 1099 : case PRAGMA_OMP_ORDERED:
53027 : 1099 : if (context != pragma_stmt && context != pragma_compound)
53028 : 6 : goto bad_stmt;
53029 : 1093 : stmt = push_omp_privatization_clauses (false);
53030 : 1093 : ret = cp_parser_omp_ordered (parser, pragma_tok, context, if_p);
53031 : 1093 : pop_omp_privatization_clauses (stmt);
53032 : 1093 : return ret;
53033 : :
53034 : 10213 : case PRAGMA_OMP_TARGET:
53035 : 10213 : if (context != pragma_stmt && context != pragma_compound)
53036 : 6 : goto bad_stmt;
53037 : 10207 : stmt = push_omp_privatization_clauses (false);
53038 : 10207 : ret = cp_parser_omp_target (parser, pragma_tok, context, if_p);
53039 : 10207 : pop_omp_privatization_clauses (stmt);
53040 : 10207 : return ret;
53041 : :
53042 : 260 : case PRAGMA_OMP_BEGIN:
53043 : 260 : cp_parser_omp_begin (parser, pragma_tok);
53044 : 260 : return false;
53045 : :
53046 : 459 : case PRAGMA_OMP_END:
53047 : 459 : cp_parser_omp_end (parser, pragma_tok);
53048 : 459 : return false;
53049 : :
53050 : 78 : case PRAGMA_OMP_SCAN:
53051 : 78 : error_at (pragma_tok->location,
53052 : : "%<#pragma omp scan%> may only be used in "
53053 : : "a loop construct with %<inscan%> %<reduction%> clause");
53054 : 78 : break;
53055 : :
53056 : 21 : case PRAGMA_OMP_SECTION:
53057 : 21 : error_at (pragma_tok->location,
53058 : : "%<#pragma omp section%> may only be used in "
53059 : : "%<#pragma omp sections%> construct");
53060 : 21 : break;
53061 : :
53062 : 446 : case PRAGMA_OMP_DISPATCH:
53063 : 446 : cp_parser_omp_dispatch (parser, pragma_tok);
53064 : 446 : return true;
53065 : :
53066 : 12836 : case PRAGMA_IVDEP:
53067 : 12836 : case PRAGMA_UNROLL:
53068 : 12836 : case PRAGMA_NOVECTOR:
53069 : 12836 : {
53070 : 12836 : bool ivdep = false;
53071 : 12836 : tree unroll = NULL_TREE;
53072 : 12836 : bool novector = false;
53073 : 12836 : const char *pragma_str;
53074 : :
53075 : 12836 : switch (id)
53076 : : {
53077 : : case PRAGMA_IVDEP:
53078 : : pragma_str = "ivdep";
53079 : : break;
53080 : 12629 : case PRAGMA_UNROLL:
53081 : 12629 : pragma_str = "unroll";
53082 : 12629 : break;
53083 : 149 : case PRAGMA_NOVECTOR:
53084 : 149 : pragma_str = "novector";
53085 : 149 : break;
53086 : : default:
53087 : : gcc_unreachable ();
53088 : : }
53089 : :
53090 : 12836 : if (context == pragma_external)
53091 : : {
53092 : 6 : error_at (pragma_tok->location,
53093 : : "%<#pragma GCC %s%> must be inside a function",
53094 : : pragma_str);
53095 : 6 : break;
53096 : : }
53097 : :
53098 : : cp_token *tok = pragma_tok;
53099 : : bool has_more = true;
53100 : 25708 : do
53101 : : {
53102 : 12854 : switch (cp_parser_pragma_kind (tok))
53103 : : {
53104 : 58 : case PRAGMA_IVDEP:
53105 : 58 : {
53106 : 58 : if (tok != pragma_tok)
53107 : 6 : tok = cp_lexer_consume_token (parser->lexer);
53108 : 58 : ivdep = cp_parser_pragma_ivdep (parser, tok);
53109 : 58 : break;
53110 : : }
53111 : 12641 : case PRAGMA_UNROLL:
53112 : 12641 : {
53113 : 12641 : if (tok != pragma_tok)
53114 : 12 : tok = cp_lexer_consume_token (parser->lexer);
53115 : 12641 : unroll = cp_parser_pragma_unroll (parser, tok);
53116 : 12641 : break;
53117 : : }
53118 : 155 : case PRAGMA_NOVECTOR:
53119 : 155 : {
53120 : 155 : if (tok != pragma_tok)
53121 : 6 : tok = cp_lexer_consume_token (parser->lexer);
53122 : 155 : novector = cp_parser_pragma_novector (parser, tok);
53123 : 155 : break;
53124 : : }
53125 : : default:
53126 : : has_more = false;
53127 : : break;
53128 : : }
53129 : 12854 : tok = cp_lexer_peek_token (the_parser->lexer);
53130 : 25684 : has_more = has_more && tok->type == CPP_PRAGMA;
53131 : : }
53132 : : while (has_more);
53133 : :
53134 : 12830 : if (tok->type != CPP_KEYWORD
53135 : 12830 : || (tok->keyword != RID_FOR
53136 : 12434 : && tok->keyword != RID_WHILE
53137 : 12 : && tok->keyword != RID_DO))
53138 : : {
53139 : 0 : cp_parser_error (parser, "for, while or do statement expected");
53140 : 0 : return false;
53141 : : }
53142 : 12830 : cp_parser_iteration_statement (parser, if_p, ivdep, unroll, novector);
53143 : 12830 : return true;
53144 : : }
53145 : :
53146 : 5045248 : default:
53147 : 5045248 : gcc_assert (id >= PRAGMA_FIRST_EXTERNAL);
53148 : 5045248 : c_invoke_pragma_handler (id);
53149 : 5045248 : break;
53150 : :
53151 : 18 : bad_stmt:
53152 : 18 : cp_parser_error (parser, "expected declaration specifiers");
53153 : 18 : break;
53154 : : }
53155 : :
53156 : 5045587 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
53157 : 5045587 : return ret;
53158 : : }
53159 : :
53160 : : /* Helper for pragma_lex in preprocess-only mode; in this mode, we have not
53161 : : populated the lexer with any tokens (the tokens rather being read by
53162 : : c-ppoutput.c's machinery), so we need to read enough tokens now to handle
53163 : : a pragma. */
53164 : : static void
53165 : 23899 : maybe_read_tokens_for_pragma_lex ()
53166 : : {
53167 : 23899 : const auto lexer = the_parser->lexer;
53168 : 23899 : if (!lexer->buffer->is_empty ())
53169 : : return;
53170 : :
53171 : : /* Read the rest of the tokens comprising the pragma line. */
53172 : 40973 : cp_token *tok;
53173 : 40973 : do
53174 : : {
53175 : 40973 : tok = vec_safe_push (lexer->buffer, cp_token ());
53176 : 40973 : cp_lexer_get_preprocessor_token (C_LEX_STRING_NO_JOIN, tok);
53177 : 40973 : gcc_assert (tok->type != CPP_EOF);
53178 : 40973 : } while (tok->type != CPP_PRAGMA_EOL);
53179 : 17095 : lexer->next_token = lexer->buffer->address ();
53180 : 17095 : lexer->last_token = lexer->next_token + lexer->buffer->length () - 1;
53181 : : }
53182 : :
53183 : : /* The interface the pragma parsers have to the lexer. */
53184 : :
53185 : : enum cpp_ttype
53186 : 13964023 : pragma_lex (tree *value, location_t *loc)
53187 : : {
53188 : 13964023 : if (flag_preprocess_only)
53189 : 23899 : maybe_read_tokens_for_pragma_lex ();
53190 : :
53191 : 13964023 : cp_token *tok = cp_lexer_peek_token (the_parser->lexer);
53192 : 13964023 : enum cpp_ttype ret = tok->type;
53193 : :
53194 : 13964023 : *value = tok->u.value;
53195 : 13964023 : if (loc)
53196 : 13026997 : *loc = tok->location;
53197 : :
53198 : 13964023 : if (ret == CPP_PRAGMA_EOL)
53199 : : ret = CPP_EOF;
53200 : 13625707 : else if (ret == CPP_STRING)
53201 : 3444307 : *value = cp_parser_string_literal (the_parser, /*translate=*/false,
53202 : : /*wide_ok=*/false);
53203 : : else
53204 : : {
53205 : 10181400 : if (ret == CPP_KEYWORD)
53206 : 112051 : ret = CPP_NAME;
53207 : 10181400 : cp_lexer_consume_token (the_parser->lexer);
53208 : : }
53209 : :
53210 : 13964023 : return ret;
53211 : : }
53212 : :
53213 : : void
53214 : 17095 : pragma_lex_discard_to_eol ()
53215 : : {
53216 : : /* We have already read all the tokens, so we just need to discard
53217 : : them here. */
53218 : 17095 : const auto lexer = the_parser->lexer;
53219 : 17095 : lexer->next_token = lexer->last_token;
53220 : 17095 : lexer->buffer->truncate (0);
53221 : 17095 : }
53222 : :
53223 : :
53224 : : /* External interface. */
53225 : :
53226 : : /* Parse one entire translation unit. */
53227 : :
53228 : : void
53229 : 90780 : c_parse_file (void)
53230 : : {
53231 : 90780 : static bool already_called = false;
53232 : :
53233 : 90780 : if (already_called)
53234 : 0 : fatal_error (input_location,
53235 : : "multi-source compilation not implemented for C++");
53236 : 90780 : already_called = true;
53237 : :
53238 : : /* cp_lexer_new_main is called before doing any GC allocation
53239 : : because tokenization might load a PCH file. */
53240 : 90780 : cp_lexer_new_main ();
53241 : :
53242 : 90743 : cp_parser_translation_unit (the_parser);
53243 : 90658 : class_decl_loc_t::diag_mismatched_tags ();
53244 : :
53245 : 90658 : the_parser = NULL;
53246 : :
53247 : 90658 : finish_translation_unit ();
53248 : 90658 : }
53249 : :
53250 : : /* Create an identifier for a generic parameter type (a synthesized
53251 : : template parameter implied by `auto' or a concept identifier). */
53252 : :
53253 : : static GTY(()) int generic_parm_count;
53254 : : static tree
53255 : 349339 : make_generic_type_name ()
53256 : : {
53257 : 349339 : char buf[32];
53258 : 349339 : sprintf (buf, "auto:%d", ++generic_parm_count);
53259 : 349339 : return get_identifier (buf);
53260 : : }
53261 : :
53262 : : /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
53263 : : (creating a new template parameter list if necessary). Returns the newly
53264 : : created template type parm. */
53265 : :
53266 : : static tree
53267 : 349345 : synthesize_implicit_template_parm (cp_parser *parser, tree constr)
53268 : : {
53269 : : /* A requires-clause is not a function and cannot have placeholders. */
53270 : 349345 : if (current_binding_level->requires_expression)
53271 : : {
53272 : 6 : error ("placeholder type not allowed in this context");
53273 : 6 : return error_mark_node;
53274 : : }
53275 : :
53276 : 349339 : gcc_assert (current_binding_level->kind == sk_function_parms);
53277 : :
53278 : : /* We are either continuing a function template that already contains implicit
53279 : : template parameters, creating a new fully-implicit function template, or
53280 : : extending an existing explicit function template with implicit template
53281 : : parameters. */
53282 : :
53283 : 349339 : cp_binding_level *const entry_scope = current_binding_level;
53284 : :
53285 : 349339 : bool become_template = false;
53286 : 349339 : cp_binding_level *parent_scope = 0;
53287 : :
53288 : 349339 : if (parser->implicit_template_scope)
53289 : : {
53290 : 133987 : gcc_assert (parser->implicit_template_parms);
53291 : :
53292 : 133987 : current_binding_level = parser->implicit_template_scope;
53293 : : }
53294 : : else
53295 : : {
53296 : : /* Roll back to the existing template parameter scope (in the case of
53297 : : extending an explicit function template) or introduce a new template
53298 : : parameter scope ahead of the function parameter scope (or class scope
53299 : : in the case of out-of-line member definitions). The function scope is
53300 : : added back after template parameter synthesis below. */
53301 : :
53302 : : cp_binding_level *scope = entry_scope;
53303 : :
53304 : 430704 : while (scope->kind == sk_function_parms)
53305 : : {
53306 : 215352 : parent_scope = scope;
53307 : 215352 : scope = scope->level_chain;
53308 : : }
53309 : 430162 : if (current_class_type && !LAMBDA_TYPE_P (current_class_type))
53310 : : {
53311 : : /* If not defining a class, then any class scope is a scope level in
53312 : : an out-of-line member definition. In this case simply wind back
53313 : : beyond the first such scope to inject the template parameter list.
53314 : : Otherwise wind back to the class being defined. The latter can
53315 : : occur in class member friend declarations such as:
53316 : :
53317 : : class A {
53318 : : void foo (auto);
53319 : : };
53320 : : class B {
53321 : : friend void A::foo (auto);
53322 : : };
53323 : :
53324 : : The template parameter list synthesized for the friend declaration
53325 : : must be injected in the scope of 'B'. This can also occur in
53326 : : erroneous cases such as:
53327 : :
53328 : : struct A {
53329 : : struct B {
53330 : : void foo (auto);
53331 : : };
53332 : : void B::foo (auto) {}
53333 : : };
53334 : :
53335 : : Here the attempted definition of 'B::foo' within 'A' is ill-formed
53336 : : but, nevertheless, the template parameter list synthesized for the
53337 : : declarator should be injected into the scope of 'A' as if the
53338 : : ill-formed template was specified explicitly. */
53339 : :
53340 : 5972 : while (scope->kind == sk_class && !scope->defining_class_p)
53341 : : {
53342 : 76 : parent_scope = scope;
53343 : 76 : scope = scope->level_chain;
53344 : : }
53345 : : }
53346 : :
53347 : 215352 : current_binding_level = scope;
53348 : :
53349 : 215352 : if (scope->kind != sk_template_parms
53350 : 215352 : || !function_being_declared_is_template_p (parser))
53351 : : {
53352 : : /* Introduce a new template parameter list for implicit template
53353 : : parameters. */
53354 : :
53355 : 212166 : become_template = true;
53356 : :
53357 : 212166 : parser->implicit_template_scope
53358 : 212166 : = begin_scope (sk_template_parms, NULL);
53359 : :
53360 : 212166 : ++processing_template_decl;
53361 : :
53362 : 212166 : parser->fully_implicit_function_template_p = true;
53363 : 212166 : ++parser->num_template_parameter_lists;
53364 : : }
53365 : : else
53366 : : {
53367 : : /* Synthesize implicit template parameters at the end of the explicit
53368 : : template parameter list. */
53369 : :
53370 : 3186 : gcc_assert (current_template_parms);
53371 : :
53372 : 3186 : parser->implicit_template_scope = scope;
53373 : :
53374 : 3186 : tree v = INNERMOST_TEMPLATE_PARMS (current_template_parms);
53375 : 3186 : parser->implicit_template_parms
53376 : 3186 : = TREE_VEC_ELT (v, TREE_VEC_LENGTH (v) - 1);
53377 : : }
53378 : : }
53379 : :
53380 : : /* Synthesize a new template parameter and track the current template
53381 : : parameter chain with implicit_template_parms. */
53382 : :
53383 : 349339 : tree proto = constr ? DECL_INITIAL (constr) : NULL_TREE;
53384 : 349339 : tree synth_id = make_generic_type_name ();
53385 : 349339 : bool non_type = false;
53386 : :
53387 : : /* Synthesize the type template parameter. */
53388 : 349339 : gcc_assert(!proto || TREE_CODE (proto) == TYPE_DECL);
53389 : 349339 : tree synth_tmpl_parm = finish_template_type_parm (class_type_node, synth_id);
53390 : :
53391 : 349339 : if (become_template)
53392 : 212166 : current_template_parms = tree_cons (size_int (current_template_depth + 1),
53393 : : NULL_TREE, current_template_parms);
53394 : :
53395 : : /* Attach the constraint to the parm before processing. */
53396 : 349339 : tree node = build_tree_list (NULL_TREE, synth_tmpl_parm);
53397 : 349339 : TREE_TYPE (node) = constr;
53398 : 349339 : tree new_parm
53399 : 349339 : = process_template_parm (parser->implicit_template_parms,
53400 : : input_location,
53401 : : node,
53402 : : /*non_type=*/non_type,
53403 : : /*param_pack=*/false);
53404 : : // Process_template_parm returns the list of parms, and
53405 : : // parser->implicit_template_parms holds the final node of the parm
53406 : : // list. We really want to manipulate the newly appended element.
53407 : 349339 : gcc_checking_assert (!parser->implicit_template_parms
53408 : : || parser->implicit_template_parms == new_parm);
53409 : 349339 : if (parser->implicit_template_parms)
53410 : 137173 : new_parm = TREE_CHAIN (new_parm);
53411 : 349339 : gcc_checking_assert (!TREE_CHAIN (new_parm));
53412 : :
53413 : : // Record the last implicit parm node
53414 : 349339 : parser->implicit_template_parms = new_parm;
53415 : :
53416 : : /* Mark the synthetic declaration "virtual". This is used when
53417 : : comparing template-heads to determine if whether an abbreviated
53418 : : function template is equivalent to an explicit template.
53419 : :
53420 : : Note that DECL_ARTIFICIAL is used elsewhere for template
53421 : : parameters. */
53422 : 349339 : if (TREE_VALUE (new_parm) != error_mark_node)
53423 : 349339 : DECL_IMPLICIT_TEMPLATE_PARM_P (TREE_VALUE (new_parm)) = true;
53424 : :
53425 : 349339 : tree new_decl = get_local_decls ();
53426 : 349339 : if (non_type)
53427 : : /* Return the TEMPLATE_PARM_INDEX, not the PARM_DECL. */
53428 : : new_decl = DECL_INITIAL (new_decl);
53429 : :
53430 : : /* If creating a fully implicit function template, start the new implicit
53431 : : template parameter list with this synthesized type, otherwise grow the
53432 : : current template parameter list. */
53433 : :
53434 : 349339 : if (become_template)
53435 : : {
53436 : 212166 : parent_scope->level_chain = current_binding_level;
53437 : :
53438 : 212166 : tree new_parms = make_tree_vec (1);
53439 : 212166 : TREE_VEC_ELT (new_parms, 0) = parser->implicit_template_parms;
53440 : 212166 : TREE_VALUE (current_template_parms) = new_parms;
53441 : : }
53442 : : else
53443 : : {
53444 : 137173 : tree& new_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
53445 : 137173 : int new_parm_idx = TREE_VEC_LENGTH (new_parms);
53446 : 137173 : new_parms = grow_tree_vec (new_parms, new_parm_idx + 1);
53447 : 137173 : TREE_VEC_ELT (new_parms, new_parm_idx) = parser->implicit_template_parms;
53448 : : }
53449 : :
53450 : : /* If the new parameter was constrained, we need to add that to the
53451 : : constraints in the template parameter list. */
53452 : 349339 : if (tree req = TEMPLATE_PARM_CONSTRAINTS (new_parm))
53453 : : {
53454 : 5678 : tree reqs = TEMPLATE_PARMS_CONSTRAINTS (current_template_parms);
53455 : 5678 : reqs = combine_constraint_expressions (reqs, req);
53456 : 5678 : TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = reqs;
53457 : : }
53458 : :
53459 : 349339 : current_binding_level = entry_scope;
53460 : :
53461 : 349339 : return new_decl;
53462 : : }
53463 : :
53464 : : /* Finish the declaration of a fully implicit function template. Such a
53465 : : template has no explicit template parameter list so has not been through the
53466 : : normal template head and tail processing. synthesize_implicit_template_parm
53467 : : tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
53468 : : provided if the declaration is a class member such that its template
53469 : : declaration can be completed. If MEMBER_DECL_OPT is provided the finished
53470 : : form is returned. Otherwise NULL_TREE is returned. */
53471 : :
53472 : : static tree
53473 : 212166 : finish_fully_implicit_template (cp_parser *parser, tree member_decl_opt)
53474 : : {
53475 : 212166 : gcc_assert (parser->fully_implicit_function_template_p);
53476 : :
53477 : 211608 : if (member_decl_opt && member_decl_opt != error_mark_node
53478 : 423768 : && DECL_VIRTUAL_P (member_decl_opt))
53479 : : {
53480 : 3 : error_at (DECL_SOURCE_LOCATION (member_decl_opt),
53481 : : "implicit templates may not be %<virtual%>");
53482 : 3 : DECL_VIRTUAL_P (member_decl_opt) = false;
53483 : : }
53484 : :
53485 : 212166 : if (member_decl_opt)
53486 : 211608 : member_decl_opt = finish_member_template_decl (member_decl_opt);
53487 : 212166 : end_template_decl ();
53488 : :
53489 : 212166 : parser->fully_implicit_function_template_p = false;
53490 : 212166 : parser->implicit_template_parms = 0;
53491 : 212166 : parser->implicit_template_scope = 0;
53492 : 212166 : --parser->num_template_parameter_lists;
53493 : :
53494 : 212166 : return member_decl_opt;
53495 : : }
53496 : :
53497 : : /* Like finish_fully_implicit_template, but to be used in error
53498 : : recovery, rearranging scopes so that we restore the state we had
53499 : : before synthesize_implicit_template_parm inserted the implement
53500 : : template parms scope. */
53501 : :
53502 : : static void
53503 : 41 : abort_fully_implicit_template (cp_parser *parser)
53504 : : {
53505 : 41 : cp_binding_level *return_to_scope = current_binding_level;
53506 : :
53507 : 41 : if (parser->implicit_template_scope
53508 : 2 : && return_to_scope != parser->implicit_template_scope)
53509 : : {
53510 : 2 : cp_binding_level *child = return_to_scope;
53511 : 2 : for (cp_binding_level *scope = child->level_chain;
53512 : 2 : scope != parser->implicit_template_scope;
53513 : 0 : scope = child->level_chain)
53514 : 0 : child = scope;
53515 : 2 : child->level_chain = parser->implicit_template_scope->level_chain;
53516 : 2 : parser->implicit_template_scope->level_chain = return_to_scope;
53517 : 2 : current_binding_level = parser->implicit_template_scope;
53518 : 2 : }
53519 : : else
53520 : 39 : return_to_scope = return_to_scope->level_chain;
53521 : :
53522 : 41 : finish_fully_implicit_template (parser, NULL);
53523 : :
53524 : 41 : gcc_assert (current_binding_level == return_to_scope);
53525 : 41 : }
53526 : :
53527 : : /* Helper function for diagnostics that have complained about things
53528 : : being used with 'extern "C"' linkage.
53529 : :
53530 : : Attempt to issue a note showing where the 'extern "C"' linkage began. */
53531 : :
53532 : : void
53533 : 27 : maybe_show_extern_c_location (void)
53534 : : {
53535 : 27 : if (the_parser->innermost_linkage_specification_location != UNKNOWN_LOCATION)
53536 : 27 : inform (the_parser->innermost_linkage_specification_location,
53537 : : "%<extern \"C\"%> linkage started here");
53538 : 27 : }
53539 : :
53540 : : #include "gt-cp-parser.h"
|
