Branch data Line data Source code
1 : : /* Parser for C and Objective-C.
2 : : Copyright (C) 1987-2025 Free Software Foundation, Inc.
3 : :
4 : : Parser actions based on the old Bison parser; structure somewhat
5 : : influenced by and fragments based on the C++ parser.
6 : :
7 : : This file is part of GCC.
8 : :
9 : : GCC is free software; you can redistribute it and/or modify it under
10 : : the terms of the GNU General Public License as published by the Free
11 : : Software Foundation; either version 3, or (at your option) any later
12 : : version.
13 : :
14 : : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 : : WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 : : for more details.
18 : :
19 : : You should have received a copy of the GNU General Public License
20 : : along with GCC; see the file COPYING3. If not see
21 : : <http://www.gnu.org/licenses/>. */
22 : :
23 : : /* TODO:
24 : :
25 : : Make sure all relevant comments, and all relevant code from all
26 : : actions, brought over from old parser. Verify exact correspondence
27 : : of syntax accepted.
28 : :
29 : : Add testcases covering every input symbol in every state in old and
30 : : new parsers.
31 : :
32 : : Include full syntax for GNU C, including erroneous cases accepted
33 : : with error messages, in syntax productions in comments.
34 : :
35 : : Make more diagnostics in the front end generally take an explicit
36 : : location rather than implicitly using input_location. */
37 : :
38 : : #include "config.h"
39 : : #define INCLUDE_STRING
40 : : #include "system.h"
41 : : #include "coretypes.h"
42 : : #include "target.h"
43 : : #include "function.h"
44 : : #include "c-tree.h"
45 : : #include "timevar.h"
46 : : #include "stringpool.h"
47 : : #include "cgraph.h"
48 : : #include "attribs.h"
49 : : #include "stor-layout.h"
50 : : #include "varasm.h"
51 : : #include "trans-mem.h"
52 : : #include "c-family/c-pragma.h"
53 : : #include "c-lang.h"
54 : : #include "c-family/c-objc.h"
55 : : #include "plugin.h"
56 : : #include "omp-general.h"
57 : : #include "omp-offload.h"
58 : : #include "builtins.h"
59 : : #include "gomp-constants.h"
60 : : #include "c-family/c-indentation.h"
61 : : #include "gimple-expr.h"
62 : : #include "context.h"
63 : : #include "gcc-rich-location.h"
64 : : #include "c-parser.h"
65 : : #include "gimple-parser.h"
66 : : #include "read-rtl-function.h"
67 : : #include "run-rtl-passes.h"
68 : : #include "intl.h"
69 : : #include "c-family/name-hint.h"
70 : : #include "tree-iterator.h"
71 : : #include "tree-pretty-print.h"
72 : : #include "memmodel.h"
73 : : #include "c-family/known-headers.h"
74 : : #include "bitmap.h"
75 : : #include "analyzer/analyzer-language.h"
76 : : #include "toplev.h"
77 : : #include "asan.h"
78 : : #include "c-family/c-ubsan.h"
79 : : #include "gcc-urlifier.h"
80 : :
81 : : /* We need to walk over decls with incomplete struct/union/enum types
82 : : after parsing the whole translation unit.
83 : : In finish_decl(), if the decl is static, has incomplete
84 : : struct/union/enum type, it is appended to incomplete_record_decls.
85 : : In c_parser_translation_unit(), we iterate over incomplete_record_decls
86 : : and report error if any of the decls are still incomplete. */
87 : :
88 : : vec<tree> incomplete_record_decls;
89 : :
90 : : void
91 : 203271874 : set_c_expr_source_range (c_expr *expr,
92 : : location_t start, location_t finish)
93 : : {
94 : 203271874 : expr->src_range.m_start = start;
95 : 203271874 : expr->src_range.m_finish = finish;
96 : 203271874 : if (expr->value)
97 : 203271748 : set_source_range (expr->value, start, finish);
98 : 203271874 : }
99 : :
100 : : void
101 : 225655598 : set_c_expr_source_range (c_expr *expr,
102 : : source_range src_range)
103 : : {
104 : 225655598 : expr->src_range = src_range;
105 : 225655598 : if (expr->value)
106 : 225655593 : set_source_range (expr->value, src_range);
107 : 225655598 : }
108 : :
109 : :
110 : : /* Initialization routine for this file. */
111 : :
112 : : void
113 : 109855 : c_parse_init (void)
114 : : {
115 : : /* The only initialization required is of the reserved word
116 : : identifiers. */
117 : 109855 : unsigned int i;
118 : 109855 : tree id;
119 : 109855 : int mask = 0;
120 : :
121 : : /* Make sure RID_MAX hasn't grown past the 8 bits used to hold the keyword in
122 : : the c_token structure. */
123 : 109855 : gcc_assert (RID_MAX <= 255);
124 : :
125 : 109855 : mask |= D_CXXONLY;
126 : 109855 : if (!flag_isoc99)
127 : 6929 : mask |= D_C99;
128 : 109855 : if (!flag_isoc23)
129 : 13137 : mask |= D_C23;
130 : 109855 : if (flag_no_asm)
131 : : {
132 : 6113 : mask |= D_ASM | D_EXT;
133 : 6113 : if (!flag_isoc99)
134 : 3979 : mask |= D_EXT89;
135 : 6113 : if (!flag_isoc23)
136 : 5105 : mask |= D_EXT11;
137 : : }
138 : 109855 : if (!c_dialect_objc ())
139 : 109855 : mask |= D_OBJC | D_CXX_OBJC;
140 : :
141 : 109855 : ridpointers = ggc_cleared_vec_alloc<tree> ((int) RID_MAX);
142 : 25156795 : for (i = 0; i < num_c_common_reswords; i++)
143 : : {
144 : : /* If a keyword is disabled, do not enter it into the table
145 : : and so create a canonical spelling that isn't a keyword. */
146 : 25046940 : if (c_common_reswords[i].disable & mask)
147 : : {
148 : 9632502 : if (warn_cxx_compat
149 : 109615 : && (c_common_reswords[i].disable & D_CXXWARN))
150 : : {
151 : 51231 : id = get_identifier (c_common_reswords[i].word);
152 : 51231 : C_SET_RID_CODE (id, RID_CXX_COMPAT_WARN);
153 : 51231 : C_IS_RESERVED_WORD (id) = 1;
154 : : }
155 : 9632502 : continue;
156 : : }
157 : :
158 : 15414438 : id = get_identifier (c_common_reswords[i].word);
159 : 15414438 : C_SET_RID_CODE (id, c_common_reswords[i].rid);
160 : 15414438 : C_IS_RESERVED_WORD (id) = 1;
161 : 15414438 : ridpointers [(int) c_common_reswords[i].rid] = id;
162 : : }
163 : :
164 : 219710 : for (i = 0; i < NUM_INT_N_ENTS; i++)
165 : : {
166 : : /* We always create the symbols but they aren't always supported. */
167 : 109855 : char name[50];
168 : 109855 : sprintf (name, "__int%d", int_n_data[i].bitsize);
169 : 109855 : id = get_identifier (name);
170 : 109855 : C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
171 : 109855 : C_IS_RESERVED_WORD (id) = 1;
172 : :
173 : 109855 : sprintf (name, "__int%d__", int_n_data[i].bitsize);
174 : 109855 : id = get_identifier (name);
175 : 109855 : C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
176 : 109855 : C_IS_RESERVED_WORD (id) = 1;
177 : : }
178 : :
179 : 109855 : if (flag_openmp)
180 : : {
181 : 2167 : id = get_identifier ("omp_all_memory");
182 : 2167 : C_SET_RID_CODE (id, RID_OMP_ALL_MEMORY);
183 : 2167 : C_IS_RESERVED_WORD (id) = 1;
184 : 2167 : ridpointers [RID_OMP_ALL_MEMORY] = id;
185 : : }
186 : 109855 : }
187 : :
188 : : /* A parser structure recording information about the state and
189 : : context of parsing. Includes lexer information with up to two
190 : : tokens of look-ahead; more are not needed for C. */
191 : : struct GTY(()) c_parser {
192 : : /* The look-ahead tokens. */
193 : : c_token * GTY((skip)) tokens;
194 : : /* Buffer for look-ahead tokens. */
195 : : c_token tokens_buf[4];
196 : : /* How many look-ahead tokens are available (0 - 4, or
197 : : more if parsing from pre-lexed tokens). */
198 : : unsigned int tokens_avail;
199 : : /* Raw look-ahead tokens, used only for checking in Objective-C
200 : : whether '[[' starts attributes. */
201 : : vec<c_token, va_gc> *raw_tokens;
202 : : /* The number of raw look-ahead tokens that have since been fully
203 : : lexed. */
204 : : unsigned int raw_tokens_used;
205 : : /* True if a syntax error is being recovered from; false otherwise.
206 : : c_parser_error sets this flag. It should clear this flag when
207 : : enough tokens have been consumed to recover from the error. */
208 : : BOOL_BITFIELD error : 1;
209 : : /* True if we're processing a pragma, and shouldn't automatically
210 : : consume CPP_PRAGMA_EOL. */
211 : : BOOL_BITFIELD in_pragma : 1;
212 : : /* True if we're parsing the outermost block of an if statement. */
213 : : BOOL_BITFIELD in_if_block : 1;
214 : : /* True if we want to lex a translated, joined string (for an
215 : : initial #pragma pch_preprocess). Otherwise the parser is
216 : : responsible for concatenating strings and translating to the
217 : : execution character set as needed. */
218 : : BOOL_BITFIELD lex_joined_string : 1;
219 : : /* True if, when the parser is concatenating string literals, it
220 : : should translate them to the execution character set (false
221 : : inside attributes). */
222 : : BOOL_BITFIELD translate_strings_p : 1;
223 : :
224 : : /* Objective-C specific parser/lexer information. */
225 : :
226 : : /* True if we are in a context where the Objective-C "PQ" keywords
227 : : are considered keywords. */
228 : : BOOL_BITFIELD objc_pq_context : 1;
229 : : /* True if we are parsing a (potential) Objective-C foreach
230 : : statement. This is set to true after we parsed 'for (' and while
231 : : we wait for 'in' or ';' to decide if it's a standard C for loop or an
232 : : Objective-C foreach loop. */
233 : : BOOL_BITFIELD objc_could_be_foreach_context : 1;
234 : : /* The following flag is needed to contextualize Objective-C lexical
235 : : analysis. In some cases (e.g., 'int NSObject;'), it is
236 : : undesirable to bind an identifier to an Objective-C class, even
237 : : if a class with that name exists. */
238 : : BOOL_BITFIELD objc_need_raw_identifier : 1;
239 : : /* Nonzero if we're processing a __transaction statement. The value
240 : : is 1 | TM_STMT_ATTR_*. */
241 : : unsigned int in_transaction : 4;
242 : : /* True if we are in a context where the Objective-C "Property attribute"
243 : : keywords are valid. */
244 : : BOOL_BITFIELD objc_property_attr_context : 1;
245 : :
246 : : /* Whether we have just seen/constructed a string-literal. Set when
247 : : returning a string-literal from c_parser_string_literal. Reset
248 : : in consume_token. Useful when we get a parse error and see an
249 : : unknown token, which could have been a string-literal constant
250 : : macro. */
251 : : BOOL_BITFIELD seen_string_literal : 1;
252 : :
253 : : /* TRUE if omp::directive, omp::decl or omp::sequence attributes may not
254 : : appear. */
255 : : BOOL_BITFIELD omp_attrs_forbidden_p : 1;
256 : :
257 : : /* Location of the last consumed token. */
258 : : location_t last_token_location;
259 : :
260 : : /* Holds state for parsing collapsed OMP_FOR loops. Managed by
261 : : c_parser_omp_for_loop. */
262 : : struct omp_for_parse_data * GTY((skip)) omp_for_parse_state;
263 : :
264 : : /* If we're in the context of OpenMP directives written as C23
265 : : attributes turned into pragma, the tokens field is temporarily
266 : : redirected. This holds data needed to restore state afterwards.
267 : : It's NULL otherwise. */
268 : : struct omp_attribute_pragma_state *in_omp_attribute_pragma;
269 : :
270 : : /* Set for omp::decl attribute parsing to the decl to which it
271 : : appertains. */
272 : : tree in_omp_decl_attribute;
273 : :
274 : : /* Non-null only when parsing the body of an OpenMP metadirective.
275 : : Managed by c_parser_omp_metadirective. */
276 : : struct omp_metadirective_parse_data * GTY((skip))
277 : : omp_metadirective_state;
278 : : };
279 : :
280 : : /* Holds data needed to restore the token stream to its previous state
281 : : after parsing an OpenMP attribute-syntax pragma. */
282 : : struct GTY(()) omp_attribute_pragma_state
283 : : {
284 : : vec<c_token, va_gc> *token_vec;
285 : : c_token * GTY((skip)) save_tokens;
286 : : unsigned int save_tokens_avail;
287 : : };
288 : :
289 : : /* Return a pointer to the Nth token in PARSERs tokens_buf. */
290 : :
291 : : c_token *
292 : 197 : c_parser_tokens_buf (c_parser *parser, unsigned n)
293 : : {
294 : 197 : return &parser->tokens_buf[n];
295 : : }
296 : :
297 : : /* Return the error state of PARSER. */
298 : :
299 : : bool
300 : 4891 : c_parser_error (c_parser *parser)
301 : : {
302 : 4891 : return parser->error;
303 : : }
304 : :
305 : : /* Set the error state of PARSER to ERR. */
306 : :
307 : : void
308 : 0 : c_parser_set_error (c_parser *parser, bool err)
309 : : {
310 : 0 : parser->error = err;
311 : 0 : }
312 : :
313 : :
314 : : /* The actual parser and external interface. ??? Does this need to be
315 : : garbage-collected? */
316 : :
317 : : static GTY (()) c_parser *the_parser;
318 : :
319 : : /* Read in and lex a single token, storing it in *TOKEN. If RAW,
320 : : context-sensitive postprocessing of the token is not done. */
321 : :
322 : : static void
323 : 2263842631 : c_lex_one_token (c_parser *parser, c_token *token, bool raw = false)
324 : : {
325 : 2263842631 : timevar_push (TV_LEX);
326 : :
327 : 2263842631 : if (raw || vec_safe_length (parser->raw_tokens) == 0)
328 : : {
329 : 2263782067 : token->type = c_lex_with_flags (&token->value, &token->location,
330 : : &token->flags,
331 : 2263782067 : (parser->lex_joined_string
332 : : ? 0 : C_LEX_STRING_NO_JOIN));
333 : 2263781914 : token->id_kind = C_ID_NONE;
334 : 2263781914 : token->keyword = RID_MAX;
335 : 2263781914 : token->pragma_kind = PRAGMA_NONE;
336 : : }
337 : : else
338 : : {
339 : : /* Use a token previously lexed as a raw look-ahead token, and
340 : : complete the processing on it. */
341 : 60564 : *token = (*parser->raw_tokens)[parser->raw_tokens_used];
342 : 60564 : ++parser->raw_tokens_used;
343 : 60564 : if (parser->raw_tokens_used == vec_safe_length (parser->raw_tokens))
344 : : {
345 : 14060 : vec_free (parser->raw_tokens);
346 : 14060 : parser->raw_tokens_used = 0;
347 : : }
348 : : }
349 : :
350 : 2263842478 : if (raw)
351 : 60564 : goto out;
352 : :
353 : 2263781914 : switch (token->type)
354 : : {
355 : 1018762668 : case CPP_NAME:
356 : 1018762668 : {
357 : 1018762668 : tree decl;
358 : :
359 : 1018762668 : bool objc_force_identifier = parser->objc_need_raw_identifier;
360 : 1018762668 : if (c_dialect_objc ())
361 : 0 : parser->objc_need_raw_identifier = false;
362 : :
363 : 1018762668 : if (C_IS_RESERVED_WORD (token->value))
364 : : {
365 : 283173020 : enum rid rid_code = C_RID_CODE (token->value);
366 : :
367 : 283173020 : if (rid_code == RID_CXX_COMPAT_WARN)
368 : : {
369 : 35 : warning_at (token->location,
370 : 35 : OPT_Wc___compat,
371 : : "identifier %qE conflicts with C++ keyword",
372 : : token->value);
373 : : }
374 : 283172985 : else if (rid_code >= RID_FIRST_ADDR_SPACE
375 : 283172985 : && rid_code <= RID_LAST_ADDR_SPACE)
376 : : {
377 : 174 : addr_space_t as;
378 : 174 : as = (addr_space_t) (rid_code - RID_FIRST_ADDR_SPACE);
379 : 174 : targetm.addr_space.diagnose_usage (as, token->location);
380 : 174 : token->id_kind = C_ID_ADDRSPACE;
381 : 174 : token->keyword = rid_code;
382 : 174 : break;
383 : : }
384 : 283172811 : else if (c_dialect_objc () && OBJC_IS_PQ_KEYWORD (rid_code))
385 : : {
386 : : /* We found an Objective-C "pq" keyword (in, out,
387 : : inout, bycopy, byref, oneway). They need special
388 : : care because the interpretation depends on the
389 : : context. */
390 : 0 : if (parser->objc_pq_context)
391 : : {
392 : 0 : token->type = CPP_KEYWORD;
393 : 0 : token->keyword = rid_code;
394 : 0 : break;
395 : : }
396 : 0 : else if (parser->objc_could_be_foreach_context
397 : 0 : && rid_code == RID_IN)
398 : : {
399 : : /* We are in Objective-C, inside a (potential)
400 : : foreach context (which means after having
401 : : parsed 'for (', but before having parsed ';'),
402 : : and we found 'in'. We consider it the keyword
403 : : which terminates the declaration at the
404 : : beginning of a foreach-statement. Note that
405 : : this means you can't use 'in' for anything else
406 : : in that context; in particular, in Objective-C
407 : : you can't use 'in' as the name of the running
408 : : variable in a C for loop. We could potentially
409 : : try to add code here to disambiguate, but it
410 : : seems a reasonable limitation. */
411 : 0 : token->type = CPP_KEYWORD;
412 : 0 : token->keyword = rid_code;
413 : 0 : break;
414 : : }
415 : : /* Else, "pq" keywords outside of the "pq" context are
416 : : not keywords, and we fall through to the code for
417 : : normal tokens. */
418 : : }
419 : 283172811 : else if (c_dialect_objc () && OBJC_IS_PATTR_KEYWORD (rid_code))
420 : : {
421 : : /* We found an Objective-C "property attribute"
422 : : keyword (getter, setter, readonly, etc). These are
423 : : only valid in the property context. */
424 : 0 : if (parser->objc_property_attr_context)
425 : : {
426 : 0 : token->type = CPP_KEYWORD;
427 : 0 : token->keyword = rid_code;
428 : 0 : break;
429 : : }
430 : : /* Else they are not special keywords.
431 : : */
432 : : }
433 : 283172811 : else if (c_dialect_objc ()
434 : 0 : && (OBJC_IS_AT_KEYWORD (rid_code)
435 : : || OBJC_IS_CXX_KEYWORD (rid_code)))
436 : : {
437 : : /* We found one of the Objective-C "@" keywords (defs,
438 : : selector, synchronized, etc) or one of the
439 : : Objective-C "cxx" keywords (class, private,
440 : : protected, public, try, catch, throw) without a
441 : : preceding '@' sign. Do nothing and fall through to
442 : : the code for normal tokens (in C++ we would still
443 : : consider the CXX ones keywords, but not in C). */
444 : : ;
445 : : }
446 : : else
447 : : {
448 : 283172811 : token->type = CPP_KEYWORD;
449 : 283172811 : token->keyword = rid_code;
450 : 283172811 : break;
451 : : }
452 : : }
453 : :
454 : 735589683 : decl = lookup_name (token->value);
455 : 735589683 : if (decl)
456 : : {
457 : 411685933 : if (TREE_CODE (decl) == TYPE_DECL)
458 : : {
459 : 239613676 : token->id_kind = C_ID_TYPENAME;
460 : 239613676 : break;
461 : : }
462 : : }
463 : 323903750 : else if (c_dialect_objc ())
464 : : {
465 : 0 : tree objc_interface_decl = objc_is_class_name (token->value);
466 : : /* Objective-C class names are in the same namespace as
467 : : variables and typedefs, and hence are shadowed by local
468 : : declarations. */
469 : 0 : if (objc_interface_decl
470 : 0 : && (!objc_force_identifier || global_bindings_p ()))
471 : : {
472 : 0 : token->value = objc_interface_decl;
473 : 0 : token->id_kind = C_ID_CLASSNAME;
474 : 0 : break;
475 : : }
476 : : }
477 : 495976007 : token->id_kind = C_ID_ID;
478 : : }
479 : 495976007 : break;
480 : 0 : case CPP_AT_NAME:
481 : : /* This only happens in Objective-C; it must be a keyword. */
482 : 0 : token->type = CPP_KEYWORD;
483 : 0 : switch (C_RID_CODE (token->value))
484 : : {
485 : : /* Replace 'class' with '@class', 'private' with '@private',
486 : : etc. This prevents confusion with the C++ keyword
487 : : 'class', and makes the tokens consistent with other
488 : : Objective-C 'AT' keywords. For example '@class' is
489 : : reported as RID_AT_CLASS which is consistent with
490 : : '@synchronized', which is reported as
491 : : RID_AT_SYNCHRONIZED.
492 : : */
493 : 0 : case RID_CLASS: token->keyword = RID_AT_CLASS; break;
494 : 0 : case RID_PRIVATE: token->keyword = RID_AT_PRIVATE; break;
495 : 0 : case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
496 : 0 : case RID_PUBLIC: token->keyword = RID_AT_PUBLIC; break;
497 : 0 : case RID_THROW: token->keyword = RID_AT_THROW; break;
498 : 0 : case RID_TRY: token->keyword = RID_AT_TRY; break;
499 : 0 : case RID_CATCH: token->keyword = RID_AT_CATCH; break;
500 : 0 : case RID_SYNCHRONIZED: token->keyword = RID_AT_SYNCHRONIZED; break;
501 : 0 : default: token->keyword = C_RID_CODE (token->value);
502 : : }
503 : : break;
504 : 682454426 : case CPP_COLON:
505 : 682454426 : case CPP_COMMA:
506 : 682454426 : case CPP_CLOSE_PAREN:
507 : 682454426 : case CPP_SEMICOLON:
508 : : /* These tokens may affect the interpretation of any identifiers
509 : : following, if doing Objective-C. */
510 : 682454426 : if (c_dialect_objc ())
511 : 0 : parser->objc_need_raw_identifier = false;
512 : : break;
513 : 1948735 : case CPP_PRAGMA:
514 : : /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
515 : 1948735 : token->pragma_kind = (enum pragma_kind) TREE_INT_CST_LOW (token->value);
516 : 1948735 : token->value = NULL;
517 : 1948735 : break;
518 : : default:
519 : : break;
520 : : }
521 : 2263842478 : out:
522 : 2263842478 : timevar_pop (TV_LEX);
523 : 2263842478 : }
524 : :
525 : : /* Return a pointer to the next token from PARSER, reading it in if
526 : : necessary. */
527 : :
528 : : c_token *
529 : 17248927158 : c_parser_peek_token (c_parser *parser)
530 : : {
531 : 17248927158 : if (parser->tokens_avail == 0)
532 : : {
533 : 1855723375 : c_lex_one_token (parser, &parser->tokens[0]);
534 : 1855723222 : parser->tokens_avail = 1;
535 : : }
536 : 17248927005 : return &parser->tokens[0];
537 : : }
538 : :
539 : : /* Return a pointer to the next-but-one token from PARSER, reading it
540 : : in if necessary. The next token is already read in. */
541 : :
542 : : c_token *
543 : 177775161 : c_parser_peek_2nd_token (c_parser *parser)
544 : : {
545 : 177775161 : if (parser->tokens_avail >= 2)
546 : 30014516 : return &parser->tokens[1];
547 : 147760645 : gcc_assert (parser->tokens_avail == 1);
548 : 147760645 : gcc_assert (parser->tokens[0].type != CPP_EOF);
549 : 147760645 : gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL);
550 : 147760645 : c_lex_one_token (parser, &parser->tokens[1]);
551 : 147760645 : parser->tokens_avail = 2;
552 : 147760645 : return &parser->tokens[1];
553 : : }
554 : :
555 : : /* Return a pointer to the Nth token from PARSER, reading it
556 : : in if necessary. The N-1th token is already read in. */
557 : :
558 : : c_token *
559 : 874196885 : c_parser_peek_nth_token (c_parser *parser, unsigned int n)
560 : : {
561 : : /* N is 1-based, not zero-based. */
562 : 874196885 : gcc_assert (n > 0);
563 : :
564 : 874196885 : if (parser->tokens_avail >= n)
565 : 613898838 : return &parser->tokens[n - 1];
566 : 260298047 : gcc_assert (parser->tokens_avail == n - 1);
567 : 260298047 : c_lex_one_token (parser, &parser->tokens[n - 1]);
568 : 260298047 : parser->tokens_avail = n;
569 : 260298047 : return &parser->tokens[n - 1];
570 : : }
571 : :
572 : : /* Return a pointer to the Nth token from PARSER, reading it in as a
573 : : raw look-ahead token if necessary. The N-1th token is already read
574 : : in. Raw look-ahead tokens remain available for when the non-raw
575 : : functions above are called. */
576 : :
577 : : c_token *
578 : 87621 : c_parser_peek_nth_token_raw (c_parser *parser, unsigned int n)
579 : : {
580 : : /* N is 1-based, not zero-based. */
581 : 87621 : gcc_assert (n > 0);
582 : :
583 : 87621 : if (parser->tokens_avail >= n)
584 : 10300 : return &parser->tokens[n - 1];
585 : 77321 : unsigned int raw_len = vec_safe_length (parser->raw_tokens);
586 : 77321 : unsigned int raw_avail
587 : 77321 : = parser->tokens_avail + raw_len - parser->raw_tokens_used;
588 : 77321 : gcc_assert (raw_avail >= n - 1);
589 : 77321 : if (raw_avail >= n)
590 : 16757 : return &(*parser->raw_tokens)[parser->raw_tokens_used
591 : 16757 : + n - 1 - parser->tokens_avail];
592 : 60564 : vec_safe_reserve (parser->raw_tokens, 1);
593 : 60564 : parser->raw_tokens->quick_grow (raw_len + 1);
594 : 60564 : c_lex_one_token (parser, &(*parser->raw_tokens)[raw_len], true);
595 : 60564 : return &(*parser->raw_tokens)[raw_len];
596 : : }
597 : :
598 : : bool
599 : 43698041 : c_keyword_starts_typename (enum rid keyword)
600 : : {
601 : 43698041 : switch (keyword)
602 : : {
603 : : case RID_UNSIGNED:
604 : : case RID_LONG:
605 : : case RID_SHORT:
606 : : case RID_SIGNED:
607 : : case RID_COMPLEX:
608 : : case RID_INT:
609 : : case RID_CHAR:
610 : : case RID_FLOAT:
611 : : case RID_DOUBLE:
612 : : case RID_VOID:
613 : : case RID_DFLOAT32:
614 : : case RID_DFLOAT64:
615 : : case RID_DFLOAT128:
616 : : case RID_DFLOAT64X:
617 : : CASE_RID_FLOATN_NX:
618 : : case RID_BOOL:
619 : : case RID_BITINT:
620 : : case RID_ENUM:
621 : : case RID_STRUCT:
622 : : case RID_UNION:
623 : : case RID_TYPEOF:
624 : : case RID_TYPEOF_UNQUAL:
625 : : case RID_CONST:
626 : : case RID_ATOMIC:
627 : : case RID_VOLATILE:
628 : : case RID_RESTRICT:
629 : : case RID_ATTRIBUTE:
630 : : case RID_FRACT:
631 : : case RID_ACCUM:
632 : : case RID_SAT:
633 : : case RID_AUTO_TYPE:
634 : : case RID_ALIGNAS:
635 : : return true;
636 : 35770310 : default:
637 : 35770310 : if (keyword >= RID_FIRST_INT_N
638 : : && keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS
639 : 497 : && int_n_enabled_p[keyword - RID_FIRST_INT_N])
640 : : return true;
641 : : return false;
642 : : }
643 : : }
644 : :
645 : : /* Return true if TOKEN can start a type name,
646 : : false otherwise. */
647 : : bool
648 : 437248317 : c_token_starts_typename (c_token *token)
649 : : {
650 : 437248317 : switch (token->type)
651 : : {
652 : 387108315 : case CPP_NAME:
653 : 387108315 : switch (token->id_kind)
654 : : {
655 : : case C_ID_ID:
656 : : return false;
657 : : case C_ID_ADDRSPACE:
658 : : return true;
659 : : case C_ID_TYPENAME:
660 : : return true;
661 : 0 : case C_ID_CLASSNAME:
662 : 0 : gcc_assert (c_dialect_objc ());
663 : : return true;
664 : 0 : default:
665 : 0 : gcc_unreachable ();
666 : : }
667 : 43643549 : case CPP_KEYWORD:
668 : 43643549 : return c_keyword_starts_typename (token->keyword);
669 : 0 : case CPP_LESS:
670 : 0 : if (c_dialect_objc ())
671 : : return true;
672 : : return false;
673 : : default:
674 : : return false;
675 : : }
676 : : }
677 : :
678 : : /* Return true if the next token from PARSER can start a type name,
679 : : false otherwise. LA specifies how to do lookahead in order to
680 : : detect unknown type names. If unsure, pick CLA_PREFER_ID. */
681 : :
682 : : static inline bool
683 : 311508489 : c_parser_next_tokens_start_typename (c_parser *parser, enum c_lookahead_kind la)
684 : : {
685 : 311508489 : c_token *token = c_parser_peek_token (parser);
686 : 311508489 : if (c_token_starts_typename (token))
687 : : return true;
688 : :
689 : : /* Try a bit harder to detect an unknown typename. */
690 : 68178256 : if (la != cla_prefer_id
691 : 43354839 : && token->type == CPP_NAME
692 : 6353872 : && token->id_kind == C_ID_ID
693 : :
694 : : /* Do not try too hard when we could have "object in array". */
695 : 6353872 : && !parser->objc_could_be_foreach_context
696 : :
697 : 6353872 : && (la == cla_prefer_type
698 : 6353779 : || c_parser_peek_2nd_token (parser)->type == CPP_NAME
699 : 6353695 : || c_parser_peek_2nd_token (parser)->type == CPP_MULT)
700 : :
701 : : /* Only unknown identifiers. */
702 : 68179690 : && !lookup_name (token->value))
703 : : return true;
704 : :
705 : : return false;
706 : : }
707 : :
708 : : /* Return true if TOKEN, after an open parenthesis, can start a
709 : : compound literal (either a storage class specifier allowed in that
710 : : context, or a type name), false otherwise. */
711 : : static bool
712 : 125736123 : c_token_starts_compound_literal (c_token *token)
713 : : {
714 : 125736123 : switch (token->type)
715 : : {
716 : 4434020 : case CPP_KEYWORD:
717 : 4434020 : switch (token->keyword)
718 : : {
719 : : case RID_CONSTEXPR:
720 : : case RID_REGISTER:
721 : : case RID_STATIC:
722 : : case RID_THREAD:
723 : : return true;
724 : : default:
725 : : break;
726 : : }
727 : : /* Fall through. */
728 : 125735822 : default:
729 : 125735822 : return c_token_starts_typename (token);
730 : : }
731 : : }
732 : :
733 : : /* Return true if TOKEN is a type qualifier, false otherwise. */
734 : : static bool
735 : 426559952 : c_token_is_qualifier (c_token *token)
736 : : {
737 : 426559952 : switch (token->type)
738 : : {
739 : 422792733 : case CPP_NAME:
740 : 422792733 : switch (token->id_kind)
741 : : {
742 : : case C_ID_ADDRSPACE:
743 : : return true;
744 : : default:
745 : : return false;
746 : : }
747 : 3767219 : case CPP_KEYWORD:
748 : 3767219 : switch (token->keyword)
749 : : {
750 : : case RID_CONST:
751 : : case RID_VOLATILE:
752 : : case RID_RESTRICT:
753 : : case RID_ATTRIBUTE:
754 : : case RID_ATOMIC:
755 : : return true;
756 : : default:
757 : : return false;
758 : : }
759 : : case CPP_LESS:
760 : : return false;
761 : 0 : default:
762 : 0 : gcc_unreachable ();
763 : : }
764 : : }
765 : :
766 : : /* Return true if the next token from PARSER is a type qualifier,
767 : : false otherwise. */
768 : : static inline bool
769 : 426559952 : c_parser_next_token_is_qualifier (c_parser *parser)
770 : : {
771 : 426559952 : c_token *token = c_parser_peek_token (parser);
772 : 426559952 : return c_token_is_qualifier (token);
773 : : }
774 : :
775 : : /* Return true if TOKEN can start declaration specifiers (not
776 : : including standard attributes), false otherwise. */
777 : : static bool
778 : 172040021 : c_token_starts_declspecs (c_token *token)
779 : : {
780 : 172040021 : switch (token->type)
781 : : {
782 : 95834874 : case CPP_NAME:
783 : 95834874 : switch (token->id_kind)
784 : : {
785 : : case C_ID_ID:
786 : : return false;
787 : : case C_ID_ADDRSPACE:
788 : : return true;
789 : : case C_ID_TYPENAME:
790 : : return true;
791 : 0 : case C_ID_CLASSNAME:
792 : 0 : gcc_assert (c_dialect_objc ());
793 : : return true;
794 : 0 : default:
795 : 0 : gcc_unreachable ();
796 : : }
797 : 74548446 : case CPP_KEYWORD:
798 : 74548446 : switch (token->keyword)
799 : : {
800 : : case RID_STATIC:
801 : : case RID_EXTERN:
802 : : case RID_REGISTER:
803 : : case RID_TYPEDEF:
804 : : case RID_INLINE:
805 : : case RID_NORETURN:
806 : : case RID_AUTO:
807 : : case RID_THREAD:
808 : : case RID_UNSIGNED:
809 : : case RID_LONG:
810 : : case RID_SHORT:
811 : : case RID_SIGNED:
812 : : case RID_COMPLEX:
813 : : case RID_INT:
814 : : case RID_CHAR:
815 : : case RID_FLOAT:
816 : : case RID_DOUBLE:
817 : : case RID_VOID:
818 : : case RID_DFLOAT32:
819 : : case RID_DFLOAT64:
820 : : case RID_DFLOAT128:
821 : : case RID_DFLOAT64X:
822 : : CASE_RID_FLOATN_NX:
823 : : case RID_BOOL:
824 : : case RID_BITINT:
825 : : case RID_ENUM:
826 : : case RID_STRUCT:
827 : : case RID_UNION:
828 : : case RID_TYPEOF:
829 : : case RID_TYPEOF_UNQUAL:
830 : : case RID_CONST:
831 : : case RID_VOLATILE:
832 : : case RID_RESTRICT:
833 : : case RID_ATTRIBUTE:
834 : : case RID_FRACT:
835 : : case RID_ACCUM:
836 : : case RID_SAT:
837 : : case RID_ALIGNAS:
838 : : case RID_ATOMIC:
839 : : case RID_AUTO_TYPE:
840 : : case RID_CONSTEXPR:
841 : : return true;
842 : 35429860 : default:
843 : 35429860 : if (token->keyword >= RID_FIRST_INT_N
844 : : && token->keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS
845 : 413 : && int_n_enabled_p[token->keyword - RID_FIRST_INT_N])
846 : : return true;
847 : : return false;
848 : : }
849 : 2 : case CPP_LESS:
850 : 2 : if (c_dialect_objc ())
851 : : return true;
852 : : return false;
853 : : default:
854 : : return false;
855 : : }
856 : : }
857 : :
858 : :
859 : : /* Return true if TOKEN can start declaration specifiers (not
860 : : including standard attributes) or a static assertion, false
861 : : otherwise. */
862 : : static bool
863 : 49933644 : c_token_starts_declaration (c_token *token)
864 : : {
865 : 49933644 : if (c_token_starts_declspecs (token)
866 : 49933644 : || token->keyword == RID_STATIC_ASSERT)
867 : 7498625 : return true;
868 : : else
869 : : return false;
870 : : }
871 : :
872 : : /* Return true if the next token from PARSER can start declaration
873 : : specifiers (not including standard attributes), false
874 : : otherwise. */
875 : : bool
876 : 122106377 : c_parser_next_token_starts_declspecs (c_parser *parser)
877 : : {
878 : 122106377 : c_token *token = c_parser_peek_token (parser);
879 : :
880 : : /* In Objective-C, a classname normally starts a declspecs unless it
881 : : is immediately followed by a dot. In that case, it is the
882 : : Objective-C 2.0 "dot-syntax" for class objects, ie, calls the
883 : : setter/getter on the class. c_token_starts_declspecs() can't
884 : : differentiate between the two cases because it only checks the
885 : : current token, so we have a special check here. */
886 : 122106377 : if (c_dialect_objc ()
887 : 0 : && token->type == CPP_NAME
888 : 0 : && token->id_kind == C_ID_CLASSNAME
889 : 122106377 : && c_parser_peek_2nd_token (parser)->type == CPP_DOT)
890 : : return false;
891 : :
892 : 122106377 : return c_token_starts_declspecs (token);
893 : : }
894 : :
895 : : /* Return true if the next tokens from PARSER can start declaration
896 : : specifiers (not including standard attributes) or a static
897 : : assertion, false otherwise. */
898 : : bool
899 : 49932882 : c_parser_next_tokens_start_declaration (c_parser *parser)
900 : : {
901 : 49932882 : c_token *token = c_parser_peek_token (parser);
902 : :
903 : : /* Same as above. */
904 : 49932882 : if (c_dialect_objc ()
905 : 0 : && token->type == CPP_NAME
906 : 0 : && token->id_kind == C_ID_CLASSNAME
907 : 49932882 : && c_parser_peek_2nd_token (parser)->type == CPP_DOT)
908 : : return false;
909 : :
910 : : /* Labels do not start declarations. */
911 : 49932882 : if (token->type == CPP_NAME
912 : 49932882 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
913 : : return false;
914 : :
915 : 49932864 : if (c_token_starts_declaration (token))
916 : : return true;
917 : :
918 : 42434310 : if (c_parser_next_tokens_start_typename (parser, cla_nonabstract_decl))
919 : : return true;
920 : :
921 : : return false;
922 : : }
923 : :
924 : : /* Consume the next token from PARSER. */
925 : :
926 : : void
927 : 2261771596 : c_parser_consume_token (c_parser *parser)
928 : : {
929 : 2261771596 : gcc_assert (parser->tokens_avail >= 1);
930 : 2261771596 : gcc_assert (parser->tokens[0].type != CPP_EOF);
931 : 2261771596 : gcc_assert (!parser->in_pragma || parser->tokens[0].type != CPP_PRAGMA_EOL);
932 : 2261771596 : gcc_assert (parser->error || parser->tokens[0].type != CPP_PRAGMA);
933 : 2261771596 : parser->last_token_location = parser->tokens[0].location;
934 : 2261771596 : if (parser->tokens != &parser->tokens_buf[0])
935 : 42643 : parser->tokens++;
936 : 2261728953 : else if (parser->tokens_avail >= 2)
937 : : {
938 : 148924407 : parser->tokens[0] = parser->tokens[1];
939 : 148924407 : if (parser->tokens_avail >= 3)
940 : : {
941 : 32881 : parser->tokens[1] = parser->tokens[2];
942 : 32881 : if (parser->tokens_avail >= 4)
943 : 12572 : parser->tokens[2] = parser->tokens[3];
944 : : }
945 : : }
946 : 2261771596 : parser->tokens_avail--;
947 : 2261771596 : parser->seen_string_literal = false;
948 : 2261771596 : }
949 : :
950 : : /* Expect the current token to be a #pragma. Consume it and remember
951 : : that we've begun parsing a pragma. */
952 : :
953 : : static void
954 : 1949557 : c_parser_consume_pragma (c_parser *parser)
955 : : {
956 : 1949557 : gcc_assert (!parser->in_pragma);
957 : 1949557 : gcc_assert (parser->tokens_avail >= 1);
958 : 1949557 : gcc_assert (parser->tokens[0].type == CPP_PRAGMA);
959 : 1949557 : if (parser->tokens != &parser->tokens_buf[0])
960 : 932 : parser->tokens++;
961 : 1948625 : else if (parser->tokens_avail >= 2)
962 : : {
963 : 204 : parser->tokens[0] = parser->tokens[1];
964 : 204 : if (parser->tokens_avail >= 3)
965 : 0 : parser->tokens[1] = parser->tokens[2];
966 : : }
967 : 1949557 : parser->tokens_avail--;
968 : 1949557 : parser->in_pragma = true;
969 : 1949557 : }
970 : :
971 : : /* Update the global input_location from TOKEN. */
972 : : static inline void
973 : 7951976 : c_parser_set_source_position_from_token (c_token *token)
974 : : {
975 : 7951976 : if (token->type != CPP_EOF)
976 : : {
977 : 7951900 : input_location = token->location;
978 : : }
979 : : }
980 : :
981 : : /* Helper function for c_parser_error.
982 : : Having peeked a token of kind TOK1_KIND that might signify
983 : : a conflict marker, peek successor tokens to determine
984 : : if we actually do have a conflict marker.
985 : : Specifically, we consider a run of 7 '<', '=' or '>' characters
986 : : at the start of a line as a conflict marker.
987 : : These come through the lexer as three pairs and a single,
988 : : e.g. three CPP_LSHIFT ("<<") and a CPP_LESS ('<').
989 : : If it returns true, *OUT_LOC is written to with the location/range
990 : : of the marker. */
991 : :
992 : : static bool
993 : 30 : c_parser_peek_conflict_marker (c_parser *parser, enum cpp_ttype tok1_kind,
994 : : location_t *out_loc)
995 : : {
996 : 30 : c_token *token2 = c_parser_peek_2nd_token (parser);
997 : 30 : if (token2->type != tok1_kind)
998 : : return false;
999 : 25 : c_token *token3 = c_parser_peek_nth_token (parser, 3);
1000 : 25 : if (token3->type != tok1_kind)
1001 : : return false;
1002 : 22 : c_token *token4 = c_parser_peek_nth_token (parser, 4);
1003 : 22 : if (token4->type != conflict_marker_get_final_tok_kind (tok1_kind))
1004 : : return false;
1005 : :
1006 : : /* It must be at the start of the line. */
1007 : 15 : location_t start_loc = c_parser_peek_token (parser)->location;
1008 : 15 : if (LOCATION_COLUMN (start_loc) != 1)
1009 : : return false;
1010 : :
1011 : : /* We have a conflict marker. Construct a location of the form:
1012 : : <<<<<<<
1013 : : ^~~~~~~
1014 : : with start == caret, finishing at the end of the marker. */
1015 : 12 : location_t finish_loc = get_finish (token4->location);
1016 : 12 : *out_loc = make_location (start_loc, start_loc, finish_loc);
1017 : :
1018 : 12 : return true;
1019 : : }
1020 : :
1021 : : /* Issue a diagnostic of the form
1022 : : FILE:LINE: MESSAGE before TOKEN
1023 : : where TOKEN is the next token in the input stream of PARSER.
1024 : : MESSAGE (specified by the caller) is usually of the form "expected
1025 : : OTHER-TOKEN".
1026 : :
1027 : : Use RICHLOC as the location of the diagnostic.
1028 : :
1029 : : Do not issue a diagnostic if still recovering from an error.
1030 : :
1031 : : Return true iff an error was actually emitted.
1032 : :
1033 : : ??? This is taken from the C++ parser, but building up messages in
1034 : : this way is not i18n-friendly and some other approach should be
1035 : : used. */
1036 : :
1037 : : static bool
1038 : 3034 : c_parser_error_richloc (c_parser *parser, const char *gmsgid,
1039 : : rich_location *richloc)
1040 : : {
1041 : 3034 : c_token *token = c_parser_peek_token (parser);
1042 : 3034 : if (parser->error)
1043 : : return false;
1044 : 2319 : parser->error = true;
1045 : 2319 : if (!gmsgid)
1046 : : return false;
1047 : :
1048 : : /* If this is actually a conflict marker, report it as such. */
1049 : 2203 : if (token->type == CPP_LSHIFT
1050 : 2203 : || token->type == CPP_RSHIFT
1051 : 2184 : || token->type == CPP_EQ_EQ)
1052 : : {
1053 : 30 : location_t loc;
1054 : 30 : if (c_parser_peek_conflict_marker (parser, token->type, &loc))
1055 : : {
1056 : 12 : error_at (loc, "version control conflict marker in file");
1057 : 12 : return true;
1058 : : }
1059 : : }
1060 : :
1061 : : /* If we were parsing a string-literal and there is an unknown name
1062 : : token right after, then check to see if that could also have been
1063 : : a literal string by checking the name against a list of known
1064 : : standard string literal constants defined in header files. If
1065 : : there is one, then add that as an hint to the error message. */
1066 : 2191 : auto_diagnostic_group d;
1067 : 2191 : name_hint h;
1068 : 2191 : if (parser->seen_string_literal && token->type == CPP_NAME)
1069 : : {
1070 : 16 : tree name = token->value;
1071 : 16 : const char *token_name = IDENTIFIER_POINTER (name);
1072 : 16 : const char *header_hint
1073 : 16 : = get_c_stdlib_header_for_string_macro_name (token_name);
1074 : 16 : if (header_hint != NULL)
1075 : 48 : h = name_hint (nullptr,
1076 : : std::make_unique<suggest_missing_header>
1077 : 32 : (token->location,
1078 : : token_name,
1079 : 16 : header_hint));
1080 : : }
1081 : :
1082 : 2191 : c_parse_error (gmsgid,
1083 : : /* Because c_parse_error does not understand
1084 : : CPP_KEYWORD, keywords are treated like
1085 : : identifiers. */
1086 : 2191 : (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
1087 : : /* ??? The C parser does not save the cpp flags of a
1088 : : token, we need to pass 0 here and we will not get
1089 : : the source spelling of some tokens but rather the
1090 : : canonical spelling. */
1091 : : token->value, /*flags=*/0, richloc);
1092 : 2191 : return true;
1093 : 2191 : }
1094 : :
1095 : : /* As c_parser_error_richloc, but issue the message at the
1096 : : location of PARSER's next token, or at input_location
1097 : : if the next token is EOF. */
1098 : :
1099 : : bool
1100 : 1925 : c_parser_error (c_parser *parser, const char *gmsgid)
1101 : : {
1102 : 1925 : c_token *token = c_parser_peek_token (parser);
1103 : 1925 : c_parser_set_source_position_from_token (token);
1104 : 1925 : rich_location richloc (line_table, input_location);
1105 : 1925 : return c_parser_error_richloc (parser, gmsgid, &richloc);
1106 : 1925 : }
1107 : :
1108 : : /* Some tokens naturally come in pairs e.g.'(' and ')'.
1109 : : This class is for tracking such a matching pair of symbols.
1110 : : In particular, it tracks the location of the first token,
1111 : : so that if the second token is missing, we can highlight the
1112 : : location of the first token when notifying the user about the
1113 : : problem. */
1114 : :
1115 : : template <typename traits_t>
1116 : : class token_pair
1117 : : {
1118 : : public:
1119 : : /* token_pair's ctor. */
1120 : 172654347 : token_pair () : m_open_loc (UNKNOWN_LOCATION) {}
1121 : :
1122 : : /* If the next token is the opening symbol for this pair, consume it and
1123 : : return true.
1124 : : Otherwise, issue an error and return false.
1125 : : In either case, record the location of the opening token. */
1126 : :
1127 : 4440600 : bool require_open (c_parser *parser)
1128 : : {
1129 : 4440600 : c_token *token = c_parser_peek_token (parser);
1130 : 4440600 : if (token)
1131 : 4440600 : m_open_loc = token->location;
1132 : :
1133 : 4440600 : return c_parser_require (parser, traits_t::open_token_type,
1134 : 4440600 : traits_t::open_gmsgid);
1135 : : }
1136 : :
1137 : : /* Consume the next token from PARSER, recording its location as
1138 : : that of the opening token within the pair. */
1139 : :
1140 : 168213885 : void consume_open (c_parser *parser)
1141 : : {
1142 : 168213885 : c_token *token = c_parser_peek_token (parser);
1143 : 168213885 : gcc_assert (token->type == traits_t::open_token_type);
1144 : 168213885 : m_open_loc = token->location;
1145 : 168213885 : c_parser_consume_token (parser);
1146 : 168213885 : }
1147 : :
1148 : : /* If the next token is the closing symbol for this pair, consume it
1149 : : and return true.
1150 : : Otherwise, issue an error, highlighting the location of the
1151 : : corresponding opening token, and return false. */
1152 : :
1153 : 1755214 : bool require_close (c_parser *parser) const
1154 : : {
1155 : 1755214 : return c_parser_require (parser, traits_t::close_token_type,
1156 : 1755214 : traits_t::close_gmsgid, m_open_loc);
1157 : : }
1158 : :
1159 : : /* Like token_pair::require_close, except that tokens will be skipped
1160 : : until the desired token is found. An error message is still produced
1161 : : if the next token is not as expected. */
1162 : :
1163 : 169531055 : void skip_until_found_close (c_parser *parser) const
1164 : : {
1165 : 169531055 : c_parser_skip_until_found (parser, traits_t::close_token_type,
1166 : 169531055 : traits_t::close_gmsgid, m_open_loc);
1167 : 48427 : }
1168 : :
1169 : : private:
1170 : : location_t m_open_loc;
1171 : : };
1172 : :
1173 : : /* Traits for token_pair<T> for tracking matching pairs of parentheses. */
1174 : :
1175 : : struct matching_paren_traits
1176 : : {
1177 : : static const enum cpp_ttype open_token_type = CPP_OPEN_PAREN;
1178 : : static const char * const open_gmsgid;
1179 : : static const enum cpp_ttype close_token_type = CPP_CLOSE_PAREN;
1180 : : static const char * const close_gmsgid;
1181 : : };
1182 : :
1183 : : const char * const matching_paren_traits::open_gmsgid = "expected %<(%>";
1184 : : const char * const matching_paren_traits::close_gmsgid = "expected %<)%>";
1185 : :
1186 : : /* "matching_parens" is a token_pair<T> class for tracking matching
1187 : : pairs of parentheses. */
1188 : :
1189 : : typedef token_pair<matching_paren_traits> matching_parens;
1190 : :
1191 : : /* Traits for token_pair<T> for tracking matching pairs of braces. */
1192 : :
1193 : : struct matching_brace_traits
1194 : : {
1195 : : static const enum cpp_ttype open_token_type = CPP_OPEN_BRACE;
1196 : : static const char * const open_gmsgid;
1197 : : static const enum cpp_ttype close_token_type = CPP_CLOSE_BRACE;
1198 : : static const char * const close_gmsgid;
1199 : : };
1200 : :
1201 : : const char * const matching_brace_traits::open_gmsgid = "expected %<{%>";
1202 : : const char * const matching_brace_traits::close_gmsgid = "expected %<}%>";
1203 : :
1204 : : /* "matching_braces" is a token_pair<T> class for tracking matching
1205 : : pairs of braces. */
1206 : :
1207 : : typedef token_pair<matching_brace_traits> matching_braces;
1208 : :
1209 : : /* Get a description of the matching symbol to TYPE e.g. "(" for
1210 : : CPP_CLOSE_PAREN. */
1211 : :
1212 : : static const char *
1213 : 4 : get_matching_symbol (enum cpp_ttype type)
1214 : : {
1215 : 4 : switch (type)
1216 : : {
1217 : 0 : default:
1218 : 0 : gcc_unreachable ();
1219 : : case CPP_CLOSE_PAREN:
1220 : : return "(";
1221 : 1 : case CPP_CLOSE_BRACE:
1222 : 1 : return "{";
1223 : : }
1224 : : }
1225 : :
1226 : : /* If the next token is of the indicated TYPE, consume it. Otherwise,
1227 : : issue the error MSGID. If MSGID is NULL then a message has already
1228 : : been produced and no message will be produced this time. Returns
1229 : : true if found, false otherwise.
1230 : :
1231 : : If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
1232 : : within any error as the location of an "opening" token matching
1233 : : the close token TYPE (e.g. the location of the '(' when TYPE is
1234 : : CPP_CLOSE_PAREN).
1235 : :
1236 : : If TYPE_IS_UNIQUE is true (the default) then msgid describes exactly
1237 : : one type (e.g. "expected %<)%>") and thus it may be reasonable to
1238 : : attempt to generate a fix-it hint for the problem.
1239 : : Otherwise msgid describes multiple token types (e.g.
1240 : : "expected %<;%>, %<,%> or %<)%>"), and thus we shouldn't attempt to
1241 : : generate a fix-it hint. */
1242 : :
1243 : : bool
1244 : 442206913 : c_parser_require (c_parser *parser,
1245 : : enum cpp_ttype type,
1246 : : const char *msgid,
1247 : : location_t matching_location,
1248 : : bool type_is_unique)
1249 : : {
1250 : 442206913 : if (c_parser_next_token_is (parser, type))
1251 : : {
1252 : 442205804 : c_parser_consume_token (parser);
1253 : 442205804 : return true;
1254 : : }
1255 : : else
1256 : : {
1257 : 1109 : location_t next_token_loc = c_parser_peek_token (parser)->location;
1258 : 1109 : gcc_rich_location richloc (next_token_loc);
1259 : :
1260 : : /* Potentially supply a fix-it hint, suggesting to add the
1261 : : missing token immediately after the *previous* token.
1262 : : This may move the primary location within richloc. */
1263 : 1109 : if (!parser->error && type_is_unique)
1264 : 646 : maybe_suggest_missing_token_insertion (&richloc, type,
1265 : : parser->last_token_location);
1266 : :
1267 : : /* If matching_location != UNKNOWN_LOCATION, highlight it.
1268 : : Attempt to consolidate diagnostics by printing it as a
1269 : : secondary range within the main diagnostic. */
1270 : 1109 : bool added_matching_location = false;
1271 : 1109 : if (matching_location != UNKNOWN_LOCATION)
1272 : 397 : added_matching_location
1273 : 397 : = richloc.add_location_if_nearby (*global_dc, matching_location);
1274 : :
1275 : 1109 : if (c_parser_error_richloc (parser, msgid, &richloc))
1276 : : /* If we weren't able to consolidate matching_location, then
1277 : : print it as a secondary diagnostic. */
1278 : 538 : if (matching_location != UNKNOWN_LOCATION && !added_matching_location)
1279 : 4 : inform (matching_location, "to match this %qs",
1280 : : get_matching_symbol (type));
1281 : :
1282 : 1109 : return false;
1283 : 1109 : }
1284 : : }
1285 : :
1286 : : /* If the next token is the indicated keyword, consume it. Otherwise,
1287 : : issue the error MSGID. Returns true if found, false otherwise. */
1288 : :
1289 : : static bool
1290 : 144622 : c_parser_require_keyword (c_parser *parser,
1291 : : enum rid keyword,
1292 : : const char *msgid)
1293 : : {
1294 : 144622 : if (c_parser_next_token_is_keyword (parser, keyword))
1295 : : {
1296 : 144621 : c_parser_consume_token (parser);
1297 : 144621 : return true;
1298 : : }
1299 : : else
1300 : : {
1301 : 1 : c_parser_error (parser, msgid);
1302 : 1 : return false;
1303 : : }
1304 : : }
1305 : :
1306 : : /* Like c_parser_require, except that tokens will be skipped until the
1307 : : desired token is found. An error message is still produced if the
1308 : : next token is not as expected. If MSGID is NULL then a message has
1309 : : already been produced and no message will be produced this
1310 : : time.
1311 : :
1312 : : If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
1313 : : within any error as the location of an "opening" token matching
1314 : : the close token TYPE (e.g. the location of the '(' when TYPE is
1315 : : CPP_CLOSE_PAREN). */
1316 : :
1317 : : void
1318 : 220442290 : c_parser_skip_until_found (c_parser *parser,
1319 : : enum cpp_ttype type,
1320 : : const char *msgid,
1321 : : location_t matching_location)
1322 : : {
1323 : 220442290 : unsigned nesting_depth = 0;
1324 : :
1325 : 220442290 : if (c_parser_require (parser, type, msgid, matching_location))
1326 : : {
1327 : 220441408 : if (UNLIKELY (type == CPP_PRAGMA_EOL) && parser->in_omp_attribute_pragma)
1328 : : {
1329 : 0 : c_token *token = c_parser_peek_token (parser);
1330 : 0 : if (token->type == CPP_EOF)
1331 : : {
1332 : 0 : parser->tokens = parser->in_omp_attribute_pragma->save_tokens;
1333 : 0 : parser->tokens_avail
1334 : 0 : = parser->in_omp_attribute_pragma->save_tokens_avail;
1335 : 0 : parser->in_omp_attribute_pragma = NULL;
1336 : : }
1337 : : }
1338 : 220441408 : return;
1339 : : }
1340 : :
1341 : : /* Skip tokens until the desired token is found. */
1342 : 5860 : while (true)
1343 : : {
1344 : : /* Peek at the next token. */
1345 : 3371 : c_token *token = c_parser_peek_token (parser);
1346 : : /* If we've reached the token we want, consume it and stop. */
1347 : 3371 : if (token->type == type && !nesting_depth)
1348 : : {
1349 : 679 : c_parser_consume_token (parser);
1350 : 679 : if (UNLIKELY (type == CPP_PRAGMA_EOL)
1351 : 109 : && parser->in_omp_attribute_pragma)
1352 : : {
1353 : 1 : c_token *token = c_parser_peek_token (parser);
1354 : 1 : if (token->type == CPP_EOF)
1355 : : {
1356 : 1 : parser->tokens = parser->in_omp_attribute_pragma->save_tokens;
1357 : 1 : parser->tokens_avail
1358 : 1 : = parser->in_omp_attribute_pragma->save_tokens_avail;
1359 : 1 : parser->in_omp_attribute_pragma = NULL;
1360 : : }
1361 : : }
1362 : : break;
1363 : : }
1364 : :
1365 : : /* If we've run out of tokens, stop. */
1366 : 2692 : if (token->type == CPP_EOF)
1367 : : return;
1368 : 2673 : if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
1369 : : return;
1370 : 2607 : if (token->type == CPP_OPEN_BRACE
1371 : : || token->type == CPP_OPEN_PAREN
1372 : : || token->type == CPP_OPEN_SQUARE)
1373 : 288 : ++nesting_depth;
1374 : : else if (token->type == CPP_CLOSE_BRACE
1375 : : || token->type == CPP_CLOSE_PAREN
1376 : : || token->type == CPP_CLOSE_SQUARE)
1377 : : {
1378 : 406 : if (nesting_depth-- == 0)
1379 : : break;
1380 : : }
1381 : : /* Consume this token. */
1382 : 2489 : c_parser_consume_token (parser);
1383 : 2489 : }
1384 : 797 : parser->error = false;
1385 : : }
1386 : :
1387 : : /* Skip tokens until the end of a parameter is found, but do not
1388 : : consume the comma, semicolon or closing delimiter. */
1389 : :
1390 : : static void
1391 : 97 : c_parser_skip_to_end_of_parameter (c_parser *parser)
1392 : : {
1393 : 97 : unsigned nesting_depth = 0;
1394 : :
1395 : 501 : while (true)
1396 : : {
1397 : 299 : c_token *token = c_parser_peek_token (parser);
1398 : 299 : if ((token->type == CPP_COMMA || token->type == CPP_SEMICOLON)
1399 : 25 : && !nesting_depth)
1400 : : break;
1401 : : /* If we've run out of tokens, stop. */
1402 : 274 : if (token->type == CPP_EOF)
1403 : : return;
1404 : 274 : if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
1405 : : return;
1406 : 274 : if (token->type == CPP_OPEN_BRACE
1407 : : || token->type == CPP_OPEN_PAREN
1408 : : || token->type == CPP_OPEN_SQUARE)
1409 : 3 : ++nesting_depth;
1410 : : else if (token->type == CPP_CLOSE_BRACE
1411 : : || token->type == CPP_CLOSE_PAREN
1412 : : || token->type == CPP_CLOSE_SQUARE)
1413 : : {
1414 : 75 : if (nesting_depth-- == 0)
1415 : : break;
1416 : : }
1417 : : /* Consume this token. */
1418 : 202 : c_parser_consume_token (parser);
1419 : 202 : }
1420 : 97 : parser->error = false;
1421 : : }
1422 : :
1423 : : /* Skip tokens until a non-nested closing curly brace is the next
1424 : : token, or there are no more tokens. Return true in the first case,
1425 : : false otherwise. */
1426 : :
1427 : : static bool
1428 : 26 : c_parser_skip_to_closing_brace (c_parser *parser)
1429 : : {
1430 : 26 : unsigned nesting_depth = 0;
1431 : :
1432 : 96 : while (true)
1433 : : {
1434 : 61 : c_token *token = c_parser_peek_token (parser);
1435 : :
1436 : 61 : switch (token->type)
1437 : : {
1438 : 2 : case CPP_PRAGMA_EOL:
1439 : 2 : if (!parser->in_pragma)
1440 : : break;
1441 : : /* FALLTHRU */
1442 : : case CPP_EOF:
1443 : : /* If we've run out of tokens, stop. */
1444 : : return false;
1445 : :
1446 : 24 : case CPP_CLOSE_BRACE:
1447 : : /* If the next token is a non-nested `}', then we have reached
1448 : : the end of the current block. */
1449 : 24 : if (nesting_depth-- == 0)
1450 : : return true;
1451 : : break;
1452 : :
1453 : 0 : case CPP_OPEN_BRACE:
1454 : : /* If it the next token is a `{', then we are entering a new
1455 : : block. Consume the entire block. */
1456 : 0 : ++nesting_depth;
1457 : 0 : break;
1458 : :
1459 : : default:
1460 : : break;
1461 : : }
1462 : :
1463 : : /* Consume the token. */
1464 : 35 : c_parser_consume_token (parser);
1465 : 35 : }
1466 : : }
1467 : :
1468 : : /* Expect to be at the end of the pragma directive and consume an
1469 : : end of line marker. */
1470 : :
1471 : : static void
1472 : 1950537 : c_parser_skip_to_pragma_eol (c_parser *parser, bool error_if_not_eol = true)
1473 : : {
1474 : 1950537 : gcc_assert (parser->in_pragma);
1475 : 1950537 : parser->in_pragma = false;
1476 : :
1477 : 1950537 : if (error_if_not_eol && c_parser_peek_token (parser)->type != CPP_PRAGMA_EOL)
1478 : 190 : c_parser_error (parser, "expected end of line");
1479 : :
1480 : 1951827 : cpp_ttype token_type;
1481 : 1951827 : do
1482 : : {
1483 : 1951827 : c_token *token = c_parser_peek_token (parser);
1484 : 1951827 : token_type = token->type;
1485 : 1951827 : if (token_type == CPP_EOF)
1486 : : break;
1487 : 1951827 : c_parser_consume_token (parser);
1488 : : }
1489 : 1951827 : while (token_type != CPP_PRAGMA_EOL);
1490 : :
1491 : 1950537 : if (parser->in_omp_attribute_pragma)
1492 : : {
1493 : 743 : c_token *token = c_parser_peek_token (parser);
1494 : 743 : if (token->type == CPP_EOF)
1495 : : {
1496 : 596 : parser->tokens = parser->in_omp_attribute_pragma->save_tokens;
1497 : 596 : parser->tokens_avail
1498 : 596 : = parser->in_omp_attribute_pragma->save_tokens_avail;
1499 : 596 : parser->in_omp_attribute_pragma = NULL;
1500 : : }
1501 : : }
1502 : :
1503 : 1950537 : parser->error = false;
1504 : 1950537 : }
1505 : :
1506 : : /* Skip tokens until we have consumed an entire block, or until we
1507 : : have consumed a non-nested ';'. */
1508 : :
1509 : : static void
1510 : 492 : c_parser_skip_to_end_of_block_or_statement (c_parser *parser,
1511 : : bool metadirective_p = false)
1512 : : {
1513 : 492 : unsigned nesting_depth = 0;
1514 : 492 : int bracket_depth = 0;
1515 : 492 : bool save_error = parser->error;
1516 : :
1517 : 1795 : while (true)
1518 : : {
1519 : 1795 : c_token *token;
1520 : :
1521 : : /* Peek at the next token. */
1522 : 1795 : token = c_parser_peek_token (parser);
1523 : :
1524 : 1795 : switch (token->type)
1525 : : {
1526 : : case CPP_EOF:
1527 : : return;
1528 : :
1529 : 0 : case CPP_PRAGMA_EOL:
1530 : 0 : if (parser->in_pragma)
1531 : : return;
1532 : : break;
1533 : :
1534 : 429 : case CPP_SEMICOLON:
1535 : : /* If the next token is a ';', we have reached the
1536 : : end of the statement. */
1537 : 429 : if (!nesting_depth && (!metadirective_p || bracket_depth <= 0))
1538 : : {
1539 : : /* Consume the ';'. */
1540 : 364 : c_parser_consume_token (parser);
1541 : 364 : goto finished;
1542 : : }
1543 : : break;
1544 : :
1545 : 110 : case CPP_CLOSE_BRACE:
1546 : : /* If the next token is a non-nested '}', then we have
1547 : : reached the end of the current block. */
1548 : 61 : if ((nesting_depth == 0 || --nesting_depth == 0)
1549 : 171 : && (!metadirective_p || bracket_depth <= 0))
1550 : : {
1551 : 110 : c_parser_consume_token (parser);
1552 : 110 : goto finished;
1553 : : }
1554 : : break;
1555 : :
1556 : 61 : case CPP_OPEN_BRACE:
1557 : : /* If it the next token is a '{', then we are entering a new
1558 : : block. Consume the entire block. */
1559 : 61 : ++nesting_depth;
1560 : 61 : break;
1561 : :
1562 : 64 : case CPP_OPEN_PAREN:
1563 : : /* Track parentheses in case the statement is a standalone 'for'
1564 : : statement - we want to skip over the semicolons separating the
1565 : : operands. */
1566 : 64 : if (metadirective_p && nesting_depth == 0)
1567 : 2 : ++bracket_depth;
1568 : : break;
1569 : :
1570 : 90 : case CPP_CLOSE_PAREN:
1571 : 90 : if (metadirective_p && nesting_depth == 0)
1572 : 2 : --bracket_depth;
1573 : : break;
1574 : :
1575 : 7 : case CPP_PRAGMA:
1576 : : /* If we see a pragma, consume the whole thing at once. We
1577 : : have some safeguards against consuming pragmas willy-nilly.
1578 : : Normally, we'd expect to be here with parser->error set,
1579 : : which disables these safeguards. But it's possible to get
1580 : : here for secondary error recovery, after parser->error has
1581 : : been cleared. */
1582 : 7 : c_parser_consume_pragma (parser);
1583 : 7 : c_parser_skip_to_pragma_eol (parser, false);
1584 : 7 : parser->error = save_error;
1585 : 7 : continue;
1586 : :
1587 : : default:
1588 : : break;
1589 : : }
1590 : :
1591 : 1296 : c_parser_consume_token (parser);
1592 : : }
1593 : :
1594 : 474 : finished:
1595 : 474 : parser->error = false;
1596 : : }
1597 : :
1598 : : /* CPP's options (initialized by c-opts.cc). */
1599 : : extern cpp_options *cpp_opts;
1600 : :
1601 : : /* Save the warning flags which are controlled by __extension__. */
1602 : :
1603 : : static inline int
1604 : 959292 : disable_extension_diagnostics (void)
1605 : : {
1606 : 1918584 : int ret = (pedantic
1607 : 959292 : | (warn_pointer_arith << 1)
1608 : 959292 : | (warn_traditional << 2)
1609 : 959292 : | (flag_iso << 3)
1610 : 959292 : | (warn_long_long << 4)
1611 : 959292 : | (warn_cxx_compat << 5)
1612 : 959292 : | (warn_overlength_strings << 6)
1613 : : /* warn_c90_c99_compat has three states: -1/0/1, so we must
1614 : : play tricks to properly restore it. */
1615 : 959292 : | ((warn_c90_c99_compat == 1) << 7)
1616 : 959292 : | ((warn_c90_c99_compat == -1) << 8)
1617 : : /* Similarly for warn_c99_c11_compat. */
1618 : 959292 : | ((warn_c99_c11_compat == 1) << 9)
1619 : 959292 : | ((warn_c99_c11_compat == -1) << 10)
1620 : : /* Similarly for warn_c11_c23_compat. */
1621 : 959292 : | ((warn_c11_c23_compat == 1) << 11)
1622 : 959292 : | ((warn_c11_c23_compat == -1) << 12)
1623 : : /* Similarly for warn_c23_c2y_compat. */
1624 : 959292 : | ((warn_c23_c2y_compat == 1) << 13)
1625 : 959292 : | ((warn_c23_c2y_compat == -1) << 14)
1626 : : );
1627 : 959292 : cpp_opts->cpp_pedantic = pedantic = 0;
1628 : 959292 : warn_pointer_arith = 0;
1629 : 959292 : cpp_opts->cpp_warn_traditional = warn_traditional = 0;
1630 : 959292 : flag_iso = 0;
1631 : 959292 : cpp_opts->cpp_warn_long_long = warn_long_long = 0;
1632 : 959292 : warn_cxx_compat = 0;
1633 : 959292 : warn_overlength_strings = 0;
1634 : 959292 : warn_c90_c99_compat = 0;
1635 : 959292 : warn_c99_c11_compat = 0;
1636 : 959292 : warn_c11_c23_compat = 0;
1637 : 959292 : warn_c23_c2y_compat = 0;
1638 : 959292 : return ret;
1639 : : }
1640 : :
1641 : : /* Restore the warning flags which are controlled by __extension__.
1642 : : FLAGS is the return value from disable_extension_diagnostics. */
1643 : :
1644 : : static inline void
1645 : 959292 : restore_extension_diagnostics (int flags)
1646 : : {
1647 : 959292 : cpp_opts->cpp_pedantic = pedantic = flags & 1;
1648 : 959292 : warn_pointer_arith = (flags >> 1) & 1;
1649 : 959292 : cpp_opts->cpp_warn_traditional = warn_traditional = (flags >> 2) & 1;
1650 : 959292 : flag_iso = (flags >> 3) & 1;
1651 : 959292 : cpp_opts->cpp_warn_long_long = warn_long_long = (flags >> 4) & 1;
1652 : 959292 : warn_cxx_compat = (flags >> 5) & 1;
1653 : 959292 : warn_overlength_strings = (flags >> 6) & 1;
1654 : : /* See above for why is this needed. */
1655 : 959292 : warn_c90_c99_compat = (flags >> 7) & 1 ? 1 : ((flags >> 8) & 1 ? -1 : 0);
1656 : 959292 : warn_c99_c11_compat = (flags >> 9) & 1 ? 1 : ((flags >> 10) & 1 ? -1 : 0);
1657 : 959292 : warn_c11_c23_compat = (flags >> 11) & 1 ? 1 : ((flags >> 12) & 1 ? -1 : 0);
1658 : 959292 : warn_c23_c2y_compat = (flags >> 13) & 1 ? 1 : ((flags >> 14) & 1 ? -1 : 0);
1659 : 959292 : }
1660 : :
1661 : : /* Helper data structure for parsing #pragma acc routine. */
1662 : : struct oacc_routine_data {
1663 : : bool error_seen; /* Set if error has been reported. */
1664 : : bool fndecl_seen; /* Set if one fn decl/definition has been seen already. */
1665 : : tree clauses;
1666 : : location_t loc;
1667 : : };
1668 : :
1669 : : /* Used for parsing objc foreach statements. */
1670 : : static tree objc_foreach_break_label, objc_foreach_continue_label;
1671 : :
1672 : : /* Used for parsing OMP for loops.
1673 : :
1674 : : Some notes on flags used for context:
1675 : : parser->omp_for_parse_state is non-null anywhere inside the OMP FOR
1676 : : construct, except for the final-loop-body.
1677 : : The want_nested_loop flag is true if inside a {} sequence where
1678 : : a loop-nest (or another {} sequence containing a loop-nest) is expected,
1679 : : but has not yet been seen. It's false when parsing intervening code
1680 : : statements or their substatements that cannot contain a loop-nest.
1681 : : The in_intervening_code flag is true when parsing any intervening code,
1682 : : including substatements, and whether or not want_nested_loop is true.
1683 : :
1684 : : And, about error handling:
1685 : : The saw_intervening_code flag is set if the loop is not perfectly
1686 : : nested, even in the usual case where this is not an error.
1687 : : perfect_nesting_fail is set if an error has been diagnosed because an
1688 : : imperfectly-nested loop was found where a perfectly-nested one is
1689 : : required (we diagnose this only once).
1690 : : fail is set if any kind of structural error in the loop nest
1691 : : has been found and diagnosed.
1692 : : */
1693 : : struct omp_for_parse_data {
1694 : : enum tree_code code;
1695 : : tree declv, condv, incrv, initv;
1696 : : tree pre_body;
1697 : : tree bindings;
1698 : : int count; /* Expected nesting depth. */
1699 : : int depth; /* Current nesting depth. */
1700 : : location_t for_loc;
1701 : : bool ordered : 1;
1702 : : bool inscan : 1;
1703 : : bool want_nested_loop : 1;
1704 : : bool in_intervening_code : 1;
1705 : : bool saw_intervening_code: 1;
1706 : : bool perfect_nesting_fail : 1;
1707 : : bool fail : 1;
1708 : : };
1709 : :
1710 : : struct attr_state
1711 : : {
1712 : : /* True if we parsed a musttail attribute for return. */
1713 : : bool musttail_p;
1714 : : };
1715 : :
1716 : : static bool c_parser_nth_token_starts_std_attributes (c_parser *,
1717 : : unsigned int);
1718 : : static tree c_parser_std_attribute_specifier_sequence (c_parser *);
1719 : : static void c_parser_external_declaration (c_parser *);
1720 : : static void c_parser_asm_definition (c_parser *);
1721 : : static tree c_parser_declaration_or_fndef (c_parser *, bool, bool, bool,
1722 : : bool, bool, bool, tree * = NULL,
1723 : : vec<c_token> * = NULL,
1724 : : bool have_attrs = false,
1725 : : tree attrs = NULL,
1726 : : struct oacc_routine_data * = NULL,
1727 : : bool * = NULL);
1728 : : static bool c_parser_handle_statement_omp_attributes (c_parser *, tree &,
1729 : : bool *);
1730 : : static void c_parser_static_assert_declaration_no_semi (c_parser *);
1731 : : static void c_parser_static_assert_declaration (c_parser *);
1732 : : static struct c_typespec c_parser_enum_specifier (c_parser *);
1733 : : static struct c_typespec c_parser_struct_or_union_specifier (c_parser *);
1734 : : static tree c_parser_struct_declaration (c_parser *, tree *);
1735 : : static struct c_typespec c_parser_typeof_specifier (c_parser *);
1736 : : static tree c_parser_alignas_specifier (c_parser *);
1737 : : static struct c_declarator *c_parser_direct_declarator (c_parser *, bool,
1738 : : c_dtr_syn, bool *);
1739 : : static struct c_declarator *c_parser_direct_declarator_inner (c_parser *,
1740 : : bool,
1741 : : struct c_declarator *);
1742 : : static struct c_arg_info *c_parser_parms_declarator (c_parser *, bool, tree,
1743 : : bool);
1744 : : static struct c_arg_info *c_parser_parms_list_declarator (c_parser *, tree,
1745 : : tree, bool);
1746 : : static struct c_parm *c_parser_parameter_declaration (c_parser *, tree, bool);
1747 : : static tree c_parser_asm_string_literal (c_parser *);
1748 : : static tree c_parser_simple_asm_expr (c_parser *);
1749 : : static tree c_parser_gnu_attributes (c_parser *);
1750 : : static struct c_expr c_parser_initializer (c_parser *, tree);
1751 : : static struct c_expr c_parser_braced_init (c_parser *, tree, bool,
1752 : : struct obstack *, tree);
1753 : : static void c_parser_initelt (c_parser *, struct obstack *);
1754 : : static void c_parser_initval (c_parser *, struct c_expr *,
1755 : : struct obstack *);
1756 : : static tree c_parser_compound_statement (c_parser *, location_t * = NULL);
1757 : : static location_t c_parser_compound_statement_nostart (c_parser *);
1758 : : static void c_parser_label (c_parser *, tree);
1759 : : static void c_parser_statement (c_parser *, bool *, location_t * = NULL);
1760 : : static void c_parser_statement_after_labels (c_parser *, bool *, tree,
1761 : : vec<tree> * = NULL,
1762 : : attr_state = {});
1763 : : static tree c_parser_c99_block_statement (c_parser *, bool *,
1764 : : location_t * = NULL);
1765 : : static void c_parser_if_statement (c_parser *, bool *, vec<tree> *);
1766 : : static void c_parser_switch_statement (c_parser *, bool *, tree);
1767 : : static void c_parser_while_statement (c_parser *, bool, unsigned short, bool,
1768 : : bool *, tree);
1769 : : static void c_parser_do_statement (c_parser *, bool, unsigned short, bool,
1770 : : tree);
1771 : : static void c_parser_for_statement (c_parser *, bool, unsigned short, bool,
1772 : : bool *, tree);
1773 : : static tree c_parser_asm_statement (c_parser *);
1774 : : static tree c_parser_asm_operands (c_parser *);
1775 : : static tree c_parser_asm_goto_operands (c_parser *);
1776 : : static tree c_parser_asm_clobbers (c_parser *);
1777 : : static struct c_expr c_parser_expr_no_commas (c_parser *, struct c_expr *,
1778 : : tree = NULL_TREE);
1779 : : static struct c_expr c_parser_conditional_expression (c_parser *,
1780 : : struct c_expr *, tree);
1781 : : static struct c_expr c_parser_binary_expression (c_parser *, struct c_expr *,
1782 : : tree);
1783 : : static struct c_expr c_parser_cast_expression (c_parser *, struct c_expr *);
1784 : : static struct c_expr c_parser_unary_expression (c_parser *);
1785 : : static inline struct c_expr c_parser_sizeof_expression (c_parser *);
1786 : : static inline struct c_expr c_parser_countof_expression (c_parser *);
1787 : : static struct c_expr c_parser_sizeof_or_countof_expression (c_parser *,
1788 : : enum rid);
1789 : : static struct c_expr c_parser_alignof_expression (c_parser *);
1790 : : static struct c_expr c_parser_postfix_expression (c_parser *);
1791 : : static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *,
1792 : : struct c_declspecs *,
1793 : : struct c_type_name *,
1794 : : location_t);
1795 : : static struct c_expr c_parser_postfix_expression_after_primary (c_parser *,
1796 : : location_t loc,
1797 : : struct c_expr);
1798 : : static tree c_parser_transaction (c_parser *, enum rid);
1799 : : static struct c_expr c_parser_transaction_expression (c_parser *, enum rid);
1800 : : static tree c_parser_transaction_cancel (c_parser *);
1801 : : static struct c_expr c_parser_expression (c_parser *);
1802 : : static struct c_expr c_parser_expression_conv (c_parser *);
1803 : : static vec<tree, va_gc> *c_parser_expr_list (c_parser *, bool, bool,
1804 : : vec<tree, va_gc> **, location_t *,
1805 : : tree *, vec<location_t> *,
1806 : : unsigned int * = NULL);
1807 : : static struct c_expr c_parser_has_attribute_expression (c_parser *);
1808 : :
1809 : : static void c_parser_oacc_declare (c_parser *);
1810 : : static void c_parser_oacc_enter_exit_data (c_parser *, bool);
1811 : : static void c_parser_oacc_update (c_parser *);
1812 : : static void c_parser_omp_construct (c_parser *, bool *);
1813 : : static void c_parser_omp_threadprivate (c_parser *);
1814 : : static void c_parser_omp_barrier (c_parser *);
1815 : : static void c_parser_omp_depobj (c_parser *);
1816 : : static void c_parser_omp_flush (c_parser *);
1817 : : static bool c_parser_omp_next_tokens_can_be_canon_loop (c_parser *,
1818 : : enum tree_code, bool);
1819 : : static tree c_parser_omp_loop_nest (c_parser *, bool *);
1820 : : static tree c_parser_omp_for_loop (location_t, c_parser *, enum tree_code,
1821 : : tree, tree *, bool *);
1822 : : static void c_parser_omp_taskwait (c_parser *);
1823 : : static void c_parser_omp_taskyield (c_parser *);
1824 : : static void c_parser_omp_cancel (c_parser *);
1825 : : static void c_parser_omp_nothing (c_parser *);
1826 : : static void c_parser_omp_metadirective (c_parser *, bool *);
1827 : :
1828 : : enum pragma_context { pragma_external, pragma_struct, pragma_param,
1829 : : pragma_stmt, pragma_compound };
1830 : : static bool c_parser_pragma (c_parser *, enum pragma_context, bool *, tree);
1831 : : static bool c_parser_omp_cancellation_point (c_parser *, enum pragma_context);
1832 : : static bool c_parser_omp_target (c_parser *, enum pragma_context, bool *);
1833 : : static void c_parser_omp_begin (c_parser *);
1834 : : static void c_parser_omp_end (c_parser *);
1835 : : static bool c_parser_omp_declare (c_parser *, enum pragma_context);
1836 : : static void c_parser_omp_requires (c_parser *);
1837 : : static bool c_parser_omp_error (c_parser *, enum pragma_context);
1838 : : static void c_parser_omp_assumption_clauses (c_parser *, bool);
1839 : : static void c_parser_omp_allocate (c_parser *);
1840 : : static void c_parser_omp_assumes (c_parser *);
1841 : : static bool c_parser_omp_ordered (c_parser *, enum pragma_context, bool *);
1842 : : static tree c_parser_omp_dispatch (location_t, c_parser *);
1843 : : static void c_parser_omp_interop (c_parser *);
1844 : : static void c_parser_oacc_routine (c_parser *, enum pragma_context);
1845 : :
1846 : : /* These Objective-C parser functions are only ever called when
1847 : : compiling Objective-C. */
1848 : : static void c_parser_objc_class_definition (c_parser *, tree);
1849 : : static void c_parser_objc_class_instance_variables (c_parser *);
1850 : : static void c_parser_objc_class_declaration (c_parser *);
1851 : : static void c_parser_objc_alias_declaration (c_parser *);
1852 : : static void c_parser_objc_protocol_definition (c_parser *, tree);
1853 : : static bool c_parser_objc_method_type (c_parser *);
1854 : : static void c_parser_objc_method_definition (c_parser *);
1855 : : static void c_parser_objc_methodprotolist (c_parser *);
1856 : : static void c_parser_objc_methodproto (c_parser *);
1857 : : static tree c_parser_objc_method_decl (c_parser *, bool, tree *, tree *);
1858 : : static tree c_parser_objc_type_name (c_parser *);
1859 : : static tree c_parser_objc_protocol_refs (c_parser *);
1860 : : static void c_parser_objc_try_catch_finally_statement (c_parser *);
1861 : : static void c_parser_objc_synchronized_statement (c_parser *);
1862 : : static tree c_parser_objc_selector (c_parser *);
1863 : : static tree c_parser_objc_selector_arg (c_parser *);
1864 : : static tree c_parser_objc_receiver (c_parser *);
1865 : : static tree c_parser_objc_message_args (c_parser *);
1866 : : static tree c_parser_objc_keywordexpr (c_parser *);
1867 : : static void c_parser_objc_at_property_declaration (c_parser *);
1868 : : static void c_parser_objc_at_synthesize_declaration (c_parser *);
1869 : : static void c_parser_objc_at_dynamic_declaration (c_parser *);
1870 : : static bool c_parser_objc_diagnose_bad_element_prefix
1871 : : (c_parser *, struct c_declspecs *);
1872 : : static location_t c_parser_parse_rtl_body (c_parser *, char *);
1873 : : static tree c_parser_handle_musttail (c_parser *, tree, attr_state &);
1874 : :
1875 : : #if ENABLE_ANALYZER
1876 : :
1877 : : namespace ana {
1878 : :
1879 : : /* Concrete implementation of ana::translation_unit for the C frontend. */
1880 : :
1881 : : class c_translation_unit : public translation_unit
1882 : : {
1883 : : public:
1884 : : /* Implementation of translation_unit::lookup_constant_by_id for use by the
1885 : : analyzer to look up named constants in the user's source code. */
1886 : 6995 : tree lookup_constant_by_id (tree id) const final override
1887 : : {
1888 : : /* Consider decls. */
1889 : 6995 : if (tree decl = lookup_name (id))
1890 : 42 : if (TREE_CODE (decl) == CONST_DECL)
1891 : 42 : if (tree value = DECL_INITIAL (decl))
1892 : 42 : if (TREE_CODE (value) == INTEGER_CST)
1893 : : return value;
1894 : :
1895 : : /* Consider macros. */
1896 : 6953 : cpp_hashnode *hashnode = C_CPP_HASHNODE (id);
1897 : 6953 : if (cpp_macro_p (hashnode))
1898 : 48 : if (tree value = consider_macro (hashnode->value.macro))
1899 : : return value;
1900 : :
1901 : : return NULL_TREE;
1902 : : }
1903 : :
1904 : : tree
1905 : 4 : lookup_type_by_id (tree id) const final override
1906 : : {
1907 : 4 : if (tree type_decl = lookup_name (id))
1908 : 0 : if (TREE_CODE (type_decl) == TYPE_DECL)
1909 : : {
1910 : 0 : tree record_type = TREE_TYPE (type_decl);
1911 : 0 : if (TREE_CODE (record_type) == RECORD_TYPE)
1912 : 0 : return record_type;
1913 : : }
1914 : :
1915 : : return NULL_TREE;
1916 : : }
1917 : :
1918 : : tree
1919 : 2 : lookup_global_var_by_id (tree id) const final override
1920 : : {
1921 : 2 : if (tree var_decl = lookup_name (id))
1922 : 0 : if (TREE_CODE (var_decl) == VAR_DECL)
1923 : 0 : return var_decl;
1924 : :
1925 : : return NULL_TREE;
1926 : : }
1927 : :
1928 : : private:
1929 : : /* Attempt to get an INTEGER_CST from MACRO.
1930 : : Only handle the simplest cases: where MACRO's definition is a single
1931 : : token containing a number, by lexing the number again.
1932 : : This will handle e.g.
1933 : : #define NAME 42
1934 : : and other bases but not negative numbers, parentheses or e.g.
1935 : : #define NAME 1 << 7
1936 : : as doing so would require a parser. */
1937 : 48 : tree consider_macro (cpp_macro *macro) const
1938 : : {
1939 : 48 : if (macro->paramc > 0)
1940 : : return NULL_TREE;
1941 : 45 : if (macro->kind != cmk_macro)
1942 : : return NULL_TREE;
1943 : 45 : if (macro->count != 1)
1944 : : return NULL_TREE;
1945 : 39 : const cpp_token &tok = macro->exp.tokens[0];
1946 : 39 : if (tok.type != CPP_NUMBER)
1947 : : return NULL_TREE;
1948 : :
1949 : 36 : cpp_reader *old_parse_in = parse_in;
1950 : 36 : parse_in = cpp_create_reader (CLK_GNUC89, NULL, line_table);
1951 : :
1952 : 36 : pretty_printer pp;
1953 : 36 : pp_string (&pp, (const char *) tok.val.str.text);
1954 : 36 : pp_newline (&pp);
1955 : 72 : cpp_push_buffer (parse_in,
1956 : 36 : (const unsigned char *) pp_formatted_text (&pp),
1957 : : strlen (pp_formatted_text (&pp)),
1958 : : 0);
1959 : :
1960 : 36 : tree value;
1961 : 36 : location_t loc;
1962 : 36 : unsigned char cpp_flags;
1963 : 36 : c_lex_with_flags (&value, &loc, &cpp_flags, 0);
1964 : :
1965 : 36 : cpp_destroy (parse_in);
1966 : 36 : parse_in = old_parse_in;
1967 : :
1968 : 36 : if (value && TREE_CODE (value) == INTEGER_CST)
1969 : 36 : return value;
1970 : :
1971 : : return NULL_TREE;
1972 : 36 : }
1973 : : };
1974 : :
1975 : : } // namespace ana
1976 : :
1977 : : #endif /* #if ENABLE_ANALYZER */
1978 : :
1979 : : /* Parse a translation unit (C90 6.7, C99 6.9, C11 6.9).
1980 : :
1981 : : translation-unit:
1982 : : external-declarations
1983 : :
1984 : : external-declarations:
1985 : : external-declaration
1986 : : external-declarations external-declaration
1987 : :
1988 : : GNU extensions:
1989 : :
1990 : : translation-unit:
1991 : : empty
1992 : : */
1993 : :
1994 : : static void
1995 : 104422 : c_parser_translation_unit (c_parser *parser)
1996 : : {
1997 : 104422 : if (c_parser_next_token_is (parser, CPP_EOF))
1998 : : {
1999 : 1215 : pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
2000 : : "ISO C forbids an empty translation unit");
2001 : : }
2002 : : else
2003 : : {
2004 : 103207 : void *obstack_position = obstack_alloc (&parser_obstack, 0);
2005 : 103207 : mark_valid_location_for_stdc_pragma (false);
2006 : 57005335 : do
2007 : : {
2008 : 57005335 : ggc_collect ();
2009 : 57005335 : c_parser_external_declaration (parser);
2010 : 57005330 : obstack_free (&parser_obstack, obstack_position);
2011 : : }
2012 : 57005330 : while (c_parser_next_token_is_not (parser, CPP_EOF));
2013 : : }
2014 : :
2015 : : unsigned int i;
2016 : : tree decl;
2017 : 104427 : FOR_EACH_VEC_ELT (incomplete_record_decls, i, decl)
2018 : 95 : if (DECL_SIZE (decl) == NULL_TREE && TREE_TYPE (decl) != error_mark_node)
2019 : 17 : error ("storage size of %q+D isn%'t known", decl);
2020 : :
2021 : 104332 : if (vec_safe_length (current_omp_declare_target_attribute))
2022 : : {
2023 : 4 : c_omp_declare_target_attr
2024 : 4 : a = current_omp_declare_target_attribute->pop ();
2025 : 4 : if (!errorcount)
2026 : 3 : error ("%qs without corresponding %qs",
2027 : : a.device_type >= 0 ? "#pragma omp begin declare target"
2028 : : : "#pragma omp declare target",
2029 : : "#pragma omp end declare target");
2030 : 8 : vec_safe_truncate (current_omp_declare_target_attribute, 0);
2031 : : }
2032 : 104332 : if (vec_safe_length (current_omp_begin_assumes))
2033 : : {
2034 : 1 : if (!errorcount)
2035 : 1 : error ("%qs without corresponding %qs",
2036 : : "#pragma omp begin assumes", "#pragma omp end assumes");
2037 : 1 : vec_safe_truncate (current_omp_begin_assumes, 0);
2038 : : }
2039 : :
2040 : : #if ENABLE_ANALYZER
2041 : 104332 : if (flag_analyzer)
2042 : : {
2043 : 1399 : ana::c_translation_unit tu;
2044 : 1399 : ana::on_finish_translation_unit (tu);
2045 : : }
2046 : : #endif
2047 : 104332 : }
2048 : :
2049 : : /* Parse an external declaration (C90 6.7, C99 6.9, C11 6.9).
2050 : :
2051 : : external-declaration:
2052 : : function-definition
2053 : : declaration
2054 : :
2055 : : GNU extensions:
2056 : :
2057 : : external-declaration:
2058 : : asm-definition
2059 : : ;
2060 : : __extension__ external-declaration
2061 : :
2062 : : Objective-C:
2063 : :
2064 : : external-declaration:
2065 : : objc-class-definition
2066 : : objc-class-declaration
2067 : : objc-alias-declaration
2068 : : objc-protocol-definition
2069 : : objc-method-definition
2070 : : @end
2071 : : */
2072 : :
2073 : : static void
2074 : 57449417 : c_parser_external_declaration (c_parser *parser)
2075 : : {
2076 : 57449417 : int ext;
2077 : 57449417 : switch (c_parser_peek_token (parser)->type)
2078 : : {
2079 : 55609169 : case CPP_KEYWORD:
2080 : 55609169 : switch (c_parser_peek_token (parser)->keyword)
2081 : : {
2082 : 444082 : case RID_EXTENSION:
2083 : 444082 : ext = disable_extension_diagnostics ();
2084 : 444082 : c_parser_consume_token (parser);
2085 : 444082 : c_parser_external_declaration (parser);
2086 : 444082 : restore_extension_diagnostics (ext);
2087 : 444082 : break;
2088 : 172 : case RID_ASM:
2089 : 172 : c_parser_asm_definition (parser);
2090 : 172 : break;
2091 : 0 : case RID_AT_INTERFACE:
2092 : 0 : case RID_AT_IMPLEMENTATION:
2093 : 0 : gcc_assert (c_dialect_objc ());
2094 : 0 : c_parser_objc_class_definition (parser, NULL_TREE);
2095 : 0 : break;
2096 : 0 : case RID_AT_CLASS:
2097 : 0 : gcc_assert (c_dialect_objc ());
2098 : 0 : c_parser_objc_class_declaration (parser);
2099 : 0 : break;
2100 : 0 : case RID_AT_ALIAS:
2101 : 0 : gcc_assert (c_dialect_objc ());
2102 : 0 : c_parser_objc_alias_declaration (parser);
2103 : 0 : break;
2104 : 0 : case RID_AT_PROTOCOL:
2105 : 0 : gcc_assert (c_dialect_objc ());
2106 : 0 : c_parser_objc_protocol_definition (parser, NULL_TREE);
2107 : 0 : break;
2108 : 0 : case RID_AT_PROPERTY:
2109 : 0 : gcc_assert (c_dialect_objc ());
2110 : 0 : c_parser_objc_at_property_declaration (parser);
2111 : 0 : break;
2112 : 0 : case RID_AT_SYNTHESIZE:
2113 : 0 : gcc_assert (c_dialect_objc ());
2114 : 0 : c_parser_objc_at_synthesize_declaration (parser);
2115 : 0 : break;
2116 : 0 : case RID_AT_DYNAMIC:
2117 : 0 : gcc_assert (c_dialect_objc ());
2118 : 0 : c_parser_objc_at_dynamic_declaration (parser);
2119 : 0 : break;
2120 : 0 : case RID_AT_END:
2121 : 0 : gcc_assert (c_dialect_objc ());
2122 : 0 : c_parser_consume_token (parser);
2123 : 0 : objc_finish_implementation ();
2124 : 0 : break;
2125 : 55164915 : default:
2126 : 55164915 : goto decl_or_fndef;
2127 : : }
2128 : : break;
2129 : 2130 : case CPP_SEMICOLON:
2130 : 2130 : pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
2131 : : "ISO C does not allow extra %<;%> outside of a function");
2132 : 2130 : c_parser_consume_token (parser);
2133 : 2130 : break;
2134 : 1616959 : case CPP_PRAGMA:
2135 : 1616959 : mark_valid_location_for_stdc_pragma (true);
2136 : 1616959 : c_parser_pragma (parser, pragma_external, NULL, NULL_TREE);
2137 : 1616959 : mark_valid_location_for_stdc_pragma (false);
2138 : 1616959 : break;
2139 : 1 : case CPP_PLUS:
2140 : 1 : case CPP_MINUS:
2141 : 1 : if (c_dialect_objc ())
2142 : : {
2143 : 0 : c_parser_objc_method_definition (parser);
2144 : 0 : break;
2145 : : }
2146 : : /* Else fall through, and yield a syntax error trying to parse
2147 : : as a declaration or function definition. */
2148 : : /* FALLTHRU */
2149 : 55386074 : default:
2150 : 1 : decl_or_fndef:
2151 : : /* A declaration or a function definition (or, in Objective-C,
2152 : : an @interface or @protocol with prefix attributes). We can
2153 : : only tell which after parsing the declaration specifiers, if
2154 : : any, and the first declarator. */
2155 : 55386074 : c_parser_declaration_or_fndef (parser, true, true, true, false, true,
2156 : : false);
2157 : 55386074 : break;
2158 : : }
2159 : 57449412 : }
2160 : :
2161 : : static void c_parser_handle_directive_omp_attributes (tree &, vec<c_token> *&,
2162 : : vec<c_token> *);
2163 : : static void c_finish_omp_declare_simd (c_parser *, tree, tree, vec<c_token> *);
2164 : : static void c_finish_oacc_routine (struct oacc_routine_data *, tree, bool);
2165 : :
2166 : : /* Build and add a DEBUG_BEGIN_STMT statement with location LOC. */
2167 : :
2168 : : static void
2169 : 104614580 : add_debug_begin_stmt (location_t loc)
2170 : : {
2171 : : /* Don't add DEBUG_BEGIN_STMTs outside of functions, see PR84721. */
2172 : 104614580 : if (!MAY_HAVE_DEBUG_MARKER_STMTS || !building_stmt_list_p ())
2173 : 101886808 : return;
2174 : :
2175 : 2727772 : tree stmt = build0 (DEBUG_BEGIN_STMT, void_type_node);
2176 : 2727772 : SET_EXPR_LOCATION (stmt, loc);
2177 : 2727772 : add_stmt (stmt);
2178 : : }
2179 : :
2180 : : /* Helper function for c_parser_declaration_or_fndef and
2181 : : Handle assume attribute(s). */
2182 : :
2183 : : static tree
2184 : 38 : handle_assume_attribute (location_t here, tree attrs, bool nested)
2185 : : {
2186 : 38 : if (nested)
2187 : 78 : for (tree attr = lookup_attribute ("gnu", "assume", attrs); attr;
2188 : 41 : attr = lookup_attribute ("gnu", "assume", TREE_CHAIN (attr)))
2189 : : {
2190 : 41 : tree args = TREE_VALUE (attr);
2191 : 41 : int nargs = list_length (args);
2192 : 41 : if (nargs != 1)
2193 : : {
2194 : 6 : error_at (here, "wrong number of arguments specified "
2195 : : "for %qE attribute",
2196 : : get_attribute_name (attr));
2197 : 6 : inform (here, "expected %i, found %i", 1, nargs);
2198 : : }
2199 : : else
2200 : : {
2201 : 35 : tree arg = TREE_VALUE (args);
2202 : 35 : arg = c_objc_common_truthvalue_conversion (here, arg);
2203 : 35 : arg = c_fully_fold (arg, false, NULL);
2204 : 35 : if (arg != error_mark_node)
2205 : : {
2206 : 33 : tree fn = build_call_expr_internal_loc (here, IFN_ASSUME,
2207 : : void_type_node, 1,
2208 : : arg);
2209 : 33 : add_stmt (fn);
2210 : : }
2211 : : }
2212 : : }
2213 : : else
2214 : 1 : pedwarn (here, OPT_Wattributes,
2215 : : "%<assume%> attribute at top level");
2216 : :
2217 : 38 : return remove_attribute ("gnu", "assume", attrs);
2218 : : }
2219 : :
2220 : : /* We might need to reclassify any previously-lexed identifier, e.g.
2221 : : when we've left a for loop with an if-statement without else in the
2222 : : body - we might have used a wrong scope for the token. See PR67784. */
2223 : :
2224 : : static void
2225 : 36982069 : c_parser_maybe_reclassify_token (c_parser *parser)
2226 : : {
2227 : 36982069 : if (c_parser_next_token_is (parser, CPP_NAME))
2228 : : {
2229 : 200107 : c_token *token = c_parser_peek_token (parser);
2230 : :
2231 : 200107 : if (token->id_kind != C_ID_CLASSNAME)
2232 : : {
2233 : 200107 : tree decl = lookup_name (token->value);
2234 : :
2235 : 200107 : token->id_kind = C_ID_ID;
2236 : 200107 : if (decl)
2237 : : {
2238 : 197158 : if (TREE_CODE (decl) == TYPE_DECL)
2239 : 2164 : token->id_kind = C_ID_TYPENAME;
2240 : : }
2241 : 2949 : else if (c_dialect_objc ())
2242 : : {
2243 : 0 : tree objc_interface_decl = objc_is_class_name (token->value);
2244 : : /* Objective-C class names are in the same namespace as
2245 : : variables and typedefs, and hence are shadowed by local
2246 : : declarations. */
2247 : 0 : if (objc_interface_decl)
2248 : : {
2249 : 0 : token->value = objc_interface_decl;
2250 : 0 : token->id_kind = C_ID_CLASSNAME;
2251 : : }
2252 : : }
2253 : : }
2254 : : }
2255 : 36982069 : }
2256 : :
2257 : : /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
2258 : : 6.7, 6.9.1, C11 6.7, 6.9.1). If FNDEF_OK is true, a function definition
2259 : : is accepted; otherwise (old-style parameter declarations) only other
2260 : : declarations are accepted. If STATIC_ASSERT_OK is true, a static
2261 : : assertion is accepted; otherwise (old-style parameter declarations)
2262 : : it is not. If NESTED is true, we are inside a function or parsing
2263 : : old-style parameter declarations; any functions encountered are
2264 : : nested functions and declaration specifiers are required; otherwise
2265 : : we are at top level and functions are normal functions and
2266 : : declaration specifiers may be optional. If EMPTY_OK is true, empty
2267 : : declarations are OK (subject to all other constraints); otherwise
2268 : : (old-style parameter declarations) they are diagnosed. If
2269 : : START_ATTR_OK is true, the declaration specifiers may start with
2270 : : attributes (GNU or standard); otherwise they may not.
2271 : : OBJC_FOREACH_OBJECT_DECLARATION can be used to get back the parsed
2272 : : declaration when parsing an Objective-C foreach statement.
2273 : : FALLTHRU_ATTR_P is used to signal whether this function parsed
2274 : : "__attribute__((fallthrough));". ATTRS are any standard attributes
2275 : : parsed in the caller (in contexts where such attributes had to be
2276 : : parsed to determine whether what follows is a declaration or a
2277 : : statement); HAVE_ATTRS says whether there were any such attributes
2278 : : (even empty). If SIMPLE_OK, the construct can be a simple-declaration;
2279 : : in that case, the ';' is not consumed (left to the caller so that it
2280 : : can figure out if there was a simple-declaration or not), there must
2281 : : be an initializer, and only one object may be declared. When SIMPLE_OK
2282 : : is true we are called from c_parser_selection_header.
2283 : :
2284 : : Returns the resulting declaration, if there was any with an initializer.
2285 : :
2286 : : declaration:
2287 : : declaration-specifiers init-declarator-list[opt] ;
2288 : : static_assert-declaration
2289 : :
2290 : : function-definition:
2291 : : declaration-specifiers[opt] declarator declaration-list[opt]
2292 : : compound-statement
2293 : :
2294 : : declaration-list:
2295 : : declaration
2296 : : declaration-list declaration
2297 : :
2298 : : init-declarator-list:
2299 : : init-declarator
2300 : : init-declarator-list , init-declarator
2301 : :
2302 : : init-declarator:
2303 : : declarator simple-asm-expr[opt] gnu-attributes[opt]
2304 : : declarator simple-asm-expr[opt] gnu-attributes[opt] = initializer
2305 : :
2306 : : simple-declaration:
2307 : : attribute-specifier-sequence[opt] declaration-specifiers declarator
2308 : : = initializer
2309 : :
2310 : : GNU extensions:
2311 : :
2312 : : nested-function-definition:
2313 : : declaration-specifiers declarator declaration-list[opt]
2314 : : compound-statement
2315 : :
2316 : : attribute ;
2317 : :
2318 : : Objective-C:
2319 : : gnu-attributes objc-class-definition
2320 : : gnu-attributes objc-category-definition
2321 : : gnu-attributes objc-protocol-definition
2322 : :
2323 : : The simple-asm-expr and gnu-attributes are GNU extensions.
2324 : :
2325 : : This function does not handle __extension__; that is handled in its
2326 : : callers. ??? Following the old parser, __extension__ may start
2327 : : external declarations, declarations in functions and declarations
2328 : : at the start of "for" loops, but not old-style parameter
2329 : : declarations.
2330 : :
2331 : : C99 requires declaration specifiers in a function definition; the
2332 : : absence is diagnosed through the diagnosis of implicit int. In GNU
2333 : : C we also allow but diagnose declarations without declaration
2334 : : specifiers, but only at top level (elsewhere they conflict with
2335 : : other syntax).
2336 : :
2337 : : In Objective-C, declarations of the looping variable in a foreach
2338 : : statement are exceptionally terminated by 'in' (for example, 'for
2339 : : (NSObject *object in array) { ... }').
2340 : :
2341 : : OpenMP:
2342 : :
2343 : : declaration:
2344 : : threadprivate-directive
2345 : :
2346 : : GIMPLE:
2347 : :
2348 : : gimple-function-definition:
2349 : : declaration-specifiers[opt] __GIMPLE (gimple-or-rtl-pass-list) declarator
2350 : : declaration-list[opt] compound-statement
2351 : :
2352 : : rtl-function-definition:
2353 : : declaration-specifiers[opt] __RTL (gimple-or-rtl-pass-list) declarator
2354 : : declaration-list[opt] compound-statement */
2355 : :
2356 : : static tree
2357 : 62897540 : c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok,
2358 : : bool static_assert_ok, bool empty_ok,
2359 : : bool nested, bool start_attr_ok,
2360 : : bool simple_ok,
2361 : : tree *objc_foreach_object_declaration
2362 : : /* = NULL */,
2363 : : vec<c_token> *omp_declare_simd_clauses
2364 : : /* = NULL */,
2365 : : bool have_attrs /* = false */,
2366 : : tree attrs /* = NULL_TREE */,
2367 : : struct oacc_routine_data *oacc_routine_data
2368 : : /* = NULL */,
2369 : : bool *fallthru_attr_p /* = NULL */)
2370 : : {
2371 : 62897540 : struct c_declspecs *specs;
2372 : 62897540 : tree prefix_attrs;
2373 : 62897540 : tree all_prefix_attrs;
2374 : 62897540 : bool diagnosed_no_specs = false;
2375 : 62897540 : location_t here = c_parser_peek_token (parser)->location;
2376 : 62897540 : tree result = NULL_TREE;
2377 : :
2378 : 62897540 : add_debug_begin_stmt (c_parser_peek_token (parser)->location);
2379 : :
2380 : 62897540 : if (static_assert_ok
2381 : 125781734 : && c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
2382 : : {
2383 : 1851 : c_parser_static_assert_declaration (parser);
2384 : 1851 : return result;
2385 : : }
2386 : 62895689 : specs = build_null_declspecs ();
2387 : :
2388 : : /* Handle any standard attributes parsed in the caller. */
2389 : 62895689 : if (have_attrs)
2390 : : {
2391 : 143 : declspecs_add_attrs (here, specs, attrs);
2392 : 143 : specs->non_std_attrs_seen_p = false;
2393 : : }
2394 : :
2395 : : /* Try to detect an unknown type name when we have "A B" or "A *B". */
2396 : 62895689 : if (c_parser_peek_token (parser)->type == CPP_NAME
2397 : 5765961 : && c_parser_peek_token (parser)->id_kind == C_ID_ID
2398 : 9294 : && (c_parser_peek_2nd_token (parser)->type == CPP_NAME
2399 : 9185 : || c_parser_peek_2nd_token (parser)->type == CPP_MULT)
2400 : 62895822 : && (!nested || !lookup_name (c_parser_peek_token (parser)->value)))
2401 : : {
2402 : 131 : tree name = c_parser_peek_token (parser)->value;
2403 : :
2404 : : /* Issue a warning about NAME being an unknown type name, perhaps
2405 : : with some kind of hint.
2406 : : If the user forgot a "struct" etc, suggest inserting
2407 : : it. Otherwise, attempt to look for misspellings. */
2408 : 131 : gcc_rich_location richloc (here);
2409 : 131 : if (tag_exists_p (RECORD_TYPE, name))
2410 : : {
2411 : : /* This is not C++ with its implicit typedef. */
2412 : 3 : richloc.add_fixit_insert_before ("struct ");
2413 : 3 : error_at (&richloc,
2414 : : "unknown type name %qE;"
2415 : : " use %<struct%> keyword to refer to the type",
2416 : : name);
2417 : : }
2418 : 128 : else if (tag_exists_p (UNION_TYPE, name))
2419 : : {
2420 : 3 : richloc.add_fixit_insert_before ("union ");
2421 : 3 : error_at (&richloc,
2422 : : "unknown type name %qE;"
2423 : : " use %<union%> keyword to refer to the type",
2424 : : name);
2425 : : }
2426 : 125 : else if (tag_exists_p (ENUMERAL_TYPE, name))
2427 : : {
2428 : 3 : richloc.add_fixit_insert_before ("enum ");
2429 : 3 : error_at (&richloc,
2430 : : "unknown type name %qE;"
2431 : : " use %<enum%> keyword to refer to the type",
2432 : : name);
2433 : : }
2434 : : else
2435 : : {
2436 : 122 : auto_diagnostic_group d;
2437 : 122 : name_hint hint = lookup_name_fuzzy (name, FUZZY_LOOKUP_TYPENAME,
2438 : 122 : here);
2439 : 122 : if (const char *suggestion = hint.suggestion ())
2440 : : {
2441 : 12 : richloc.add_fixit_replace (suggestion);
2442 : 12 : error_at (&richloc,
2443 : : "unknown type name %qE; did you mean %qs?",
2444 : : name, suggestion);
2445 : : }
2446 : : else
2447 : 110 : error_at (here, "unknown type name %qE", name);
2448 : 122 : }
2449 : :
2450 : : /* Parse declspecs normally to get a correct pointer type, but avoid
2451 : : a further "fails to be a type name" error. Refuse nested functions
2452 : : since it is not how the user likely wants us to recover. */
2453 : 131 : c_parser_peek_token (parser)->type = CPP_KEYWORD;
2454 : 131 : c_parser_peek_token (parser)->keyword = RID_VOID;
2455 : 131 : c_parser_peek_token (parser)->value = error_mark_node;
2456 : 131 : fndef_ok = !nested;
2457 : 131 : }
2458 : :
2459 : : /* When there are standard attributes at the start of the
2460 : : declaration (to apply to the entity being declared), an
2461 : : init-declarator-list or function definition must be present. */
2462 : 62895689 : if (c_parser_nth_token_starts_std_attributes (parser, 1))
2463 : 528 : have_attrs = true;
2464 : :
2465 : 62895689 : c_parser_declspecs (parser, specs, true, true, start_attr_ok,
2466 : : true, true, start_attr_ok, true, cla_nonabstract_decl);
2467 : 62895689 : if (parser->error)
2468 : : {
2469 : 33 : c_parser_skip_to_end_of_block_or_statement (parser);
2470 : 33 : return result;
2471 : : }
2472 : 62895656 : if (nested && !specs->declspecs_seen_p)
2473 : : {
2474 : 63 : c_parser_error (parser, "expected declaration specifiers");
2475 : 63 : c_parser_skip_to_end_of_block_or_statement (parser);
2476 : 63 : return result;
2477 : : }
2478 : :
2479 : 62895593 : finish_declspecs (specs);
2480 : 62895593 : bool gnu_auto_type_p = specs->typespec_word == cts_auto_type;
2481 : 62895593 : bool std_auto_type_p = specs->c23_auto_p;
2482 : 62895593 : bool any_auto_type_p = gnu_auto_type_p || std_auto_type_p;
2483 : 62895593 : gcc_assert (!(gnu_auto_type_p && std_auto_type_p));
2484 : 62895593 : const char *auto_type_keyword = gnu_auto_type_p ? "__auto_type" : "auto";
2485 : 62895593 : if (specs->constexpr_p)
2486 : : {
2487 : : /* An underspecified declaration may not declare tags or members
2488 : : or structures or unions; it is undefined behavior to declare
2489 : : the members of an enumeration. Where the structure, union or
2490 : : enumeration type is declared within an initializer, this is
2491 : : diagnosed elsewhere. Diagnose here the case of declaring
2492 : : such a type in the type specifiers of a constexpr
2493 : : declaration. */
2494 : 364 : switch (specs->typespec_kind)
2495 : : {
2496 : 6 : case ctsk_tagfirstref:
2497 : 6 : case ctsk_tagfirstref_attrs:
2498 : 6 : error_at (here, "%qT declared in underspecified object declaration",
2499 : : specs->type);
2500 : 6 : break;
2501 : :
2502 : 10 : case ctsk_tagdef:
2503 : 10 : error_at (here, "%qT defined in underspecified object declaration",
2504 : : specs->type);
2505 : 10 : break;
2506 : :
2507 : : default:
2508 : : break;
2509 : : }
2510 : : }
2511 : :
2512 : 62895593 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2513 : : {
2514 : 491374 : bool handled_assume = false;
2515 : 491374 : if (specs->attrs
2516 : 498 : && !nested
2517 : 121 : && specs->typespec_kind == ctsk_none
2518 : 491477 : && c_parser_handle_statement_omp_attributes (parser, specs->attrs,
2519 : : NULL))
2520 : : {
2521 : 82 : if (specs->attrs)
2522 : 0 : c_warn_unused_attributes (specs->attrs);
2523 : 165 : while (parser->in_omp_attribute_pragma)
2524 : : {
2525 : 83 : gcc_assert (c_parser_next_token_is (parser, CPP_PRAGMA));
2526 : 83 : c_parser_pragma (parser, pragma_external, NULL, NULL_TREE);
2527 : : }
2528 : 82 : c_parser_consume_token (parser);
2529 : 82 : return result;
2530 : : }
2531 : 491292 : if (specs->typespec_kind == ctsk_none
2532 : 491292 : && lookup_attribute ("gnu", "assume", specs->attrs))
2533 : : {
2534 : 38 : handled_assume = true;
2535 : 38 : specs->attrs
2536 : 38 : = handle_assume_attribute (here, specs->attrs, nested);
2537 : : }
2538 : 491292 : if (any_auto_type_p)
2539 : 6 : error_at (here, "%qs in empty declaration", auto_type_keyword);
2540 : 491286 : else if (specs->typespec_kind == ctsk_none
2541 : 491286 : && attribute_fallthrough_p (specs->attrs))
2542 : : {
2543 : 328 : if (fallthru_attr_p != NULL)
2544 : 327 : *fallthru_attr_p = true;
2545 : 328 : if (nested)
2546 : : {
2547 : 327 : tree fn = build_call_expr_internal_loc (here, IFN_FALLTHROUGH,
2548 : : void_type_node, 0);
2549 : 327 : add_stmt (fn);
2550 : : }
2551 : : else
2552 : 1 : pedwarn (here, OPT_Wattributes,
2553 : : "%<fallthrough%> attribute at top level");
2554 : : }
2555 : 490958 : else if (empty_ok
2556 : 490941 : && !(have_attrs && specs->non_std_attrs_seen_p)
2557 : 490938 : && !handled_assume)
2558 : 490900 : shadow_tag (specs);
2559 : : else
2560 : : {
2561 : 58 : shadow_tag_warned (specs, 1);
2562 : 58 : if (!handled_assume)
2563 : 20 : pedwarn (here, 0, "empty declaration");
2564 : : }
2565 : : /* We still have to evaluate size expressions. */
2566 : 491292 : if (specs->expr)
2567 : 106 : add_stmt (fold_convert (void_type_node, specs->expr));
2568 : 491292 : c_parser_consume_token (parser);
2569 : 491292 : if (oacc_routine_data)
2570 : 0 : c_finish_oacc_routine (oacc_routine_data, NULL_TREE, false);
2571 : 491292 : return result;
2572 : : }
2573 : 62404219 : else if (specs->typespec_kind == ctsk_none
2574 : : && nested
2575 : : /* Only parse __attribute__((musttail)) when called from
2576 : : c_parser_compound_statement_nostart. This certainly isn't
2577 : : a declaration in that case, but we don't do tentative parsing
2578 : : of GNU attributes right now. */
2579 : 9771 : && fallthru_attr_p
2580 : 62404300 : && c_parser_next_token_is_keyword (parser, RID_RETURN))
2581 : : {
2582 : 12 : attr_state astate = {};
2583 : 12 : specs->attrs = c_parser_handle_musttail (parser, specs->attrs, astate);
2584 : 12 : if (astate.musttail_p)
2585 : : {
2586 : 12 : if (specs->attrs)
2587 : : {
2588 : 0 : auto_urlify_attributes sentinel;
2589 : 0 : warning_at (c_parser_peek_token (parser)->location,
2590 : 0 : OPT_Wattributes,
2591 : : "attribute %<musttail%> mixed with other attributes "
2592 : : "on %<return%> statement");
2593 : 0 : }
2594 : 12 : c_parser_statement_after_labels (parser, NULL, NULL_TREE, NULL,
2595 : : astate);
2596 : 12 : return result;
2597 : : }
2598 : : }
2599 : :
2600 : : /* Provide better error recovery. Note that a type name here is usually
2601 : : better diagnosed as a redeclaration. */
2602 : 62404207 : if (empty_ok
2603 : 62391075 : && specs->typespec_kind == ctsk_tagdef
2604 : 761638 : && c_parser_next_token_starts_declspecs (parser)
2605 : 62404237 : && !c_parser_next_token_is (parser, CPP_NAME))
2606 : : {
2607 : 9 : c_parser_error (parser, "expected %<;%>, identifier or %<(%>");
2608 : 9 : parser->error = false;
2609 : 9 : shadow_tag_warned (specs, 1);
2610 : 9 : return result;
2611 : : }
2612 : 62404198 : else if (c_dialect_objc () && !any_auto_type_p)
2613 : : {
2614 : : /* Prefix attributes are an error on method decls. */
2615 : 0 : switch (c_parser_peek_token (parser)->type)
2616 : : {
2617 : 0 : case CPP_PLUS:
2618 : 0 : case CPP_MINUS:
2619 : 0 : if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
2620 : : return result;
2621 : 0 : if (specs->attrs)
2622 : : {
2623 : 0 : warning_at (c_parser_peek_token (parser)->location,
2624 : 0 : OPT_Wattributes,
2625 : : "prefix attributes are ignored for methods");
2626 : 0 : specs->attrs = NULL_TREE;
2627 : : }
2628 : 0 : if (fndef_ok)
2629 : 0 : c_parser_objc_method_definition (parser);
2630 : : else
2631 : 0 : c_parser_objc_methodproto (parser);
2632 : 0 : return result;
2633 : 0 : break;
2634 : 0 : default:
2635 : 0 : break;
2636 : : }
2637 : : /* This is where we parse 'attributes @interface ...',
2638 : : 'attributes @implementation ...', 'attributes @protocol ...'
2639 : : (where attributes could be, for example, __attribute__
2640 : : ((deprecated)).
2641 : : */
2642 : 0 : switch (c_parser_peek_token (parser)->keyword)
2643 : : {
2644 : 0 : case RID_AT_INTERFACE:
2645 : 0 : {
2646 : 0 : if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
2647 : : return result;
2648 : 0 : c_parser_objc_class_definition (parser, specs->attrs);
2649 : 0 : return result;
2650 : : }
2651 : 0 : break;
2652 : 0 : case RID_AT_IMPLEMENTATION:
2653 : 0 : {
2654 : 0 : if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
2655 : : return result;
2656 : 0 : if (specs->attrs)
2657 : : {
2658 : 0 : warning_at (c_parser_peek_token (parser)->location,
2659 : 0 : OPT_Wattributes,
2660 : : "prefix attributes are ignored for implementations");
2661 : 0 : specs->attrs = NULL_TREE;
2662 : : }
2663 : 0 : c_parser_objc_class_definition (parser, NULL_TREE);
2664 : 0 : return result;
2665 : : }
2666 : 0 : break;
2667 : 0 : case RID_AT_PROTOCOL:
2668 : 0 : {
2669 : 0 : if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
2670 : : return result;
2671 : 0 : c_parser_objc_protocol_definition (parser, specs->attrs);
2672 : 0 : return result;
2673 : : }
2674 : 0 : break;
2675 : 0 : case RID_AT_ALIAS:
2676 : 0 : case RID_AT_CLASS:
2677 : 0 : case RID_AT_END:
2678 : 0 : case RID_AT_PROPERTY:
2679 : 0 : if (specs->attrs)
2680 : : {
2681 : 0 : c_parser_error (parser, "unexpected attribute");
2682 : 0 : specs->attrs = NULL;
2683 : : }
2684 : : break;
2685 : : default:
2686 : : break;
2687 : : }
2688 : : }
2689 : 62404198 : else if (attribute_fallthrough_p (specs->attrs))
2690 : 5 : warning_at (here, OPT_Wattributes,
2691 : : "%<fallthrough%> attribute not followed by %<;%>");
2692 : 62404193 : else if (lookup_attribute ("gnu", "assume", specs->attrs))
2693 : 2 : warning_at (here, OPT_Wattributes,
2694 : : "%<assume%> attribute not followed by %<;%>");
2695 : :
2696 : 124808391 : auto_vec<c_token> omp_declare_simd_attr_clauses;
2697 : 62404198 : c_parser_handle_directive_omp_attributes (specs->attrs,
2698 : : omp_declare_simd_clauses,
2699 : : &omp_declare_simd_attr_clauses);
2700 : 62404198 : pending_xref_error ();
2701 : 62404198 : prefix_attrs = specs->attrs;
2702 : 62404198 : all_prefix_attrs = prefix_attrs;
2703 : 62404198 : specs->attrs = NULL_TREE;
2704 : 62404198 : bool more_than_one_decl = false;
2705 : 63241802 : while (true)
2706 : : {
2707 : 62823000 : struct c_declarator *declarator;
2708 : 62823000 : bool dummy = false;
2709 : 62823000 : timevar_id_t tv;
2710 : 62823000 : tree fnbody = NULL_TREE;
2711 : 62823000 : tree underspec_name = NULL_TREE;
2712 : 62823000 : auto_vec<c_token> omp_dsimd_idattr_clauses;
2713 : : /* Declaring either one or more declarators (in which case we
2714 : : should diagnose if there were no declaration specifiers) or a
2715 : : function definition (in which case the diagnostic for
2716 : : implicit int suffices). */
2717 : 125646000 : declarator = c_parser_declarator (parser,
2718 : 62823000 : specs->typespec_kind != ctsk_none,
2719 : : C_DTR_NORMAL, &dummy);
2720 : 62823000 : if (declarator == NULL)
2721 : : {
2722 : 215 : if (omp_declare_simd_clauses)
2723 : 1 : c_finish_omp_declare_simd (parser, NULL_TREE, NULL_TREE,
2724 : : omp_declare_simd_clauses);
2725 : 215 : if (oacc_routine_data)
2726 : 0 : c_finish_oacc_routine (oacc_routine_data, NULL_TREE, false);
2727 : : /* This check is here purely to improve the diagnostic. */
2728 : 215 : if (!simple_ok)
2729 : 195 : c_parser_skip_to_end_of_block_or_statement (parser);
2730 : 215 : return result;
2731 : : }
2732 : 62822785 : if (flag_openmp || flag_openmp_simd)
2733 : : {
2734 : : struct c_declarator *d = declarator;
2735 : 835229 : while (d->kind != cdk_id)
2736 : 362238 : d = d->declarator;
2737 : 472991 : vec<c_token> *dummy = NULL;
2738 : 472991 : c_parser_handle_directive_omp_attributes (d->u.id.attrs, dummy,
2739 : : &omp_dsimd_idattr_clauses);
2740 : : }
2741 : 62822785 : if (gnu_auto_type_p && declarator->kind != cdk_id)
2742 : : {
2743 : 1 : error_at (here,
2744 : : "%<__auto_type%> requires a plain identifier"
2745 : : " as declarator");
2746 : 1 : c_parser_skip_to_end_of_block_or_statement (parser);
2747 : 1 : return result;
2748 : : }
2749 : 62822784 : if (std_auto_type_p)
2750 : : {
2751 : : struct c_declarator *d = declarator;
2752 : 82 : while (d->kind == cdk_attrs)
2753 : 0 : d = d->declarator;
2754 : 82 : if (d->kind != cdk_id)
2755 : : {
2756 : 1 : error_at (here,
2757 : : "%<auto%> requires a plain identifier, possibly with"
2758 : : " attributes, as declarator");
2759 : 1 : c_parser_skip_to_end_of_block_or_statement (parser);
2760 : 1 : return result;
2761 : : }
2762 : 81 : underspec_name = d->u.id.id;
2763 : : }
2764 : 62822702 : else if (specs->constexpr_p)
2765 : : {
2766 : : struct c_declarator *d = declarator;
2767 : 428 : while (d->kind != cdk_id)
2768 : 79 : d = d->declarator;
2769 : 349 : underspec_name = d->u.id.id;
2770 : : }
2771 : 62822783 : if (c_parser_next_token_is (parser, CPP_EQ)
2772 : 56627411 : || c_parser_next_token_is (parser, CPP_COMMA)
2773 : 56324663 : || c_parser_next_token_is (parser, CPP_SEMICOLON)
2774 : 48407113 : || c_parser_next_token_is_keyword (parser, RID_ASM)
2775 : 47550820 : || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)
2776 : 98203043 : || c_parser_next_token_is_keyword (parser, RID_IN))
2777 : : {
2778 : 27442523 : tree asm_name = NULL_TREE;
2779 : 27442523 : tree postfix_attrs = NULL_TREE;
2780 : 27442523 : if (!diagnosed_no_specs && !specs->declspecs_seen_p)
2781 : : {
2782 : 78 : diagnosed_no_specs = true;
2783 : 78 : pedwarn (here, 0, "data definition has no type or storage class");
2784 : : }
2785 : : /* Having seen a data definition, there cannot now be a
2786 : : function definition. */
2787 : 27442523 : fndef_ok = false;
2788 : 27442523 : if (c_parser_next_token_is_keyword (parser, RID_ASM))
2789 : 856293 : asm_name = c_parser_simple_asm_expr (parser);
2790 : 27442523 : if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2791 : : {
2792 : 12980859 : postfix_attrs = c_parser_gnu_attributes (parser);
2793 : 12980859 : if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
2794 : : {
2795 : : /* This means there is an attribute specifier after
2796 : : the declarator in a function definition. Provide
2797 : : some more information for the user. */
2798 : 1 : error_at (here, "attributes should be specified before the "
2799 : : "declarator in a function definition");
2800 : 1 : c_parser_skip_to_end_of_block_or_statement (parser);
2801 : 1 : return result;
2802 : : }
2803 : : }
2804 : 27442522 : if (c_parser_next_token_is (parser, CPP_EQ))
2805 : : {
2806 : 6196784 : tree d;
2807 : 6196784 : struct c_expr init;
2808 : 6196784 : location_t init_loc;
2809 : 6196784 : c_parser_consume_token (parser);
2810 : 6196784 : if (any_auto_type_p)
2811 : : {
2812 : 1908 : init_loc = c_parser_peek_token (parser)->location;
2813 : 1908 : rich_location richloc (line_table, init_loc);
2814 : 1908 : unsigned int underspec_state = 0;
2815 : 1908 : if (std_auto_type_p)
2816 : 79 : underspec_state =
2817 : 79 : start_underspecified_init (init_loc, underspec_name);
2818 : 1908 : start_init (NULL_TREE, asm_name,
2819 : 1908 : (global_bindings_p ()
2820 : 1844 : || specs->storage_class == csc_static
2821 : 3750 : || specs->constexpr_p),
2822 : 1908 : specs->constexpr_p, &richloc);
2823 : : /* A parameter is initialized, which is invalid. Don't
2824 : : attempt to instrument the initializer. */
2825 : 1908 : sanitize_code_type flag_sanitize_save = flag_sanitize;
2826 : 1908 : if (nested && !empty_ok)
2827 : 30 : flag_sanitize = 0;
2828 : 1908 : init = c_parser_expr_no_commas (parser, NULL);
2829 : 1908 : if (std_auto_type_p)
2830 : 79 : finish_underspecified_init (underspec_name,
2831 : : underspec_state);
2832 : 1908 : flag_sanitize = flag_sanitize_save;
2833 : 1908 : if (gnu_auto_type_p
2834 : 1829 : && TREE_CODE (init.value) == COMPONENT_REF
2835 : 1909 : && DECL_C_BIT_FIELD (TREE_OPERAND (init.value, 1)))
2836 : 1 : error_at (here,
2837 : : "%<__auto_type%> used with a bit-field"
2838 : : " initializer");
2839 : 1908 : init = convert_lvalue_to_rvalue (init_loc, init, true, true,
2840 : : true);
2841 : 1908 : tree init_type = TREE_TYPE (init.value);
2842 : 1908 : bool vm_type = c_type_variably_modified_p (init_type);
2843 : 1908 : if (vm_type)
2844 : 95 : init.value = save_expr (init.value);
2845 : 1908 : finish_init ();
2846 : 1908 : specs->typespec_kind = ctsk_typeof;
2847 : 1908 : specs->locations[cdw_typedef] = init_loc;
2848 : 1908 : specs->typedef_p = true;
2849 : 1908 : specs->type = init_type;
2850 : 1908 : if (specs->postfix_attrs)
2851 : : {
2852 : : /* Postfix [[]] attributes are valid with C23
2853 : : auto, although not with __auto_type, and
2854 : : modify the type given by the initializer. */
2855 : 2 : specs->postfix_attrs
2856 : 2 : = c_warn_type_attributes (specs->type,
2857 : : specs->postfix_attrs);
2858 : 2 : decl_attributes (&specs->type, specs->postfix_attrs, 0);
2859 : 2 : specs->postfix_attrs = NULL_TREE;
2860 : : }
2861 : 1908 : if (vm_type)
2862 : : {
2863 : 95 : bool maybe_const = true;
2864 : 95 : tree type_expr = c_fully_fold (init.value, false,
2865 : : &maybe_const);
2866 : 95 : specs->expr_const_operands &= maybe_const;
2867 : 95 : if (specs->expr)
2868 : 0 : specs->expr = build2 (COMPOUND_EXPR,
2869 : 0 : TREE_TYPE (type_expr),
2870 : : specs->expr, type_expr);
2871 : : else
2872 : 95 : specs->expr = type_expr;
2873 : : }
2874 : 1908 : d = start_decl (declarator, specs, true,
2875 : : chainon (postfix_attrs, all_prefix_attrs));
2876 : 1908 : if (!d)
2877 : 12 : d = error_mark_node;
2878 : 1908 : if (omp_declare_simd_clauses)
2879 : 0 : c_finish_omp_declare_simd (parser, d, NULL_TREE,
2880 : : omp_declare_simd_clauses);
2881 : 1908 : if (!omp_dsimd_idattr_clauses.is_empty ())
2882 : 0 : c_finish_omp_declare_simd (parser, d, NULL_TREE,
2883 : : &omp_dsimd_idattr_clauses);
2884 : 1908 : }
2885 : : else
2886 : : {
2887 : : /* The declaration of the variable is in effect while
2888 : : its initializer is parsed, except for a constexpr
2889 : : variable. */
2890 : 6194876 : init_loc = c_parser_peek_token (parser)->location;
2891 : 6194876 : rich_location richloc (line_table, init_loc);
2892 : 6194876 : unsigned int underspec_state = 0;
2893 : 6194876 : if (specs->constexpr_p)
2894 : 344 : underspec_state =
2895 : 344 : start_underspecified_init (init_loc, underspec_name);
2896 : 6194876 : d = start_decl (declarator, specs, true,
2897 : : chainon (postfix_attrs,
2898 : : all_prefix_attrs),
2899 : 6194876 : !specs->constexpr_p);
2900 : 6194876 : if (!d)
2901 : 4 : d = error_mark_node;
2902 : 6194876 : if (!specs->constexpr_p && omp_declare_simd_clauses)
2903 : 0 : c_finish_omp_declare_simd (parser, d, NULL_TREE,
2904 : : omp_declare_simd_clauses);
2905 : 6194876 : if (!specs->constexpr_p
2906 : 6194876 : && !omp_dsimd_idattr_clauses.is_empty ())
2907 : 0 : c_finish_omp_declare_simd (parser, d, NULL_TREE,
2908 : : &omp_dsimd_idattr_clauses);
2909 : 6194876 : start_init (d, asm_name,
2910 : 6018451 : TREE_STATIC (d) || specs->constexpr_p,
2911 : 6194876 : specs->constexpr_p, &richloc);
2912 : : /* A parameter is initialized, which is invalid. Don't
2913 : : attempt to instrument the initializer. */
2914 : 6194876 : sanitize_code_type flag_sanitize_save = flag_sanitize;
2915 : 6194876 : if (TREE_CODE (d) == PARM_DECL)
2916 : 35 : flag_sanitize = 0;
2917 : 6194876 : init = c_parser_initializer (parser, d);
2918 : 6194874 : flag_sanitize = flag_sanitize_save;
2919 : 6194874 : if (specs->constexpr_p)
2920 : : {
2921 : 344 : finish_underspecified_init (underspec_name,
2922 : : underspec_state);
2923 : 344 : d = pushdecl (d);
2924 : 344 : if (omp_declare_simd_clauses)
2925 : 0 : c_finish_omp_declare_simd (parser, d, NULL_TREE,
2926 : : omp_declare_simd_clauses);
2927 : 344 : if (!specs->constexpr_p
2928 : 344 : && !omp_dsimd_idattr_clauses.is_empty ())
2929 : 0 : c_finish_omp_declare_simd (parser, d, NULL_TREE,
2930 : : &omp_dsimd_idattr_clauses);
2931 : : }
2932 : 6194874 : finish_init ();
2933 : 6194874 : }
2934 : 6196782 : if (oacc_routine_data)
2935 : 0 : c_finish_oacc_routine (oacc_routine_data, d, false);
2936 : 6196782 : if (d != error_mark_node)
2937 : : {
2938 : 6196766 : maybe_warn_string_init (init_loc, TREE_TYPE (d), init);
2939 : 6196766 : finish_decl (d, init_loc, init.value,
2940 : : init.original_type, asm_name);
2941 : 6196766 : result = d;
2942 : : }
2943 : : }
2944 : : else
2945 : : {
2946 : 21245738 : if (any_auto_type_p || specs->constexpr_p)
2947 : : {
2948 : 8 : error_at (here,
2949 : : "%qs requires an initialized data declaration",
2950 : : any_auto_type_p ? auto_type_keyword : "constexpr");
2951 : 5 : c_parser_skip_to_end_of_block_or_statement (parser);
2952 : 5 : return result;
2953 : : }
2954 : :
2955 : 21245733 : location_t lastloc = UNKNOWN_LOCATION;
2956 : 21245733 : tree attrs = chainon (postfix_attrs, all_prefix_attrs);
2957 : 21245733 : tree d = start_decl (declarator, specs, false, attrs, true,
2958 : : &lastloc);
2959 : 21245732 : if (d && TREE_CODE (d) == FUNCTION_DECL)
2960 : : {
2961 : : /* Find the innermost declarator that is neither cdk_id
2962 : : nor cdk_attrs. */
2963 : : const struct c_declarator *decl = declarator;
2964 : : const struct c_declarator *last_non_id_attrs = NULL;
2965 : :
2966 : 29259120 : while (decl)
2967 : 29259120 : switch (decl->kind)
2968 : : {
2969 : 14802660 : case cdk_array:
2970 : 14802660 : case cdk_function:
2971 : 14802660 : case cdk_pointer:
2972 : 14802660 : last_non_id_attrs = decl;
2973 : 14802660 : decl = decl->declarator;
2974 : 14802660 : break;
2975 : :
2976 : 111 : case cdk_attrs:
2977 : 111 : decl = decl->declarator;
2978 : 111 : break;
2979 : :
2980 : : case cdk_id:
2981 : : decl = 0;
2982 : : break;
2983 : :
2984 : 0 : default:
2985 : 0 : gcc_unreachable ();
2986 : : }
2987 : :
2988 : : /* If it exists and is cdk_function declaration whose
2989 : : arguments have not been set yet, use its arguments. */
2990 : 14456349 : if (last_non_id_attrs
2991 : 13847711 : && last_non_id_attrs->kind == cdk_function)
2992 : : {
2993 : 13847711 : tree parms = last_non_id_attrs->u.arg_info->parms;
2994 : 13847711 : if (DECL_ARGUMENTS (d) == NULL_TREE
2995 : 13847711 : && DECL_INITIAL (d) == NULL_TREE)
2996 : 13399592 : DECL_ARGUMENTS (d) = parms;
2997 : :
2998 : 13847711 : warn_parm_array_mismatch (lastloc, d, parms);
2999 : : }
3000 : : }
3001 : 21245732 : if (omp_declare_simd_clauses
3002 : 21245732 : || !omp_dsimd_idattr_clauses.is_empty ())
3003 : : {
3004 : 480 : tree parms = NULL_TREE;
3005 : 480 : if (d && TREE_CODE (d) == FUNCTION_DECL)
3006 : : {
3007 : : struct c_declarator *ce = declarator;
3008 : 469 : while (ce != NULL)
3009 : 469 : if (ce->kind == cdk_function)
3010 : : {
3011 : 466 : parms = ce->u.arg_info->parms;
3012 : 466 : break;
3013 : : }
3014 : : else
3015 : 3 : ce = ce->declarator;
3016 : : }
3017 : 466 : if (parms)
3018 : 240 : temp_store_parm_decls (d, parms);
3019 : 480 : if (omp_declare_simd_clauses)
3020 : 460 : c_finish_omp_declare_simd (parser, d, parms,
3021 : : omp_declare_simd_clauses);
3022 : 480 : if (!specs->constexpr_p
3023 : 480 : && !omp_dsimd_idattr_clauses.is_empty ())
3024 : 22 : c_finish_omp_declare_simd (parser, d, parms,
3025 : : &omp_dsimd_idattr_clauses);
3026 : 480 : if (parms)
3027 : 240 : temp_pop_parm_decls ();
3028 : : }
3029 : 21245732 : if (oacc_routine_data)
3030 : 72 : c_finish_oacc_routine (oacc_routine_data, d, false);
3031 : 21245732 : if (d)
3032 : 21245724 : finish_decl (d, UNKNOWN_LOCATION, NULL_TREE,
3033 : : NULL_TREE, asm_name);
3034 : :
3035 : 21245732 : if (c_parser_next_token_is_keyword (parser, RID_IN))
3036 : : {
3037 : 0 : if (d)
3038 : 0 : *objc_foreach_object_declaration = d;
3039 : : else
3040 : 0 : *objc_foreach_object_declaration = error_mark_node;
3041 : : }
3042 : : }
3043 : 27442514 : if (c_parser_next_token_is (parser, CPP_COMMA))
3044 : : {
3045 : 418805 : more_than_one_decl = true;
3046 : 418805 : if (any_auto_type_p || specs->constexpr_p)
3047 : : {
3048 : 4 : error_at (here,
3049 : : "%qs may only be used with a single declarator",
3050 : : any_auto_type_p ? auto_type_keyword : "constexpr");
3051 : 3 : c_parser_skip_to_end_of_block_or_statement (parser);
3052 : 3 : return result;
3053 : : }
3054 : 418802 : c_parser_consume_token (parser);
3055 : 418802 : if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
3056 : 19 : all_prefix_attrs = chainon (c_parser_gnu_attributes (parser),
3057 : : prefix_attrs);
3058 : : else
3059 : : all_prefix_attrs = prefix_attrs;
3060 : 418802 : continue;
3061 : : }
3062 : 27023709 : else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3063 : : {
3064 : 27023569 : if (!simple_ok)
3065 : 27023470 : c_parser_consume_token (parser);
3066 : 27023569 : return result;
3067 : : }
3068 : 140 : else if (c_parser_next_token_is_keyword (parser, RID_IN))
3069 : : {
3070 : : /* This can only happen in Objective-C: we found the
3071 : : 'in' that terminates the declaration inside an
3072 : : Objective-C foreach statement. Do not consume the
3073 : : token, so that the caller can use it to determine
3074 : : that this indeed is a foreach context. */
3075 : : return result;
3076 : : }
3077 : : else
3078 : : {
3079 : 140 : if (!simple_ok)
3080 : : {
3081 : 48 : c_parser_error (parser, "expected %<,%> or %<;%>");
3082 : 48 : c_parser_skip_to_end_of_block_or_statement (parser);
3083 : : }
3084 : : /* It's not valid to use if (int i = 2, j = 3). */
3085 : 92 : else if (more_than_one_decl)
3086 : 4 : error_at (here, "declaration in condition can only declare "
3087 : : "a single object");
3088 : 140 : return result;
3089 : : }
3090 : : }
3091 : 35380260 : else if (any_auto_type_p || specs->constexpr_p)
3092 : : {
3093 : 4 : error_at (here,
3094 : : "%qs requires an initialized data declaration",
3095 : : any_auto_type_p ? auto_type_keyword : "constexpr");
3096 : 4 : c_parser_skip_to_end_of_block_or_statement (parser);
3097 : 4 : return result;
3098 : : }
3099 : 35380256 : else if (!fndef_ok)
3100 : : {
3101 : 76 : if (simple_ok && c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3102 : : /* Let c_parser_selection_header emit the error. */;
3103 : : else
3104 : : {
3105 : 36 : c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
3106 : : "%<asm%> or %<__attribute__%>");
3107 : 36 : c_parser_skip_to_end_of_block_or_statement (parser);
3108 : : }
3109 : 56 : return result;
3110 : : }
3111 : : /* Function definition (nested or otherwise). */
3112 : 35380200 : if (nested)
3113 : : {
3114 : 1576 : pedwarn (here, OPT_Wpedantic, "ISO C forbids nested functions");
3115 : 1576 : c_push_function_context ();
3116 : : }
3117 : 35380200 : if (!start_function (specs, declarator, all_prefix_attrs))
3118 : : {
3119 : : /* At this point we've consumed:
3120 : : declaration-specifiers declarator
3121 : : and the next token isn't CPP_EQ, CPP_COMMA, CPP_SEMICOLON,
3122 : : RID_ASM, RID_ATTRIBUTE, or RID_IN,
3123 : : but the
3124 : : declaration-specifiers declarator
3125 : : aren't grokkable as a function definition, so we have
3126 : : an error. */
3127 : 38 : gcc_assert (!c_parser_next_token_is (parser, CPP_SEMICOLON));
3128 : 38 : if (c_parser_next_token_starts_declspecs (parser))
3129 : : {
3130 : : /* If we have
3131 : : declaration-specifiers declarator decl-specs
3132 : : then assume we have a missing semicolon, which would
3133 : : give us:
3134 : : declaration-specifiers declarator decl-specs
3135 : : ^
3136 : : ;
3137 : : <~~~~~~~~~ declaration ~~~~~~~~~~>
3138 : : Use c_parser_require to get an error with a fix-it hint. */
3139 : 13 : c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>");
3140 : 13 : parser->error = false;
3141 : : }
3142 : : else
3143 : : {
3144 : : /* This can appear in many cases looking nothing like a
3145 : : function definition, so we don't give a more specific
3146 : : error suggesting there was one. */
3147 : 25 : c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
3148 : : "or %<__attribute__%>");
3149 : : }
3150 : 38 : if (nested)
3151 : 1 : c_pop_function_context ();
3152 : : break;
3153 : : }
3154 : :
3155 : 35380162 : if (DECL_DECLARED_INLINE_P (current_function_decl))
3156 : : tv = TV_PARSE_INLINE;
3157 : : else
3158 : 675320 : tv = TV_PARSE_FUNC;
3159 : 35380162 : auto_timevar at (g_timer, tv);
3160 : :
3161 : : /* Parse old-style parameter declarations. ??? Attributes are
3162 : : not allowed to start declaration specifiers here because of a
3163 : : syntax conflict between a function declaration with attribute
3164 : : suffix and a function definition with an attribute prefix on
3165 : : first old-style parameter declaration. Following the old
3166 : : parser, they are not accepted on subsequent old-style
3167 : : parameter declarations either. However, there is no
3168 : : ambiguity after the first declaration, nor indeed on the
3169 : : first as long as we don't allow postfix attributes after a
3170 : : declarator with a nonempty identifier list in a definition;
3171 : : and postfix attributes have never been accepted here in
3172 : : function definitions either. */
3173 : 35380162 : int save_debug_nonbind_markers_p = debug_nonbind_markers_p;
3174 : 35380162 : debug_nonbind_markers_p = 0;
3175 : 35380162 : c_parser_maybe_reclassify_token (parser);
3176 : 35380162 : while (c_parser_next_token_is_not (parser, CPP_EOF)
3177 : 70786262 : && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE))
3178 : 12977 : c_parser_declaration_or_fndef (parser, false, false, false,
3179 : : true, false, false);
3180 : 35380162 : debug_nonbind_markers_p = save_debug_nonbind_markers_p;
3181 : 35380162 : store_parm_decls ();
3182 : 35380162 : if (omp_declare_simd_clauses)
3183 : 289 : c_finish_omp_declare_simd (parser, current_function_decl, NULL_TREE,
3184 : : omp_declare_simd_clauses);
3185 : 35380162 : if (!omp_dsimd_idattr_clauses.is_empty ())
3186 : 4 : c_finish_omp_declare_simd (parser, current_function_decl, NULL_TREE,
3187 : : &omp_dsimd_idattr_clauses);
3188 : 35380162 : if (oacc_routine_data)
3189 : 130 : c_finish_oacc_routine (oacc_routine_data, current_function_decl, true);
3190 : 35380162 : location_t startloc = c_parser_peek_token (parser)->location;
3191 : 35380162 : DECL_STRUCT_FUNCTION (current_function_decl)->function_start_locus
3192 : 35380162 : = startloc;
3193 : 35380162 : location_t endloc = startloc;
3194 : :
3195 : : /* If the definition was marked with __RTL, use the RTL parser now,
3196 : : consuming the function body. */
3197 : 35380162 : if (specs->declspec_il == cdil_rtl)
3198 : : {
3199 : 25 : endloc = c_parser_parse_rtl_body (parser, specs->gimple_or_rtl_pass);
3200 : :
3201 : : /* Normally, store_parm_decls sets next_is_function_body,
3202 : : anticipating a function body. We need a push_scope/pop_scope
3203 : : pair to flush out this state, or subsequent function parsing
3204 : : will go wrong. */
3205 : 24 : push_scope ();
3206 : 24 : pop_scope ();
3207 : :
3208 : 24 : finish_function (endloc);
3209 : 24 : return result;
3210 : : }
3211 : : /* If the definition was marked with __GIMPLE then parse the
3212 : : function body as GIMPLE. */
3213 : 35380137 : else if (specs->declspec_il != cdil_none)
3214 : : {
3215 : 252 : bool saved = in_late_binary_op;
3216 : 252 : in_late_binary_op = true;
3217 : 252 : c_parser_parse_gimple_body (parser, specs->gimple_or_rtl_pass,
3218 : 252 : specs->declspec_il,
3219 : : specs->entry_bb_count);
3220 : 252 : in_late_binary_op = saved;
3221 : : }
3222 : : else
3223 : 35379885 : fnbody = c_parser_compound_statement (parser, &endloc);
3224 : 35380136 : tree fndecl = current_function_decl;
3225 : 35380136 : if (nested && specs->declspec_il == cdil_none)
3226 : : {
3227 : 1574 : tree decl = current_function_decl;
3228 : : /* Mark nested functions as needing static-chain initially.
3229 : : lower_nested_functions will recompute it but the
3230 : : DECL_STATIC_CHAIN flag is also used before that happens,
3231 : : by initializer_constant_valid_p. See gcc.dg/nested-fn-2.c. */
3232 : 1574 : DECL_STATIC_CHAIN (decl) = 1;
3233 : 1574 : add_stmt (fnbody);
3234 : 1574 : finish_function (endloc);
3235 : 1574 : c_pop_function_context ();
3236 : 1574 : add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
3237 : 1574 : }
3238 : 1 : else if (nested)
3239 : : {
3240 : 1 : if (specs->declspec_il == cdil_rtl)
3241 : 0 : error ("%<__RTL%> function cannot be a nested function");
3242 : : else
3243 : 1 : error ("%<__GIMPLE%> function cannot be a nested function");
3244 : 1 : finish_function (endloc);
3245 : 1 : c_pop_function_context ();
3246 : : }
3247 : : else
3248 : : {
3249 : 35378561 : if (fnbody)
3250 : 35378310 : add_stmt (fnbody);
3251 : 35378561 : finish_function (endloc);
3252 : : }
3253 : : /* Get rid of the empty stmt list for GIMPLE/RTL. */
3254 : 35380136 : if (specs->declspec_il != cdil_none)
3255 : 252 : DECL_SAVED_TREE (fndecl) = NULL_TREE;
3256 : :
3257 : 35380136 : break;
3258 : 27442821 : }
3259 : :
3260 : 35380174 : return result;
3261 : : }
3262 : :
3263 : : /* Parse an asm-definition (asm() outside a function body). This is a
3264 : : GNU extension.
3265 : :
3266 : : asm-definition:
3267 : : simple-asm-expr ;
3268 : : asm ( toplevel-asm-argument ) ;
3269 : :
3270 : : toplevel-asm-argument:
3271 : : asm-string-literal
3272 : : asm-string-literal : asm-operands[opt]
3273 : : asm-string-literal : asm-operands[opt] : asm-operands[opt]
3274 : :
3275 : : The :: token is considered equivalent to two consecutive : tokens. */
3276 : :
3277 : : static void
3278 : 172 : c_parser_asm_definition (c_parser *parser)
3279 : : {
3280 : 172 : location_t asm_loc = c_parser_peek_token (parser)->location;
3281 : 172 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
3282 : 172 : c_parser_consume_token (parser);
3283 : 172 : matching_parens parens;
3284 : 172 : tree asm_str = NULL_TREE;
3285 : 172 : tree outputs = NULL_TREE, inputs = NULL_TREE;
3286 : 172 : if (!parens.require_open (parser))
3287 : 5 : goto done;
3288 : 167 : asm_str = c_parser_asm_string_literal (parser);
3289 : 167 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3290 : : {
3291 : 135 : parens.require_close (parser);
3292 : 135 : goto done;
3293 : : }
3294 : 50 : for (int section = 0; section < 2; ++section)
3295 : : {
3296 : 48 : if (c_parser_next_token_is (parser, CPP_SCOPE))
3297 : : {
3298 : 6 : ++section;
3299 : 6 : if (section == 2)
3300 : : {
3301 : 0 : c_parser_error (parser, "expected %<)%>");
3302 : 1 : error_close_paren:
3303 : 1 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3304 : 1 : asm_str = NULL_TREE;
3305 : 1 : goto done;
3306 : : }
3307 : 6 : c_parser_consume_token (parser);
3308 : : }
3309 : 42 : else if (!c_parser_require (parser, CPP_COLON,
3310 : : "expected %<:%> or %<)%>",
3311 : : UNKNOWN_LOCATION, false))
3312 : 1 : goto error_close_paren;
3313 : 47 : if (!c_parser_next_token_is (parser, CPP_COLON)
3314 : 33 : && !c_parser_next_token_is (parser, CPP_SCOPE)
3315 : 80 : && !c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3316 : : {
3317 : 33 : if (section)
3318 : 22 : inputs = c_parser_asm_operands (parser);
3319 : : else
3320 : 11 : outputs = c_parser_asm_operands (parser);
3321 : : }
3322 : 47 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3323 : : break;
3324 : : }
3325 : :
3326 : 31 : if (!parens.require_close (parser))
3327 : : {
3328 : 2 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3329 : 2 : asm_str = NULL_TREE;
3330 : : }
3331 : :
3332 : 31 : if (asm_str)
3333 : 29 : asm_str = build_asm_expr (asm_loc, asm_str, outputs, inputs,
3334 : : NULL_TREE, NULL_TREE, false, false);
3335 : 170 : done:
3336 : 170 : if (asm_str)
3337 : 164 : symtab->finalize_toplevel_asm (asm_str);
3338 : 172 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3339 : 172 : }
3340 : :
3341 : : /* Parse a static assertion (C11 6.7.10).
3342 : :
3343 : : static_assert-declaration:
3344 : : static_assert-declaration-no-semi ;
3345 : : */
3346 : :
3347 : : static void
3348 : 1851 : c_parser_static_assert_declaration (c_parser *parser)
3349 : : {
3350 : 1851 : c_parser_static_assert_declaration_no_semi (parser);
3351 : 1851 : if (parser->error
3352 : 1851 : || !c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
3353 : 8 : c_parser_skip_to_end_of_block_or_statement (parser);
3354 : 1851 : }
3355 : :
3356 : : /* Parse a static assertion (C11 6.7.10), without the trailing
3357 : : semicolon.
3358 : :
3359 : : static_assert-declaration-no-semi:
3360 : : _Static_assert ( constant-expression , string-literal )
3361 : :
3362 : : C23:
3363 : : static_assert-declaration-no-semi:
3364 : : _Static_assert ( constant-expression )
3365 : : */
3366 : :
3367 : : static void
3368 : 1861 : c_parser_static_assert_declaration_no_semi (c_parser *parser)
3369 : : {
3370 : 1861 : location_t assert_loc, value_loc;
3371 : 1861 : tree value;
3372 : 1861 : tree string = NULL_TREE;
3373 : :
3374 : 1861 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT));
3375 : 1861 : tree spelling = c_parser_peek_token (parser)->value;
3376 : 1861 : assert_loc = c_parser_peek_token (parser)->location;
3377 : 1861 : if (flag_isoc99)
3378 : 1858 : pedwarn_c99 (assert_loc, OPT_Wpedantic,
3379 : : "ISO C99 does not support %qE", spelling);
3380 : : else
3381 : 3 : pedwarn_c99 (assert_loc, OPT_Wpedantic,
3382 : : "ISO C90 does not support %qE", spelling);
3383 : 1861 : c_parser_consume_token (parser);
3384 : 1861 : matching_parens parens;
3385 : 1861 : if (!parens.require_open (parser))
3386 : 15 : return;
3387 : 1860 : location_t value_tok_loc = c_parser_peek_token (parser)->location;
3388 : 1860 : value = convert_lvalue_to_rvalue (value_tok_loc,
3389 : : c_parser_expr_no_commas (parser, NULL),
3390 : : true, true).value;
3391 : 1860 : value_loc = EXPR_LOC_OR_LOC (value, value_tok_loc);
3392 : 1860 : if (c_parser_next_token_is (parser, CPP_COMMA))
3393 : : {
3394 : 1479 : c_parser_consume_token (parser);
3395 : 1479 : switch (c_parser_peek_token (parser)->type)
3396 : : {
3397 : 1476 : case CPP_STRING:
3398 : 1476 : case CPP_STRING16:
3399 : 1476 : case CPP_STRING32:
3400 : 1476 : case CPP_WSTRING:
3401 : 1476 : case CPP_UTF8STRING:
3402 : 1476 : string = c_parser_string_literal (parser, false, true).value;
3403 : 1476 : break;
3404 : 3 : default:
3405 : 3 : c_parser_error (parser, "expected string literal");
3406 : 3 : return;
3407 : : }
3408 : : }
3409 : 381 : else if (flag_isoc11)
3410 : : /* If pedantic for pre-C11, the use of _Static_assert itself will
3411 : : have been diagnosed, so do not also diagnose the use of this
3412 : : new C23 feature of _Static_assert. */
3413 : 380 : pedwarn_c11 (assert_loc, OPT_Wpedantic,
3414 : : "ISO C11 does not support omitting the string in "
3415 : : "%qE", spelling);
3416 : 1857 : parens.require_close (parser);
3417 : :
3418 : 1857 : if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
3419 : : {
3420 : 5 : error_at (value_loc, "expression in static assertion is not an integer");
3421 : 5 : return;
3422 : : }
3423 : 1852 : if (TREE_CODE (value) != INTEGER_CST)
3424 : : {
3425 : 12 : value = c_fully_fold (value, false, NULL);
3426 : : /* Strip no-op conversions. */
3427 : 24 : STRIP_TYPE_NOPS (value);
3428 : 12 : if (TREE_CODE (value) == INTEGER_CST)
3429 : 6 : pedwarn (value_loc, OPT_Wpedantic, "expression in static assertion "
3430 : : "is not an integer constant expression");
3431 : : }
3432 : 1852 : if (TREE_CODE (value) != INTEGER_CST)
3433 : : {
3434 : 6 : error_at (value_loc, "expression in static assertion is not constant");
3435 : 6 : return;
3436 : : }
3437 : 1846 : constant_expression_warning (value);
3438 : 1846 : if (integer_zerop (value))
3439 : : {
3440 : 11 : if (string)
3441 : 9 : error_at (assert_loc, "static assertion failed: %E", string);
3442 : : else
3443 : 2 : error_at (assert_loc, "static assertion failed");
3444 : : }
3445 : : }
3446 : :
3447 : : /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
3448 : : 6.7, C11 6.7), adding them to SPECS (which may already include some).
3449 : : Storage class specifiers are accepted iff SCSPEC_OK; type
3450 : : specifiers are accepted iff TYPESPEC_OK; alignment specifiers are
3451 : : accepted iff ALIGNSPEC_OK; gnu-attributes are accepted at the start
3452 : : iff START_ATTR_OK; __auto_type is accepted iff AUTO_TYPE_OK. In
3453 : : addition to the syntax shown, standard attributes are accepted at
3454 : : the start iff START_STD_ATTR_OK and at the end iff END_STD_ATTR_OK;
3455 : : unlike gnu-attributes, they are not accepted in the middle of the
3456 : : list. (This combines various different syntax productions in the C
3457 : : standard, and in some cases gnu-attributes and standard attributes
3458 : : at the start may already have been parsed before this function is
3459 : : called.)
3460 : :
3461 : : declaration-specifiers:
3462 : : storage-class-specifier declaration-specifiers[opt]
3463 : : type-specifier declaration-specifiers[opt]
3464 : : type-qualifier declaration-specifiers[opt]
3465 : : function-specifier declaration-specifiers[opt]
3466 : : alignment-specifier declaration-specifiers[opt]
3467 : :
3468 : : Function specifiers (inline) are from C99, and are currently
3469 : : handled as storage class specifiers, as is __thread. Alignment
3470 : : specifiers are from C11.
3471 : :
3472 : : C90 6.5.1, C99 6.7.1, C11 6.7.1:
3473 : : storage-class-specifier:
3474 : : typedef
3475 : : extern
3476 : : static
3477 : : auto
3478 : : register
3479 : : _Thread_local
3480 : :
3481 : : (_Thread_local is new in C11.)
3482 : :
3483 : : C99 6.7.4, C11 6.7.4:
3484 : : function-specifier:
3485 : : inline
3486 : : _Noreturn
3487 : :
3488 : : (_Noreturn is new in C11.)
3489 : :
3490 : : C90 6.5.2, C99 6.7.2, C11 6.7.2:
3491 : : type-specifier:
3492 : : void
3493 : : char
3494 : : short
3495 : : int
3496 : : long
3497 : : float
3498 : : double
3499 : : signed
3500 : : unsigned
3501 : : _Bool
3502 : : _Complex
3503 : : [_Imaginary removed in C99 TC2]
3504 : : _BitInt ( constant-expression )
3505 : : struct-or-union-specifier
3506 : : enum-specifier
3507 : : typedef-name
3508 : : atomic-type-specifier
3509 : :
3510 : : (_Bool and _Complex are new in C99.)
3511 : : (atomic-type-specifier is new in C11.)
3512 : : (_BitInt is new in C23.)
3513 : :
3514 : : C90 6.5.3, C99 6.7.3, C11 6.7.3:
3515 : :
3516 : : type-qualifier:
3517 : : const
3518 : : restrict
3519 : : volatile
3520 : : address-space-qualifier
3521 : : _Atomic
3522 : :
3523 : : (restrict is new in C99.)
3524 : : (_Atomic is new in C11.)
3525 : :
3526 : : GNU extensions:
3527 : :
3528 : : declaration-specifiers:
3529 : : gnu-attributes declaration-specifiers[opt]
3530 : :
3531 : : type-qualifier:
3532 : : address-space
3533 : :
3534 : : address-space:
3535 : : identifier recognized by the target
3536 : :
3537 : : storage-class-specifier:
3538 : : __thread
3539 : :
3540 : : type-specifier:
3541 : : typeof-specifier
3542 : : __auto_type
3543 : : __intN
3544 : : _Decimal32
3545 : : _Decimal64
3546 : : _Decimal128
3547 : : _Fract
3548 : : _Accum
3549 : : _Sat
3550 : :
3551 : : (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
3552 : : http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
3553 : :
3554 : : atomic-type-specifier
3555 : : _Atomic ( type-name )
3556 : :
3557 : : Objective-C:
3558 : :
3559 : : type-specifier:
3560 : : class-name objc-protocol-refs[opt]
3561 : : typedef-name objc-protocol-refs
3562 : : objc-protocol-refs
3563 : : */
3564 : :
3565 : : void
3566 : 325577998 : c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
3567 : : bool scspec_ok, bool typespec_ok, bool start_attr_ok,
3568 : : bool alignspec_ok, bool auto_type_ok,
3569 : : bool start_std_attr_ok, bool end_std_attr_ok,
3570 : : enum c_lookahead_kind la)
3571 : : {
3572 : 325577998 : bool attrs_ok = start_attr_ok;
3573 : 325577998 : bool seen_type = specs->typespec_kind != ctsk_none;
3574 : :
3575 : 325577998 : if (!typespec_ok)
3576 : 19020223 : gcc_assert (la == cla_prefer_id);
3577 : :
3578 : 325577998 : if (start_std_attr_ok
3579 : 325577998 : && c_parser_nth_token_starts_std_attributes (parser, 1))
3580 : : {
3581 : 563 : gcc_assert (!specs->non_std_attrs_seen_p);
3582 : 563 : location_t loc = c_parser_peek_token (parser)->location;
3583 : 563 : tree attrs = c_parser_std_attribute_specifier_sequence (parser);
3584 : 563 : declspecs_add_attrs (loc, specs, attrs);
3585 : 563 : specs->non_std_attrs_seen_p = false;
3586 : : }
3587 : :
3588 : 788862992 : while (c_parser_next_token_is (parser, CPP_NAME)
3589 : 366070086 : || c_parser_next_token_is (parser, CPP_KEYWORD)
3590 : 931207475 : || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
3591 : : {
3592 : 646518509 : struct c_typespec t;
3593 : 646518509 : tree attrs;
3594 : 646518509 : tree align;
3595 : 646518509 : location_t loc = c_parser_peek_token (parser)->location;
3596 : :
3597 : : /* If we cannot accept a type, exit if the next token must start
3598 : : one. Also, if we already have seen a tagged definition,
3599 : : a typename would be an error anyway and likely the user
3600 : : has simply forgotten a semicolon, so we exit. */
3601 : 630742646 : if ((!typespec_ok || specs->typespec_kind == ctsk_tagdef)
3602 : 16686585 : && c_parser_next_tokens_start_typename (parser, la)
3603 : 3767270 : && !c_parser_next_token_is_qualifier (parser)
3604 : 646518580 : && !c_parser_next_token_is_keyword (parser, RID_ALIGNAS))
3605 : : break;
3606 : :
3607 : 646518447 : if (c_parser_next_token_is (parser, CPP_NAME))
3608 : : {
3609 : 422792856 : c_token *name_token = c_parser_peek_token (parser);
3610 : 422792856 : tree value = name_token->value;
3611 : 422792856 : c_id_kind kind = name_token->id_kind;
3612 : :
3613 : 422792856 : if (kind == C_ID_ADDRSPACE)
3614 : : {
3615 : 174 : addr_space_t as
3616 : 174 : = name_token->keyword - RID_FIRST_ADDR_SPACE;
3617 : 174 : declspecs_add_addrspace (name_token->location, specs, as);
3618 : 174 : c_parser_consume_token (parser);
3619 : 174 : attrs_ok = true;
3620 : 239562113 : continue;
3621 : 174 : }
3622 : :
3623 : 422792682 : gcc_assert (!c_parser_next_token_is_qualifier (parser));
3624 : :
3625 : : /* If we cannot accept a type, and the next token must start one,
3626 : : exit. Do the same if we already have seen a tagged definition,
3627 : : since it would be an error anyway and likely the user has simply
3628 : : forgotten a semicolon. */
3629 : 422792682 : if (seen_type || !c_parser_next_tokens_start_typename (parser, la))
3630 : : break;
3631 : :
3632 : : /* Now at an unknown typename (C_ID_ID), a C_ID_TYPENAME or
3633 : : a C_ID_CLASSNAME. */
3634 : 239561939 : c_parser_consume_token (parser);
3635 : 239561939 : seen_type = true;
3636 : 239561939 : attrs_ok = true;
3637 : 239561939 : if (kind == C_ID_ID)
3638 : : {
3639 : 51 : auto_diagnostic_group d;
3640 : 51 : name_hint hint = lookup_name_fuzzy (value, FUZZY_LOOKUP_TYPENAME,
3641 : 51 : loc);
3642 : 51 : if (const char *suggestion = hint.suggestion ())
3643 : : {
3644 : 2 : gcc_rich_location richloc (loc);
3645 : 2 : richloc.add_fixit_replace (suggestion);
3646 : 2 : error_at (&richloc,
3647 : : "unknown type name %qE; did you mean %qs?",
3648 : : value, suggestion);
3649 : 2 : }
3650 : : else
3651 : 49 : error_at (loc, "unknown type name %qE", value);
3652 : 51 : t.kind = ctsk_typedef;
3653 : 51 : t.spec = error_mark_node;
3654 : 51 : }
3655 : 239561888 : else if (kind == C_ID_TYPENAME
3656 : 239561888 : && (!c_dialect_objc ()
3657 : 0 : || c_parser_next_token_is_not (parser, CPP_LESS)))
3658 : : {
3659 : 239561888 : t.kind = ctsk_typedef;
3660 : : /* For a typedef name, record the meaning, not the name.
3661 : : In case of 'foo foo, bar;'. */
3662 : 239561888 : t.spec = lookup_name (value);
3663 : : }
3664 : : else
3665 : : {
3666 : 0 : tree proto = NULL_TREE;
3667 : 0 : gcc_assert (c_dialect_objc ());
3668 : 0 : t.kind = ctsk_objc;
3669 : 0 : if (c_parser_next_token_is (parser, CPP_LESS))
3670 : 0 : proto = c_parser_objc_protocol_refs (parser);
3671 : 0 : t.spec = objc_get_protocol_qualified_type (value, proto);
3672 : : }
3673 : 239561939 : t.expr = NULL_TREE;
3674 : 239561939 : t.expr_const_operands = true;
3675 : 239561939 : t.has_enum_type_specifier = false;
3676 : 239561939 : declspecs_add_type (name_token->location, specs, t);
3677 : 239561939 : continue;
3678 : 239561939 : }
3679 : 223725591 : if (c_parser_next_token_is (parser, CPP_LESS))
3680 : : {
3681 : : /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
3682 : : nisse@lysator.liu.se. */
3683 : 0 : tree proto;
3684 : 0 : gcc_assert (c_dialect_objc ());
3685 : 0 : if (!typespec_ok || seen_type)
3686 : : break;
3687 : 0 : proto = c_parser_objc_protocol_refs (parser);
3688 : 0 : t.kind = ctsk_objc;
3689 : 0 : t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
3690 : 0 : t.expr = NULL_TREE;
3691 : 0 : t.expr_const_operands = true;
3692 : 0 : t.has_enum_type_specifier = false;
3693 : 0 : declspecs_add_type (loc, specs, t);
3694 : 0 : continue;
3695 : 0 : }
3696 : 223725591 : gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
3697 : 223725591 : switch (c_parser_peek_token (parser)->keyword)
3698 : : {
3699 : 88215036 : case RID_STATIC:
3700 : 88215036 : case RID_EXTERN:
3701 : 88215036 : case RID_REGISTER:
3702 : 88215036 : case RID_TYPEDEF:
3703 : 88215036 : case RID_INLINE:
3704 : 88215036 : case RID_NORETURN:
3705 : 88215036 : case RID_AUTO:
3706 : 88215036 : case RID_THREAD:
3707 : 88215036 : case RID_CONSTEXPR:
3708 : 88215036 : if (!scspec_ok)
3709 : 2710 : goto out;
3710 : 88214903 : attrs_ok = true;
3711 : : /* TODO: Distinguish between function specifiers (inline, noreturn)
3712 : : and storage class specifiers, either here or in
3713 : : declspecs_add_scspec. */
3714 : 88214903 : declspecs_add_scspec (loc, specs,
3715 : 88214903 : c_parser_peek_token (parser)->value);
3716 : 88214903 : c_parser_consume_token (parser);
3717 : 88214903 : break;
3718 : 1839 : case RID_AUTO_TYPE:
3719 : 1839 : if (!auto_type_ok)
3720 : 0 : goto out;
3721 : : /* Fall through. */
3722 : 80993317 : case RID_UNSIGNED:
3723 : 80993317 : case RID_LONG:
3724 : 80993317 : case RID_SHORT:
3725 : 80993317 : case RID_SIGNED:
3726 : 80993317 : case RID_COMPLEX:
3727 : 80993317 : case RID_INT:
3728 : 80993317 : case RID_CHAR:
3729 : 80993317 : case RID_FLOAT:
3730 : 80993317 : case RID_DOUBLE:
3731 : 80993317 : case RID_VOID:
3732 : 80993317 : case RID_DFLOAT32:
3733 : 80993317 : case RID_DFLOAT64:
3734 : 80993317 : case RID_DFLOAT128:
3735 : 80993317 : case RID_DFLOAT64X:
3736 : 80993317 : CASE_RID_FLOATN_NX:
3737 : 80993317 : case RID_BOOL:
3738 : 80993317 : case RID_FRACT:
3739 : 80993317 : case RID_ACCUM:
3740 : 80993317 : case RID_SAT:
3741 : 80993317 : case RID_INT_N_0:
3742 : 80993317 : case RID_INT_N_1:
3743 : 80993317 : case RID_INT_N_2:
3744 : 80993317 : case RID_INT_N_3:
3745 : 80993317 : if (!typespec_ok)
3746 : 0 : goto out;
3747 : 80993317 : attrs_ok = true;
3748 : 80993317 : seen_type = true;
3749 : 80993317 : if (c_dialect_objc ())
3750 : 0 : parser->objc_need_raw_identifier = true;
3751 : 80993317 : t.kind = ctsk_resword;
3752 : 80993317 : t.spec = c_parser_peek_token (parser)->value;
3753 : 80993317 : t.expr = NULL_TREE;
3754 : 80993317 : t.expr_const_operands = true;
3755 : 80993317 : t.has_enum_type_specifier = false;
3756 : 80993317 : declspecs_add_type (loc, specs, t);
3757 : 80993317 : c_parser_consume_token (parser);
3758 : 80993317 : break;
3759 : 231658 : case RID_ENUM:
3760 : 231658 : if (!typespec_ok)
3761 : 0 : goto out;
3762 : 231658 : attrs_ok = true;
3763 : 231658 : seen_type = true;
3764 : 231658 : t = c_parser_enum_specifier (parser);
3765 : 231658 : invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec);
3766 : 231658 : declspecs_add_type (loc, specs, t);
3767 : 231658 : break;
3768 : 2160953 : case RID_STRUCT:
3769 : 2160953 : case RID_UNION:
3770 : 2160953 : if (!typespec_ok)
3771 : 0 : goto out;
3772 : 2160953 : attrs_ok = true;
3773 : 2160953 : seen_type = true;
3774 : 2160953 : t = c_parser_struct_or_union_specifier (parser);
3775 : 2160953 : invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec);
3776 : 2160953 : declspecs_add_type (loc, specs, t);
3777 : 2160953 : break;
3778 : 806315 : case RID_TYPEOF:
3779 : 806315 : case RID_TYPEOF_UNQUAL:
3780 : : /* ??? The old parser rejected typeof after other type
3781 : : specifiers, but is a syntax error the best way of
3782 : : handling this? */
3783 : 806315 : if (!typespec_ok || seen_type)
3784 : 2 : goto out;
3785 : 806313 : attrs_ok = true;
3786 : 806313 : seen_type = true;
3787 : 806313 : t = c_parser_typeof_specifier (parser);
3788 : 806313 : declspecs_add_type (loc, specs, t);
3789 : 806313 : break;
3790 : 45587 : case RID_BITINT:
3791 : 45587 : if (!typespec_ok)
3792 : 0 : goto out;
3793 : : else
3794 : : {
3795 : 45587 : attrs_ok = true;
3796 : 45587 : seen_type = true;
3797 : 45587 : t.kind = ctsk_resword;
3798 : 45587 : t.spec = c_parser_peek_token (parser)->value;
3799 : 45587 : t.expr = error_mark_node;
3800 : 45587 : t.expr_const_operands = true;
3801 : 45587 : t.has_enum_type_specifier = false;
3802 : 45587 : c_parser_consume_token (parser);
3803 : 45587 : matching_parens parens;
3804 : 45587 : if (parens.require_open (parser))
3805 : : {
3806 : 45587 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
3807 : 45587 : t.expr = convert_lvalue_to_rvalue (loc, expr, true,
3808 : 45587 : true).value;
3809 : 45587 : parens.skip_until_found_close (parser);
3810 : : }
3811 : 45587 : declspecs_add_type (loc, specs, t);
3812 : : }
3813 : 45587 : break;
3814 : 32373 : case RID_ATOMIC:
3815 : : /* C parser handling of Objective-C constructs needs
3816 : : checking for correct lvalue-to-rvalue conversions, and
3817 : : the code in build_modify_expr handling various
3818 : : Objective-C cases, and that in build_unary_op handling
3819 : : Objective-C cases for increment / decrement, also needs
3820 : : updating; uses of TYPE_MAIN_VARIANT in objc_compare_types
3821 : : and objc_types_are_equivalent may also need updates. */
3822 : 32373 : if (c_dialect_objc ())
3823 : 0 : sorry ("%<_Atomic%> in Objective-C");
3824 : 32373 : if (flag_isoc99)
3825 : 32322 : pedwarn_c99 (loc, OPT_Wpedantic,
3826 : : "ISO C99 does not support the %<_Atomic%> qualifier");
3827 : : else
3828 : 51 : pedwarn_c99 (loc, OPT_Wpedantic,
3829 : : "ISO C90 does not support the %<_Atomic%> qualifier");
3830 : 32373 : attrs_ok = true;
3831 : 32373 : tree value;
3832 : 32373 : value = c_parser_peek_token (parser)->value;
3833 : 32373 : c_parser_consume_token (parser);
3834 : 64543 : if (typespec_ok && c_parser_next_token_is (parser, CPP_OPEN_PAREN))
3835 : : {
3836 : : /* _Atomic ( type-name ). */
3837 : 13430 : seen_type = true;
3838 : 13430 : c_parser_consume_token (parser);
3839 : 13430 : struct c_type_name *type = c_parser_type_name (parser);
3840 : 13430 : t.kind = ctsk_typeof;
3841 : 13430 : t.spec = error_mark_node;
3842 : 13430 : t.expr = NULL_TREE;
3843 : 13430 : t.expr_const_operands = true;
3844 : 13430 : t.has_enum_type_specifier = false;
3845 : 13430 : if (type != NULL)
3846 : 13429 : t.spec = groktypename (type, &t.expr,
3847 : : &t.expr_const_operands);
3848 : 13430 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3849 : : "expected %<)%>");
3850 : 13430 : if (t.spec != error_mark_node)
3851 : : {
3852 : 13429 : if (TREE_CODE (t.spec) == ARRAY_TYPE)
3853 : 1 : error_at (loc, "%<_Atomic%>-qualified array type");
3854 : 13428 : else if (TREE_CODE (t.spec) == FUNCTION_TYPE)
3855 : 1 : error_at (loc, "%<_Atomic%>-qualified function type");
3856 : 13427 : else if (TYPE_QUALS (t.spec) != TYPE_UNQUALIFIED)
3857 : 4 : error_at (loc, "%<_Atomic%> applied to a qualified type");
3858 : : else
3859 : 13423 : t.spec = c_build_qualified_type (t.spec, TYPE_QUAL_ATOMIC);
3860 : : }
3861 : 13430 : declspecs_add_type (loc, specs, t);
3862 : : }
3863 : : else
3864 : 18943 : declspecs_add_qual (loc, specs, value);
3865 : : break;
3866 : 16229450 : case RID_CONST:
3867 : 16229450 : case RID_VOLATILE:
3868 : 16229450 : case RID_RESTRICT:
3869 : 16229450 : attrs_ok = true;
3870 : 16229450 : declspecs_add_qual (loc, specs, c_parser_peek_token (parser)->value);
3871 : 16229450 : c_parser_consume_token (parser);
3872 : 16229450 : break;
3873 : 35007849 : case RID_ATTRIBUTE:
3874 : 35007849 : if (!attrs_ok)
3875 : 0 : goto out;
3876 : 35007849 : attrs = c_parser_gnu_attributes (parser);
3877 : 35007849 : declspecs_add_attrs (loc, specs, attrs);
3878 : 35007849 : break;
3879 : 216 : case RID_ALIGNAS:
3880 : 216 : if (!alignspec_ok)
3881 : 16 : goto out;
3882 : 200 : align = c_parser_alignas_specifier (parser);
3883 : 200 : declspecs_add_alignas (loc, specs, align);
3884 : 200 : break;
3885 : 253 : case RID_GIMPLE:
3886 : 253 : if (! flag_gimple)
3887 : 0 : error_at (loc, "%<__GIMPLE%> only valid with %<-fgimple%>");
3888 : 253 : c_parser_consume_token (parser);
3889 : 253 : specs->declspec_il = cdil_gimple;
3890 : 253 : specs->locations[cdw_gimple] = loc;
3891 : 253 : c_parser_gimple_or_rtl_pass_list (parser, specs);
3892 : 253 : break;
3893 : 25 : case RID_RTL:
3894 : 25 : c_parser_consume_token (parser);
3895 : 25 : specs->declspec_il = cdil_rtl;
3896 : 25 : specs->locations[cdw_rtl] = loc;
3897 : 25 : c_parser_gimple_or_rtl_pass_list (parser, specs);
3898 : 25 : break;
3899 : 2559 : default:
3900 : 2559 : goto out;
3901 : : }
3902 : : }
3903 : 325577998 : out:
3904 : 325577998 : if (end_std_attr_ok
3905 : 325577998 : && c_parser_nth_token_starts_std_attributes (parser, 1))
3906 : 115 : specs->postfix_attrs = c_parser_std_attribute_specifier_sequence (parser);
3907 : 325577998 : }
3908 : :
3909 : : /* Complain about a non-CPP_NAME within an enumerator list. */
3910 : :
3911 : : static void
3912 : 11 : report_bad_enum_name (c_parser *parser)
3913 : : {
3914 : 11 : if (!parser->error)
3915 : : {
3916 : 11 : c_token *token = c_parser_peek_token (parser);
3917 : 11 : switch (token->type)
3918 : : {
3919 : : default:
3920 : : break;
3921 : 6 : case CPP_CLOSE_BRACE:
3922 : : /* Give a nicer error for "enum {}". */
3923 : 6 : error_at (token->location,
3924 : : "empty enum is invalid");
3925 : 6 : parser->error = true;
3926 : 6 : return;
3927 : 3 : case CPP_KEYWORD:
3928 : : /* Give a nicer error for attempts to use "true" and "false"
3929 : : in enums with C23 onwards. */
3930 : 3 : if (token->keyword == RID_FALSE
3931 : 2 : || token->keyword == RID_TRUE)
3932 : : {
3933 : 2 : auto_diagnostic_group d;
3934 : 4 : error_at (token->location,
3935 : : "cannot use keyword %qs as enumeration constant",
3936 : 2 : IDENTIFIER_POINTER (token->value));
3937 : 2 : add_note_about_new_keyword (token->location,
3938 : : token->value);
3939 : 2 : parser->error = true;
3940 : 2 : return;
3941 : 2 : }
3942 : : break;
3943 : : }
3944 : : }
3945 : :
3946 : : /* Otherwise, a more generic error message. */
3947 : 3 : c_parser_error (parser, "expected identifier");
3948 : : }
3949 : :
3950 : : /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2, C11 6.7.2.2).
3951 : :
3952 : : enum-specifier:
3953 : : enum gnu-attributes[opt] identifier[opt] enum-type-specifier[opt]
3954 : : { enumerator-list } gnu-attributes[opt]
3955 : : enum gnu-attributes[opt] identifier[opt] enum-type-specifier[opt]
3956 : : { enumerator-list , } gnu-attributes[opt] enum-type-specifier[opt]
3957 : : enum gnu-attributes[opt] identifier
3958 : :
3959 : : The form with trailing comma is new in C99; enum-type-specifiers
3960 : : are new in C23. The forms with gnu-attributes are GNU extensions.
3961 : : In GNU C, we accept any expression without commas in the syntax
3962 : : (assignment expressions, not just conditional expressions);
3963 : : assignment expressions will be diagnosed as non-constant.
3964 : :
3965 : : enum-type-specifier:
3966 : : : specifier-qualifier-list
3967 : :
3968 : : enumerator-list:
3969 : : enumerator
3970 : : enumerator-list , enumerator
3971 : :
3972 : : enumerator:
3973 : : enumeration-constant attribute-specifier-sequence[opt]
3974 : : enumeration-constant attribute-specifier-sequence[opt]
3975 : : = constant-expression
3976 : :
3977 : : GNU Extensions:
3978 : :
3979 : : enumerator:
3980 : : enumeration-constant attribute-specifier-sequence[opt] gnu-attributes[opt]
3981 : : enumeration-constant attribute-specifier-sequence[opt] gnu-attributes[opt]
3982 : : = constant-expression
3983 : :
3984 : : */
3985 : :
3986 : : static struct c_typespec
3987 : 231658 : c_parser_enum_specifier (c_parser *parser)
3988 : : {
3989 : 231658 : struct c_typespec ret;
3990 : 231658 : bool have_std_attrs;
3991 : 231658 : bool potential_nesting_p = false;
3992 : 231658 : tree std_attrs = NULL_TREE;
3993 : 231658 : tree attrs;
3994 : 231658 : tree ident = NULL_TREE;
3995 : 231658 : tree fixed_underlying_type = NULL_TREE;
3996 : 231658 : location_t enum_loc;
3997 : 231658 : location_t ident_loc = UNKNOWN_LOCATION; /* Quiet warning. */
3998 : 231658 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM));
3999 : 231658 : c_parser_consume_token (parser);
4000 : 231658 : have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1);
4001 : 231658 : if (have_std_attrs)
4002 : 14 : std_attrs = c_parser_std_attribute_specifier_sequence (parser);
4003 : 231658 : attrs = c_parser_gnu_attributes (parser);
4004 : 231658 : enum_loc = c_parser_peek_token (parser)->location;
4005 : : /* Set the location in case we create a decl now. */
4006 : 231658 : c_parser_set_source_position_from_token (c_parser_peek_token (parser));
4007 : 231658 : if (c_parser_next_token_is (parser, CPP_NAME))
4008 : : {
4009 : 126472 : ident = c_parser_peek_token (parser)->value;
4010 : 126472 : ident_loc = c_parser_peek_token (parser)->location;
4011 : 126472 : enum_loc = ident_loc;
4012 : 126472 : c_parser_consume_token (parser);
4013 : : }
4014 : 231658 : if (c_parser_next_token_is (parser, CPP_COLON)
4015 : : /* Distinguish an enum-type-specifier from a bit-field
4016 : : declaration of the form "enum e : constant-expression;". */
4017 : 231658 : && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
4018 : : {
4019 : 168 : pedwarn_c11 (enum_loc, OPT_Wpedantic,
4020 : : "ISO C does not support specifying %<enum%> underlying "
4021 : : "types before C23");
4022 : 168 : if (ident)
4023 : : {
4024 : : /* The tag is in scope during the enum-type-specifier (which
4025 : : may refer to the tag inside typeof). */
4026 : 164 : ret = parser_xref_tag (ident_loc, ENUMERAL_TYPE, ident,
4027 : : have_std_attrs, std_attrs, true);
4028 : 164 : if (!ENUM_FIXED_UNDERLYING_TYPE_P (ret.spec))
4029 : 3 : error_at (enum_loc, "%<enum%> declared both with and without "
4030 : : "fixed underlying type");
4031 : 164 : potential_nesting_p = NULL_TREE == TYPE_VALUES (ret.spec);
4032 : : }
4033 : : else
4034 : : {
4035 : : /* There must be an enum definition, so this initialization
4036 : : (to avoid possible warnings about uninitialized data)
4037 : : will be replaced later (either with the results of that
4038 : : definition, or with the results of error handling for the
4039 : : case of no tag and no definition). */
4040 : 4 : ret.spec = NULL_TREE;
4041 : 4 : ret.kind = ctsk_tagdef;
4042 : 4 : ret.expr = NULL_TREE;
4043 : 4 : ret.expr_const_operands = true;
4044 : 4 : ret.has_enum_type_specifier = true;
4045 : : }
4046 : 168 : c_parser_consume_token (parser);
4047 : 168 : struct c_declspecs *specs = build_null_declspecs ();
4048 : 168 : c_parser_declspecs (parser, specs, false, true, false, false, false,
4049 : : false, true, cla_prefer_id);
4050 : 168 : finish_declspecs (specs);
4051 : 168 : if (specs->default_int_p)
4052 : 1 : error_at (enum_loc, "no %<enum%> underlying type specified");
4053 : 167 : else if (TREE_CODE (specs->type) != INTEGER_TYPE
4054 : 167 : && TREE_CODE (specs->type) != BOOLEAN_TYPE)
4055 : : {
4056 : 9 : error_at (enum_loc, "invalid %<enum%> underlying type");
4057 : 9 : specs->type = integer_type_node;
4058 : : }
4059 : 158 : else if (specs->restrict_p)
4060 : 1 : error_at (enum_loc, "invalid use of %<restrict%>");
4061 : 168 : fixed_underlying_type = TYPE_MAIN_VARIANT (specs->type);
4062 : 168 : if (ident)
4063 : : {
4064 : : /* The type specified must be consistent with any previously
4065 : : specified underlying type. If this is a newly declared
4066 : : type, it is now a complete type. */
4067 : 164 : if (ENUM_FIXED_UNDERLYING_TYPE_P (ret.spec)
4068 : 164 : && ENUM_UNDERLYING_TYPE (ret.spec) == NULL_TREE)
4069 : : {
4070 : 429 : TYPE_MIN_VALUE (ret.spec) =
4071 : 143 : TYPE_MIN_VALUE (fixed_underlying_type);
4072 : 429 : TYPE_MAX_VALUE (ret.spec) =
4073 : 143 : TYPE_MAX_VALUE (fixed_underlying_type);
4074 : 143 : TYPE_UNSIGNED (ret.spec) = TYPE_UNSIGNED (fixed_underlying_type);
4075 : 143 : SET_TYPE_ALIGN (ret.spec, TYPE_ALIGN (fixed_underlying_type));
4076 : 143 : TYPE_SIZE (ret.spec) = NULL_TREE;
4077 : 143 : TYPE_PRECISION (ret.spec) =
4078 : 143 : TYPE_PRECISION (fixed_underlying_type);
4079 : 143 : ENUM_UNDERLYING_TYPE (ret.spec) = fixed_underlying_type;
4080 : 143 : layout_type (ret.spec);
4081 : : }
4082 : 21 : else if (ENUM_FIXED_UNDERLYING_TYPE_P (ret.spec)
4083 : 37 : && !comptypes (fixed_underlying_type,
4084 : 16 : ENUM_UNDERLYING_TYPE (ret.spec)))
4085 : : {
4086 : 3 : error_at (enum_loc, "%<enum%> underlying type incompatible with "
4087 : : "previous declaration");
4088 : 3 : fixed_underlying_type = ENUM_UNDERLYING_TYPE (ret.spec);
4089 : : }
4090 : : }
4091 : : }
4092 : 231658 : if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
4093 : : {
4094 : : /* Parse an enum definition. */
4095 : 174881 : struct c_enum_contents the_enum;
4096 : 174881 : tree type;
4097 : 174881 : tree postfix_attrs;
4098 : : /* We chain the enumerators in reverse order, then put them in
4099 : : forward order at the end. */
4100 : 174881 : tree values;
4101 : 174881 : timevar_push (TV_PARSE_ENUM);
4102 : 174881 : type = start_enum (enum_loc, &the_enum, ident, fixed_underlying_type,
4103 : : potential_nesting_p);
4104 : 174881 : values = NULL_TREE;
4105 : 174881 : c_parser_consume_token (parser);
4106 : 5557354 : while (true)
4107 : : {
4108 : 5557354 : tree enum_id;
4109 : 5557354 : tree enum_value;
4110 : 5557354 : tree enum_decl;
4111 : 5557354 : bool seen_comma;
4112 : 5557354 : c_token *token;
4113 : 5557354 : location_t comma_loc = UNKNOWN_LOCATION; /* Quiet warning. */
4114 : 5557354 : location_t decl_loc, value_loc;
4115 : 5557354 : if (c_parser_next_token_is_not (parser, CPP_NAME))
4116 : : {
4117 : 11 : report_bad_enum_name (parser);
4118 : 11 : c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
4119 : 11 : values = error_mark_node;
4120 : 11 : break;
4121 : : }
4122 : 5557343 : token = c_parser_peek_token (parser);
4123 : 5557343 : enum_id = token->value;
4124 : : /* Set the location in case we create a decl now. */
4125 : 5557343 : c_parser_set_source_position_from_token (token);
4126 : 5557343 : decl_loc = value_loc = token->location;
4127 : 5557343 : c_parser_consume_token (parser);
4128 : : /* Parse any specified attributes. */
4129 : 5557343 : tree std_attrs = NULL_TREE;
4130 : 5557343 : if (c_parser_nth_token_starts_std_attributes (parser, 1))
4131 : 12 : std_attrs = c_parser_std_attribute_specifier_sequence (parser);
4132 : 5557343 : tree enum_attrs = chainon (std_attrs,
4133 : : c_parser_gnu_attributes (parser));
4134 : 5557343 : if (c_parser_next_token_is (parser, CPP_EQ))
4135 : : {
4136 : 3438615 : c_parser_consume_token (parser);
4137 : 3438615 : value_loc = c_parser_peek_token (parser)->location;
4138 : 3438615 : enum_value = convert_lvalue_to_rvalue (value_loc,
4139 : : (c_parser_expr_no_commas
4140 : : (parser, NULL)),
4141 : : true, true).value;
4142 : : }
4143 : : else
4144 : : enum_value = NULL_TREE;
4145 : 5557343 : enum_decl = build_enumerator (decl_loc, value_loc,
4146 : : &the_enum, enum_id, enum_value);
4147 : 5557343 : if (enum_attrs)
4148 : 20 : decl_attributes (&TREE_PURPOSE (enum_decl), enum_attrs, 0);
4149 : 5557343 : TREE_CHAIN (enum_decl) = values;
4150 : 5557343 : values = enum_decl;
4151 : 5557343 : seen_comma = false;
4152 : 5557343 : if (c_parser_next_token_is (parser, CPP_COMMA))
4153 : : {
4154 : 5402684 : comma_loc = c_parser_peek_token (parser)->location;
4155 : 5402684 : seen_comma = true;
4156 : 5402684 : c_parser_consume_token (parser);
4157 : : }
4158 : 5557343 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
4159 : : {
4160 : 174855 : if (seen_comma)
4161 : 20211 : pedwarn_c90 (comma_loc, OPT_Wpedantic,
4162 : : "comma at end of enumerator list");
4163 : 174855 : c_parser_consume_token (parser);
4164 : 174855 : break;
4165 : : }
4166 : 5382488 : if (!seen_comma)
4167 : : {
4168 : 15 : c_parser_error (parser, "expected %<,%> or %<}%>");
4169 : 15 : c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
4170 : 15 : values = error_mark_node;
4171 : 15 : break;
4172 : : }
4173 : : }
4174 : 174881 : postfix_attrs = c_parser_gnu_attributes (parser);
4175 : 174881 : ret.spec = finish_enum (type, nreverse (values),
4176 : : chainon (std_attrs,
4177 : : chainon (attrs, postfix_attrs)));
4178 : 174881 : ret.kind = ctsk_tagdef;
4179 : 174881 : ret.expr = NULL_TREE;
4180 : 174881 : ret.expr_const_operands = true;
4181 : 174881 : ret.has_enum_type_specifier = fixed_underlying_type != NULL_TREE;
4182 : 174881 : timevar_pop (TV_PARSE_ENUM);
4183 : 174881 : return ret;
4184 : : }
4185 : 56777 : else if (!ident)
4186 : : {
4187 : 1 : c_parser_error (parser, "expected %<{%>");
4188 : 1 : ret.spec = error_mark_node;
4189 : 1 : ret.kind = ctsk_tagref;
4190 : 1 : ret.expr = NULL_TREE;
4191 : 1 : ret.expr_const_operands = true;
4192 : 1 : ret.has_enum_type_specifier = false;
4193 : 1 : return ret;
4194 : : }
4195 : : /* Attributes may only appear when the members are defined or in
4196 : : certain forward declarations (treat enum forward declarations in
4197 : : GNU C analogously to struct and union forward declarations in
4198 : : standard C). */
4199 : 56777 : if (have_std_attrs && c_parser_next_token_is_not (parser, CPP_SEMICOLON))
4200 : 1 : c_parser_error (parser, "expected %<;%>");
4201 : 56776 : if (fixed_underlying_type == NULL_TREE)
4202 : : {
4203 : 56727 : ret = parser_xref_tag (ident_loc, ENUMERAL_TYPE, ident, have_std_attrs,
4204 : : std_attrs, false);
4205 : : /* In ISO C, enumerated types without a fixed underlying type
4206 : : can be referred to only if already defined. */
4207 : 56727 : if (pedantic && !COMPLETE_TYPE_P (ret.spec))
4208 : : {
4209 : 11 : gcc_assert (ident);
4210 : 11 : pedwarn (enum_loc, OPT_Wpedantic,
4211 : : "ISO C forbids forward references to %<enum%> types");
4212 : : }
4213 : : }
4214 : : return ret;
4215 : : }
4216 : :
4217 : : /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1, C11 6.7.2.1).
4218 : :
4219 : : struct-or-union-specifier:
4220 : : struct-or-union attribute-specifier-sequence[opt] gnu-attributes[opt]
4221 : : identifier[opt] { struct-contents } gnu-attributes[opt]
4222 : : struct-or-union attribute-specifier-sequence[opt] gnu-attributes[opt]
4223 : : identifier
4224 : :
4225 : : struct-contents:
4226 : : struct-declaration-list
4227 : :
4228 : : struct-declaration-list:
4229 : : struct-declaration ;
4230 : : struct-declaration-list struct-declaration ;
4231 : :
4232 : : GNU extensions:
4233 : :
4234 : : struct-contents:
4235 : : empty
4236 : : struct-declaration
4237 : : struct-declaration-list struct-declaration
4238 : :
4239 : : struct-declaration-list:
4240 : : struct-declaration-list ;
4241 : : ;
4242 : :
4243 : : (Note that in the syntax here, unlike that in ISO C, the semicolons
4244 : : are included here rather than in struct-declaration, in order to
4245 : : describe the syntax with extra semicolons and missing semicolon at
4246 : : end.)
4247 : :
4248 : : Objective-C:
4249 : :
4250 : : struct-declaration-list:
4251 : : @defs ( class-name )
4252 : :
4253 : : (Note this does not include a trailing semicolon, but can be
4254 : : followed by further declarations, and gets a pedwarn-if-pedantic
4255 : : when followed by a semicolon.) */
4256 : :
4257 : : static struct c_typespec
4258 : 2160953 : c_parser_struct_or_union_specifier (c_parser *parser)
4259 : : {
4260 : 2160953 : struct c_typespec ret;
4261 : 2160953 : bool have_std_attrs;
4262 : 2160953 : tree std_attrs = NULL_TREE;
4263 : 2160953 : tree attrs;
4264 : 2160953 : tree ident = NULL_TREE;
4265 : 2160953 : location_t struct_loc;
4266 : 2160953 : location_t ident_loc = UNKNOWN_LOCATION;
4267 : 2160953 : enum tree_code code;
4268 : 2160953 : switch (c_parser_peek_token (parser)->keyword)
4269 : : {
4270 : : case RID_STRUCT:
4271 : : code = RECORD_TYPE;
4272 : : break;
4273 : 407156 : case RID_UNION:
4274 : 407156 : code = UNION_TYPE;
4275 : 407156 : break;
4276 : 0 : default:
4277 : 0 : gcc_unreachable ();
4278 : : }
4279 : 2160953 : struct_loc = c_parser_peek_token (parser)->location;
4280 : 2160953 : c_parser_consume_token (parser);
4281 : 2160953 : have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1);
4282 : 2160953 : if (have_std_attrs)
4283 : 34 : std_attrs = c_parser_std_attribute_specifier_sequence (parser);
4284 : 2160953 : attrs = c_parser_gnu_attributes (parser);
4285 : :
4286 : : /* Set the location in case we create a decl now. */
4287 : 2160953 : c_parser_set_source_position_from_token (c_parser_peek_token (parser));
4288 : :
4289 : 2160953 : if (c_parser_next_token_is (parser, CPP_NAME))
4290 : : {
4291 : 1483988 : ident = c_parser_peek_token (parser)->value;
4292 : 1483988 : ident_loc = c_parser_peek_token (parser)->location;
4293 : 1483988 : struct_loc = ident_loc;
4294 : 1483988 : c_parser_consume_token (parser);
4295 : : }
4296 : 2160953 : if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
4297 : : {
4298 : : /* Parse a struct or union definition. Start the scope of the
4299 : : tag before parsing components. */
4300 : 1152807 : class c_struct_parse_info *struct_info;
4301 : 1152807 : tree type = start_struct (struct_loc, code, ident, &struct_info);
4302 : 1152807 : tree postfix_attrs;
4303 : : /* We chain the components in reverse order, then put them in
4304 : : forward order at the end. Each struct-declaration may
4305 : : declare multiple components (comma-separated), so we must use
4306 : : chainon to join them, although when parsing each
4307 : : struct-declaration we can use TREE_CHAIN directly.
4308 : :
4309 : : The theory behind all this is that there will be more
4310 : : semicolon separated fields than comma separated fields, and
4311 : : so we'll be minimizing the number of node traversals required
4312 : : by chainon. */
4313 : 1152807 : tree contents;
4314 : 1152807 : tree expr = NULL;
4315 : 1152807 : timevar_push (TV_PARSE_STRUCT);
4316 : 1152807 : contents = NULL_TREE;
4317 : 1152807 : c_parser_consume_token (parser);
4318 : : /* Handle the Objective-C @defs construct,
4319 : : e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
4320 : 1152807 : if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
4321 : : {
4322 : 0 : tree name;
4323 : 0 : gcc_assert (c_dialect_objc ());
4324 : 0 : c_parser_consume_token (parser);
4325 : 0 : matching_parens parens;
4326 : 0 : if (!parens.require_open (parser))
4327 : 0 : goto end_at_defs;
4328 : 0 : if (c_parser_next_token_is (parser, CPP_NAME)
4329 : 0 : && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
4330 : : {
4331 : 0 : name = c_parser_peek_token (parser)->value;
4332 : 0 : c_parser_consume_token (parser);
4333 : : }
4334 : : else
4335 : : {
4336 : 0 : c_parser_error (parser, "expected class name");
4337 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4338 : 0 : goto end_at_defs;
4339 : : }
4340 : 0 : parens.skip_until_found_close (parser);
4341 : 0 : contents = nreverse (objc_get_class_ivars (name));
4342 : : }
4343 : 1152807 : end_at_defs:
4344 : : /* Parse the struct-declarations and semicolons. Problems with
4345 : : semicolons are diagnosed here; empty structures are diagnosed
4346 : : elsewhere. */
4347 : 5327187 : while (true)
4348 : : {
4349 : 5327187 : tree decls;
4350 : : /* Parse any stray semicolon. */
4351 : 5327187 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4352 : : {
4353 : 13 : location_t semicolon_loc
4354 : 13 : = c_parser_peek_token (parser)->location;
4355 : 13 : gcc_rich_location richloc (semicolon_loc);
4356 : 13 : richloc.add_fixit_remove ();
4357 : 13 : pedwarn (&richloc, OPT_Wpedantic,
4358 : : "extra semicolon in struct or union specified");
4359 : 13 : c_parser_consume_token (parser);
4360 : 13 : continue;
4361 : 13 : }
4362 : : /* Stop if at the end of the struct or union contents. */
4363 : 5327174 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
4364 : : {
4365 : 1152798 : c_parser_consume_token (parser);
4366 : 1152798 : break;
4367 : : }
4368 : : /* Accept #pragmas at struct scope. */
4369 : 4174376 : if (c_parser_next_token_is (parser, CPP_PRAGMA))
4370 : : {
4371 : 20 : c_parser_pragma (parser, pragma_struct, NULL, NULL_TREE);
4372 : 20 : continue;
4373 : : }
4374 : : /* Parse some comma-separated declarations, but not the
4375 : : trailing semicolon if any. */
4376 : 4174356 : decls = c_parser_struct_declaration (parser, &expr);
4377 : 4174356 : contents = chainon (decls, contents);
4378 : : /* If no semicolon follows, either we have a parse error or
4379 : : are at the end of the struct or union and should
4380 : : pedwarn. */
4381 : 4174356 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4382 : 4174320 : c_parser_consume_token (parser);
4383 : : else
4384 : : {
4385 : 36 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
4386 : 25 : pedwarn (c_parser_peek_token (parser)->location, 0,
4387 : : "no semicolon at end of struct or union");
4388 : 11 : else if (parser->error
4389 : 11 : || !c_parser_next_token_starts_declspecs (parser))
4390 : : {
4391 : 9 : c_parser_error (parser, "expected %<;%>");
4392 : 9 : c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
4393 : 9 : break;
4394 : : }
4395 : :
4396 : : /* If we come here, we have already emitted an error
4397 : : for an expected `;', identifier or `(', and we also
4398 : : recovered already. Go on with the next field. */
4399 : : }
4400 : : }
4401 : 1152807 : postfix_attrs = c_parser_gnu_attributes (parser);
4402 : 1152807 : ret.spec = finish_struct (struct_loc, type, nreverse (contents),
4403 : : chainon (std_attrs,
4404 : : chainon (attrs, postfix_attrs)),
4405 : : struct_info, &expr);
4406 : 1152807 : ret.kind = ctsk_tagdef;
4407 : 1152807 : ret.expr = expr;
4408 : 1152807 : ret.expr_const_operands = true;
4409 : 1152807 : ret.has_enum_type_specifier = false;
4410 : 1152807 : timevar_pop (TV_PARSE_STRUCT);
4411 : 1152807 : return ret;
4412 : : }
4413 : 1008146 : else if (!ident)
4414 : : {
4415 : 10 : c_parser_error (parser, "expected %<{%>");
4416 : 10 : ret.spec = error_mark_node;
4417 : 10 : ret.kind = ctsk_tagref;
4418 : 10 : ret.expr = NULL_TREE;
4419 : 10 : ret.expr_const_operands = true;
4420 : 10 : ret.has_enum_type_specifier = false;
4421 : 10 : return ret;
4422 : : }
4423 : : /* Attributes may only appear when the members are defined or in
4424 : : certain forward declarations. */
4425 : 1008146 : if (have_std_attrs && c_parser_next_token_is_not (parser, CPP_SEMICOLON))
4426 : 2 : c_parser_error (parser, "expected %<;%>");
4427 : : /* ??? Existing practice is that GNU attributes are ignored after
4428 : : the struct or union keyword when not defining the members. */
4429 : 1008136 : ret = parser_xref_tag (ident_loc, code, ident, have_std_attrs, std_attrs,
4430 : : false);
4431 : 1008136 : return ret;
4432 : : }
4433 : :
4434 : : /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1, C11 6.7.2.1),
4435 : : *without* the trailing semicolon.
4436 : :
4437 : : struct-declaration:
4438 : : attribute-specifier-sequence[opt] specifier-qualifier-list
4439 : : attribute-specifier-sequence[opt] struct-declarator-list
4440 : : static_assert-declaration-no-semi
4441 : :
4442 : : specifier-qualifier-list:
4443 : : type-specifier specifier-qualifier-list[opt]
4444 : : type-qualifier specifier-qualifier-list[opt]
4445 : : alignment-specifier specifier-qualifier-list[opt]
4446 : : gnu-attributes specifier-qualifier-list[opt]
4447 : :
4448 : : struct-declarator-list:
4449 : : struct-declarator
4450 : : struct-declarator-list , gnu-attributes[opt] struct-declarator
4451 : :
4452 : : struct-declarator:
4453 : : declarator gnu-attributes[opt]
4454 : : declarator[opt] : constant-expression gnu-attributes[opt]
4455 : :
4456 : : GNU extensions:
4457 : :
4458 : : struct-declaration:
4459 : : __extension__ struct-declaration
4460 : : specifier-qualifier-list
4461 : :
4462 : : Unlike the ISO C syntax, semicolons are handled elsewhere. The use
4463 : : of gnu-attributes where shown is a GNU extension. In GNU C, we accept
4464 : : any expression without commas in the syntax (assignment
4465 : : expressions, not just conditional expressions); assignment
4466 : : expressions will be diagnosed as non-constant. */
4467 : :
4468 : : static tree
4469 : 4238144 : c_parser_struct_declaration (c_parser *parser, tree *expr)
4470 : : {
4471 : 4238144 : struct c_declspecs *specs;
4472 : 4238144 : tree prefix_attrs;
4473 : 4238144 : tree all_prefix_attrs;
4474 : 4238144 : tree decls;
4475 : 4238144 : location_t decl_loc;
4476 : 4238144 : if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
4477 : : {
4478 : 63788 : int ext;
4479 : 63788 : tree decl;
4480 : 63788 : ext = disable_extension_diagnostics ();
4481 : 63788 : c_parser_consume_token (parser);
4482 : 63788 : decl = c_parser_struct_declaration (parser, expr);
4483 : 63788 : restore_extension_diagnostics (ext);
4484 : 63788 : return decl;
4485 : : }
4486 : 4174356 : if (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
4487 : : {
4488 : 10 : c_parser_static_assert_declaration_no_semi (parser);
4489 : 10 : return NULL_TREE;
4490 : : }
4491 : 4174346 : specs = build_null_declspecs ();
4492 : 4174346 : decl_loc = c_parser_peek_token (parser)->location;
4493 : : /* Strictly by the standard, we shouldn't allow _Alignas here,
4494 : : but it appears to have been intended to allow it there, so
4495 : : we're keeping it as it is until WG14 reaches a conclusion
4496 : : of N1731.
4497 : : <http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1731.pdf> */
4498 : 4174346 : c_parser_declspecs (parser, specs, false, true, true,
4499 : : true, false, true, true, cla_nonabstract_decl);
4500 : 4174346 : if (parser->error)
4501 : : return NULL_TREE;
4502 : 4174338 : if (!specs->declspecs_seen_p)
4503 : : {
4504 : 1 : c_parser_error (parser, "expected specifier-qualifier-list");
4505 : 1 : return NULL_TREE;
4506 : : }
4507 : 4174337 : finish_declspecs (specs);
4508 : 4174337 : if (c_parser_next_token_is (parser, CPP_SEMICOLON)
4509 : 8338114 : || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
4510 : : {
4511 : 10564 : tree ret;
4512 : 10564 : if (specs->typespec_kind == ctsk_none)
4513 : : {
4514 : 3 : pedwarn (decl_loc, OPT_Wpedantic,
4515 : : "ISO C forbids member declarations with no members");
4516 : 3 : shadow_tag_warned (specs, pedantic);
4517 : 3 : ret = NULL_TREE;
4518 : : }
4519 : : else
4520 : : {
4521 : : /* Support for unnamed structs or unions as members of
4522 : : structs or unions (which is [a] useful and [b] supports
4523 : : MS P-SDK). */
4524 : 10561 : tree attrs = NULL;
4525 : :
4526 : 10561 : ret = grokfield (c_parser_peek_token (parser)->location,
4527 : : build_id_declarator (NULL_TREE), specs,
4528 : : NULL_TREE, &attrs, expr);
4529 : 10561 : if (ret)
4530 : 10532 : decl_attributes (&ret, attrs, 0);
4531 : : }
4532 : 10564 : return ret;
4533 : : }
4534 : :
4535 : : /* Provide better error recovery. Note that a type name here is valid,
4536 : : and will be treated as a field name. */
4537 : 4163773 : if (specs->typespec_kind == ctsk_tagdef
4538 : 149996 : && TREE_CODE (specs->type) != ENUMERAL_TYPE
4539 : 149843 : && c_parser_next_token_starts_declspecs (parser)
4540 : 4163776 : && !c_parser_next_token_is (parser, CPP_NAME))
4541 : : {
4542 : 2 : c_parser_error (parser, "expected %<;%>, identifier or %<(%>");
4543 : 2 : parser->error = false;
4544 : 2 : return NULL_TREE;
4545 : : }
4546 : :
4547 : 4163771 : pending_xref_error ();
4548 : 4163771 : prefix_attrs = specs->attrs;
4549 : 4163771 : all_prefix_attrs = prefix_attrs;
4550 : 4163771 : specs->attrs = NULL_TREE;
4551 : 4163771 : decls = NULL_TREE;
4552 : 57320 : while (true)
4553 : : {
4554 : : /* Declaring one or more declarators or un-named bit-fields. */
4555 : 4221091 : struct c_declarator *declarator;
4556 : 4221091 : bool dummy = false;
4557 : 4221091 : if (c_parser_next_token_is (parser, CPP_COLON))
4558 : 9188 : declarator = build_id_declarator (NULL_TREE);
4559 : : else
4560 : 4211903 : declarator = c_parser_declarator (parser,
4561 : 4211903 : specs->typespec_kind != ctsk_none,
4562 : : C_DTR_NORMAL, &dummy);
4563 : 4221091 : if (declarator == NULL)
4564 : : {
4565 : 1 : c_parser_skip_to_end_of_block_or_statement (parser);
4566 : 1 : break;
4567 : : }
4568 : 4221090 : if (c_parser_next_token_is (parser, CPP_COLON)
4569 : 4169219 : || c_parser_next_token_is (parser, CPP_COMMA)
4570 : 4114097 : || c_parser_next_token_is (parser, CPP_SEMICOLON)
4571 : 32633 : || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
4572 : 4253703 : || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
4573 : : {
4574 : 4221090 : tree postfix_attrs = NULL_TREE;
4575 : 4221090 : tree width = NULL_TREE;
4576 : 4221090 : tree d;
4577 : 4221090 : if (c_parser_next_token_is (parser, CPP_COLON))
4578 : : {
4579 : 51871 : c_parser_consume_token (parser);
4580 : 51871 : location_t loc = c_parser_peek_token (parser)->location;
4581 : 51871 : width = convert_lvalue_to_rvalue (loc,
4582 : : (c_parser_expr_no_commas
4583 : : (parser, NULL)),
4584 : : true, true).value;
4585 : : }
4586 : 4221090 : if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
4587 : 32794 : postfix_attrs = c_parser_gnu_attributes (parser);
4588 : 4221090 : d = grokfield (c_parser_peek_token (parser)->location,
4589 : : declarator, specs, width, &all_prefix_attrs, expr);
4590 : 4221090 : decl_attributes (&d, chainon (postfix_attrs,
4591 : : all_prefix_attrs), 0);
4592 : 4221090 : DECL_CHAIN (d) = decls;
4593 : 4221090 : decls = d;
4594 : 4221090 : if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
4595 : 0 : all_prefix_attrs = chainon (c_parser_gnu_attributes (parser),
4596 : : prefix_attrs);
4597 : : else
4598 : 4221090 : all_prefix_attrs = prefix_attrs;
4599 : 4221090 : if (c_parser_next_token_is (parser, CPP_COMMA))
4600 : 57320 : c_parser_consume_token (parser);
4601 : 4163770 : else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
4602 : 4163790 : || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
4603 : : {
4604 : : /* Semicolon consumed in caller. */
4605 : : break;
4606 : : }
4607 : : else
4608 : : {
4609 : 0 : c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
4610 : 0 : break;
4611 : : }
4612 : : }
4613 : : else
4614 : : {
4615 : 0 : c_parser_error (parser,
4616 : : "expected %<:%>, %<,%>, %<;%>, %<}%> or "
4617 : : "%<__attribute__%>");
4618 : 0 : break;
4619 : : }
4620 : : }
4621 : 4163771 : return decls;
4622 : : }
4623 : :
4624 : : /* Parse a typeof specifier (a GNU extension adopted in C23).
4625 : :
4626 : : typeof-specifier:
4627 : : typeof ( expression )
4628 : : typeof ( type-name )
4629 : : typeof_unqual ( expression )
4630 : : typeof_unqual ( type-name )
4631 : : */
4632 : :
4633 : : static struct c_typespec
4634 : 806313 : c_parser_typeof_specifier (c_parser *parser)
4635 : : {
4636 : 806313 : bool is_unqual;
4637 : 806313 : bool is_std;
4638 : 806313 : struct c_typespec ret;
4639 : 806313 : ret.kind = ctsk_typeof;
4640 : 806313 : ret.spec = error_mark_node;
4641 : 806313 : ret.expr = NULL_TREE;
4642 : 806313 : ret.expr_const_operands = true;
4643 : 806313 : ret.has_enum_type_specifier = false;
4644 : 806313 : if (c_parser_next_token_is_keyword (parser, RID_TYPEOF))
4645 : : {
4646 : 806221 : is_unqual = false;
4647 : 806221 : tree spelling = c_parser_peek_token (parser)->value;
4648 : 806221 : is_std = (flag_isoc23
4649 : 897316 : && strcmp (IDENTIFIER_POINTER (spelling), "typeof") == 0);
4650 : : }
4651 : : else
4652 : : {
4653 : 92 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF_UNQUAL));
4654 : 92 : is_unqual = true;
4655 : 92 : tree spelling = c_parser_peek_token (parser)->value;
4656 : 92 : is_std = strcmp (IDENTIFIER_POINTER (spelling), "typeof_unqual") == 0;
4657 : : }
4658 : 806313 : c_parser_consume_token (parser);
4659 : 806313 : c_inhibit_evaluation_warnings++;
4660 : 806313 : in_typeof++;
4661 : 806313 : matching_parens parens;
4662 : 806313 : if (!parens.require_open (parser))
4663 : : {
4664 : 0 : c_inhibit_evaluation_warnings--;
4665 : 0 : in_typeof--;
4666 : 0 : return ret;
4667 : : }
4668 : 806313 : if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
4669 : : {
4670 : 685 : struct c_type_name *type = c_parser_type_name (parser);
4671 : 685 : c_inhibit_evaluation_warnings--;
4672 : 685 : in_typeof--;
4673 : 685 : if (type != NULL)
4674 : : {
4675 : 685 : ret.spec = groktypename (type, &ret.expr, &ret.expr_const_operands);
4676 : 685 : pop_maybe_used (c_type_variably_modified_p (ret.spec));
4677 : : }
4678 : : }
4679 : : else
4680 : : {
4681 : 805628 : bool was_vm;
4682 : 805628 : location_t here = c_parser_peek_token (parser)->location;
4683 : 805628 : struct c_expr expr = c_parser_expression (parser);
4684 : 805628 : c_inhibit_evaluation_warnings--;
4685 : 805628 : in_typeof--;
4686 : 805628 : if (TREE_CODE (expr.value) == COMPONENT_REF
4687 : 805628 : && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
4688 : 13 : error_at (here, "%<typeof%> applied to a bit-field");
4689 : 805628 : mark_exp_read (expr.value);
4690 : 805628 : ret.spec = TREE_TYPE (expr.value);
4691 : 805628 : was_vm = c_type_variably_modified_p (ret.spec);
4692 : : /* This is returned with the type so that when the type is
4693 : : evaluated, this can be evaluated. */
4694 : 805628 : if (was_vm)
4695 : 217 : ret.expr = c_fully_fold (expr.value, false, &ret.expr_const_operands);
4696 : 805628 : pop_maybe_used (was_vm);
4697 : : }
4698 : 806313 : parens.skip_until_found_close (parser);
4699 : 806313 : if (ret.spec != error_mark_node)
4700 : : {
4701 : 806302 : if (is_unqual)
4702 : : {
4703 : 92 : bool is_array = TREE_CODE (ret.spec) == ARRAY_TYPE;
4704 : 92 : int quals = TYPE_QUALS (strip_array_types (ret.spec));
4705 : 92 : if ((is_array ? quals & ~TYPE_QUAL_ATOMIC : quals)
4706 : : != TYPE_UNQUALIFIED)
4707 : : {
4708 : 51 : ret.spec = TYPE_MAIN_VARIANT (ret.spec);
4709 : 51 : if (quals & TYPE_QUAL_ATOMIC && is_array)
4710 : 4 : ret.spec = c_build_qualified_type (ret.spec,
4711 : : TYPE_QUAL_ATOMIC);
4712 : : }
4713 : : }
4714 : 806302 : if (is_std)
4715 : : {
4716 : : /* In ISO C terms, _Noreturn is not part of the type of
4717 : : expressions such as &abort, but in GCC it is represented
4718 : : internally as a type qualifier. */
4719 : 4245 : if (TREE_CODE (ret.spec) == FUNCTION_TYPE
4720 : 4245 : && TYPE_QUALS (ret.spec) != TYPE_UNQUALIFIED)
4721 : 2 : ret.spec = TYPE_MAIN_VARIANT (ret.spec);
4722 : 2901 : else if (FUNCTION_POINTER_TYPE_P (ret.spec)
4723 : 7071 : && TYPE_QUALS (TREE_TYPE (ret.spec)) != TYPE_UNQUALIFIED)
4724 : 2 : ret.spec
4725 : 2 : = c_build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (ret.spec)));
4726 : : }
4727 : : }
4728 : : return ret;
4729 : : }
4730 : :
4731 : : /* Parse an alignment-specifier.
4732 : :
4733 : : C11 6.7.5:
4734 : :
4735 : : alignment-specifier:
4736 : : _Alignas ( type-name )
4737 : : _Alignas ( constant-expression )
4738 : : */
4739 : :
4740 : : static tree
4741 : 200 : c_parser_alignas_specifier (c_parser * parser)
4742 : : {
4743 : 200 : tree ret = error_mark_node;
4744 : 200 : location_t loc = c_parser_peek_token (parser)->location;
4745 : 200 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNAS));
4746 : 200 : tree spelling = c_parser_peek_token (parser)->value;
4747 : 200 : c_parser_consume_token (parser);
4748 : 200 : if (flag_isoc99)
4749 : 197 : pedwarn_c99 (loc, OPT_Wpedantic,
4750 : : "ISO C99 does not support %qE", spelling);
4751 : : else
4752 : 3 : pedwarn_c99 (loc, OPT_Wpedantic,
4753 : : "ISO C90 does not support %qE", spelling);
4754 : 200 : matching_parens parens;
4755 : 200 : if (!parens.require_open (parser))
4756 : : return ret;
4757 : 200 : if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
4758 : : {
4759 : 132 : struct c_type_name *type = c_parser_type_name (parser);
4760 : 132 : if (type != NULL)
4761 : 131 : ret = c_sizeof_or_alignof_type (loc, groktypename (type, NULL, NULL),
4762 : : false, true, 1);
4763 : : }
4764 : : else
4765 : 68 : ret = convert_lvalue_to_rvalue (loc,
4766 : : c_parser_expr_no_commas (parser, NULL),
4767 : : true, true).value;
4768 : 200 : parens.skip_until_found_close (parser);
4769 : 200 : return ret;
4770 : : }
4771 : :
4772 : : /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
4773 : : 6.5.5, C99 6.7.5, 6.7.6, C11 6.7.6, 6.7.7). If TYPE_SEEN_P then
4774 : : a typedef name may be redeclared; otherwise it may not. KIND
4775 : : indicates which kind of declarator is wanted. Returns a valid
4776 : : declarator except in the case of a syntax error in which case NULL is
4777 : : returned. *SEEN_ID is set to true if an identifier being declared is
4778 : : seen; this is used to diagnose bad forms of abstract array declarators
4779 : : and to determine whether an identifier list is syntactically permitted.
4780 : :
4781 : : declarator:
4782 : : pointer[opt] direct-declarator
4783 : :
4784 : : direct-declarator:
4785 : : identifier
4786 : : ( gnu-attributes[opt] declarator )
4787 : : direct-declarator array-declarator
4788 : : direct-declarator ( parameter-type-list )
4789 : : direct-declarator ( identifier-list[opt] )
4790 : :
4791 : : pointer:
4792 : : * type-qualifier-list[opt]
4793 : : * type-qualifier-list[opt] pointer
4794 : :
4795 : : type-qualifier-list:
4796 : : type-qualifier
4797 : : gnu-attributes
4798 : : type-qualifier-list type-qualifier
4799 : : type-qualifier-list gnu-attributes
4800 : :
4801 : : array-declarator:
4802 : : [ type-qualifier-list[opt] assignment-expression[opt] ]
4803 : : [ static type-qualifier-list[opt] assignment-expression ]
4804 : : [ type-qualifier-list static assignment-expression ]
4805 : : [ type-qualifier-list[opt] * ]
4806 : :
4807 : : parameter-type-list:
4808 : : parameter-list
4809 : : parameter-list , ...
4810 : :
4811 : : parameter-list:
4812 : : parameter-declaration
4813 : : parameter-list , parameter-declaration
4814 : :
4815 : : parameter-declaration:
4816 : : declaration-specifiers declarator gnu-attributes[opt]
4817 : : declaration-specifiers abstract-declarator[opt] gnu-attributes[opt]
4818 : :
4819 : : identifier-list:
4820 : : identifier
4821 : : identifier-list , identifier
4822 : :
4823 : : abstract-declarator:
4824 : : pointer
4825 : : pointer[opt] direct-abstract-declarator
4826 : :
4827 : : direct-abstract-declarator:
4828 : : ( gnu-attributes[opt] abstract-declarator )
4829 : : direct-abstract-declarator[opt] array-declarator
4830 : : direct-abstract-declarator[opt] ( parameter-type-list[opt] )
4831 : :
4832 : : GNU extensions:
4833 : :
4834 : : direct-declarator:
4835 : : direct-declarator ( parameter-forward-declarations
4836 : : parameter-type-list[opt] )
4837 : :
4838 : : direct-abstract-declarator:
4839 : : direct-abstract-declarator[opt] ( parameter-forward-declarations
4840 : : parameter-type-list[opt] )
4841 : :
4842 : : parameter-forward-declarations:
4843 : : parameter-list ;
4844 : : parameter-forward-declarations parameter-list ;
4845 : :
4846 : : The uses of gnu-attributes shown above are GNU extensions.
4847 : :
4848 : : Some forms of array declarator are not included in C99 in the
4849 : : syntax for abstract declarators; these are disallowed elsewhere.
4850 : : This may be a defect (DR#289).
4851 : :
4852 : : This function also accepts an omitted abstract declarator as being
4853 : : an abstract declarator, although not part of the formal syntax. */
4854 : :
4855 : : struct c_declarator *
4856 : 324635683 : c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
4857 : : bool *seen_id)
4858 : : {
4859 : : /* Parse any initial pointer part. */
4860 : 324635683 : if (c_parser_next_token_is (parser, CPP_MULT))
4861 : : {
4862 : 17891349 : struct c_declspecs *quals_attrs = build_null_declspecs ();
4863 : 17891349 : struct c_declarator *inner;
4864 : 17891349 : c_parser_consume_token (parser);
4865 : 17891349 : c_parser_declspecs (parser, quals_attrs, false, false, true,
4866 : : false, false, true, false, cla_prefer_id);
4867 : 17891349 : inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
4868 : 17891349 : if (inner == NULL)
4869 : : return NULL;
4870 : : else
4871 : 17891340 : return make_pointer_declarator (quals_attrs, inner);
4872 : : }
4873 : : /* Now we have a direct declarator, direct abstract declarator or
4874 : : nothing (which counts as a direct abstract declarator here). */
4875 : 306744334 : return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
4876 : : }
4877 : :
4878 : : /* Parse a direct declarator or direct abstract declarator; arguments
4879 : : as c_parser_declarator. */
4880 : :
4881 : : static struct c_declarator *
4882 : 306744334 : c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
4883 : : bool *seen_id)
4884 : : {
4885 : : /* The direct declarator must start with an identifier (possibly
4886 : : omitted) or a parenthesized declarator (possibly abstract). In
4887 : : an ordinary declarator, initial parentheses must start a
4888 : : parenthesized declarator. In an abstract declarator or parameter
4889 : : declarator, they could start a parenthesized declarator or a
4890 : : parameter list. To tell which, the open parenthesis and any
4891 : : following gnu-attributes must be read. If a declaration
4892 : : specifier or standard attributes follow, then it is a parameter
4893 : : list; if the specifier is a typedef name, there might be an
4894 : : ambiguity about redeclaring it, which is resolved in the
4895 : : direction of treating it as a typedef name. If a close
4896 : : parenthesis follows, it is also an empty parameter list, as the
4897 : : syntax does not permit empty abstract declarators. Otherwise, it
4898 : : is a parenthesized declarator (in which case the analysis may be
4899 : : repeated inside it, recursively).
4900 : :
4901 : : ??? There is an ambiguity in a parameter declaration "int
4902 : : (__attribute__((foo)) x)", where x is not a typedef name: it
4903 : : could be an abstract declarator for a function, or declare x with
4904 : : parentheses. The proper resolution of this ambiguity needs
4905 : : documenting. At present we follow an accident of the old
4906 : : parser's implementation, whereby the first parameter must have
4907 : : some declaration specifiers other than just gnu-attributes. Thus as
4908 : : a parameter declaration it is treated as a parenthesized
4909 : : parameter named x, and as an abstract declarator it is
4910 : : rejected.
4911 : :
4912 : : ??? Also following the old parser, gnu-attributes inside an empty
4913 : : parameter list are ignored, making it a list not yielding a
4914 : : prototype, rather than giving an error or making it have one
4915 : : parameter with implicit type int.
4916 : :
4917 : : ??? Also following the old parser, typedef names may be
4918 : : redeclared in declarators, but not Objective-C class names. */
4919 : :
4920 : 306744334 : if (kind != C_DTR_ABSTRACT
4921 : 188363666 : && c_parser_next_token_is (parser, CPP_NAME)
4922 : 490409053 : && ((type_seen_p
4923 : 183654860 : && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
4924 : 183608988 : || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
4925 : 183618847 : || c_parser_peek_token (parser)->id_kind == C_ID_ID))
4926 : : {
4927 : 183664719 : struct c_declarator *inner
4928 : 183664719 : = build_id_declarator (c_parser_peek_token (parser)->value);
4929 : 183664719 : *seen_id = true;
4930 : 183664719 : inner->id_loc = c_parser_peek_token (parser)->location;
4931 : 183664719 : c_parser_consume_token (parser);
4932 : 183664719 : if (c_parser_nth_token_starts_std_attributes (parser, 1))
4933 : 84 : inner->u.id.attrs = c_parser_std_attribute_specifier_sequence (parser);
4934 : 183664719 : return c_parser_direct_declarator_inner (parser, *seen_id, inner);
4935 : : }
4936 : :
4937 : 123079615 : if (kind != C_DTR_NORMAL
4938 : 122939861 : && c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
4939 : 123103432 : && !c_parser_nth_token_starts_std_attributes (parser, 1))
4940 : : {
4941 : 23817 : struct c_declarator *inner = build_id_declarator (NULL_TREE);
4942 : 23817 : inner->id_loc = c_parser_peek_token (parser)->location;
4943 : 23817 : return c_parser_direct_declarator_inner (parser, *seen_id, inner);
4944 : : }
4945 : :
4946 : : /* Either we are at the end of an abstract declarator, or we have
4947 : : parentheses. */
4948 : :
4949 : 123055798 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
4950 : : {
4951 : 221927 : tree attrs;
4952 : 221927 : struct c_declarator *inner;
4953 : 221927 : c_parser_consume_token (parser);
4954 : 221927 : bool have_gnu_attrs = c_parser_next_token_is_keyword (parser,
4955 : : RID_ATTRIBUTE);
4956 : 221927 : attrs = c_parser_gnu_attributes (parser);
4957 : 221927 : if (kind != C_DTR_NORMAL
4958 : 221927 : && (c_parser_next_token_starts_declspecs (parser)
4959 : 82241 : || (!have_gnu_attrs
4960 : 82083 : && (c_parser_nth_token_starts_std_attributes (parser, 1)
4961 : 82083 : || c_parser_next_token_is (parser, CPP_ELLIPSIS)))
4962 : 82236 : || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
4963 : : {
4964 : 64 : struct c_arg_info *args
4965 : 64 : = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
4966 : : attrs, have_gnu_attrs);
4967 : 64 : if (args == NULL)
4968 : : return NULL;
4969 : : else
4970 : : {
4971 : 64 : inner = build_id_declarator (NULL_TREE);
4972 : 89 : if (!(args->types
4973 : 25 : && args->types != error_mark_node
4974 : 25 : && TREE_CODE (TREE_VALUE (args->types)) == IDENTIFIER_NODE)
4975 : 89 : && c_parser_nth_token_starts_std_attributes (parser, 1))
4976 : : {
4977 : 4 : tree std_attrs
4978 : 4 : = c_parser_std_attribute_specifier_sequence (parser);
4979 : 4 : if (std_attrs)
4980 : 2 : inner = build_attrs_declarator (std_attrs, inner);
4981 : : }
4982 : 64 : inner = build_function_declarator (args, inner);
4983 : 64 : return c_parser_direct_declarator_inner (parser, *seen_id,
4984 : 64 : inner);
4985 : : }
4986 : : }
4987 : : /* A parenthesized declarator. */
4988 : 221863 : inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
4989 : 221863 : if (inner != NULL && attrs != NULL)
4990 : 179 : inner = build_attrs_declarator (attrs, inner);
4991 : 221863 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4992 : : {
4993 : 221849 : c_parser_consume_token (parser);
4994 : 221849 : if (inner == NULL)
4995 : : return NULL;
4996 : : else
4997 : 221849 : return c_parser_direct_declarator_inner (parser, *seen_id, inner);
4998 : : }
4999 : : else
5000 : : {
5001 : 14 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5002 : : "expected %<)%>");
5003 : 14 : return NULL;
5004 : : }
5005 : : }
5006 : : else
5007 : : {
5008 : 122833871 : if (kind == C_DTR_NORMAL)
5009 : : {
5010 : 93 : c_parser_error (parser, "expected identifier or %<(%>");
5011 : 93 : return NULL;
5012 : : }
5013 : : else
5014 : 122833778 : return build_id_declarator (NULL_TREE);
5015 : : }
5016 : : }
5017 : :
5018 : : /* Parse part of a direct declarator or direct abstract declarator,
5019 : : given that some (in INNER) has already been parsed; ID_PRESENT is
5020 : : true if an identifier is present, false for an abstract
5021 : : declarator. */
5022 : :
5023 : : static struct c_declarator *
5024 : 234456573 : c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
5025 : : struct c_declarator *inner)
5026 : : {
5027 : : /* Parse a sequence of array declarators and parameter lists. */
5028 : 234456573 : if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
5029 : 234456573 : && !c_parser_nth_token_starts_std_attributes (parser, 1))
5030 : : {
5031 : 1128763 : location_t brace_loc = c_parser_peek_token (parser)->location;
5032 : 1128763 : struct c_declarator *declarator;
5033 : 1128763 : struct c_declspecs *quals_attrs = build_null_declspecs ();
5034 : 1128763 : struct c_expr dimen;
5035 : 1128763 : dimen.value = NULL_TREE;
5036 : 1128763 : dimen.original_code = ERROR_MARK;
5037 : 1128763 : dimen.original_type = NULL_TREE;
5038 : 1128763 : c_parser_consume_token (parser);
5039 : 1128763 : c_parser_declspecs (parser, quals_attrs, false, false, true,
5040 : : false, false, false, false, cla_prefer_id);
5041 : :
5042 : 1128763 : location_t static_loc = UNKNOWN_LOCATION;
5043 : 1128763 : if (c_parser_next_token_is_keyword (parser, RID_STATIC))
5044 : : {
5045 : 131 : static_loc = c_parser_peek_token (parser)->location;
5046 : 131 : c_parser_consume_token (parser);
5047 : 131 : if (!quals_attrs->declspecs_seen_p)
5048 : 111 : c_parser_declspecs (parser, quals_attrs, false, false, true,
5049 : : false, false, false, false, cla_prefer_id);
5050 : : }
5051 : 1128763 : if (!quals_attrs->declspecs_seen_p)
5052 : 1127825 : quals_attrs = NULL;
5053 : : /* If "static" is present, there must be an array dimension.
5054 : : Otherwise, there may be a dimension, "*", or no
5055 : : dimension. */
5056 : 1128763 : const bool static_seen = (static_loc != UNKNOWN_LOCATION);
5057 : 1128763 : bool star_seen = false;
5058 : 1128763 : if (c_parser_next_token_is (parser, CPP_MULT)
5059 : 1128763 : && c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
5060 : : {
5061 : 150 : star_seen = true;
5062 : 150 : c_parser_consume_token (parser);
5063 : : }
5064 : 1128613 : else if (!c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
5065 : 960481 : dimen = c_parser_expr_no_commas (parser, NULL);
5066 : :
5067 : 1128763 : if (static_seen)
5068 : : {
5069 : 131 : if (star_seen)
5070 : : {
5071 : 3 : error_at (static_loc,
5072 : : "%<static%> may not be used with an unspecified "
5073 : : "variable length array size");
5074 : : /* Prevent further errors. */
5075 : 3 : star_seen = false;
5076 : 3 : dimen.value = error_mark_node;
5077 : : }
5078 : 128 : else if (!dimen.value)
5079 : 2 : error_at (static_loc,
5080 : : "%<static%> may not be used without an array size");
5081 : : }
5082 : :
5083 : 1128763 : if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
5084 : 1128748 : c_parser_consume_token (parser);
5085 : : else
5086 : : {
5087 : 15 : c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
5088 : : "expected %<]%>");
5089 : 15 : return NULL;
5090 : : }
5091 : 1128748 : if (dimen.value)
5092 : 960469 : dimen = convert_lvalue_to_rvalue (brace_loc, dimen, true, true);
5093 : 1128748 : declarator = build_array_declarator (brace_loc, dimen.value, quals_attrs,
5094 : : static_seen, star_seen);
5095 : 1128748 : if (declarator == NULL)
5096 : : return NULL;
5097 : 1128744 : if (c_parser_nth_token_starts_std_attributes (parser, 1))
5098 : : {
5099 : 16 : tree std_attrs
5100 : 16 : = c_parser_std_attribute_specifier_sequence (parser);
5101 : 16 : if (std_attrs)
5102 : 10 : inner = build_attrs_declarator (std_attrs, inner);
5103 : : }
5104 : 1128744 : inner = set_array_declarator_inner (declarator, inner);
5105 : 1128744 : return c_parser_direct_declarator_inner (parser, id_present, inner);
5106 : : }
5107 : 233327810 : else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
5108 : : {
5109 : 49417488 : tree attrs;
5110 : 49417488 : struct c_arg_info *args;
5111 : 49417488 : c_parser_consume_token (parser);
5112 : 49417488 : bool have_gnu_attrs = c_parser_next_token_is_keyword (parser,
5113 : : RID_ATTRIBUTE);
5114 : 49417488 : attrs = c_parser_gnu_attributes (parser);
5115 : 49417488 : args = c_parser_parms_declarator (parser, id_present, attrs,
5116 : : have_gnu_attrs);
5117 : 49417488 : if (args == NULL)
5118 : : return NULL;
5119 : : else
5120 : : {
5121 : 98063725 : if (!(args->types
5122 : 48646345 : && args->types != error_mark_node
5123 : 48646345 : && TREE_CODE (TREE_VALUE (args->types)) == IDENTIFIER_NODE)
5124 : 98055039 : && c_parser_nth_token_starts_std_attributes (parser, 1))
5125 : : {
5126 : 98 : tree std_attrs
5127 : 98 : = c_parser_std_attribute_specifier_sequence (parser);
5128 : 98 : if (std_attrs)
5129 : 81 : inner = build_attrs_declarator (std_attrs, inner);
5130 : : }
5131 : 49417380 : inner = build_function_declarator (args, inner);
5132 : 49417380 : return c_parser_direct_declarator_inner (parser, id_present, inner);
5133 : : }
5134 : : }
5135 : : return inner;
5136 : : }
5137 : :
5138 : : /* Parse a parameter list or identifier list, including the closing
5139 : : parenthesis but not the opening one. ATTRS are the gnu-attributes
5140 : : at the start of the list. ID_LIST_OK is true if an identifier list
5141 : : is acceptable; such a list must not have attributes at the start.
5142 : : HAVE_GNU_ATTRS says whether any gnu-attributes (including empty
5143 : : attributes) were present (in which case standard attributes cannot
5144 : : occur). */
5145 : :
5146 : : static struct c_arg_info *
5147 : 49417552 : c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs,
5148 : : bool have_gnu_attrs)
5149 : : {
5150 : 49417552 : push_scope ();
5151 : 49417552 : declare_parm_level ();
5152 : : /* If the list starts with an identifier, it is an identifier list.
5153 : : Otherwise, it is either a prototype list or an empty list. */
5154 : 49417552 : if (id_list_ok
5155 : 49417552 : && !attrs
5156 : 49405657 : && c_parser_next_token_is (parser, CPP_NAME)
5157 : 32948539 : && c_parser_peek_token (parser)->id_kind == C_ID_ID
5158 : :
5159 : : /* Look ahead to detect typos in type names. */
5160 : 8697 : && c_parser_peek_2nd_token (parser)->type != CPP_NAME
5161 : 8690 : && c_parser_peek_2nd_token (parser)->type != CPP_MULT
5162 : 8689 : && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN
5163 : 8688 : && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_SQUARE
5164 : 49426239 : && c_parser_peek_2nd_token (parser)->type != CPP_KEYWORD)
5165 : : {
5166 : 8686 : tree list = NULL_TREE, *nextp = &list;
5167 : 8686 : while (c_parser_next_token_is (parser, CPP_NAME)
5168 : 34286 : && c_parser_peek_token (parser)->id_kind == C_ID_ID)
5169 : : {
5170 : 34286 : *nextp = build_tree_list (NULL_TREE,
5171 : 34286 : c_parser_peek_token (parser)->value);
5172 : 34286 : nextp = & TREE_CHAIN (*nextp);
5173 : 34286 : c_parser_consume_token (parser);
5174 : 34286 : if (c_parser_next_token_is_not (parser, CPP_COMMA))
5175 : : break;
5176 : 25600 : c_parser_consume_token (parser);
5177 : 25600 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5178 : : {
5179 : 0 : c_parser_error (parser, "expected identifier");
5180 : 0 : break;
5181 : : }
5182 : : }
5183 : 8686 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5184 : : {
5185 : 8686 : struct c_arg_info *ret = build_arg_info ();
5186 : 8686 : ret->types = list;
5187 : 8686 : c_parser_consume_token (parser);
5188 : 8686 : pop_scope ();
5189 : 8686 : return ret;
5190 : : }
5191 : : else
5192 : : {
5193 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5194 : : "expected %<)%>");
5195 : 0 : pop_scope ();
5196 : 0 : return NULL;
5197 : : }
5198 : : }
5199 : : else
5200 : : {
5201 : 49408866 : struct c_arg_info *ret
5202 : 49408866 : = c_parser_parms_list_declarator (parser, attrs, NULL, have_gnu_attrs);
5203 : 49408866 : pop_scope ();
5204 : 49408866 : return ret;
5205 : : }
5206 : : }
5207 : :
5208 : : /* Parse a parameter list (possibly empty), including the closing
5209 : : parenthesis but not the opening one. ATTRS are the gnu-attributes
5210 : : at the start of the list; if HAVE_GNU_ATTRS, there were some such
5211 : : attributes (possibly empty, in which case ATTRS is NULL_TREE),
5212 : : which means standard attributes cannot start the list. EXPR is
5213 : : NULL or an expression that needs to be evaluated for the side
5214 : : effects of array size expressions in the parameters. */
5215 : :
5216 : : static struct c_arg_info *
5217 : 49408903 : c_parser_parms_list_declarator (c_parser *parser, tree attrs, tree expr,
5218 : : bool have_gnu_attrs)
5219 : : {
5220 : 49408903 : bool bad_parm = false;
5221 : :
5222 : : /* ??? Following the old parser, forward parameter declarations may
5223 : : use abstract declarators, and if no real parameter declarations
5224 : : follow the forward declarations then this is not diagnosed. Also
5225 : : note as above that gnu-attributes are ignored as the only contents of
5226 : : the parentheses, or as the only contents after forward
5227 : : declarations. */
5228 : 49408903 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5229 : : {
5230 : 770916 : struct c_arg_info *ret = build_arg_info ();
5231 : 770916 : c_parser_consume_token (parser);
5232 : 770916 : return ret;
5233 : : }
5234 : 48637987 : if (c_parser_next_token_is (parser, CPP_ELLIPSIS) && !have_gnu_attrs)
5235 : : {
5236 : 135 : struct c_arg_info *ret = build_arg_info ();
5237 : :
5238 : 135 : ret->types = NULL_TREE;
5239 : 135 : pedwarn_c11 (c_parser_peek_token (parser)->location, OPT_Wpedantic,
5240 : : "ISO C requires a named argument before %<...%> "
5241 : : "before C23");
5242 : 135 : c_parser_consume_token (parser);
5243 : 135 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5244 : : {
5245 : 135 : ret->no_named_args_stdarg_p = true;
5246 : 135 : c_parser_consume_token (parser);
5247 : 135 : return ret;
5248 : : }
5249 : : else
5250 : : {
5251 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5252 : : "expected %<)%>");
5253 : 0 : return NULL;
5254 : : }
5255 : : }
5256 : : /* Nonempty list of parameters, either terminated with semicolon
5257 : : (forward declarations; recurse) or with close parenthesis (normal
5258 : : function) or with ", ... )" (variadic function). */
5259 : 121111430 : while (true)
5260 : : {
5261 : : /* Parse a parameter. */
5262 : 121111430 : struct c_parm *parm = c_parser_parameter_declaration (parser, attrs,
5263 : : have_gnu_attrs);
5264 : 121111430 : attrs = NULL_TREE;
5265 : 121111430 : have_gnu_attrs = false;
5266 : 121111430 : if (parm == NULL)
5267 : : bad_parm = true;
5268 : : else
5269 : 121111321 : push_parm_decl (parm, &expr);
5270 : 121111430 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
5271 : : {
5272 : 37 : tree new_attrs;
5273 : 37 : c_parser_consume_token (parser);
5274 : 37 : mark_forward_parm_decls ();
5275 : 37 : bool new_have_gnu_attrs
5276 : 37 : = c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE);
5277 : 37 : new_attrs = c_parser_gnu_attributes (parser);
5278 : 37 : return c_parser_parms_list_declarator (parser, new_attrs, expr,
5279 : 37 : new_have_gnu_attrs);
5280 : : }
5281 : 121111393 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5282 : : {
5283 : 48427621 : c_parser_consume_token (parser);
5284 : 48427621 : if (bad_parm)
5285 : : return NULL;
5286 : : else
5287 : 48427536 : return get_parm_info (false, expr);
5288 : : }
5289 : 72683772 : if (!c_parser_require (parser, CPP_COMMA,
5290 : : "expected %<;%>, %<,%> or %<)%>",
5291 : : UNKNOWN_LOCATION, false))
5292 : : {
5293 : 8 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5294 : 8 : return NULL;
5295 : : }
5296 : 72683764 : if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
5297 : : {
5298 : 210186 : c_parser_consume_token (parser);
5299 : 210186 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5300 : : {
5301 : 210179 : c_parser_consume_token (parser);
5302 : 210179 : if (bad_parm)
5303 : : return NULL;
5304 : : else
5305 : 210171 : return get_parm_info (true, expr);
5306 : : }
5307 : : else
5308 : : {
5309 : 7 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5310 : : "expected %<)%>");
5311 : 7 : return NULL;
5312 : : }
5313 : : }
5314 : : }
5315 : : }
5316 : :
5317 : : /* Parse a parameter declaration. ATTRS are the gnu-attributes at the
5318 : : start of the declaration if it is the first parameter;
5319 : : HAVE_GNU_ATTRS is true if there were any gnu-attributes there (even
5320 : : empty) there. */
5321 : :
5322 : : static struct c_parm *
5323 : 121111430 : c_parser_parameter_declaration (c_parser *parser, tree attrs,
5324 : : bool have_gnu_attrs)
5325 : : {
5326 : 121111430 : struct c_declspecs *specs;
5327 : 121111430 : struct c_declarator *declarator;
5328 : 121111430 : tree prefix_attrs;
5329 : 121111430 : tree postfix_attrs = NULL_TREE;
5330 : 121111430 : bool dummy = false;
5331 : :
5332 : : /* Accept #pragmas between parameter declarations. */
5333 : 121111432 : while (c_parser_next_token_is (parser, CPP_PRAGMA))
5334 : 2 : c_parser_pragma (parser, pragma_param, NULL, NULL_TREE);
5335 : :
5336 : 121111430 : if (!c_parser_next_token_starts_declspecs (parser)
5337 : 121111430 : && !c_parser_nth_token_starts_std_attributes (parser, 1))
5338 : : {
5339 : 97 : c_token *token = c_parser_peek_token (parser);
5340 : 97 : if (parser->error)
5341 : : return NULL;
5342 : 97 : c_parser_set_source_position_from_token (token);
5343 : 97 : if (c_parser_next_tokens_start_typename (parser, cla_prefer_type))
5344 : : {
5345 : 79 : auto_diagnostic_group d;
5346 : 79 : name_hint hint = lookup_name_fuzzy (token->value,
5347 : : FUZZY_LOOKUP_TYPENAME,
5348 : 79 : token->location);
5349 : 79 : if (const char *suggestion = hint.suggestion ())
5350 : : {
5351 : 30 : gcc_rich_location richloc (token->location);
5352 : 30 : richloc.add_fixit_replace (suggestion);
5353 : 30 : error_at (&richloc,
5354 : : "unknown type name %qE; did you mean %qs?",
5355 : : token->value, suggestion);
5356 : 30 : }
5357 : : else
5358 : 49 : error_at (token->location, "unknown type name %qE", token->value);
5359 : 79 : parser->error = true;
5360 : 79 : }
5361 : : /* ??? In some Objective-C cases '...' isn't applicable so there
5362 : : should be a different message. */
5363 : : else
5364 : 18 : c_parser_error (parser,
5365 : : "expected declaration specifiers or %<...%>");
5366 : 97 : c_parser_skip_to_end_of_parameter (parser);
5367 : 97 : return NULL;
5368 : : }
5369 : :
5370 : 121111333 : location_t start_loc = c_parser_peek_token (parser)->location;
5371 : :
5372 : 121111333 : specs = build_null_declspecs ();
5373 : 121111333 : if (attrs)
5374 : : {
5375 : 338 : declspecs_add_attrs (input_location, specs, attrs);
5376 : 338 : attrs = NULL_TREE;
5377 : : }
5378 : 121111333 : c_parser_declspecs (parser, specs, true, true, true, true, false,
5379 : 121111333 : !have_gnu_attrs, true, cla_nonabstract_decl);
5380 : 121111333 : finish_declspecs (specs);
5381 : 121111333 : pending_xref_error ();
5382 : 121111333 : prefix_attrs = specs->attrs;
5383 : 121111333 : specs->attrs = NULL_TREE;
5384 : 242222666 : declarator = c_parser_declarator (parser,
5385 : 121111333 : specs->typespec_kind != ctsk_none,
5386 : : C_DTR_PARM, &dummy);
5387 : 121111333 : if (declarator == NULL)
5388 : : {
5389 : 12 : c_parser_skip_until_found (parser, CPP_COMMA, NULL);
5390 : 12 : return NULL;
5391 : : }
5392 : 121111321 : if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
5393 : 17128 : postfix_attrs = c_parser_gnu_attributes (parser);
5394 : :
5395 : : /* Generate a location for the parameter, ranging from the start of the
5396 : : initial token to the end of the final token.
5397 : :
5398 : : If we have a identifier, then use it for the caret location, e.g.
5399 : :
5400 : : extern int callee (int one, int (*two)(int, int), float three);
5401 : : ~~~~~~^~~~~~~~~~~~~~
5402 : :
5403 : : otherwise, reuse the start location for the caret location e.g.:
5404 : :
5405 : : extern int callee (int one, int (*)(int, int), float three);
5406 : : ^~~~~~~~~~~~~~~~~
5407 : : */
5408 : 121111321 : location_t end_loc = parser->last_token_location;
5409 : :
5410 : : /* Find any cdk_id declarator; determine if we have an identifier. */
5411 : 121111321 : c_declarator *id_declarator = declarator;
5412 : 133756386 : while (id_declarator && id_declarator->kind != cdk_id)
5413 : 12645065 : id_declarator = id_declarator->declarator;
5414 : 116628744 : location_t caret_loc = (id_declarator->u.id.id
5415 : 121111321 : ? id_declarator->id_loc
5416 : : : start_loc);
5417 : 121111321 : location_t param_loc = make_location (caret_loc, start_loc, end_loc);
5418 : :
5419 : 121111321 : return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
5420 : 121111321 : declarator, param_loc);
5421 : : }
5422 : :
5423 : : /* Parse a string literal in an asm expression. It should not be
5424 : : translated, and wide string literals are an error although
5425 : : permitted by the syntax. This is a GNU extension.
5426 : :
5427 : : asm-string-literal:
5428 : : string-literal
5429 : : */
5430 : :
5431 : : static tree
5432 : 1926403 : c_parser_asm_string_literal (c_parser *parser)
5433 : : {
5434 : 1926403 : tree str;
5435 : 1926403 : int save_flag = warn_overlength_strings;
5436 : 1926403 : warn_overlength_strings = 0;
5437 : 1926403 : str = c_parser_string_literal (parser, false, false).value;
5438 : 1926403 : warn_overlength_strings = save_flag;
5439 : 1926403 : return str;
5440 : : }
5441 : :
5442 : : /* Parse a simple asm expression. This is used in restricted
5443 : : contexts, where a full expression with inputs and outputs does not
5444 : : make sense. This is a GNU extension.
5445 : :
5446 : : simple-asm-expr:
5447 : : asm ( asm-string-literal )
5448 : : */
5449 : :
5450 : : static tree
5451 : 856293 : c_parser_simple_asm_expr (c_parser *parser)
5452 : : {
5453 : 856293 : tree str;
5454 : 856293 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
5455 : 856293 : c_parser_consume_token (parser);
5456 : 856293 : matching_parens parens;
5457 : 856293 : if (!parens.require_open (parser))
5458 : : return NULL_TREE;
5459 : 856293 : str = c_parser_asm_string_literal (parser);
5460 : 856293 : if (!parens.require_close (parser))
5461 : : {
5462 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5463 : 0 : return NULL_TREE;
5464 : : }
5465 : : return str;
5466 : : }
5467 : :
5468 : : static tree
5469 : 132229994 : c_parser_gnu_attribute_any_word (c_parser *parser)
5470 : : {
5471 : 132229994 : tree attr_name = NULL_TREE;
5472 : :
5473 : 132229994 : if (c_parser_next_token_is (parser, CPP_KEYWORD))
5474 : : {
5475 : : /* ??? See comment above about what keywords are accepted here. */
5476 : 852508 : bool ok;
5477 : 852508 : switch (c_parser_peek_token (parser)->keyword)
5478 : : {
5479 : : case RID_STATIC:
5480 : : case RID_UNSIGNED:
5481 : : case RID_LONG:
5482 : : case RID_CONST:
5483 : : case RID_EXTERN:
5484 : : case RID_REGISTER:
5485 : : case RID_TYPEDEF:
5486 : : case RID_SHORT:
5487 : : case RID_INLINE:
5488 : : case RID_NORETURN:
5489 : : case RID_VOLATILE:
5490 : : case RID_SIGNED:
5491 : : case RID_AUTO:
5492 : : case RID_RESTRICT:
5493 : : case RID_COMPLEX:
5494 : : case RID_THREAD:
5495 : : case RID_INT:
5496 : : case RID_CHAR:
5497 : : case RID_FLOAT:
5498 : : case RID_DOUBLE:
5499 : : case RID_VOID:
5500 : : case RID_DFLOAT32:
5501 : : case RID_DFLOAT64:
5502 : : case RID_DFLOAT128:
5503 : : case RID_DFLOAT64X:
5504 : : CASE_RID_FLOATN_NX:
5505 : : case RID_BOOL:
5506 : : case RID_BITINT:
5507 : : case RID_FRACT:
5508 : : case RID_ACCUM:
5509 : : case RID_SAT:
5510 : : case RID_TRANSACTION_ATOMIC:
5511 : : case RID_TRANSACTION_CANCEL:
5512 : : case RID_ATOMIC:
5513 : : case RID_AUTO_TYPE:
5514 : : case RID_CONSTEXPR:
5515 : : case RID_INT_N_0:
5516 : : case RID_INT_N_1:
5517 : : case RID_INT_N_2:
5518 : : case RID_INT_N_3:
5519 : : ok = true;
5520 : : break;
5521 : : default:
5522 : : ok = false;
5523 : : break;
5524 : : }
5525 : 852508 : if (!ok)
5526 : : return NULL_TREE;
5527 : :
5528 : : /* Accept __attribute__((__const)) as __attribute__((const)) etc. */
5529 : 852508 : attr_name = ridpointers[(int) c_parser_peek_token (parser)->keyword];
5530 : : }
5531 : 131377486 : else if (c_parser_next_token_is (parser, CPP_NAME))
5532 : 131377483 : attr_name = c_parser_peek_token (parser)->value;
5533 : :
5534 : : return attr_name;
5535 : : }
5536 : :
5537 : : /* Parse attribute arguments. This is a common form of syntax
5538 : : covering all currently valid GNU and standard attributes.
5539 : :
5540 : : gnu-attribute-arguments:
5541 : : identifier
5542 : : identifier , nonempty-expr-list
5543 : : expr-list
5544 : :
5545 : : where the "identifier" must not be declared as a type. ??? Why not
5546 : : allow identifiers declared as types to start the arguments? */
5547 : :
5548 : : static tree
5549 : 4452324 : c_parser_attribute_arguments (c_parser *parser, bool takes_identifier,
5550 : : bool require_string, bool assume_attr,
5551 : : bool allow_empty_args)
5552 : : {
5553 : 4452324 : vec<tree, va_gc> *expr_list;
5554 : 4452324 : tree attr_args;
5555 : : /* Parse the attribute contents. If they start with an
5556 : : identifier which is followed by a comma or close
5557 : : parenthesis, then the arguments start with that
5558 : : identifier; otherwise they are an expression list.
5559 : : In objective-c the identifier may be a classname. */
5560 : 4452324 : if (c_parser_next_token_is (parser, CPP_NAME)
5561 : 562090 : && (c_parser_peek_token (parser)->id_kind == C_ID_ID
5562 : 1 : || (c_dialect_objc ()
5563 : 0 : && c_parser_peek_token (parser)->id_kind
5564 : : == C_ID_CLASSNAME))
5565 : 562089 : && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
5566 : 38793 : || (c_parser_peek_2nd_token (parser)->type
5567 : : == CPP_CLOSE_PAREN))
5568 : 5014374 : && (takes_identifier
5569 : 141843 : || (c_dialect_objc ()
5570 : 0 : && !assume_attr
5571 : 0 : && c_parser_peek_token (parser)->id_kind
5572 : : == C_ID_CLASSNAME)))
5573 : : {
5574 : 420207 : tree arg1 = c_parser_peek_token (parser)->value;
5575 : 420207 : c_parser_consume_token (parser);
5576 : 420207 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5577 : 35071 : attr_args = build_tree_list (NULL_TREE, arg1);
5578 : : else
5579 : : {
5580 : 385136 : tree tree_list;
5581 : 385136 : c_parser_consume_token (parser);
5582 : 385136 : expr_list = c_parser_expr_list (parser, false, true,
5583 : : NULL, NULL, NULL, NULL);
5584 : 385136 : tree_list = build_tree_list_vec (expr_list);
5585 : 385136 : attr_args = tree_cons (NULL_TREE, arg1, tree_list);
5586 : 385136 : release_tree_vector (expr_list);
5587 : : }
5588 : : }
5589 : : else
5590 : : {
5591 : 4032117 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5592 : : {
5593 : 16 : if (!allow_empty_args)
5594 : 3 : error_at (c_parser_peek_token (parser)->location,
5595 : : "parentheses must be omitted if "
5596 : : "attribute argument list is empty");
5597 : : attr_args = NULL_TREE;
5598 : : }
5599 : 4032101 : else if (require_string)
5600 : : {
5601 : : /* The only valid argument for this attribute is a string
5602 : : literal. Handle this specially here to avoid accepting
5603 : : string literals with excess parentheses. */
5604 : 19 : tree string = c_parser_string_literal (parser, false, true).value;
5605 : 19 : attr_args = build_tree_list (NULL_TREE, string);
5606 : : }
5607 : 4032082 : else if (assume_attr)
5608 : : {
5609 : 45 : tree cond
5610 : 45 : = c_parser_conditional_expression (parser, NULL, NULL_TREE).value;
5611 : 45 : if (!c_parser_next_token_is (parser, CPP_COMMA))
5612 : 43 : attr_args = build_tree_list (NULL_TREE, cond);
5613 : : else
5614 : : {
5615 : 2 : tree tree_list;
5616 : 2 : c_parser_consume_token (parser);
5617 : 2 : expr_list = c_parser_expr_list (parser, false, true,
5618 : : NULL, NULL, NULL, NULL);
5619 : 2 : tree_list = build_tree_list_vec (expr_list);
5620 : 2 : attr_args = tree_cons (NULL_TREE, cond, tree_list);
5621 : 2 : release_tree_vector (expr_list);
5622 : : }
5623 : : }
5624 : : else
5625 : : {
5626 : 4032037 : expr_list = c_parser_expr_list (parser, false, true,
5627 : : NULL, NULL, NULL, NULL);
5628 : 4032037 : attr_args = build_tree_list_vec (expr_list);
5629 : 4032037 : release_tree_vector (expr_list);
5630 : : }
5631 : : }
5632 : 4452324 : return attr_args;
5633 : : }
5634 : :
5635 : : /* Parse (possibly empty) gnu-attributes. This is a GNU extension.
5636 : :
5637 : : gnu-attributes:
5638 : : empty
5639 : : gnu-attributes gnu-attribute
5640 : :
5641 : : gnu-attribute:
5642 : : __attribute__ ( ( gnu-attribute-list ) )
5643 : :
5644 : : gnu-attribute-list:
5645 : : gnu-attrib
5646 : : gnu-attribute_list , gnu-attrib
5647 : :
5648 : : gnu-attrib:
5649 : : empty
5650 : : any-word
5651 : : any-word ( gnu-attribute-arguments )
5652 : :
5653 : : where "any-word" may be any identifier (including one declared as a
5654 : : type), a reserved word storage class specifier, type specifier or
5655 : : type qualifier. ??? This still leaves out most reserved keywords
5656 : : (following the old parser), shouldn't we include them?
5657 : : When EXPECT_COMMA is true, expect the attribute to be preceded
5658 : : by a comma and fail if it isn't.
5659 : : When EMPTY_OK is true, allow and consume any number of consecutive
5660 : : commas with no attributes in between. */
5661 : :
5662 : : static tree
5663 : 184105856 : c_parser_gnu_attribute (c_parser *parser, tree attrs,
5664 : : bool expect_comma = false, bool empty_ok = true)
5665 : : {
5666 : 184105856 : bool comma_first = c_parser_next_token_is (parser, CPP_COMMA);
5667 : 184105856 : if (!comma_first
5668 : 103752483 : && !c_parser_next_token_is (parser, CPP_NAME)
5669 : 236834119 : && !c_parser_next_token_is (parser, CPP_KEYWORD))
5670 : : return NULL_TREE;
5671 : :
5672 : 212583374 : while (c_parser_next_token_is (parser, CPP_COMMA))
5673 : : {
5674 : 80353380 : c_parser_consume_token (parser);
5675 : 80353380 : if (!empty_ok)
5676 : : return attrs;
5677 : : }
5678 : :
5679 : 132229994 : tree attr_name = c_parser_gnu_attribute_any_word (parser);
5680 : 132229994 : if (attr_name == NULL_TREE)
5681 : : return NULL_TREE;
5682 : :
5683 : 132229991 : attr_name = canonicalize_attr_name (attr_name);
5684 : 132229991 : c_parser_consume_token (parser);
5685 : :
5686 : 132229991 : tree attr;
5687 : 132229991 : if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
5688 : : {
5689 : 127777756 : if (expect_comma && !comma_first)
5690 : : {
5691 : : /* A comma is missing between the last attribute on the chain
5692 : : and this one. */
5693 : 7 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5694 : : "expected %<)%>");
5695 : 7 : return error_mark_node;
5696 : : }
5697 : 127777749 : attr = build_tree_list (attr_name, NULL_TREE);
5698 : : /* Add this attribute to the list. */
5699 : 127777749 : attrs = chainon (attrs, attr);
5700 : 127777749 : return attrs;
5701 : : }
5702 : 4452235 : c_parser_consume_token (parser);
5703 : :
5704 : 4452235 : tree attr_args
5705 : 4452235 : = c_parser_attribute_arguments (parser,
5706 : 4452235 : attribute_takes_identifier_p (attr_name),
5707 : : false,
5708 : 4452235 : is_attribute_p ("assume", attr_name),
5709 : : true);
5710 : :
5711 : 4452235 : attr = build_tree_list (attr_name, attr_args);
5712 : 4452235 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5713 : 4452233 : c_parser_consume_token (parser);
5714 : : else
5715 : : {
5716 : 2 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5717 : : "expected %<)%>");
5718 : 2 : return error_mark_node;
5719 : : }
5720 : :
5721 : 4452233 : if (expect_comma && !comma_first)
5722 : : {
5723 : : /* A comma is missing between the last attribute on the chain
5724 : : and this one. */
5725 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5726 : : "expected %<)%>");
5727 : 0 : return error_mark_node;
5728 : : }
5729 : :
5730 : : /* Add this attribute to the list. */
5731 : 4452233 : attrs = chainon (attrs, attr);
5732 : 4452233 : return attrs;
5733 : : }
5734 : :
5735 : : static tree
5736 : 106979309 : c_parser_gnu_attributes (c_parser *parser)
5737 : : {
5738 : 106979309 : tree attrs = NULL_TREE;
5739 : 158855170 : while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
5740 : : {
5741 : 51875871 : bool save_translate_strings_p = parser->translate_strings_p;
5742 : 51875871 : parser->translate_strings_p = false;
5743 : : /* Consume the `__attribute__' keyword. */
5744 : 51875871 : c_parser_consume_token (parser);
5745 : : /* Look for the two `(' tokens. */
5746 : 51875871 : if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5747 : : {
5748 : 0 : parser->translate_strings_p = save_translate_strings_p;
5749 : 0 : return attrs;
5750 : : }
5751 : 51875871 : if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5752 : : {
5753 : 0 : parser->translate_strings_p = save_translate_strings_p;
5754 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5755 : 0 : return attrs;
5756 : : }
5757 : : /* Parse the attribute list. Require a comma between successive
5758 : : (possibly empty) attributes. */
5759 : : for (bool expect_comma = false; ; expect_comma = true)
5760 : : {
5761 : : /* Parse a single attribute. */
5762 : 184105096 : tree attr = c_parser_gnu_attribute (parser, attrs, expect_comma);
5763 : 184105096 : if (attr == error_mark_node)
5764 : : return attrs;
5765 : 184105087 : if (!attr)
5766 : : break;
5767 : : attrs = attr;
5768 : : }
5769 : :
5770 : : /* Look for the two `)' tokens. */
5771 : 51875862 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5772 : 51875862 : c_parser_consume_token (parser);
5773 : : else
5774 : : {
5775 : 0 : parser->translate_strings_p = save_translate_strings_p;
5776 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5777 : : "expected %<)%>");
5778 : 0 : return attrs;
5779 : : }
5780 : 51875862 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5781 : 51875861 : c_parser_consume_token (parser);
5782 : : else
5783 : : {
5784 : 1 : parser->translate_strings_p = save_translate_strings_p;
5785 : 1 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5786 : : "expected %<)%>");
5787 : 1 : return attrs;
5788 : : }
5789 : 51875861 : parser->translate_strings_p = save_translate_strings_p;
5790 : : }
5791 : :
5792 : : return attrs;
5793 : : }
5794 : :
5795 : : /* Parse an optional balanced token sequence.
5796 : :
5797 : : balanced-token-sequence:
5798 : : balanced-token
5799 : : balanced-token-sequence balanced-token
5800 : :
5801 : : balanced-token:
5802 : : ( balanced-token-sequence[opt] )
5803 : : [ balanced-token-sequence[opt] ]
5804 : : { balanced-token-sequence[opt] }
5805 : : any token other than ()[]{}
5806 : : */
5807 : :
5808 : : static void
5809 : 142 : c_parser_balanced_token_sequence (c_parser *parser)
5810 : : {
5811 : 551 : while (true)
5812 : : {
5813 : 551 : c_token *token = c_parser_peek_token (parser);
5814 : 551 : switch (token->type)
5815 : : {
5816 : 4 : case CPP_OPEN_BRACE:
5817 : 4 : {
5818 : 4 : matching_braces braces;
5819 : 4 : braces.consume_open (parser);
5820 : 4 : c_parser_balanced_token_sequence (parser);
5821 : 4 : braces.require_close (parser);
5822 : 4 : break;
5823 : : }
5824 : :
5825 : 42 : case CPP_OPEN_PAREN:
5826 : 42 : {
5827 : 42 : matching_parens parens;
5828 : 42 : parens.consume_open (parser);
5829 : 42 : c_parser_balanced_token_sequence (parser);
5830 : 42 : parens.require_close (parser);
5831 : 42 : break;
5832 : : }
5833 : :
5834 : 33 : case CPP_OPEN_SQUARE:
5835 : 33 : c_parser_consume_token (parser);
5836 : 33 : c_parser_balanced_token_sequence (parser);
5837 : 33 : c_parser_require (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
5838 : 33 : break;
5839 : :
5840 : 142 : case CPP_CLOSE_BRACE:
5841 : 142 : case CPP_CLOSE_PAREN:
5842 : 142 : case CPP_CLOSE_SQUARE:
5843 : 142 : case CPP_EOF:
5844 : 142 : return;
5845 : :
5846 : 1 : case CPP_PRAGMA:
5847 : 1 : c_parser_consume_pragma (parser);
5848 : 1 : c_parser_skip_to_pragma_eol (parser, false);
5849 : 1 : break;
5850 : :
5851 : 329 : default:
5852 : 329 : c_parser_consume_token (parser);
5853 : 329 : break;
5854 : : }
5855 : : }
5856 : : }
5857 : :
5858 : : static bool c_parser_check_balanced_raw_token_sequence (c_parser *,
5859 : : unsigned int *);
5860 : :
5861 : : /* Parse arguments of omp::directive or omp::decl attribute.
5862 : :
5863 : : directive-name ,[opt] clause-list[opt]
5864 : :
5865 : : For directive just remember the tokens in a vector for subsequent
5866 : : parsing. */
5867 : :
5868 : : static void
5869 : 904 : c_parser_omp_directive_args (c_parser *parser, tree attribute, bool decl_p)
5870 : : {
5871 : 904 : unsigned int n = 1;
5872 : 904 : c_token *first = c_parser_peek_token (parser);
5873 : 904 : if (!c_parser_check_balanced_raw_token_sequence (parser, &n)
5874 : 904 : || (c_parser_peek_nth_token_raw (parser, n)->type
5875 : : != CPP_CLOSE_PAREN))
5876 : : {
5877 : 1 : c_parser_balanced_token_sequence (parser);
5878 : 1 : TREE_VALUE (attribute) = NULL_TREE;
5879 : 3 : return;
5880 : : }
5881 : 903 : if (n == 1)
5882 : : {
5883 : 2 : error_at (first->location, "expected OpenMP directive name");
5884 : 2 : TREE_VALUE (attribute) = NULL_TREE;
5885 : 2 : return;
5886 : : }
5887 : 901 : vec<c_token, va_gc> *v;
5888 : 901 : vec_alloc (v, n - 1);
5889 : 18697 : for (--n; n; --n)
5890 : : {
5891 : 17796 : c_token *tok = c_parser_peek_token (parser);
5892 : 17796 : v->quick_push (*tok);
5893 : 17796 : c_parser_consume_token (parser);
5894 : : }
5895 : 901 : tree arg = make_node (C_TOKEN_VEC);
5896 : 901 : C_TOKEN_VEC_TOKENS (arg) = v;
5897 : 901 : if (decl_p)
5898 : 54 : TREE_PUBLIC (arg) = 1;
5899 : 901 : TREE_VALUE (attribute) = tree_cons (NULL_TREE, arg, TREE_VALUE (attribute));
5900 : : }
5901 : :
5902 : : /* Parse arguments of omp::sequence attribute.
5903 : :
5904 : : omp::[opt] directive-attr [ , omp::[opt] directive-attr ]... */
5905 : :
5906 : : static void
5907 : 157 : c_parser_omp_sequence_args (c_parser *parser, tree attribute)
5908 : : {
5909 : 314 : do
5910 : : {
5911 : 314 : c_token *token = c_parser_peek_token (parser);
5912 : 314 : if (token->type == CPP_NAME
5913 : 313 : && strcmp (IDENTIFIER_POINTER (token->value), "omp") == 0
5914 : 378 : && c_parser_peek_2nd_token (parser)->type == CPP_SCOPE)
5915 : : {
5916 : 64 : c_parser_consume_token (parser);
5917 : 64 : c_parser_consume_token (parser);
5918 : 64 : token = c_parser_peek_token (parser);
5919 : : }
5920 : 314 : bool directive = false;
5921 : 314 : const char *p;
5922 : 314 : if (token->type != CPP_NAME)
5923 : : p = "";
5924 : : else
5925 : 313 : p = IDENTIFIER_POINTER (token->value);
5926 : 314 : if (strcmp (p, "directive") == 0)
5927 : : directive = true;
5928 : 12 : else if (strcmp (p, "sequence") != 0)
5929 : : {
5930 : 7 : error_at (token->location, "expected %<directive%> or %<sequence%>");
5931 : 7 : unsigned nesting_depth = 0;
5932 : :
5933 : 47 : while (true)
5934 : : {
5935 : : /* Peek at the next token. */
5936 : 27 : token = c_parser_peek_token (parser);
5937 : : /* If we've reached the token we want, consume it and stop. */
5938 : 27 : if ((token->type == CPP_CLOSE_PAREN || token->type == CPP_COMMA)
5939 : 13 : && !nesting_depth)
5940 : : break;
5941 : : /* If we've run out of tokens, stop. */
5942 : 20 : if (token->type == CPP_EOF)
5943 : : break;
5944 : 20 : if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
5945 : : break;
5946 : 20 : if (token->type == CPP_OPEN_BRACE
5947 : : || token->type == CPP_OPEN_PAREN
5948 : : || token->type == CPP_OPEN_SQUARE)
5949 : 6 : ++nesting_depth;
5950 : : else if (token->type == CPP_CLOSE_BRACE
5951 : : || token->type == CPP_CLOSE_PAREN
5952 : : || token->type == CPP_CLOSE_SQUARE)
5953 : : {
5954 : 6 : if (nesting_depth-- == 0)
5955 : : break;
5956 : : }
5957 : : /* Consume this token. */
5958 : 20 : c_parser_consume_token (parser);
5959 : : }
5960 : 7 : if (c_parser_next_token_is_not (parser, CPP_COMMA))
5961 : : break;
5962 : 0 : c_parser_consume_token (parser);
5963 : 0 : continue;
5964 : 0 : }
5965 : 307 : c_parser_consume_token (parser);
5966 : 307 : matching_parens parens;
5967 : 307 : if (parens.require_open (parser))
5968 : : {
5969 : 305 : if (directive)
5970 : 301 : c_parser_omp_directive_args (parser, attribute, false);
5971 : : else
5972 : 4 : c_parser_omp_sequence_args (parser, attribute);
5973 : 305 : parens.skip_until_found_close (parser);
5974 : 305 : if (c_parser_next_token_is_not (parser, CPP_COMMA))
5975 : : break;
5976 : 157 : c_parser_consume_token (parser);
5977 : : }
5978 : 2 : else if (c_parser_next_token_is_not (parser, CPP_COMMA))
5979 : : break;
5980 : : else
5981 : 0 : c_parser_consume_token (parser);
5982 : : }
5983 : : while (1);
5984 : 157 : }
5985 : :
5986 : : /* Parse standard (C23) attributes (including GNU attributes in the
5987 : : gnu:: namespace).
5988 : :
5989 : : attribute-specifier-sequence:
5990 : : attribute-specifier-sequence[opt] attribute-specifier
5991 : :
5992 : : attribute-specifier:
5993 : : [ [ attribute-list ] ]
5994 : :
5995 : : attribute-list:
5996 : : attribute[opt]
5997 : : attribute-list, attribute[opt]
5998 : :
5999 : : attribute:
6000 : : attribute-token attribute-argument-clause[opt]
6001 : :
6002 : : attribute-token:
6003 : : standard-attribute
6004 : : attribute-prefixed-token
6005 : :
6006 : : standard-attribute:
6007 : : identifier
6008 : :
6009 : : attribute-prefixed-token:
6010 : : attribute-prefix :: identifier
6011 : :
6012 : : attribute-prefix:
6013 : : identifier
6014 : :
6015 : : attribute-argument-clause:
6016 : : ( balanced-token-sequence[opt] )
6017 : :
6018 : : Keywords are accepted as identifiers for this purpose.
6019 : :
6020 : : As an extension, we permit an attribute-specifier to be:
6021 : :
6022 : : [ [ __extension__ attribute-list ] ]
6023 : :
6024 : : Two colons are then accepted as a synonym for ::. No attempt is made
6025 : : to check whether the colons are immediately adjacent. LOOSE_SCOPE_P
6026 : : indicates whether this relaxation is in effect. */
6027 : :
6028 : : static tree
6029 : 1921 : c_parser_std_attribute (c_parser *parser, bool for_tm)
6030 : : {
6031 : 1921 : c_token *token = c_parser_peek_token (parser);
6032 : 1921 : tree ns, name, attribute;
6033 : :
6034 : : /* Parse the attribute-token. */
6035 : 1921 : if (token->type != CPP_NAME && token->type != CPP_KEYWORD)
6036 : : {
6037 : 2 : c_parser_error (parser, "expected identifier");
6038 : 2 : return error_mark_node;
6039 : : }
6040 : 1919 : name = canonicalize_attr_name (token->value);
6041 : 1919 : c_parser_consume_token (parser);
6042 : 1919 : if (c_parser_next_token_is (parser, CPP_SCOPE)
6043 : 2381 : || (c_parser_next_token_is (parser, CPP_COLON)
6044 : 36 : && (c_parser_peek_token (parser)->flags & COLON_SCOPE) != 0
6045 : 10 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
6046 : : {
6047 : 1467 : ns = name;
6048 : 1467 : if (c_parser_next_token_is (parser, CPP_COLON))
6049 : 10 : c_parser_consume_token (parser);
6050 : 1467 : c_parser_consume_token (parser);
6051 : 1467 : token = c_parser_peek_token (parser);
6052 : 1467 : if (token->type != CPP_NAME && token->type != CPP_KEYWORD)
6053 : : {
6054 : 0 : c_parser_error (parser, "expected identifier");
6055 : 0 : return error_mark_node;
6056 : : }
6057 : 1467 : name = canonicalize_attr_name (token->value);
6058 : 1467 : c_parser_consume_token (parser);
6059 : : }
6060 : : else
6061 : : ns = NULL_TREE;
6062 : 1919 : attribute = build_tree_list (build_tree_list (ns, name), NULL_TREE);
6063 : :
6064 : : /* Parse the arguments, if any. */
6065 : 1919 : const attribute_spec *as = lookup_attribute_spec (TREE_PURPOSE (attribute));
6066 : 1919 : if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
6067 : : {
6068 : 987 : if ((flag_openmp || flag_openmp_simd)
6069 : 9 : && ns
6070 : 7 : && is_attribute_p ("omp", ns)
6071 : 999 : && (is_attribute_p ("directive", name)
6072 : 2 : || is_attribute_p ("sequence", name)
6073 : 1 : || is_attribute_p ("decl", name)))
6074 : : {
6075 : 3 : error ("%<omp::%E%> attribute requires argument", name);
6076 : 3 : return error_mark_node;
6077 : : }
6078 : 993 : goto out;
6079 : : }
6080 : 923 : {
6081 : 923 : location_t open_loc = c_parser_peek_token (parser)->location;
6082 : 923 : matching_parens parens;
6083 : 923 : parens.consume_open (parser);
6084 : 125 : if ((as && as->max_length == 0)
6085 : : /* Special-case the transactional-memory attribute "outer",
6086 : : which is specially handled but not registered as an
6087 : : attribute, to avoid allowing arbitrary balanced token
6088 : : sequences as arguments. */
6089 : 1025 : || is_attribute_p ("outer", name))
6090 : : {
6091 : 24 : error_at (open_loc, "%qE attribute does not take any arguments", name);
6092 : 24 : parens.skip_until_found_close (parser);
6093 : 780 : return error_mark_node;
6094 : : }
6095 : : /* If this is a fake attribute created to handle -Wno-attributes,
6096 : : we must skip parsing the arguments. */
6097 : 899 : if (as && !attribute_ignored_p (as))
6098 : : {
6099 : 89 : bool takes_identifier
6100 : : = (ns != NULL_TREE
6101 : 68 : && strcmp (IDENTIFIER_POINTER (ns), "gnu") == 0
6102 : 157 : && attribute_takes_identifier_p (name));
6103 : 21 : bool require_string
6104 : : = (ns == NULL_TREE
6105 : 21 : && (strcmp (IDENTIFIER_POINTER (name), "deprecated") == 0
6106 : 11 : || strcmp (IDENTIFIER_POINTER (name), "nodiscard") == 0));
6107 : 68 : bool assume_attr
6108 : : = (ns != NULL_TREE
6109 : 68 : && strcmp (IDENTIFIER_POINTER (ns), "gnu") == 0
6110 : 68 : && strcmp (IDENTIFIER_POINTER (name), "assume") == 0);
6111 : 178 : TREE_VALUE (attribute)
6112 : 89 : = c_parser_attribute_arguments (parser, takes_identifier,
6113 : : require_string, assume_attr, false);
6114 : : }
6115 : : else
6116 : : {
6117 : 54 : if ((flag_openmp || flag_openmp_simd)
6118 : 756 : && ns
6119 : 1566 : && is_attribute_p ("omp", ns))
6120 : : {
6121 : 756 : if (is_attribute_p ("directive", name))
6122 : : {
6123 : 548 : c_parser_omp_directive_args (parser, attribute, false);
6124 : 548 : parens.skip_until_found_close (parser);
6125 : 548 : return attribute;
6126 : : }
6127 : 208 : else if (is_attribute_p ("decl", name))
6128 : : {
6129 : 55 : TREE_VALUE (TREE_PURPOSE (attribute))
6130 : 55 : = get_identifier ("directive");
6131 : 55 : c_parser_omp_directive_args (parser, attribute, true);
6132 : 55 : parens.skip_until_found_close (parser);
6133 : 55 : return attribute;
6134 : : }
6135 : 153 : else if (is_attribute_p ("sequence", name))
6136 : : {
6137 : 153 : TREE_VALUE (TREE_PURPOSE (attribute))
6138 : 153 : = get_identifier ("directive");
6139 : 153 : c_parser_omp_sequence_args (parser, attribute);
6140 : 153 : parens.skip_until_found_close (parser);
6141 : 153 : TREE_VALUE (attribute) = nreverse (TREE_VALUE (attribute));
6142 : 153 : return attribute;
6143 : : }
6144 : : }
6145 : 54 : c_parser_balanced_token_sequence (parser);
6146 : : }
6147 : 143 : parens.require_close (parser);
6148 : : }
6149 : 1136 : out:
6150 : 1136 : if (ns == NULL_TREE && !for_tm && !as)
6151 : : {
6152 : : /* An attribute with standard syntax and no namespace specified
6153 : : is a constraint violation if it is not one of the known
6154 : : standard attributes. Diagnose it here with a pedwarn and
6155 : : then discard it to prevent a duplicate warning later. */
6156 : 72 : pedwarn (input_location, OPT_Wattributes, "%qE attribute ignored",
6157 : : name);
6158 : 72 : return error_mark_node;
6159 : : }
6160 : : return attribute;
6161 : : }
6162 : :
6163 : : static tree
6164 : 2035 : c_parser_std_attribute_list (c_parser *parser, bool for_tm)
6165 : : {
6166 : 2035 : tree attributes = NULL_TREE;
6167 : 2261 : while (true)
6168 : : {
6169 : 2261 : c_token *token = c_parser_peek_token (parser);
6170 : 2261 : if (token->type == CPP_CLOSE_SQUARE)
6171 : : break;
6172 : 2045 : if (token->type == CPP_COMMA)
6173 : : {
6174 : 124 : c_parser_consume_token (parser);
6175 : 124 : continue;
6176 : : }
6177 : 1921 : tree attribute = c_parser_std_attribute (parser, for_tm);
6178 : 1921 : if (attribute != error_mark_node)
6179 : : {
6180 : 1820 : TREE_CHAIN (attribute) = attributes;
6181 : 1820 : attributes = attribute;
6182 : : }
6183 : 1921 : if (c_parser_next_token_is_not (parser, CPP_COMMA))
6184 : : break;
6185 : : }
6186 : 2035 : return attributes;
6187 : : }
6188 : :
6189 : : static tree
6190 : 2035 : c_parser_std_attribute_specifier (c_parser *parser, bool for_tm)
6191 : : {
6192 : 2035 : location_t loc = c_parser_peek_token (parser)->location;
6193 : 2035 : if (!c_parser_require (parser, CPP_OPEN_SQUARE, "expected %<[%>"))
6194 : : return NULL_TREE;
6195 : 2035 : if (!c_parser_require (parser, CPP_OPEN_SQUARE, "expected %<[%>"))
6196 : : {
6197 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
6198 : 0 : return NULL_TREE;
6199 : : }
6200 : 2035 : tree attributes;
6201 : 2035 : if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
6202 : : {
6203 : 42 : auto ext = disable_extension_diagnostics ();
6204 : 42 : c_parser_consume_token (parser);
6205 : 42 : attributes = c_parser_std_attribute_list (parser, for_tm);
6206 : 42 : restore_extension_diagnostics (ext);
6207 : : }
6208 : : else
6209 : : {
6210 : 1993 : if (!for_tm)
6211 : 1973 : pedwarn_c11 (loc, OPT_Wpedantic,
6212 : : "ISO C does not support %<[[]]%> attributes before C23");
6213 : 1993 : attributes = c_parser_std_attribute_list (parser, for_tm);
6214 : : }
6215 : 2035 : c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
6216 : 2035 : c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
6217 : 2035 : return nreverse (attributes);
6218 : : }
6219 : :
6220 : : /* Look past an optional balanced token sequence of raw look-ahead
6221 : : tokens starting with the *Nth token. *N is updated to point to the
6222 : : following token. Return true if such a sequence was found, false
6223 : : if the tokens parsed were not balanced. */
6224 : :
6225 : : static bool
6226 : 4372 : c_parser_check_balanced_raw_token_sequence (c_parser *parser, unsigned int *n)
6227 : : {
6228 : 20317 : while (true)
6229 : : {
6230 : 20317 : c_token *token = c_parser_peek_nth_token_raw (parser, *n);
6231 : 20317 : switch (token->type)
6232 : : {
6233 : 44 : case CPP_OPEN_BRACE:
6234 : 44 : {
6235 : 44 : ++*n;
6236 : 44 : if (c_parser_check_balanced_raw_token_sequence (parser, n))
6237 : : {
6238 : 44 : token = c_parser_peek_nth_token_raw (parser, *n);
6239 : 44 : if (token->type == CPP_CLOSE_BRACE)
6240 : 44 : ++*n;
6241 : : else
6242 : : return false;
6243 : : }
6244 : : else
6245 : : return false;
6246 : 44 : break;
6247 : : }
6248 : :
6249 : 3127 : case CPP_OPEN_PAREN:
6250 : 3127 : {
6251 : 3127 : ++*n;
6252 : 3127 : if (c_parser_check_balanced_raw_token_sequence (parser, n))
6253 : : {
6254 : 3127 : token = c_parser_peek_nth_token_raw (parser, *n);
6255 : 3127 : if (token->type == CPP_CLOSE_PAREN)
6256 : 3127 : ++*n;
6257 : : else
6258 : : return false;
6259 : : }
6260 : : else
6261 : : return false;
6262 : 3127 : break;
6263 : : }
6264 : :
6265 : 55 : case CPP_OPEN_SQUARE:
6266 : 55 : {
6267 : 55 : ++*n;
6268 : 55 : if (c_parser_check_balanced_raw_token_sequence (parser, n))
6269 : : {
6270 : 55 : token = c_parser_peek_nth_token_raw (parser, *n);
6271 : 55 : if (token->type == CPP_CLOSE_SQUARE)
6272 : 55 : ++*n;
6273 : : else
6274 : : return false;
6275 : : }
6276 : : else
6277 : : return false;
6278 : 55 : break;
6279 : : }
6280 : :
6281 : : case CPP_CLOSE_BRACE:
6282 : : case CPP_CLOSE_PAREN:
6283 : : case CPP_CLOSE_SQUARE:
6284 : : case CPP_EOF:
6285 : : return true;
6286 : :
6287 : 12719 : default:
6288 : 12719 : ++*n;
6289 : 12719 : break;
6290 : : }
6291 : : }
6292 : : }
6293 : :
6294 : : /* Return whether standard attributes start with the Nth token. */
6295 : :
6296 : : static bool
6297 : 871883309 : c_parser_nth_token_starts_std_attributes (c_parser *parser, unsigned int n)
6298 : : {
6299 : 871883309 : if (!(c_parser_peek_nth_token (parser, n)->type == CPP_OPEN_SQUARE
6300 : 2276770 : && c_parser_peek_nth_token (parser, n + 1)->type == CPP_OPEN_SQUARE))
6301 : 871880742 : return false;
6302 : : /* In C, '[[' must start attributes. In Objective-C, we need to
6303 : : check whether '[[' is matched by ']]'. */
6304 : 2567 : if (!c_dialect_objc ())
6305 : : return true;
6306 : 0 : n += 2;
6307 : 0 : if (!c_parser_check_balanced_raw_token_sequence (parser, &n))
6308 : : return false;
6309 : 0 : c_token *token = c_parser_peek_nth_token_raw (parser, n);
6310 : 0 : if (token->type != CPP_CLOSE_SQUARE)
6311 : : return false;
6312 : 0 : token = c_parser_peek_nth_token_raw (parser, n + 1);
6313 : 0 : return token->type == CPP_CLOSE_SQUARE;
6314 : : }
6315 : :
6316 : : /* Skip standard attribute tokens starting at Nth token (with 1 as the
6317 : : next token), return index of the first token after the standard
6318 : : attribute tokens, or N on failure. */
6319 : :
6320 : : static size_t
6321 : 319 : c_parser_skip_std_attribute_spec_seq (c_parser *parser, size_t n)
6322 : : {
6323 : 319 : size_t orig_n = n;
6324 : 351 : while (true)
6325 : : {
6326 : 335 : if (c_parser_peek_nth_token_raw (parser, n)->type == CPP_OPEN_SQUARE
6327 : 335 : && (c_parser_peek_nth_token_raw (parser, n + 1)->type
6328 : : == CPP_OPEN_SQUARE))
6329 : : {
6330 : 16 : unsigned int m = n + 2;
6331 : 16 : if (!c_parser_check_balanced_raw_token_sequence (parser, &m))
6332 : 0 : return orig_n;
6333 : 16 : c_token *token = c_parser_peek_nth_token_raw (parser, m);
6334 : 16 : if (token->type != CPP_CLOSE_SQUARE)
6335 : : return orig_n;
6336 : 16 : token = c_parser_peek_nth_token_raw (parser, m + 1);
6337 : 16 : if (token->type != CPP_CLOSE_SQUARE)
6338 : : return orig_n;
6339 : 16 : n = m + 2;
6340 : : }
6341 : : else
6342 : : break;
6343 : 16 : }
6344 : : return n;
6345 : : }
6346 : :
6347 : : static tree
6348 : 1955 : c_parser_std_attribute_specifier_sequence (c_parser *parser)
6349 : : {
6350 : 1955 : tree attributes = NULL_TREE;
6351 : 2015 : do
6352 : : {
6353 : 2015 : tree attrs = c_parser_std_attribute_specifier (parser, false);
6354 : 2015 : attributes = chainon (attributes, attrs);
6355 : : }
6356 : 2015 : while (c_parser_nth_token_starts_std_attributes (parser, 1));
6357 : 1955 : return attributes;
6358 : : }
6359 : :
6360 : : /* Parse a type name (C90 6.5.5, C99 6.7.6, C11 6.7.7). ALIGNAS_OK
6361 : : says whether alignment specifiers are OK (only in cases that might
6362 : : be the type name of a compound literal).
6363 : :
6364 : : type-name:
6365 : : specifier-qualifier-list abstract-declarator[opt]
6366 : : */
6367 : :
6368 : : struct c_type_name *
6369 : 118375079 : c_parser_type_name (c_parser *parser, bool alignas_ok)
6370 : : {
6371 : 118375079 : struct c_declspecs *specs = build_null_declspecs ();
6372 : 118375079 : struct c_declarator *declarator;
6373 : 118375079 : struct c_type_name *ret;
6374 : 118375079 : bool dummy = false;
6375 : 118375079 : c_parser_declspecs (parser, specs, false, true, true, alignas_ok, false,
6376 : : false, true, cla_prefer_type);
6377 : 118375079 : if (!specs->declspecs_seen_p)
6378 : : {
6379 : 4 : c_parser_error (parser, "expected specifier-qualifier-list");
6380 : 4 : return NULL;
6381 : : }
6382 : 118375075 : if (specs->type != error_mark_node)
6383 : : {
6384 : 118375058 : pending_xref_error ();
6385 : 118375058 : finish_declspecs (specs);
6386 : : }
6387 : 236750150 : declarator = c_parser_declarator (parser,
6388 : 118375075 : specs->typespec_kind != ctsk_none,
6389 : : C_DTR_ABSTRACT, &dummy);
6390 : 118375075 : if (declarator == NULL)
6391 : : return NULL;
6392 : 118375072 : ret = XOBNEW (&parser_obstack, struct c_type_name);
6393 : 118375072 : ret->specs = specs;
6394 : 118375072 : ret->declarator = declarator;
6395 : 118375072 : return ret;
6396 : : }
6397 : :
6398 : : /* Parse an initializer (C90 6.5.7, C99 6.7.8, C11 6.7.9).
6399 : :
6400 : : initializer:
6401 : : assignment-expression
6402 : : { initializer-list }
6403 : : { initializer-list , }
6404 : :
6405 : : initializer-list:
6406 : : designation[opt] initializer
6407 : : initializer-list , designation[opt] initializer
6408 : :
6409 : : designation:
6410 : : designator-list =
6411 : :
6412 : : designator-list:
6413 : : designator
6414 : : designator-list designator
6415 : :
6416 : : designator:
6417 : : array-designator
6418 : : . identifier
6419 : :
6420 : : array-designator:
6421 : : [ constant-expression ]
6422 : :
6423 : : GNU extensions:
6424 : :
6425 : : initializer:
6426 : : { }
6427 : :
6428 : : designation:
6429 : : array-designator
6430 : : identifier :
6431 : :
6432 : : array-designator:
6433 : : [ constant-expression ... constant-expression ]
6434 : :
6435 : : Any expression without commas is accepted in the syntax for the
6436 : : constant-expressions, with non-constant expressions rejected later.
6437 : :
6438 : : DECL is the declaration we're parsing this initializer for.
6439 : :
6440 : : This function is only used for top-level initializers; for nested
6441 : : ones, see c_parser_initval. */
6442 : :
6443 : : static struct c_expr
6444 : 6194931 : c_parser_initializer (c_parser *parser, tree decl)
6445 : : {
6446 : 6194931 : if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
6447 : 104109 : return c_parser_braced_init (parser, NULL_TREE, false, NULL, decl);
6448 : : else
6449 : : {
6450 : 6090822 : struct c_expr ret;
6451 : 6090822 : location_t loc = c_parser_peek_token (parser)->location;
6452 : 6090822 : ret = c_parser_expr_no_commas (parser, NULL);
6453 : 6090820 : if (decl != error_mark_node && C_DECL_VARIABLE_SIZE (decl))
6454 : : {
6455 : 2 : error_at (loc,
6456 : : "variable-sized object may not be initialized except "
6457 : : "with an empty initializer");
6458 : 2 : ret.set_error ();
6459 : : }
6460 : : /* This is handled mostly by gimplify.cc, but we have to deal with
6461 : : not warning about int x = x; as it is a GCC extension to turn off
6462 : : this warning but only if warn_init_self is zero. */
6463 : 6090820 : if (VAR_P (decl)
6464 : 6090772 : && !DECL_EXTERNAL (decl)
6465 : 6090772 : && !TREE_STATIC (decl)
6466 : 5971655 : && ret.value == decl
6467 : 6178040 : && !warning_enabled_at (DECL_SOURCE_LOCATION (decl), OPT_Winit_self))
6468 : 87213 : suppress_warning (decl, OPT_Winit_self);
6469 : 6090820 : if (TREE_CODE (ret.value) != STRING_CST
6470 : 6090820 : && (TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR
6471 : 93258 : || C_DECL_DECLARED_CONSTEXPR (COMPOUND_LITERAL_EXPR_DECL
6472 : : (ret.value))))
6473 : 5983665 : ret = convert_lvalue_to_rvalue (loc, ret, true, true, true);
6474 : 6090820 : return ret;
6475 : : }
6476 : : }
6477 : :
6478 : : /* The location of the last comma within the current initializer list,
6479 : : or UNKNOWN_LOCATION if not within one. */
6480 : :
6481 : : location_t last_init_list_comma;
6482 : :
6483 : : /* Parse a braced initializer list. TYPE is the type specified for a
6484 : : compound literal, and NULL_TREE for other initializers and for
6485 : : nested braced lists. NESTED_P is true for nested braced lists,
6486 : : false for the list of a compound literal or the list that is the
6487 : : top-level initializer in a declaration. DECL is the declaration for
6488 : : the top-level initializer for a declaration, otherwise NULL_TREE. */
6489 : :
6490 : : static struct c_expr
6491 : 1341586 : c_parser_braced_init (c_parser *parser, tree type, bool nested_p,
6492 : : struct obstack *outer_obstack, tree decl)
6493 : : {
6494 : 1341586 : struct c_expr ret;
6495 : 1341586 : struct obstack braced_init_obstack;
6496 : 1341586 : location_t brace_loc = c_parser_peek_token (parser)->location;
6497 : 1341586 : gcc_obstack_init (&braced_init_obstack);
6498 : 1341586 : gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
6499 : 1341586 : bool save_c_omp_array_section_p = c_omp_array_section_p;
6500 : 1341586 : c_omp_array_section_p = false;
6501 : 1341586 : bool zero_init_padding_bits = false;
6502 : 1341586 : matching_braces braces;
6503 : 1341586 : braces.consume_open (parser);
6504 : 1341586 : if (nested_p)
6505 : : {
6506 : 339379 : finish_implicit_inits (brace_loc, outer_obstack);
6507 : 339379 : push_init_level (brace_loc, 0, &braced_init_obstack);
6508 : : }
6509 : : else
6510 : 1002207 : really_start_incremental_init (type);
6511 : 1341586 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
6512 : : {
6513 : 2483 : pedwarn_c11 (brace_loc, OPT_Wpedantic,
6514 : : "ISO C forbids empty initializer braces before C23");
6515 : 2483 : if (flag_isoc23)
6516 : 1341586 : zero_init_padding_bits = true;
6517 : : }
6518 : : else
6519 : : {
6520 : 1339103 : if (decl && decl != error_mark_node && C_DECL_VARIABLE_SIZE (decl))
6521 : 52 : error_at (brace_loc,
6522 : : "variable-sized object may not be initialized except "
6523 : : "with an empty initializer");
6524 : : /* Parse a non-empty initializer list, possibly with a trailing
6525 : : comma. */
6526 : 8748603 : while (true)
6527 : : {
6528 : 8748603 : c_parser_initelt (parser, &braced_init_obstack);
6529 : 8748603 : if (parser->error)
6530 : : break;
6531 : 8748573 : if (c_parser_next_token_is (parser, CPP_COMMA))
6532 : : {
6533 : 7412159 : last_init_list_comma = c_parser_peek_token (parser)->location;
6534 : 7412159 : c_parser_consume_token (parser);
6535 : : /* CPP_EMBED should be always in between two CPP_COMMA
6536 : : tokens. */
6537 : 14824421 : while (c_parser_next_token_is (parser, CPP_EMBED))
6538 : : {
6539 : 103 : c_token *embed = c_parser_peek_token (parser);
6540 : 103 : c_parser_consume_token (parser);
6541 : 103 : c_expr embed_val;
6542 : 103 : embed_val.value = embed->value;
6543 : 103 : embed_val.original_code = RAW_DATA_CST;
6544 : 103 : embed_val.original_type = integer_type_node;
6545 : 103 : set_c_expr_source_range (&embed_val, embed->get_range ());
6546 : 103 : embed_val.m_decimal = 0;
6547 : 103 : process_init_element (embed->location, embed_val, false,
6548 : : &braced_init_obstack);
6549 : 103 : gcc_checking_assert (c_parser_next_token_is (parser,
6550 : : CPP_COMMA));
6551 : 103 : last_init_list_comma = c_parser_peek_token (parser)->location;
6552 : 103 : c_parser_consume_token (parser);
6553 : : }
6554 : : }
6555 : : else
6556 : : break;
6557 : 7412159 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
6558 : : break;
6559 : : }
6560 : : }
6561 : 1341586 : c_omp_array_section_p = save_c_omp_array_section_p;
6562 : 1341586 : c_token *next_tok = c_parser_peek_token (parser);
6563 : 1341586 : if (next_tok->type != CPP_CLOSE_BRACE)
6564 : : {
6565 : 31 : ret.set_error ();
6566 : 31 : ret.original_code = ERROR_MARK;
6567 : 31 : ret.original_type = NULL;
6568 : 31 : braces.skip_until_found_close (parser);
6569 : 31 : pop_init_level (brace_loc, 0, &braced_init_obstack, last_init_list_comma);
6570 : 31 : obstack_free (&braced_init_obstack, NULL);
6571 : : return ret;
6572 : : }
6573 : 1341555 : location_t close_loc = next_tok->location;
6574 : 1341555 : c_parser_consume_token (parser);
6575 : 1341555 : ret = pop_init_level (brace_loc, 0, &braced_init_obstack, close_loc);
6576 : 1341555 : if (zero_init_padding_bits
6577 : 2226 : && ret.value
6578 : 2159 : && TREE_CODE (ret.value) == CONSTRUCTOR)
6579 : 2066 : CONSTRUCTOR_ZERO_PADDING_BITS (ret.value) = 1;
6580 : 1341555 : obstack_free (&braced_init_obstack, NULL);
6581 : 1341555 : set_c_expr_source_range (&ret, brace_loc, close_loc);
6582 : 1341555 : return ret;
6583 : : }
6584 : :
6585 : : /* Parse a nested initializer, including designators. */
6586 : :
6587 : : static void
6588 : 8748603 : c_parser_initelt (c_parser *parser, struct obstack * braced_init_obstack)
6589 : : {
6590 : : /* Parse any designator or designator list. A single array
6591 : : designator may have the subsequent "=" omitted in GNU C, but a
6592 : : longer list or a structure member designator may not. */
6593 : 8748603 : if (c_parser_next_token_is (parser, CPP_NAME)
6594 : 8748603 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
6595 : : {
6596 : : /* Old-style structure member designator. */
6597 : 156 : set_init_label (c_parser_peek_token (parser)->location,
6598 : 156 : c_parser_peek_token (parser)->value,
6599 : 156 : c_parser_peek_token (parser)->location,
6600 : : braced_init_obstack);
6601 : : /* Use the colon as the error location. */
6602 : 156 : pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_Wpedantic,
6603 : : "obsolete use of designated initializer with %<:%>");
6604 : 156 : c_parser_consume_token (parser);
6605 : 156 : c_parser_consume_token (parser);
6606 : : }
6607 : : else
6608 : : {
6609 : : /* des_seen is 0 if there have been no designators, 1 if there
6610 : : has been a single array designator and 2 otherwise. */
6611 : : int des_seen = 0;
6612 : : /* Location of a designator. */
6613 : : location_t des_loc = UNKNOWN_LOCATION; /* Quiet warning. */
6614 : 8781346 : while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
6615 : 17561549 : || c_parser_next_token_is (parser, CPP_DOT))
6616 : : {
6617 : 32899 : int des_prev = des_seen;
6618 : 32899 : if (!des_seen)
6619 : 32321 : des_loc = c_parser_peek_token (parser)->location;
6620 : 32899 : if (des_seen < 2)
6621 : 32399 : des_seen++;
6622 : 32899 : if (c_parser_next_token_is (parser, CPP_DOT))
6623 : : {
6624 : 31756 : des_seen = 2;
6625 : 31756 : c_parser_consume_token (parser);
6626 : 31756 : if (c_parser_next_token_is (parser, CPP_NAME))
6627 : : {
6628 : 31756 : set_init_label (des_loc, c_parser_peek_token (parser)->value,
6629 : 31756 : c_parser_peek_token (parser)->location,
6630 : : braced_init_obstack);
6631 : 31756 : c_parser_consume_token (parser);
6632 : : }
6633 : : else
6634 : : {
6635 : 0 : struct c_expr init;
6636 : 0 : init.set_error ();
6637 : 0 : init.original_code = ERROR_MARK;
6638 : 0 : init.original_type = NULL;
6639 : 0 : c_parser_error (parser, "expected identifier");
6640 : 0 : c_parser_skip_until_found (parser, CPP_COMMA, NULL);
6641 : 0 : process_init_element (input_location, init, false,
6642 : : braced_init_obstack);
6643 : 0 : return;
6644 : : }
6645 : : }
6646 : : else
6647 : : {
6648 : 1143 : struct c_expr first_expr;
6649 : 1143 : tree first, second;
6650 : 1143 : location_t ellipsis_loc = UNKNOWN_LOCATION; /* Quiet warning. */
6651 : 1143 : location_t array_index_loc = UNKNOWN_LOCATION;
6652 : : /* ??? Following the old parser, [ objc-receiver
6653 : : objc-message-args ] is accepted as an initializer,
6654 : : being distinguished from a designator by what follows
6655 : : the first assignment expression inside the square
6656 : : brackets, but after a first array designator a
6657 : : subsequent square bracket is for Objective-C taken to
6658 : : start an expression, using the obsolete form of
6659 : : designated initializer without '=', rather than
6660 : : possibly being a second level of designation: in LALR
6661 : : terms, the '[' is shifted rather than reducing
6662 : : designator to designator-list. */
6663 : 1143 : if (des_prev == 1 && c_dialect_objc ())
6664 : : {
6665 : 0 : des_seen = des_prev;
6666 : 0 : break;
6667 : : }
6668 : 1143 : if (des_prev == 0 && c_dialect_objc ())
6669 : : {
6670 : : /* This might be an array designator or an
6671 : : Objective-C message expression. If the former,
6672 : : continue parsing here; if the latter, parse the
6673 : : remainder of the initializer given the starting
6674 : : primary-expression. ??? It might make sense to
6675 : : distinguish when des_prev == 1 as well; see
6676 : : previous comment. */
6677 : 0 : tree rec, args;
6678 : 0 : struct c_expr mexpr;
6679 : 0 : c_parser_consume_token (parser);
6680 : 0 : if (c_parser_peek_token (parser)->type == CPP_NAME
6681 : 0 : && ((c_parser_peek_token (parser)->id_kind
6682 : : == C_ID_TYPENAME)
6683 : 0 : || (c_parser_peek_token (parser)->id_kind
6684 : : == C_ID_CLASSNAME)))
6685 : : {
6686 : : /* Type name receiver. */
6687 : 0 : tree id = c_parser_peek_token (parser)->value;
6688 : 0 : c_parser_consume_token (parser);
6689 : 0 : rec = objc_get_class_reference (id);
6690 : 0 : goto parse_message_args;
6691 : : }
6692 : 0 : array_index_loc = c_parser_peek_token (parser)->location;
6693 : 0 : first_expr = c_parser_expr_no_commas (parser, NULL);
6694 : 0 : mark_exp_read (first_expr.value);
6695 : 0 : if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
6696 : 0 : || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
6697 : 0 : goto array_desig_after_first;
6698 : 0 : first = first_expr.value;
6699 : : /* Expression receiver. So far only one part
6700 : : without commas has been parsed; there might be
6701 : : more of the expression. */
6702 : : rec = first;
6703 : 0 : while (c_parser_next_token_is (parser, CPP_COMMA))
6704 : : {
6705 : 0 : struct c_expr next;
6706 : 0 : location_t comma_loc, exp_loc;
6707 : 0 : comma_loc = c_parser_peek_token (parser)->location;
6708 : 0 : c_parser_consume_token (parser);
6709 : 0 : exp_loc = c_parser_peek_token (parser)->location;
6710 : 0 : next = c_parser_expr_no_commas (parser, NULL);
6711 : 0 : next = convert_lvalue_to_rvalue (exp_loc, next,
6712 : : true, true);
6713 : 0 : rec = build_compound_expr (comma_loc, rec, next.value);
6714 : : }
6715 : 0 : parse_message_args:
6716 : : /* Now parse the objc-message-args. */
6717 : 0 : args = c_parser_objc_message_args (parser);
6718 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
6719 : : "expected %<]%>");
6720 : 0 : mexpr.value
6721 : 0 : = objc_build_message_expr (rec, args);
6722 : 0 : mexpr.original_code = ERROR_MARK;
6723 : 0 : mexpr.original_type = NULL;
6724 : 0 : mexpr.m_decimal = 0;
6725 : : /* Now parse and process the remainder of the
6726 : : initializer, starting with this message
6727 : : expression as a primary-expression. */
6728 : 0 : c_parser_initval (parser, &mexpr, braced_init_obstack);
6729 : 0 : return;
6730 : : }
6731 : 1143 : c_parser_consume_token (parser);
6732 : 1143 : array_index_loc = c_parser_peek_token (parser)->location;
6733 : 1143 : first_expr = c_parser_expr_no_commas (parser, NULL);
6734 : 1143 : mark_exp_read (first_expr.value);
6735 : 1143 : array_desig_after_first:
6736 : 1143 : first_expr = convert_lvalue_to_rvalue (array_index_loc,
6737 : : first_expr,
6738 : : true, true);
6739 : 1143 : first = first_expr.value;
6740 : 1143 : if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
6741 : : {
6742 : 391 : ellipsis_loc = c_parser_peek_token (parser)->location;
6743 : 391 : c_parser_consume_token (parser);
6744 : 391 : second = convert_lvalue_to_rvalue (ellipsis_loc,
6745 : : (c_parser_expr_no_commas
6746 : : (parser, NULL)),
6747 : : true, true).value;
6748 : 391 : mark_exp_read (second);
6749 : : }
6750 : : else
6751 : : second = NULL_TREE;
6752 : 1143 : if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
6753 : : {
6754 : 1143 : c_parser_consume_token (parser);
6755 : 1143 : set_init_index (array_index_loc, first, second,
6756 : : braced_init_obstack);
6757 : 1143 : if (second)
6758 : 391 : pedwarn (ellipsis_loc, OPT_Wpedantic,
6759 : : "ISO C forbids specifying range of elements to initialize");
6760 : : }
6761 : : else
6762 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
6763 : : "expected %<]%>");
6764 : : }
6765 : : }
6766 : 8748447 : if (des_seen >= 1)
6767 : : {
6768 : 32321 : if (c_parser_next_token_is (parser, CPP_EQ))
6769 : : {
6770 : 32300 : pedwarn_c90 (des_loc, OPT_Wpedantic,
6771 : : "ISO C90 forbids specifying subobject "
6772 : : "to initialize");
6773 : 32300 : c_parser_consume_token (parser);
6774 : : }
6775 : : else
6776 : : {
6777 : 21 : if (des_seen == 1)
6778 : 19 : pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
6779 : : "obsolete use of designated initializer without %<=%>");
6780 : : else
6781 : : {
6782 : 2 : struct c_expr init;
6783 : 2 : init.set_error ();
6784 : 2 : init.original_code = ERROR_MARK;
6785 : 2 : init.original_type = NULL;
6786 : 2 : c_parser_error (parser, "expected %<=%>");
6787 : 2 : c_parser_skip_until_found (parser, CPP_COMMA, NULL);
6788 : 2 : process_init_element (input_location, init, false,
6789 : : braced_init_obstack);
6790 : 2 : return;
6791 : : }
6792 : : }
6793 : : }
6794 : : }
6795 : 8748601 : c_parser_initval (parser, NULL, braced_init_obstack);
6796 : : }
6797 : :
6798 : : /* Parse a nested initializer; as c_parser_initializer but parses
6799 : : initializers within braced lists, after any designators have been
6800 : : applied. If AFTER is not NULL then it is an Objective-C message
6801 : : expression which is the primary-expression starting the
6802 : : initializer. */
6803 : :
6804 : : static void
6805 : 8748601 : c_parser_initval (c_parser *parser, struct c_expr *after,
6806 : : struct obstack * braced_init_obstack)
6807 : : {
6808 : 8748601 : struct c_expr init;
6809 : 8748601 : gcc_assert (!after || c_dialect_objc ());
6810 : 8748601 : location_t loc = c_parser_peek_token (parser)->location;
6811 : :
6812 : 8748601 : if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
6813 : 339379 : init = c_parser_braced_init (parser, NULL_TREE, true,
6814 : : braced_init_obstack, NULL_TREE);
6815 : : else
6816 : : {
6817 : 8409222 : init = c_parser_expr_no_commas (parser, after);
6818 : 8409222 : if (init.value != NULL_TREE
6819 : 8409222 : && TREE_CODE (init.value) != STRING_CST
6820 : 16776976 : && (TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR
6821 : 173 : || C_DECL_DECLARED_CONSTEXPR (COMPOUND_LITERAL_EXPR_DECL
6822 : : (init.value))))
6823 : 8367586 : init = convert_lvalue_to_rvalue (loc, init, true, true, true);
6824 : : }
6825 : 8748601 : tree val = init.value;
6826 : 8748601 : process_init_element (loc, init, false, braced_init_obstack);
6827 : :
6828 : : /* Attempt to optimize large char array initializers into RAW_DATA_CST
6829 : : to save compile time and memory even when not using #embed. */
6830 : 8748601 : static unsigned vals_to_ignore;
6831 : 8748601 : if (vals_to_ignore)
6832 : : /* If earlier call determined there is certain number of CPP_COMMA
6833 : : CPP_NUMBER tokens with 0-255 int values, but not enough for
6834 : : RAW_DATA_CST to be beneficial, don't try to check it again until
6835 : : they are all parsed. */
6836 : 6022 : --vals_to_ignore;
6837 : 8742579 : else if (val
6838 : 8742453 : && TREE_CODE (val) == INTEGER_CST
6839 : 4128179 : && TREE_TYPE (val) == integer_type_node
6840 : 12322248 : && c_parser_next_token_is (parser, CPP_COMMA))
6841 : 2933564 : if (unsigned int len = c_maybe_optimize_large_byte_initializer ())
6842 : : {
6843 : 8530 : char buf1[64];
6844 : 8530 : unsigned int i;
6845 : 8530 : gcc_checking_assert (len >= 64);
6846 : : location_t last_loc = UNKNOWN_LOCATION;
6847 : 20440 : for (i = 0; i < 64; ++i)
6848 : : {
6849 : 20342 : c_token *tok = c_parser_peek_nth_token_raw (parser, 1 + 2 * i);
6850 : 20342 : if (tok->type != CPP_COMMA)
6851 : : break;
6852 : 19545 : tok = c_parser_peek_nth_token_raw (parser, 2 + 2 * i);
6853 : 19545 : if (tok->type != CPP_NUMBER
6854 : 11910 : || TREE_CODE (tok->value) != INTEGER_CST
6855 : 11910 : || TREE_TYPE (tok->value) != integer_type_node
6856 : 11910 : || wi::neg_p (wi::to_wide (tok->value))
6857 : 31455 : || wi::to_widest (tok->value) > UCHAR_MAX)
6858 : : break;
6859 : 11910 : buf1[i] = (char) tree_to_uhwi (tok->value);
6860 : 11910 : if (i == 0)
6861 : 1113 : loc = tok->location;
6862 : 11910 : last_loc = tok->location;
6863 : : }
6864 : 8530 : if (i < 64)
6865 : : {
6866 : 8432 : vals_to_ignore = i;
6867 : 8438 : return;
6868 : : }
6869 : 98 : c_token *tok = c_parser_peek_nth_token_raw (parser, 1 + 2 * i);
6870 : : /* If 64 CPP_COMMA CPP_NUMBER pairs are followed by CPP_CLOSE_BRACE,
6871 : : punt if len is INT_MAX as that can mean this is a flexible array
6872 : : member and in that case we need one CPP_NUMBER afterwards
6873 : : (as guaranteed for CPP_EMBED). */
6874 : 98 : if (tok->type == CPP_CLOSE_BRACE && len != INT_MAX)
6875 : : len = i;
6876 : 96 : else if (tok->type != CPP_COMMA
6877 : 96 : || (c_parser_peek_nth_token_raw (parser, 2 + 2 * i)->type
6878 : : != CPP_NUMBER))
6879 : : {
6880 : 6 : vals_to_ignore = i;
6881 : 6 : return;
6882 : : }
6883 : : /* Ensure the STRING_CST fits into 128K. */
6884 : 92 : unsigned int max_len = 131072 - offsetof (struct tree_string, str) - 1;
6885 : 92 : unsigned int orig_len = len;
6886 : 92 : unsigned int off = 0, last = 0;
6887 : 92 : if (!wi::neg_p (wi::to_wide (val)) && wi::to_widest (val) <= UCHAR_MAX)
6888 : 84 : off = 1;
6889 : 92 : len = MIN (len, max_len - off);
6890 : 92 : char *buf2 = XNEWVEC (char, len + off);
6891 : 92 : if (off)
6892 : 84 : buf2[0] = (char) tree_to_uhwi (val);
6893 : 92 : memcpy (buf2 + off, buf1, i);
6894 : 5980 : for (unsigned int j = 0; j < i; ++j)
6895 : : {
6896 : 5888 : c_parser_peek_token (parser);
6897 : 5888 : c_parser_consume_token (parser);
6898 : 5888 : c_parser_peek_token (parser);
6899 : 5888 : c_parser_consume_token (parser);
6900 : : }
6901 : 19740 : for (; i < len; ++i)
6902 : : {
6903 : 19698 : if (!c_parser_next_token_is (parser, CPP_COMMA))
6904 : : break;
6905 : 19696 : tok = c_parser_peek_2nd_token (parser);
6906 : 19696 : if (tok->type != CPP_NUMBER
6907 : 19688 : || TREE_CODE (tok->value) != INTEGER_CST
6908 : 19688 : || TREE_TYPE (tok->value) != integer_type_node
6909 : 19688 : || wi::neg_p (wi::to_wide (tok->value))
6910 : 39384 : || wi::to_widest (tok->value) > UCHAR_MAX)
6911 : : break;
6912 : 19688 : c_token *tok2 = c_parser_peek_nth_token (parser, 3);
6913 : 19688 : if (tok2->type != CPP_COMMA && tok2->type != CPP_CLOSE_BRACE)
6914 : : break;
6915 : 19685 : buf2[i + off] = (char) tree_to_uhwi (tok->value);
6916 : : /* If orig_len is INT_MAX, this can be flexible array member and
6917 : : in that case we need to ensure another element which
6918 : : for CPP_EMBED is normally guaranteed after it. Include
6919 : : that byte in the RAW_DATA_OWNER though, so it can be optimized
6920 : : later. */
6921 : 19685 : if (orig_len == INT_MAX
6922 : 19685 : && (tok2->type == CPP_CLOSE_BRACE
6923 : 12517 : || (c_parser_peek_nth_token (parser, 4)->type
6924 : : != CPP_NUMBER)))
6925 : : {
6926 : : last = 1;
6927 : : break;
6928 : : }
6929 : 19648 : last_loc = tok->location;
6930 : 19648 : c_parser_consume_token (parser);
6931 : 19648 : c_parser_consume_token (parser);
6932 : : }
6933 : 92 : val = make_node (RAW_DATA_CST);
6934 : 92 : TREE_TYPE (val) = integer_type_node;
6935 : 92 : RAW_DATA_LENGTH (val) = i;
6936 : 92 : tree owner = build_string (i + off + last, buf2);
6937 : 92 : XDELETEVEC (buf2);
6938 : 92 : TREE_TYPE (owner) = build_array_type_nelts (unsigned_char_type_node,
6939 : 92 : i + off + last);
6940 : 92 : RAW_DATA_OWNER (val) = owner;
6941 : 92 : RAW_DATA_POINTER (val) = TREE_STRING_POINTER (owner) + off;
6942 : 92 : init.value = val;
6943 : 92 : set_c_expr_source_range (&init, loc, last_loc);
6944 : 92 : init.original_code = RAW_DATA_CST;
6945 : 92 : init.original_type = integer_type_node;
6946 : 92 : init.m_decimal = 0;
6947 : 92 : process_init_element (loc, init, false, braced_init_obstack);
6948 : : }
6949 : : }
6950 : :
6951 : : /* Parse a compound statement (possibly a function body) (C90 6.6.2,
6952 : : C99 6.8.2, C11 6.8.2, C23 6.8.2).
6953 : :
6954 : : compound-statement:
6955 : : { block-item-list[opt] }
6956 : : { label-declarations block-item-list }
6957 : :
6958 : : block-item-list:
6959 : : block-item
6960 : : block-item-list block-item
6961 : :
6962 : : block-item:
6963 : : label
6964 : : nested-declaration
6965 : : statement
6966 : :
6967 : : nested-declaration:
6968 : : declaration
6969 : :
6970 : : GNU extensions:
6971 : :
6972 : : compound-statement:
6973 : : { label-declarations block-item-list }
6974 : :
6975 : : nested-declaration:
6976 : : __extension__ nested-declaration
6977 : : nested-function-definition
6978 : :
6979 : : label-declarations:
6980 : : label-declaration
6981 : : label-declarations label-declaration
6982 : :
6983 : : label-declaration:
6984 : : __label__ identifier-list ;
6985 : :
6986 : : Allowing the mixing of declarations and code is new in C99. The
6987 : : GNU syntax also permits (not shown above) labels at the end of
6988 : : compound statements, which yield an error. We don't allow labels
6989 : : on declarations; this might seem like a natural extension, but
6990 : : there would be a conflict between gnu-attributes on the label and
6991 : : prefix gnu-attributes on the declaration. ??? The syntax follows the
6992 : : old parser in requiring something after label declarations.
6993 : : Although they are erroneous if the labels declared aren't defined,
6994 : : is it useful for the syntax to be this way?
6995 : :
6996 : : OpenACC:
6997 : :
6998 : : block-item:
6999 : : openacc-directive
7000 : :
7001 : : openacc-directive:
7002 : : update-directive
7003 : :
7004 : : OpenMP:
7005 : :
7006 : : block-item:
7007 : : openmp-directive
7008 : :
7009 : : openmp-directive:
7010 : : barrier-directive
7011 : : flush-directive
7012 : : taskwait-directive
7013 : : taskyield-directive
7014 : : cancel-directive
7015 : : cancellation-point-directive */
7016 : :
7017 : : static tree
7018 : 36266687 : c_parser_compound_statement (c_parser *parser, location_t *endlocp)
7019 : : {
7020 : 36266687 : tree stmt;
7021 : 36266687 : location_t brace_loc;
7022 : 36266687 : brace_loc = c_parser_peek_token (parser)->location;
7023 : 36266687 : if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
7024 : : {
7025 : : /* Ensure a scope is entered and left anyway to avoid confusion
7026 : : if we have just prepared to enter a function body. */
7027 : 16 : stmt = c_begin_compound_stmt (true);
7028 : 16 : c_end_compound_stmt (brace_loc, stmt, true);
7029 : 16 : return error_mark_node;
7030 : : }
7031 : 36266671 : stmt = c_begin_compound_stmt (true);
7032 : 36266671 : location_t end_loc = c_parser_compound_statement_nostart (parser);
7033 : 36266670 : if (endlocp)
7034 : 35379868 : *endlocp = end_loc;
7035 : :
7036 : 36266670 : return c_end_compound_stmt (brace_loc, stmt, true);
7037 : : }
7038 : :
7039 : : /* Diagnose errors related to imperfectly nested loops in an OMP
7040 : : loop construct. This function is called when such code is seen.
7041 : : Only issue one such diagnostic no matter how much invalid
7042 : : intervening code there is in the loop.
7043 : : FIXME: maybe the location associated with the diagnostic should
7044 : : be the current parser token instead of the location of the outer loop
7045 : : nest. */
7046 : :
7047 : : static void
7048 : 294 : check_omp_intervening_code (c_parser *parser)
7049 : : {
7050 : 294 : struct omp_for_parse_data *omp_for_parse_state = parser->omp_for_parse_state;
7051 : 294 : gcc_assert (omp_for_parse_state);
7052 : :
7053 : 294 : if (!omp_for_parse_state->in_intervening_code)
7054 : : return;
7055 : 273 : omp_for_parse_state->saw_intervening_code = true;
7056 : :
7057 : : /* Only diagnose errors related to perfect nesting once. */
7058 : 273 : if (!omp_for_parse_state->perfect_nesting_fail)
7059 : : {
7060 : :
7061 : : /* OpenACC does not (yet) permit intervening code, in
7062 : : addition to situations forbidden by the OpenMP spec. */
7063 : 251 : if (omp_for_parse_state->code == OACC_LOOP)
7064 : : {
7065 : 3 : error_at (omp_for_parse_state->for_loc,
7066 : : "inner loops must be perfectly nested in "
7067 : : "%<#pragma acc loop%>");
7068 : 3 : omp_for_parse_state->perfect_nesting_fail = true;
7069 : : }
7070 : 248 : else if (omp_for_parse_state->ordered)
7071 : : {
7072 : 11 : error_at (omp_for_parse_state->for_loc,
7073 : : "inner loops must be perfectly nested with "
7074 : : "%<ordered%> clause");
7075 : 11 : omp_for_parse_state->perfect_nesting_fail = true;
7076 : : }
7077 : 237 : else if (omp_for_parse_state->inscan)
7078 : : {
7079 : 2 : error_at (omp_for_parse_state->for_loc,
7080 : : "inner loops must be perfectly nested with "
7081 : : "%<reduction%> %<inscan%> clause");
7082 : 2 : omp_for_parse_state->perfect_nesting_fail = true;
7083 : : }
7084 : 235 : else if (omp_for_parse_state->code == OMP_TILE)
7085 : : {
7086 : 9 : error_at (omp_for_parse_state->for_loc,
7087 : : "inner loops must be perfectly nested in "
7088 : : "%<pragma omp tile%>");
7089 : 9 : omp_for_parse_state->perfect_nesting_fail = true;
7090 : : }
7091 : 251 : if (omp_for_parse_state->perfect_nesting_fail)
7092 : 25 : omp_for_parse_state->fail = true;
7093 : : }
7094 : : }
7095 : :
7096 : : /* Helper function for below: wrap an OMP_STRUCTURED_BLOCK around SL
7097 : : and add the statement to the current list. If SL is an empty statement
7098 : : list, do nothing. */
7099 : : static void
7100 : 282 : add_structured_block_stmt (tree sl)
7101 : : {
7102 : 282 : if (TREE_CODE (sl) != STATEMENT_LIST
7103 : 282 : || !tsi_end_p (tsi_start (sl)))
7104 : 149 : add_stmt (build1 (OMP_STRUCTURED_BLOCK, void_type_node, sl));
7105 : 282 : }
7106 : :
7107 : : struct c_omp_attribute_data
7108 : : {
7109 : : vec<c_token, va_gc> *tokens;
7110 : : const c_omp_directive *dir;
7111 : : c_omp_directive_kind kind;
7112 : : };
7113 : :
7114 : : /* Handle omp::directive and omp::sequence attributes in ATTRS
7115 : : (if any) at the start of a statement or in attribute-declaration. */
7116 : :
7117 : : static bool
7118 : 870 : c_parser_handle_statement_omp_attributes (c_parser *parser, tree &attrs,
7119 : : bool *have_std_attrs)
7120 : : {
7121 : 870 : if (!flag_openmp && !flag_openmp_simd)
7122 : : return false;
7123 : :
7124 : 604 : auto_vec<c_omp_attribute_data, 16> vd;
7125 : 604 : int cnt = 0;
7126 : 604 : int tokens = 0;
7127 : 604 : bool bad = false;
7128 : 1208 : for (tree *pa = &attrs; *pa; )
7129 : 604 : if (is_attribute_namespace_p ("omp", *pa)
7130 : 604 : && is_attribute_p ("directive", get_attribute_name (*pa)))
7131 : : {
7132 : 603 : cnt++;
7133 : 1346 : for (tree a = TREE_VALUE (*pa); a; a = TREE_CHAIN (a))
7134 : : {
7135 : 743 : tree d = TREE_VALUE (a);
7136 : 743 : gcc_assert (TREE_CODE (d) == C_TOKEN_VEC);
7137 : 743 : vec<c_token, va_gc> *toks = C_TOKEN_VEC_TOKENS (d);
7138 : 743 : c_token *first = toks->address ();
7139 : 743 : c_token *last = first + toks->length ();
7140 : 743 : if (parser->omp_attrs_forbidden_p)
7141 : : {
7142 : 14 : error_at (first->location,
7143 : : "mixing OpenMP directives with attribute and pragma "
7144 : : "syntax on the same statement");
7145 : 14 : parser->omp_attrs_forbidden_p = false;
7146 : 14 : bad = true;
7147 : : }
7148 : 729 : else if (TREE_PUBLIC (d))
7149 : : {
7150 : 3 : error_at (first->location,
7151 : : "OpenMP %<omp::decl%> attribute on a statement");
7152 : 3 : bad = true;
7153 : : }
7154 : 743 : const char *directive[3] = {};
7155 : 2184 : for (int i = 0; i < 3; i++)
7156 : : {
7157 : 2008 : tree id = NULL_TREE;
7158 : 2008 : if (first + i == last)
7159 : : break;
7160 : 1763 : if (first[i].type == CPP_NAME)
7161 : 1323 : id = first[i].value;
7162 : 440 : else if (first[i].type == CPP_KEYWORD)
7163 : 118 : id = ridpointers[(int) first[i].keyword];
7164 : : else
7165 : : break;
7166 : 1441 : directive[i] = IDENTIFIER_POINTER (id);
7167 : : }
7168 : 743 : const c_omp_directive *dir = NULL;
7169 : 743 : if (directive[0])
7170 : 743 : dir = c_omp_categorize_directive (directive[0], directive[1],
7171 : : directive[2]);
7172 : 743 : if (dir == NULL)
7173 : : {
7174 : 1 : error_at (first->location,
7175 : : "unknown OpenMP directive name in %qs attribute "
7176 : : "argument",
7177 : 1 : TREE_PUBLIC (d) ? "omp::decl" : "omp::directive");
7178 : 1 : continue;
7179 : : }
7180 : 742 : c_omp_directive_kind kind = dir->kind;
7181 : 742 : if (dir->id == PRAGMA_OMP_ORDERED)
7182 : : {
7183 : : /* ordered is C_OMP_DIR_CONSTRUCT only if it doesn't contain
7184 : : depend/doacross clause. */
7185 : 8 : if (directive[1]
7186 : 4 : && (strcmp (directive[1], "depend") == 0
7187 : 2 : || strcmp (directive[1], "doacross") == 0))
7188 : : kind = C_OMP_DIR_STANDALONE;
7189 : 6 : else if (first + 2 < last
7190 : 4 : && first[1].type == CPP_COMMA
7191 : 4 : && first[2].type == CPP_NAME
7192 : 10 : && (strcmp (IDENTIFIER_POINTER (first[2].value),
7193 : : "depend") == 0
7194 : 2 : || strcmp (IDENTIFIER_POINTER (first[2].value),
7195 : : "doacross") == 0))
7196 : : kind = C_OMP_DIR_STANDALONE;
7197 : : }
7198 : 734 : else if (dir->id == PRAGMA_OMP_ERROR)
7199 : : {
7200 : : /* error with at(execution) clause is C_OMP_DIR_STANDALONE. */
7201 : : int paren_depth = 0;
7202 : 99 : for (int i = 1; first + i < last; i++)
7203 : 84 : if (first[i].type == CPP_OPEN_PAREN)
7204 : 18 : paren_depth++;
7205 : 66 : else if (first[i].type == CPP_CLOSE_PAREN)
7206 : 18 : paren_depth--;
7207 : 48 : else if (paren_depth == 0
7208 : 30 : && first + i + 2 < last
7209 : 30 : && first[i].type == CPP_NAME
7210 : 21 : && first[i + 1].type == CPP_OPEN_PAREN
7211 : 21 : && first[i + 2].type == CPP_NAME
7212 : 15 : && !strcmp (IDENTIFIER_POINTER (first[i].value),
7213 : : "at")
7214 : 57 : && !strcmp (IDENTIFIER_POINTER (first[i
7215 : : + 2].value),
7216 : : "execution"))
7217 : : {
7218 : : kind = C_OMP_DIR_STANDALONE;
7219 : : break;
7220 : : }
7221 : : }
7222 : 742 : c_omp_attribute_data v = { toks, dir, kind };
7223 : 742 : vd.safe_push (v);
7224 : 742 : if (flag_openmp || dir->simd)
7225 : 742 : tokens += (last - first) + 1;
7226 : : }
7227 : 603 : c_omp_attribute_data v = {};
7228 : 603 : vd.safe_push (v);
7229 : 603 : *pa = TREE_CHAIN (*pa);
7230 : : }
7231 : : else
7232 : 1 : pa = &TREE_CHAIN (*pa);
7233 : :
7234 : 604 : if (bad)
7235 : : {
7236 : 17 : fail:
7237 : 29 : if (have_std_attrs && attrs == NULL)
7238 : 26 : *have_std_attrs = false;
7239 : 29 : return false;
7240 : : }
7241 : :
7242 : : unsigned int i;
7243 : : c_omp_attribute_data *v;
7244 : : c_omp_attribute_data *construct_seen = nullptr;
7245 : : c_omp_attribute_data *standalone_seen = nullptr;
7246 : : c_omp_attribute_data *prev_standalone_seen = nullptr;
7247 : 1897 : FOR_EACH_VEC_ELT (vd, i, v)
7248 : 1310 : if (v->tokens)
7249 : : {
7250 : 724 : if (v->kind == C_OMP_DIR_CONSTRUCT && !construct_seen)
7251 : : construct_seen = v;
7252 : 353 : else if (v->kind == C_OMP_DIR_STANDALONE && !standalone_seen)
7253 : 71 : standalone_seen = v;
7254 : : }
7255 : : else
7256 : : {
7257 : 586 : if (standalone_seen && !prev_standalone_seen)
7258 : : {
7259 : 1310 : prev_standalone_seen = standalone_seen;
7260 : 1310 : standalone_seen = nullptr;
7261 : : }
7262 : : }
7263 : :
7264 : 587 : if (cnt > 1 && construct_seen)
7265 : : {
7266 : 4 : error_at ((*construct_seen->tokens)[0].location,
7267 : : "OpenMP construct among %<omp::directive%> attributes"
7268 : : " requires all %<omp::directive%> attributes on the"
7269 : : " same statement to be in the same %<omp::sequence%>");
7270 : 4 : goto fail;
7271 : : }
7272 : 583 : if (cnt > 1 && standalone_seen && prev_standalone_seen)
7273 : : {
7274 : 2 : error_at ((*standalone_seen->tokens)[0].location,
7275 : : "multiple OpenMP standalone directives among"
7276 : : " %<omp::directive%> attributes must be all within the"
7277 : : " same %<omp::sequence%>");
7278 : 2 : goto fail;
7279 : : }
7280 : :
7281 : 581 : if (prev_standalone_seen)
7282 : : standalone_seen = prev_standalone_seen;
7283 : 514 : if (standalone_seen
7284 : 581 : && !c_parser_next_token_is (parser, CPP_SEMICOLON))
7285 : : {
7286 : 2 : error_at (standalone_seen->tokens->address ()->location,
7287 : : "standalone OpenMP directives in %<omp::directive%> attribute"
7288 : : " can only appear on an empty statement");
7289 : 2 : goto fail;
7290 : : }
7291 : 1150 : if (cnt && c_parser_next_token_is (parser, CPP_PRAGMA))
7292 : : {
7293 : 4 : c_token *token = c_parser_peek_token (parser);
7294 : 4 : enum pragma_kind kind = token->pragma_kind;
7295 : 4 : if (kind >= PRAGMA_OMP__START_ && kind <= PRAGMA_OMP__LAST_)
7296 : : {
7297 : 4 : error_at (token->location,
7298 : : "mixing OpenMP directives with attribute and pragma "
7299 : : "syntax on the same statement");
7300 : 4 : goto fail;
7301 : : }
7302 : : }
7303 : :
7304 : 575 : if (!tokens)
7305 : : return false;
7306 : :
7307 : 559 : unsigned int tokens_avail = parser->tokens_avail;
7308 : :
7309 : 559 : tokens++;
7310 : 559 : vec<c_token, va_gc> *toks = NULL;
7311 : 559 : vec_safe_reserve (toks, tokens, true);
7312 : 1825 : FOR_EACH_VEC_ELT (vd, i, v)
7313 : : {
7314 : 1266 : if (!v->tokens)
7315 : 560 : continue;
7316 : 706 : if (!flag_openmp && !v->dir->simd)
7317 : 0 : continue;
7318 : 706 : c_token *first = v->tokens->address ();
7319 : 706 : c_token *last = first + v->tokens->length ();
7320 : 706 : c_token tok = {};
7321 : 706 : tok.type = CPP_PRAGMA;
7322 : 706 : tok.keyword = RID_MAX;
7323 : 706 : tok.pragma_kind = pragma_kind (v->dir->id);
7324 : 706 : tok.location = first->location;
7325 : 706 : toks->quick_push (tok);
7326 : 17418 : while (++first < last)
7327 : 16006 : toks->quick_push (*first);
7328 : 706 : tok = {};
7329 : 706 : tok.type = CPP_PRAGMA_EOL;
7330 : 706 : tok.keyword = RID_MAX;
7331 : 706 : tok.location = last[-1].location;
7332 : 706 : toks->quick_push (tok);
7333 : : }
7334 : :
7335 : 559 : c_token tok = {};
7336 : 559 : tok.type = CPP_EOF;
7337 : 559 : tok.keyword = RID_MAX;
7338 : 559 : tok.location = toks->last ().location;
7339 : 559 : toks->quick_push (tok);
7340 : :
7341 : 559 : gcc_assert (!parser->in_omp_attribute_pragma);
7342 : 559 : parser->in_omp_attribute_pragma = ggc_alloc<omp_attribute_pragma_state> ();
7343 : 559 : parser->in_omp_attribute_pragma->token_vec = toks;
7344 : 559 : parser->in_omp_attribute_pragma->save_tokens = parser->tokens;
7345 : 559 : parser->in_omp_attribute_pragma->save_tokens_avail = tokens_avail;
7346 : 559 : parser->tokens = toks->address ();
7347 : 559 : parser->tokens_avail = tokens;
7348 : 559 : return true;
7349 : 604 : }
7350 : :
7351 : : /* Handle omp::directive and omp::sequence attributes in ATTRS
7352 : : (if any) at the start or after declaration-id of a declaration. */
7353 : :
7354 : : static void
7355 : 62877189 : c_parser_handle_directive_omp_attributes (tree &attrs,
7356 : : vec<c_token> *&pragma_clauses,
7357 : : vec<c_token> *attr_clauses)
7358 : : {
7359 : 62877189 : if (!flag_openmp && !flag_openmp_simd)
7360 : : return;
7361 : :
7362 : 1581571 : for (tree *pa = &attrs; *pa; )
7363 : 642311 : if (is_attribute_namespace_p ("omp", *pa)
7364 : 642311 : && is_attribute_p ("directive", get_attribute_name (*pa)))
7365 : : {
7366 : 137 : int cnt = 0;
7367 : 273 : for (tree *pa2 = &TREE_VALUE (*pa); *pa2; )
7368 : : {
7369 : 138 : tree a = *pa2;
7370 : 138 : tree d = TREE_VALUE (a);
7371 : 138 : gcc_assert (TREE_CODE (d) == C_TOKEN_VEC);
7372 : 138 : vec<c_token, va_gc> *toks = C_TOKEN_VEC_TOKENS (d);
7373 : 138 : c_token *first = toks->address ();
7374 : 138 : c_token *last = first + toks->length ();
7375 : 138 : const char *directive[3] = {};
7376 : 416 : for (int i = 0; i < 3; i++)
7377 : : {
7378 : 382 : tree id = NULL_TREE;
7379 : 382 : if (first + i == last)
7380 : : break;
7381 : 328 : if (first[i].type == CPP_NAME)
7382 : 278 : id = first[i].value;
7383 : 50 : else if (first[i].type == CPP_KEYWORD)
7384 : 0 : id = ridpointers[(int) first[i].keyword];
7385 : : else
7386 : : break;
7387 : 278 : directive[i] = IDENTIFIER_POINTER (id);
7388 : : }
7389 : 138 : const c_omp_directive *dir = NULL;
7390 : 138 : if (directive[0])
7391 : 138 : dir = c_omp_categorize_directive (directive[0], directive[1],
7392 : : directive[2]);
7393 : 138 : if (dir == NULL)
7394 : : {
7395 : 9 : error_at (first->location,
7396 : : "unknown OpenMP directive name in "
7397 : : "%qs attribute argument",
7398 : 9 : TREE_PUBLIC (d) ? "omp::decl" : "omp::directive");
7399 : 9 : *pa2 = TREE_CHAIN (a);
7400 : : }
7401 : 129 : else if (dir->id == PRAGMA_OMP_DECLARE
7402 : 105 : && (strcmp (directive[1], "simd") == 0
7403 : 22 : || strcmp (directive[1], "variant") == 0))
7404 : : {
7405 : 92 : if (pragma_clauses)
7406 : : {
7407 : 2 : error_at (first->location,
7408 : : "mixing OpenMP directives with attribute and "
7409 : : "pragma syntax on the same declaration");
7410 : 6 : for (pa = &attrs; *pa; )
7411 : 2 : if (is_attribute_namespace_p ("omp", *pa)
7412 : 4 : && is_attribute_p ("directive",
7413 : 2 : get_attribute_name (*pa)))
7414 : 2 : *pa = TREE_CHAIN (*pa);
7415 : : else
7416 : 0 : pa = &TREE_CHAIN (*pa);
7417 : 2 : return;
7418 : : }
7419 : 90 : ++cnt;
7420 : 110 : attr_clauses->reserve (attr_clauses->length ()
7421 : 90 : + toks->length () + 2);
7422 : 834 : for (++first; first < last; ++first)
7423 : 744 : attr_clauses->quick_push (*first);
7424 : 90 : c_token tok = {};
7425 : 90 : tok.type = CPP_PRAGMA_EOL;
7426 : 90 : tok.keyword = RID_MAX;
7427 : 90 : tok.location = last[-1].location;
7428 : 90 : attr_clauses->quick_push (tok);
7429 : 90 : *pa2 = TREE_CHAIN (a);
7430 : 90 : }
7431 : : else
7432 : 37 : pa2 = &TREE_CHAIN (a);
7433 : : }
7434 : 135 : if (cnt && TREE_VALUE (*pa) == NULL_TREE)
7435 : 86 : *pa = TREE_CHAIN (*pa);
7436 : : else
7437 : 49 : pa = &TREE_CHAIN (*pa);
7438 : : }
7439 : : else
7440 : 642174 : pa = &TREE_CHAIN (*pa);
7441 : 939260 : if (attr_clauses->length ())
7442 : : {
7443 : 70 : c_token tok = {};
7444 : 70 : tok.type = CPP_EOF;
7445 : 70 : tok.keyword = RID_MAX;
7446 : 70 : tok.location = attr_clauses->last ().location;
7447 : 70 : attr_clauses->quick_push (tok);
7448 : 70 : attr_clauses->quick_push (tok);
7449 : 70 : pragma_clauses = attr_clauses;
7450 : : }
7451 : : }
7452 : :
7453 : : /* Check if STD_ATTR contains a musttail attribute and remove if it
7454 : : precedes a return. PARSER is the parser and ATTR is the output
7455 : : attr_state. */
7456 : :
7457 : : static tree
7458 : 971 : c_parser_handle_musttail (c_parser *parser, tree std_attrs, attr_state &attr)
7459 : : {
7460 : 971 : if (c_parser_next_token_is_keyword (parser, RID_RETURN))
7461 : : {
7462 : 224 : if (tree a = lookup_attribute ("gnu", "musttail", std_attrs))
7463 : : {
7464 : 416 : for (; a; a = lookup_attribute ("gnu", "musttail", TREE_CHAIN (a)))
7465 : 209 : if (TREE_VALUE (a))
7466 : 2 : error ("%qs attribute does not take any arguments",
7467 : : "musttail");
7468 : 207 : std_attrs = remove_attribute ("gnu", "musttail", std_attrs);
7469 : 207 : attr.musttail_p = true;
7470 : : }
7471 : 224 : if (lookup_attribute ("clang", "musttail", std_attrs))
7472 : : {
7473 : 10 : std_attrs = remove_attribute ("clang", "musttail", std_attrs);
7474 : 10 : attr.musttail_p = true;
7475 : : }
7476 : : }
7477 : 971 : return std_attrs;
7478 : : }
7479 : :
7480 : : /* Return a statement before optional series of LABEL_EXPR/CASE_LABEL_EXPRs.
7481 : : Instead of collecting vectors of labels before each stmt just in case
7482 : : the statement would be iteration or switch statement for named loops,
7483 : : we just remember last emitted statement and let the iteration/switch
7484 : : statement search backwards in cur_stmt_list until that stmt for loop
7485 : : names if any. */
7486 : :
7487 : : static tree
7488 : 86666503 : get_before_labels ()
7489 : : {
7490 : 86666503 : if (!building_stmt_list_p ())
7491 : 0 : return NULL_TREE;
7492 : 86666503 : tree_stmt_iterator tsi = tsi_last (cur_stmt_list);
7493 : 86666503 : if (tsi_end_p (tsi))
7494 : : return NULL_TREE;
7495 : 48020267 : return tsi_stmt (tsi);
7496 : : }
7497 : :
7498 : : /* Parse a compound statement except for the opening brace. This is
7499 : : used for parsing both compound statements and statement expressions
7500 : : (which follow different paths to handling the opening). */
7501 : :
7502 : : static location_t
7503 : 36301396 : c_parser_compound_statement_nostart (c_parser *parser)
7504 : : {
7505 : 36301396 : bool last_stmt = false;
7506 : 36301396 : bool last_label = false;
7507 : 36301396 : bool save_valid_for_pragma = valid_location_for_stdc_pragma_p ();
7508 : 36301396 : location_t label_loc = UNKNOWN_LOCATION; /* Quiet warning. */
7509 : 36301396 : struct omp_for_parse_data *omp_for_parse_state
7510 : : = parser->omp_for_parse_state;
7511 : 72602792 : bool in_omp_loop_block
7512 : 36301396 : = omp_for_parse_state ? omp_for_parse_state->want_nested_loop : false;
7513 : 36301396 : tree sl = NULL_TREE;
7514 : 36301396 : attr_state a = {};
7515 : :
7516 : 36301396 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
7517 : : {
7518 : 23139 : location_t endloc = c_parser_peek_token (parser)->location;
7519 : 23139 : add_debug_begin_stmt (endloc);
7520 : 23139 : c_parser_consume_token (parser);
7521 : 23139 : return endloc;
7522 : : }
7523 : :
7524 : : /* If we're parsing a {} sequence in an OMP_FOR body, start a
7525 : : statement list for intervening code. */
7526 : 36278257 : if (in_omp_loop_block)
7527 : 172 : sl = push_stmt_list ();
7528 : :
7529 : 36278257 : mark_valid_location_for_stdc_pragma (true);
7530 : 36278257 : if (c_parser_next_token_is_keyword (parser, RID_LABEL))
7531 : : {
7532 : : /* Read zero or more forward-declarations for labels that nested
7533 : : functions can jump to. */
7534 : 723 : mark_valid_location_for_stdc_pragma (false);
7535 : 723 : if (in_omp_loop_block)
7536 : 5 : check_omp_intervening_code (parser);
7537 : 1567 : while (c_parser_next_token_is_keyword (parser, RID_LABEL))
7538 : : {
7539 : 844 : label_loc = c_parser_peek_token (parser)->location;
7540 : 844 : c_parser_consume_token (parser);
7541 : : /* Any identifiers, including those declared as type names,
7542 : : are OK here. */
7543 : 1518 : while (true)
7544 : : {
7545 : 1181 : tree label;
7546 : 1181 : if (c_parser_next_token_is_not (parser, CPP_NAME))
7547 : : {
7548 : 0 : c_parser_error (parser, "expected identifier");
7549 : 0 : break;
7550 : : }
7551 : 1181 : label
7552 : 1181 : = declare_label (c_parser_peek_token (parser)->value);
7553 : 1181 : C_DECLARED_LABEL_FLAG (label) = 1;
7554 : 1181 : add_stmt (build_stmt (label_loc, DECL_EXPR, label));
7555 : 1181 : c_parser_consume_token (parser);
7556 : 1181 : if (c_parser_next_token_is (parser, CPP_COMMA))
7557 : 337 : c_parser_consume_token (parser);
7558 : : else
7559 : : break;
7560 : 337 : }
7561 : 844 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
7562 : : }
7563 : 723 : pedwarn (label_loc, OPT_Wpedantic, "ISO C forbids label declarations");
7564 : : }
7565 : : /* We must now have at least one statement, label or declaration. */
7566 : 36278257 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
7567 : : {
7568 : 0 : mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
7569 : 0 : c_parser_error (parser, "expected declaration or statement");
7570 : 0 : location_t endloc = c_parser_peek_token (parser)->location;
7571 : 0 : c_parser_consume_token (parser);
7572 : 0 : return endloc;
7573 : : }
7574 : 36278257 : tree before_labels = get_before_labels ();
7575 : 121972927 : while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
7576 : : {
7577 : 49416472 : location_t loc = c_parser_peek_token (parser)->location;
7578 : 49416472 : loc = expansion_point_location_if_in_system_header (loc);
7579 : :
7580 : 98832944 : bool want_nested_loop = (omp_for_parse_state
7581 : 49416472 : ? omp_for_parse_state->want_nested_loop
7582 : : : false);
7583 : :
7584 : : /* First take care of special cases for OpenMP "canonical loop
7585 : : nest form", that do not allow standard attributes, labels, or
7586 : : __extension__ before the nested statement. */
7587 : 49416472 : if (in_omp_loop_block && !last_label)
7588 : : {
7589 : 385 : tree_code code = omp_for_parse_state->code;
7590 : 495 : if (want_nested_loop
7591 : 385 : && c_parser_omp_next_tokens_can_be_canon_loop (parser, code,
7592 : : false))
7593 : : {
7594 : : /* Found the next nested loop. If there were intervening
7595 : : code statements collected before now, wrap them in an
7596 : : OMP_STRUCTURED_BLOCK node, and start a new structured
7597 : : block to hold statements that may come after the FOR. */
7598 : 110 : gcc_assert (sl);
7599 : 110 : add_structured_block_stmt (pop_stmt_list (sl));
7600 : 110 : omp_for_parse_state->depth++;
7601 : 110 : add_stmt (c_parser_omp_loop_nest (parser, NULL));
7602 : 110 : omp_for_parse_state->depth--;
7603 : 110 : sl = push_stmt_list ();
7604 : 110 : parser->error = false;
7605 : 110 : before_labels = get_before_labels ();
7606 : 161 : continue;
7607 : : }
7608 : 275 : else if (want_nested_loop
7609 : 458 : && c_parser_next_token_is (parser, CPP_OPEN_BRACE))
7610 : : {
7611 : : /* If this nested compound statement contains the nested loop,
7612 : : we need to separate the other statements in the current
7613 : : statement into separate blocks of intervening code. If
7614 : : there's no nested loop, it's all part of the same
7615 : : chunk of intervening code. */
7616 : 44 : tree pre_sl = pop_stmt_list (sl);
7617 : 44 : tree nested_sl = push_stmt_list ();
7618 : 44 : mark_valid_location_for_stdc_pragma (false);
7619 : 44 : c_parser_statement_after_labels (parser, NULL, NULL_TREE);
7620 : 44 : nested_sl = pop_stmt_list (nested_sl);
7621 : 44 : if (omp_for_parse_state->want_nested_loop)
7622 : : {
7623 : : /* This block didn't contain a loop-nest, so it's
7624 : : all part of the same chunk of intervening code. */
7625 : 13 : check_omp_intervening_code (parser);
7626 : 13 : sl = push_stmt_list ();
7627 : 13 : add_stmt (pre_sl);
7628 : 13 : add_stmt (nested_sl);
7629 : : }
7630 : : else
7631 : : {
7632 : : /* It contains the nested loop. */
7633 : 31 : add_structured_block_stmt (pre_sl);
7634 : 31 : add_stmt (nested_sl);
7635 : 31 : sl = push_stmt_list ();
7636 : : }
7637 : 44 : parser->error = false;
7638 : 44 : before_labels = get_before_labels ();
7639 : 44 : continue;
7640 : 44 : }
7641 : 231 : else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
7642 : : {
7643 : : /* Prior to implementing the OpenMP 5.1 syntax for canonical
7644 : : loop form, GCC used to accept an empty statements that
7645 : : would now be flagged as intervening code. Continue to
7646 : : do that, as an extension. */
7647 : : /* FIXME: Maybe issue a warning or something here? */
7648 : 4 : c_parser_consume_token (parser);
7649 : 4 : before_labels = get_before_labels ();
7650 : 4 : continue;
7651 : : }
7652 : : }
7653 : :
7654 : : /* Standard attributes may start a label, statement or declaration. */
7655 : 49416314 : bool have_std_attrs
7656 : 49416314 : = c_parser_nth_token_starts_std_attributes (parser, 1);
7657 : 49416314 : tree std_attrs = NULL_TREE;
7658 : 49416314 : if (have_std_attrs)
7659 : : {
7660 : 838 : std_attrs = c_parser_std_attribute_specifier_sequence (parser);
7661 : 838 : std_attrs = c_parser_handle_musttail (parser, std_attrs, a);
7662 : : }
7663 : 49416314 : if (c_parser_next_token_is_keyword (parser, RID_CASE)
7664 : 48424879 : || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
7665 : 97808511 : || (c_parser_next_token_is (parser, CPP_NAME)
7666 : 9867801 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
7667 : : {
7668 : 1047208 : if (c_parser_next_token_is_keyword (parser, RID_CASE))
7669 : 991435 : label_loc = c_parser_peek_2nd_token (parser)->location;
7670 : : else
7671 : 55773 : label_loc = c_parser_peek_token (parser)->location;
7672 : 1047208 : last_label = true;
7673 : 1047208 : last_stmt = false;
7674 : 1047208 : mark_valid_location_for_stdc_pragma (false);
7675 : 1047208 : if (in_omp_loop_block)
7676 : 26 : check_omp_intervening_code (parser);
7677 : 1047208 : c_parser_label (parser, std_attrs);
7678 : : }
7679 : 48369106 : else if (c_parser_next_tokens_start_declaration (parser)
7680 : 48369106 : || (have_std_attrs
7681 : 703 : && !c_parser_handle_statement_omp_attributes
7682 : 703 : (parser, std_attrs, &have_std_attrs)
7683 : 269 : && c_parser_next_token_is (parser, CPP_SEMICOLON)
7684 : 77 : && (have_std_attrs = true)))
7685 : : {
7686 : 7472566 : if (last_label)
7687 : 64 : pedwarn_c11 (c_parser_peek_token (parser)->location, OPT_Wfree_labels,
7688 : : "a label can only be part of a statement and "
7689 : : "a declaration is not a statement");
7690 : : /* It's unlikely we'll see a nested loop in a declaration in
7691 : : intervening code in an OMP loop, but disallow it anyway. */
7692 : 7472566 : if (in_omp_loop_block)
7693 : : {
7694 : 19 : check_omp_intervening_code (parser);
7695 : 19 : omp_for_parse_state->want_nested_loop = false;
7696 : : }
7697 : 7472566 : mark_valid_location_for_stdc_pragma (false);
7698 : 7472566 : bool fallthru_attr_p = false;
7699 : 7472566 : c_parser_declaration_or_fndef (parser, true, !have_std_attrs,
7700 : : true, true, true, false, NULL,
7701 : : NULL, have_std_attrs, std_attrs,
7702 : : NULL, &fallthru_attr_p);
7703 : :
7704 : 7472566 : if (in_omp_loop_block)
7705 : 19 : omp_for_parse_state->want_nested_loop = want_nested_loop;
7706 : 7472566 : if (last_stmt && !fallthru_attr_p)
7707 : 301166 : pedwarn_c90 (loc, OPT_Wdeclaration_after_statement,
7708 : : "ISO C90 forbids mixed declarations and code");
7709 : 7472566 : last_stmt = fallthru_attr_p;
7710 : 7472566 : last_label = false;
7711 : 7472566 : before_labels = get_before_labels ();
7712 : : }
7713 : 40896540 : else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
7714 : : {
7715 : : /* __extension__ can start a declaration, but is also an
7716 : : unary operator that can start an expression. Consume all
7717 : : but the last of a possible series of __extension__ to
7718 : : determine which. If standard attributes have already
7719 : : been seen, it must start a statement, not a declaration,
7720 : : but standard attributes starting a declaration may appear
7721 : : after __extension__. */
7722 : 1560 : while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
7723 : 780 : && (c_parser_peek_2nd_token (parser)->keyword
7724 : : == RID_EXTENSION))
7725 : 0 : c_parser_consume_token (parser);
7726 : 780 : if (!have_std_attrs
7727 : 780 : && (c_token_starts_declaration (c_parser_peek_2nd_token (parser))
7728 : 709 : || c_parser_nth_token_starts_std_attributes (parser, 2)))
7729 : : {
7730 : 74 : int ext;
7731 : 74 : ext = disable_extension_diagnostics ();
7732 : 74 : c_parser_consume_token (parser);
7733 : 74 : last_label = false;
7734 : : /* It's unlikely we'll see a nested loop in a declaration in
7735 : : intervening code in an OMP loop, but disallow it anyway. */
7736 : 74 : if (in_omp_loop_block)
7737 : : {
7738 : 0 : check_omp_intervening_code (parser);
7739 : 0 : omp_for_parse_state->want_nested_loop = false;
7740 : : }
7741 : 74 : mark_valid_location_for_stdc_pragma (false);
7742 : 74 : c_parser_declaration_or_fndef (parser, true, true, true, true,
7743 : : true, false);
7744 : 74 : if (in_omp_loop_block)
7745 : 0 : omp_for_parse_state->want_nested_loop = want_nested_loop;
7746 : : /* Following the old parser, __extension__ does not
7747 : : disable this diagnostic. */
7748 : 74 : restore_extension_diagnostics (ext);
7749 : 74 : if (last_stmt)
7750 : 7 : pedwarn_c90 (loc, OPT_Wdeclaration_after_statement,
7751 : : "ISO C90 forbids mixed declarations and code");
7752 : 74 : last_stmt = false;
7753 : 74 : before_labels = get_before_labels ();
7754 : : }
7755 : : else
7756 : 706 : goto statement;
7757 : : }
7758 : 40895760 : else if (c_parser_next_token_is (parser, CPP_PRAGMA))
7759 : : {
7760 : 328390 : if (have_std_attrs && !parser->in_omp_attribute_pragma)
7761 : 0 : c_parser_error (parser, "expected declaration or statement");
7762 : 328390 : else if (std_attrs)
7763 : 0 : c_warn_unused_attributes (std_attrs);
7764 : : /* External pragmas, and some omp pragmas, are not associated
7765 : : with regular c code, and so are not to be considered statements
7766 : : syntactically. This ensures that the user doesn't put them
7767 : : places that would turn into syntax errors if the directive
7768 : : were ignored. */
7769 : 328390 : if (omp_for_parse_state)
7770 : 9 : omp_for_parse_state->want_nested_loop = false;
7771 : 656700 : if (c_parser_pragma (parser,
7772 : : last_label ? pragma_stmt : pragma_compound,
7773 : : NULL, before_labels))
7774 : : {
7775 : 22634 : last_label = false;
7776 : 22634 : last_stmt = true;
7777 : 22634 : if (omp_for_parse_state)
7778 : 2 : check_omp_intervening_code (parser);
7779 : : }
7780 : 305758 : if (omp_for_parse_state)
7781 : 9 : omp_for_parse_state->want_nested_loop = want_nested_loop;
7782 : 328390 : before_labels = get_before_labels ();
7783 : : }
7784 : 40567370 : else if (c_parser_next_token_is (parser, CPP_EOF))
7785 : : {
7786 : 56 : mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
7787 : 56 : c_parser_error (parser, "expected declaration or statement");
7788 : 58 : return c_parser_peek_token (parser)->location;
7789 : : }
7790 : 40567314 : else if (c_parser_next_token_is_keyword (parser, RID_ELSE))
7791 : : {
7792 : 5 : if (parser->in_if_block)
7793 : : {
7794 : 2 : mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
7795 : 2 : error_at (loc, "expected %<}%> before %<else%>");
7796 : 2 : return c_parser_peek_token (parser)->location;
7797 : : }
7798 : : else
7799 : : {
7800 : 3 : error_at (loc, "%<else%> without a previous %<if%>");
7801 : 3 : c_parser_consume_token (parser);
7802 : 3 : before_labels = get_before_labels ();
7803 : 3 : continue;
7804 : : }
7805 : : }
7806 : : else
7807 : : {
7808 : 40567309 : statement:
7809 : 40568015 : c_warn_unused_attributes (std_attrs);
7810 : 40568015 : last_label = false;
7811 : 40568015 : last_stmt = true;
7812 : 40568015 : mark_valid_location_for_stdc_pragma (false);
7813 : 40568015 : if (!omp_for_parse_state)
7814 : 40567786 : c_parser_statement_after_labels (parser, NULL, before_labels,
7815 : : NULL, a);
7816 : : else
7817 : : {
7818 : : /* In canonical loop nest form, nested loops can only appear
7819 : : directly, or in a directly nested compound statement. We
7820 : : already took care of those cases above, so now we have
7821 : : something else. This statement and everything inside
7822 : : it must be intervening code. */
7823 : 229 : omp_for_parse_state->want_nested_loop = false;
7824 : 229 : check_omp_intervening_code (parser);
7825 : 229 : c_parser_statement_after_labels (parser, NULL, before_labels);
7826 : 229 : omp_for_parse_state->want_nested_loop = want_nested_loop;
7827 : : }
7828 : 40568014 : before_labels = get_before_labels ();
7829 : : }
7830 : :
7831 : 49416252 : parser->error = false;
7832 : : }
7833 : 36278198 : if (last_label)
7834 : 44 : pedwarn_c11 (label_loc, OPT_Wfree_labels,
7835 : : "label at end of compound statement");
7836 : 36278198 : location_t endloc = c_parser_peek_token (parser)->location;
7837 : 36278198 : c_parser_consume_token (parser);
7838 : :
7839 : : /* Restore the value we started with. */
7840 : 36278198 : mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
7841 : :
7842 : : /* Package leftover intervening code, or the whole contents of the
7843 : : compound statement if we were looking for a nested loop in an OMP_FOR
7844 : : construct and didn't find one. */
7845 : 36278198 : if (sl)
7846 : : {
7847 : 172 : sl = pop_stmt_list (sl);
7848 : 172 : if (omp_for_parse_state->want_nested_loop)
7849 : 31 : add_stmt (sl);
7850 : : else
7851 : 141 : add_structured_block_stmt (sl);
7852 : : }
7853 : : return endloc;
7854 : : }
7855 : :
7856 : : /* Parse all consecutive labels, possibly preceded by standard
7857 : : attributes. In this context, a statement is required, not a
7858 : : declaration, so attributes must be followed by a statement that is
7859 : : not just a semicolon. Returns an attr_state. */
7860 : :
7861 : : static attr_state
7862 : 2019041 : c_parser_all_labels (c_parser *parser)
7863 : : {
7864 : 2019041 : attr_state attr = {};
7865 : 2019041 : bool have_std_attrs;
7866 : 2019041 : tree std_attrs = NULL;
7867 : 2019041 : if ((have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1)))
7868 : : {
7869 : 109 : std_attrs = c_parser_std_attribute_specifier_sequence (parser);
7870 : 109 : std_attrs = c_parser_handle_musttail (parser, std_attrs, attr);
7871 : : }
7872 : :
7873 : 2020004 : while (c_parser_next_token_is_keyword (parser, RID_CASE)
7874 : 2019518 : || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
7875 : 4039511 : || (c_parser_next_token_is (parser, CPP_NAME)
7876 : 495552 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
7877 : : {
7878 : 963 : c_parser_label (parser, std_attrs);
7879 : 963 : std_attrs = NULL;
7880 : 963 : if ((have_std_attrs = c_parser_nth_token_starts_std_attributes (parser,
7881 : : 1)))
7882 : : {
7883 : 3 : std_attrs = c_parser_std_attribute_specifier_sequence (parser);
7884 : 3 : std_attrs = c_parser_handle_musttail (parser, std_attrs, attr);
7885 : : }
7886 : : }
7887 : 2019041 : if (std_attrs
7888 : 2019041 : && (!c_parser_handle_statement_omp_attributes (parser, std_attrs, &have_std_attrs)
7889 : 11 : || std_attrs))
7890 : : {
7891 : 22 : if (have_std_attrs && c_parser_next_token_is (parser, CPP_SEMICOLON))
7892 : 0 : c_parser_error (parser, "expected statement");
7893 : 18 : c_warn_unused_attributes (std_attrs);
7894 : : }
7895 : 2019115 : else if (have_std_attrs && c_parser_next_token_is (parser, CPP_SEMICOLON))
7896 : 1 : c_parser_error (parser, "expected statement");
7897 : 2019041 : return attr;
7898 : : }
7899 : :
7900 : :
7901 : : /* Information used while parsing an OpenMP metadirective. */
7902 : : struct omp_metadirective_parse_data {
7903 : : /* These fields are used to unique-ify labels when reparsing the
7904 : : code in a metadirective alternative. */
7905 : : vec<tree> * GTY((skip)) body_labels;
7906 : : unsigned int region_num;
7907 : : };
7908 : :
7909 : : /* Helper function for c_parser_label: mangle a metadirective region
7910 : : label NAME. */
7911 : : static tree
7912 : 16 : mangle_metadirective_region_label (c_parser *parser, tree name)
7913 : : {
7914 : 16 : if (parser->omp_metadirective_state->body_labels->contains (name))
7915 : : {
7916 : 16 : const char *old_name = IDENTIFIER_POINTER (name);
7917 : 16 : char *new_name = (char *) XALLOCAVEC (char, strlen (old_name) + 32);
7918 : 16 : sprintf (new_name, "%s_MDR%u", old_name,
7919 : : parser->omp_metadirective_state->region_num);
7920 : 16 : return get_identifier (new_name);
7921 : : }
7922 : 0 : return name;
7923 : : }
7924 : :
7925 : : /* Parse a label (C90 6.6.1, C99 6.8.1, C11 6.8.1).
7926 : :
7927 : : label:
7928 : : identifier : gnu-attributes[opt]
7929 : : case constant-expression :
7930 : : default :
7931 : :
7932 : : GNU extensions:
7933 : :
7934 : : label:
7935 : : case constant-expression ... constant-expression :
7936 : :
7937 : : The use of gnu-attributes on labels is a GNU extension. The syntax in
7938 : : GNU C accepts any expressions without commas, non-constant
7939 : : expressions being rejected later. Any standard
7940 : : attribute-specifier-sequence before the first label has been parsed
7941 : : in the caller, to distinguish statements from declarations. Any
7942 : : attribute-specifier-sequence after the label is parsed in this
7943 : : function. */
7944 : : static void
7945 : 1048171 : c_parser_label (c_parser *parser, tree std_attrs)
7946 : : {
7947 : 1048171 : location_t loc1 = c_parser_peek_token (parser)->location;
7948 : 1048171 : tree label = NULL_TREE;
7949 : :
7950 : : /* Remember whether this case or a user-defined label is allowed to fall
7951 : : through to. */
7952 : 1048171 : bool fallthrough_p = c_parser_peek_token (parser)->flags & PREV_FALLTHROUGH;
7953 : :
7954 : 1048171 : if (c_parser_next_token_is_keyword (parser, RID_CASE))
7955 : : {
7956 : 991921 : tree exp1, exp2;
7957 : 991921 : c_parser_consume_token (parser);
7958 : 991921 : exp1 = convert_lvalue_to_rvalue (loc1,
7959 : : c_parser_expr_no_commas (parser, NULL),
7960 : : true, true).value;
7961 : 991921 : if (c_parser_next_token_is (parser, CPP_COLON))
7962 : : {
7963 : 991599 : c_parser_consume_token (parser);
7964 : 991599 : label = do_case (loc1, exp1, NULL_TREE, std_attrs);
7965 : : }
7966 : 322 : else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
7967 : : {
7968 : 314 : c_parser_consume_token (parser);
7969 : 314 : exp2 = convert_lvalue_to_rvalue (loc1,
7970 : : c_parser_expr_no_commas (parser,
7971 : : NULL),
7972 : : true, true).value;
7973 : 314 : if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
7974 : 314 : label = do_case (loc1, exp1, exp2, std_attrs);
7975 : : }
7976 : : else
7977 : 8 : c_parser_error (parser, "expected %<:%> or %<...%>");
7978 : : }
7979 : 56250 : else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
7980 : : {
7981 : 32693 : c_parser_consume_token (parser);
7982 : 32693 : if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
7983 : 32693 : label = do_case (loc1, NULL_TREE, NULL_TREE, std_attrs);
7984 : : }
7985 : : else
7986 : : {
7987 : 23557 : tree name = c_parser_peek_token (parser)->value;
7988 : 23557 : tree tlab;
7989 : 23557 : tree attrs;
7990 : 23557 : location_t loc2 = c_parser_peek_token (parser)->location;
7991 : 23557 : gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
7992 : 23557 : c_parser_consume_token (parser);
7993 : 23557 : gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
7994 : 23557 : c_parser_consume_token (parser);
7995 : 23557 : attrs = c_parser_gnu_attributes (parser);
7996 : 23557 : if (parser->omp_metadirective_state)
7997 : 8 : name = mangle_metadirective_region_label (parser, name);
7998 : 23557 : tlab = define_label (loc2, name);
7999 : 23557 : if (tlab)
8000 : : {
8001 : 23529 : decl_attributes (&tlab, attrs, 0);
8002 : 23529 : decl_attributes (&tlab, std_attrs, 0);
8003 : 23529 : label = add_stmt (build_stmt (loc1, LABEL_EXPR, tlab));
8004 : : }
8005 : 23557 : if (attrs
8006 : 23557 : && c_parser_next_tokens_start_declaration (parser))
8007 : 1 : warning_at (loc2, OPT_Wattributes, "GNU-style attribute between"
8008 : : " label and declaration appertains to the label");
8009 : : }
8010 : 1048171 : if (label)
8011 : : {
8012 : 1047991 : if (TREE_CODE (label) == LABEL_EXPR)
8013 : 23529 : FALLTHROUGH_LABEL_P (LABEL_EXPR_LABEL (label)) = fallthrough_p;
8014 : : else
8015 : 1024462 : FALLTHROUGH_LABEL_P (CASE_LABEL (label)) = fallthrough_p;
8016 : : }
8017 : 1048171 : }
8018 : :
8019 : : /* Parse a statement (C90 6.6, C99 6.8, C11 6.8).
8020 : :
8021 : : statement:
8022 : : labeled-statement
8023 : : attribute-specifier-sequence[opt] compound-statement
8024 : : expression-statement
8025 : : attribute-specifier-sequence[opt] selection-statement
8026 : : attribute-specifier-sequence[opt] iteration-statement
8027 : : attribute-specifier-sequence[opt] jump-statement
8028 : :
8029 : : labeled-statement:
8030 : : attribute-specifier-sequence[opt] label statement
8031 : :
8032 : : expression-statement:
8033 : : expression[opt] ;
8034 : : attribute-specifier-sequence expression ;
8035 : :
8036 : : selection-statement:
8037 : : if-statement
8038 : : switch-statement
8039 : :
8040 : : iteration-statement:
8041 : : while-statement
8042 : : do-statement
8043 : : for-statement
8044 : :
8045 : : jump-statement:
8046 : : goto identifier ;
8047 : : continue ;
8048 : : break ;
8049 : : return expression[opt] ;
8050 : :
8051 : : GNU extensions:
8052 : :
8053 : : statement:
8054 : : attribute-specifier-sequence[opt] asm-statement
8055 : :
8056 : : jump-statement:
8057 : : goto * expression ;
8058 : :
8059 : : expression-statement:
8060 : : gnu-attributes ;
8061 : :
8062 : : Objective-C:
8063 : :
8064 : : statement:
8065 : : attribute-specifier-sequence[opt] objc-throw-statement
8066 : : attribute-specifier-sequence[opt] objc-try-catch-statement
8067 : : attribute-specifier-sequence[opt] objc-synchronized-statement
8068 : :
8069 : : objc-throw-statement:
8070 : : @throw expression ;
8071 : : @throw ;
8072 : :
8073 : : OpenACC:
8074 : :
8075 : : statement:
8076 : : attribute-specifier-sequence[opt] openacc-construct
8077 : :
8078 : : openacc-construct:
8079 : : parallel-construct
8080 : : kernels-construct
8081 : : data-construct
8082 : : loop-construct
8083 : :
8084 : : parallel-construct:
8085 : : parallel-directive structured-block
8086 : :
8087 : : kernels-construct:
8088 : : kernels-directive structured-block
8089 : :
8090 : : data-construct:
8091 : : data-directive structured-block
8092 : :
8093 : : loop-construct:
8094 : : loop-directive structured-block
8095 : :
8096 : : OpenMP:
8097 : :
8098 : : statement:
8099 : : attribute-specifier-sequence[opt] openmp-construct
8100 : :
8101 : : openmp-construct:
8102 : : parallel-construct
8103 : : for-construct
8104 : : simd-construct
8105 : : for-simd-construct
8106 : : sections-construct
8107 : : single-construct
8108 : : parallel-for-construct
8109 : : parallel-for-simd-construct
8110 : : parallel-sections-construct
8111 : : master-construct
8112 : : critical-construct
8113 : : atomic-construct
8114 : : ordered-construct
8115 : :
8116 : : parallel-construct:
8117 : : parallel-directive structured-block
8118 : :
8119 : : for-construct:
8120 : : for-directive iteration-statement
8121 : :
8122 : : simd-construct:
8123 : : simd-directive iteration-statements
8124 : :
8125 : : for-simd-construct:
8126 : : for-simd-directive iteration-statements
8127 : :
8128 : : sections-construct:
8129 : : sections-directive section-scope
8130 : :
8131 : : single-construct:
8132 : : single-directive structured-block
8133 : :
8134 : : parallel-for-construct:
8135 : : parallel-for-directive iteration-statement
8136 : :
8137 : : parallel-for-simd-construct:
8138 : : parallel-for-simd-directive iteration-statement
8139 : :
8140 : : parallel-sections-construct:
8141 : : parallel-sections-directive section-scope
8142 : :
8143 : : master-construct:
8144 : : master-directive structured-block
8145 : :
8146 : : critical-construct:
8147 : : critical-directive structured-block
8148 : :
8149 : : atomic-construct:
8150 : : atomic-directive expression-statement
8151 : :
8152 : : ordered-construct:
8153 : : ordered-directive structured-block
8154 : :
8155 : : Transactional Memory:
8156 : :
8157 : : statement:
8158 : : attribute-specifier-sequence[opt] transaction-statement
8159 : : attribute-specifier-sequence[opt] transaction-cancel-statement
8160 : :
8161 : : IF_P is used to track whether there's a (possibly labeled) if statement
8162 : : which is not enclosed in braces and has an else clause. This is used to
8163 : : implement -Wparentheses. */
8164 : :
8165 : : static void
8166 : 518949 : c_parser_statement (c_parser *parser, bool *if_p, location_t *loc_after_labels)
8167 : : {
8168 : 518949 : tree before_labels = get_before_labels ();
8169 : 518949 : attr_state a = c_parser_all_labels (parser);
8170 : 518949 : if (loc_after_labels)
8171 : 354214 : *loc_after_labels = c_parser_peek_token (parser)->location;
8172 : 518949 : parser->omp_attrs_forbidden_p = false;
8173 : 518949 : c_parser_statement_after_labels (parser, if_p, before_labels, NULL, a);
8174 : 518949 : }
8175 : :
8176 : : /* Parse and handle optional identifier after break or continue keywords. */
8177 : :
8178 : : static tree
8179 : 183485 : c_parser_bc_name (c_parser *parser, bool is_break)
8180 : : {
8181 : 183485 : if (!c_parser_next_token_is (parser, CPP_NAME))
8182 : : return NULL_TREE;
8183 : :
8184 : 316 : c_token *tok = c_parser_peek_token (parser);
8185 : 316 : tree label = c_finish_bc_name (tok->location, tok->value, is_break);
8186 : 316 : c_parser_consume_token (parser);
8187 : 316 : return label;
8188 : : }
8189 : :
8190 : : /* Parse a statement, other than a labeled statement. CHAIN is a vector
8191 : : of if-else-if conditions. All labels and standard attributes have
8192 : : been parsed in the caller.
8193 : :
8194 : : IF_P is used to track whether there's a (possibly labeled) if statement
8195 : : which is not enclosed in braces and has an else clause. This is used to
8196 : : implement -Wparentheses. ASTATE is an earlier parsed attribute state.
8197 : :
8198 : : BEFORE_LABELS is last statement before possible labels, see
8199 : : get_before_labels description for details. */
8200 : :
8201 : : static void
8202 : 42138180 : c_parser_statement_after_labels (c_parser *parser, bool *if_p,
8203 : : tree before_labels,
8204 : : vec<tree> *chain, attr_state astate)
8205 : : {
8206 : 42138180 : location_t loc = c_parser_peek_token (parser)->location;
8207 : 42138180 : tree stmt = NULL_TREE;
8208 : 42138180 : bool in_if_block = parser->in_if_block;
8209 : 42138180 : parser->in_if_block = false;
8210 : 42138180 : if (if_p != NULL)
8211 : 801801 : *if_p = false;
8212 : :
8213 : 42138180 : if (c_parser_peek_token (parser)->type != CPP_OPEN_BRACE)
8214 : 41693901 : add_debug_begin_stmt (loc);
8215 : :
8216 : 444279 : restart:
8217 : 42138216 : switch (c_parser_peek_token (parser)->type)
8218 : : {
8219 : 444283 : case CPP_OPEN_BRACE:
8220 : 444283 : add_stmt (c_parser_compound_statement (parser));
8221 : 444283 : break;
8222 : 35934046 : case CPP_KEYWORD:
8223 : 35934046 : switch (c_parser_peek_token (parser)->keyword)
8224 : : {
8225 : 1247693 : case RID_IF:
8226 : 1247693 : c_parser_if_statement (parser, if_p, chain);
8227 : 1247693 : break;
8228 : 36597 : case RID_SWITCH:
8229 : 36597 : c_parser_switch_statement (parser, if_p, before_labels);
8230 : 36597 : break;
8231 : 43663 : case RID_WHILE:
8232 : 43663 : c_parser_while_statement (parser, false, 0, false, if_p, before_labels);
8233 : 43663 : break;
8234 : 144562 : case RID_DO:
8235 : 144562 : c_parser_do_statement (parser, false, 0, false, before_labels);
8236 : 144562 : break;
8237 : 270996 : case RID_FOR:
8238 : 270996 : c_parser_for_statement (parser, false, 0, false, if_p, before_labels);
8239 : 270996 : break;
8240 : 83467 : case RID_GOTO:
8241 : 83467 : c_parser_consume_token (parser);
8242 : 83467 : if (c_parser_next_token_is (parser, CPP_NAME))
8243 : : {
8244 : 82537 : tree name = c_parser_peek_token (parser)->value;
8245 : 82537 : if (parser->omp_metadirective_state)
8246 : 8 : name = mangle_metadirective_region_label (parser, name);
8247 : 82537 : stmt = c_finish_goto_label (loc, name);
8248 : 82537 : c_parser_consume_token (parser);
8249 : : }
8250 : 930 : else if (c_parser_next_token_is (parser, CPP_MULT))
8251 : : {
8252 : 930 : struct c_expr val;
8253 : :
8254 : 930 : c_parser_consume_token (parser);
8255 : 930 : val = c_parser_expression (parser);
8256 : 930 : val = convert_lvalue_to_rvalue (loc, val, false, true);
8257 : 930 : stmt = c_finish_goto_ptr (loc, val);
8258 : : }
8259 : : else
8260 : 0 : c_parser_error (parser, "expected identifier or %<*%>");
8261 : 83467 : goto expect_semicolon;
8262 : 12245 : case RID_CONTINUE:
8263 : 12245 : c_parser_consume_token (parser);
8264 : 12245 : stmt = c_finish_bc_stmt (loc, objc_foreach_continue_label, false,
8265 : : c_parser_bc_name (parser, false));
8266 : 12245 : goto expect_semicolon;
8267 : 171240 : case RID_BREAK:
8268 : 171240 : c_parser_consume_token (parser);
8269 : 171240 : stmt = c_finish_bc_stmt (loc, objc_foreach_break_label, true,
8270 : : c_parser_bc_name (parser, true));
8271 : 171240 : goto expect_semicolon;
8272 : 33704695 : case RID_RETURN:
8273 : 33704695 : c_parser_consume_token (parser);
8274 : 33704695 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
8275 : : {
8276 : 42084 : stmt = c_finish_return (loc, NULL_TREE, NULL_TREE,
8277 : 21042 : astate.musttail_p);
8278 : 21042 : c_parser_consume_token (parser);
8279 : : }
8280 : : else
8281 : : {
8282 : 33683653 : location_t xloc = c_parser_peek_token (parser)->location;
8283 : 33683653 : struct c_expr expr = c_parser_expression_conv (parser);
8284 : 33683653 : mark_exp_read (expr.value);
8285 : 34445677 : stmt = c_finish_return (EXPR_LOC_OR_LOC (expr.value, xloc),
8286 : : expr.value, expr.original_type,
8287 : 33683653 : astate.musttail_p);
8288 : 33683653 : goto expect_semicolon;
8289 : : }
8290 : 21042 : break;
8291 : 200484 : case RID_ASM:
8292 : 200484 : stmt = c_parser_asm_statement (parser);
8293 : 200484 : break;
8294 : 137 : case RID_TRANSACTION_ATOMIC:
8295 : 137 : case RID_TRANSACTION_RELAXED:
8296 : 274 : stmt = c_parser_transaction (parser,
8297 : 137 : c_parser_peek_token (parser)->keyword);
8298 : 137 : break;
8299 : 28 : case RID_TRANSACTION_CANCEL:
8300 : 28 : stmt = c_parser_transaction_cancel (parser);
8301 : 28 : goto expect_semicolon;
8302 : 0 : case RID_AT_THROW:
8303 : 0 : gcc_assert (c_dialect_objc ());
8304 : 0 : c_parser_consume_token (parser);
8305 : 0 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
8306 : : {
8307 : 0 : stmt = objc_build_throw_stmt (loc, NULL_TREE);
8308 : 0 : c_parser_consume_token (parser);
8309 : : }
8310 : : else
8311 : : {
8312 : 0 : struct c_expr expr = c_parser_expression (parser);
8313 : 0 : expr = convert_lvalue_to_rvalue (loc, expr, false, false);
8314 : 0 : expr.value = c_fully_fold (expr.value, false, NULL);
8315 : 0 : stmt = objc_build_throw_stmt (loc, expr.value);
8316 : 0 : goto expect_semicolon;
8317 : : }
8318 : 0 : break;
8319 : 0 : case RID_AT_TRY:
8320 : 0 : gcc_assert (c_dialect_objc ());
8321 : 0 : c_parser_objc_try_catch_finally_statement (parser);
8322 : 0 : break;
8323 : 0 : case RID_AT_SYNCHRONIZED:
8324 : 0 : gcc_assert (c_dialect_objc ());
8325 : 0 : c_parser_objc_synchronized_statement (parser);
8326 : 0 : break;
8327 : 9 : case RID_ATTRIBUTE:
8328 : 9 : {
8329 : : /* Allow '__attribute__((fallthrough));' or
8330 : : '__attribute__((assume(cond)));' or
8331 : : '__attribute__((musttail))) return'. */
8332 : 9 : tree attrs = c_parser_gnu_attributes (parser);
8333 : 9 : bool has_assume = lookup_attribute ("assume", attrs);
8334 : 9 : if (has_assume)
8335 : : {
8336 : 0 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
8337 : 0 : attrs = handle_assume_attribute (loc, attrs, true);
8338 : : else
8339 : : {
8340 : 0 : auto_urlify_attributes sentinel;
8341 : 0 : warning_at (loc, OPT_Wattributes,
8342 : : "%<assume%> attribute not followed by %<;%>");
8343 : 0 : has_assume = false;
8344 : 0 : }
8345 : : }
8346 : 9 : gcc_assert (!astate.musttail_p);
8347 : 9 : attrs = c_parser_handle_musttail (parser, attrs, astate);
8348 : 9 : if (astate.musttail_p)
8349 : : {
8350 : 4 : if (attrs)
8351 : : {
8352 : 1 : auto_urlify_attributes sentinel;
8353 : 1 : warning_at (c_parser_peek_token (parser)->location,
8354 : 1 : OPT_Wattributes,
8355 : : "attribute %<musttail%> mixed with other "
8356 : : "attributes on %<return%> statement");
8357 : 1 : }
8358 : 4 : goto restart;
8359 : : }
8360 : 5 : if (attribute_fallthrough_p (attrs))
8361 : : {
8362 : 5 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
8363 : : {
8364 : 5 : tree fn = build_call_expr_internal_loc (loc,
8365 : : IFN_FALLTHROUGH,
8366 : : void_type_node, 0);
8367 : 5 : add_stmt (fn);
8368 : : /* Eat the ';'. */
8369 : 5 : c_parser_consume_token (parser);
8370 : : }
8371 : : else
8372 : : {
8373 : 0 : auto_urlify_attributes sentinel;
8374 : 0 : warning_at (loc, OPT_Wattributes,
8375 : : "%<fallthrough%> attribute not followed "
8376 : : "by %<;%>");
8377 : 0 : }
8378 : : }
8379 : 0 : else if (has_assume)
8380 : : /* Eat the ';'. */
8381 : 0 : c_parser_consume_token (parser);
8382 : 0 : else if (attrs != NULL_TREE)
8383 : : {
8384 : 0 : auto_urlify_attributes sentinel;
8385 : 0 : warning_at (loc, OPT_Wattributes,
8386 : : "only attribute %<fallthrough%> or %<assume%> can "
8387 : : "be applied to a null statement");
8388 : 0 : }
8389 : : break;
8390 : : }
8391 : 18230 : default:
8392 : 18230 : goto expr_stmt;
8393 : : }
8394 : : break;
8395 : 199391 : case CPP_SEMICOLON:
8396 : 199391 : c_parser_consume_token (parser);
8397 : 199391 : break;
8398 : 5 : case CPP_CLOSE_PAREN:
8399 : 5 : case CPP_CLOSE_SQUARE:
8400 : : /* Avoid infinite loop in error recovery:
8401 : : c_parser_skip_until_found stops at a closing nesting
8402 : : delimiter without consuming it, but here we need to consume
8403 : : it to proceed further. */
8404 : 5 : c_parser_error (parser, "expected statement");
8405 : 5 : c_parser_consume_token (parser);
8406 : 5 : break;
8407 : 2697 : case CPP_PRAGMA:
8408 : 2697 : if (!c_parser_pragma (parser, pragma_stmt, if_p, before_labels))
8409 : 32 : goto restart;
8410 : : break;
8411 : 5576024 : default:
8412 : 5576024 : expr_stmt:
8413 : 5576024 : stmt = c_finish_expr_stmt (loc, c_parser_expression_conv (parser).value);
8414 : 39526656 : expect_semicolon:
8415 : 39526656 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
8416 : 39526656 : break;
8417 : : }
8418 : : /* Two cases cannot and do not have line numbers associated: If stmt
8419 : : is degenerate, such as "2;", then stmt is an INTEGER_CST, which
8420 : : cannot hold line numbers. But that's OK because the statement
8421 : : will either be changed to a MODIFY_EXPR during gimplification of
8422 : : the statement expr, or discarded. If stmt was compound, but
8423 : : without new variables, we will have skipped the creation of a
8424 : : BIND and will have a bare STATEMENT_LIST. But that's OK because
8425 : : (recursively) all of the component statements should already have
8426 : : line numbers assigned. ??? Can we discard no-op statements
8427 : : earlier? */
8428 : 42138179 : if (EXPR_LOCATION (stmt) == UNKNOWN_LOCATION)
8429 : 2393303 : protected_set_expr_location (stmt, loc);
8430 : :
8431 : 42138179 : parser->in_if_block = in_if_block;
8432 : 42138179 : }
8433 : :
8434 : : /* Parse the condition from an if, do, while or for statements. */
8435 : :
8436 : : static tree
8437 : 459206 : c_parser_condition (c_parser *parser)
8438 : : {
8439 : 459206 : location_t loc = c_parser_peek_token (parser)->location;
8440 : 459206 : tree cond;
8441 : 459206 : cond = c_parser_expression_conv (parser).value;
8442 : 459206 : cond = c_objc_common_truthvalue_conversion (loc, cond);
8443 : 459206 : cond = c_fully_fold (cond, false, NULL);
8444 : 459206 : if (warn_sequence_point)
8445 : 81443 : verify_sequence_points (cond);
8446 : 459206 : return cond;
8447 : : }
8448 : :
8449 : : /* Parse a parenthesized condition from a do or while statement.
8450 : :
8451 : : condition:
8452 : : ( expression )
8453 : : */
8454 : :
8455 : : static tree
8456 : 188299 : c_parser_paren_condition (c_parser *parser)
8457 : : {
8458 : 188299 : tree cond;
8459 : 188299 : matching_parens parens;
8460 : 188299 : if (!parens.require_open (parser))
8461 : 0 : return error_mark_node;
8462 : 188299 : cond = c_parser_condition (parser);
8463 : 188299 : parens.skip_until_found_close (parser);
8464 : 188299 : return cond;
8465 : : }
8466 : :
8467 : : /* Parse a selection-header:
8468 : :
8469 : : selection-header:
8470 : : expression
8471 : : declaration expression
8472 : : simple-declaration
8473 : :
8474 : : simple-declaration:
8475 : : attribute-specifier-sequence[opt] declaration-specifiers declarator
8476 : : = initializer
8477 : :
8478 : : SWITCH_P is true if we are called from c_parser_switch_statement; in
8479 : : that case, don't perform the truthvalue conversion. */
8480 : :
8481 : : static c_expr
8482 : 1284282 : c_parser_selection_header (c_parser *parser, bool switch_p)
8483 : : {
8484 : 1284282 : location_t loc = c_parser_peek_token (parser)->location;
8485 : 1284282 : c_expr expr;
8486 : 1284282 : bool parse_expr = true;
8487 : 1284282 : tree std_attrs;
8488 : 1284282 : bool have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1);
8489 : 1284282 : if (have_std_attrs)
8490 : 20 : std_attrs = c_parser_std_attribute_specifier_sequence (parser);
8491 : : else
8492 : : std_attrs = NULL_TREE;
8493 : 1284282 : if (c_parser_next_tokens_start_declaration (parser))
8494 : : {
8495 : 239 : pedwarn_c23 (loc, OPT_Wpedantic,
8496 : : "ISO C does not support if declarations before C2Y");
8497 : 239 : expr.value
8498 : 239 : = c_parser_declaration_or_fndef (parser,
8499 : : /*fndef_ok=*/false,
8500 : : /*static_assert_ok=*/false,
8501 : : /*empty_ok=*/false,
8502 : : /*nested=*/true,
8503 : : /*start_attr_ok=*/true,
8504 : : /*simple_ok=*/true,
8505 : : /*objc_foreach_object_decl=*/nullptr,
8506 : : /*omp_declare_simd_clauses=*/nullptr,
8507 : : have_std_attrs,
8508 : : std_attrs);
8509 : 239 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
8510 : 99 : c_parser_consume_token (parser);
8511 : : else
8512 : : {
8513 : : /* A simple-declaration is a declaration that can appear in
8514 : : place of the controlling expression of a selection statement.
8515 : : In that case, there shall be an initializer. */
8516 : 140 : if (!expr.value)
8517 : : {
8518 : 48 : error_at (loc, "declaration in the controlling expression must "
8519 : : "have an initializer");
8520 : 48 : expr.original_type = error_mark_node;
8521 : 48 : expr.set_error ();
8522 : 48 : return expr;
8523 : : }
8524 : : parse_expr = false;
8525 : : }
8526 : 191 : if (expr.value)
8527 : : {
8528 : 175 : expr.original_type = TREE_TYPE (expr.value);
8529 : 175 : expr = convert_lvalue_to_rvalue (loc, expr, /*convert_p=*/true,
8530 : : /*read_p=*/true);
8531 : : }
8532 : : }
8533 : 1284043 : else if (have_std_attrs)
8534 : : {
8535 : 8 : c_parser_error (parser, "expected declaration");
8536 : 8 : expr.original_type = error_mark_node;
8537 : 8 : expr.set_error ();
8538 : 8 : return expr;
8539 : : }
8540 : :
8541 : 191 : if (parse_expr)
8542 : 1284134 : expr = c_parser_expression_conv (parser);
8543 : 1284226 : if (!switch_p)
8544 : : {
8545 : 1247664 : expr.value = c_objc_common_truthvalue_conversion (loc, expr.value);
8546 : 1247664 : expr.value = c_fully_fold (expr.value, false, NULL);
8547 : 1247664 : if (warn_sequence_point)
8548 : 244349 : verify_sequence_points (expr.value);
8549 : : }
8550 : : return expr;
8551 : : }
8552 : :
8553 : : /* Parse a selection-header enclosed in parentheses:
8554 : :
8555 : : ( selection-header )
8556 : : */
8557 : :
8558 : : static tree
8559 : 1247693 : c_parser_paren_selection_header (c_parser *parser)
8560 : : {
8561 : 1247693 : matching_parens parens;
8562 : 1247693 : if (!parens.require_open (parser))
8563 : 1 : return error_mark_node;
8564 : 1247692 : tree cond = c_parser_selection_header (parser, /*switch_p=*/false).value;
8565 : 1247692 : parens.skip_until_found_close (parser);
8566 : 1247692 : return cond;
8567 : : }
8568 : :
8569 : : /* Parse a statement which is a block in C99.
8570 : :
8571 : : IF_P is used to track whether there's a (possibly labeled) if statement
8572 : : which is not enclosed in braces and has an else clause. This is used to
8573 : : implement -Wparentheses. */
8574 : :
8575 : : static tree
8576 : 509502 : c_parser_c99_block_statement (c_parser *parser, bool *if_p,
8577 : : location_t *loc_after_labels)
8578 : : {
8579 : 509502 : tree block = c_begin_compound_stmt (flag_isoc99);
8580 : 509502 : location_t loc = c_parser_peek_token (parser)->location;
8581 : 509502 : c_parser_statement (parser, if_p, loc_after_labels);
8582 : 509502 : return c_end_compound_stmt (loc, block, flag_isoc99);
8583 : : }
8584 : :
8585 : : /* Parse the body of an if statement. This is just parsing a
8586 : : statement but (a) it is a block in C99, (b) we track whether the
8587 : : body is an if statement for the sake of -Wparentheses warnings, (c)
8588 : : we handle an empty body specially for the sake of -Wempty-body
8589 : : warnings, and (d) we call parser_compound_statement directly
8590 : : because c_parser_statement_after_labels resets
8591 : : parser->in_if_block.
8592 : :
8593 : : IF_P is used to track whether there's a (possibly labeled) if statement
8594 : : which is not enclosed in braces and has an else clause. This is used to
8595 : : implement -Wparentheses. */
8596 : :
8597 : : static tree
8598 : 1247693 : c_parser_if_body (c_parser *parser, bool *if_p,
8599 : : const token_indent_info &if_tinfo)
8600 : : {
8601 : 1247693 : tree block = c_begin_compound_stmt (flag_isoc99);
8602 : 1247693 : location_t body_loc = c_parser_peek_token (parser)->location;
8603 : 1247693 : location_t body_loc_after_labels = UNKNOWN_LOCATION;
8604 : 1247693 : token_indent_info body_tinfo
8605 : 1247693 : = get_token_indent_info (c_parser_peek_token (parser));
8606 : 1247693 : tree before_labels = get_before_labels ();
8607 : 1247693 : attr_state a = c_parser_all_labels (parser);
8608 : :
8609 : 1247693 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
8610 : : {
8611 : 6642 : location_t loc = c_parser_peek_token (parser)->location;
8612 : 6642 : add_stmt (build_empty_stmt (loc));
8613 : 6642 : c_parser_consume_token (parser);
8614 : 6642 : if (!c_parser_next_token_is_keyword (parser, RID_ELSE))
8615 : 459 : warning_at (loc, OPT_Wempty_body,
8616 : : "suggest braces around empty body in an %<if%> statement");
8617 : : }
8618 : 1241051 : else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
8619 : 442261 : add_stmt (c_parser_compound_statement (parser));
8620 : : else
8621 : : {
8622 : 798790 : body_loc_after_labels = c_parser_peek_token (parser)->location;
8623 : 798790 : c_parser_statement_after_labels (parser, if_p, before_labels, NULL, a);
8624 : : }
8625 : :
8626 : 1247693 : token_indent_info next_tinfo
8627 : 1247693 : = get_token_indent_info (c_parser_peek_token (parser));
8628 : 1247693 : warn_for_misleading_indentation (if_tinfo, body_tinfo, next_tinfo);
8629 : 1247693 : if (body_loc_after_labels != UNKNOWN_LOCATION
8630 : 798790 : && next_tinfo.type != CPP_SEMICOLON)
8631 : 794214 : warn_for_multistatement_macros (body_loc_after_labels, next_tinfo.location,
8632 : 794214 : if_tinfo.location, RID_IF);
8633 : :
8634 : 1247693 : return c_end_compound_stmt (body_loc, block, flag_isoc99);
8635 : : }
8636 : :
8637 : : /* Parse the else body of an if statement. This is just parsing a
8638 : : statement but (a) it is a block in C99, (b) we handle an empty body
8639 : : specially for the sake of -Wempty-body warnings. CHAIN is a vector
8640 : : of if-else-if conditions. */
8641 : :
8642 : : static tree
8643 : 252399 : c_parser_else_body (c_parser *parser, const token_indent_info &else_tinfo,
8644 : : vec<tree> *chain)
8645 : : {
8646 : 252399 : location_t body_loc = c_parser_peek_token (parser)->location;
8647 : 252399 : tree block = c_begin_compound_stmt (flag_isoc99);
8648 : 252399 : token_indent_info body_tinfo
8649 : 252399 : = get_token_indent_info (c_parser_peek_token (parser));
8650 : 252399 : location_t body_loc_after_labels = UNKNOWN_LOCATION;
8651 : 252399 : tree before_labels = get_before_labels ();
8652 : 252399 : attr_state a = c_parser_all_labels (parser);
8653 : :
8654 : 252399 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
8655 : : {
8656 : 29 : location_t loc = c_parser_peek_token (parser)->location;
8657 : 29 : warning_at (loc,
8658 : 29 : OPT_Wempty_body,
8659 : : "suggest braces around empty body in an %<else%> statement");
8660 : 29 : add_stmt (build_empty_stmt (loc));
8661 : 29 : c_parser_consume_token (parser);
8662 : : }
8663 : : else
8664 : : {
8665 : 252370 : if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE))
8666 : 216785 : body_loc_after_labels = c_parser_peek_token (parser)->location;
8667 : 252370 : c_parser_statement_after_labels (parser, NULL, before_labels, chain, a);
8668 : : }
8669 : :
8670 : 252399 : token_indent_info next_tinfo
8671 : 252399 : = get_token_indent_info (c_parser_peek_token (parser));
8672 : 252399 : warn_for_misleading_indentation (else_tinfo, body_tinfo, next_tinfo);
8673 : 252399 : if (body_loc_after_labels != UNKNOWN_LOCATION
8674 : 216785 : && next_tinfo.type != CPP_SEMICOLON)
8675 : 216771 : warn_for_multistatement_macros (body_loc_after_labels, next_tinfo.location,
8676 : 216771 : else_tinfo.location, RID_ELSE);
8677 : :
8678 : 252399 : return c_end_compound_stmt (body_loc, block, flag_isoc99);
8679 : : }
8680 : :
8681 : : /* Parse an if statement (C90 6.6.4, C99 6.8.4, C11 6.8.4).
8682 : :
8683 : : if-statement:
8684 : : if ( selection-header ) statement
8685 : : if ( selection-header ) statement else statement
8686 : :
8687 : : CHAIN is a vector of if-else-if conditions.
8688 : : IF_P is used to track whether there's a (possibly labeled) if statement
8689 : : which is not enclosed in braces and has an else clause. This is used to
8690 : : implement -Wparentheses. */
8691 : :
8692 : : static void
8693 : 1247693 : c_parser_if_statement (c_parser *parser, bool *if_p, vec<tree> *chain)
8694 : : {
8695 : 1247693 : tree block;
8696 : 1247693 : location_t loc;
8697 : 1247693 : tree cond;
8698 : 1247693 : bool nested_if = false;
8699 : 1247693 : tree first_body, second_body;
8700 : 1247693 : bool in_if_block;
8701 : :
8702 : 1247693 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF));
8703 : 1247693 : token_indent_info if_tinfo
8704 : 1247693 : = get_token_indent_info (c_parser_peek_token (parser));
8705 : 1247693 : c_parser_consume_token (parser);
8706 : 1247693 : block = c_begin_compound_stmt (flag_isoc99);
8707 : 1247693 : loc = c_parser_peek_token (parser)->location;
8708 : 1247693 : cond = c_parser_paren_selection_header (parser);
8709 : 1247693 : in_if_block = parser->in_if_block;
8710 : 1247693 : parser->in_if_block = true;
8711 : 1247693 : first_body = c_parser_if_body (parser, &nested_if, if_tinfo);
8712 : 1247693 : parser->in_if_block = in_if_block;
8713 : :
8714 : 1247693 : if (warn_duplicated_cond)
8715 : 62 : warn_duplicated_cond_add_or_warn (EXPR_LOCATION (cond), cond, &chain);
8716 : :
8717 : 1247693 : if (c_parser_next_token_is_keyword (parser, RID_ELSE))
8718 : : {
8719 : 252399 : token_indent_info else_tinfo
8720 : 252399 : = get_token_indent_info (c_parser_peek_token (parser));
8721 : 252399 : c_parser_consume_token (parser);
8722 : 252399 : if (warn_duplicated_cond)
8723 : : {
8724 : 43 : if (c_parser_next_token_is_keyword (parser, RID_IF)
8725 : 43 : && chain == NULL)
8726 : : {
8727 : : /* We've got "if (COND) else if (COND2)". Start the
8728 : : condition chain and add COND as the first element. */
8729 : 18 : chain = new vec<tree> ();
8730 : 18 : if (!CONSTANT_CLASS_P (cond) && !TREE_SIDE_EFFECTS (cond))
8731 : 12 : chain->safe_push (cond);
8732 : : }
8733 : 25 : else if (!c_parser_next_token_is_keyword (parser, RID_IF))
8734 : : /* This is if-else without subsequent if. Zap the condition
8735 : : chain; we would have already warned at this point. */
8736 : 4 : vec_free (chain);
8737 : : }
8738 : 252399 : second_body = c_parser_else_body (parser, else_tinfo, chain);
8739 : : /* Set IF_P to true to indicate that this if statement has an
8740 : : else clause. This may trigger the Wparentheses warning
8741 : : below when we get back up to the parent if statement. */
8742 : 252399 : if (if_p != NULL)
8743 : 188 : *if_p = true;
8744 : : }
8745 : : else
8746 : : {
8747 : 995294 : second_body = NULL_TREE;
8748 : :
8749 : : /* Diagnose an ambiguous else if if-then-else is nested inside
8750 : : if-then. */
8751 : 995294 : if (nested_if)
8752 : 142 : warning_at (loc, OPT_Wdangling_else,
8753 : : "suggest explicit braces to avoid ambiguous %<else%>");
8754 : :
8755 : 995294 : if (warn_duplicated_cond)
8756 : : /* This if statement does not have an else clause. We don't
8757 : : need the condition chain anymore. */
8758 : 19 : vec_free (chain);
8759 : : }
8760 : 1247693 : c_finish_if_stmt (loc, cond, first_body, second_body);
8761 : 1247693 : add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
8762 : :
8763 : 1247693 : c_parser_maybe_reclassify_token (parser);
8764 : 1247693 : }
8765 : :
8766 : : /* Parse a switch statement (C90 6.6.4, C99 6.8.4, C11 6.8.4).
8767 : :
8768 : : switch-statement:
8769 : : switch (expression) statement
8770 : :
8771 : : BEFORE_LABELS is last statement before possible labels, see
8772 : : get_before_labels description for details. */
8773 : :
8774 : : static void
8775 : 36597 : c_parser_switch_statement (c_parser *parser, bool *if_p, tree before_labels)
8776 : : {
8777 : 36597 : struct c_expr ce;
8778 : 36597 : tree block, expr, body;
8779 : 36597 : unsigned char save_in_statement;
8780 : 36597 : location_t switch_loc = c_parser_peek_token (parser)->location;
8781 : 36597 : location_t switch_cond_loc;
8782 : 36597 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH));
8783 : 36597 : c_parser_consume_token (parser);
8784 : 36597 : tree switch_name;
8785 : 36597 : int num_names = c_get_loop_names (before_labels, true, &switch_name);
8786 : 36597 : block = c_begin_compound_stmt (flag_isoc99);
8787 : 36597 : bool explicit_cast_p = false;
8788 : 36597 : matching_parens parens;
8789 : 36597 : if (parens.require_open (parser))
8790 : : {
8791 : 36590 : switch_cond_loc = c_parser_peek_token (parser)->location;
8792 : 36590 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
8793 : 36590 : && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
8794 : : explicit_cast_p = true;
8795 : 36590 : ce = c_parser_selection_header (parser, /*switch_p=*/true);
8796 : : /* The call above already performed convert_lvalue_to_rvalue, but
8797 : : if it parsed an expression, read_p was false. Make sure we mark
8798 : : the expression as read. */
8799 : 36590 : ce = convert_lvalue_to_rvalue (switch_cond_loc, ce, true, true);
8800 : 36590 : expr = ce.value;
8801 : : /* ??? expr has no valid location? */
8802 : 36590 : parens.skip_until_found_close (parser);
8803 : : }
8804 : : else
8805 : : {
8806 : 7 : switch_cond_loc = UNKNOWN_LOCATION;
8807 : 7 : expr = error_mark_node;
8808 : 7 : ce.original_type = error_mark_node;
8809 : : }
8810 : 36597 : tree stmt
8811 : 36597 : = c_start_switch (switch_loc, switch_cond_loc, expr, explicit_cast_p,
8812 : : switch_name);
8813 : 36597 : save_in_statement = in_statement;
8814 : 36597 : in_statement |= IN_SWITCH_STMT;
8815 : 36597 : if (switch_name)
8816 : : {
8817 : 129 : C_DECL_LOOP_SWITCH_NAME_VALID (switch_name) = 1;
8818 : 129 : in_statement |= IN_NAMED_STMT;
8819 : : }
8820 : : else
8821 : 36468 : in_statement &= ~IN_NAMED_STMT;
8822 : 36597 : location_t loc_after_labels;
8823 : 36597 : bool open_brace_p = c_parser_peek_token (parser)->type == CPP_OPEN_BRACE;
8824 : 36597 : body = c_parser_c99_block_statement (parser, if_p, &loc_after_labels);
8825 : 36597 : location_t next_loc = c_parser_peek_token (parser)->location;
8826 : 36597 : if (!open_brace_p && c_parser_peek_token (parser)->type != CPP_SEMICOLON)
8827 : 367 : warn_for_multistatement_macros (loc_after_labels, next_loc, switch_loc,
8828 : : RID_SWITCH);
8829 : 36597 : c_finish_switch (body, ce.original_type);
8830 : 36597 : in_statement = save_in_statement;
8831 : 36597 : if (num_names)
8832 : : {
8833 : 129 : if (!C_DECL_LOOP_SWITCH_NAME_USED (switch_name))
8834 : 117 : SWITCH_STMT_NAME (stmt) = NULL_TREE;
8835 : : else
8836 : 12 : SWITCH_STMT_NO_BREAK_P (stmt) = 0;
8837 : 129 : c_release_loop_names (num_names);
8838 : : }
8839 : 36597 : add_stmt (c_end_compound_stmt (switch_loc, block, flag_isoc99));
8840 : 36597 : c_parser_maybe_reclassify_token (parser);
8841 : 36597 : }
8842 : :
8843 : : /* Parse a while statement (C90 6.6.5, C99 6.8.5, C11 6.8.5).
8844 : :
8845 : : while-statement:
8846 : : while (expression) statement
8847 : :
8848 : : IF_P is used to track whether there's a (possibly labeled) if statement
8849 : : which is not enclosed in braces and has an else clause. This is used to
8850 : : implement -Wparentheses.
8851 : :
8852 : : BEFORE_LABELS is last statement before possible labels, see
8853 : : get_before_labels description for details. */
8854 : :
8855 : : static void
8856 : 43678 : c_parser_while_statement (c_parser *parser, bool ivdep, unsigned short unroll,
8857 : : bool novector, bool *if_p, tree before_labels)
8858 : : {
8859 : 43678 : tree block, cond, body;
8860 : 43678 : unsigned char save_in_statement;
8861 : 43678 : location_t loc;
8862 : 43678 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE));
8863 : 43678 : token_indent_info while_tinfo
8864 : 43678 : = get_token_indent_info (c_parser_peek_token (parser));
8865 : 43678 : tree loop_name;
8866 : 43678 : int num_names = c_get_loop_names (before_labels, false, &loop_name);
8867 : :
8868 : 43678 : if (parser->omp_for_parse_state)
8869 : : {
8870 : 1 : error_at (c_parser_peek_token (parser)->location,
8871 : : "loop not permitted in intervening code in OpenMP loop body");
8872 : 1 : parser->omp_for_parse_state->fail = true;
8873 : : }
8874 : :
8875 : 43678 : c_parser_consume_token (parser);
8876 : 43678 : block = c_begin_compound_stmt (flag_isoc99);
8877 : 43678 : loc = c_parser_peek_token (parser)->location;
8878 : 43678 : cond = c_parser_paren_condition (parser);
8879 : 43678 : if (ivdep && cond != error_mark_node)
8880 : 3 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
8881 : : build_int_cst (integer_type_node,
8882 : : annot_expr_ivdep_kind),
8883 : : integer_zero_node);
8884 : 43678 : if (unroll && cond != error_mark_node)
8885 : 6 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
8886 : : build_int_cst (integer_type_node,
8887 : : annot_expr_unroll_kind),
8888 : 6 : build_int_cst (integer_type_node, unroll));
8889 : 43678 : if (novector && cond != error_mark_node)
8890 : 6 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
8891 : : build_int_cst (integer_type_node,
8892 : : annot_expr_no_vector_kind),
8893 : : integer_zero_node);
8894 : 43678 : save_in_statement = in_statement;
8895 : 43678 : in_statement = IN_ITERATION_STMT;
8896 : 43678 : if (loop_name)
8897 : : {
8898 : 135 : C_DECL_LOOP_SWITCH_NAME_VALID (loop_name) = 1;
8899 : 135 : in_statement |= IN_NAMED_STMT;
8900 : : }
8901 : :
8902 : 43678 : token_indent_info body_tinfo
8903 : 43678 : = get_token_indent_info (c_parser_peek_token (parser));
8904 : :
8905 : 43678 : location_t loc_after_labels;
8906 : 43678 : bool open_brace = c_parser_next_token_is (parser, CPP_OPEN_BRACE);
8907 : 43678 : body = c_parser_c99_block_statement (parser, if_p, &loc_after_labels);
8908 : 43678 : if (loop_name && !C_DECL_LOOP_SWITCH_NAME_USED (loop_name))
8909 : 133 : loop_name = NULL_TREE;
8910 : 43678 : add_stmt (build_stmt (loc, WHILE_STMT, cond, body, loop_name, NULL_TREE,
8911 : : NULL_TREE));
8912 : 43678 : add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
8913 : 43678 : c_parser_maybe_reclassify_token (parser);
8914 : 43678 : if (num_names)
8915 : 135 : c_release_loop_names (num_names);
8916 : :
8917 : 43678 : token_indent_info next_tinfo
8918 : 43678 : = get_token_indent_info (c_parser_peek_token (parser));
8919 : 43678 : warn_for_misleading_indentation (while_tinfo, body_tinfo, next_tinfo);
8920 : :
8921 : 43678 : if (next_tinfo.type != CPP_SEMICOLON && !open_brace)
8922 : 10439 : warn_for_multistatement_macros (loc_after_labels, next_tinfo.location,
8923 : : while_tinfo.location, RID_WHILE);
8924 : :
8925 : 43678 : in_statement = save_in_statement;
8926 : 43678 : }
8927 : :
8928 : : /* Parse a do statement (C90 6.6.5, C99 6.8.5, C11 6.8.5).
8929 : :
8930 : : do-statement:
8931 : : do statement while ( expression ) ;
8932 : :
8933 : : BEFORE_LABELS is last statement before possible labels, see
8934 : : get_before_labels description for details. */
8935 : :
8936 : : static void
8937 : 144621 : c_parser_do_statement (c_parser *parser, bool ivdep, unsigned short unroll,
8938 : : bool novector, tree before_labels)
8939 : : {
8940 : 144621 : tree block, cond, body;
8941 : 144621 : unsigned char save_in_statement;
8942 : 144621 : location_t loc;
8943 : 144621 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO));
8944 : 144621 : tree loop_name;
8945 : 144621 : int num_names = c_get_loop_names (before_labels, false, &loop_name);
8946 : :
8947 : 144621 : if (parser->omp_for_parse_state)
8948 : : {
8949 : 1 : error_at (c_parser_peek_token (parser)->location,
8950 : : "loop not permitted in intervening code in OpenMP loop body");
8951 : 1 : parser->omp_for_parse_state->fail = true;
8952 : : }
8953 : :
8954 : 144621 : c_parser_consume_token (parser);
8955 : 144621 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
8956 : 50 : warning_at (c_parser_peek_token (parser)->location,
8957 : 50 : OPT_Wempty_body,
8958 : : "suggest braces around empty body in %<do%> statement");
8959 : 144621 : block = c_begin_compound_stmt (flag_isoc99);
8960 : 144621 : loc = c_parser_peek_token (parser)->location;
8961 : 144621 : save_in_statement = in_statement;
8962 : 144621 : in_statement = IN_ITERATION_STMT;
8963 : 144621 : if (loop_name)
8964 : : {
8965 : 183 : C_DECL_LOOP_SWITCH_NAME_VALID (loop_name) = 1;
8966 : 183 : in_statement |= IN_NAMED_STMT;
8967 : : }
8968 : 144621 : body = c_parser_c99_block_statement (parser, NULL);
8969 : 144621 : c_parser_require_keyword (parser, RID_WHILE, "expected %<while%>");
8970 : 144621 : in_statement = save_in_statement;
8971 : 144621 : if (num_names)
8972 : : {
8973 : 183 : if (!C_DECL_LOOP_SWITCH_NAME_USED (loop_name))
8974 : 181 : loop_name = NULL_TREE;
8975 : 183 : c_release_loop_names (num_names);
8976 : : }
8977 : 144621 : cond = c_parser_paren_condition (parser);
8978 : 144621 : if (ivdep && cond != error_mark_node)
8979 : 2 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
8980 : : build_int_cst (integer_type_node,
8981 : : annot_expr_ivdep_kind),
8982 : : integer_zero_node);
8983 : 144621 : if (unroll && cond != error_mark_node)
8984 : 3 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
8985 : : build_int_cst (integer_type_node,
8986 : : annot_expr_unroll_kind),
8987 : 3 : build_int_cst (integer_type_node, unroll));
8988 : 144621 : if (novector && cond != error_mark_node)
8989 : 54 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
8990 : : build_int_cst (integer_type_node,
8991 : : annot_expr_no_vector_kind),
8992 : : integer_zero_node);
8993 : 144621 : if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
8994 : 0 : c_parser_skip_to_end_of_block_or_statement (parser);
8995 : :
8996 : 144621 : add_stmt (build_stmt (loc, DO_STMT, cond, body, loop_name));
8997 : 144621 : add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
8998 : 144621 : }
8999 : :
9000 : : /* Parse a for statement (C90 6.6.5, C99 6.8.5, C11 6.8.5).
9001 : :
9002 : : for-statement:
9003 : : for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
9004 : : for ( nested-declaration expression[opt] ; expression[opt] ) statement
9005 : :
9006 : : The form with a declaration is new in C99.
9007 : :
9008 : : ??? In accordance with the old parser, the declaration may be a
9009 : : nested function, which is then rejected in check_for_loop_decls,
9010 : : but does it make any sense for this to be included in the grammar?
9011 : : Note in particular that the nested function does not include a
9012 : : trailing ';', whereas the "declaration" production includes one.
9013 : : Also, can we reject bad declarations earlier and cheaper than
9014 : : check_for_loop_decls?
9015 : :
9016 : : In Objective-C, there are two additional variants:
9017 : :
9018 : : foreach-statement:
9019 : : for ( expression in expresssion ) statement
9020 : : for ( declaration in expression ) statement
9021 : :
9022 : : This is inconsistent with C, because the second variant is allowed
9023 : : even if c99 is not enabled.
9024 : :
9025 : : The rest of the comment documents these Objective-C foreach-statement.
9026 : :
9027 : : Here is the canonical example of the first variant:
9028 : : for (object in array) { do something with object }
9029 : : we call the first expression ("object") the "object_expression" and
9030 : : the second expression ("array") the "collection_expression".
9031 : : object_expression must be an lvalue of type "id" (a generic Objective-C
9032 : : object) because the loop works by assigning to object_expression the
9033 : : various objects from the collection_expression. collection_expression
9034 : : must evaluate to something of type "id" which responds to the method
9035 : : countByEnumeratingWithState:objects:count:.
9036 : :
9037 : : The canonical example of the second variant is:
9038 : : for (id object in array) { do something with object }
9039 : : which is completely equivalent to
9040 : : {
9041 : : id object;
9042 : : for (object in array) { do something with object }
9043 : : }
9044 : : Note that initizializing 'object' in some way (eg, "for ((object =
9045 : : xxx) in array) { do something with object }") is possibly
9046 : : technically valid, but completely pointless as 'object' will be
9047 : : assigned to something else as soon as the loop starts. We should
9048 : : most likely reject it (TODO).
9049 : :
9050 : : The beginning of the Objective-C foreach-statement looks exactly
9051 : : like the beginning of the for-statement, and we can tell it is a
9052 : : foreach-statement only because the initial declaration or
9053 : : expression is terminated by 'in' instead of ';'.
9054 : :
9055 : : IF_P is used to track whether there's a (possibly labeled) if statement
9056 : : which is not enclosed in braces and has an else clause. This is used to
9057 : : implement -Wparentheses.
9058 : :
9059 : : BEFORE_LABELS is last statement before possible labels, see
9060 : : get_before_labels description for details. */
9061 : :
9062 : : static void
9063 : 273939 : c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
9064 : : bool novector, bool *if_p, tree before_labels)
9065 : : {
9066 : 273939 : tree block, cond, incr, body;
9067 : 273939 : unsigned char save_in_statement;
9068 : 273939 : tree save_objc_foreach_break_label, save_objc_foreach_continue_label;
9069 : : /* The following are only used when parsing an ObjC foreach statement. */
9070 : 273939 : tree object_expression;
9071 : : /* Silence the bogus uninitialized warning. */
9072 : 273939 : tree collection_expression = NULL;
9073 : 273939 : location_t loc = c_parser_peek_token (parser)->location;
9074 : 273939 : location_t for_loc = loc;
9075 : 273939 : bool is_foreach_statement = false;
9076 : 273939 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR));
9077 : 273939 : token_indent_info for_tinfo
9078 : 273939 : = get_token_indent_info (c_parser_peek_token (parser));
9079 : 273939 : tree loop_name;
9080 : 273939 : int num_names = c_get_loop_names (before_labels, false, &loop_name);
9081 : :
9082 : 273939 : if (parser->omp_for_parse_state)
9083 : : {
9084 : 13 : error_at (for_loc,
9085 : : "loop not permitted in intervening code in OpenMP loop body");
9086 : 13 : parser->omp_for_parse_state->fail = true;
9087 : : }
9088 : :
9089 : 273939 : c_parser_consume_token (parser);
9090 : : /* Open a compound statement in Objective-C as well, just in case this is
9091 : : as foreach expression. */
9092 : 546992 : block = c_begin_compound_stmt (flag_isoc99 || c_dialect_objc ());
9093 : 273939 : cond = error_mark_node;
9094 : 273939 : incr = error_mark_node;
9095 : 273939 : matching_parens parens;
9096 : 273939 : if (parens.require_open (parser))
9097 : : {
9098 : : /* Parse the initialization declaration or expression. */
9099 : 273938 : object_expression = error_mark_node;
9100 : 273938 : parser->objc_could_be_foreach_context = c_dialect_objc ();
9101 : 273938 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
9102 : : {
9103 : 12273 : parser->objc_could_be_foreach_context = false;
9104 : 12273 : c_parser_consume_token (parser);
9105 : 12273 : c_finish_expr_stmt (loc, NULL_TREE);
9106 : : }
9107 : 261665 : else if (c_parser_next_tokens_start_declaration (parser)
9108 : 261665 : || c_parser_nth_token_starts_std_attributes (parser, 1))
9109 : : {
9110 : 19985 : c_parser_declaration_or_fndef (parser, true, true, true, true, true,
9111 : : false, &object_expression);
9112 : 19985 : parser->objc_could_be_foreach_context = false;
9113 : :
9114 : 19985 : if (c_parser_next_token_is_keyword (parser, RID_IN))
9115 : : {
9116 : 0 : c_parser_consume_token (parser);
9117 : 0 : is_foreach_statement = true;
9118 : 0 : if (check_for_loop_decls (for_loc, true) == NULL_TREE)
9119 : 0 : c_parser_error (parser, "multiple iterating variables in "
9120 : : "fast enumeration");
9121 : : }
9122 : : else
9123 : 19985 : check_for_loop_decls (for_loc, flag_isoc99);
9124 : : }
9125 : 241680 : else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
9126 : : {
9127 : : /* __extension__ can start a declaration, but is also an
9128 : : unary operator that can start an expression. Consume all
9129 : : but the last of a possible series of __extension__ to
9130 : : determine which. */
9131 : 0 : while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
9132 : 0 : && (c_parser_peek_2nd_token (parser)->keyword
9133 : : == RID_EXTENSION))
9134 : 0 : c_parser_consume_token (parser);
9135 : 0 : if (c_token_starts_declaration (c_parser_peek_2nd_token (parser))
9136 : 0 : || c_parser_nth_token_starts_std_attributes (parser, 2))
9137 : : {
9138 : 0 : int ext;
9139 : 0 : ext = disable_extension_diagnostics ();
9140 : 0 : c_parser_consume_token (parser);
9141 : 0 : c_parser_declaration_or_fndef (parser, true, true, true, true,
9142 : : true, false, &object_expression);
9143 : 0 : parser->objc_could_be_foreach_context = false;
9144 : :
9145 : 0 : restore_extension_diagnostics (ext);
9146 : 0 : if (c_parser_next_token_is_keyword (parser, RID_IN))
9147 : : {
9148 : 0 : c_parser_consume_token (parser);
9149 : 0 : is_foreach_statement = true;
9150 : 0 : if (check_for_loop_decls (for_loc, true) == NULL_TREE)
9151 : 0 : c_parser_error (parser, "multiple iterating variables in "
9152 : : "fast enumeration");
9153 : : }
9154 : : else
9155 : 0 : check_for_loop_decls (for_loc, flag_isoc99);
9156 : : }
9157 : : else
9158 : 0 : goto init_expr;
9159 : : }
9160 : : else
9161 : : {
9162 : 241680 : init_expr:
9163 : 241680 : {
9164 : 241680 : struct c_expr ce;
9165 : 241680 : tree init_expression;
9166 : 241680 : ce = c_parser_expression (parser);
9167 : 241680 : init_expression = ce.value;
9168 : 241680 : parser->objc_could_be_foreach_context = false;
9169 : 241680 : if (c_parser_next_token_is_keyword (parser, RID_IN))
9170 : : {
9171 : 0 : c_parser_consume_token (parser);
9172 : 0 : is_foreach_statement = true;
9173 : 0 : if (! lvalue_p (init_expression))
9174 : 0 : c_parser_error (parser, "invalid iterating variable in "
9175 : : "fast enumeration");
9176 : 0 : object_expression
9177 : 0 : = c_fully_fold (init_expression, false, NULL);
9178 : : }
9179 : : else
9180 : : {
9181 : 241680 : ce = convert_lvalue_to_rvalue (loc, ce, true, false);
9182 : 241680 : init_expression = ce.value;
9183 : 241680 : c_finish_expr_stmt (loc, init_expression);
9184 : 241680 : c_parser_skip_until_found (parser, CPP_SEMICOLON,
9185 : : "expected %<;%>");
9186 : : }
9187 : : }
9188 : : }
9189 : : /* Parse the loop condition. In the case of a foreach
9190 : : statement, there is no loop condition. */
9191 : 273938 : gcc_assert (!parser->objc_could_be_foreach_context);
9192 : 273938 : if (!is_foreach_statement)
9193 : : {
9194 : 273938 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
9195 : : {
9196 : 3031 : if (ivdep)
9197 : : {
9198 : 1 : c_parser_error (parser, "missing loop condition in loop "
9199 : : "with %<GCC ivdep%> pragma");
9200 : 1 : cond = error_mark_node;
9201 : : }
9202 : 3030 : else if (unroll)
9203 : : {
9204 : 0 : c_parser_error (parser, "missing loop condition in loop "
9205 : : "with %<GCC unroll%> pragma");
9206 : 0 : cond = error_mark_node;
9207 : : }
9208 : : else
9209 : : {
9210 : 3030 : c_parser_consume_token (parser);
9211 : 3030 : cond = NULL_TREE;
9212 : : }
9213 : : }
9214 : : else
9215 : : {
9216 : 270907 : cond = c_parser_condition (parser);
9217 : 270907 : c_parser_skip_until_found (parser, CPP_SEMICOLON,
9218 : : "expected %<;%>");
9219 : : }
9220 : 273938 : if (ivdep && cond != error_mark_node)
9221 : 122 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
9222 : : build_int_cst (integer_type_node,
9223 : : annot_expr_ivdep_kind),
9224 : : integer_zero_node);
9225 : 273938 : if (unroll && cond != error_mark_node)
9226 : 264 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
9227 : : build_int_cst (integer_type_node,
9228 : : annot_expr_unroll_kind),
9229 : 264 : build_int_cst (integer_type_node, unroll));
9230 : 273938 : if (novector && cond && cond != error_mark_node)
9231 : 2567 : cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
9232 : : build_int_cst (integer_type_node,
9233 : : annot_expr_no_vector_kind),
9234 : : integer_zero_node);
9235 : : }
9236 : : /* Parse the increment expression (the third expression in a
9237 : : for-statement). In the case of a foreach-statement, this is
9238 : : the expression that follows the 'in'. */
9239 : 273938 : loc = c_parser_peek_token (parser)->location;
9240 : 273938 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
9241 : : {
9242 : 4209 : if (is_foreach_statement)
9243 : : {
9244 : 0 : c_parser_error (parser,
9245 : : "missing collection in fast enumeration");
9246 : 0 : collection_expression = error_mark_node;
9247 : : }
9248 : : else
9249 : 4209 : incr = c_process_expr_stmt (loc, NULL_TREE);
9250 : : }
9251 : : else
9252 : : {
9253 : 269729 : if (is_foreach_statement)
9254 : 0 : collection_expression
9255 : 0 : = c_fully_fold (c_parser_expression (parser).value, false, NULL);
9256 : : else
9257 : : {
9258 : 269729 : struct c_expr ce = c_parser_expression (parser);
9259 : 269729 : ce = convert_lvalue_to_rvalue (loc, ce, true, false);
9260 : 269729 : incr = c_process_expr_stmt (loc, ce.value);
9261 : : }
9262 : : }
9263 : 273938 : parens.skip_until_found_close (parser);
9264 : : }
9265 : 273939 : save_in_statement = in_statement;
9266 : 273939 : if (is_foreach_statement)
9267 : : {
9268 : 0 : in_statement = IN_OBJC_FOREACH;
9269 : 0 : save_objc_foreach_break_label = objc_foreach_break_label;
9270 : 0 : save_objc_foreach_continue_label = objc_foreach_continue_label;
9271 : 0 : objc_foreach_break_label = create_artificial_label (loc);
9272 : 0 : objc_foreach_continue_label = create_artificial_label (loc);
9273 : 0 : if (loop_name)
9274 : : {
9275 : 0 : gcc_checking_assert (!DECL_CHAIN (loop_name)
9276 : : && !DECL_CHAIN (objc_foreach_break_label));
9277 : 0 : C_DECL_SWITCH_NAME (loop_name) = 1;
9278 : 0 : DECL_CHAIN (loop_name) = objc_foreach_break_label;
9279 : 0 : DECL_CHAIN (objc_foreach_break_label) = objc_foreach_continue_label;
9280 : : }
9281 : : }
9282 : : else
9283 : 273939 : in_statement = IN_ITERATION_STMT;
9284 : 273939 : if (loop_name)
9285 : : {
9286 : 452 : C_DECL_LOOP_SWITCH_NAME_VALID (loop_name) = 1;
9287 : 452 : in_statement |= IN_NAMED_STMT;
9288 : : }
9289 : :
9290 : 273939 : token_indent_info body_tinfo
9291 : 273939 : = get_token_indent_info (c_parser_peek_token (parser));
9292 : :
9293 : 273939 : location_t loc_after_labels;
9294 : 273939 : bool open_brace = c_parser_next_token_is (parser, CPP_OPEN_BRACE);
9295 : 273939 : body = c_parser_c99_block_statement (parser, if_p, &loc_after_labels);
9296 : :
9297 : 273939 : if (loop_name && is_foreach_statement)
9298 : : {
9299 : 0 : gcc_checking_assert (DECL_CHAIN (loop_name) == objc_foreach_break_label
9300 : : && (DECL_CHAIN (objc_foreach_break_label)
9301 : : == objc_foreach_continue_label));
9302 : 0 : C_DECL_SWITCH_NAME (loop_name) = 0;
9303 : 0 : DECL_CHAIN (loop_name) = NULL_TREE;
9304 : 0 : DECL_CHAIN (objc_foreach_break_label) = NULL_TREE;
9305 : : }
9306 : :
9307 : 273487 : if (is_foreach_statement)
9308 : 0 : objc_finish_foreach_loop (for_loc, object_expression,
9309 : : collection_expression, body,
9310 : : objc_foreach_break_label,
9311 : : objc_foreach_continue_label);
9312 : : else
9313 : 547878 : add_stmt (build_stmt (for_loc, FOR_STMT, NULL_TREE, cond, incr,
9314 : : body, NULL_TREE,
9315 : 452 : loop_name && C_DECL_LOOP_SWITCH_NAME_USED (loop_name)
9316 : : ? loop_name : NULL_TREE, NULL_TREE, NULL_TREE));
9317 : 273939 : add_stmt (c_end_compound_stmt (for_loc, block,
9318 : 273939 : flag_isoc99 || c_dialect_objc ()));
9319 : 273939 : c_parser_maybe_reclassify_token (parser);
9320 : :
9321 : 273939 : token_indent_info next_tinfo
9322 : 273939 : = get_token_indent_info (c_parser_peek_token (parser));
9323 : 273939 : warn_for_misleading_indentation (for_tinfo, body_tinfo, next_tinfo);
9324 : :
9325 : 273939 : if (next_tinfo.type != CPP_SEMICOLON && !open_brace)
9326 : 161305 : warn_for_multistatement_macros (loc_after_labels, next_tinfo.location,
9327 : : for_tinfo.location, RID_FOR);
9328 : :
9329 : 273939 : in_statement = save_in_statement;
9330 : 273939 : if (num_names)
9331 : 452 : c_release_loop_names (num_names);
9332 : 273939 : if (is_foreach_statement)
9333 : : {
9334 : 0 : objc_foreach_break_label = save_objc_foreach_break_label;
9335 : 0 : objc_foreach_continue_label = save_objc_foreach_continue_label;
9336 : : }
9337 : 273939 : }
9338 : :
9339 : : /* Parse an asm statement, a GNU extension. This is a full-blown asm
9340 : : statement with inputs, outputs, clobbers, and volatile, inline, and goto
9341 : : tags allowed.
9342 : :
9343 : : asm-qualifier:
9344 : : volatile
9345 : : inline
9346 : : goto
9347 : :
9348 : : asm-qualifier-list:
9349 : : asm-qualifier-list asm-qualifier
9350 : : asm-qualifier
9351 : :
9352 : : asm-statement:
9353 : : asm asm-qualifier-list[opt] ( asm-argument ) ;
9354 : :
9355 : : asm-argument:
9356 : : asm-string-literal
9357 : : asm-string-literal : asm-operands[opt]
9358 : : asm-string-literal : asm-operands[opt] : asm-operands[opt]
9359 : : asm-string-literal : asm-operands[opt] : asm-operands[opt] \
9360 : : : asm-clobbers[opt]
9361 : : asm-string-literal : : asm-operands[opt] : asm-clobbers[opt] \
9362 : : : asm-goto-operands
9363 : :
9364 : : The form with asm-goto-operands is valid if and only if the
9365 : : asm-qualifier-list contains goto, and is the only allowed form in that case.
9366 : : Duplicate asm-qualifiers are not allowed.
9367 : :
9368 : : The :: token is considered equivalent to two consecutive : tokens. */
9369 : :
9370 : : static tree
9371 : 200484 : c_parser_asm_statement (c_parser *parser)
9372 : : {
9373 : 200484 : tree str, outputs, inputs, clobbers, labels, ret;
9374 : 200484 : bool simple;
9375 : 200484 : location_t asm_loc = c_parser_peek_token (parser)->location;
9376 : 200484 : int section, nsections;
9377 : :
9378 : 200484 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
9379 : 200484 : c_parser_consume_token (parser);
9380 : :
9381 : : /* Handle the asm-qualifier-list. */
9382 : 200484 : location_t volatile_loc = UNKNOWN_LOCATION;
9383 : 200484 : location_t inline_loc = UNKNOWN_LOCATION;
9384 : 200484 : location_t goto_loc = UNKNOWN_LOCATION;
9385 : 361783 : for (;;)
9386 : : {
9387 : 361783 : c_token *token = c_parser_peek_token (parser);
9388 : 361783 : location_t loc = token->location;
9389 : 361783 : switch (token->keyword)
9390 : : {
9391 : 160834 : case RID_VOLATILE:
9392 : 160834 : if (volatile_loc)
9393 : : {
9394 : 6 : error_at (loc, "duplicate %<asm%> qualifier %qE", token->value);
9395 : 6 : inform (volatile_loc, "first seen here");
9396 : : }
9397 : : else
9398 : : volatile_loc = loc;
9399 : 160834 : c_parser_consume_token (parser);
9400 : 160834 : continue;
9401 : :
9402 : 38 : case RID_INLINE:
9403 : 38 : if (inline_loc)
9404 : : {
9405 : 6 : error_at (loc, "duplicate %<asm%> qualifier %qE", token->value);
9406 : 6 : inform (inline_loc, "first seen here");
9407 : : }
9408 : : else
9409 : : inline_loc = loc;
9410 : 38 : c_parser_consume_token (parser);
9411 : 38 : continue;
9412 : :
9413 : 425 : case RID_GOTO:
9414 : 425 : if (goto_loc)
9415 : : {
9416 : 6 : error_at (loc, "duplicate %<asm%> qualifier %qE", token->value);
9417 : 6 : inform (goto_loc, "first seen here");
9418 : : }
9419 : : else
9420 : : goto_loc = loc;
9421 : 425 : c_parser_consume_token (parser);
9422 : 425 : continue;
9423 : :
9424 : 2 : case RID_CONST:
9425 : 2 : case RID_RESTRICT:
9426 : 2 : error_at (loc, "%qE is not a valid %<asm%> qualifier", token->value);
9427 : 2 : c_parser_consume_token (parser);
9428 : 2 : continue;
9429 : :
9430 : 200484 : default:
9431 : 200484 : break;
9432 : : }
9433 : 200484 : break;
9434 : : }
9435 : :
9436 : 200484 : bool is_volatile = (volatile_loc != UNKNOWN_LOCATION);
9437 : 200484 : bool is_inline = (inline_loc != UNKNOWN_LOCATION);
9438 : 200484 : bool is_goto = (goto_loc != UNKNOWN_LOCATION);
9439 : :
9440 : 200484 : ret = NULL;
9441 : :
9442 : 200484 : matching_parens parens;
9443 : 200484 : if (!parens.require_open (parser))
9444 : 0 : goto error;
9445 : :
9446 : 200484 : str = c_parser_asm_string_literal (parser);
9447 : 200484 : if (str == NULL_TREE)
9448 : 12 : goto error_close_paren;
9449 : :
9450 : 200472 : simple = true;
9451 : 200472 : outputs = NULL_TREE;
9452 : 200472 : inputs = NULL_TREE;
9453 : 200472 : clobbers = NULL_TREE;
9454 : 200472 : labels = NULL_TREE;
9455 : :
9456 : 200472 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN) && !is_goto)
9457 : 1830 : goto done_asm;
9458 : :
9459 : : /* Parse each colon-delimited section of operands. */
9460 : 198642 : nsections = 3 + is_goto;
9461 : 508264 : for (section = 0; section < nsections; ++section)
9462 : : {
9463 : 507855 : if (c_parser_next_token_is (parser, CPP_SCOPE))
9464 : : {
9465 : 35125 : ++section;
9466 : 35125 : if (section == nsections)
9467 : : {
9468 : 5 : c_parser_error (parser, "expected %<)%>");
9469 : 5 : goto error_close_paren;
9470 : : }
9471 : 35120 : c_parser_consume_token (parser);
9472 : : }
9473 : 944008 : else if (!c_parser_require (parser, CPP_COLON,
9474 : : is_goto
9475 : : ? G_("expected %<:%>")
9476 : : : G_("expected %<:%> or %<)%>"),
9477 : : UNKNOWN_LOCATION, is_goto))
9478 : 7 : goto error_close_paren;
9479 : :
9480 : : /* Once past any colon, we're no longer a simple asm. */
9481 : 507843 : simple = false;
9482 : :
9483 : 507843 : if ((!c_parser_next_token_is (parser, CPP_COLON)
9484 : 411549 : && !c_parser_next_token_is (parser, CPP_SCOPE)
9485 : 411500 : && !c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
9486 : 512718 : || section == 3)
9487 : 406675 : switch (section)
9488 : : {
9489 : 128598 : case 0:
9490 : 128598 : outputs = c_parser_asm_operands (parser);
9491 : 128598 : break;
9492 : 128010 : case 1:
9493 : 128010 : inputs = c_parser_asm_operands (parser);
9494 : 128010 : break;
9495 : 149658 : case 2:
9496 : 149658 : clobbers = c_parser_asm_clobbers (parser);
9497 : 149658 : break;
9498 : 409 : case 3:
9499 : 409 : labels = c_parser_asm_goto_operands (parser);
9500 : 409 : break;
9501 : 0 : default:
9502 : 0 : gcc_unreachable ();
9503 : : }
9504 : :
9505 : 507843 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN) && !is_goto)
9506 : 198221 : goto done_asm;
9507 : : }
9508 : :
9509 : 409 : done_asm:
9510 : 200460 : if (!parens.require_close (parser))
9511 : : {
9512 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
9513 : 0 : goto error;
9514 : : }
9515 : :
9516 : 200460 : if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
9517 : 0 : c_parser_skip_to_end_of_block_or_statement (parser);
9518 : :
9519 : 200460 : ret = build_asm_stmt (is_volatile,
9520 : : build_asm_expr (asm_loc, str, outputs, inputs,
9521 : : clobbers, labels, simple, is_inline));
9522 : :
9523 : 200484 : error:
9524 : 200484 : return ret;
9525 : :
9526 : 24 : error_close_paren:
9527 : 24 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
9528 : 24 : goto error;
9529 : : }
9530 : :
9531 : : /* Parse asm operands, a GNU extension.
9532 : :
9533 : : asm-operands:
9534 : : asm-operand
9535 : : asm-operands , asm-operand
9536 : :
9537 : : asm-operand:
9538 : : asm-string-literal ( expression )
9539 : : [ identifier ] asm-string-literal ( expression )
9540 : : */
9541 : :
9542 : : static tree
9543 : 256641 : c_parser_asm_operands (c_parser *parser)
9544 : : {
9545 : 256641 : tree list = NULL_TREE;
9546 : 1128959 : while (true)
9547 : : {
9548 : 692800 : tree name, str;
9549 : 692800 : struct c_expr expr;
9550 : 692800 : if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
9551 : : {
9552 : 472 : c_parser_consume_token (parser);
9553 : 472 : if (c_parser_next_token_is (parser, CPP_NAME))
9554 : : {
9555 : 472 : tree id = c_parser_peek_token (parser)->value;
9556 : 472 : c_parser_consume_token (parser);
9557 : 472 : name = build_string (IDENTIFIER_LENGTH (id),
9558 : 472 : IDENTIFIER_POINTER (id));
9559 : : }
9560 : : else
9561 : : {
9562 : 0 : c_parser_error (parser, "expected identifier");
9563 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
9564 : 0 : return NULL_TREE;
9565 : : }
9566 : 472 : c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
9567 : : "expected %<]%>");
9568 : : }
9569 : : else
9570 : : name = NULL_TREE;
9571 : 692800 : str = c_parser_asm_string_literal (parser);
9572 : 692800 : if (str == NULL_TREE)
9573 : : return NULL_TREE;
9574 : 692800 : matching_parens parens;
9575 : 692800 : if (!parens.require_open (parser))
9576 : : return NULL_TREE;
9577 : 692800 : expr = c_parser_expression (parser);
9578 : 692800 : mark_exp_read (expr.value);
9579 : 692800 : if (!parens.require_close (parser))
9580 : : {
9581 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
9582 : 0 : return NULL_TREE;
9583 : : }
9584 : 692800 : list = chainon (list, build_tree_list (build_tree_list (name, str),
9585 : : expr.value));
9586 : 692800 : if (c_parser_next_token_is (parser, CPP_COMMA))
9587 : 436159 : c_parser_consume_token (parser);
9588 : : else
9589 : : break;
9590 : 436159 : }
9591 : 256641 : return list;
9592 : : }
9593 : :
9594 : : /* Parse asm clobbers, a GNU extension.
9595 : :
9596 : : asm-clobbers:
9597 : : asm-string-literal
9598 : : asm-clobbers , asm-string-literal
9599 : : */
9600 : :
9601 : : static tree
9602 : 149658 : c_parser_asm_clobbers (c_parser *parser)
9603 : : {
9604 : 149658 : tree list = NULL_TREE;
9605 : 203660 : while (true)
9606 : : {
9607 : 176659 : tree str = c_parser_asm_string_literal (parser);
9608 : 176659 : if (str)
9609 : 176659 : list = tree_cons (NULL_TREE, str, list);
9610 : : else
9611 : : return NULL_TREE;
9612 : 176659 : if (c_parser_next_token_is (parser, CPP_COMMA))
9613 : 27001 : c_parser_consume_token (parser);
9614 : : else
9615 : : break;
9616 : 27001 : }
9617 : : return list;
9618 : : }
9619 : :
9620 : : /* Parse asm goto labels, a GNU extension.
9621 : :
9622 : : asm-goto-operands:
9623 : : identifier
9624 : : asm-goto-operands , identifier
9625 : : */
9626 : :
9627 : : static tree
9628 : 409 : c_parser_asm_goto_operands (c_parser *parser)
9629 : : {
9630 : 409 : tree list = NULL_TREE;
9631 : 993 : while (true)
9632 : : {
9633 : 701 : tree name, label;
9634 : :
9635 : 701 : if (c_parser_next_token_is (parser, CPP_NAME))
9636 : : {
9637 : 700 : c_token *tok = c_parser_peek_token (parser);
9638 : 700 : name = tok->value;
9639 : 700 : label = lookup_label_for_goto (tok->location, name);
9640 : 700 : c_parser_consume_token (parser);
9641 : 700 : TREE_USED (label) = 1;
9642 : : }
9643 : : else
9644 : : {
9645 : 1 : c_parser_error (parser, "expected identifier");
9646 : 1 : return NULL_TREE;
9647 : : }
9648 : :
9649 : 700 : name = build_string (IDENTIFIER_LENGTH (name),
9650 : 700 : IDENTIFIER_POINTER (name));
9651 : 700 : list = tree_cons (name, label, list);
9652 : 700 : if (c_parser_next_token_is (parser, CPP_COMMA))
9653 : 292 : c_parser_consume_token (parser);
9654 : : else
9655 : 408 : return nreverse (list);
9656 : 292 : }
9657 : : }
9658 : :
9659 : : /* Parse a possibly concatenated sequence of string literals.
9660 : : TRANSLATE says whether to translate them to the execution character
9661 : : set; WIDE_OK says whether any kind of prefixed string literal is
9662 : : permitted in this context. This code is based on that in
9663 : : lex_string. */
9664 : :
9665 : : struct c_expr
9666 : 3722798 : c_parser_string_literal (c_parser *parser, bool translate, bool wide_ok)
9667 : : {
9668 : 3722798 : struct c_expr ret;
9669 : 3722798 : size_t count;
9670 : 3722798 : struct obstack str_ob;
9671 : 3722798 : struct obstack loc_ob;
9672 : 3722798 : cpp_string str, istr, *strs;
9673 : 3722798 : c_token *tok;
9674 : 3722798 : location_t loc, last_tok_loc;
9675 : 3722798 : enum cpp_ttype type;
9676 : 3722798 : tree value, string_tree;
9677 : :
9678 : 3722798 : tok = c_parser_peek_token (parser);
9679 : 3722798 : loc = tok->location;
9680 : 3722798 : last_tok_loc = linemap_resolve_location (line_table, loc,
9681 : : LRK_MACRO_DEFINITION_LOCATION,
9682 : : NULL);
9683 : 3722798 : type = tok->type;
9684 : 3722798 : switch (type)
9685 : : {
9686 : 3722781 : case CPP_STRING:
9687 : 3722781 : case CPP_WSTRING:
9688 : 3722781 : case CPP_STRING16:
9689 : 3722781 : case CPP_STRING32:
9690 : 3722781 : case CPP_UTF8STRING:
9691 : 3722781 : string_tree = tok->value;
9692 : 3722781 : break;
9693 : :
9694 : 17 : default:
9695 : 17 : c_parser_error (parser, "expected string literal");
9696 : 17 : ret.set_error ();
9697 : 17 : ret.value = NULL_TREE;
9698 : 17 : ret.original_code = ERROR_MARK;
9699 : 17 : ret.original_type = NULL_TREE;
9700 : 17 : return ret;
9701 : : }
9702 : :
9703 : : /* Try to avoid the overhead of creating and destroying an obstack
9704 : : for the common case of just one string. */
9705 : 3722781 : switch (c_parser_peek_2nd_token (parser)->type)
9706 : : {
9707 : 2857062 : default:
9708 : 2857062 : c_parser_consume_token (parser);
9709 : 2857062 : str.text = (const unsigned char *) TREE_STRING_POINTER (string_tree);
9710 : 2857062 : str.len = TREE_STRING_LENGTH (string_tree);
9711 : 2857062 : count = 1;
9712 : 2857062 : strs = &str;
9713 : 2857062 : break;
9714 : :
9715 : 865719 : case CPP_STRING:
9716 : 865719 : case CPP_WSTRING:
9717 : 865719 : case CPP_STRING16:
9718 : 865719 : case CPP_STRING32:
9719 : 865719 : case CPP_UTF8STRING:
9720 : 865719 : gcc_obstack_init (&str_ob);
9721 : 865719 : gcc_obstack_init (&loc_ob);
9722 : 865719 : count = 0;
9723 : 27842249 : do
9724 : : {
9725 : 27842249 : c_parser_consume_token (parser);
9726 : 27842249 : count++;
9727 : 27842249 : str.text = (const unsigned char *) TREE_STRING_POINTER (string_tree);
9728 : 27842249 : str.len = TREE_STRING_LENGTH (string_tree);
9729 : 27842249 : if (type != tok->type)
9730 : : {
9731 : 669 : if (type == CPP_STRING)
9732 : 29 : type = tok->type;
9733 : 640 : else if (tok->type != CPP_STRING)
9734 : 66 : error ("unsupported non-standard concatenation "
9735 : : "of string literals");
9736 : : }
9737 : 27842249 : obstack_grow (&str_ob, &str, sizeof (cpp_string));
9738 : 27842249 : obstack_grow (&loc_ob, &last_tok_loc, sizeof (location_t));
9739 : 27842249 : tok = c_parser_peek_token (parser);
9740 : 27842249 : string_tree = tok->value;
9741 : 27842249 : last_tok_loc
9742 : 27842249 : = linemap_resolve_location (line_table, tok->location,
9743 : : LRK_MACRO_DEFINITION_LOCATION, NULL);
9744 : : }
9745 : 27842249 : while (tok->type == CPP_STRING
9746 : : || tok->type == CPP_WSTRING
9747 : : || tok->type == CPP_STRING16
9748 : : || tok->type == CPP_STRING32
9749 : 27842249 : || tok->type == CPP_UTF8STRING);
9750 : 865719 : strs = (cpp_string *) obstack_finish (&str_ob);
9751 : : }
9752 : :
9753 : 3722781 : if (count > 1 && !in_system_header_at (input_location))
9754 : 646468 : warning (OPT_Wtraditional,
9755 : : "traditional C rejects string constant concatenation");
9756 : :
9757 : 3722781 : if ((type == CPP_STRING || wide_ok)
9758 : 7445552 : && ((translate
9759 : 3722771 : ? cpp_interpret_string : cpp_interpret_string_notranslate)
9760 : 3722771 : (parse_in, strs, count, &istr, type)))
9761 : : {
9762 : 3722771 : value = build_string (istr.len, (const char *) istr.text);
9763 : 3722771 : free (CONST_CAST (unsigned char *, istr.text));
9764 : 3722771 : if (count > 1)
9765 : : {
9766 : 865719 : location_t *locs = (location_t *) obstack_finish (&loc_ob);
9767 : 865719 : gcc_assert (g_string_concat_db);
9768 : 865719 : g_string_concat_db->record_string_concatenation (count, locs);
9769 : : }
9770 : : }
9771 : : else
9772 : : {
9773 : 10 : if (type != CPP_STRING && !wide_ok)
9774 : : {
9775 : 10 : error_at (loc, "a wide string is invalid in this context");
9776 : 10 : type = CPP_STRING;
9777 : : }
9778 : : /* Callers cannot generally handle error_mark_node in this
9779 : : context, so return the empty string instead. An error has
9780 : : been issued, either above or from cpp_interpret_string. */
9781 : 10 : switch (type)
9782 : : {
9783 : 10 : default:
9784 : 10 : case CPP_STRING:
9785 : 10 : case CPP_UTF8STRING:
9786 : 10 : if (type == CPP_UTF8STRING && flag_char8_t)
9787 : : {
9788 : 0 : value = build_string (TYPE_PRECISION (char8_type_node)
9789 : 0 : / TYPE_PRECISION (char_type_node),
9790 : : ""); /* char8_t is 8 bits */
9791 : : }
9792 : : else
9793 : 10 : value = build_string (1, "");
9794 : : break;
9795 : 0 : case CPP_STRING16:
9796 : 0 : value = build_string (TYPE_PRECISION (char16_type_node)
9797 : 0 : / TYPE_PRECISION (char_type_node),
9798 : : "\0"); /* char16_t is 16 bits */
9799 : 0 : break;
9800 : 0 : case CPP_STRING32:
9801 : 0 : value = build_string (TYPE_PRECISION (char32_type_node)
9802 : 0 : / TYPE_PRECISION (char_type_node),
9803 : : "\0\0\0"); /* char32_t is 32 bits */
9804 : 0 : break;
9805 : 0 : case CPP_WSTRING:
9806 : 0 : value = build_string (TYPE_PRECISION (wchar_type_node)
9807 : 0 : / TYPE_PRECISION (char_type_node),
9808 : : "\0\0\0"); /* widest supported wchar_t
9809 : : is 32 bits */
9810 : 0 : break;
9811 : : }
9812 : : }
9813 : :
9814 : 3722781 : switch (type)
9815 : : {
9816 : 3719524 : default:
9817 : 3719524 : case CPP_STRING:
9818 : 3719524 : TREE_TYPE (value) = char_array_type_node;
9819 : 3719524 : break;
9820 : 243 : case CPP_UTF8STRING:
9821 : 243 : if (flag_char8_t)
9822 : 63 : TREE_TYPE (value) = char8_array_type_node;
9823 : : else
9824 : 180 : TREE_TYPE (value) = char_array_type_node;
9825 : : break;
9826 : 219 : case CPP_STRING16:
9827 : 219 : TREE_TYPE (value) = char16_array_type_node;
9828 : 219 : break;
9829 : 2282 : case CPP_STRING32:
9830 : 2282 : TREE_TYPE (value) = char32_array_type_node;
9831 : 2282 : break;
9832 : 513 : case CPP_WSTRING:
9833 : 513 : TREE_TYPE (value) = wchar_array_type_node;
9834 : : }
9835 : 3722781 : value = fix_string_type (value);
9836 : :
9837 : 3722781 : if (count > 1)
9838 : : {
9839 : 865719 : obstack_free (&str_ob, 0);
9840 : 865719 : obstack_free (&loc_ob, 0);
9841 : : }
9842 : :
9843 : 3722781 : ret.value = value;
9844 : 3722781 : ret.original_code = STRING_CST;
9845 : 3722781 : ret.original_type = NULL_TREE;
9846 : 3722781 : set_c_expr_source_range (&ret, get_range_from_loc (line_table, loc));
9847 : 3722781 : ret.m_decimal = 0;
9848 : 3722781 : parser->seen_string_literal = true;
9849 : 3722781 : return ret;
9850 : : }
9851 : :
9852 : : /* Parse an expression other than a compound expression; that is, an
9853 : : assignment expression (C90 6.3.16, C99 6.5.16, C11 6.5.16). If
9854 : : AFTER is not NULL then it is an Objective-C message expression which
9855 : : is the primary-expression starting the expression as an initializer.
9856 : :
9857 : : assignment-expression:
9858 : : conditional-expression
9859 : : unary-expression assignment-operator assignment-expression
9860 : :
9861 : : assignment-operator: one of
9862 : : = *= /= %= += -= <<= >>= &= ^= |=
9863 : :
9864 : : In GNU C we accept any conditional expression on the LHS and
9865 : : diagnose the invalid lvalue rather than producing a syntax
9866 : : error. */
9867 : :
9868 : : static struct c_expr
9869 : 222347048 : c_parser_expr_no_commas (c_parser *parser, struct c_expr *after,
9870 : : tree omp_atomic_lhs)
9871 : : {
9872 : 222347048 : struct c_expr lhs, rhs, ret;
9873 : 222347048 : enum tree_code code;
9874 : 222347048 : location_t op_location, exp_location;
9875 : 222347048 : bool save_in_omp_for = c_in_omp_for;
9876 : 222347048 : c_in_omp_for = false;
9877 : 222347048 : gcc_assert (!after || c_dialect_objc ());
9878 : 222347048 : lhs = c_parser_conditional_expression (parser, after, omp_atomic_lhs);
9879 : 222347046 : op_location = c_parser_peek_token (parser)->location;
9880 : 222347046 : switch (c_parser_peek_token (parser)->type)
9881 : : {
9882 : : case CPP_EQ:
9883 : : code = NOP_EXPR;
9884 : : break;
9885 : 12091 : case CPP_MULT_EQ:
9886 : 12091 : code = MULT_EXPR;
9887 : 12091 : break;
9888 : 8644 : case CPP_DIV_EQ:
9889 : 8644 : code = TRUNC_DIV_EXPR;
9890 : 8644 : break;
9891 : 2241 : case CPP_MOD_EQ:
9892 : 2241 : code = TRUNC_MOD_EXPR;
9893 : 2241 : break;
9894 : 89548 : case CPP_PLUS_EQ:
9895 : 89548 : code = PLUS_EXPR;
9896 : 89548 : break;
9897 : 28697 : case CPP_MINUS_EQ:
9898 : 28697 : code = MINUS_EXPR;
9899 : 28697 : break;
9900 : 4106 : case CPP_LSHIFT_EQ:
9901 : 4106 : code = LSHIFT_EXPR;
9902 : 4106 : break;
9903 : 16677 : case CPP_RSHIFT_EQ:
9904 : 16677 : code = RSHIFT_EXPR;
9905 : 16677 : break;
9906 : 24532 : case CPP_AND_EQ:
9907 : 24532 : code = BIT_AND_EXPR;
9908 : 24532 : break;
9909 : 3140 : case CPP_XOR_EQ:
9910 : 3140 : code = BIT_XOR_EXPR;
9911 : 3140 : break;
9912 : 19838 : case CPP_OR_EQ:
9913 : 19838 : code = BIT_IOR_EXPR;
9914 : 19838 : break;
9915 : 219520754 : default:
9916 : 219520754 : c_in_omp_for = save_in_omp_for;
9917 : 219520754 : return lhs;
9918 : : }
9919 : 2826292 : c_parser_consume_token (parser);
9920 : 2826292 : exp_location = c_parser_peek_token (parser)->location;
9921 : 2826292 : rhs = c_parser_expr_no_commas (parser, NULL);
9922 : 2826292 : rhs = convert_lvalue_to_rvalue (exp_location, rhs, true, true);
9923 : :
9924 : 2826292 : ret.value = build_modify_expr (op_location, lhs.value, lhs.original_type,
9925 : : code, exp_location, rhs.value,
9926 : : rhs.original_type);
9927 : 2826292 : ret.m_decimal = 0;
9928 : 2826292 : set_c_expr_source_range (&ret, lhs.get_start (), rhs.get_finish ());
9929 : 2826292 : if (code == NOP_EXPR)
9930 : 2616778 : ret.original_code = MODIFY_EXPR;
9931 : : else
9932 : : {
9933 : 209514 : suppress_warning (ret.value, OPT_Wparentheses);
9934 : 209514 : ret.original_code = ERROR_MARK;
9935 : : }
9936 : 2826292 : ret.original_type = NULL;
9937 : 2826292 : c_in_omp_for = save_in_omp_for;
9938 : 2826292 : return ret;
9939 : : }
9940 : :
9941 : : /* Parse a conditional expression (C90 6.3.15, C99 6.5.15, C11 6.5.15). If
9942 : : AFTER is not NULL then it is an Objective-C message expression which is
9943 : : the primary-expression starting the expression as an initializer.
9944 : :
9945 : : conditional-expression:
9946 : : logical-OR-expression
9947 : : logical-OR-expression ? expression : conditional-expression
9948 : :
9949 : : GNU extensions:
9950 : :
9951 : : conditional-expression:
9952 : : logical-OR-expression ? : conditional-expression
9953 : : */
9954 : :
9955 : : static struct c_expr
9956 : 222750026 : c_parser_conditional_expression (c_parser *parser, struct c_expr *after,
9957 : : tree omp_atomic_lhs)
9958 : : {
9959 : 222750026 : struct c_expr cond, exp1, exp2, ret;
9960 : 222750026 : location_t start, cond_loc, colon_loc;
9961 : 222750026 : bool save_c_omp_array_section_p = c_omp_array_section_p;
9962 : :
9963 : 222750026 : gcc_assert (!after || c_dialect_objc ());
9964 : :
9965 : 222750026 : cond = c_parser_binary_expression (parser, after, omp_atomic_lhs);
9966 : :
9967 : 222750024 : if (c_parser_next_token_is_not (parser, CPP_QUERY))
9968 : 222347234 : return cond;
9969 : 402790 : c_omp_array_section_p = false;
9970 : 402790 : if (cond.value != error_mark_node)
9971 : 402779 : start = cond.get_start ();
9972 : : else
9973 : : start = UNKNOWN_LOCATION;
9974 : 402790 : cond_loc = c_parser_peek_token (parser)->location;
9975 : 402790 : cond = convert_lvalue_to_rvalue (cond_loc, cond, true, true);
9976 : 402790 : c_parser_consume_token (parser);
9977 : 402790 : if (c_parser_next_token_is (parser, CPP_COLON))
9978 : : {
9979 : 744 : tree eptype = NULL_TREE;
9980 : :
9981 : 744 : location_t middle_loc = c_parser_peek_token (parser)->location;
9982 : 744 : pedwarn (middle_loc, OPT_Wpedantic,
9983 : : "ISO C forbids omitting the middle term of a %<?:%> expression");
9984 : 744 : if (TREE_CODE (cond.value) == EXCESS_PRECISION_EXPR)
9985 : : {
9986 : 1 : eptype = TREE_TYPE (cond.value);
9987 : 1 : cond.value = TREE_OPERAND (cond.value, 0);
9988 : : }
9989 : 744 : tree e = cond.value;
9990 : 747 : while (TREE_CODE (e) == COMPOUND_EXPR)
9991 : 3 : e = TREE_OPERAND (e, 1);
9992 : 744 : warn_for_omitted_condop (middle_loc, e);
9993 : : /* Make sure first operand is calculated only once. */
9994 : 744 : exp1.value = save_expr (default_conversion (cond.value));
9995 : 744 : if (eptype)
9996 : 1 : exp1.value = build1 (EXCESS_PRECISION_EXPR, eptype, exp1.value);
9997 : 744 : exp1.original_type = NULL;
9998 : 744 : exp1.src_range = cond.src_range;
9999 : 744 : cond.value = c_objc_common_truthvalue_conversion (cond_loc, exp1.value);
10000 : 744 : c_inhibit_evaluation_warnings += cond.value == truthvalue_true_node;
10001 : : }
10002 : : else
10003 : : {
10004 : 402046 : cond.value
10005 : 402046 : = c_objc_common_truthvalue_conversion
10006 : 402046 : (cond_loc, default_conversion (cond.value));
10007 : 402046 : c_inhibit_evaluation_warnings += cond.value == truthvalue_false_node;
10008 : 402046 : exp1 = c_parser_expression_conv (parser);
10009 : 402046 : mark_exp_read (exp1.value);
10010 : 402046 : c_inhibit_evaluation_warnings +=
10011 : 402046 : ((cond.value == truthvalue_true_node)
10012 : 402046 : - (cond.value == truthvalue_false_node));
10013 : : }
10014 : :
10015 : 402790 : colon_loc = c_parser_peek_token (parser)->location;
10016 : 402790 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
10017 : : {
10018 : 9 : c_inhibit_evaluation_warnings -= cond.value == truthvalue_true_node;
10019 : 9 : ret.set_error ();
10020 : 9 : ret.original_code = ERROR_MARK;
10021 : 9 : ret.original_type = NULL;
10022 : 9 : c_omp_array_section_p = save_c_omp_array_section_p;
10023 : 9 : return ret;
10024 : : }
10025 : 402781 : {
10026 : 402781 : location_t exp2_loc = c_parser_peek_token (parser)->location;
10027 : 402781 : exp2 = c_parser_conditional_expression (parser, NULL, NULL_TREE);
10028 : 402781 : exp2 = convert_lvalue_to_rvalue (exp2_loc, exp2, true, true);
10029 : : }
10030 : 402781 : c_inhibit_evaluation_warnings -= cond.value == truthvalue_true_node;
10031 : 402781 : location_t loc1 = make_location (exp1.get_start (), exp1.src_range);
10032 : 402781 : location_t loc2 = make_location (exp2.get_start (), exp2.src_range);
10033 : 402781 : if (UNLIKELY (omp_atomic_lhs != NULL)
10034 : 69 : && (TREE_CODE (cond.value) == GT_EXPR
10035 : : || TREE_CODE (cond.value) == LT_EXPR
10036 : : || TREE_CODE (cond.value) == EQ_EXPR)
10037 : 63 : && c_tree_equal (exp2.value, omp_atomic_lhs)
10038 : 402839 : && (c_tree_equal (TREE_OPERAND (cond.value, 0), omp_atomic_lhs)
10039 : 19 : || c_tree_equal (TREE_OPERAND (cond.value, 1), omp_atomic_lhs)))
10040 : 55 : ret.value = build3_loc (colon_loc, COND_EXPR, TREE_TYPE (omp_atomic_lhs),
10041 : : cond.value, exp1.value, exp2.value);
10042 : : else
10043 : 402726 : ret.value
10044 : 402726 : = build_conditional_expr (colon_loc, cond.value,
10045 : 402726 : cond.original_code == C_MAYBE_CONST_EXPR,
10046 : : exp1.value, exp1.original_type, loc1,
10047 : : exp2.value, exp2.original_type, loc2);
10048 : 402781 : ret.original_code = ERROR_MARK;
10049 : 402781 : if (exp1.value == error_mark_node || exp2.value == error_mark_node)
10050 : 15 : ret.original_type = NULL;
10051 : : else
10052 : : {
10053 : 402766 : tree t1, t2;
10054 : :
10055 : : /* If both sides are enum type, the default conversion will have
10056 : : made the type of the result be an integer type. We want to
10057 : : remember the enum types we started with. */
10058 : 402766 : t1 = exp1.original_type ? exp1.original_type : TREE_TYPE (exp1.value);
10059 : 402766 : t2 = exp2.original_type ? exp2.original_type : TREE_TYPE (exp2.value);
10060 : 402766 : ret.original_type = ((t1 != error_mark_node
10061 : 402766 : && t2 != error_mark_node
10062 : 402766 : && (TYPE_MAIN_VARIANT (t1)
10063 : 402766 : == TYPE_MAIN_VARIANT (t2)))
10064 : 402766 : ? t1
10065 : : : NULL);
10066 : : }
10067 : 402781 : set_c_expr_source_range (&ret, start, exp2.get_finish ());
10068 : 402781 : ret.m_decimal = 0;
10069 : 402781 : c_omp_array_section_p = save_c_omp_array_section_p;
10070 : 402781 : return ret;
10071 : : }
10072 : :
10073 : : /* Parse a binary expression; that is, a logical-OR-expression (C90
10074 : : 6.3.5-6.3.14, C99 6.5.5-6.5.14, C11 6.5.5-6.5.14). If AFTER is not
10075 : : NULL then it is an Objective-C message expression which is the
10076 : : primary-expression starting the expression as an initializer.
10077 : :
10078 : : OMP_ATOMIC_LHS is NULL, unless parsing OpenMP #pragma omp atomic,
10079 : : when it should be the unfolded lhs. In a valid OpenMP source,
10080 : : one of the operands of the toplevel binary expression must be equal
10081 : : to it. In that case, just return a build2 created binary operation
10082 : : rather than result of parser_build_binary_op.
10083 : :
10084 : : multiplicative-expression:
10085 : : cast-expression
10086 : : multiplicative-expression * cast-expression
10087 : : multiplicative-expression / cast-expression
10088 : : multiplicative-expression % cast-expression
10089 : :
10090 : : additive-expression:
10091 : : multiplicative-expression
10092 : : additive-expression + multiplicative-expression
10093 : : additive-expression - multiplicative-expression
10094 : :
10095 : : shift-expression:
10096 : : additive-expression
10097 : : shift-expression << additive-expression
10098 : : shift-expression >> additive-expression
10099 : :
10100 : : relational-expression:
10101 : : shift-expression
10102 : : relational-expression < shift-expression
10103 : : relational-expression > shift-expression
10104 : : relational-expression <= shift-expression
10105 : : relational-expression >= shift-expression
10106 : :
10107 : : equality-expression:
10108 : : relational-expression
10109 : : equality-expression == relational-expression
10110 : : equality-expression != relational-expression
10111 : :
10112 : : AND-expression:
10113 : : equality-expression
10114 : : AND-expression & equality-expression
10115 : :
10116 : : exclusive-OR-expression:
10117 : : AND-expression
10118 : : exclusive-OR-expression ^ AND-expression
10119 : :
10120 : : inclusive-OR-expression:
10121 : : exclusive-OR-expression
10122 : : inclusive-OR-expression | exclusive-OR-expression
10123 : :
10124 : : logical-AND-expression:
10125 : : inclusive-OR-expression
10126 : : logical-AND-expression && inclusive-OR-expression
10127 : :
10128 : : logical-OR-expression:
10129 : : logical-AND-expression
10130 : : logical-OR-expression || logical-AND-expression
10131 : : */
10132 : :
10133 : : static struct c_expr
10134 : 222766466 : c_parser_binary_expression (c_parser *parser, struct c_expr *after,
10135 : : tree omp_atomic_lhs)
10136 : : {
10137 : : /* A binary expression is parsed using operator-precedence parsing,
10138 : : with the operands being cast expressions. All the binary
10139 : : operators are left-associative. Thus a binary expression is of
10140 : : form:
10141 : :
10142 : : E0 op1 E1 op2 E2 ...
10143 : :
10144 : : which we represent on a stack. On the stack, the precedence
10145 : : levels are strictly increasing. When a new operator is
10146 : : encountered of higher precedence than that at the top of the
10147 : : stack, it is pushed; its LHS is the top expression, and its RHS
10148 : : is everything parsed until it is popped. When a new operator is
10149 : : encountered with precedence less than or equal to that at the top
10150 : : of the stack, triples E[i-1] op[i] E[i] are popped and replaced
10151 : : by the result of the operation until the operator at the top of
10152 : : the stack has lower precedence than the new operator or there is
10153 : : only one element on the stack; then the top expression is the LHS
10154 : : of the new operator. In the case of logical AND and OR
10155 : : expressions, we also need to adjust c_inhibit_evaluation_warnings
10156 : : as appropriate when the operators are pushed and popped. */
10157 : :
10158 : 222766466 : struct {
10159 : : /* The expression at this stack level. */
10160 : : struct c_expr expr;
10161 : : /* The precedence of the operator on its left, PREC_NONE at the
10162 : : bottom of the stack. */
10163 : : enum c_parser_prec prec;
10164 : : /* The operation on its left. */
10165 : : enum tree_code op;
10166 : : /* The source location of this operation. */
10167 : : location_t loc;
10168 : : /* The sizeof argument if expr.original_code == {PAREN_,}SIZEOF_EXPR. */
10169 : : tree sizeof_arg;
10170 : : } stack[NUM_PRECS];
10171 : 222766466 : int sp;
10172 : : /* Location of the binary operator. */
10173 : 222766466 : location_t binary_loc = UNKNOWN_LOCATION; /* Quiet warning. */
10174 : : #define POP \
10175 : : do { \
10176 : : switch (stack[sp].op) \
10177 : : { \
10178 : : case TRUTH_ANDIF_EXPR: \
10179 : : c_inhibit_evaluation_warnings -= (stack[sp - 1].expr.value \
10180 : : == truthvalue_false_node); \
10181 : : break; \
10182 : : case TRUTH_ORIF_EXPR: \
10183 : : c_inhibit_evaluation_warnings -= (stack[sp - 1].expr.value \
10184 : : == truthvalue_true_node); \
10185 : : break; \
10186 : : case TRUNC_DIV_EXPR: \
10187 : : if ((stack[sp - 1].expr.original_code == SIZEOF_EXPR \
10188 : : || stack[sp - 1].expr.original_code == PAREN_SIZEOF_EXPR) \
10189 : : && (stack[sp].expr.original_code == SIZEOF_EXPR \
10190 : : || stack[sp].expr.original_code == PAREN_SIZEOF_EXPR)) \
10191 : : { \
10192 : : tree type0 = stack[sp - 1].sizeof_arg; \
10193 : : tree type1 = stack[sp].sizeof_arg; \
10194 : : tree first_arg = type0; \
10195 : : if (!TYPE_P (type0)) \
10196 : : type0 = TREE_TYPE (type0); \
10197 : : if (!TYPE_P (type1)) \
10198 : : type1 = TREE_TYPE (type1); \
10199 : : if (POINTER_TYPE_P (type0) \
10200 : : && comptypes (TREE_TYPE (type0), type1) \
10201 : : && !(TREE_CODE (first_arg) == PARM_DECL \
10202 : : && C_ARRAY_PARAMETER (first_arg) \
10203 : : && warn_sizeof_array_argument)) \
10204 : : { \
10205 : : auto_diagnostic_group d; \
10206 : : if (warning_at (stack[sp].loc, OPT_Wsizeof_pointer_div, \
10207 : : "division %<sizeof (%T) / sizeof (%T)%> " \
10208 : : "does not compute the number of array " \
10209 : : "elements", \
10210 : : type0, type1)) \
10211 : : if (DECL_P (first_arg)) \
10212 : : inform (DECL_SOURCE_LOCATION (first_arg), \
10213 : : "first %<sizeof%> operand was declared here"); \
10214 : : } \
10215 : : else if (TREE_CODE (type0) == ARRAY_TYPE \
10216 : : && !char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type0))) \
10217 : : && stack[sp].expr.original_code != PAREN_SIZEOF_EXPR) \
10218 : : maybe_warn_sizeof_array_div (stack[sp].loc, first_arg, type0, \
10219 : : stack[sp].sizeof_arg, type1); \
10220 : : } \
10221 : : break; \
10222 : : default: \
10223 : : break; \
10224 : : } \
10225 : : stack[sp - 1].expr \
10226 : : = convert_lvalue_to_rvalue (stack[sp - 1].loc, \
10227 : : stack[sp - 1].expr, true, true); \
10228 : : stack[sp].expr \
10229 : : = convert_lvalue_to_rvalue (stack[sp].loc, \
10230 : : stack[sp].expr, true, true); \
10231 : : if (UNLIKELY (omp_atomic_lhs != NULL_TREE) && sp == 1 \
10232 : : && ((c_parser_next_token_is (parser, CPP_SEMICOLON) \
10233 : : && ((1 << stack[sp].prec) \
10234 : : & ((1 << PREC_BITOR) | (1 << PREC_BITXOR) \
10235 : : | (1 << PREC_BITAND) | (1 << PREC_SHIFT) \
10236 : : | (1 << PREC_ADD) | (1 << PREC_MULT) \
10237 : : | (1 << PREC_EQ)))) \
10238 : : || ((c_parser_next_token_is (parser, CPP_QUERY) \
10239 : : || (omp_atomic_lhs == void_list_node \
10240 : : && c_parser_next_token_is (parser, CPP_CLOSE_PAREN))) \
10241 : : && (stack[sp].prec == PREC_REL || stack[sp].prec == PREC_EQ)))\
10242 : : && stack[sp].op != TRUNC_MOD_EXPR \
10243 : : && stack[sp].op != GE_EXPR \
10244 : : && stack[sp].op != LE_EXPR \
10245 : : && stack[sp].op != NE_EXPR \
10246 : : && stack[0].expr.value != error_mark_node \
10247 : : && stack[1].expr.value != error_mark_node \
10248 : : && (omp_atomic_lhs == void_list_node \
10249 : : || c_tree_equal (stack[0].expr.value, omp_atomic_lhs) \
10250 : : || c_tree_equal (stack[1].expr.value, omp_atomic_lhs) \
10251 : : || (stack[sp].op == EQ_EXPR \
10252 : : && c_parser_peek_2nd_token (parser)->keyword == RID_IF))) \
10253 : : { \
10254 : : tree t = make_node (stack[1].op); \
10255 : : TREE_TYPE (t) = TREE_TYPE (stack[0].expr.value); \
10256 : : TREE_OPERAND (t, 0) = stack[0].expr.value; \
10257 : : TREE_OPERAND (t, 1) = stack[1].expr.value; \
10258 : : stack[0].expr.value = t; \
10259 : : stack[0].expr.m_decimal = 0; \
10260 : : } \
10261 : : else \
10262 : : stack[sp - 1].expr = parser_build_binary_op (stack[sp].loc, \
10263 : : stack[sp].op, \
10264 : : stack[sp - 1].expr, \
10265 : : stack[sp].expr); \
10266 : : sp--; \
10267 : : } while (0)
10268 : 222766466 : gcc_assert (!after || c_dialect_objc ());
10269 : 222766466 : stack[0].loc = c_parser_peek_token (parser)->location;
10270 : 222766466 : stack[0].expr = c_parser_cast_expression (parser, after);
10271 : 222766466 : stack[0].prec = PREC_NONE;
10272 : 222766466 : stack[0].sizeof_arg = c_last_sizeof_arg;
10273 : 222766466 : sp = 0;
10274 : 241055076 : while (true)
10275 : : {
10276 : 231910771 : enum c_parser_prec oprec;
10277 : 231910771 : enum tree_code ocode;
10278 : 231910771 : source_range src_range;
10279 : 231910771 : if (parser->error)
10280 : 1070 : goto out;
10281 : 231909701 : switch (c_parser_peek_token (parser)->type)
10282 : : {
10283 : : case CPP_MULT:
10284 : : oprec = PREC_MULT;
10285 : : ocode = MULT_EXPR;
10286 : : break;
10287 : 254343 : case CPP_DIV:
10288 : 254343 : oprec = PREC_MULT;
10289 : 254343 : ocode = TRUNC_DIV_EXPR;
10290 : 254343 : break;
10291 : 54248 : case CPP_MOD:
10292 : 54248 : oprec = PREC_MULT;
10293 : 54248 : ocode = TRUNC_MOD_EXPR;
10294 : 54248 : break;
10295 : 1811082 : case CPP_PLUS:
10296 : 1811082 : oprec = PREC_ADD;
10297 : 1811082 : ocode = PLUS_EXPR;
10298 : 1811082 : break;
10299 : 740541 : case CPP_MINUS:
10300 : 740541 : oprec = PREC_ADD;
10301 : 740541 : ocode = MINUS_EXPR;
10302 : 740541 : break;
10303 : 779130 : case CPP_LSHIFT:
10304 : 779130 : oprec = PREC_SHIFT;
10305 : 779130 : ocode = LSHIFT_EXPR;
10306 : 779130 : break;
10307 : 209874 : case CPP_RSHIFT:
10308 : 209874 : oprec = PREC_SHIFT;
10309 : 209874 : ocode = RSHIFT_EXPR;
10310 : 209874 : break;
10311 : 454829 : case CPP_LESS:
10312 : 454829 : oprec = PREC_REL;
10313 : 454829 : ocode = LT_EXPR;
10314 : 454829 : break;
10315 : 190074 : case CPP_GREATER:
10316 : 190074 : oprec = PREC_REL;
10317 : 190074 : ocode = GT_EXPR;
10318 : 190074 : break;
10319 : 162695 : case CPP_LESS_EQ:
10320 : 162695 : oprec = PREC_REL;
10321 : 162695 : ocode = LE_EXPR;
10322 : 162695 : break;
10323 : 165566 : case CPP_GREATER_EQ:
10324 : 165566 : oprec = PREC_REL;
10325 : 165566 : ocode = GE_EXPR;
10326 : 165566 : break;
10327 : 385187 : case CPP_EQ_EQ:
10328 : 385187 : oprec = PREC_EQ;
10329 : 385187 : ocode = EQ_EXPR;
10330 : 385187 : break;
10331 : 761451 : case CPP_NOT_EQ:
10332 : 761451 : oprec = PREC_EQ;
10333 : 761451 : ocode = NE_EXPR;
10334 : 761451 : break;
10335 : 576945 : case CPP_AND:
10336 : 576945 : oprec = PREC_BITAND;
10337 : 576945 : ocode = BIT_AND_EXPR;
10338 : 576945 : break;
10339 : 75077 : case CPP_XOR:
10340 : 75077 : oprec = PREC_BITXOR;
10341 : 75077 : ocode = BIT_XOR_EXPR;
10342 : 75077 : break;
10343 : 841140 : case CPP_OR:
10344 : 841140 : oprec = PREC_BITOR;
10345 : 841140 : ocode = BIT_IOR_EXPR;
10346 : 841140 : break;
10347 : 180575 : case CPP_AND_AND:
10348 : 180575 : oprec = PREC_LOGAND;
10349 : 180575 : ocode = TRUTH_ANDIF_EXPR;
10350 : 180575 : break;
10351 : 320270 : case CPP_OR_OR:
10352 : 320270 : oprec = PREC_LOGOR;
10353 : 320270 : ocode = TRUTH_ORIF_EXPR;
10354 : 320270 : break;
10355 : 222765396 : default:
10356 : : /* Not a binary operator, so end of the binary
10357 : : expression. */
10358 : 222765396 : goto out;
10359 : : }
10360 : 9144305 : binary_loc = c_parser_peek_token (parser)->location;
10361 : 9144305 : while (oprec <= stack[sp].prec)
10362 : 10578239 : POP;
10363 : 9144305 : c_parser_consume_token (parser);
10364 : 9144305 : switch (ocode)
10365 : : {
10366 : 180575 : case TRUTH_ANDIF_EXPR:
10367 : 180575 : src_range = stack[sp].expr.src_range;
10368 : 180575 : stack[sp].expr
10369 : 180575 : = convert_lvalue_to_rvalue (stack[sp].loc,
10370 : : stack[sp].expr, true, true);
10371 : 361150 : stack[sp].expr.value = c_objc_common_truthvalue_conversion
10372 : 180575 : (stack[sp].loc, default_conversion (stack[sp].expr.value));
10373 : 180575 : c_inhibit_evaluation_warnings += (stack[sp].expr.value
10374 : 180575 : == truthvalue_false_node);
10375 : 180575 : set_c_expr_source_range (&stack[sp].expr, src_range);
10376 : 180575 : break;
10377 : 320270 : case TRUTH_ORIF_EXPR:
10378 : 320270 : src_range = stack[sp].expr.src_range;
10379 : 320270 : stack[sp].expr
10380 : 320270 : = convert_lvalue_to_rvalue (stack[sp].loc,
10381 : : stack[sp].expr, true, true);
10382 : 640540 : stack[sp].expr.value = c_objc_common_truthvalue_conversion
10383 : 320270 : (stack[sp].loc, default_conversion (stack[sp].expr.value));
10384 : 320270 : c_inhibit_evaluation_warnings += (stack[sp].expr.value
10385 : 320270 : == truthvalue_true_node);
10386 : 320270 : set_c_expr_source_range (&stack[sp].expr, src_range);
10387 : 320270 : break;
10388 : : default:
10389 : : break;
10390 : : }
10391 : 9144305 : sp++;
10392 : 9144305 : stack[sp].loc = binary_loc;
10393 : 9144305 : stack[sp].expr = c_parser_cast_expression (parser, NULL);
10394 : 9144305 : stack[sp].prec = oprec;
10395 : 9144305 : stack[sp].op = ocode;
10396 : 9144305 : stack[sp].sizeof_arg = c_last_sizeof_arg;
10397 : 9144305 : }
10398 : 222766466 : out:
10399 : 222766466 : while (sp > 0)
10400 : 230477558 : POP;
10401 : 222766464 : return stack[0].expr;
10402 : : #undef POP
10403 : : }
10404 : :
10405 : : /* Parse any storage class specifiers after an open parenthesis in a
10406 : : context where a compound literal is permitted. */
10407 : :
10408 : : static struct c_declspecs *
10409 : 118333851 : c_parser_compound_literal_scspecs (c_parser *parser)
10410 : : {
10411 : 118333851 : bool seen_scspec = false;
10412 : 118333851 : struct c_declspecs *specs = build_null_declspecs ();
10413 : 236668036 : while (c_parser_next_token_is (parser, CPP_KEYWORD))
10414 : : {
10415 : 4147688 : switch (c_parser_peek_token (parser)->keyword)
10416 : : {
10417 : 334 : case RID_CONSTEXPR:
10418 : 334 : case RID_REGISTER:
10419 : 334 : case RID_STATIC:
10420 : 334 : case RID_THREAD:
10421 : 334 : seen_scspec = true;
10422 : 334 : declspecs_add_scspec (c_parser_peek_token (parser)->location,
10423 : 334 : specs, c_parser_peek_token (parser)->value);
10424 : 334 : c_parser_consume_token (parser);
10425 : 334 : break;
10426 : 4147354 : default:
10427 : 4147354 : goto out;
10428 : : }
10429 : : }
10430 : 114186497 : out:
10431 : 118333851 : return seen_scspec ? specs : NULL;
10432 : : }
10433 : :
10434 : : /* Parse a cast expression (C90 6.3.4, C99 6.5.4, C11 6.5.4). If AFTER
10435 : : is not NULL then it is an Objective-C message expression which is the
10436 : : primary-expression starting the expression as an initializer.
10437 : :
10438 : : cast-expression:
10439 : : unary-expression
10440 : : ( type-name ) unary-expression
10441 : : */
10442 : :
10443 : : static struct c_expr
10444 : 358591212 : c_parser_cast_expression (c_parser *parser, struct c_expr *after)
10445 : : {
10446 : 358591212 : location_t cast_loc = c_parser_peek_token (parser)->location;
10447 : 358591212 : gcc_assert (!after || c_dialect_objc ());
10448 : 0 : if (after)
10449 : 0 : return c_parser_postfix_expression_after_primary (parser,
10450 : 0 : cast_loc, *after);
10451 : : /* If the expression begins with a parenthesized type name, it may
10452 : : be either a cast or a compound literal; we need to see whether
10453 : : the next character is '{' to tell the difference. If not, it is
10454 : : an unary expression. Full detection of unknown typenames here
10455 : : would require a 3-token lookahead. */
10456 : 358591212 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
10457 : 358591212 : && c_token_starts_compound_literal (c_parser_peek_2nd_token (parser)))
10458 : : {
10459 : 117973353 : struct c_declspecs *scspecs;
10460 : 117973353 : struct c_type_name *type_name;
10461 : 117973353 : struct c_expr ret;
10462 : 117973353 : struct c_expr expr;
10463 : 117973353 : matching_parens parens;
10464 : 117973353 : parens.consume_open (parser);
10465 : 117973353 : scspecs = c_parser_compound_literal_scspecs (parser);
10466 : 117973353 : type_name = c_parser_type_name (parser, true);
10467 : 117973353 : parens.skip_until_found_close (parser);
10468 : 117973353 : if (type_name == NULL)
10469 : : {
10470 : 1 : ret.set_error ();
10471 : 1 : ret.original_code = ERROR_MARK;
10472 : 1 : ret.original_type = NULL;
10473 : 1 : return ret;
10474 : : }
10475 : :
10476 : : /* Save casted types in the function's used types hash table. */
10477 : 117973352 : used_types_insert (type_name->specs->type);
10478 : :
10479 : 117973352 : if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
10480 : 898070 : return c_parser_postfix_expression_after_paren_type (parser, scspecs,
10481 : : type_name,
10482 : 898070 : cast_loc);
10483 : 117075282 : if (scspecs)
10484 : 1 : error_at (cast_loc, "storage class specifier in cast");
10485 : 117075282 : if (type_name->specs->alignas_p)
10486 : 1 : error_at (type_name->specs->locations[cdw_alignas],
10487 : : "alignment specified for type name in cast");
10488 : 117075282 : {
10489 : 117075282 : location_t expr_loc = c_parser_peek_token (parser)->location;
10490 : 117075282 : expr = c_parser_cast_expression (parser, NULL);
10491 : 117075282 : expr = convert_lvalue_to_rvalue (expr_loc, expr, true, true);
10492 : : }
10493 : 117075282 : ret.value = c_cast_expr (cast_loc, type_name, expr.value);
10494 : 117075282 : if (ret.value && expr.value)
10495 : 117075282 : set_c_expr_source_range (&ret, cast_loc, expr.get_finish ());
10496 : 117075282 : ret.original_code = ERROR_MARK;
10497 : 117075282 : ret.original_type = NULL;
10498 : 117075282 : ret.m_decimal = 0;
10499 : 117075282 : return ret;
10500 : : }
10501 : : else
10502 : 240617859 : return c_parser_unary_expression (parser);
10503 : : }
10504 : :
10505 : : /* Parse an unary expression (C90 6.3.3, C99 6.5.3, C11 6.5.3).
10506 : :
10507 : : unary-expression:
10508 : : postfix-expression
10509 : : ++ unary-expression
10510 : : -- unary-expression
10511 : : unary-operator cast-expression
10512 : : _Countof unary-expression
10513 : : _Countof ( type-name )
10514 : : sizeof unary-expression
10515 : : sizeof ( type-name )
10516 : :
10517 : : (_Countof is new in C2y.)
10518 : :
10519 : : unary-operator: one of
10520 : : & * + - ~ !
10521 : :
10522 : : GNU extensions:
10523 : :
10524 : : unary-expression:
10525 : : __alignof__ unary-expression
10526 : : __alignof__ ( type-name )
10527 : : && identifier
10528 : :
10529 : : (C11 permits _Alignof with type names only.)
10530 : :
10531 : : unary-operator: one of
10532 : : __extension__ __real__ __imag__
10533 : :
10534 : : Transactional Memory:
10535 : :
10536 : : unary-expression:
10537 : : transaction-expression
10538 : :
10539 : : In addition, the GNU syntax treats ++ and -- as unary operators, so
10540 : : they may be applied to cast expressions with errors for non-lvalues
10541 : : given later. */
10542 : :
10543 : : static struct c_expr
10544 : 240961048 : c_parser_unary_expression (c_parser *parser)
10545 : : {
10546 : 240961048 : int ext;
10547 : 240961048 : struct c_expr ret, op;
10548 : 240961048 : location_t op_loc = c_parser_peek_token (parser)->location;
10549 : 240961048 : location_t exp_loc;
10550 : 240961048 : location_t finish;
10551 : 240961048 : ret.original_code = ERROR_MARK;
10552 : 240961048 : ret.original_type = NULL;
10553 : 240961048 : switch (c_parser_peek_token (parser)->type)
10554 : : {
10555 : 220107 : case CPP_PLUS_PLUS:
10556 : 220107 : c_parser_consume_token (parser);
10557 : 220107 : exp_loc = c_parser_peek_token (parser)->location;
10558 : 220107 : op = c_parser_cast_expression (parser, NULL);
10559 : 4068 : if ((VAR_P (op.value) || TREE_CODE (op.value) == PARM_DECL)
10560 : 217154 : && !DECL_READ_P (op.value)
10561 : 226294 : && (VAR_P (op.value) ? warn_unused_but_set_variable
10562 : : : warn_unused_but_set_parameter) > 1)
10563 : : {
10564 : 399 : op = default_function_array_read_conversion (exp_loc, op);
10565 : 399 : DECL_READ_P (op.value) = 0;
10566 : : }
10567 : : else
10568 : 219708 : op = default_function_array_read_conversion (exp_loc, op);
10569 : 220107 : return parser_build_unary_op (op_loc, PREINCREMENT_EXPR, op);
10570 : 19844 : case CPP_MINUS_MINUS:
10571 : 19844 : c_parser_consume_token (parser);
10572 : 19844 : exp_loc = c_parser_peek_token (parser)->location;
10573 : 19844 : op = c_parser_cast_expression (parser, NULL);
10574 : 14590 : if ((VAR_P (op.value) || TREE_CODE (op.value) == PARM_DECL)
10575 : 19211 : && !DECL_READ_P (op.value)
10576 : 21808 : && (VAR_P (op.value) ? warn_unused_but_set_variable
10577 : : : warn_unused_but_set_parameter) > 1)
10578 : : {
10579 : 202 : op = default_function_array_read_conversion (exp_loc, op);
10580 : 202 : DECL_READ_P (op.value) = 0;
10581 : : }
10582 : : else
10583 : 19642 : op = default_function_array_read_conversion (exp_loc, op);
10584 : 19844 : return parser_build_unary_op (op_loc, PREDECREMENT_EXPR, op);
10585 : 441734 : case CPP_AND:
10586 : 441734 : c_parser_consume_token (parser);
10587 : 441734 : op = c_parser_cast_expression (parser, NULL);
10588 : 441734 : mark_exp_read (op.value);
10589 : 441734 : return parser_build_unary_op (op_loc, ADDR_EXPR, op);
10590 : 1182992 : case CPP_MULT:
10591 : 1182992 : {
10592 : 1182992 : c_parser_consume_token (parser);
10593 : 1182992 : exp_loc = c_parser_peek_token (parser)->location;
10594 : 1182992 : op = c_parser_cast_expression (parser, NULL);
10595 : 1182992 : finish = op.get_finish ();
10596 : 1182992 : op = convert_lvalue_to_rvalue (exp_loc, op, true, true);
10597 : 1182992 : location_t combined_loc = make_location (op_loc, op_loc, finish);
10598 : 1182992 : ret.value = build_indirect_ref (combined_loc, op.value, RO_UNARY_STAR);
10599 : 1182992 : ret.src_range.m_start = op_loc;
10600 : 1182992 : ret.src_range.m_finish = finish;
10601 : 1182992 : ret.m_decimal = 0;
10602 : 1182992 : return ret;
10603 : : }
10604 : 28536 : case CPP_PLUS:
10605 : 28536 : if (!c_dialect_objc () && !in_system_header_at (input_location))
10606 : 28534 : warning_at (op_loc,
10607 : 28534 : OPT_Wtraditional,
10608 : : "traditional C rejects the unary plus operator");
10609 : 28536 : c_parser_consume_token (parser);
10610 : 28536 : exp_loc = c_parser_peek_token (parser)->location;
10611 : 28536 : op = c_parser_cast_expression (parser, NULL);
10612 : 28536 : op = convert_lvalue_to_rvalue (exp_loc, op, true, true);
10613 : 28536 : return parser_build_unary_op (op_loc, CONVERT_EXPR, op);
10614 : 6518829 : case CPP_MINUS:
10615 : 6518829 : c_parser_consume_token (parser);
10616 : 6518829 : exp_loc = c_parser_peek_token (parser)->location;
10617 : 6518829 : op = c_parser_cast_expression (parser, NULL);
10618 : 6518829 : op = convert_lvalue_to_rvalue (exp_loc, op, true, true);
10619 : 6518829 : return parser_build_unary_op (op_loc, NEGATE_EXPR, op);
10620 : 288668 : case CPP_COMPL:
10621 : 288668 : c_parser_consume_token (parser);
10622 : 288668 : exp_loc = c_parser_peek_token (parser)->location;
10623 : 288668 : op = c_parser_cast_expression (parser, NULL);
10624 : 288668 : op = convert_lvalue_to_rvalue (exp_loc, op, true, true);
10625 : 288668 : return parser_build_unary_op (op_loc, BIT_NOT_EXPR, op);
10626 : 373901 : case CPP_NOT:
10627 : 373901 : c_parser_consume_token (parser);
10628 : 373901 : exp_loc = c_parser_peek_token (parser)->location;
10629 : 373901 : op = c_parser_cast_expression (parser, NULL);
10630 : 373901 : op = convert_lvalue_to_rvalue (exp_loc, op, true, true);
10631 : 373901 : return parser_build_unary_op (op_loc, TRUTH_NOT_EXPR, op);
10632 : 1834 : case CPP_AND_AND:
10633 : : /* Refer to the address of a label as a pointer. */
10634 : 1834 : c_parser_consume_token (parser);
10635 : 1834 : if (c_parser_next_token_is (parser, CPP_NAME))
10636 : : {
10637 : 3654 : ret.value = finish_label_address_expr
10638 : 1827 : (c_parser_peek_token (parser)->value, op_loc);
10639 : 1827 : set_c_expr_source_range (&ret, op_loc,
10640 : : c_parser_peek_token (parser)->get_finish ());
10641 : 1827 : c_parser_consume_token (parser);
10642 : : }
10643 : : else
10644 : : {
10645 : 7 : c_parser_error (parser, "expected identifier");
10646 : 7 : ret.set_error ();
10647 : : }
10648 : 1834 : return ret;
10649 : 2831031 : case CPP_KEYWORD:
10650 : 2831031 : switch (c_parser_peek_token (parser)->keyword)
10651 : : {
10652 : 71 : case RID_COUNTOF:
10653 : 71 : return c_parser_countof_expression (parser);
10654 : 631321 : case RID_SIZEOF:
10655 : 631321 : return c_parser_sizeof_expression (parser);
10656 : 72295 : case RID_ALIGNOF:
10657 : 72295 : return c_parser_alignof_expression (parser);
10658 : 764 : case RID_BUILTIN_HAS_ATTRIBUTE:
10659 : 764 : return c_parser_has_attribute_expression (parser);
10660 : 451301 : case RID_EXTENSION:
10661 : 451301 : c_parser_consume_token (parser);
10662 : 451301 : ext = disable_extension_diagnostics ();
10663 : 451301 : ret = c_parser_cast_expression (parser, NULL);
10664 : 451301 : restore_extension_diagnostics (ext);
10665 : 451301 : return ret;
10666 : 38362 : case RID_REALPART:
10667 : 38362 : c_parser_consume_token (parser);
10668 : 38362 : exp_loc = c_parser_peek_token (parser)->location;
10669 : 38362 : op = c_parser_cast_expression (parser, NULL);
10670 : 38362 : op = default_function_array_conversion (exp_loc, op);
10671 : 38362 : return parser_build_unary_op (op_loc, REALPART_EXPR, op);
10672 : 38305 : case RID_IMAGPART:
10673 : 38305 : c_parser_consume_token (parser);
10674 : 38305 : exp_loc = c_parser_peek_token (parser)->location;
10675 : 38305 : op = c_parser_cast_expression (parser, NULL);
10676 : 38305 : op = default_function_array_conversion (exp_loc, op);
10677 : 38305 : return parser_build_unary_op (op_loc, IMAGPART_EXPR, op);
10678 : 7 : case RID_TRANSACTION_ATOMIC:
10679 : 7 : case RID_TRANSACTION_RELAXED:
10680 : 14 : return c_parser_transaction_expression (parser,
10681 : 7 : c_parser_peek_token (parser)->keyword);
10682 : 1598605 : default:
10683 : 1598605 : return c_parser_postfix_expression (parser);
10684 : : }
10685 : 229053572 : default:
10686 : 229053572 : return c_parser_postfix_expression (parser);
10687 : : }
10688 : : }
10689 : :
10690 : : /* Parse a sizeof expression. */
10691 : :
10692 : : static inline struct c_expr
10693 : 631321 : c_parser_sizeof_expression (c_parser *parser)
10694 : : {
10695 : 631321 : return c_parser_sizeof_or_countof_expression (parser, RID_SIZEOF);
10696 : : }
10697 : :
10698 : : /* Parse a _Countof expression. */
10699 : :
10700 : : static inline struct c_expr
10701 : 71 : c_parser_countof_expression (c_parser *parser)
10702 : : {
10703 : 71 : return c_parser_sizeof_or_countof_expression (parser, RID_COUNTOF);
10704 : : }
10705 : :
10706 : : /* Parse a sizeof or _Countof expression. */
10707 : :
10708 : : static struct c_expr
10709 : 631392 : c_parser_sizeof_or_countof_expression (c_parser *parser, enum rid rid)
10710 : : {
10711 : 631392 : const char *op_name = (rid == RID_COUNTOF) ? "_Countof" : "sizeof";
10712 : 631392 : struct c_expr expr;
10713 : 631392 : struct c_expr result;
10714 : 631392 : location_t expr_loc;
10715 : 631392 : gcc_assert (c_parser_next_token_is_keyword (parser, rid));
10716 : :
10717 : 631392 : location_t start;
10718 : 631392 : location_t finish = UNKNOWN_LOCATION;
10719 : :
10720 : 631392 : start = c_parser_peek_token (parser)->location;
10721 : :
10722 : 631392 : if (rid == RID_COUNTOF)
10723 : 71 : pedwarn_c23 (start, OPT_Wpedantic,
10724 : : "ISO C does not support %qs before C2Y", op_name);
10725 : :
10726 : 631392 : c_parser_consume_token (parser);
10727 : 631392 : c_inhibit_evaluation_warnings++;
10728 : 631392 : if (rid == RID_COUNTOF)
10729 : 71 : in_countof++;
10730 : : else
10731 : 631321 : in_sizeof++;
10732 : 631392 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
10733 : 631392 : && c_token_starts_compound_literal (c_parser_peek_2nd_token (parser)))
10734 : : {
10735 : : /* Either sizeof ( type-name ) or sizeof unary-expression
10736 : : starting with a compound literal. */
10737 : 328994 : struct c_declspecs *scspecs;
10738 : 328994 : struct c_type_name *type_name;
10739 : 328994 : matching_parens parens;
10740 : 328994 : parens.consume_open (parser);
10741 : 328994 : expr_loc = c_parser_peek_token (parser)->location;
10742 : 328994 : scspecs = c_parser_compound_literal_scspecs (parser);
10743 : 328994 : type_name = c_parser_type_name (parser, true);
10744 : 328994 : parens.skip_until_found_close (parser);
10745 : 328994 : finish = parser->tokens_buf[0].location;
10746 : 328994 : if (type_name == NULL)
10747 : : {
10748 : : /* Let c_expr_sizeof_expr call pop_maybe_used and fill in c_expr
10749 : : for parsing error; the parsing of the expression could have
10750 : : called record_maybe_used_decl. */
10751 : 1 : expr.set_error ();
10752 : 27 : goto Xof_expr;
10753 : : }
10754 : 328993 : if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
10755 : : {
10756 : 26 : expr = c_parser_postfix_expression_after_paren_type (parser, scspecs,
10757 : : type_name,
10758 : : expr_loc);
10759 : 26 : finish = expr.get_finish ();
10760 : 26 : goto Xof_expr;
10761 : : }
10762 : : /* sizeof ( type-name ). */
10763 : 328967 : if (scspecs)
10764 : 1 : error_at (expr_loc, "storage class specifier in %qs", op_name);
10765 : 328967 : if (type_name->specs->alignas_p)
10766 : 2 : error_at (type_name->specs->locations[cdw_alignas],
10767 : : "alignment specified for type name in %qs", op_name);
10768 : 328967 : c_inhibit_evaluation_warnings--;
10769 : 328967 : if (rid == RID_COUNTOF)
10770 : : {
10771 : 18 : in_countof--;
10772 : 18 : result = c_expr_countof_type (expr_loc, type_name);
10773 : : }
10774 : : else
10775 : : {
10776 : 328949 : in_sizeof--;
10777 : 328949 : result = c_expr_sizeof_type (expr_loc, type_name);
10778 : : }
10779 : : }
10780 : : else
10781 : : {
10782 : 302398 : expr_loc = c_parser_peek_token (parser)->location;
10783 : 302398 : expr = c_parser_unary_expression (parser);
10784 : 302398 : finish = expr.get_finish ();
10785 : 302425 : Xof_expr:
10786 : 302425 : c_inhibit_evaluation_warnings--;
10787 : 302425 : if (rid == RID_COUNTOF)
10788 : 53 : in_countof--;
10789 : : else
10790 : 302372 : in_sizeof--;
10791 : 302425 : mark_exp_read (expr.value);
10792 : 302425 : if (TREE_CODE (expr.value) == COMPONENT_REF
10793 : 302425 : && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
10794 : 1 : error_at (expr_loc, "%qs applied to a bit-field", op_name);
10795 : 302425 : if (rid == RID_COUNTOF)
10796 : 53 : result = c_expr_countof_expr (expr_loc, expr);
10797 : : else
10798 : 302372 : result = c_expr_sizeof_expr (expr_loc, expr);
10799 : : }
10800 : 631392 : if (finish == UNKNOWN_LOCATION)
10801 : 1 : finish = start;
10802 : 631392 : set_c_expr_source_range (&result, start, finish);
10803 : 631392 : return result;
10804 : : }
10805 : :
10806 : : /* Parse an alignof expression. */
10807 : :
10808 : : static struct c_expr
10809 : 72295 : c_parser_alignof_expression (c_parser *parser)
10810 : : {
10811 : 72295 : struct c_expr expr;
10812 : 72295 : location_t start_loc = c_parser_peek_token (parser)->location;
10813 : 72295 : location_t end_loc;
10814 : 72295 : tree alignof_spelling = c_parser_peek_token (parser)->value;
10815 : 72295 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNOF));
10816 : 72295 : bool is_c11_alignof = (strcmp (IDENTIFIER_POINTER (alignof_spelling),
10817 : : "_Alignof") == 0
10818 : 72295 : || strcmp (IDENTIFIER_POINTER (alignof_spelling),
10819 : 72524 : "alignof") == 0);
10820 : : /* A diagnostic is not required for the use of this identifier in
10821 : : the implementation namespace; only diagnose it for the C11 or C23
10822 : : spelling because of existing code using the other spellings. */
10823 : 229 : if (is_c11_alignof)
10824 : : {
10825 : 229 : if (flag_isoc99)
10826 : 225 : pedwarn_c99 (start_loc, OPT_Wpedantic, "ISO C99 does not support %qE",
10827 : : alignof_spelling);
10828 : : else
10829 : 4 : pedwarn_c99 (start_loc, OPT_Wpedantic, "ISO C90 does not support %qE",
10830 : : alignof_spelling);
10831 : : }
10832 : 72295 : c_parser_consume_token (parser);
10833 : 72295 : c_inhibit_evaluation_warnings++;
10834 : 72295 : in_alignof++;
10835 : 72295 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
10836 : 72295 : && c_token_starts_compound_literal (c_parser_peek_2nd_token (parser)))
10837 : : {
10838 : : /* Either __alignof__ ( type-name ) or __alignof__
10839 : : unary-expression starting with a compound literal. */
10840 : 31504 : location_t loc;
10841 : 31504 : struct c_declspecs *scspecs;
10842 : 31504 : struct c_type_name *type_name;
10843 : 31504 : struct c_expr ret;
10844 : 31504 : matching_parens parens;
10845 : 31504 : parens.consume_open (parser);
10846 : 31504 : loc = c_parser_peek_token (parser)->location;
10847 : 31504 : scspecs = c_parser_compound_literal_scspecs (parser);
10848 : 31504 : type_name = c_parser_type_name (parser, true);
10849 : 31504 : end_loc = c_parser_peek_token (parser)->location;
10850 : 31504 : parens.skip_until_found_close (parser);
10851 : 31504 : if (type_name == NULL)
10852 : : {
10853 : 0 : struct c_expr ret;
10854 : 0 : c_inhibit_evaluation_warnings--;
10855 : 0 : in_alignof--;
10856 : 0 : ret.set_error ();
10857 : 0 : ret.original_code = ERROR_MARK;
10858 : 0 : ret.original_type = NULL;
10859 : 31502 : return ret;
10860 : : }
10861 : 31504 : if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
10862 : : {
10863 : 2 : expr = c_parser_postfix_expression_after_paren_type (parser, scspecs,
10864 : : type_name,
10865 : : loc);
10866 : 2 : goto alignof_expr;
10867 : : }
10868 : : /* alignof ( type-name ). */
10869 : 31502 : if (scspecs)
10870 : 1 : error_at (loc, "storage class specifier in %qE", alignof_spelling);
10871 : 31502 : if (type_name->specs->alignas_p)
10872 : 1 : error_at (type_name->specs->locations[cdw_alignas],
10873 : : "alignment specified for type name in %qE",
10874 : : alignof_spelling);
10875 : 31502 : c_inhibit_evaluation_warnings--;
10876 : 31502 : in_alignof--;
10877 : 31502 : ret.value = c_sizeof_or_alignof_type (loc, groktypename (type_name,
10878 : : NULL, NULL),
10879 : : false, is_c11_alignof, 1);
10880 : 31502 : ret.original_code = ERROR_MARK;
10881 : 31502 : ret.original_type = NULL;
10882 : 31502 : set_c_expr_source_range (&ret, start_loc, end_loc);
10883 : 31502 : ret.m_decimal = 0;
10884 : 31502 : return ret;
10885 : : }
10886 : : else
10887 : : {
10888 : 40791 : struct c_expr ret;
10889 : 40791 : expr = c_parser_unary_expression (parser);
10890 : 40791 : end_loc = expr.src_range.m_finish;
10891 : 40793 : alignof_expr:
10892 : 40793 : mark_exp_read (expr.value);
10893 : 40793 : c_inhibit_evaluation_warnings--;
10894 : 40793 : in_alignof--;
10895 : 40793 : if (is_c11_alignof)
10896 : 36 : pedwarn (start_loc,
10897 : 36 : OPT_Wpedantic, "ISO C does not allow %<%E (expression)%>",
10898 : : alignof_spelling);
10899 : 40793 : ret.value = c_alignof_expr (start_loc, expr.value);
10900 : 40793 : ret.original_code = ERROR_MARK;
10901 : 40793 : ret.original_type = NULL;
10902 : 40793 : set_c_expr_source_range (&ret, start_loc, end_loc);
10903 : 40793 : ret.m_decimal = 0;
10904 : 40793 : return ret;
10905 : : }
10906 : : }
10907 : :
10908 : : /* Parse the __builtin_has_attribute ([expr|type], attribute-spec)
10909 : : expression. */
10910 : :
10911 : : static struct c_expr
10912 : 764 : c_parser_has_attribute_expression (c_parser *parser)
10913 : : {
10914 : 764 : gcc_assert (c_parser_next_token_is_keyword (parser,
10915 : : RID_BUILTIN_HAS_ATTRIBUTE));
10916 : 764 : location_t start = c_parser_peek_token (parser)->location;
10917 : 764 : c_parser_consume_token (parser);
10918 : :
10919 : 764 : c_inhibit_evaluation_warnings++;
10920 : :
10921 : 764 : matching_parens parens;
10922 : 764 : if (!parens.require_open (parser))
10923 : : {
10924 : 0 : c_inhibit_evaluation_warnings--;
10925 : 0 : in_typeof--;
10926 : :
10927 : 0 : struct c_expr result;
10928 : 0 : result.set_error ();
10929 : 0 : result.original_code = ERROR_MARK;
10930 : 0 : result.original_type = NULL;
10931 : 0 : return result;
10932 : : }
10933 : :
10934 : : /* Treat the type argument the same way as in typeof for the purposes
10935 : : of warnings. FIXME: Generalize this so the warning refers to
10936 : : __builtin_has_attribute rather than typeof. */
10937 : 764 : in_typeof++;
10938 : :
10939 : : /* The first operand: one of DECL, EXPR, or TYPE. */
10940 : 764 : tree oper = NULL_TREE;
10941 : 764 : if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
10942 : : {
10943 : 148 : struct c_type_name *tname = c_parser_type_name (parser);
10944 : 148 : in_typeof--;
10945 : 148 : if (tname)
10946 : : {
10947 : 148 : oper = groktypename (tname, NULL, NULL);
10948 : 148 : pop_maybe_used (c_type_variably_modified_p (oper));
10949 : : }
10950 : : }
10951 : : else
10952 : : {
10953 : 616 : struct c_expr cexpr = c_parser_expr_no_commas (parser, NULL);
10954 : 616 : c_inhibit_evaluation_warnings--;
10955 : 616 : in_typeof--;
10956 : 616 : if (cexpr.value != error_mark_node)
10957 : : {
10958 : 613 : mark_exp_read (cexpr.value);
10959 : 613 : oper = cexpr.value;
10960 : 613 : tree etype = TREE_TYPE (oper);
10961 : 613 : bool was_vm = c_type_variably_modified_p (etype);
10962 : : /* This is returned with the type so that when the type is
10963 : : evaluated, this can be evaluated. */
10964 : 613 : if (was_vm)
10965 : 0 : oper = c_fully_fold (oper, false, NULL);
10966 : 613 : pop_maybe_used (was_vm);
10967 : : }
10968 : : }
10969 : :
10970 : 764 : struct c_expr result;
10971 : 764 : result.original_code = ERROR_MARK;
10972 : 764 : result.original_type = NULL;
10973 : :
10974 : 764 : if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
10975 : : {
10976 : : /* Consume the closing parenthesis if that's the next token
10977 : : in the likely case the built-in was invoked with fewer
10978 : : than two arguments. */
10979 : 4 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
10980 : 4 : c_parser_consume_token (parser);
10981 : 4 : c_inhibit_evaluation_warnings--;
10982 : 4 : result.set_error ();
10983 : 4 : return result;
10984 : : }
10985 : :
10986 : 760 : bool save_translate_strings_p = parser->translate_strings_p;
10987 : :
10988 : 760 : location_t atloc = c_parser_peek_token (parser)->location;
10989 : : /* Parse a single attribute. Require no leading comma and do not
10990 : : allow empty attributes. */
10991 : 760 : tree attr = c_parser_gnu_attribute (parser, NULL_TREE, false, false);
10992 : :
10993 : 760 : parser->translate_strings_p = save_translate_strings_p;
10994 : :
10995 : 760 : location_t finish = c_parser_peek_token (parser)->location;
10996 : 760 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
10997 : 757 : c_parser_consume_token (parser);
10998 : : else
10999 : : {
11000 : 3 : c_parser_error (parser, "expected identifier");
11001 : 3 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11002 : :
11003 : 3 : result.set_error ();
11004 : 3 : return result;
11005 : : }
11006 : :
11007 : 757 : if (!attr)
11008 : : {
11009 : 0 : error_at (atloc, "expected identifier");
11010 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
11011 : : "expected %<)%>");
11012 : 0 : result.set_error ();
11013 : 0 : return result;
11014 : : }
11015 : :
11016 : 757 : result.original_code = INTEGER_CST;
11017 : 757 : result.original_type = boolean_type_node;
11018 : :
11019 : 757 : if (has_attribute (atloc, oper, attr, default_conversion))
11020 : 296 : result.value = boolean_true_node;
11021 : : else
11022 : 461 : result.value = boolean_false_node;
11023 : :
11024 : 757 : set_c_expr_source_range (&result, start, finish);
11025 : 757 : result.m_decimal = 0;
11026 : 757 : return result;
11027 : : }
11028 : :
11029 : : /* Helper function to read arguments of builtins which are interfaces
11030 : : for the middle-end nodes like COMPLEX_EXPR, VEC_PERM_EXPR and
11031 : : others. The name of the builtin is passed using BNAME parameter.
11032 : : Function returns true if there were no errors while parsing and
11033 : : stores the arguments in CEXPR_LIST. If it returns true,
11034 : : *OUT_CLOSE_PAREN_LOC is written to with the location of the closing
11035 : : parenthesis. */
11036 : : static bool
11037 : 1527672 : c_parser_get_builtin_args (c_parser *parser, const char *bname,
11038 : : vec<c_expr_t, va_gc> **ret_cexpr_list,
11039 : : bool choose_expr_p,
11040 : : location_t *out_close_paren_loc)
11041 : : {
11042 : 1527672 : location_t loc = c_parser_peek_token (parser)->location;
11043 : 1527672 : vec<c_expr_t, va_gc> *cexpr_list;
11044 : 1527672 : c_expr_t expr;
11045 : 1527672 : bool saved_force_folding_builtin_constant_p;
11046 : :
11047 : 1527672 : *ret_cexpr_list = NULL;
11048 : 1527672 : if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
11049 : : {
11050 : 1 : error_at (loc, "cannot take address of %qs", bname);
11051 : 1 : return false;
11052 : : }
11053 : :
11054 : 1527671 : c_parser_consume_token (parser);
11055 : :
11056 : 1527671 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
11057 : : {
11058 : 18 : *out_close_paren_loc = c_parser_peek_token (parser)->location;
11059 : 18 : c_parser_consume_token (parser);
11060 : 18 : return true;
11061 : : }
11062 : :
11063 : 1527653 : saved_force_folding_builtin_constant_p
11064 : 1527653 : = force_folding_builtin_constant_p;
11065 : 1527653 : force_folding_builtin_constant_p |= choose_expr_p;
11066 : 1527653 : expr = c_parser_expr_no_commas (parser, NULL);
11067 : 1527653 : force_folding_builtin_constant_p
11068 : 1527653 : = saved_force_folding_builtin_constant_p;
11069 : 1527653 : vec_alloc (cexpr_list, 1);
11070 : 1527653 : vec_safe_push (cexpr_list, expr);
11071 : 17861121 : while (c_parser_next_token_is (parser, CPP_COMMA))
11072 : : {
11073 : 14805815 : c_parser_consume_token (parser);
11074 : 14805815 : if (c_parser_next_token_is (parser, CPP_EMBED))
11075 : : {
11076 : 2 : c_token *embed = c_parser_peek_token (parser);
11077 : 2 : tree value = embed->value;
11078 : 2 : expr.original_code = INTEGER_CST;
11079 : 2 : expr.original_type = integer_type_node;
11080 : 2 : expr.value = NULL_TREE;
11081 : 2 : set_c_expr_source_range (&expr, embed->get_range ());
11082 : 2 : expr.m_decimal = 0;
11083 : 510 : for (unsigned int i = 0; i < (unsigned) RAW_DATA_LENGTH (value); i++)
11084 : : {
11085 : 1016 : expr.value = build_int_cst (integer_type_node,
11086 : 508 : RAW_DATA_UCHAR_ELT (value, i));
11087 : 508 : vec_safe_push (cexpr_list, expr);
11088 : : }
11089 : 2 : c_parser_consume_token (parser);
11090 : 2 : continue;
11091 : 2 : }
11092 : 14805813 : expr = c_parser_expr_no_commas (parser, NULL);
11093 : 14805813 : vec_safe_push (cexpr_list, expr);
11094 : : }
11095 : :
11096 : 1527653 : *out_close_paren_loc = c_parser_peek_token (parser)->location;
11097 : 1527653 : if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
11098 : : return false;
11099 : :
11100 : 1527653 : *ret_cexpr_list = cexpr_list;
11101 : 1527653 : return true;
11102 : : }
11103 : :
11104 : : /* This represents a single generic-association. */
11105 : :
11106 : : struct c_generic_association
11107 : : {
11108 : : /* The location of the starting token of the type. */
11109 : : location_t type_location;
11110 : : /* The association's type, or NULL_TREE for 'default'. */
11111 : : tree type;
11112 : : /* The association's expression. */
11113 : : struct c_expr expression;
11114 : : };
11115 : :
11116 : : /* Parse a generic-selection. (C11 6.5.1.1).
11117 : :
11118 : : generic-selection:
11119 : : _Generic ( generic-controlling-operand , generic-assoc-list )
11120 : :
11121 : : generic-controlling-operand:
11122 : : assignment-expression
11123 : : type-name
11124 : :
11125 : : (The use of a type-name is new in C2Y.)
11126 : :
11127 : : generic-assoc-list:
11128 : : generic-association
11129 : : generic-assoc-list , generic-association
11130 : :
11131 : : generic-association:
11132 : : type-name : assignment-expression
11133 : : default : assignment-expression
11134 : : */
11135 : :
11136 : : static struct c_expr
11137 : 622 : c_parser_generic_selection (c_parser *parser)
11138 : : {
11139 : 622 : struct c_expr selector, error_expr;
11140 : 622 : tree selector_type;
11141 : 622 : struct c_generic_association matched_assoc;
11142 : 622 : int match_found = -1;
11143 : 622 : location_t generic_loc, selector_loc;
11144 : :
11145 : 622 : error_expr.original_code = ERROR_MARK;
11146 : 622 : error_expr.original_type = NULL;
11147 : 622 : error_expr.set_error ();
11148 : 622 : matched_assoc.type_location = UNKNOWN_LOCATION;
11149 : 622 : matched_assoc.type = NULL_TREE;
11150 : 622 : matched_assoc.expression = error_expr;
11151 : :
11152 : 622 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_GENERIC));
11153 : 622 : generic_loc = c_parser_peek_token (parser)->location;
11154 : 622 : c_parser_consume_token (parser);
11155 : 622 : if (flag_isoc99)
11156 : 620 : pedwarn_c99 (generic_loc, OPT_Wpedantic,
11157 : : "ISO C99 does not support %<_Generic%>");
11158 : : else
11159 : 2 : pedwarn_c99 (generic_loc, OPT_Wpedantic,
11160 : : "ISO C90 does not support %<_Generic%>");
11161 : :
11162 : 622 : matching_parens parens;
11163 : 622 : if (!parens.require_open (parser))
11164 : 0 : return error_expr;
11165 : :
11166 : 622 : selector_loc = c_parser_peek_token (parser)->location;
11167 : 622 : if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
11168 : : {
11169 : 31 : c_inhibit_evaluation_warnings++;
11170 : 31 : pedwarn_c23 (selector_loc, OPT_Wpedantic,
11171 : : "ISO C does not support use of type name as %<_Generic%> "
11172 : : "controlling operand before C2Y");
11173 : 31 : struct c_type_name *type = c_parser_type_name (parser);
11174 : 31 : if (type)
11175 : 30 : selector_type = groktypename (type, NULL, NULL);
11176 : 31 : c_inhibit_evaluation_warnings--;
11177 : 31 : if (!type)
11178 : : {
11179 : 1 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11180 : 1 : return error_expr;
11181 : : }
11182 : : }
11183 : : else
11184 : : {
11185 : 591 : c_inhibit_evaluation_warnings++;
11186 : 591 : selector = c_parser_expr_no_commas (parser, NULL);
11187 : 591 : selector = default_function_array_conversion (selector_loc, selector);
11188 : 591 : c_inhibit_evaluation_warnings--;
11189 : :
11190 : 591 : if (selector.value == error_mark_node)
11191 : : {
11192 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11193 : 0 : return selector;
11194 : : }
11195 : 591 : mark_exp_read (selector.value);
11196 : 591 : selector_type = TREE_TYPE (selector.value);
11197 : : /* In ISO C terms, rvalues (including the controlling expression
11198 : : of _Generic) do not have qualified types. */
11199 : 591 : if (TREE_CODE (selector_type) != ARRAY_TYPE)
11200 : 591 : selector_type = TYPE_MAIN_VARIANT (selector_type);
11201 : : /* In ISO C terms, _Noreturn is not part of the type of expressions
11202 : : such as &abort, but in GCC it is represented internally as a type
11203 : : qualifier. */
11204 : 58 : if (FUNCTION_POINTER_TYPE_P (selector_type)
11205 : 595 : && TYPE_QUALS (TREE_TYPE (selector_type)) != TYPE_UNQUALIFIED)
11206 : 1 : selector_type
11207 : 1 : = c_build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (selector_type)));
11208 : : }
11209 : :
11210 : 621 : if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
11211 : : {
11212 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11213 : 0 : return error_expr;
11214 : : }
11215 : :
11216 : 621 : auto_vec<c_generic_association> associations;
11217 : 1779 : while (1)
11218 : : {
11219 : 1200 : struct c_generic_association assoc, *iter;
11220 : 1200 : unsigned int ix;
11221 : 1200 : c_token *token = c_parser_peek_token (parser);
11222 : :
11223 : 1200 : assoc.type_location = token->location;
11224 : 1200 : if (token->type == CPP_KEYWORD && token->keyword == RID_DEFAULT)
11225 : : {
11226 : 476 : c_parser_consume_token (parser);
11227 : 476 : assoc.type = NULL_TREE;
11228 : : }
11229 : : else
11230 : : {
11231 : 724 : struct c_type_name *type_name;
11232 : :
11233 : 724 : type_name = c_parser_type_name (parser);
11234 : 724 : if (type_name == NULL)
11235 : : {
11236 : 1 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11237 : 1 : return error_expr;
11238 : : }
11239 : 723 : assoc.type = groktypename (type_name, NULL, NULL);
11240 : 723 : if (assoc.type == error_mark_node)
11241 : : {
11242 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11243 : 0 : return error_expr;
11244 : : }
11245 : :
11246 : 723 : if (TREE_CODE (assoc.type) == FUNCTION_TYPE)
11247 : 9 : pedwarn_c23 (assoc.type_location, OPT_Wpedantic,
11248 : : "ISO C does not support %<_Generic%> association with "
11249 : : "function type before C2Y");
11250 : 714 : else if (!COMPLETE_TYPE_P (assoc.type))
11251 : 13 : pedwarn_c23 (assoc.type_location, OPT_Wpedantic,
11252 : : "ISO C does not support %<_Generic%> association with "
11253 : : "incomplete type before C2Y");
11254 : :
11255 : 723 : if (c_type_variably_modified_p (assoc.type))
11256 : 2 : error_at (assoc.type_location,
11257 : : "%<_Generic%> association has "
11258 : : "variable length type");
11259 : : }
11260 : :
11261 : 1199 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
11262 : : {
11263 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11264 : 0 : return error_expr;
11265 : : }
11266 : :
11267 : 1199 : bool match = assoc.type == NULL_TREE
11268 : 1199 : || comptypes (assoc.type, selector_type);
11269 : :
11270 : 147 : if (!match)
11271 : 147 : c_inhibit_evaluation_warnings++;
11272 : :
11273 : 1199 : assoc.expression = c_parser_expr_no_commas (parser, NULL);
11274 : :
11275 : 1199 : if (!match)
11276 : 147 : c_inhibit_evaluation_warnings--;
11277 : :
11278 : 1199 : if (assoc.expression.value == error_mark_node)
11279 : : {
11280 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11281 : 0 : return error_expr;
11282 : : }
11283 : :
11284 : 1892 : for (ix = 0; associations.iterate (ix, &iter); ++ix)
11285 : : {
11286 : 693 : if (assoc.type == NULL_TREE)
11287 : : {
11288 : 190 : if (iter->type == NULL_TREE)
11289 : : {
11290 : 1 : error_at (assoc.type_location,
11291 : : "duplicate %<default%> case in %<_Generic%>");
11292 : 1 : inform (iter->type_location, "original %<default%> is here");
11293 : : }
11294 : : }
11295 : 503 : else if (iter->type != NULL_TREE)
11296 : : {
11297 : 169 : if (comptypes (assoc.type, iter->type))
11298 : : {
11299 : 1 : error_at (assoc.type_location,
11300 : : "%<_Generic%> specifies two compatible types");
11301 : 1 : inform (iter->type_location, "compatible type is here");
11302 : : }
11303 : : }
11304 : : }
11305 : :
11306 : 1199 : if (assoc.type == NULL_TREE)
11307 : : {
11308 : 476 : if (match_found < 0)
11309 : : {
11310 : 333 : matched_assoc = assoc;
11311 : 364 : match_found = associations.length ();
11312 : : }
11313 : : }
11314 : 723 : else if (match)
11315 : : {
11316 : 576 : if (match_found < 0 || matched_assoc.type == NULL_TREE)
11317 : : {
11318 : 576 : matched_assoc = assoc;
11319 : 906 : match_found = associations.length ();
11320 : : }
11321 : : else
11322 : : {
11323 : 0 : error_at (assoc.type_location,
11324 : : "%<_Generic%> selector matches multiple associations");
11325 : 0 : inform (matched_assoc.type_location,
11326 : : "other match is here");
11327 : : }
11328 : : }
11329 : :
11330 : 1199 : associations.safe_push (assoc);
11331 : :
11332 : 1199 : if (c_parser_peek_token (parser)->type != CPP_COMMA)
11333 : : break;
11334 : 579 : c_parser_consume_token (parser);
11335 : 579 : }
11336 : :
11337 : 620 : unsigned int ix;
11338 : 620 : struct c_generic_association *iter;
11339 : 1818 : FOR_EACH_VEC_ELT (associations, ix, iter)
11340 : 1198 : if (ix != (unsigned) match_found)
11341 : 582 : mark_exp_read (iter->expression.value);
11342 : :
11343 : 620 : if (!parens.require_close (parser))
11344 : : {
11345 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11346 : 0 : return error_expr;
11347 : : }
11348 : :
11349 : 620 : if (match_found < 0)
11350 : : {
11351 : 4 : error_at (selector_loc, "%<_Generic%> selector of type %qT is not "
11352 : : "compatible with any association",
11353 : : selector_type);
11354 : 4 : return error_expr;
11355 : : }
11356 : :
11357 : 616 : return matched_assoc.expression;
11358 : 621 : }
11359 : :
11360 : : /* Check the validity of a function pointer argument *EXPR (argument
11361 : : position POS) to __builtin_tgmath. Return the number of function
11362 : : arguments if possibly valid; return 0 having reported an error if
11363 : : not valid. */
11364 : :
11365 : : static unsigned int
11366 : 1755 : check_tgmath_function (c_expr *expr, unsigned int pos)
11367 : : {
11368 : 1755 : tree type = TREE_TYPE (expr->value);
11369 : 1755 : if (!FUNCTION_POINTER_TYPE_P (type))
11370 : : {
11371 : 2 : error_at (expr->get_location (),
11372 : : "argument %u of %<__builtin_tgmath%> is not a function pointer",
11373 : : pos);
11374 : 2 : return 0;
11375 : : }
11376 : 1753 : type = TREE_TYPE (type);
11377 : 1753 : if (!prototype_p (type))
11378 : : {
11379 : 2 : error_at (expr->get_location (),
11380 : : "argument %u of %<__builtin_tgmath%> is unprototyped", pos);
11381 : 2 : return 0;
11382 : : }
11383 : 1751 : if (stdarg_p (type))
11384 : : {
11385 : 2 : error_at (expr->get_location (),
11386 : : "argument %u of %<__builtin_tgmath%> has variable arguments",
11387 : : pos);
11388 : 2 : return 0;
11389 : : }
11390 : 1749 : unsigned int nargs = 0;
11391 : 1749 : function_args_iterator iter;
11392 : 1749 : tree t;
11393 : 4176 : FOREACH_FUNCTION_ARGS (type, t, iter)
11394 : : {
11395 : 4176 : if (t == void_type_node)
11396 : : break;
11397 : 2427 : nargs++;
11398 : : }
11399 : 1749 : if (nargs == 0)
11400 : : {
11401 : 2 : error_at (expr->get_location (),
11402 : : "argument %u of %<__builtin_tgmath%> has no arguments", pos);
11403 : 2 : return 0;
11404 : : }
11405 : : return nargs;
11406 : : }
11407 : :
11408 : : /* Ways in which a parameter or return value of a type-generic macro
11409 : : may vary between the different functions the macro may call. */
11410 : : enum tgmath_parm_kind
11411 : : {
11412 : : tgmath_fixed, tgmath_real, tgmath_complex
11413 : : };
11414 : :
11415 : : /* Helper function for c_parser_postfix_expression. Parse predefined
11416 : : identifiers. */
11417 : :
11418 : : static struct c_expr
11419 : 13087 : c_parser_predefined_identifier (c_parser *parser)
11420 : : {
11421 : 13087 : location_t loc = c_parser_peek_token (parser)->location;
11422 : 13087 : switch (c_parser_peek_token (parser)->keyword)
11423 : : {
11424 : 709 : case RID_FUNCTION_NAME:
11425 : 709 : pedwarn (loc, OPT_Wpedantic, "ISO C does not support %qs predefined "
11426 : : "identifier", "__FUNCTION__");
11427 : 709 : break;
11428 : 6111 : case RID_PRETTY_FUNCTION_NAME:
11429 : 6111 : pedwarn (loc, OPT_Wpedantic, "ISO C does not support %qs predefined "
11430 : : "identifier", "__PRETTY_FUNCTION__");
11431 : 6111 : break;
11432 : 6267 : case RID_C99_FUNCTION_NAME:
11433 : 6267 : pedwarn_c90 (loc, OPT_Wpedantic, "ISO C90 does not support "
11434 : : "%<__func__%> predefined identifier");
11435 : 6267 : break;
11436 : 0 : default:
11437 : 0 : gcc_unreachable ();
11438 : : }
11439 : :
11440 : 13087 : struct c_expr expr;
11441 : 13087 : expr.original_code = ERROR_MARK;
11442 : 13087 : expr.original_type = NULL;
11443 : 13087 : expr.value = fname_decl (loc, c_parser_peek_token (parser)->keyword,
11444 : 13087 : c_parser_peek_token (parser)->value);
11445 : 13087 : set_c_expr_source_range (&expr, loc, loc);
11446 : 13087 : expr.m_decimal = 0;
11447 : 13087 : c_parser_consume_token (parser);
11448 : 13087 : return expr;
11449 : : }
11450 : :
11451 : : /* Check whether the ARRAY_REF has an counted-by object associated with it
11452 : : through the "counted_by" attribute. */
11453 : :
11454 : : static bool
11455 : 40 : has_counted_by_object (tree array_ref)
11456 : : {
11457 : : /* Currently, only when the array_ref is an indirect_ref to a call to the
11458 : : .ACCESS_WITH_SIZE, return true.
11459 : : More cases can be included later when the counted_by attribute is
11460 : : extended to other situations. */
11461 : 40 : if (TREE_CODE (array_ref) == INDIRECT_REF
11462 : 40 : && is_access_with_size_p (TREE_OPERAND (array_ref, 0)))
11463 : : return true;
11464 : : return false;
11465 : : }
11466 : :
11467 : : /* Get the reference to the counted-by object associated with the ARRAY_REF. */
11468 : :
11469 : : static tree
11470 : 25 : get_counted_by_ref (tree array_ref)
11471 : : {
11472 : : /* Currently, only when the array_ref is an indirect_ref to a call to the
11473 : : .ACCESS_WITH_SIZE, get the corresponding counted_by ref.
11474 : : More cases can be included later when the counted_by attribute is
11475 : : extended to other situations. */
11476 : 25 : if (TREE_CODE (array_ref) == INDIRECT_REF
11477 : 25 : && is_access_with_size_p (TREE_OPERAND (array_ref, 0)))
11478 : 25 : return CALL_EXPR_ARG (TREE_OPERAND (array_ref, 0), 1);
11479 : : return NULL_TREE;
11480 : : }
11481 : :
11482 : : /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2,
11483 : : C11 6.5.1-6.5.2). Compound literals aren't handled here; callers have to
11484 : : call c_parser_postfix_expression_after_paren_type on encountering them.
11485 : :
11486 : : postfix-expression:
11487 : : primary-expression
11488 : : postfix-expression [ expression ]
11489 : : postfix-expression ( argument-expression-list[opt] )
11490 : : postfix-expression . identifier
11491 : : postfix-expression -> identifier
11492 : : postfix-expression ++
11493 : : postfix-expression --
11494 : : ( storage-class-specifiers[opt] type-name ) { initializer-list[opt] }
11495 : : ( storage-class-specifiers[opt] type-name ) { initializer-list , }
11496 : :
11497 : : argument-expression-list:
11498 : : argument-expression
11499 : : argument-expression-list , argument-expression
11500 : :
11501 : : primary-expression:
11502 : : identifier
11503 : : constant
11504 : : string-literal
11505 : : ( expression )
11506 : : generic-selection
11507 : :
11508 : : GNU extensions:
11509 : :
11510 : : primary-expression:
11511 : : __func__
11512 : : (treated as a keyword in GNU C)
11513 : : __FUNCTION__
11514 : : __PRETTY_FUNCTION__
11515 : : ( compound-statement )
11516 : : __builtin_va_arg ( assignment-expression , type-name )
11517 : : __builtin_offsetof ( type-name , offsetof-member-designator )
11518 : : __builtin_choose_expr ( assignment-expression ,
11519 : : assignment-expression ,
11520 : : assignment-expression )
11521 : : __builtin_types_compatible_p ( type-name , type-name )
11522 : : __builtin_tgmath ( expr-list )
11523 : : __builtin_complex ( assignment-expression , assignment-expression )
11524 : : __builtin_shuffle ( assignment-expression , assignment-expression )
11525 : : __builtin_shuffle ( assignment-expression ,
11526 : : assignment-expression ,
11527 : : assignment-expression, )
11528 : : __builtin_convertvector ( assignment-expression , type-name )
11529 : : __builtin_assoc_barrier ( assignment-expression )
11530 : :
11531 : : offsetof-member-designator:
11532 : : identifier
11533 : : offsetof-member-designator . identifier
11534 : : offsetof-member-designator [ expression ]
11535 : :
11536 : : Objective-C:
11537 : :
11538 : : primary-expression:
11539 : : [ objc-receiver objc-message-args ]
11540 : : @selector ( objc-selector-arg )
11541 : : @protocol ( identifier )
11542 : : @encode ( type-name )
11543 : : objc-string-literal
11544 : : Classname . identifier
11545 : : */
11546 : :
11547 : : static struct c_expr
11548 : 230663835 : c_parser_postfix_expression (c_parser *parser)
11549 : : {
11550 : 230663835 : struct c_expr expr, e1;
11551 : 230663835 : struct c_type_name *t1, *t2;
11552 : 230663835 : location_t loc = c_parser_peek_token (parser)->location;
11553 : 230663835 : source_range tok_range = c_parser_peek_token (parser)->get_range ();
11554 : 230663835 : expr.original_code = ERROR_MARK;
11555 : 230663835 : expr.original_type = NULL;
11556 : 230663835 : expr.m_decimal = 0;
11557 : 230663835 : switch (c_parser_peek_token (parser)->type)
11558 : : {
11559 : 49858909 : case CPP_NUMBER:
11560 : 49858909 : expr.value = c_parser_peek_token (parser)->value;
11561 : 49858909 : set_c_expr_source_range (&expr, tok_range);
11562 : 49858909 : loc = c_parser_peek_token (parser)->location;
11563 : 49858909 : expr.m_decimal = c_parser_peek_token (parser)->flags & DECIMAL_INT;
11564 : 49858909 : c_parser_consume_token (parser);
11565 : 49858909 : if (TREE_CODE (expr.value) == FIXED_CST
11566 : 49858909 : && !targetm.fixed_point_supported_p ())
11567 : : {
11568 : 6 : error_at (loc, "fixed-point types not supported for this target");
11569 : 6 : expr.set_error ();
11570 : : }
11571 : : break;
11572 : 113085 : case CPP_CHAR:
11573 : 113085 : case CPP_CHAR16:
11574 : 113085 : case CPP_CHAR32:
11575 : 113085 : case CPP_UTF8CHAR:
11576 : 113085 : case CPP_WCHAR:
11577 : 113085 : expr.value = c_parser_peek_token (parser)->value;
11578 : : /* For the purpose of warning when a pointer is compared with
11579 : : a zero character constant. */
11580 : 113085 : expr.original_type = char_type_node;
11581 : 113085 : set_c_expr_source_range (&expr, tok_range);
11582 : 113085 : c_parser_consume_token (parser);
11583 : 113085 : break;
11584 : 1152828 : case CPP_STRING:
11585 : 1152828 : case CPP_STRING16:
11586 : 1152828 : case CPP_STRING32:
11587 : 1152828 : case CPP_WSTRING:
11588 : 1152828 : case CPP_UTF8STRING:
11589 : 1152828 : expr = c_parser_string_literal (parser, parser->translate_strings_p,
11590 : : true);
11591 : 1152828 : break;
11592 : 0 : case CPP_OBJC_STRING:
11593 : 0 : gcc_assert (c_dialect_objc ());
11594 : 0 : expr.value
11595 : 0 : = objc_build_string_object (c_parser_peek_token (parser)->value);
11596 : 0 : set_c_expr_source_range (&expr, tok_range);
11597 : 0 : c_parser_consume_token (parser);
11598 : 0 : break;
11599 : 170537343 : case CPP_NAME:
11600 : 170537343 : switch (c_parser_peek_token (parser)->id_kind)
11601 : : {
11602 : 170537341 : case C_ID_ID:
11603 : 170537341 : {
11604 : 170537341 : tree id = c_parser_peek_token (parser)->value;
11605 : 170537341 : c_parser_consume_token (parser);
11606 : 511612023 : expr.value = build_external_ref (loc, id,
11607 : 170537341 : (c_parser_peek_token (parser)->type
11608 : : == CPP_OPEN_PAREN),
11609 : : &expr.original_type);
11610 : 170537341 : set_c_expr_source_range (&expr, tok_range);
11611 : 170537341 : break;
11612 : : }
11613 : 0 : case C_ID_CLASSNAME:
11614 : 0 : {
11615 : : /* Here we parse the Objective-C 2.0 Class.name dot
11616 : : syntax. */
11617 : 0 : tree class_name = c_parser_peek_token (parser)->value;
11618 : 0 : tree component;
11619 : 0 : c_parser_consume_token (parser);
11620 : 0 : gcc_assert (c_dialect_objc ());
11621 : 0 : if (!c_parser_require (parser, CPP_DOT, "expected %<.%>"))
11622 : : {
11623 : 0 : expr.set_error ();
11624 : 0 : break;
11625 : : }
11626 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
11627 : : {
11628 : 0 : c_parser_error (parser, "expected identifier");
11629 : 0 : expr.set_error ();
11630 : 0 : break;
11631 : : }
11632 : 0 : c_token *component_tok = c_parser_peek_token (parser);
11633 : 0 : component = component_tok->value;
11634 : 0 : location_t end_loc = component_tok->get_finish ();
11635 : 0 : c_parser_consume_token (parser);
11636 : 0 : expr.value = objc_build_class_component_ref (class_name,
11637 : : component);
11638 : 0 : set_c_expr_source_range (&expr, loc, end_loc);
11639 : 0 : break;
11640 : : }
11641 : 2 : default:
11642 : 2 : c_parser_error (parser, "expected expression");
11643 : 2 : expr.set_error ();
11644 : 2 : break;
11645 : : }
11646 : : break;
11647 : 7402272 : case CPP_OPEN_PAREN:
11648 : : /* A parenthesized expression, statement expression or compound
11649 : : literal. */
11650 : 7402272 : if (c_parser_peek_2nd_token (parser)->type == CPP_OPEN_BRACE)
11651 : : {
11652 : : /* A statement expression. */
11653 : 34749 : tree stmt;
11654 : 34749 : location_t brace_loc;
11655 : 34749 : bool save_c_omp_array_section_p = c_omp_array_section_p;
11656 : 34749 : c_parser_consume_token (parser);
11657 : 34749 : brace_loc = c_parser_peek_token (parser)->location;
11658 : 34749 : c_parser_consume_token (parser);
11659 : : /* If we've not yet started the current function's statement list,
11660 : : or we're in the parameter scope of an old-style function
11661 : : declaration, statement expressions are not allowed. */
11662 : 34749 : if (!building_stmt_list_p () || old_style_parameter_scope ())
11663 : : {
11664 : 24 : error_at (loc, "braced-group within expression allowed "
11665 : : "only inside a function");
11666 : 24 : parser->error = true;
11667 : 24 : c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
11668 : 24 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11669 : 24 : expr.set_error ();
11670 : 24 : break;
11671 : : }
11672 : 34725 : c_omp_array_section_p = false;
11673 : 34725 : stmt = c_begin_stmt_expr ();
11674 : 34725 : c_parser_compound_statement_nostart (parser);
11675 : 34725 : location_t close_loc = c_parser_peek_token (parser)->location;
11676 : 34725 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
11677 : : "expected %<)%>");
11678 : 34725 : pedwarn (loc, OPT_Wpedantic,
11679 : : "ISO C forbids braced-groups within expressions");
11680 : 34725 : expr.value = c_finish_stmt_expr (brace_loc, stmt);
11681 : 34725 : set_c_expr_source_range (&expr, loc, close_loc);
11682 : 34725 : mark_exp_read (expr.value);
11683 : 34725 : c_omp_array_section_p = save_c_omp_array_section_p;
11684 : : }
11685 : : else
11686 : : {
11687 : : /* A parenthesized expression. */
11688 : 7367523 : location_t loc_open_paren = c_parser_peek_token (parser)->location;
11689 : 7367523 : c_parser_consume_token (parser);
11690 : 7367523 : expr = c_parser_expression (parser);
11691 : 7367523 : if (TREE_CODE (expr.value) == MODIFY_EXPR)
11692 : 37734 : suppress_warning (expr.value, OPT_Wparentheses);
11693 : 7367523 : if (expr.original_code != C_MAYBE_CONST_EXPR
11694 : 7367511 : && expr.original_code != SIZEOF_EXPR)
11695 : 7362633 : expr.original_code = ERROR_MARK;
11696 : : /* Remember that we saw ( ) around the sizeof. */
11697 : 7367523 : if (expr.original_code == SIZEOF_EXPR)
11698 : 4878 : expr.original_code = PAREN_SIZEOF_EXPR;
11699 : : /* Don't change EXPR.ORIGINAL_TYPE. */
11700 : 7367523 : location_t loc_close_paren = c_parser_peek_token (parser)->location;
11701 : 7367523 : set_c_expr_source_range (&expr, loc_open_paren, loc_close_paren);
11702 : 7367523 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
11703 : : "expected %<)%>", loc_open_paren);
11704 : : }
11705 : : break;
11706 : 1598605 : case CPP_KEYWORD:
11707 : 1598605 : switch (c_parser_peek_token (parser)->keyword)
11708 : : {
11709 : 13067 : case RID_FUNCTION_NAME:
11710 : 13067 : case RID_PRETTY_FUNCTION_NAME:
11711 : 13067 : case RID_C99_FUNCTION_NAME:
11712 : 13067 : expr = c_parser_predefined_identifier (parser);
11713 : 13067 : break;
11714 : 19906 : case RID_VA_ARG:
11715 : 19906 : {
11716 : 19906 : location_t start_loc = loc;
11717 : 19906 : c_parser_consume_token (parser);
11718 : 19906 : matching_parens parens;
11719 : 19906 : if (!parens.require_open (parser))
11720 : : {
11721 : 0 : expr.set_error ();
11722 : 0 : break;
11723 : : }
11724 : 19906 : e1 = c_parser_expr_no_commas (parser, NULL);
11725 : 19906 : mark_exp_read (e1.value);
11726 : 19906 : e1.value = c_fully_fold (e1.value, false, NULL);
11727 : 19906 : if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
11728 : : {
11729 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11730 : 0 : expr.set_error ();
11731 : 0 : break;
11732 : : }
11733 : 19906 : loc = c_parser_peek_token (parser)->location;
11734 : 19906 : t1 = c_parser_type_name (parser);
11735 : 19906 : location_t end_loc = c_parser_peek_token (parser)->get_finish ();
11736 : 19906 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
11737 : : "expected %<)%>");
11738 : 19906 : if (t1 == NULL)
11739 : : {
11740 : 0 : expr.set_error ();
11741 : : }
11742 : : else
11743 : : {
11744 : 19906 : tree type_expr = NULL_TREE;
11745 : 19906 : expr.value = c_build_va_arg (start_loc, e1.value, loc,
11746 : : groktypename (t1, &type_expr, NULL));
11747 : 19906 : if (type_expr)
11748 : : {
11749 : 24 : expr.value = build2 (C_MAYBE_CONST_EXPR,
11750 : 24 : TREE_TYPE (expr.value), type_expr,
11751 : : expr.value);
11752 : 24 : C_MAYBE_CONST_EXPR_NON_CONST (expr.value) = true;
11753 : : }
11754 : 19906 : set_c_expr_source_range (&expr, start_loc, end_loc);
11755 : : }
11756 : : }
11757 : 19906 : break;
11758 : 13596 : case RID_C23_VA_START:
11759 : 13596 : {
11760 : 13596 : c_parser_consume_token (parser);
11761 : 13596 : matching_parens parens;
11762 : 13596 : if (!parens.require_open (parser))
11763 : : {
11764 : 0 : expr.set_error ();
11765 : 0 : break;
11766 : : }
11767 : 13596 : e1 = c_parser_expr_no_commas (parser, NULL);
11768 : 13596 : e1 = convert_lvalue_to_rvalue (e1.get_location (), e1, true, true);
11769 : 13596 : if (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
11770 : : {
11771 : 13418 : location_t cloc = c_parser_peek_token (parser)->location;
11772 : 13418 : if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
11773 : : {
11774 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11775 : 0 : expr.set_error ();
11776 : 0 : break;
11777 : : }
11778 : 13418 : if (c_parser_next_token_is (parser, CPP_NAME)
11779 : 13413 : && c_parser_peek_token (parser)->id_kind == C_ID_ID
11780 : 26831 : && (c_parser_peek_2nd_token (parser)->type
11781 : : == CPP_CLOSE_PAREN))
11782 : : {
11783 : 13392 : tree name = c_parser_peek_token (parser)->value;
11784 : 13392 : location_t nloc = c_parser_peek_token (parser)->location;
11785 : 13392 : tree decl = lookup_name (name);
11786 : 13392 : tree last_parm
11787 : 13392 : = tree_last (DECL_ARGUMENTS (current_function_decl));
11788 : 13392 : if (!last_parm || decl != last_parm)
11789 : 4 : warning_at (nloc, OPT_Wvarargs,
11790 : : "optional second parameter of %<va_start%> "
11791 : : "not last named argument");
11792 : 13388 : else if (DECL_REGISTER (decl))
11793 : 2 : warning_at (nloc, OPT_Wvarargs,
11794 : : "undefined behavior when second parameter "
11795 : : "of %<va_start%> is declared with "
11796 : : "%<register%> storage");
11797 : 13392 : c_parser_consume_token (parser);
11798 : : }
11799 : : else
11800 : : {
11801 : 26 : unsigned nesting_depth = 0;
11802 : 26 : location_t sloc = c_parser_peek_token (parser)->location;
11803 : 26 : location_t eloc = sloc;
11804 : :
11805 : : /* For va_start (ap,) the ) comes from stdarg.h.
11806 : : Use location of , in that case, otherwise without
11807 : : -Wsystem-headers nothing is reported. After all,
11808 : : the problematic token is the comma in that case. */
11809 : 26 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
11810 : 1 : sloc = eloc = cloc;
11811 : 492 : while (true)
11812 : : {
11813 : 259 : c_token *token = c_parser_peek_token (parser);
11814 : 259 : if (token->type == CPP_CLOSE_PAREN && !nesting_depth)
11815 : : break;
11816 : :
11817 : 233 : if (token->type == CPP_EOF)
11818 : : break;
11819 : 233 : if (token->type == CPP_OPEN_PAREN)
11820 : 8 : ++nesting_depth;
11821 : 225 : else if (token->type == CPP_CLOSE_PAREN)
11822 : 8 : --nesting_depth;
11823 : 233 : eloc = token->location;
11824 : 233 : c_parser_consume_token (parser);
11825 : 233 : }
11826 : 26 : if (sloc != eloc)
11827 : 25 : sloc = make_location (sloc, sloc, eloc);
11828 : 26 : warning_at (sloc, OPT_Wvarargs,
11829 : : "%<va_start%> macro used with additional "
11830 : : "arguments other than identifier of the "
11831 : : "last named argument");
11832 : : }
11833 : : }
11834 : 13596 : parens.skip_until_found_close (parser);
11835 : 13596 : tree fndecl = builtin_decl_explicit (BUILT_IN_VA_START);
11836 : 13596 : vec<tree, va_gc> *params;
11837 : 13596 : vec_alloc (params, 2);
11838 : 13596 : params->quick_push (e1.value);
11839 : 13596 : params->quick_push (integer_zero_node);
11840 : 13596 : auto_vec<location_t> arg_loc (2);
11841 : 13596 : arg_loc.quick_push (e1.get_location ());
11842 : 13596 : arg_loc.quick_push (UNKNOWN_LOCATION);
11843 : 13596 : expr.value = c_build_function_call_vec (loc, arg_loc, fndecl,
11844 : : params, NULL);
11845 : 13596 : set_c_expr_source_range (&expr, loc,
11846 : : parser->tokens_buf[0].get_finish ());
11847 : 13596 : expr.m_decimal = 0;
11848 : 13596 : expr.original_code = ERROR_MARK;
11849 : 13596 : expr.original_type = NULL;
11850 : 13596 : release_tree_vector (params);
11851 : 13596 : break;
11852 : 13596 : }
11853 : 3612 : case RID_OFFSETOF:
11854 : 3612 : {
11855 : 3612 : c_parser_consume_token (parser);
11856 : 3612 : matching_parens parens;
11857 : 3612 : if (!parens.require_open (parser))
11858 : : {
11859 : 0 : expr.set_error ();
11860 : 1 : break;
11861 : : }
11862 : 3612 : t1 = c_parser_type_name (parser);
11863 : 3612 : if (t1 == NULL)
11864 : 0 : parser->error = true;
11865 : 3612 : if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
11866 : 1 : gcc_assert (parser->error);
11867 : 3612 : if (parser->error)
11868 : : {
11869 : 1 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
11870 : 1 : expr.set_error ();
11871 : 1 : break;
11872 : : }
11873 : 3611 : tree type = groktypename (t1, NULL, NULL);
11874 : 3611 : tree offsetof_ref;
11875 : 3611 : if (type == error_mark_node)
11876 : : offsetof_ref = error_mark_node;
11877 : : else
11878 : : {
11879 : 3610 : offsetof_ref = build1 (INDIRECT_REF, type, null_pointer_node);
11880 : 3610 : SET_EXPR_LOCATION (offsetof_ref, loc);
11881 : : }
11882 : : /* Parse the second argument to __builtin_offsetof. We
11883 : : must have one identifier, and beyond that we want to
11884 : : accept sub structure and sub array references. */
11885 : 3611 : if (c_parser_next_token_is (parser, CPP_NAME))
11886 : : {
11887 : 3611 : c_token *comp_tok = c_parser_peek_token (parser);
11888 : 3611 : offsetof_ref
11889 : 3611 : = build_component_ref (loc, offsetof_ref, comp_tok->value,
11890 : : comp_tok->location, UNKNOWN_LOCATION);
11891 : 3611 : c_parser_consume_token (parser);
11892 : 3611 : while (c_parser_next_token_is (parser, CPP_DOT)
11893 : 4069 : || c_parser_next_token_is (parser,
11894 : : CPP_OPEN_SQUARE)
11895 : 7919 : || c_parser_next_token_is (parser,
11896 : : CPP_DEREF))
11897 : : {
11898 : 696 : if (c_parser_next_token_is (parser, CPP_DEREF))
11899 : : {
11900 : 1 : loc = c_parser_peek_token (parser)->location;
11901 : 1 : offsetof_ref = build_array_ref (loc,
11902 : : offsetof_ref,
11903 : : integer_zero_node);
11904 : 1 : goto do_dot;
11905 : : }
11906 : 695 : else if (c_parser_next_token_is (parser, CPP_DOT))
11907 : : {
11908 : 238 : do_dot:
11909 : 239 : c_parser_consume_token (parser);
11910 : 239 : if (c_parser_next_token_is_not (parser,
11911 : : CPP_NAME))
11912 : : {
11913 : 0 : c_parser_error (parser, "expected identifier");
11914 : 0 : break;
11915 : : }
11916 : 239 : c_token *comp_tok = c_parser_peek_token (parser);
11917 : 239 : offsetof_ref
11918 : 239 : = build_component_ref (loc, offsetof_ref,
11919 : : comp_tok->value,
11920 : : comp_tok->location,
11921 : : UNKNOWN_LOCATION);
11922 : 239 : c_parser_consume_token (parser);
11923 : : }
11924 : : else
11925 : : {
11926 : 457 : struct c_expr ce;
11927 : 457 : tree idx;
11928 : 457 : loc = c_parser_peek_token (parser)->location;
11929 : 457 : c_parser_consume_token (parser);
11930 : 457 : ce = c_parser_expression (parser);
11931 : 457 : ce = convert_lvalue_to_rvalue (loc, ce, false, false);
11932 : 457 : idx = ce.value;
11933 : 457 : idx = c_fully_fold (idx, false, NULL);
11934 : 457 : c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
11935 : : "expected %<]%>");
11936 : 457 : offsetof_ref = build_array_ref (loc, offsetof_ref, idx);
11937 : : }
11938 : : }
11939 : : }
11940 : : else
11941 : 0 : c_parser_error (parser, "expected identifier");
11942 : 3611 : location_t end_loc = c_parser_peek_token (parser)->get_finish ();
11943 : 3611 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
11944 : : "expected %<)%>");
11945 : 3611 : expr.value = fold_offsetof (offsetof_ref);
11946 : 3611 : set_c_expr_source_range (&expr, loc, end_loc);
11947 : : }
11948 : 3611 : break;
11949 : 1183 : case RID_CHOOSE_EXPR:
11950 : 1183 : {
11951 : 1183 : vec<c_expr_t, va_gc> *cexpr_list;
11952 : 1183 : c_expr_t *e1_p, *e2_p, *e3_p;
11953 : 1183 : tree c;
11954 : 1183 : location_t close_paren_loc;
11955 : :
11956 : 1183 : c_parser_consume_token (parser);
11957 : 1183 : if (!c_parser_get_builtin_args (parser,
11958 : : "__builtin_choose_expr",
11959 : : &cexpr_list, true,
11960 : : &close_paren_loc))
11961 : : {
11962 : 0 : expr.set_error ();
11963 : 0 : break;
11964 : : }
11965 : :
11966 : 1183 : if (vec_safe_length (cexpr_list) != 3)
11967 : : {
11968 : 0 : error_at (loc, "wrong number of arguments to "
11969 : : "%<__builtin_choose_expr%>");
11970 : 0 : expr.set_error ();
11971 : 0 : break;
11972 : : }
11973 : :
11974 : 1183 : e1_p = &(*cexpr_list)[0];
11975 : 1183 : e2_p = &(*cexpr_list)[1];
11976 : 1183 : e3_p = &(*cexpr_list)[2];
11977 : :
11978 : 1183 : c = e1_p->value;
11979 : 1183 : mark_exp_read (e2_p->value);
11980 : 1183 : mark_exp_read (e3_p->value);
11981 : 1183 : if (TREE_CODE (c) != INTEGER_CST
11982 : 1183 : || !INTEGRAL_TYPE_P (TREE_TYPE (c)))
11983 : 7 : error_at (loc,
11984 : : "first argument to %<__builtin_choose_expr%> not"
11985 : : " a constant");
11986 : 1183 : constant_expression_warning (c);
11987 : 1183 : expr = integer_zerop (c) ? *e3_p : *e2_p;
11988 : 1183 : set_c_expr_source_range (&expr, loc, close_paren_loc);
11989 : 1183 : break;
11990 : : }
11991 : 675 : case RID_TYPES_COMPATIBLE_P:
11992 : 675 : {
11993 : 675 : c_parser_consume_token (parser);
11994 : 675 : matching_parens parens;
11995 : 675 : if (!parens.require_open (parser))
11996 : : {
11997 : 0 : expr.set_error ();
11998 : 2 : break;
11999 : : }
12000 : 675 : t1 = c_parser_type_name (parser);
12001 : 675 : if (t1 == NULL)
12002 : : {
12003 : 0 : expr.set_error ();
12004 : 0 : break;
12005 : : }
12006 : 675 : if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
12007 : : {
12008 : 1 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
12009 : 1 : expr.set_error ();
12010 : 1 : break;
12011 : : }
12012 : 674 : t2 = c_parser_type_name (parser);
12013 : 674 : if (t2 == NULL)
12014 : : {
12015 : 0 : expr.set_error ();
12016 : 0 : break;
12017 : : }
12018 : 674 : location_t close_paren_loc = c_parser_peek_token (parser)->location;
12019 : 674 : parens.skip_until_found_close (parser);
12020 : 674 : tree e1, e2;
12021 : 674 : e1 = groktypename (t1, NULL, NULL);
12022 : 674 : e2 = groktypename (t2, NULL, NULL);
12023 : 674 : if (e1 == error_mark_node || e2 == error_mark_node)
12024 : : {
12025 : 1 : expr.set_error ();
12026 : 1 : break;
12027 : : }
12028 : :
12029 : 673 : e1 = TYPE_MAIN_VARIANT (e1);
12030 : 673 : e2 = TYPE_MAIN_VARIANT (e2);
12031 : :
12032 : 673 : expr.value
12033 : 673 : = comptypes (e1, e2) ? integer_one_node : integer_zero_node;
12034 : 673 : set_c_expr_source_range (&expr, loc, close_paren_loc);
12035 : : }
12036 : 673 : break;
12037 : 356 : case RID_BUILTIN_TGMATH:
12038 : 356 : {
12039 : 356 : vec<c_expr_t, va_gc> *cexpr_list;
12040 : 356 : location_t close_paren_loc;
12041 : :
12042 : 356 : c_parser_consume_token (parser);
12043 : 356 : if (!c_parser_get_builtin_args (parser,
12044 : : "__builtin_tgmath",
12045 : : &cexpr_list, false,
12046 : : &close_paren_loc))
12047 : : {
12048 : 0 : expr.set_error ();
12049 : 327 : break;
12050 : : }
12051 : :
12052 : 356 : if (vec_safe_length (cexpr_list) < 3)
12053 : : {
12054 : 3 : error_at (loc, "too few arguments to %<__builtin_tgmath%>");
12055 : 3 : expr.set_error ();
12056 : 3 : break;
12057 : : }
12058 : :
12059 : : unsigned int i;
12060 : : c_expr_t *p;
12061 : 2587 : FOR_EACH_VEC_ELT (*cexpr_list, i, p)
12062 : 2234 : *p = convert_lvalue_to_rvalue (loc, *p, true, true);
12063 : 353 : unsigned int nargs = check_tgmath_function (&(*cexpr_list)[0], 1);
12064 : 353 : if (nargs == 0)
12065 : : {
12066 : 4 : expr.set_error ();
12067 : 4 : break;
12068 : : }
12069 : 698 : if (vec_safe_length (cexpr_list) < nargs)
12070 : : {
12071 : 1 : error_at (loc, "too few arguments to %<__builtin_tgmath%>");
12072 : 1 : expr.set_error ();
12073 : 1 : break;
12074 : : }
12075 : 348 : unsigned int num_functions = vec_safe_length (cexpr_list) - nargs;
12076 : 348 : if (num_functions < 2)
12077 : : {
12078 : 1 : error_at (loc, "too few arguments to %<__builtin_tgmath%>");
12079 : 1 : expr.set_error ();
12080 : 1 : break;
12081 : : }
12082 : :
12083 : : /* The first NUM_FUNCTIONS expressions are the function
12084 : : pointers. The remaining NARGS expressions are the
12085 : : arguments that are to be passed to one of those
12086 : : functions, chosen following <tgmath.h> rules. */
12087 : 1744 : for (unsigned int j = 1; j < num_functions; j++)
12088 : : {
12089 : 1402 : unsigned int this_nargs
12090 : 1402 : = check_tgmath_function (&(*cexpr_list)[j], j + 1);
12091 : 1402 : if (this_nargs == 0)
12092 : : {
12093 : 4 : expr.set_error ();
12094 : 29 : goto out;
12095 : : }
12096 : 1398 : if (this_nargs != nargs)
12097 : : {
12098 : 1 : error_at ((*cexpr_list)[j].get_location (),
12099 : : "argument %u of %<__builtin_tgmath%> has "
12100 : : "wrong number of arguments", j + 1);
12101 : 1 : expr.set_error ();
12102 : 1 : goto out;
12103 : : }
12104 : : }
12105 : :
12106 : : /* The functions all have the same number of arguments.
12107 : : Determine whether arguments and return types vary in
12108 : : ways permitted for <tgmath.h> functions. */
12109 : : /* The first entry in each of these vectors is for the
12110 : : return type, subsequent entries for parameter
12111 : : types. */
12112 : 342 : auto_vec<enum tgmath_parm_kind> parm_kind (nargs + 1);
12113 : 342 : auto_vec<tree> parm_first (nargs + 1);
12114 : 342 : auto_vec<bool> parm_complex (nargs + 1);
12115 : 342 : auto_vec<bool> parm_varies (nargs + 1);
12116 : 342 : tree first_type = TREE_TYPE (TREE_TYPE ((*cexpr_list)[0].value));
12117 : 342 : tree first_ret = TYPE_MAIN_VARIANT (TREE_TYPE (first_type));
12118 : 342 : parm_first.quick_push (first_ret);
12119 : 342 : parm_complex.quick_push (TREE_CODE (first_ret) == COMPLEX_TYPE);
12120 : 342 : parm_varies.quick_push (false);
12121 : 342 : function_args_iterator iter;
12122 : 342 : tree t;
12123 : 342 : unsigned int argpos;
12124 : 802 : FOREACH_FUNCTION_ARGS (first_type, t, iter)
12125 : : {
12126 : 802 : if (t == void_type_node)
12127 : : break;
12128 : 460 : parm_first.quick_push (TYPE_MAIN_VARIANT (t));
12129 : 460 : parm_complex.quick_push (TREE_CODE (t) == COMPLEX_TYPE);
12130 : 460 : parm_varies.quick_push (false);
12131 : : }
12132 : 1727 : for (unsigned int j = 1; j < num_functions; j++)
12133 : : {
12134 : 1397 : tree type = TREE_TYPE (TREE_TYPE ((*cexpr_list)[j].value));
12135 : 1397 : tree ret = TYPE_MAIN_VARIANT (TREE_TYPE (type));
12136 : 1397 : if (ret != parm_first[0])
12137 : : {
12138 : 1294 : parm_varies[0] = true;
12139 : 1294 : if (!SCALAR_FLOAT_TYPE_P (parm_first[0])
12140 : 1294 : && !COMPLEX_FLOAT_TYPE_P (parm_first[0]))
12141 : : {
12142 : 3 : error_at ((*cexpr_list)[0].get_location (),
12143 : : "invalid type-generic return type for "
12144 : : "argument %u of %<__builtin_tgmath%>",
12145 : : 1);
12146 : 3 : expr.set_error ();
12147 : 3 : goto out;
12148 : : }
12149 : 1291 : if (!SCALAR_FLOAT_TYPE_P (ret)
12150 : 1291 : && !COMPLEX_FLOAT_TYPE_P (ret))
12151 : : {
12152 : 3 : error_at ((*cexpr_list)[j].get_location (),
12153 : : "invalid type-generic return type for "
12154 : : "argument %u of %<__builtin_tgmath%>",
12155 : : j + 1);
12156 : 3 : expr.set_error ();
12157 : 3 : goto out;
12158 : : }
12159 : : }
12160 : 1391 : if (TREE_CODE (ret) == COMPLEX_TYPE)
12161 : 342 : parm_complex[0] = true;
12162 : 1391 : argpos = 1;
12163 : 3329 : FOREACH_FUNCTION_ARGS (type, t, iter)
12164 : : {
12165 : 3329 : if (t == void_type_node)
12166 : : break;
12167 : 1944 : t = TYPE_MAIN_VARIANT (t);
12168 : 1944 : if (t != parm_first[argpos])
12169 : : {
12170 : 1919 : parm_varies[argpos] = true;
12171 : 1919 : if (!SCALAR_FLOAT_TYPE_P (parm_first[argpos])
12172 : 1919 : && !COMPLEX_FLOAT_TYPE_P (parm_first[argpos]))
12173 : : {
12174 : 3 : error_at ((*cexpr_list)[0].get_location (),
12175 : : "invalid type-generic type for "
12176 : : "argument %u of argument %u of "
12177 : : "%<__builtin_tgmath%>", argpos, 1);
12178 : 3 : expr.set_error ();
12179 : 3 : goto out;
12180 : : }
12181 : 1916 : if (!SCALAR_FLOAT_TYPE_P (t)
12182 : 1916 : && !COMPLEX_FLOAT_TYPE_P (t))
12183 : : {
12184 : 3 : error_at ((*cexpr_list)[j].get_location (),
12185 : : "invalid type-generic type for "
12186 : : "argument %u of argument %u of "
12187 : : "%<__builtin_tgmath%>", argpos, j + 1);
12188 : 3 : expr.set_error ();
12189 : 3 : goto out;
12190 : : }
12191 : : }
12192 : 1938 : if (TREE_CODE (t) == COMPLEX_TYPE)
12193 : 674 : parm_complex[argpos] = true;
12194 : 1938 : argpos++;
12195 : : }
12196 : : }
12197 : : enum tgmath_parm_kind max_variation = tgmath_fixed;
12198 : 1108 : for (unsigned int j = 0; j <= nargs; j++)
12199 : : {
12200 : 778 : enum tgmath_parm_kind this_kind;
12201 : 778 : if (parm_varies[j])
12202 : : {
12203 : 731 : if (parm_complex[j])
12204 : 394 : max_variation = this_kind = tgmath_complex;
12205 : : else
12206 : : {
12207 : 337 : this_kind = tgmath_real;
12208 : 337 : if (max_variation != tgmath_complex)
12209 : 778 : max_variation = tgmath_real;
12210 : : }
12211 : : }
12212 : : else
12213 : 47 : this_kind = tgmath_fixed;
12214 : 778 : parm_kind.quick_push (this_kind);
12215 : : }
12216 : 330 : if (max_variation == tgmath_fixed)
12217 : : {
12218 : 1 : error_at (loc, "function arguments of %<__builtin_tgmath%> "
12219 : : "all have the same type");
12220 : 1 : expr.set_error ();
12221 : 1 : break;
12222 : : }
12223 : :
12224 : : /* Identify a parameter (not the return type) that varies,
12225 : : including with complex types if any variation includes
12226 : : complex types; there must be at least one such
12227 : : parameter. */
12228 : 341 : unsigned int tgarg = 0;
12229 : 341 : for (unsigned int j = 1; j <= nargs; j++)
12230 : 339 : if (parm_kind[j] == max_variation)
12231 : : {
12232 : : tgarg = j;
12233 : : break;
12234 : : }
12235 : 329 : if (tgarg == 0)
12236 : : {
12237 : 2 : error_at (loc, "function arguments of %<__builtin_tgmath%> "
12238 : : "lack type-generic parameter");
12239 : 2 : expr.set_error ();
12240 : 2 : break;
12241 : : }
12242 : :
12243 : : /* Determine the type of the relevant parameter for each
12244 : : function. */
12245 : 327 : auto_vec<tree> tg_type (num_functions);
12246 : 2035 : for (unsigned int j = 0; j < num_functions; j++)
12247 : : {
12248 : 1708 : tree type = TREE_TYPE (TREE_TYPE ((*cexpr_list)[j].value));
12249 : 1708 : argpos = 1;
12250 : 1738 : FOREACH_FUNCTION_ARGS (type, t, iter)
12251 : : {
12252 : 1738 : if (argpos == tgarg)
12253 : : {
12254 : 1708 : tg_type.quick_push (TYPE_MAIN_VARIANT (t));
12255 : 1708 : break;
12256 : : }
12257 : 30 : argpos++;
12258 : : }
12259 : : }
12260 : :
12261 : : /* Verify that the corresponding types are different for
12262 : : all the listed functions. Also determine whether all
12263 : : the types are complex, whether all the types are
12264 : : standard or binary, and whether all the types are
12265 : : decimal. */
12266 : 327 : bool all_complex = true;
12267 : 327 : bool all_binary = true;
12268 : 327 : bool all_decimal = true;
12269 : 327 : hash_set<tree> tg_types;
12270 : 2687 : FOR_EACH_VEC_ELT (tg_type, i, t)
12271 : : {
12272 : 1708 : if (TREE_CODE (t) == COMPLEX_TYPE)
12273 : : all_decimal = false;
12274 : : else
12275 : : {
12276 : 1186 : all_complex = false;
12277 : 1186 : if (DECIMAL_FLOAT_TYPE_P (t))
12278 : : all_binary = false;
12279 : : else
12280 : : all_decimal = false;
12281 : : }
12282 : 1708 : if (tg_types.add (t))
12283 : : {
12284 : 1 : error_at ((*cexpr_list)[i].get_location (),
12285 : : "duplicate type-generic parameter type for "
12286 : : "function argument %u of %<__builtin_tgmath%>",
12287 : : i + 1);
12288 : 1 : expr.set_error ();
12289 : 1 : goto out;
12290 : : }
12291 : : }
12292 : :
12293 : : /* Verify that other parameters and the return type whose
12294 : : types vary have their types varying in the correct
12295 : : way. */
12296 : 2029 : for (unsigned int j = 0; j < num_functions; j++)
12297 : : {
12298 : 1705 : tree exp_type = tg_type[j];
12299 : 1705 : tree exp_real_type = exp_type;
12300 : 1705 : if (TREE_CODE (exp_type) == COMPLEX_TYPE)
12301 : 522 : exp_real_type = TREE_TYPE (exp_type);
12302 : 1705 : tree type = TREE_TYPE (TREE_TYPE ((*cexpr_list)[j].value));
12303 : 1705 : tree ret = TYPE_MAIN_VARIANT (TREE_TYPE (type));
12304 : 2606 : if ((parm_kind[0] == tgmath_complex && ret != exp_type)
12305 : 2606 : || (parm_kind[0] == tgmath_real && ret != exp_real_type))
12306 : : {
12307 : 1 : error_at ((*cexpr_list)[j].get_location (),
12308 : : "bad return type for function argument %u "
12309 : : "of %<__builtin_tgmath%>", j + 1);
12310 : 1 : expr.set_error ();
12311 : 1 : goto out;
12312 : : }
12313 : 1704 : argpos = 1;
12314 : 4078 : FOREACH_FUNCTION_ARGS (type, t, iter)
12315 : : {
12316 : 4078 : if (t == void_type_node)
12317 : : break;
12318 : 2375 : t = TYPE_MAIN_VARIANT (t);
12319 : 2375 : if ((parm_kind[argpos] == tgmath_complex
12320 : 1787 : && t != exp_type)
12321 : 4162 : || (parm_kind[argpos] == tgmath_real
12322 : 558 : && t != exp_real_type))
12323 : : {
12324 : 1 : error_at ((*cexpr_list)[j].get_location (),
12325 : : "bad type for argument %u of "
12326 : : "function argument %u of "
12327 : : "%<__builtin_tgmath%>", argpos, j + 1);
12328 : 1 : expr.set_error ();
12329 : 1 : goto out;
12330 : : }
12331 : 2374 : argpos++;
12332 : : }
12333 : : }
12334 : :
12335 : : /* The functions listed are a valid set of functions for a
12336 : : <tgmath.h> macro to select between. Identify the
12337 : : matching function, if any. First, the argument types
12338 : : must be combined following <tgmath.h> rules. Integer
12339 : : types are treated as _Decimal64 if any type-generic
12340 : : argument is decimal, or if the only alternatives for
12341 : : type-generic arguments are of decimal types, and are
12342 : : otherwise treated as _Float32x (or _Complex _Float32x
12343 : : for complex integer types) if any type-generic argument
12344 : : has _FloatNx type, otherwise as double (or _Complex
12345 : : double for complex integer types). After that
12346 : : adjustment, types are combined following the usual
12347 : : arithmetic conversions. If the function only accepts
12348 : : complex arguments, a complex type is produced. */
12349 : : bool arg_complex = all_complex;
12350 : : bool arg_binary = all_binary;
12351 : : bool arg_int_decimal = all_decimal;
12352 : : bool arg_int_floatnx = false;
12353 : : bool arg_int_decimalx = false;
12354 : 756 : for (unsigned int j = 1; j <= nargs; j++)
12355 : : {
12356 : 441 : if (parm_kind[j] == tgmath_fixed)
12357 : 10 : continue;
12358 : 431 : c_expr_t *ce = &(*cexpr_list)[num_functions + j - 1];
12359 : 431 : tree type = TREE_TYPE (ce->value);
12360 : 431 : if (!INTEGRAL_TYPE_P (type)
12361 : 431 : && !SCALAR_FLOAT_TYPE_P (type)
12362 : 89 : && TREE_CODE (type) != COMPLEX_TYPE)
12363 : : {
12364 : 1 : error_at (ce->get_location (),
12365 : : "invalid type of argument %u of type-generic "
12366 : : "function", j);
12367 : 1 : expr.set_error ();
12368 : 1 : goto out;
12369 : : }
12370 : 430 : if (DECIMAL_FLOAT_TYPE_P (type))
12371 : : {
12372 : 68 : arg_int_decimal = true;
12373 : 68 : if (all_complex)
12374 : : {
12375 : 1 : error_at (ce->get_location (),
12376 : : "decimal floating-point argument %u to "
12377 : : "complex-only type-generic function", j);
12378 : 1 : expr.set_error ();
12379 : 1 : goto out;
12380 : : }
12381 : 67 : else if (all_binary)
12382 : : {
12383 : 1 : error_at (ce->get_location (),
12384 : : "decimal floating-point argument %u to "
12385 : : "binary-only type-generic function", j);
12386 : 1 : expr.set_error ();
12387 : 1 : goto out;
12388 : : }
12389 : 66 : else if (arg_complex)
12390 : : {
12391 : 1 : error_at (ce->get_location (),
12392 : : "both complex and decimal floating-point "
12393 : : "arguments to type-generic function");
12394 : 1 : expr.set_error ();
12395 : 1 : goto out;
12396 : : }
12397 : 65 : else if (arg_binary)
12398 : : {
12399 : 1 : error_at (ce->get_location (),
12400 : : "both binary and decimal floating-point "
12401 : : "arguments to type-generic function");
12402 : 1 : expr.set_error ();
12403 : 1 : goto out;
12404 : : }
12405 : : }
12406 : 362 : else if (TREE_CODE (type) == COMPLEX_TYPE)
12407 : : {
12408 : 88 : arg_complex = true;
12409 : 88 : if (COMPLEX_FLOAT_TYPE_P (type))
12410 : : arg_binary = true;
12411 : 88 : if (all_decimal)
12412 : : {
12413 : 1 : error_at (ce->get_location (),
12414 : : "complex argument %u to "
12415 : : "decimal-only type-generic function", j);
12416 : 1 : expr.set_error ();
12417 : 1 : goto out;
12418 : : }
12419 : 87 : else if (arg_int_decimal)
12420 : : {
12421 : 1 : error_at (ce->get_location (),
12422 : : "both complex and decimal floating-point "
12423 : : "arguments to type-generic function");
12424 : 1 : expr.set_error ();
12425 : 1 : goto out;
12426 : : }
12427 : : }
12428 : 274 : else if (SCALAR_FLOAT_TYPE_P (type))
12429 : : {
12430 : 180 : arg_binary = true;
12431 : 180 : if (all_decimal)
12432 : : {
12433 : 1 : error_at (ce->get_location (),
12434 : : "binary argument %u to "
12435 : : "decimal-only type-generic function", j);
12436 : 1 : expr.set_error ();
12437 : 1 : goto out;
12438 : : }
12439 : 179 : else if (arg_int_decimal)
12440 : : {
12441 : 1 : error_at (ce->get_location (),
12442 : : "both binary and decimal floating-point "
12443 : : "arguments to type-generic function");
12444 : 1 : expr.set_error ();
12445 : 1 : goto out;
12446 : : }
12447 : : }
12448 : 422 : tree rtype = TYPE_MAIN_VARIANT (type);
12449 : 422 : if (TREE_CODE (rtype) == COMPLEX_TYPE)
12450 : 86 : rtype = TREE_TYPE (rtype);
12451 : 422 : if (SCALAR_FLOAT_TYPE_P (rtype))
12452 : 1208 : for (unsigned int j = 0; j < NUM_FLOATNX_TYPES; j++)
12453 : 908 : if (rtype == FLOATNX_TYPE_NODE (j))
12454 : : {
12455 : : arg_int_floatnx = true;
12456 : : break;
12457 : : }
12458 : 422 : if (rtype == dfloat64x_type_node)
12459 : 0 : arg_int_decimalx = true;
12460 : : }
12461 : : tree arg_real = NULL_TREE;
12462 : 743 : for (unsigned int j = 1; j <= nargs; j++)
12463 : : {
12464 : 428 : if (parm_kind[j] == tgmath_fixed)
12465 : 10 : continue;
12466 : 418 : c_expr_t *ce = &(*cexpr_list)[num_functions + j - 1];
12467 : 418 : tree type = TYPE_MAIN_VARIANT (TREE_TYPE (ce->value));
12468 : 418 : if (TREE_CODE (type) == COMPLEX_TYPE)
12469 : 85 : type = TREE_TYPE (type);
12470 : 418 : if (INTEGRAL_TYPE_P (type))
12471 : 114 : type = (arg_int_decimalx
12472 : 114 : ? dfloat64x_type_node
12473 : : : arg_int_floatnx
12474 : 114 : ? float32x_type_node
12475 : : : arg_int_decimal
12476 : 106 : ? dfloat64_type_node
12477 : : : double_type_node);
12478 : 418 : if (arg_real == NULL_TREE)
12479 : : arg_real = type;
12480 : : else
12481 : 103 : arg_real = common_type (arg_real, type);
12482 : 418 : if (arg_real == error_mark_node)
12483 : : {
12484 : 0 : expr.set_error ();
12485 : 0 : goto out;
12486 : : }
12487 : : }
12488 : 315 : tree arg_type = (arg_complex
12489 : 315 : ? build_complex_type (arg_real)
12490 : : : arg_real);
12491 : :
12492 : : /* Look for a function to call with type-generic parameter
12493 : : type ARG_TYPE. */
12494 : 315 : c_expr_t *fn = NULL;
12495 : 976 : for (unsigned int j = 0; j < num_functions; j++)
12496 : : {
12497 : 970 : if (tg_type[j] == arg_type)
12498 : : {
12499 : 309 : fn = &(*cexpr_list)[j];
12500 : 309 : break;
12501 : : }
12502 : : }
12503 : 315 : if (fn == NULL
12504 : 6 : && parm_kind[0] == tgmath_fixed
12505 : 4 : && SCALAR_FLOAT_TYPE_P (parm_first[0]))
12506 : : {
12507 : : /* Presume this is a macro that rounds its result to a
12508 : : narrower type, and look for the first function with
12509 : : at least the range and precision of the argument
12510 : : type. */
12511 : 4 : for (unsigned int j = 0; j < num_functions; j++)
12512 : : {
12513 : 8 : if (arg_complex
12514 : 4 : != (TREE_CODE (tg_type[j]) == COMPLEX_TYPE))
12515 : 0 : continue;
12516 : 4 : tree real_tg_type = (arg_complex
12517 : 4 : ? TREE_TYPE (tg_type[j])
12518 : 0 : : tg_type[j]);
12519 : 8 : if (DECIMAL_FLOAT_TYPE_P (arg_real)
12520 : 4 : != DECIMAL_FLOAT_TYPE_P (real_tg_type))
12521 : 0 : continue;
12522 : 4 : scalar_float_mode arg_mode
12523 : 4 : = SCALAR_FLOAT_TYPE_MODE (arg_real);
12524 : 4 : scalar_float_mode tg_mode
12525 : 4 : = SCALAR_FLOAT_TYPE_MODE (real_tg_type);
12526 : 4 : const real_format *arg_fmt = REAL_MODE_FORMAT (arg_mode);
12527 : 4 : const real_format *tg_fmt = REAL_MODE_FORMAT (tg_mode);
12528 : 4 : if (arg_fmt->b == tg_fmt->b
12529 : 4 : && arg_fmt->p <= tg_fmt->p
12530 : 4 : && arg_fmt->emax <= tg_fmt->emax
12531 : 4 : && (arg_fmt->emin - arg_fmt->p
12532 : 4 : >= tg_fmt->emin - tg_fmt->p))
12533 : : {
12534 : 4 : fn = &(*cexpr_list)[j];
12535 : 4 : break;
12536 : : }
12537 : : }
12538 : : }
12539 : 315 : if (fn == NULL)
12540 : : {
12541 : 2 : error_at (loc, "no matching function for type-generic call");
12542 : 2 : expr.set_error ();
12543 : 2 : break;
12544 : : }
12545 : :
12546 : : /* Construct a call to FN. */
12547 : 313 : vec<tree, va_gc> *args;
12548 : 313 : vec_alloc (args, nargs);
12549 : 313 : vec<tree, va_gc> *origtypes;
12550 : 313 : vec_alloc (origtypes, nargs);
12551 : 313 : auto_vec<location_t> arg_loc (nargs);
12552 : 739 : for (unsigned int j = 0; j < nargs; j++)
12553 : : {
12554 : 426 : c_expr_t *ce = &(*cexpr_list)[num_functions + j];
12555 : 426 : args->quick_push (ce->value);
12556 : 426 : arg_loc.quick_push (ce->get_location ());
12557 : 426 : origtypes->quick_push (ce->original_type);
12558 : : }
12559 : 313 : expr.value = c_build_function_call_vec (loc, arg_loc, fn->value,
12560 : : args, origtypes);
12561 : 313 : set_c_expr_source_range (&expr, loc, close_paren_loc);
12562 : 313 : break;
12563 : 982 : }
12564 : 22 : case RID_BUILTIN_CALL_WITH_STATIC_CHAIN:
12565 : 22 : {
12566 : 22 : vec<c_expr_t, va_gc> *cexpr_list;
12567 : 22 : c_expr_t *e2_p;
12568 : 22 : tree chain_value;
12569 : 22 : location_t close_paren_loc;
12570 : :
12571 : 22 : c_parser_consume_token (parser);
12572 : 22 : if (!c_parser_get_builtin_args (parser,
12573 : : "__builtin_call_with_static_chain",
12574 : : &cexpr_list, false,
12575 : : &close_paren_loc))
12576 : : {
12577 : 0 : expr.set_error ();
12578 : 0 : break;
12579 : : }
12580 : 22 : if (vec_safe_length (cexpr_list) != 2)
12581 : : {
12582 : 0 : error_at (loc, "wrong number of arguments to "
12583 : : "%<__builtin_call_with_static_chain%>");
12584 : 0 : expr.set_error ();
12585 : 0 : break;
12586 : : }
12587 : :
12588 : 22 : expr = (*cexpr_list)[0];
12589 : 22 : e2_p = &(*cexpr_list)[1];
12590 : 22 : *e2_p = convert_lvalue_to_rvalue (loc, *e2_p, true, true);
12591 : 22 : chain_value = e2_p->value;
12592 : 22 : mark_exp_read (chain_value);
12593 : :
12594 : 22 : if (TREE_CODE (expr.value) != CALL_EXPR)
12595 : 3 : error_at (loc, "first argument to "
12596 : : "%<__builtin_call_with_static_chain%> "
12597 : : "must be a call expression");
12598 : 19 : else if (TREE_CODE (TREE_TYPE (chain_value)) != POINTER_TYPE)
12599 : 1 : error_at (loc, "second argument to "
12600 : : "%<__builtin_call_with_static_chain%> "
12601 : : "must be a pointer type");
12602 : : else
12603 : 18 : CALL_EXPR_STATIC_CHAIN (expr.value) = chain_value;
12604 : 22 : set_c_expr_source_range (&expr, loc, close_paren_loc);
12605 : 22 : break;
12606 : : }
12607 : 12078 : case RID_BUILTIN_COMPLEX:
12608 : 12078 : {
12609 : 12078 : vec<c_expr_t, va_gc> *cexpr_list;
12610 : 12078 : c_expr_t *e1_p, *e2_p;
12611 : 12078 : location_t close_paren_loc;
12612 : :
12613 : 12078 : c_parser_consume_token (parser);
12614 : 12078 : if (!c_parser_get_builtin_args (parser,
12615 : : "__builtin_complex",
12616 : : &cexpr_list, false,
12617 : : &close_paren_loc))
12618 : : {
12619 : 1 : expr.set_error ();
12620 : 1 : break;
12621 : : }
12622 : :
12623 : 12077 : if (vec_safe_length (cexpr_list) != 2)
12624 : : {
12625 : 2 : error_at (loc, "wrong number of arguments to "
12626 : : "%<__builtin_complex%>");
12627 : 2 : expr.set_error ();
12628 : 2 : break;
12629 : : }
12630 : :
12631 : 12075 : e1_p = &(*cexpr_list)[0];
12632 : 12075 : e2_p = &(*cexpr_list)[1];
12633 : :
12634 : 12075 : *e1_p = convert_lvalue_to_rvalue (loc, *e1_p, true, true);
12635 : 12075 : if (TREE_CODE (e1_p->value) == EXCESS_PRECISION_EXPR)
12636 : 56 : e1_p->value = convert (TREE_TYPE (e1_p->value),
12637 : 56 : TREE_OPERAND (e1_p->value, 0));
12638 : 12075 : *e2_p = convert_lvalue_to_rvalue (loc, *e2_p, true, true);
12639 : 12075 : if (TREE_CODE (e2_p->value) == EXCESS_PRECISION_EXPR)
12640 : 56 : e2_p->value = convert (TREE_TYPE (e2_p->value),
12641 : 56 : TREE_OPERAND (e2_p->value, 0));
12642 : 12075 : if (!SCALAR_FLOAT_TYPE_P (TREE_TYPE (e1_p->value))
12643 : 12074 : || DECIMAL_FLOAT_TYPE_P (TREE_TYPE (e1_p->value))
12644 : 12073 : || !SCALAR_FLOAT_TYPE_P (TREE_TYPE (e2_p->value))
12645 : 24147 : || DECIMAL_FLOAT_TYPE_P (TREE_TYPE (e2_p->value)))
12646 : : {
12647 : 3 : error_at (loc, "%<__builtin_complex%> operand "
12648 : : "not of real binary floating-point type");
12649 : 3 : expr.set_error ();
12650 : 3 : break;
12651 : : }
12652 : 12072 : if (TYPE_MAIN_VARIANT (TREE_TYPE (e1_p->value))
12653 : 12072 : != TYPE_MAIN_VARIANT (TREE_TYPE (e2_p->value)))
12654 : : {
12655 : 1 : error_at (loc,
12656 : : "%<__builtin_complex%> operands of different types");
12657 : 1 : expr.set_error ();
12658 : 1 : break;
12659 : : }
12660 : 12071 : pedwarn_c90 (loc, OPT_Wpedantic,
12661 : : "ISO C90 does not support complex types");
12662 : 12071 : expr.value = build2_loc (loc, COMPLEX_EXPR,
12663 : : build_complex_type
12664 : 12071 : (TYPE_MAIN_VARIANT
12665 : : (TREE_TYPE (e1_p->value))),
12666 : : e1_p->value, e2_p->value);
12667 : 12071 : set_c_expr_source_range (&expr, loc, close_paren_loc);
12668 : 12071 : break;
12669 : : }
12670 : 44 : case RID_BUILTIN_COUNTED_BY_REF:
12671 : 44 : {
12672 : 44 : vec<c_expr_t, va_gc> *cexpr_list;
12673 : 44 : c_expr_t *e_p;
12674 : 44 : location_t close_paren_loc;
12675 : :
12676 : 44 : c_parser_consume_token (parser);
12677 : 44 : if (!c_parser_get_builtin_args (parser,
12678 : : "__builtin_counted_by_ref",
12679 : : &cexpr_list, false,
12680 : : &close_paren_loc))
12681 : : {
12682 : 0 : expr.set_error ();
12683 : 0 : break;
12684 : : }
12685 : 44 : if (vec_safe_length (cexpr_list) != 1)
12686 : : {
12687 : 2 : error_at (loc, "wrong number of arguments to "
12688 : : "%<__builtin_counted_by_ref%>");
12689 : 2 : expr.set_error ();
12690 : 2 : break;
12691 : : }
12692 : :
12693 : 42 : e_p = &(*cexpr_list)[0];
12694 : 42 : tree ref = e_p->value;
12695 : :
12696 : 42 : if (TREE_CODE (TREE_TYPE (ref)) != ARRAY_TYPE)
12697 : : {
12698 : 2 : error_at (loc, "the argument to %<__builtin_counted_by_ref%>"
12699 : : " must be an array");
12700 : 2 : expr.set_error ();
12701 : 2 : break;
12702 : : }
12703 : :
12704 : : /* If the array ref is inside TYPEOF or ALIGNOF, the call to
12705 : : .ACCESS_WITH_SIZE was not generated by the routine
12706 : : build_component_ref by default, we should generate it here. */
12707 : 40 : if (TREE_CODE (ref) == COMPONENT_REF)
12708 : 40 : ref = handle_counted_by_for_component_ref (loc, ref);
12709 : :
12710 : 40 : if (has_counted_by_object (ref))
12711 : 25 : expr.value = get_counted_by_ref (ref);
12712 : : else
12713 : 15 : expr.value = null_pointer_node;
12714 : :
12715 : 40 : set_c_expr_source_range (&expr, loc, close_paren_loc);
12716 : 40 : break;
12717 : : }
12718 : 460014 : case RID_BUILTIN_SHUFFLE:
12719 : 460014 : {
12720 : 460014 : vec<c_expr_t, va_gc> *cexpr_list;
12721 : 460014 : unsigned int i;
12722 : 460014 : c_expr_t *p;
12723 : 460014 : location_t close_paren_loc;
12724 : :
12725 : 460014 : c_parser_consume_token (parser);
12726 : 460014 : if (!c_parser_get_builtin_args (parser,
12727 : : "__builtin_shuffle",
12728 : : &cexpr_list, false,
12729 : : &close_paren_loc))
12730 : : {
12731 : 0 : expr.set_error ();
12732 : 0 : break;
12733 : : }
12734 : :
12735 : 1421304 : FOR_EACH_VEC_SAFE_ELT (cexpr_list, i, p)
12736 : 961290 : *p = convert_lvalue_to_rvalue (loc, *p, true, true);
12737 : :
12738 : 460014 : if (vec_safe_length (cexpr_list) == 2)
12739 : 418752 : expr.value = c_build_vec_perm_expr (loc, (*cexpr_list)[0].value,
12740 : : NULL_TREE,
12741 : 418752 : (*cexpr_list)[1].value);
12742 : :
12743 : 41262 : else if (vec_safe_length (cexpr_list) == 3)
12744 : 41262 : expr.value = c_build_vec_perm_expr (loc, (*cexpr_list)[0].value,
12745 : 41262 : (*cexpr_list)[1].value,
12746 : 41262 : (*cexpr_list)[2].value);
12747 : : else
12748 : : {
12749 : 0 : error_at (loc, "wrong number of arguments to "
12750 : : "%<__builtin_shuffle%>");
12751 : 0 : expr.set_error ();
12752 : : }
12753 : 460014 : set_c_expr_source_range (&expr, loc, close_paren_loc);
12754 : 460014 : break;
12755 : : }
12756 : 1052902 : case RID_BUILTIN_SHUFFLEVECTOR:
12757 : 1052902 : {
12758 : 1052902 : vec<c_expr_t, va_gc> *cexpr_list;
12759 : 1052902 : unsigned int i;
12760 : 1052902 : c_expr_t *p;
12761 : 1052902 : location_t close_paren_loc;
12762 : :
12763 : 1052902 : c_parser_consume_token (parser);
12764 : 1052902 : if (!c_parser_get_builtin_args (parser,
12765 : : "__builtin_shufflevector",
12766 : : &cexpr_list, false,
12767 : : &close_paren_loc))
12768 : : {
12769 : 0 : expr.set_error ();
12770 : 0 : break;
12771 : : }
12772 : :
12773 : 16394204 : FOR_EACH_VEC_SAFE_ELT (cexpr_list, i, p)
12774 : 15341302 : *p = convert_lvalue_to_rvalue (loc, *p, true, true);
12775 : :
12776 : 1052902 : if (vec_safe_length (cexpr_list) < 3)
12777 : : {
12778 : 0 : error_at (loc, "wrong number of arguments to "
12779 : : "%<__builtin_shuffle%>");
12780 : 0 : expr.set_error ();
12781 : : }
12782 : : else
12783 : : {
12784 : 1052902 : auto_vec<tree, 16> mask;
12785 : 14288400 : for (i = 2; i < cexpr_list->length (); ++i)
12786 : 13235498 : mask.safe_push ((*cexpr_list)[i].value);
12787 : 1052902 : expr.value = c_build_shufflevector (loc, (*cexpr_list)[0].value,
12788 : 1052902 : (*cexpr_list)[1].value,
12789 : : mask);
12790 : 1052902 : }
12791 : 1052902 : set_c_expr_source_range (&expr, loc, close_paren_loc);
12792 : 1052902 : break;
12793 : : }
12794 : 329 : case RID_BUILTIN_CONVERTVECTOR:
12795 : 329 : {
12796 : 329 : location_t start_loc = loc;
12797 : 329 : c_parser_consume_token (parser);
12798 : 329 : matching_parens parens;
12799 : 329 : if (!parens.require_open (parser))
12800 : : {
12801 : 0 : expr.set_error ();
12802 : 2 : break;
12803 : : }
12804 : 329 : e1 = c_parser_expr_no_commas (parser, NULL);
12805 : 329 : mark_exp_read (e1.value);
12806 : 329 : if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
12807 : : {
12808 : 2 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
12809 : 2 : expr.set_error ();
12810 : 2 : break;
12811 : : }
12812 : 327 : loc = c_parser_peek_token (parser)->location;
12813 : 327 : t1 = c_parser_type_name (parser);
12814 : 327 : location_t end_loc = c_parser_peek_token (parser)->get_finish ();
12815 : 327 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
12816 : : "expected %<)%>");
12817 : 327 : if (t1 == NULL)
12818 : 1 : expr.set_error ();
12819 : : else
12820 : : {
12821 : 326 : tree type_expr = NULL_TREE;
12822 : 326 : expr.value = c_build_vec_convert (start_loc, e1.value, loc,
12823 : : groktypename (t1, &type_expr,
12824 : : NULL));
12825 : 326 : set_c_expr_source_range (&expr, start_loc, end_loc);
12826 : : }
12827 : : }
12828 : 327 : break;
12829 : 10 : case RID_BUILTIN_ASSOC_BARRIER:
12830 : 10 : {
12831 : 10 : location_t start_loc = loc;
12832 : 10 : c_parser_consume_token (parser);
12833 : 10 : matching_parens parens;
12834 : 10 : if (!parens.require_open (parser))
12835 : : {
12836 : 0 : expr.set_error ();
12837 : 0 : break;
12838 : : }
12839 : 10 : e1 = c_parser_expr_no_commas (parser, NULL);
12840 : 10 : mark_exp_read (e1.value);
12841 : 10 : location_t end_loc = c_parser_peek_token (parser)->get_finish ();
12842 : 10 : parens.skip_until_found_close (parser);
12843 : 10 : expr = parser_build_unary_op (loc, PAREN_EXPR, e1);
12844 : 10 : set_c_expr_source_range (&expr, start_loc, end_loc);
12845 : : }
12846 : 10 : break;
12847 : 1073 : case RID_BUILTIN_STDC:
12848 : 1073 : {
12849 : 1073 : vec<c_expr_t, va_gc> *cexpr_list;
12850 : 1073 : c_expr_t *arg_p;
12851 : 1073 : location_t close_paren_loc;
12852 : 1073 : enum c_builtin_stdc {
12853 : : C_BUILTIN_STDC_BIT_CEIL,
12854 : : C_BUILTIN_STDC_BIT_FLOOR,
12855 : : C_BUILTIN_STDC_BIT_WIDTH,
12856 : : C_BUILTIN_STDC_COUNT_ONES,
12857 : : C_BUILTIN_STDC_COUNT_ZEROS,
12858 : : C_BUILTIN_STDC_FIRST_LEADING_ONE,
12859 : : C_BUILTIN_STDC_FIRST_LEADING_ZERO,
12860 : : C_BUILTIN_STDC_FIRST_TRAILING_ONE,
12861 : : C_BUILTIN_STDC_FIRST_TRAILING_ZERO,
12862 : : C_BUILTIN_STDC_HAS_SINGLE_BIT,
12863 : : C_BUILTIN_STDC_LEADING_ONES,
12864 : : C_BUILTIN_STDC_LEADING_ZEROS,
12865 : : C_BUILTIN_STDC_ROTATE_LEFT,
12866 : : C_BUILTIN_STDC_ROTATE_RIGHT,
12867 : : C_BUILTIN_STDC_TRAILING_ONES,
12868 : : C_BUILTIN_STDC_TRAILING_ZEROS,
12869 : : C_BUILTIN_STDC_MAX
12870 : 1073 : } stdc_rid = C_BUILTIN_STDC_MAX;
12871 : 1073 : const char *name
12872 : 1073 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
12873 : 1073 : unsigned num_args = 1;
12874 : 1073 : switch (name[sizeof ("__builtin_stdc_") - 1])
12875 : : {
12876 : 202 : case 'b':
12877 : 202 : switch (name[sizeof ("__builtin_stdc_bit_") - 1])
12878 : : {
12879 : : case 'c':
12880 : : stdc_rid = C_BUILTIN_STDC_BIT_CEIL;
12881 : : break;
12882 : 64 : case 'f':
12883 : 64 : stdc_rid = C_BUILTIN_STDC_BIT_FLOOR;
12884 : 64 : break;
12885 : 58 : default:
12886 : 58 : stdc_rid = C_BUILTIN_STDC_BIT_WIDTH;
12887 : 58 : break;
12888 : : }
12889 : : break;
12890 : 106 : case 'c':
12891 : 106 : if (name[sizeof ("__builtin_stdc_count_") - 1] == 'o')
12892 : : stdc_rid = C_BUILTIN_STDC_COUNT_ONES;
12893 : : else
12894 : 53 : stdc_rid = C_BUILTIN_STDC_COUNT_ZEROS;
12895 : : break;
12896 : 215 : case 'f':
12897 : 215 : switch (name[sizeof ("__builtin_stdc_first_trailing_") - 1])
12898 : : {
12899 : : case 'n':
12900 : : stdc_rid = C_BUILTIN_STDC_FIRST_LEADING_ONE;
12901 : : break;
12902 : : case 'e':
12903 : : stdc_rid = C_BUILTIN_STDC_FIRST_LEADING_ZERO;
12904 : : break;
12905 : : case 'o':
12906 : : stdc_rid = C_BUILTIN_STDC_FIRST_TRAILING_ONE;
12907 : : break;
12908 : : default:
12909 : : stdc_rid = C_BUILTIN_STDC_FIRST_TRAILING_ZERO;
12910 : : break;
12911 : : }
12912 : : break;
12913 : : case 'h':
12914 : : stdc_rid = C_BUILTIN_STDC_HAS_SINGLE_BIT;
12915 : : break;
12916 : 106 : case 'l':
12917 : 106 : if (name[sizeof ("__builtin_stdc_leading_") - 1] == 'o')
12918 : : stdc_rid = C_BUILTIN_STDC_LEADING_ONES;
12919 : : else
12920 : 53 : stdc_rid = C_BUILTIN_STDC_LEADING_ZEROS;
12921 : : break;
12922 : 285 : case 'r':
12923 : 285 : if (name[sizeof ("__builtin_stdc_rotate_") - 1] == 'l')
12924 : : stdc_rid = C_BUILTIN_STDC_ROTATE_LEFT;
12925 : : else
12926 : 138 : stdc_rid = C_BUILTIN_STDC_ROTATE_RIGHT;
12927 : : num_args = 2;
12928 : : break;
12929 : 106 : case 't':
12930 : 106 : if (name[sizeof ("__builtin_stdc_trailing_") - 1] == 'o')
12931 : : stdc_rid = C_BUILTIN_STDC_TRAILING_ONES;
12932 : : else
12933 : 53 : stdc_rid = C_BUILTIN_STDC_TRAILING_ZEROS;
12934 : : break;
12935 : : }
12936 : 281 : gcc_checking_assert (stdc_rid != C_BUILTIN_STDC_MAX);
12937 : :
12938 : 1073 : c_parser_consume_token (parser);
12939 : 1073 : if (!c_parser_get_builtin_args (parser, name,
12940 : : &cexpr_list, false,
12941 : : &close_paren_loc))
12942 : : {
12943 : 0 : expr.set_error ();
12944 : 0 : break;
12945 : : }
12946 : :
12947 : 2130 : if (vec_safe_length (cexpr_list) != num_args)
12948 : : {
12949 : 34 : error_at (loc, "wrong number of arguments to %qs", name);
12950 : 34 : expr.set_error ();
12951 : 34 : break;
12952 : : }
12953 : :
12954 : 1039 : arg_p = &(*cexpr_list)[0];
12955 : 1039 : *arg_p = convert_lvalue_to_rvalue (loc, *arg_p, true, true);
12956 : 1039 : if (!INTEGRAL_TYPE_P (TREE_TYPE (arg_p->value)))
12957 : : {
12958 : 80 : error_at (loc, "%qs operand not an integral type", name);
12959 : 80 : expr.set_error ();
12960 : 80 : break;
12961 : : }
12962 : 959 : if (TREE_CODE (TREE_TYPE (arg_p->value)) == ENUMERAL_TYPE)
12963 : : {
12964 : 16 : error_at (loc, "argument %u in call to function "
12965 : : "%qs has enumerated type", 1, name);
12966 : 16 : expr.set_error ();
12967 : 16 : break;
12968 : : }
12969 : 943 : if (TREE_CODE (TREE_TYPE (arg_p->value)) == BOOLEAN_TYPE)
12970 : : {
12971 : 16 : error_at (loc, "argument %u in call to function "
12972 : : "%qs has boolean type", 1, name);
12973 : 16 : expr.set_error ();
12974 : 16 : break;
12975 : : }
12976 : 927 : if (!TYPE_UNSIGNED (TREE_TYPE (arg_p->value)))
12977 : : {
12978 : 16 : error_at (loc, "argument 1 in call to function "
12979 : : "%qs has signed type", name);
12980 : 16 : expr.set_error ();
12981 : 16 : break;
12982 : : }
12983 : 911 : if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_p->value))
12984 : 911 : == char_type_node)
12985 : : {
12986 : 16 : error_at (loc, "argument 1 in call to function "
12987 : : "%qs has %<char%> type", name);
12988 : 16 : expr.set_error ();
12989 : 16 : break;
12990 : : }
12991 : 895 : tree arg = arg_p->value;
12992 : 895 : tree type = TYPE_MAIN_VARIANT (TREE_TYPE (arg));
12993 : : /* Expand:
12994 : : __builtin_stdc_leading_zeros (arg) as
12995 : : (unsigned int) __builtin_clzg (arg, prec)
12996 : : __builtin_stdc_leading_ones (arg) as
12997 : : (unsigned int) __builtin_clzg ((type) ~arg, prec)
12998 : : __builtin_stdc_trailing_zeros (arg) as
12999 : : (unsigned int) __builtin_ctzg (arg, prec)
13000 : : __builtin_stdc_trailing_ones (arg) as
13001 : : (unsigned int) __builtin_ctzg ((type) ~arg, prec)
13002 : : __builtin_stdc_first_leading_zero (arg) as
13003 : : __builtin_clzg ((type) ~arg, -1) + 1U
13004 : : __builtin_stdc_first_leading_one (arg) as
13005 : : __builtin_clzg (arg, -1) + 1U
13006 : : __builtin_stdc_first_trailing_zero (arg) as
13007 : : __builtin_ctzg ((type) ~arg, -1) + 1U
13008 : : __builtin_stdc_first_trailing_one (arg) as
13009 : : __builtin_ctzg (arg, -1) + 1U
13010 : : __builtin_stdc_count_zeros (arg) as
13011 : : (unsigned int) __builtin_popcountg ((type) ~arg)
13012 : : __builtin_stdc_count_ones (arg) as
13013 : : (unsigned int) __builtin_popcountg (arg)
13014 : : __builtin_stdc_has_single_bit (arg) as
13015 : : (_Bool) (__builtin_popcountg (arg) == 1)
13016 : : __builtin_stdc_bit_width (arg) as
13017 : : (unsigned int) (prec - __builtin_clzg (arg, prec))
13018 : : __builtin_stdc_bit_floor (arg) as
13019 : : arg == 0 ? (type) 0
13020 : : : (type) 1 << (prec - 1 - __builtin_clzg (arg))
13021 : : __builtin_stdc_bit_ceil (arg) as
13022 : : arg <= 1 ? (type) 1
13023 : : : (type) 2 << (prec - 1 - __builtin_clzg (arg - 1))
13024 : : without evaluating arg multiple times, type being
13025 : : __typeof (arg) and prec __builtin_popcountg ((type) ~0)). */
13026 : 895 : int prec = TYPE_PRECISION (type);
13027 : 895 : if (num_args == 2)
13028 : : {
13029 : : /* Expand:
13030 : : __builtin_stdc_rotate_left (arg1, arg2) as
13031 : : arg1 r<< (arg2 % prec)
13032 : : __builtin_stdc_rotate_right (arg1, arg2) as
13033 : : arg1 r>> (arg2 % prec). */
13034 : 261 : arg_p = &(*cexpr_list)[1];
13035 : 261 : *arg_p = convert_lvalue_to_rvalue (loc, *arg_p, true, true);
13036 : 261 : if (!INTEGRAL_TYPE_P (TREE_TYPE (arg_p->value)))
13037 : : {
13038 : 10 : error_at (loc, "%qs operand not an integral type", name);
13039 : 10 : expr.set_error ();
13040 : 10 : break;
13041 : : }
13042 : 251 : if (TREE_CODE (TREE_TYPE (arg_p->value)) == ENUMERAL_TYPE)
13043 : : {
13044 : 2 : error_at (loc, "argument %u in call to function "
13045 : : "%qs has enumerated type", 2, name);
13046 : 2 : expr.set_error ();
13047 : 2 : break;
13048 : : }
13049 : 249 : tree arg1 = save_expr (arg);
13050 : 249 : tree arg2 = save_expr (arg_p->value);
13051 : 249 : tree_code code;
13052 : 249 : if (stdc_rid == C_BUILTIN_STDC_ROTATE_LEFT)
13053 : : code = LROTATE_EXPR;
13054 : : else
13055 : 120 : code = RROTATE_EXPR;
13056 : :
13057 : 249 : if (TREE_CODE (arg2) == INTEGER_CST
13058 : 249 : && tree_int_cst_sgn (arg2) < 0)
13059 : 20 : warning_at (loc, OPT_Wshift_count_negative,
13060 : : "rotate count is negative");
13061 : :
13062 : 249 : tree instrument_expr = NULL_TREE;
13063 : 249 : if (sanitize_flags_p (SANITIZE_SHIFT))
13064 : 28 : instrument_expr = ubsan_instrument_shift (loc, code,
13065 : : arg1, arg2);
13066 : :
13067 : : /* Promote arg2 to unsigned just so that we don't
13068 : : need to deal with arg2 type not being able to represent
13069 : : prec. In the end gimplification uses unsigned int
13070 : : for all shifts/rotates anyway. */
13071 : 249 : if (TYPE_PRECISION (TREE_TYPE (arg2))
13072 : 249 : < TYPE_PRECISION (integer_type_node))
13073 : 13 : arg2 = fold_convert (unsigned_type_node, arg2);
13074 : :
13075 : 249 : if (TYPE_UNSIGNED (TREE_TYPE (arg2)))
13076 : 26 : arg2 = build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (arg2),
13077 : 26 : arg2, build_int_cst (TREE_TYPE (arg2),
13078 : 26 : prec));
13079 : : else
13080 : : {
13081 : : /* When second argument is signed, just do the modulo in
13082 : : unsigned type, that results in better generated code
13083 : : (for power of 2 precisions bitwise AND). */
13084 : 223 : tree utype = c_common_unsigned_type (TREE_TYPE (arg2));
13085 : 223 : arg2 = build2_loc (loc, TRUNC_MOD_EXPR, utype,
13086 : : fold_convert (utype, arg2),
13087 : 223 : build_int_cst (utype, prec));
13088 : : }
13089 : :
13090 : : /* The middle-end isn't prepared to handle {L,R}ROTATE_EXPR
13091 : : on types without mode precision, except for large/huge
13092 : : _BitInt types. */
13093 : 249 : if (type_has_mode_precision_p (TREE_TYPE (arg1))
13094 : 249 : || (TREE_CODE (TREE_TYPE (arg1)) == BITINT_TYPE
13095 : 150 : && prec > MAX_FIXED_MODE_SIZE))
13096 : 192 : expr.value = build2_loc (loc, code, TREE_TYPE (arg1), arg1,
13097 : : arg2);
13098 : : else
13099 : : {
13100 : 57 : arg2 = save_expr (arg2);
13101 : 82 : tree t1 = build2_loc (loc, (code == LROTATE_EXPR
13102 : : ? LSHIFT_EXPR : RSHIFT_EXPR),
13103 : 57 : TREE_TYPE (arg1), arg1, arg2);
13104 : 114 : tree t2 = build2_loc (loc, MINUS_EXPR,
13105 : 57 : TREE_TYPE (arg2),
13106 : 57 : build_int_cst (TREE_TYPE (arg2),
13107 : 57 : prec), arg2);
13108 : 82 : t2 = build2_loc (loc, (code == LROTATE_EXPR
13109 : : ? RSHIFT_EXPR : LSHIFT_EXPR),
13110 : 57 : TREE_TYPE (arg1), arg1, t2);
13111 : 57 : suppress_warning (t2, OPT_Wshift_count_overflow);
13112 : 57 : tree t3 = build2_loc (loc, BIT_IOR_EXPR,
13113 : 57 : TREE_TYPE (arg1), t1, t2);
13114 : 57 : tree t4 = build2_loc (loc, NE_EXPR, boolean_type_node,
13115 : : arg2,
13116 : 57 : build_zero_cst (TREE_TYPE (arg2)));
13117 : 57 : t4 = build2_loc (loc, COMPOUND_EXPR, boolean_type_node,
13118 : : arg1, t4);
13119 : 57 : expr.value = build3_loc (loc, COND_EXPR,
13120 : 57 : TREE_TYPE (arg1), t4, t3, arg1);
13121 : : }
13122 : 249 : if (instrument_expr)
13123 : 28 : expr.value = build2_loc (loc, COMPOUND_EXPR,
13124 : 28 : TREE_TYPE (expr.value),
13125 : : instrument_expr, expr.value);
13126 : 249 : set_c_expr_source_range (&expr, loc, close_paren_loc);
13127 : 249 : break;
13128 : : }
13129 : 634 : tree barg1 = arg;
13130 : 634 : switch (stdc_rid)
13131 : : {
13132 : 69 : case C_BUILTIN_STDC_BIT_CEIL:
13133 : 69 : arg = save_expr (arg);
13134 : 69 : barg1 = build2_loc (loc, PLUS_EXPR, type, arg,
13135 : : build_int_cst (type, -1));
13136 : 69 : break;
13137 : 53 : case C_BUILTIN_STDC_BIT_FLOOR:
13138 : 53 : barg1 = arg = save_expr (arg);
13139 : 53 : break;
13140 : 211 : case C_BUILTIN_STDC_COUNT_ZEROS:
13141 : 211 : case C_BUILTIN_STDC_FIRST_LEADING_ZERO:
13142 : 211 : case C_BUILTIN_STDC_FIRST_TRAILING_ZERO:
13143 : 211 : case C_BUILTIN_STDC_LEADING_ONES:
13144 : 211 : case C_BUILTIN_STDC_TRAILING_ONES:
13145 : 211 : barg1 = build1_loc (loc, BIT_NOT_EXPR, type, arg);
13146 : 211 : break;
13147 : : default:
13148 : : break;
13149 : : }
13150 : 634 : tree barg2 = NULL_TREE;
13151 : 634 : switch (stdc_rid)
13152 : : {
13153 : 215 : case C_BUILTIN_STDC_BIT_WIDTH:
13154 : 215 : case C_BUILTIN_STDC_LEADING_ONES:
13155 : 215 : case C_BUILTIN_STDC_LEADING_ZEROS:
13156 : 215 : case C_BUILTIN_STDC_TRAILING_ONES:
13157 : 215 : case C_BUILTIN_STDC_TRAILING_ZEROS:
13158 : 215 : barg2 = build_int_cst (integer_type_node, prec);
13159 : 215 : break;
13160 : 171 : case C_BUILTIN_STDC_FIRST_LEADING_ONE:
13161 : 171 : case C_BUILTIN_STDC_FIRST_LEADING_ZERO:
13162 : 171 : case C_BUILTIN_STDC_FIRST_TRAILING_ONE:
13163 : 171 : case C_BUILTIN_STDC_FIRST_TRAILING_ZERO:
13164 : 171 : barg2 = integer_minus_one_node;
13165 : 171 : break;
13166 : : default:
13167 : : break;
13168 : : }
13169 : 634 : tree fndecl = NULL_TREE;
13170 : 634 : switch (stdc_rid)
13171 : : {
13172 : 340 : case C_BUILTIN_STDC_BIT_CEIL:
13173 : 340 : case C_BUILTIN_STDC_BIT_FLOOR:
13174 : 340 : case C_BUILTIN_STDC_BIT_WIDTH:
13175 : 340 : case C_BUILTIN_STDC_FIRST_LEADING_ONE:
13176 : 340 : case C_BUILTIN_STDC_FIRST_LEADING_ZERO:
13177 : 340 : case C_BUILTIN_STDC_LEADING_ONES:
13178 : 340 : case C_BUILTIN_STDC_LEADING_ZEROS:
13179 : 340 : fndecl = builtin_decl_explicit (BUILT_IN_CLZG);
13180 : 340 : break;
13181 : 168 : case C_BUILTIN_STDC_FIRST_TRAILING_ONE:
13182 : 168 : case C_BUILTIN_STDC_FIRST_TRAILING_ZERO:
13183 : 168 : case C_BUILTIN_STDC_TRAILING_ONES:
13184 : 168 : case C_BUILTIN_STDC_TRAILING_ZEROS:
13185 : 168 : fndecl = builtin_decl_explicit (BUILT_IN_CTZG);
13186 : 168 : break;
13187 : 126 : case C_BUILTIN_STDC_COUNT_ONES:
13188 : 126 : case C_BUILTIN_STDC_COUNT_ZEROS:
13189 : 126 : case C_BUILTIN_STDC_HAS_SINGLE_BIT:
13190 : 126 : fndecl = builtin_decl_explicit (BUILT_IN_POPCOUNTG);
13191 : 126 : break;
13192 : 0 : default:
13193 : 0 : gcc_unreachable ();
13194 : : }
13195 : : /* Construct a call to __builtin_{clz,ctz,popcount}g. */
13196 : 634 : int nargs = barg2 != NULL_TREE ? 2 : 1;
13197 : 634 : vec<tree, va_gc> *args;
13198 : 634 : vec_alloc (args, nargs);
13199 : 634 : vec<tree, va_gc> *origtypes;
13200 : 634 : vec_alloc (origtypes, nargs);
13201 : 1268 : auto_vec<location_t> arg_loc (nargs);
13202 : 634 : args->quick_push (barg1);
13203 : 634 : arg_loc.quick_push (arg_p->get_location ());
13204 : 634 : origtypes->quick_push (arg_p->original_type);
13205 : 634 : if (nargs == 2)
13206 : : {
13207 : 386 : args->quick_push (barg2);
13208 : 386 : arg_loc.quick_push (loc);
13209 : 386 : origtypes->quick_push (integer_type_node);
13210 : : }
13211 : 634 : expr.value = c_build_function_call_vec (loc, arg_loc, fndecl,
13212 : : args, origtypes);
13213 : 634 : set_c_expr_source_range (&expr, loc, close_paren_loc);
13214 : 634 : if (expr.value == error_mark_node)
13215 : : break;
13216 : 634 : switch (stdc_rid)
13217 : : {
13218 : 122 : case C_BUILTIN_STDC_BIT_CEIL:
13219 : 122 : case C_BUILTIN_STDC_BIT_FLOOR:
13220 : 122 : --prec;
13221 : : /* FALLTHRU */
13222 : 169 : case C_BUILTIN_STDC_BIT_WIDTH:
13223 : 169 : expr.value = build2_loc (loc, MINUS_EXPR, integer_type_node,
13224 : : build_int_cst (integer_type_node,
13225 : 169 : prec), expr.value);
13226 : 169 : break;
13227 : 171 : case C_BUILTIN_STDC_FIRST_LEADING_ONE:
13228 : 171 : case C_BUILTIN_STDC_FIRST_LEADING_ZERO:
13229 : 171 : case C_BUILTIN_STDC_FIRST_TRAILING_ONE:
13230 : 171 : case C_BUILTIN_STDC_FIRST_TRAILING_ZERO:
13231 : 171 : expr.value = build2_loc (loc, PLUS_EXPR, integer_type_node,
13232 : : expr.value, integer_one_node);
13233 : 171 : break;
13234 : 42 : case C_BUILTIN_STDC_HAS_SINGLE_BIT:
13235 : 42 : expr.value = build2_loc (loc, EQ_EXPR, boolean_type_node,
13236 : : expr.value, integer_one_node);
13237 : 42 : break;
13238 : : default:
13239 : : break;
13240 : : }
13241 : :
13242 : 382 : if (stdc_rid != C_BUILTIN_STDC_BIT_CEIL
13243 : : && stdc_rid != C_BUILTIN_STDC_BIT_FLOOR)
13244 : : {
13245 : 512 : if (stdc_rid != C_BUILTIN_STDC_HAS_SINGLE_BIT)
13246 : 470 : expr.value = fold_convert_loc (loc, unsigned_type_node,
13247 : : expr.value);
13248 : : break;
13249 : : }
13250 : : /* For __builtin_stdc_bit_ceil (0U) or __builtin_stdc_bit_ceil (1U)
13251 : : or __builtin_stdc_bit_floor (0U) avoid bogus -Wshift-count-*
13252 : : warnings. The LSHIFT_EXPR is in dead code in that case. */
13253 : 122 : if (integer_zerop (arg)
13254 : 122 : || (stdc_rid == C_BUILTIN_STDC_BIT_CEIL && integer_onep (arg)))
13255 : 42 : expr.value = build_int_cst (type, 0);
13256 : : else
13257 : 80 : expr.value
13258 : 80 : = build2_loc (loc, LSHIFT_EXPR, type,
13259 : : build_int_cst (type,
13260 : : (stdc_rid
13261 : : == C_BUILTIN_STDC_BIT_CEIL
13262 : 114 : ? 2 : 1)), expr.value);
13263 : 122 : if (stdc_rid == C_BUILTIN_STDC_BIT_CEIL)
13264 : 69 : expr.value = build3_loc (loc, COND_EXPR, type,
13265 : : build2_loc (loc, LE_EXPR,
13266 : : boolean_type_node, arg,
13267 : : build_int_cst (type, 1)),
13268 : : build_int_cst (type, 1),
13269 : : expr.value);
13270 : : else
13271 : 53 : expr.value = build3_loc (loc, COND_EXPR, type,
13272 : : build2_loc (loc, EQ_EXPR,
13273 : : boolean_type_node, arg,
13274 : : build_int_cst (type, 0)),
13275 : : build_int_cst (type, 0),
13276 : : expr.value);
13277 : : break;
13278 : : }
13279 : 0 : case RID_AT_SELECTOR:
13280 : 0 : {
13281 : 0 : gcc_assert (c_dialect_objc ());
13282 : 0 : c_parser_consume_token (parser);
13283 : 0 : matching_parens parens;
13284 : 0 : if (!parens.require_open (parser))
13285 : : {
13286 : 0 : expr.set_error ();
13287 : 0 : break;
13288 : : }
13289 : 0 : tree sel = c_parser_objc_selector_arg (parser);
13290 : 0 : location_t close_loc = c_parser_peek_token (parser)->location;
13291 : 0 : parens.skip_until_found_close (parser);
13292 : 0 : expr.value = objc_build_selector_expr (loc, sel);
13293 : 0 : set_c_expr_source_range (&expr, loc, close_loc);
13294 : : }
13295 : 0 : break;
13296 : 0 : case RID_AT_PROTOCOL:
13297 : 0 : {
13298 : 0 : gcc_assert (c_dialect_objc ());
13299 : 0 : c_parser_consume_token (parser);
13300 : 0 : matching_parens parens;
13301 : 0 : if (!parens.require_open (parser))
13302 : : {
13303 : 0 : expr.set_error ();
13304 : 0 : break;
13305 : : }
13306 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
13307 : : {
13308 : 0 : c_parser_error (parser, "expected identifier");
13309 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
13310 : 0 : expr.set_error ();
13311 : 0 : break;
13312 : : }
13313 : 0 : tree id = c_parser_peek_token (parser)->value;
13314 : 0 : c_parser_consume_token (parser);
13315 : 0 : location_t close_loc = c_parser_peek_token (parser)->location;
13316 : 0 : parens.skip_until_found_close (parser);
13317 : 0 : expr.value = objc_build_protocol_expr (id);
13318 : 0 : set_c_expr_source_range (&expr, loc, close_loc);
13319 : : }
13320 : 0 : break;
13321 : 0 : case RID_AT_ENCODE:
13322 : 0 : {
13323 : : /* Extension to support C-structures in the archiver. */
13324 : 0 : gcc_assert (c_dialect_objc ());
13325 : 0 : c_parser_consume_token (parser);
13326 : 0 : matching_parens parens;
13327 : 0 : if (!parens.require_open (parser))
13328 : : {
13329 : 0 : expr.set_error ();
13330 : 0 : break;
13331 : : }
13332 : 0 : t1 = c_parser_type_name (parser);
13333 : 0 : if (t1 == NULL)
13334 : : {
13335 : 0 : expr.set_error ();
13336 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
13337 : 0 : break;
13338 : : }
13339 : 0 : location_t close_loc = c_parser_peek_token (parser)->location;
13340 : 0 : parens.skip_until_found_close (parser);
13341 : 0 : tree type = groktypename (t1, NULL, NULL);
13342 : 0 : expr.value = objc_build_encode_expr (type);
13343 : 0 : set_c_expr_source_range (&expr, loc, close_loc);
13344 : : }
13345 : 0 : break;
13346 : 622 : case RID_GENERIC:
13347 : 622 : expr = c_parser_generic_selection (parser);
13348 : 622 : break;
13349 : 3 : case RID_OMP_ALL_MEMORY:
13350 : 3 : gcc_assert (flag_openmp);
13351 : 3 : c_parser_consume_token (parser);
13352 : 3 : error_at (loc, "%<omp_all_memory%> may only be used in OpenMP "
13353 : : "%<depend%> clause");
13354 : 3 : expr.set_error ();
13355 : 3 : break;
13356 : : /* C23 'nullptr' literal. */
13357 : 11228 : case RID_NULLPTR:
13358 : 11228 : c_parser_consume_token (parser);
13359 : 11228 : expr.value = nullptr_node;
13360 : 11228 : set_c_expr_source_range (&expr, tok_range);
13361 : 11228 : pedwarn_c11 (loc, OPT_Wpedantic,
13362 : : "ISO C does not support %qs before C23", "nullptr");
13363 : 11228 : break;
13364 : 3733 : case RID_TRUE:
13365 : 3733 : c_parser_consume_token (parser);
13366 : 3733 : expr.value = boolean_true_node;
13367 : 3733 : set_c_expr_source_range (&expr, tok_range);
13368 : 3733 : break;
13369 : 4115 : case RID_FALSE:
13370 : 4115 : c_parser_consume_token (parser);
13371 : 4115 : expr.value = boolean_false_node;
13372 : 4115 : set_c_expr_source_range (&expr, tok_range);
13373 : 4115 : break;
13374 : 37 : default:
13375 : 37 : c_parser_error (parser, "expected expression");
13376 : 37 : expr.set_error ();
13377 : 37 : break;
13378 : : }
13379 : : break;
13380 : 2 : case CPP_OPEN_SQUARE:
13381 : 2 : if (c_dialect_objc ())
13382 : : {
13383 : 0 : tree receiver, args;
13384 : 0 : c_parser_consume_token (parser);
13385 : 0 : receiver = c_parser_objc_receiver (parser);
13386 : 0 : args = c_parser_objc_message_args (parser);
13387 : 0 : location_t close_loc = c_parser_peek_token (parser)->location;
13388 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
13389 : : "expected %<]%>");
13390 : 0 : expr.value = objc_build_message_expr (receiver, args);
13391 : 0 : set_c_expr_source_range (&expr, loc, close_loc);
13392 : 0 : break;
13393 : : }
13394 : : /* Else fall through to report error. */
13395 : : /* FALLTHRU */
13396 : 793 : default:
13397 : 793 : c_parser_error (parser, "expected expression");
13398 : 793 : expr.set_error ();
13399 : 793 : break;
13400 : : }
13401 : 230663835 : out:
13402 : 230663835 : return c_parser_postfix_expression_after_primary
13403 : 230663835 : (parser, EXPR_LOC_OR_LOC (expr.value, loc), expr);
13404 : : }
13405 : :
13406 : : /* Parse a postfix expression after a parenthesized type name: the
13407 : : brace-enclosed initializer of a compound literal, possibly followed
13408 : : by some postfix operators. This is separate because it is not
13409 : : possible to tell until after the type name whether a cast
13410 : : expression has a cast or a compound literal, or whether the operand
13411 : : of sizeof is a parenthesized type name or starts with a compound
13412 : : literal. TYPE_LOC is the location where TYPE_NAME starts--the
13413 : : location of the first token after the parentheses around the type
13414 : : name. */
13415 : :
13416 : : static struct c_expr
13417 : 898098 : c_parser_postfix_expression_after_paren_type (c_parser *parser,
13418 : : struct c_declspecs *scspecs,
13419 : : struct c_type_name *type_name,
13420 : : location_t type_loc)
13421 : : {
13422 : 898098 : tree type;
13423 : 898098 : struct c_expr init;
13424 : 898098 : bool non_const;
13425 : 898098 : struct c_expr expr;
13426 : 898098 : location_t start_loc;
13427 : 898098 : tree type_expr = NULL_TREE;
13428 : 898098 : bool type_expr_const = true;
13429 : 898098 : bool constexpr_p = scspecs ? scspecs->constexpr_p : false;
13430 : 898098 : unsigned int underspec_state = 0;
13431 : 898098 : check_compound_literal_type (type_loc, type_name);
13432 : 898098 : rich_location richloc (line_table, type_loc);
13433 : 898098 : start_loc = c_parser_peek_token (parser)->location;
13434 : 898098 : if (constexpr_p)
13435 : : {
13436 : 232 : underspec_state = start_underspecified_init (start_loc, NULL_TREE);
13437 : : /* A constexpr compound literal is subject to the constraints on
13438 : : underspecified declarations, which may not declare tags or
13439 : : members or structures or unions; it is undefined behavior to
13440 : : declare the members of an enumeration. Where the structure,
13441 : : union or enumeration type is declared within the compound
13442 : : literal initializer, this is diagnosed elsewhere as a result
13443 : : of the above call to start_underspecified_init. Diagnose
13444 : : here the case of declaring such a type in the type specifiers
13445 : : of the compound literal. */
13446 : 232 : switch (type_name->specs->typespec_kind)
13447 : : {
13448 : 2 : case ctsk_tagfirstref:
13449 : 2 : case ctsk_tagfirstref_attrs:
13450 : 2 : error_at (type_loc, "%qT declared in %<constexpr%> compound literal",
13451 : : type_name->specs->type);
13452 : 2 : break;
13453 : :
13454 : 4 : case ctsk_tagdef:
13455 : 4 : error_at (type_loc, "%qT defined in %<constexpr%> compound literal",
13456 : : type_name->specs->type);
13457 : 4 : break;
13458 : :
13459 : : default:
13460 : : break;
13461 : : }
13462 : : }
13463 : 898098 : start_init (NULL_TREE, NULL,
13464 : 898098 : (global_bindings_p ()
13465 : 897848 : || (scspecs && scspecs->storage_class == csc_static)
13466 : 1795918 : || constexpr_p), constexpr_p, &richloc);
13467 : 898098 : type = groktypename (type_name, &type_expr, &type_expr_const);
13468 : 898098 : if (type != error_mark_node && C_TYPE_VARIABLE_SIZE (type))
13469 : : {
13470 : 9 : error_at (type_loc, "compound literal has variable size");
13471 : 9 : type = error_mark_node;
13472 : : }
13473 : 898089 : else if (TREE_CODE (type) == FUNCTION_TYPE)
13474 : : {
13475 : 3 : error_at (type_loc, "compound literal has function type");
13476 : 3 : type = error_mark_node;
13477 : : }
13478 : 898098 : if (constexpr_p && type != error_mark_node)
13479 : : {
13480 : 232 : tree type_no_array = strip_array_types (type);
13481 : : /* The type of a constexpr object must not be variably modified
13482 : : (which applies to all compound literals), volatile, atomic or
13483 : : restrict qualified or have a member with such a qualifier.
13484 : : const qualification is implicitly added. */
13485 : 232 : if (TYPE_QUALS (type_no_array)
13486 : 232 : & (TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT | TYPE_QUAL_ATOMIC))
13487 : 9 : error_at (type_loc, "invalid qualifiers for %<constexpr%> object");
13488 : 223 : else if (RECORD_OR_UNION_TYPE_P (type_no_array)
13489 : 223 : && C_TYPE_FIELDS_NON_CONSTEXPR (type_no_array))
13490 : 8 : error_at (type_loc, "invalid qualifiers for field of "
13491 : : "%<constexpr%> object");
13492 : 464 : type = c_build_qualified_type (type,
13493 : 232 : (TYPE_QUALS (type_no_array)
13494 : : | TYPE_QUAL_CONST));
13495 : : }
13496 : 898098 : init = c_parser_braced_init (parser, type, false, NULL, NULL_TREE);
13497 : 898098 : if (constexpr_p)
13498 : 232 : finish_underspecified_init (NULL_TREE, underspec_state);
13499 : 898098 : finish_init ();
13500 : 898098 : maybe_warn_string_init (type_loc, type, init);
13501 : :
13502 : 898098 : if (type != error_mark_node
13503 : 898082 : && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
13504 : 898098 : && current_function_decl)
13505 : : {
13506 : 0 : error ("compound literal qualified by address-space qualifier");
13507 : 0 : type = error_mark_node;
13508 : : }
13509 : :
13510 : 1795900 : if (!pedwarn_c90 (start_loc, OPT_Wpedantic,
13511 : 898098 : "ISO C90 forbids compound literals") && scspecs)
13512 : 296 : pedwarn_c11 (start_loc, OPT_Wpedantic,
13513 : : "ISO C forbids storage class specifiers in compound literals "
13514 : : "before C23");
13515 : 898098 : non_const = ((init.value && TREE_CODE (init.value) == CONSTRUCTOR)
13516 : 1795745 : ? CONSTRUCTOR_NON_CONST (init.value)
13517 : 451 : : init.original_code == C_MAYBE_CONST_EXPR);
13518 : 898098 : non_const |= !type_expr_const;
13519 : 898098 : unsigned int alignas_align = 0;
13520 : 898098 : if (type != error_mark_node
13521 : 898082 : && type_name->specs->align_log != -1)
13522 : : {
13523 : 4 : alignas_align = 1U << type_name->specs->align_log;
13524 : 4 : if (alignas_align < min_align_of_type (type))
13525 : : {
13526 : 1 : error_at (type_name->specs->locations[cdw_alignas],
13527 : : "%<_Alignas%> specifiers cannot reduce "
13528 : : "alignment of compound literal");
13529 : 1 : alignas_align = 0;
13530 : : }
13531 : : }
13532 : 898098 : expr.value = build_compound_literal (start_loc, type, init.value, non_const,
13533 : : alignas_align, scspecs);
13534 : 898098 : set_c_expr_source_range (&expr, init.src_range);
13535 : 898098 : expr.m_decimal = 0;
13536 : 898098 : expr.original_code = ERROR_MARK;
13537 : 898098 : expr.original_type = NULL;
13538 : 898098 : if (type != error_mark_node
13539 : 898082 : && expr.value != error_mark_node
13540 : 898010 : && type_expr)
13541 : : {
13542 : 30 : if (TREE_CODE (expr.value) == C_MAYBE_CONST_EXPR)
13543 : : {
13544 : 18 : gcc_assert (C_MAYBE_CONST_EXPR_PRE (expr.value) == NULL_TREE);
13545 : 18 : C_MAYBE_CONST_EXPR_PRE (expr.value) = type_expr;
13546 : : }
13547 : : else
13548 : : {
13549 : 12 : gcc_assert (!non_const);
13550 : 12 : expr.value = build2 (C_MAYBE_CONST_EXPR, type,
13551 : : type_expr, expr.value);
13552 : : }
13553 : : }
13554 : 898098 : return c_parser_postfix_expression_after_primary (parser, start_loc, expr);
13555 : 898098 : }
13556 : :
13557 : : /* Callback function for sizeof_pointer_memaccess_warning to compare
13558 : : types. */
13559 : :
13560 : : static bool
13561 : 3456 : sizeof_ptr_memacc_comptypes (tree type1, tree type2)
13562 : : {
13563 : 3456 : return comptypes (type1, type2) == 1;
13564 : : }
13565 : :
13566 : : /* Warn for patterns where abs-like function appears to be used incorrectly,
13567 : : gracefully ignore any non-abs-like function. The warning location should
13568 : : be LOC. FNDECL is the declaration of called function, it must be a
13569 : : BUILT_IN_NORMAL function. ARG is the first and only argument of the
13570 : : call. */
13571 : :
13572 : : static void
13573 : 57387 : warn_for_abs (location_t loc, tree fndecl, tree arg)
13574 : : {
13575 : : /* Avoid warning in unreachable subexpressions. */
13576 : 57387 : if (c_inhibit_evaluation_warnings)
13577 : : return;
13578 : :
13579 : 31049 : tree atype = TREE_TYPE (arg);
13580 : :
13581 : : /* Casts from pointers (and thus arrays and fndecls) will generate
13582 : : -Wint-conversion warnings. Most other wrong types hopefully lead to type
13583 : : mismatch errors. TODO: Think about what to do with FIXED_POINT_TYPE_P
13584 : : types and possibly other exotic types. */
13585 : 31049 : if (!INTEGRAL_TYPE_P (atype)
13586 : 31049 : && !SCALAR_FLOAT_TYPE_P (atype)
13587 : 5123 : && TREE_CODE (atype) != COMPLEX_TYPE)
13588 : : return;
13589 : :
13590 : 26404 : enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13591 : :
13592 : 26404 : switch (fcode)
13593 : : {
13594 : 35 : case BUILT_IN_ABS:
13595 : 35 : case BUILT_IN_LABS:
13596 : 35 : case BUILT_IN_LLABS:
13597 : 35 : case BUILT_IN_IMAXABS:
13598 : 35 : if (!INTEGRAL_TYPE_P (atype))
13599 : : {
13600 : 4 : if (SCALAR_FLOAT_TYPE_P (atype))
13601 : 3 : warning_at (loc, OPT_Wabsolute_value,
13602 : : "using integer absolute value function %qD when "
13603 : : "argument is of floating-point type %qT",
13604 : : fndecl, atype);
13605 : 1 : else if (TREE_CODE (atype) == COMPLEX_TYPE)
13606 : 1 : warning_at (loc, OPT_Wabsolute_value,
13607 : : "using integer absolute value function %qD when "
13608 : : "argument is of complex type %qT", fndecl, atype);
13609 : : else
13610 : : gcc_unreachable ();
13611 : 4 : return;
13612 : : }
13613 : 31 : if (TYPE_UNSIGNED (atype))
13614 : 9 : warning_at (loc, OPT_Wabsolute_value,
13615 : : "taking the absolute value of unsigned type %qT "
13616 : : "has no effect", atype);
13617 : : break;
13618 : :
13619 : 334 : CASE_FLT_FN (BUILT_IN_FABS):
13620 : 334 : CASE_FLT_FN_FLOATN_NX (BUILT_IN_FABS):
13621 : 334 : if (!SCALAR_FLOAT_TYPE_P (atype)
13622 : 334 : || DECIMAL_FLOAT_MODE_P (TYPE_MODE (atype)))
13623 : : {
13624 : 4 : if (INTEGRAL_TYPE_P (atype))
13625 : 2 : warning_at (loc, OPT_Wabsolute_value,
13626 : : "using floating-point absolute value function %qD "
13627 : : "when argument is of integer type %qT", fndecl, atype);
13628 : 2 : else if (DECIMAL_FLOAT_TYPE_P (atype))
13629 : 1 : warning_at (loc, OPT_Wabsolute_value,
13630 : : "using floating-point absolute value function %qD "
13631 : : "when argument is of decimal floating-point type %qT",
13632 : : fndecl, atype);
13633 : 1 : else if (TREE_CODE (atype) == COMPLEX_TYPE)
13634 : 1 : warning_at (loc, OPT_Wabsolute_value,
13635 : : "using floating-point absolute value function %qD when "
13636 : : "argument is of complex type %qT", fndecl, atype);
13637 : : else
13638 : 0 : gcc_unreachable ();
13639 : 4 : return;
13640 : : }
13641 : : break;
13642 : :
13643 : 7 : CASE_FLT_FN (BUILT_IN_CABS):
13644 : 7 : if (TREE_CODE (atype) != COMPLEX_TYPE)
13645 : : {
13646 : 4 : if (INTEGRAL_TYPE_P (atype))
13647 : 2 : warning_at (loc, OPT_Wabsolute_value,
13648 : : "using complex absolute value function %qD when "
13649 : : "argument is of integer type %qT", fndecl, atype);
13650 : 2 : else if (SCALAR_FLOAT_TYPE_P (atype))
13651 : 2 : warning_at (loc, OPT_Wabsolute_value,
13652 : : "using complex absolute value function %qD when "
13653 : : "argument is of floating-point type %qT",
13654 : : fndecl, atype);
13655 : : else
13656 : : gcc_unreachable ();
13657 : :
13658 : 4 : return;
13659 : : }
13660 : : break;
13661 : :
13662 : 6 : case BUILT_IN_FABSD32:
13663 : 6 : case BUILT_IN_FABSD64:
13664 : 6 : case BUILT_IN_FABSD128:
13665 : 6 : case BUILT_IN_FABSD64X:
13666 : 6 : if (!DECIMAL_FLOAT_TYPE_P (atype))
13667 : : {
13668 : 4 : if (INTEGRAL_TYPE_P (atype))
13669 : 1 : warning_at (loc, OPT_Wabsolute_value,
13670 : : "using decimal floating-point absolute value "
13671 : : "function %qD when argument is of integer type %qT",
13672 : : fndecl, atype);
13673 : 3 : else if (SCALAR_FLOAT_TYPE_P (atype))
13674 : 2 : warning_at (loc, OPT_Wabsolute_value,
13675 : : "using decimal floating-point absolute value "
13676 : : "function %qD when argument is of floating-point "
13677 : : "type %qT", fndecl, atype);
13678 : 1 : else if (TREE_CODE (atype) == COMPLEX_TYPE)
13679 : 1 : warning_at (loc, OPT_Wabsolute_value,
13680 : : "using decimal floating-point absolute value "
13681 : : "function %qD when argument is of complex type %qT",
13682 : : fndecl, atype);
13683 : : else
13684 : 0 : gcc_unreachable ();
13685 : 4 : return;
13686 : : }
13687 : : break;
13688 : :
13689 : : default:
13690 : : return;
13691 : : }
13692 : :
13693 : 366 : if (!TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
13694 : : return;
13695 : :
13696 : 365 : tree ftype = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)));
13697 : 365 : if (TREE_CODE (atype) == COMPLEX_TYPE)
13698 : : {
13699 : 3 : gcc_assert (TREE_CODE (ftype) == COMPLEX_TYPE);
13700 : 3 : atype = TREE_TYPE (atype);
13701 : 3 : ftype = TREE_TYPE (ftype);
13702 : : }
13703 : :
13704 : 365 : if (TYPE_PRECISION (ftype) < TYPE_PRECISION (atype))
13705 : 9 : warning_at (loc, OPT_Wabsolute_value,
13706 : : "absolute value function %qD given an argument of type %qT "
13707 : : "but has parameter of type %qT which may cause truncation "
13708 : : "of value", fndecl, atype, ftype);
13709 : : }
13710 : :
13711 : :
13712 : : /* Parse a postfix expression after the initial primary or compound
13713 : : literal; that is, parse a series of postfix operators.
13714 : :
13715 : : EXPR_LOC is the location of the primary expression. */
13716 : :
13717 : : static struct c_expr
13718 : 231561980 : c_parser_postfix_expression_after_primary (c_parser *parser,
13719 : : location_t expr_loc,
13720 : : struct c_expr expr)
13721 : : {
13722 : 231561980 : struct c_expr orig_expr;
13723 : 231561980 : tree ident, idx, len;
13724 : 231561980 : location_t sizeof_arg_loc[6], comp_loc;
13725 : 231561980 : tree sizeof_arg[6];
13726 : 231561980 : unsigned int literal_zero_mask;
13727 : 231561980 : unsigned int i;
13728 : 231561980 : vec<tree, va_gc> *exprlist;
13729 : 231561980 : vec<tree, va_gc> *origtypes = NULL;
13730 : 231561980 : vec<location_t> arg_loc = vNULL;
13731 : 286388083 : location_t start;
13732 : 286388083 : location_t finish;
13733 : :
13734 : 286388083 : while (true)
13735 : : {
13736 : 286388083 : location_t op_loc = c_parser_peek_token (parser)->location;
13737 : 286388083 : switch (c_parser_peek_token (parser)->type)
13738 : : {
13739 : 3392489 : case CPP_OPEN_SQUARE:
13740 : : /* Array reference. */
13741 : 3392489 : c_parser_consume_token (parser);
13742 : 3392489 : idx = len = NULL_TREE;
13743 : 3392489 : if (!c_omp_array_section_p
13744 : 3393203 : || c_parser_next_token_is_not (parser, CPP_COLON))
13745 : 3392297 : idx = c_parser_expression (parser).value;
13746 : :
13747 : 3392489 : if (c_omp_array_section_p
13748 : 3393203 : && c_parser_next_token_is (parser, CPP_COLON))
13749 : : {
13750 : 569 : c_parser_consume_token (parser);
13751 : 569 : if (c_parser_next_token_is_not (parser, CPP_CLOSE_SQUARE))
13752 : 534 : len = c_parser_expression (parser).value;
13753 : :
13754 : 569 : expr.value = build_omp_array_section (op_loc, expr.value, idx,
13755 : : len);
13756 : : }
13757 : : else
13758 : 3391920 : expr.value = build_array_ref (op_loc, expr.value, idx);
13759 : :
13760 : 3392489 : c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
13761 : : "expected %<]%>");
13762 : :
13763 : 3392489 : start = expr.get_start ();
13764 : 3392489 : finish = parser->tokens_buf[0].location;
13765 : 3392489 : set_c_expr_source_range (&expr, start, finish);
13766 : 3392489 : expr.original_code = ERROR_MARK;
13767 : 3392489 : expr.original_type = NULL;
13768 : 3392489 : expr.m_decimal = 0;
13769 : 3392489 : break;
13770 : 48537093 : case CPP_OPEN_PAREN:
13771 : : /* Function call. */
13772 : 48537093 : {
13773 : 48537093 : matching_parens parens;
13774 : 48537093 : parens.consume_open (parser);
13775 : 388296744 : for (i = 0; i < 6; i++)
13776 : : {
13777 : 291222558 : sizeof_arg[i] = NULL_TREE;
13778 : 291222558 : sizeof_arg_loc[i] = UNKNOWN_LOCATION;
13779 : : }
13780 : 48537093 : literal_zero_mask = 0;
13781 : 48537093 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
13782 : : exprlist = NULL;
13783 : 37129749 : else if (TREE_CODE (expr.value) == FUNCTION_DECL
13784 : 37062715 : && fndecl_built_in_p (expr.value, BUILT_IN_CLASSIFY_TYPE)
13785 : 37131545 : && c_parser_next_tokens_start_typename (parser,
13786 : : cla_prefer_id))
13787 : : {
13788 : : /* __builtin_classify_type (type) */
13789 : 29 : c_inhibit_evaluation_warnings++;
13790 : 29 : in_alignof++;
13791 : 29 : struct c_type_name *type = c_parser_type_name (parser);
13792 : 29 : c_inhibit_evaluation_warnings--;
13793 : 29 : in_alignof--;
13794 : 29 : struct c_typespec ret;
13795 : 29 : ret.expr = NULL_TREE;
13796 : 29 : ret.spec = error_mark_node;
13797 : 29 : ret.expr_const_operands = false;
13798 : 29 : if (type != NULL)
13799 : 29 : ret.spec = groktypename (type, &ret.expr,
13800 : : &ret.expr_const_operands);
13801 : 29 : parens.skip_until_found_close (parser);
13802 : 29 : expr.value = build_int_cst (integer_type_node,
13803 : 29 : type_to_class (ret.spec));
13804 : 29 : break;
13805 : : }
13806 : : else
13807 : 37129720 : exprlist = c_parser_expr_list (parser, true, false, &origtypes,
13808 : : sizeof_arg_loc, sizeof_arg,
13809 : : &arg_loc, &literal_zero_mask);
13810 : 48537064 : parens.skip_until_found_close (parser);
13811 : : }
13812 : 48537064 : orig_expr = expr;
13813 : 48537064 : mark_exp_read (expr.value);
13814 : 48537064 : if (warn_sizeof_pointer_memaccess)
13815 : 4536316 : sizeof_pointer_memaccess_warning (sizeof_arg_loc,
13816 : : expr.value, exprlist,
13817 : : sizeof_arg,
13818 : : sizeof_ptr_memacc_comptypes);
13819 : 48537064 : if (TREE_CODE (expr.value) == FUNCTION_DECL)
13820 : : {
13821 : 48460299 : if (fndecl_built_in_p (expr.value, BUILT_IN_MEMSET)
13822 : 48491506 : && vec_safe_length (exprlist) == 3)
13823 : : {
13824 : 31207 : tree arg0 = (*exprlist)[0];
13825 : 31207 : tree arg2 = (*exprlist)[2];
13826 : 31207 : warn_for_memset (expr_loc, arg0, arg2, literal_zero_mask);
13827 : : }
13828 : 48460299 : if (warn_absolute_value
13829 : 4265072 : && fndecl_built_in_p (expr.value, BUILT_IN_NORMAL)
13830 : 48599336 : && vec_safe_length (exprlist) == 1)
13831 : 57387 : warn_for_abs (expr_loc, expr.value, (*exprlist)[0]);
13832 : 48460299 : if (parser->omp_for_parse_state
13833 : 177 : && parser->omp_for_parse_state->in_intervening_code
13834 : 48460437 : && omp_runtime_api_call (expr.value))
13835 : : {
13836 : 2 : error_at (expr_loc, "calls to the OpenMP runtime API are "
13837 : : "not permitted in intervening code");
13838 : 2 : parser->omp_for_parse_state->fail = true;
13839 : : }
13840 : 48460299 : if (warn_calloc_transposed_args)
13841 : 4265047 : if (tree attr = lookup_attribute ("alloc_size",
13842 : 4265047 : TYPE_ATTRIBUTES
13843 : : (TREE_TYPE (expr.value))))
13844 : 1259 : if (TREE_VALUE (attr) && TREE_CHAIN (TREE_VALUE (attr)))
13845 : 146 : warn_for_calloc (sizeof_arg_loc, expr.value, exprlist,
13846 : : sizeof_arg, attr);
13847 : : }
13848 : :
13849 : 48537064 : start = expr.get_start ();
13850 : 48537064 : finish = parser->tokens_buf[0].get_finish ();
13851 : 48537064 : expr.value
13852 : 48537064 : = c_build_function_call_vec (expr_loc, arg_loc, expr.value,
13853 : : exprlist, origtypes);
13854 : 48537064 : set_c_expr_source_range (&expr, start, finish);
13855 : 48537064 : expr.m_decimal = 0;
13856 : :
13857 : 48537064 : expr.original_code = ERROR_MARK;
13858 : 48537064 : if (TREE_CODE (expr.value) == INTEGER_CST
13859 : 12720 : && TREE_CODE (orig_expr.value) == FUNCTION_DECL
13860 : 48549784 : && fndecl_built_in_p (orig_expr.value, BUILT_IN_CONSTANT_P))
13861 : 1531 : expr.original_code = C_MAYBE_CONST_EXPR;
13862 : 48537064 : expr.original_type = NULL;
13863 : 48537064 : if (exprlist)
13864 : : {
13865 : 37129720 : release_tree_vector (exprlist);
13866 : 37129720 : release_tree_vector (origtypes);
13867 : : }
13868 : 48537064 : arg_loc.release ();
13869 : 48537064 : break;
13870 : 1730407 : case CPP_DOT:
13871 : : /* Structure element reference. */
13872 : 1730407 : c_parser_consume_token (parser);
13873 : 1730407 : expr = default_function_array_conversion (expr_loc, expr);
13874 : 1730407 : if (c_parser_next_token_is (parser, CPP_NAME))
13875 : : {
13876 : 1730407 : c_token *comp_tok = c_parser_peek_token (parser);
13877 : 1730407 : ident = comp_tok->value;
13878 : 1730407 : comp_loc = comp_tok->location;
13879 : : }
13880 : : else
13881 : : {
13882 : 0 : c_parser_error (parser, "expected identifier");
13883 : 0 : expr.set_error ();
13884 : 0 : expr.original_code = ERROR_MARK;
13885 : 0 : expr.original_type = NULL;
13886 : 0 : return expr;
13887 : : }
13888 : 1730407 : start = expr.get_start ();
13889 : 1730407 : finish = c_parser_peek_token (parser)->get_finish ();
13890 : 1730407 : c_parser_consume_token (parser);
13891 : 1730407 : expr.value = build_component_ref (op_loc, expr.value, ident,
13892 : : comp_loc, UNKNOWN_LOCATION);
13893 : 1730407 : set_c_expr_source_range (&expr, start, finish);
13894 : 1730407 : expr.original_code = ERROR_MARK;
13895 : 1730407 : if (TREE_CODE (expr.value) != COMPONENT_REF)
13896 : 32 : expr.original_type = NULL;
13897 : : else
13898 : : {
13899 : : /* Remember the original type of a bitfield. */
13900 : 1730375 : tree field = TREE_OPERAND (expr.value, 1);
13901 : 1730375 : if (TREE_CODE (field) != FIELD_DECL)
13902 : 0 : expr.original_type = NULL;
13903 : : else
13904 : 1730375 : expr.original_type = DECL_BIT_FIELD_TYPE (field);
13905 : : }
13906 : 1730407 : expr.m_decimal = 0;
13907 : 1730407 : break;
13908 : 492012 : case CPP_DEREF:
13909 : : /* Structure element reference. */
13910 : 492012 : c_parser_consume_token (parser);
13911 : 492012 : expr = convert_lvalue_to_rvalue (expr_loc, expr, true, false);
13912 : 492012 : if (c_parser_next_token_is (parser, CPP_NAME))
13913 : : {
13914 : 491980 : c_token *comp_tok = c_parser_peek_token (parser);
13915 : 491980 : ident = comp_tok->value;
13916 : 491980 : comp_loc = comp_tok->location;
13917 : : }
13918 : : else
13919 : : {
13920 : 32 : c_parser_error (parser, "expected identifier");
13921 : 32 : expr.set_error ();
13922 : 32 : expr.original_code = ERROR_MARK;
13923 : 32 : expr.original_type = NULL;
13924 : 32 : return expr;
13925 : : }
13926 : 491980 : start = expr.get_start ();
13927 : 491980 : finish = c_parser_peek_token (parser)->get_finish ();
13928 : 491980 : c_parser_consume_token (parser);
13929 : 491980 : expr.value = build_component_ref (op_loc,
13930 : : build_indirect_ref (op_loc,
13931 : : expr.value,
13932 : : RO_ARROW),
13933 : : ident, comp_loc,
13934 : : expr.get_location ());
13935 : 491980 : set_c_expr_source_range (&expr, start, finish);
13936 : 491980 : expr.original_code = ERROR_MARK;
13937 : 491980 : if (TREE_CODE (expr.value) != COMPONENT_REF)
13938 : 121 : expr.original_type = NULL;
13939 : : else
13940 : : {
13941 : : /* Remember the original type of a bitfield. */
13942 : 491859 : tree field = TREE_OPERAND (expr.value, 1);
13943 : 491859 : if (TREE_CODE (field) != FIELD_DECL)
13944 : 0 : expr.original_type = NULL;
13945 : : else
13946 : 491859 : expr.original_type = DECL_BIT_FIELD_TYPE (field);
13947 : : }
13948 : 491980 : expr.m_decimal = 0;
13949 : 491980 : break;
13950 : 656619 : case CPP_PLUS_PLUS:
13951 : : /* Postincrement. */
13952 : 656619 : start = expr.get_start ();
13953 : 656619 : finish = c_parser_peek_token (parser)->get_finish ();
13954 : 656619 : c_parser_consume_token (parser);
13955 : 235483 : if ((VAR_P (expr.value) || TREE_CODE (expr.value) == PARM_DECL)
13956 : 585410 : && !DECL_READ_P (expr.value)
13957 : 155304 : && (VAR_P (expr.value) ? warn_unused_but_set_variable
13958 : : : warn_unused_but_set_parameter) > 1
13959 : 687560 : && TREE_CODE (TREE_TYPE (expr.value)) != ARRAY_TYPE)
13960 : : {
13961 : 30941 : expr = default_function_array_read_conversion (expr_loc, expr);
13962 : 30941 : DECL_READ_P (expr.value) = 0;
13963 : : }
13964 : : else
13965 : 625678 : expr = default_function_array_read_conversion (expr_loc, expr);
13966 : 656619 : expr.value = build_unary_op (op_loc, POSTINCREMENT_EXPR,
13967 : : expr.value, false);
13968 : 656619 : set_c_expr_source_range (&expr, start, finish);
13969 : 656619 : expr.original_code = ERROR_MARK;
13970 : 656619 : expr.original_type = NULL;
13971 : 656619 : break;
13972 : 17515 : case CPP_MINUS_MINUS:
13973 : : /* Postdecrement. */
13974 : 17515 : start = expr.get_start ();
13975 : 17515 : finish = c_parser_peek_token (parser)->get_finish ();
13976 : 17515 : c_parser_consume_token (parser);
13977 : 6403 : if ((VAR_P (expr.value) || TREE_CODE (expr.value) == PARM_DECL)
13978 : 14527 : && !DECL_READ_P (expr.value)
13979 : 3226 : && (VAR_P (expr.value) ? warn_unused_but_set_variable
13980 : : : warn_unused_but_set_parameter) > 1
13981 : 17851 : && TREE_CODE (TREE_TYPE (expr.value)) != ARRAY_TYPE)
13982 : : {
13983 : 336 : expr = default_function_array_read_conversion (expr_loc, expr);
13984 : 336 : DECL_READ_P (expr.value) = 0;
13985 : : }
13986 : : else
13987 : 17179 : expr = default_function_array_read_conversion (expr_loc, expr);
13988 : 17515 : expr.value = build_unary_op (op_loc, POSTDECREMENT_EXPR,
13989 : : expr.value, false);
13990 : 17515 : set_c_expr_source_range (&expr, start, finish);
13991 : 17515 : expr.original_code = ERROR_MARK;
13992 : 17515 : expr.original_type = NULL;
13993 : 17515 : break;
13994 : 231561948 : default:
13995 : 231561948 : return expr;
13996 : : }
13997 : : }
13998 : : }
13999 : :
14000 : : /* Parse an expression (C90 6.3.17, C99 6.5.17, C11 6.5.17).
14001 : :
14002 : : expression:
14003 : : assignment-expression
14004 : : expression , assignment-expression
14005 : : */
14006 : :
14007 : : static struct c_expr
14008 : 54198976 : c_parser_expression (c_parser *parser)
14009 : : {
14010 : 54198976 : location_t tloc = c_parser_peek_token (parser)->location;
14011 : 54198976 : struct c_expr expr;
14012 : 54198976 : expr = c_parser_expr_no_commas (parser, NULL);
14013 : 54198976 : if (c_parser_next_token_is (parser, CPP_COMMA))
14014 : 88266 : expr = convert_lvalue_to_rvalue (tloc, expr, true, false);
14015 : 54300403 : while (c_parser_next_token_is (parser, CPP_COMMA))
14016 : : {
14017 : 101427 : struct c_expr next;
14018 : 101427 : tree lhsval;
14019 : 101427 : location_t loc = c_parser_peek_token (parser)->location;
14020 : 101427 : location_t expr_loc;
14021 : 101427 : c_parser_consume_token (parser);
14022 : 101427 : expr_loc = c_parser_peek_token (parser)->location;
14023 : 101427 : lhsval = expr.value;
14024 : 101427 : while (TREE_CODE (lhsval) == COMPOUND_EXPR
14025 : 115442 : || TREE_CODE (lhsval) == NOP_EXPR)
14026 : : {
14027 : 14015 : if (TREE_CODE (lhsval) == COMPOUND_EXPR)
14028 : 13917 : lhsval = TREE_OPERAND (lhsval, 1);
14029 : : else
14030 : 98 : lhsval = TREE_OPERAND (lhsval, 0);
14031 : : }
14032 : 101427 : if (DECL_P (lhsval) || handled_component_p (lhsval))
14033 : 88 : mark_exp_read (lhsval);
14034 : 101427 : if (c_parser_next_token_is (parser, CPP_EMBED))
14035 : : {
14036 : : /* Users aren't interested in milions of -Wunused-value
14037 : : warnings when using #embed inside of a comma expression,
14038 : : and one CPP_NUMBER plus CPP_COMMA before it and one
14039 : : CPP_COMMA plus CPP_NUMBER after it is guaranteed by
14040 : : the preprocessor. Thus, parse the whole CPP_EMBED just
14041 : : as a single INTEGER_CST, the last byte in it. */
14042 : 1 : c_token *embed = c_parser_peek_token (parser);
14043 : 1 : tree val = embed->value;
14044 : 1 : unsigned last = RAW_DATA_LENGTH (val) - 1;
14045 : 1 : next.value = build_int_cst (TREE_TYPE (val),
14046 : 1 : RAW_DATA_UCHAR_ELT (val, last));
14047 : 1 : next.original_type = integer_type_node;
14048 : 1 : c_parser_consume_token (parser);
14049 : : }
14050 : : else
14051 : : {
14052 : 101426 : next = c_parser_expr_no_commas (parser, NULL);
14053 : 101426 : next = convert_lvalue_to_rvalue (expr_loc, next, true, false);
14054 : : }
14055 : 101427 : expr.value = build_compound_expr (loc, expr.value, next.value);
14056 : 101427 : expr.original_code = COMPOUND_EXPR;
14057 : 101427 : expr.original_type = next.original_type;
14058 : 101427 : expr.m_decimal = 0;
14059 : : }
14060 : 54198976 : return expr;
14061 : : }
14062 : :
14063 : : /* Parse an expression and convert functions or arrays to pointers and
14064 : : lvalues to rvalues. */
14065 : :
14066 : : static struct c_expr
14067 : 41405063 : c_parser_expression_conv (c_parser *parser)
14068 : : {
14069 : 41405063 : struct c_expr expr;
14070 : 41405063 : location_t loc = c_parser_peek_token (parser)->location;
14071 : 41405063 : expr = c_parser_expression (parser);
14072 : 41405063 : expr = convert_lvalue_to_rvalue (loc, expr, true, false);
14073 : 41405063 : return expr;
14074 : : }
14075 : :
14076 : : /* Helper function of c_parser_expr_list. Check if IDXth (0 based)
14077 : : argument is a literal zero alone and if so, set it in literal_zero_mask. */
14078 : :
14079 : : static inline void
14080 : 123092012 : c_parser_check_literal_zero (c_parser *parser, unsigned *literal_zero_mask,
14081 : : unsigned int idx)
14082 : : {
14083 : 123092012 : if (idx >= HOST_BITS_PER_INT)
14084 : : return;
14085 : :
14086 : 123069987 : c_token *tok = c_parser_peek_token (parser);
14087 : 123069987 : switch (tok->type)
14088 : : {
14089 : 6745091 : case CPP_NUMBER:
14090 : 6745091 : case CPP_CHAR:
14091 : 6745091 : case CPP_WCHAR:
14092 : 6745091 : case CPP_CHAR16:
14093 : 6745091 : case CPP_CHAR32:
14094 : 6745091 : case CPP_UTF8CHAR:
14095 : : /* If a parameter is literal zero alone, remember it
14096 : : for -Wmemset-transposed-args warning. */
14097 : 6745091 : if (integer_zerop (tok->value)
14098 : 1235026 : && !TREE_OVERFLOW (tok->value)
14099 : 7980117 : && (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
14100 : 854918 : || c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_PAREN))
14101 : 1234192 : *literal_zero_mask |= 1U << idx;
14102 : : default:
14103 : : break;
14104 : : }
14105 : : }
14106 : :
14107 : : /* Parse a non-empty list of expressions. If CONVERT_P, convert
14108 : : functions and arrays to pointers and lvalues to rvalues. If
14109 : : FOLD_P, fold the expressions. If LOCATIONS is non-NULL, save the
14110 : : locations of function arguments into this vector.
14111 : :
14112 : : nonempty-expr-list:
14113 : : assignment-expression
14114 : : nonempty-expr-list , assignment-expression
14115 : : */
14116 : :
14117 : : static vec<tree, va_gc> *
14118 : 41547489 : c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
14119 : : vec<tree, va_gc> **p_orig_types,
14120 : : location_t *sizeof_arg_loc, tree *sizeof_arg,
14121 : : vec<location_t> *locations,
14122 : : unsigned int *literal_zero_mask)
14123 : : {
14124 : 41547489 : vec<tree, va_gc> *ret;
14125 : 41547489 : vec<tree, va_gc> *orig_types;
14126 : 41547489 : struct c_expr expr;
14127 : 41547489 : unsigned int idx = 0;
14128 : 41547489 : bool save_c_omp_array_section_p = c_omp_array_section_p;
14129 : 41547489 : c_omp_array_section_p = false;
14130 : :
14131 : 41547489 : ret = make_tree_vector ();
14132 : 41547489 : if (p_orig_types == NULL)
14133 : 4417769 : orig_types = NULL;
14134 : : else
14135 : 37129720 : orig_types = make_tree_vector ();
14136 : :
14137 : 41547489 : if (literal_zero_mask)
14138 : 37129720 : c_parser_check_literal_zero (parser, literal_zero_mask, 0);
14139 : 41547489 : expr = c_parser_expr_no_commas (parser, NULL);
14140 : 41547489 : if (convert_p)
14141 : 37130191 : expr = convert_lvalue_to_rvalue (expr.get_location (), expr, true, true);
14142 : 41547489 : if (fold_p)
14143 : 4417769 : expr.value = c_fully_fold (expr.value, false, NULL);
14144 : 41547489 : ret->quick_push (expr.value);
14145 : 41547489 : if (orig_types)
14146 : 37129720 : orig_types->quick_push (expr.original_type);
14147 : 41547489 : if (locations)
14148 : 37129720 : locations->safe_push (expr.get_location ());
14149 : 41547489 : if (sizeof_arg != NULL
14150 : 37129720 : && (expr.original_code == SIZEOF_EXPR
14151 : 37129720 : || expr.original_code == PAREN_SIZEOF_EXPR))
14152 : : {
14153 : 2068 : sizeof_arg[0] = c_last_sizeof_arg;
14154 : 2068 : sizeof_arg_loc[0] = c_last_sizeof_loc;
14155 : : }
14156 : 128829681 : while (c_parser_next_token_is (parser, CPP_COMMA))
14157 : : {
14158 : 87282192 : c_parser_consume_token (parser);
14159 : 87282192 : if (c_parser_next_token_is (parser, CPP_EMBED))
14160 : : {
14161 : 3 : c_token *embed = c_parser_peek_token (parser);
14162 : 3 : tree value = embed->value;
14163 : 3 : expr.original_code = INTEGER_CST;
14164 : 3 : expr.original_type = integer_type_node;
14165 : 3 : expr.value = NULL_TREE;
14166 : 3 : set_c_expr_source_range (&expr, embed->get_range ());
14167 : 3 : expr.m_decimal = 0;
14168 : 381 : for (unsigned int i = 0; i < (unsigned) RAW_DATA_LENGTH (value); i++)
14169 : : {
14170 : 378 : if (literal_zero_mask
14171 : 126 : && idx + 1 < HOST_BITS_PER_INT
14172 : 409 : && RAW_DATA_POINTER (value)[i] == 0)
14173 : 0 : *literal_zero_mask |= 1U << (idx + 1);
14174 : 378 : expr.value = build_int_cst (integer_type_node,
14175 : 378 : RAW_DATA_UCHAR_ELT (value, i));
14176 : 378 : vec_safe_push (ret, expr.value);
14177 : 378 : if (orig_types)
14178 : 126 : vec_safe_push (orig_types, expr.original_type);
14179 : 378 : if (locations)
14180 : 126 : locations->safe_push (expr.get_location ());
14181 : 378 : ++idx;
14182 : : }
14183 : 3 : c_parser_consume_token (parser);
14184 : 3 : continue;
14185 : 3 : }
14186 : 87282189 : if (literal_zero_mask)
14187 : 85962292 : c_parser_check_literal_zero (parser, literal_zero_mask, idx + 1);
14188 : 87282189 : expr = c_parser_expr_no_commas (parser, NULL);
14189 : 87282189 : if (convert_p)
14190 : 85962558 : expr = convert_lvalue_to_rvalue (expr.get_location (), expr, true,
14191 : : true);
14192 : 87282189 : if (fold_p)
14193 : 1319897 : expr.value = c_fully_fold (expr.value, false, NULL);
14194 : 87282189 : vec_safe_push (ret, expr.value);
14195 : 87282189 : if (orig_types)
14196 : 85962292 : vec_safe_push (orig_types, expr.original_type);
14197 : 87282189 : if (locations)
14198 : 85962292 : locations->safe_push (expr.get_location ());
14199 : 87282189 : if (++idx < 6
14200 : 85760055 : && sizeof_arg != NULL
14201 : 87282189 : && (expr.original_code == SIZEOF_EXPR
14202 : 84440172 : || expr.original_code == PAREN_SIZEOF_EXPR))
14203 : : {
14204 : 78920 : sizeof_arg[idx] = c_last_sizeof_arg;
14205 : 78920 : sizeof_arg_loc[idx] = c_last_sizeof_loc;
14206 : : }
14207 : : }
14208 : 41547489 : if (orig_types)
14209 : 37129720 : *p_orig_types = orig_types;
14210 : 41547489 : c_omp_array_section_p = save_c_omp_array_section_p;
14211 : 41547489 : return ret;
14212 : : }
14213 : :
14214 : : /* Parse Objective-C-specific constructs. */
14215 : :
14216 : : /* Parse an objc-class-definition.
14217 : :
14218 : : objc-class-definition:
14219 : : @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
14220 : : objc-class-instance-variables[opt] objc-methodprotolist @end
14221 : : @implementation identifier objc-superclass[opt]
14222 : : objc-class-instance-variables[opt]
14223 : : @interface identifier ( identifier ) objc-protocol-refs[opt]
14224 : : objc-methodprotolist @end
14225 : : @interface identifier ( ) objc-protocol-refs[opt]
14226 : : objc-methodprotolist @end
14227 : : @implementation identifier ( identifier )
14228 : :
14229 : : objc-superclass:
14230 : : : identifier
14231 : :
14232 : : "@interface identifier (" must start "@interface identifier (
14233 : : identifier ) ...": objc-methodprotolist in the first production may
14234 : : not start with a parenthesized identifier as a declarator of a data
14235 : : definition with no declaration specifiers if the objc-superclass,
14236 : : objc-protocol-refs and objc-class-instance-variables are omitted. */
14237 : :
14238 : : static void
14239 : 0 : c_parser_objc_class_definition (c_parser *parser, tree attributes)
14240 : : {
14241 : 0 : bool iface_p;
14242 : 0 : tree id1;
14243 : 0 : tree superclass;
14244 : 0 : if (c_parser_next_token_is_keyword (parser, RID_AT_INTERFACE))
14245 : : iface_p = true;
14246 : 0 : else if (c_parser_next_token_is_keyword (parser, RID_AT_IMPLEMENTATION))
14247 : : iface_p = false;
14248 : : else
14249 : 0 : gcc_unreachable ();
14250 : :
14251 : 0 : c_parser_consume_token (parser);
14252 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
14253 : : {
14254 : 0 : c_parser_error (parser, "expected identifier");
14255 : 0 : return;
14256 : : }
14257 : 0 : id1 = c_parser_peek_token (parser)->value;
14258 : 0 : location_t loc1 = c_parser_peek_token (parser)->location;
14259 : 0 : c_parser_consume_token (parser);
14260 : 0 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
14261 : : {
14262 : : /* We have a category or class extension. */
14263 : 0 : tree id2;
14264 : 0 : tree proto = NULL_TREE;
14265 : 0 : matching_parens parens;
14266 : 0 : parens.consume_open (parser);
14267 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
14268 : : {
14269 : 0 : if (iface_p && c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
14270 : : {
14271 : : /* We have a class extension. */
14272 : : id2 = NULL_TREE;
14273 : : }
14274 : : else
14275 : : {
14276 : 0 : c_parser_error (parser, "expected identifier or %<)%>");
14277 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
14278 : 0 : return;
14279 : : }
14280 : : }
14281 : : else
14282 : : {
14283 : 0 : id2 = c_parser_peek_token (parser)->value;
14284 : 0 : c_parser_consume_token (parser);
14285 : : }
14286 : 0 : parens.skip_until_found_close (parser);
14287 : 0 : if (!iface_p)
14288 : : {
14289 : 0 : objc_start_category_implementation (id1, id2);
14290 : 0 : return;
14291 : : }
14292 : 0 : if (c_parser_next_token_is (parser, CPP_LESS))
14293 : 0 : proto = c_parser_objc_protocol_refs (parser);
14294 : 0 : objc_start_category_interface (id1, id2, proto, attributes);
14295 : 0 : c_parser_objc_methodprotolist (parser);
14296 : 0 : c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
14297 : 0 : objc_finish_interface ();
14298 : 0 : return;
14299 : : }
14300 : 0 : if (c_parser_next_token_is (parser, CPP_COLON))
14301 : : {
14302 : 0 : c_parser_consume_token (parser);
14303 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
14304 : : {
14305 : 0 : c_parser_error (parser, "expected identifier");
14306 : 0 : return;
14307 : : }
14308 : 0 : superclass = c_parser_peek_token (parser)->value;
14309 : 0 : c_parser_consume_token (parser);
14310 : : }
14311 : : else
14312 : : superclass = NULL_TREE;
14313 : 0 : if (iface_p)
14314 : : {
14315 : 0 : tree proto = NULL_TREE;
14316 : 0 : if (c_parser_next_token_is (parser, CPP_LESS))
14317 : 0 : proto = c_parser_objc_protocol_refs (parser);
14318 : 0 : objc_start_class_interface (id1, loc1, superclass, proto, attributes);
14319 : : }
14320 : : else
14321 : 0 : objc_start_class_implementation (id1, superclass);
14322 : 0 : if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
14323 : 0 : c_parser_objc_class_instance_variables (parser);
14324 : 0 : if (iface_p)
14325 : : {
14326 : 0 : objc_continue_interface ();
14327 : 0 : c_parser_objc_methodprotolist (parser);
14328 : 0 : c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
14329 : 0 : objc_finish_interface ();
14330 : : }
14331 : : else
14332 : : {
14333 : 0 : objc_continue_implementation ();
14334 : 0 : return;
14335 : : }
14336 : : }
14337 : :
14338 : : /* Parse objc-class-instance-variables.
14339 : :
14340 : : objc-class-instance-variables:
14341 : : { objc-instance-variable-decl-list[opt] }
14342 : :
14343 : : objc-instance-variable-decl-list:
14344 : : objc-visibility-spec
14345 : : objc-instance-variable-decl ;
14346 : : ;
14347 : : objc-instance-variable-decl-list objc-visibility-spec
14348 : : objc-instance-variable-decl-list objc-instance-variable-decl ;
14349 : : objc-instance-variable-decl-list ;
14350 : :
14351 : : objc-visibility-spec:
14352 : : @private
14353 : : @protected
14354 : : @public
14355 : :
14356 : : objc-instance-variable-decl:
14357 : : struct-declaration
14358 : : */
14359 : :
14360 : : static void
14361 : 0 : c_parser_objc_class_instance_variables (c_parser *parser)
14362 : : {
14363 : 0 : gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
14364 : 0 : c_parser_consume_token (parser);
14365 : 0 : while (c_parser_next_token_is_not (parser, CPP_EOF))
14366 : : {
14367 : 0 : tree decls;
14368 : : /* Parse any stray semicolon. */
14369 : 0 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
14370 : : {
14371 : 0 : pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
14372 : : "extra semicolon");
14373 : 0 : c_parser_consume_token (parser);
14374 : 0 : continue;
14375 : : }
14376 : : /* Stop if at the end of the instance variables. */
14377 : 0 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
14378 : : {
14379 : 0 : c_parser_consume_token (parser);
14380 : 0 : break;
14381 : : }
14382 : : /* Parse any objc-visibility-spec. */
14383 : 0 : if (c_parser_next_token_is_keyword (parser, RID_AT_PRIVATE))
14384 : : {
14385 : 0 : c_parser_consume_token (parser);
14386 : 0 : objc_set_visibility (OBJC_IVAR_VIS_PRIVATE);
14387 : 0 : continue;
14388 : : }
14389 : 0 : else if (c_parser_next_token_is_keyword (parser, RID_AT_PROTECTED))
14390 : : {
14391 : 0 : c_parser_consume_token (parser);
14392 : 0 : objc_set_visibility (OBJC_IVAR_VIS_PROTECTED);
14393 : 0 : continue;
14394 : : }
14395 : 0 : else if (c_parser_next_token_is_keyword (parser, RID_AT_PUBLIC))
14396 : : {
14397 : 0 : c_parser_consume_token (parser);
14398 : 0 : objc_set_visibility (OBJC_IVAR_VIS_PUBLIC);
14399 : 0 : continue;
14400 : : }
14401 : 0 : else if (c_parser_next_token_is_keyword (parser, RID_AT_PACKAGE))
14402 : : {
14403 : 0 : c_parser_consume_token (parser);
14404 : 0 : objc_set_visibility (OBJC_IVAR_VIS_PACKAGE);
14405 : 0 : continue;
14406 : : }
14407 : 0 : else if (c_parser_next_token_is (parser, CPP_PRAGMA))
14408 : : {
14409 : 0 : c_parser_pragma (parser, pragma_external, NULL, NULL_TREE);
14410 : 0 : continue;
14411 : : }
14412 : :
14413 : : /* Parse some comma-separated declarations. */
14414 : 0 : decls = c_parser_struct_declaration (parser, NULL);
14415 : 0 : if (decls == NULL)
14416 : : {
14417 : : /* There is a syntax error. We want to skip the offending
14418 : : tokens up to the next ';' (included) or '}'
14419 : : (excluded). */
14420 : :
14421 : : /* First, skip manually a ')' or ']'. This is because they
14422 : : reduce the nesting level, so c_parser_skip_until_found()
14423 : : wouldn't be able to skip past them. */
14424 : 0 : c_token *token = c_parser_peek_token (parser);
14425 : 0 : if (token->type == CPP_CLOSE_PAREN || token->type == CPP_CLOSE_SQUARE)
14426 : 0 : c_parser_consume_token (parser);
14427 : :
14428 : : /* Then, do the standard skipping. */
14429 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
14430 : :
14431 : : /* We hopefully recovered. Start normal parsing again. */
14432 : 0 : parser->error = false;
14433 : 0 : continue;
14434 : 0 : }
14435 : : else
14436 : : {
14437 : : /* Comma-separated instance variables are chained together
14438 : : in reverse order; add them one by one. */
14439 : 0 : tree ivar = nreverse (decls);
14440 : 0 : for (; ivar; ivar = DECL_CHAIN (ivar))
14441 : 0 : objc_add_instance_variable (copy_node (ivar));
14442 : : }
14443 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
14444 : : }
14445 : 0 : }
14446 : :
14447 : : /* Parse an objc-class-declaration.
14448 : :
14449 : : objc-class-declaration:
14450 : : @class identifier-list ;
14451 : : */
14452 : :
14453 : : static void
14454 : 0 : c_parser_objc_class_declaration (c_parser *parser)
14455 : : {
14456 : 0 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_CLASS));
14457 : 0 : c_parser_consume_token (parser);
14458 : : /* Any identifiers, including those declared as type names, are OK
14459 : : here. */
14460 : 0 : while (true)
14461 : : {
14462 : 0 : tree id;
14463 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
14464 : : {
14465 : 0 : c_parser_error (parser, "expected identifier");
14466 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
14467 : 0 : parser->error = false;
14468 : 0 : return;
14469 : : }
14470 : 0 : id = c_parser_peek_token (parser)->value;
14471 : 0 : objc_declare_class (id);
14472 : 0 : c_parser_consume_token (parser);
14473 : 0 : if (c_parser_next_token_is (parser, CPP_COMMA))
14474 : 0 : c_parser_consume_token (parser);
14475 : : else
14476 : : break;
14477 : 0 : }
14478 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
14479 : : }
14480 : :
14481 : : /* Parse an objc-alias-declaration.
14482 : :
14483 : : objc-alias-declaration:
14484 : : @compatibility_alias identifier identifier ;
14485 : : */
14486 : :
14487 : : static void
14488 : 0 : c_parser_objc_alias_declaration (c_parser *parser)
14489 : : {
14490 : 0 : tree id1, id2;
14491 : 0 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_ALIAS));
14492 : 0 : c_parser_consume_token (parser);
14493 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
14494 : : {
14495 : 0 : c_parser_error (parser, "expected identifier");
14496 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
14497 : 0 : return;
14498 : : }
14499 : 0 : id1 = c_parser_peek_token (parser)->value;
14500 : 0 : c_parser_consume_token (parser);
14501 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
14502 : : {
14503 : 0 : c_parser_error (parser, "expected identifier");
14504 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
14505 : 0 : return;
14506 : : }
14507 : 0 : id2 = c_parser_peek_token (parser)->value;
14508 : 0 : c_parser_consume_token (parser);
14509 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
14510 : 0 : objc_declare_alias (id1, id2);
14511 : : }
14512 : :
14513 : : /* Parse an objc-protocol-definition.
14514 : :
14515 : : objc-protocol-definition:
14516 : : @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
14517 : : @protocol identifier-list ;
14518 : :
14519 : : "@protocol identifier ;" should be resolved as "@protocol
14520 : : identifier-list ;": objc-methodprotolist may not start with a
14521 : : semicolon in the first alternative if objc-protocol-refs are
14522 : : omitted. */
14523 : :
14524 : : static void
14525 : 0 : c_parser_objc_protocol_definition (c_parser *parser, tree attributes)
14526 : : {
14527 : 0 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_PROTOCOL));
14528 : :
14529 : 0 : c_parser_consume_token (parser);
14530 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
14531 : : {
14532 : 0 : c_parser_error (parser, "expected identifier");
14533 : 0 : return;
14534 : : }
14535 : 0 : if (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
14536 : 0 : || c_parser_peek_2nd_token (parser)->type == CPP_SEMICOLON)
14537 : : {
14538 : : /* Any identifiers, including those declared as type names, are
14539 : : OK here. */
14540 : 0 : while (true)
14541 : : {
14542 : 0 : tree id;
14543 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
14544 : : {
14545 : 0 : c_parser_error (parser, "expected identifier");
14546 : 0 : break;
14547 : : }
14548 : 0 : id = c_parser_peek_token (parser)->value;
14549 : 0 : objc_declare_protocol (id, attributes);
14550 : 0 : c_parser_consume_token (parser);
14551 : 0 : if (c_parser_next_token_is (parser, CPP_COMMA))
14552 : 0 : c_parser_consume_token (parser);
14553 : : else
14554 : : break;
14555 : 0 : }
14556 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
14557 : : }
14558 : : else
14559 : : {
14560 : 0 : tree id = c_parser_peek_token (parser)->value;
14561 : 0 : tree proto = NULL_TREE;
14562 : 0 : c_parser_consume_token (parser);
14563 : 0 : if (c_parser_next_token_is (parser, CPP_LESS))
14564 : 0 : proto = c_parser_objc_protocol_refs (parser);
14565 : 0 : parser->objc_pq_context = true;
14566 : 0 : objc_start_protocol (id, proto, attributes);
14567 : 0 : c_parser_objc_methodprotolist (parser);
14568 : 0 : c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
14569 : 0 : parser->objc_pq_context = false;
14570 : 0 : objc_finish_interface ();
14571 : : }
14572 : : }
14573 : :
14574 : : /* Parse an objc-method-type.
14575 : :
14576 : : objc-method-type:
14577 : : +
14578 : : -
14579 : :
14580 : : Return true if it is a class method (+) and false if it is
14581 : : an instance method (-).
14582 : : */
14583 : : static inline bool
14584 : 0 : c_parser_objc_method_type (c_parser *parser)
14585 : : {
14586 : 0 : switch (c_parser_peek_token (parser)->type)
14587 : : {
14588 : 0 : case CPP_PLUS:
14589 : 0 : c_parser_consume_token (parser);
14590 : 0 : return true;
14591 : 0 : case CPP_MINUS:
14592 : 0 : c_parser_consume_token (parser);
14593 : 0 : return false;
14594 : 0 : default:
14595 : 0 : gcc_unreachable ();
14596 : : }
14597 : : }
14598 : :
14599 : : /* Parse an objc-method-definition.
14600 : :
14601 : : objc-method-definition:
14602 : : objc-method-type objc-method-decl ;[opt] compound-statement
14603 : : */
14604 : :
14605 : : static void
14606 : 0 : c_parser_objc_method_definition (c_parser *parser)
14607 : : {
14608 : 0 : bool is_class_method = c_parser_objc_method_type (parser);
14609 : 0 : tree decl, attributes = NULL_TREE, expr = NULL_TREE;
14610 : 0 : parser->objc_pq_context = true;
14611 : 0 : decl = c_parser_objc_method_decl (parser, is_class_method, &attributes,
14612 : : &expr);
14613 : 0 : if (decl == error_mark_node)
14614 : 0 : return; /* Bail here. */
14615 : :
14616 : 0 : if (c_parser_next_token_is (parser, CPP_SEMICOLON))
14617 : : {
14618 : 0 : c_parser_consume_token (parser);
14619 : 0 : pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
14620 : : "extra semicolon in method definition specified");
14621 : : }
14622 : :
14623 : 0 : if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE))
14624 : : {
14625 : 0 : c_parser_error (parser, "expected %<{%>");
14626 : 0 : return;
14627 : : }
14628 : :
14629 : 0 : parser->objc_pq_context = false;
14630 : 0 : if (objc_start_method_definition (is_class_method, decl, attributes, expr))
14631 : : {
14632 : 0 : add_stmt (c_parser_compound_statement (parser));
14633 : 0 : objc_finish_method_definition (current_function_decl);
14634 : : }
14635 : : else
14636 : : {
14637 : : /* This code is executed when we find a method definition
14638 : : outside of an @implementation context (or invalid for other
14639 : : reasons). Parse the method (to keep going) but do not emit
14640 : : any code.
14641 : : */
14642 : 0 : c_parser_compound_statement (parser);
14643 : : }
14644 : : }
14645 : :
14646 : : /* Parse an objc-methodprotolist.
14647 : :
14648 : : objc-methodprotolist:
14649 : : empty
14650 : : objc-methodprotolist objc-methodproto
14651 : : objc-methodprotolist declaration
14652 : : objc-methodprotolist ;
14653 : : @optional
14654 : : @required
14655 : :
14656 : : The declaration is a data definition, which may be missing
14657 : : declaration specifiers under the same rules and diagnostics as
14658 : : other data definitions outside functions, and the stray semicolon
14659 : : is diagnosed the same way as a stray semicolon outside a
14660 : : function. */
14661 : :
14662 : : static void
14663 : 0 : c_parser_objc_methodprotolist (c_parser *parser)
14664 : : {
14665 : 0 : while (true)
14666 : : {
14667 : : /* The list is terminated by @end. */
14668 : 0 : switch (c_parser_peek_token (parser)->type)
14669 : : {
14670 : 0 : case CPP_SEMICOLON:
14671 : 0 : pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
14672 : : "ISO C does not allow extra %<;%> outside of a function");
14673 : 0 : c_parser_consume_token (parser);
14674 : 0 : break;
14675 : 0 : case CPP_PLUS:
14676 : 0 : case CPP_MINUS:
14677 : 0 : c_parser_objc_methodproto (parser);
14678 : 0 : break;
14679 : 0 : case CPP_PRAGMA:
14680 : 0 : c_parser_pragma (parser, pragma_external, NULL, NULL_TREE);
14681 : 0 : break;
14682 : : case CPP_EOF:
14683 : : return;
14684 : 0 : default:
14685 : 0 : if (c_parser_next_token_is_keyword (parser, RID_AT_END))
14686 : : return;
14687 : 0 : else if (c_parser_next_token_is_keyword (parser, RID_AT_PROPERTY))
14688 : 0 : c_parser_objc_at_property_declaration (parser);
14689 : 0 : else if (c_parser_next_token_is_keyword (parser, RID_AT_OPTIONAL))
14690 : : {
14691 : 0 : objc_set_method_opt (true);
14692 : 0 : c_parser_consume_token (parser);
14693 : : }
14694 : 0 : else if (c_parser_next_token_is_keyword (parser, RID_AT_REQUIRED))
14695 : : {
14696 : 0 : objc_set_method_opt (false);
14697 : 0 : c_parser_consume_token (parser);
14698 : : }
14699 : : else
14700 : 0 : c_parser_declaration_or_fndef (parser, false, false, true,
14701 : : false, true, false);
14702 : : break;
14703 : : }
14704 : : }
14705 : : }
14706 : :
14707 : : /* Parse an objc-methodproto.
14708 : :
14709 : : objc-methodproto:
14710 : : objc-method-type objc-method-decl ;
14711 : : */
14712 : :
14713 : : static void
14714 : 0 : c_parser_objc_methodproto (c_parser *parser)
14715 : : {
14716 : 0 : bool is_class_method = c_parser_objc_method_type (parser);
14717 : 0 : tree decl, attributes = NULL_TREE;
14718 : :
14719 : : /* Remember protocol qualifiers in prototypes. */
14720 : 0 : parser->objc_pq_context = true;
14721 : 0 : decl = c_parser_objc_method_decl (parser, is_class_method, &attributes,
14722 : : NULL);
14723 : : /* Forget protocol qualifiers now. */
14724 : 0 : parser->objc_pq_context = false;
14725 : :
14726 : : /* Do not allow the presence of attributes to hide an erroneous
14727 : : method implementation in the interface section. */
14728 : 0 : if (!c_parser_next_token_is (parser, CPP_SEMICOLON))
14729 : : {
14730 : 0 : c_parser_error (parser, "expected %<;%>");
14731 : 0 : return;
14732 : : }
14733 : :
14734 : 0 : if (decl != error_mark_node)
14735 : 0 : objc_add_method_declaration (is_class_method, decl, attributes);
14736 : :
14737 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
14738 : : }
14739 : :
14740 : : /* If we are at a position that method attributes may be present, check that
14741 : : there are not any parsed already (a syntax error) and then collect any
14742 : : specified at the current location. Finally, if new attributes were present,
14743 : : check that the next token is legal ( ';' for decls and '{' for defs). */
14744 : :
14745 : : static bool
14746 : 0 : c_parser_objc_maybe_method_attributes (c_parser* parser, tree* attributes)
14747 : : {
14748 : 0 : bool bad = false;
14749 : 0 : if (*attributes)
14750 : : {
14751 : 0 : c_parser_error (parser,
14752 : : "method attributes must be specified at the end only");
14753 : 0 : *attributes = NULL_TREE;
14754 : 0 : bad = true;
14755 : : }
14756 : :
14757 : 0 : if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
14758 : 0 : *attributes = c_parser_gnu_attributes (parser);
14759 : :
14760 : : /* If there were no attributes here, just report any earlier error. */
14761 : 0 : if (*attributes == NULL_TREE || bad)
14762 : : return bad;
14763 : :
14764 : : /* If the attributes are followed by a ; or {, then just report any earlier
14765 : : error. */
14766 : 0 : if (c_parser_next_token_is (parser, CPP_SEMICOLON)
14767 : 0 : || c_parser_next_token_is (parser, CPP_OPEN_BRACE))
14768 : 0 : return bad;
14769 : :
14770 : : /* We've got attributes, but not at the end. */
14771 : 0 : c_parser_error (parser,
14772 : : "expected %<;%> or %<{%> after method attribute definition");
14773 : 0 : return true;
14774 : : }
14775 : :
14776 : : /* Parse an objc-method-decl.
14777 : :
14778 : : objc-method-decl:
14779 : : ( objc-type-name ) objc-selector
14780 : : objc-selector
14781 : : ( objc-type-name ) objc-keyword-selector objc-optparmlist
14782 : : objc-keyword-selector objc-optparmlist
14783 : : gnu-attributes
14784 : :
14785 : : objc-keyword-selector:
14786 : : objc-keyword-decl
14787 : : objc-keyword-selector objc-keyword-decl
14788 : :
14789 : : objc-keyword-decl:
14790 : : objc-selector : ( objc-type-name ) identifier
14791 : : objc-selector : identifier
14792 : : : ( objc-type-name ) identifier
14793 : : : identifier
14794 : :
14795 : : objc-optparmlist:
14796 : : objc-optparms objc-optellipsis
14797 : :
14798 : : objc-optparms:
14799 : : empty
14800 : : objc-opt-parms , parameter-declaration
14801 : :
14802 : : objc-optellipsis:
14803 : : empty
14804 : : , ...
14805 : : */
14806 : :
14807 : : static tree
14808 : 0 : c_parser_objc_method_decl (c_parser *parser, bool is_class_method,
14809 : : tree *attributes, tree *expr)
14810 : : {
14811 : 0 : tree type = NULL_TREE;
14812 : 0 : tree sel;
14813 : 0 : tree parms = NULL_TREE;
14814 : 0 : bool ellipsis = false;
14815 : 0 : bool attr_err = false;
14816 : :
14817 : 0 : *attributes = NULL_TREE;
14818 : 0 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
14819 : : {
14820 : 0 : matching_parens parens;
14821 : 0 : parens.consume_open (parser);
14822 : 0 : type = c_parser_objc_type_name (parser);
14823 : 0 : parens.skip_until_found_close (parser);
14824 : : }
14825 : 0 : sel = c_parser_objc_selector (parser);
14826 : : /* If there is no selector, or a colon follows, we have an
14827 : : objc-keyword-selector. If there is a selector, and a colon does
14828 : : not follow, that selector ends the objc-method-decl. */
14829 : 0 : if (!sel || c_parser_next_token_is (parser, CPP_COLON))
14830 : : {
14831 : : tree tsel = sel;
14832 : : tree list = NULL_TREE;
14833 : 0 : while (true)
14834 : : {
14835 : 0 : tree atype = NULL_TREE, id, keyworddecl;
14836 : 0 : tree param_attr = NULL_TREE;
14837 : 0 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
14838 : : break;
14839 : 0 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
14840 : : {
14841 : 0 : c_parser_consume_token (parser);
14842 : 0 : atype = c_parser_objc_type_name (parser);
14843 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
14844 : : "expected %<)%>");
14845 : : }
14846 : : /* New ObjC allows attributes on method parameters. */
14847 : 0 : if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
14848 : 0 : param_attr = c_parser_gnu_attributes (parser);
14849 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
14850 : : {
14851 : 0 : c_parser_error (parser, "expected identifier");
14852 : 0 : return error_mark_node;
14853 : : }
14854 : 0 : id = c_parser_peek_token (parser)->value;
14855 : 0 : c_parser_consume_token (parser);
14856 : 0 : keyworddecl = objc_build_keyword_decl (tsel, atype, id, param_attr);
14857 : 0 : list = chainon (list, keyworddecl);
14858 : 0 : tsel = c_parser_objc_selector (parser);
14859 : 0 : if (!tsel && c_parser_next_token_is_not (parser, CPP_COLON))
14860 : : break;
14861 : : }
14862 : :
14863 : 0 : attr_err |= c_parser_objc_maybe_method_attributes (parser, attributes) ;
14864 : :
14865 : : /* Parse the optional parameter list. Optional Objective-C
14866 : : method parameters follow the C syntax, and may include '...'
14867 : : to denote a variable number of arguments. */
14868 : 0 : parms = make_node (TREE_LIST);
14869 : 0 : while (c_parser_next_token_is (parser, CPP_COMMA))
14870 : : {
14871 : 0 : struct c_parm *parm;
14872 : 0 : c_parser_consume_token (parser);
14873 : 0 : if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
14874 : : {
14875 : 0 : ellipsis = true;
14876 : 0 : c_parser_consume_token (parser);
14877 : 0 : attr_err |= c_parser_objc_maybe_method_attributes
14878 : 0 : (parser, attributes) ;
14879 : 0 : break;
14880 : : }
14881 : 0 : parm = c_parser_parameter_declaration (parser, NULL_TREE, false);
14882 : 0 : if (parm == NULL)
14883 : : break;
14884 : 0 : parms = chainon (parms,
14885 : : build_tree_list (NULL_TREE, grokparm (parm, expr)));
14886 : : }
14887 : : sel = list;
14888 : : }
14889 : : else
14890 : 0 : attr_err |= c_parser_objc_maybe_method_attributes (parser, attributes) ;
14891 : :
14892 : 0 : if (sel == NULL)
14893 : : {
14894 : 0 : c_parser_error (parser, "objective-c method declaration is expected");
14895 : 0 : return error_mark_node;
14896 : : }
14897 : :
14898 : 0 : if (attr_err)
14899 : 0 : return error_mark_node;
14900 : :
14901 : 0 : return objc_build_method_signature (is_class_method, type, sel, parms, ellipsis);
14902 : : }
14903 : :
14904 : : /* Parse an objc-type-name.
14905 : :
14906 : : objc-type-name:
14907 : : objc-type-qualifiers[opt] type-name
14908 : : objc-type-qualifiers[opt]
14909 : :
14910 : : objc-type-qualifiers:
14911 : : objc-type-qualifier
14912 : : objc-type-qualifiers objc-type-qualifier
14913 : :
14914 : : objc-type-qualifier: one of
14915 : : in out inout bycopy byref oneway
14916 : : */
14917 : :
14918 : : static tree
14919 : 0 : c_parser_objc_type_name (c_parser *parser)
14920 : : {
14921 : 0 : tree quals = NULL_TREE;
14922 : 0 : struct c_type_name *type_name = NULL;
14923 : 0 : tree type = NULL_TREE;
14924 : 0 : while (true)
14925 : : {
14926 : 0 : c_token *token = c_parser_peek_token (parser);
14927 : 0 : if (token->type == CPP_KEYWORD
14928 : 0 : && (token->keyword == RID_IN
14929 : : || token->keyword == RID_OUT
14930 : : || token->keyword == RID_INOUT
14931 : : || token->keyword == RID_BYCOPY
14932 : : || token->keyword == RID_BYREF
14933 : 0 : || token->keyword == RID_ONEWAY))
14934 : : {
14935 : 0 : quals = chainon (build_tree_list (NULL_TREE, token->value), quals);
14936 : 0 : c_parser_consume_token (parser);
14937 : : }
14938 : : else
14939 : : break;
14940 : 0 : }
14941 : 0 : if (c_parser_next_tokens_start_typename (parser, cla_prefer_type))
14942 : 0 : type_name = c_parser_type_name (parser);
14943 : 0 : if (type_name)
14944 : 0 : type = groktypename (type_name, NULL, NULL);
14945 : :
14946 : : /* If the type is unknown, and error has already been produced and
14947 : : we need to recover from the error. In that case, use NULL_TREE
14948 : : for the type, as if no type had been specified; this will use the
14949 : : default type ('id') which is good for error recovery. */
14950 : 0 : if (type == error_mark_node)
14951 : 0 : type = NULL_TREE;
14952 : :
14953 : 0 : return build_tree_list (quals, type);
14954 : : }
14955 : :
14956 : : /* Parse objc-protocol-refs.
14957 : :
14958 : : objc-protocol-refs:
14959 : : < identifier-list >
14960 : : */
14961 : :
14962 : : static tree
14963 : 0 : c_parser_objc_protocol_refs (c_parser *parser)
14964 : : {
14965 : 0 : tree list = NULL_TREE;
14966 : 0 : gcc_assert (c_parser_next_token_is (parser, CPP_LESS));
14967 : 0 : c_parser_consume_token (parser);
14968 : : /* Any identifiers, including those declared as type names, are OK
14969 : : here. */
14970 : 0 : while (true)
14971 : : {
14972 : 0 : tree id;
14973 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
14974 : : {
14975 : 0 : c_parser_error (parser, "expected identifier");
14976 : 0 : break;
14977 : : }
14978 : 0 : id = c_parser_peek_token (parser)->value;
14979 : 0 : list = chainon (list, build_tree_list (NULL_TREE, id));
14980 : 0 : c_parser_consume_token (parser);
14981 : 0 : if (c_parser_next_token_is (parser, CPP_COMMA))
14982 : 0 : c_parser_consume_token (parser);
14983 : : else
14984 : : break;
14985 : 0 : }
14986 : 0 : c_parser_require (parser, CPP_GREATER, "expected %<>%>");
14987 : 0 : return list;
14988 : : }
14989 : :
14990 : : /* Parse an objc-try-catch-finally-statement.
14991 : :
14992 : : objc-try-catch-finally-statement:
14993 : : @try compound-statement objc-catch-list[opt]
14994 : : @try compound-statement objc-catch-list[opt] @finally compound-statement
14995 : :
14996 : : objc-catch-list:
14997 : : @catch ( objc-catch-parameter-declaration ) compound-statement
14998 : : objc-catch-list @catch ( objc-catch-parameter-declaration ) compound-statement
14999 : :
15000 : : objc-catch-parameter-declaration:
15001 : : parameter-declaration
15002 : : '...'
15003 : :
15004 : : where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
15005 : :
15006 : : PS: This function is identical to cp_parser_objc_try_catch_finally_statement
15007 : : for C++. Keep them in sync. */
15008 : :
15009 : : static void
15010 : 0 : c_parser_objc_try_catch_finally_statement (c_parser *parser)
15011 : : {
15012 : 0 : location_t location;
15013 : 0 : tree stmt;
15014 : :
15015 : 0 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_TRY));
15016 : 0 : c_parser_consume_token (parser);
15017 : 0 : location = c_parser_peek_token (parser)->location;
15018 : 0 : objc_maybe_warn_exceptions (location);
15019 : 0 : stmt = c_parser_compound_statement (parser);
15020 : 0 : objc_begin_try_stmt (location, stmt);
15021 : :
15022 : 0 : while (c_parser_next_token_is_keyword (parser, RID_AT_CATCH))
15023 : : {
15024 : 0 : struct c_parm *parm;
15025 : 0 : tree parameter_declaration = error_mark_node;
15026 : 0 : bool seen_open_paren = false;
15027 : :
15028 : 0 : c_parser_consume_token (parser);
15029 : 0 : matching_parens parens;
15030 : 0 : if (!parens.require_open (parser))
15031 : 0 : seen_open_paren = true;
15032 : 0 : if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
15033 : : {
15034 : : /* We have "@catch (...)" (where the '...' are literally
15035 : : what is in the code). Skip the '...'.
15036 : : parameter_declaration is set to NULL_TREE, and
15037 : : objc_being_catch_clauses() knows that that means
15038 : : '...'. */
15039 : 0 : c_parser_consume_token (parser);
15040 : 0 : parameter_declaration = NULL_TREE;
15041 : : }
15042 : : else
15043 : : {
15044 : : /* We have "@catch (NSException *exception)" or something
15045 : : like that. Parse the parameter declaration. */
15046 : 0 : parm = c_parser_parameter_declaration (parser, NULL_TREE, false);
15047 : 0 : if (parm == NULL)
15048 : 0 : parameter_declaration = error_mark_node;
15049 : : else
15050 : 0 : parameter_declaration = grokparm (parm, NULL);
15051 : : }
15052 : 0 : if (seen_open_paren)
15053 : 0 : parens.require_close (parser);
15054 : : else
15055 : : {
15056 : : /* If there was no open parenthesis, we are recovering from
15057 : : an error, and we are trying to figure out what mistake
15058 : : the user has made. */
15059 : :
15060 : : /* If there is an immediate closing parenthesis, the user
15061 : : probably forgot the opening one (ie, they typed "@catch
15062 : : NSException *e)". Parse the closing parenthesis and keep
15063 : : going. */
15064 : 0 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
15065 : 0 : c_parser_consume_token (parser);
15066 : :
15067 : : /* If these is no immediate closing parenthesis, the user
15068 : : probably doesn't know that parenthesis are required at
15069 : : all (ie, they typed "@catch NSException *e"). So, just
15070 : : forget about the closing parenthesis and keep going. */
15071 : : }
15072 : 0 : objc_begin_catch_clause (parameter_declaration);
15073 : 0 : if (c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
15074 : 0 : c_parser_compound_statement_nostart (parser);
15075 : 0 : objc_finish_catch_clause ();
15076 : : }
15077 : 0 : if (c_parser_next_token_is_keyword (parser, RID_AT_FINALLY))
15078 : : {
15079 : 0 : c_parser_consume_token (parser);
15080 : 0 : location = c_parser_peek_token (parser)->location;
15081 : 0 : stmt = c_parser_compound_statement (parser);
15082 : 0 : objc_build_finally_clause (location, stmt);
15083 : : }
15084 : 0 : objc_finish_try_stmt ();
15085 : 0 : }
15086 : :
15087 : : /* Parse an objc-synchronized-statement.
15088 : :
15089 : : objc-synchronized-statement:
15090 : : @synchronized ( expression ) compound-statement
15091 : : */
15092 : :
15093 : : static void
15094 : 0 : c_parser_objc_synchronized_statement (c_parser *parser)
15095 : : {
15096 : 0 : location_t loc;
15097 : 0 : tree expr, stmt;
15098 : 0 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_SYNCHRONIZED));
15099 : 0 : c_parser_consume_token (parser);
15100 : 0 : loc = c_parser_peek_token (parser)->location;
15101 : 0 : objc_maybe_warn_exceptions (loc);
15102 : 0 : matching_parens parens;
15103 : 0 : if (parens.require_open (parser))
15104 : : {
15105 : 0 : struct c_expr ce = c_parser_expression (parser);
15106 : 0 : ce = convert_lvalue_to_rvalue (loc, ce, false, false);
15107 : 0 : expr = ce.value;
15108 : 0 : expr = c_fully_fold (expr, false, NULL);
15109 : 0 : parens.skip_until_found_close (parser);
15110 : : }
15111 : : else
15112 : 0 : expr = error_mark_node;
15113 : 0 : stmt = c_parser_compound_statement (parser);
15114 : 0 : objc_build_synchronized (loc, expr, stmt);
15115 : 0 : }
15116 : :
15117 : : /* Parse an objc-selector; return NULL_TREE without an error if the
15118 : : next token is not an objc-selector.
15119 : :
15120 : : objc-selector:
15121 : : identifier
15122 : : one of
15123 : : enum struct union if else while do for switch case default
15124 : : break continue return goto asm sizeof typeof typeof_unqual __alignof
15125 : : unsigned long const short volatile signed restrict _Complex
15126 : : in out inout bycopy byref oneway int char float double void _Bool
15127 : : _Atomic
15128 : :
15129 : : ??? Why this selection of keywords but not, for example, storage
15130 : : class specifiers? */
15131 : :
15132 : : static tree
15133 : 0 : c_parser_objc_selector (c_parser *parser)
15134 : : {
15135 : 0 : c_token *token = c_parser_peek_token (parser);
15136 : 0 : tree value = token->value;
15137 : 0 : if (token->type == CPP_NAME)
15138 : : {
15139 : 0 : c_parser_consume_token (parser);
15140 : 0 : return value;
15141 : : }
15142 : 0 : if (token->type != CPP_KEYWORD)
15143 : : return NULL_TREE;
15144 : 0 : switch (token->keyword)
15145 : : {
15146 : 0 : case RID_ENUM:
15147 : 0 : case RID_STRUCT:
15148 : 0 : case RID_UNION:
15149 : 0 : case RID_IF:
15150 : 0 : case RID_ELSE:
15151 : 0 : case RID_WHILE:
15152 : 0 : case RID_DO:
15153 : 0 : case RID_FOR:
15154 : 0 : case RID_SWITCH:
15155 : 0 : case RID_CASE:
15156 : 0 : case RID_DEFAULT:
15157 : 0 : case RID_BREAK:
15158 : 0 : case RID_CONTINUE:
15159 : 0 : case RID_RETURN:
15160 : 0 : case RID_GOTO:
15161 : 0 : case RID_ASM:
15162 : 0 : case RID_SIZEOF:
15163 : 0 : case RID_TYPEOF:
15164 : 0 : case RID_TYPEOF_UNQUAL:
15165 : 0 : case RID_ALIGNOF:
15166 : 0 : case RID_UNSIGNED:
15167 : 0 : case RID_LONG:
15168 : 0 : case RID_CONST:
15169 : 0 : case RID_SHORT:
15170 : 0 : case RID_VOLATILE:
15171 : 0 : case RID_SIGNED:
15172 : 0 : case RID_RESTRICT:
15173 : 0 : case RID_COMPLEX:
15174 : 0 : case RID_IN:
15175 : 0 : case RID_OUT:
15176 : 0 : case RID_INOUT:
15177 : 0 : case RID_BYCOPY:
15178 : 0 : case RID_BYREF:
15179 : 0 : case RID_ONEWAY:
15180 : 0 : case RID_INT:
15181 : 0 : case RID_CHAR:
15182 : 0 : case RID_FLOAT:
15183 : 0 : case RID_DOUBLE:
15184 : 0 : CASE_RID_FLOATN_NX:
15185 : 0 : case RID_VOID:
15186 : 0 : case RID_BOOL:
15187 : 0 : case RID_ATOMIC:
15188 : 0 : case RID_AUTO_TYPE:
15189 : 0 : case RID_INT_N_0:
15190 : 0 : case RID_INT_N_1:
15191 : 0 : case RID_INT_N_2:
15192 : 0 : case RID_INT_N_3:
15193 : 0 : c_parser_consume_token (parser);
15194 : 0 : return value;
15195 : : default:
15196 : : return NULL_TREE;
15197 : : }
15198 : : }
15199 : :
15200 : : /* Parse an objc-selector-arg.
15201 : :
15202 : : objc-selector-arg:
15203 : : objc-selector
15204 : : objc-keywordname-list
15205 : :
15206 : : objc-keywordname-list:
15207 : : objc-keywordname
15208 : : objc-keywordname-list objc-keywordname
15209 : :
15210 : : objc-keywordname:
15211 : : objc-selector :
15212 : : :
15213 : : */
15214 : :
15215 : : static tree
15216 : 0 : c_parser_objc_selector_arg (c_parser *parser)
15217 : : {
15218 : 0 : tree sel = c_parser_objc_selector (parser);
15219 : 0 : tree list = NULL_TREE;
15220 : 0 : if (sel
15221 : 0 : && c_parser_next_token_is_not (parser, CPP_COLON)
15222 : 0 : && c_parser_next_token_is_not (parser, CPP_SCOPE))
15223 : : return sel;
15224 : 0 : while (true)
15225 : : {
15226 : 0 : if (c_parser_next_token_is (parser, CPP_SCOPE))
15227 : : {
15228 : 0 : c_parser_consume_token (parser);
15229 : 0 : list = chainon (list, build_tree_list (sel, NULL_TREE));
15230 : 0 : list = chainon (list, build_tree_list (NULL_TREE, NULL_TREE));
15231 : : }
15232 : : else
15233 : : {
15234 : 0 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
15235 : : return list;
15236 : 0 : list = chainon (list, build_tree_list (sel, NULL_TREE));
15237 : : }
15238 : 0 : sel = c_parser_objc_selector (parser);
15239 : 0 : if (!sel
15240 : 0 : && c_parser_next_token_is_not (parser, CPP_COLON)
15241 : 0 : && c_parser_next_token_is_not (parser, CPP_SCOPE))
15242 : : break;
15243 : : }
15244 : : return list;
15245 : : }
15246 : :
15247 : : /* Parse an objc-receiver.
15248 : :
15249 : : objc-receiver:
15250 : : expression
15251 : : class-name
15252 : : type-name
15253 : : */
15254 : :
15255 : : static tree
15256 : 0 : c_parser_objc_receiver (c_parser *parser)
15257 : : {
15258 : 0 : location_t loc = c_parser_peek_token (parser)->location;
15259 : :
15260 : 0 : if (c_parser_peek_token (parser)->type == CPP_NAME
15261 : 0 : && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
15262 : 0 : || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
15263 : : {
15264 : 0 : tree id = c_parser_peek_token (parser)->value;
15265 : 0 : c_parser_consume_token (parser);
15266 : 0 : return objc_get_class_reference (id);
15267 : : }
15268 : 0 : struct c_expr ce = c_parser_expression (parser);
15269 : 0 : ce = convert_lvalue_to_rvalue (loc, ce, false, false);
15270 : 0 : return c_fully_fold (ce.value, false, NULL);
15271 : : }
15272 : :
15273 : : /* Parse objc-message-args.
15274 : :
15275 : : objc-message-args:
15276 : : objc-selector
15277 : : objc-keywordarg-list
15278 : :
15279 : : objc-keywordarg-list:
15280 : : objc-keywordarg
15281 : : objc-keywordarg-list objc-keywordarg
15282 : :
15283 : : objc-keywordarg:
15284 : : objc-selector : objc-keywordexpr
15285 : : : objc-keywordexpr
15286 : : */
15287 : :
15288 : : static tree
15289 : 0 : c_parser_objc_message_args (c_parser *parser)
15290 : : {
15291 : 0 : tree sel = c_parser_objc_selector (parser);
15292 : 0 : tree list = NULL_TREE;
15293 : 0 : if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
15294 : : return sel;
15295 : 0 : while (true)
15296 : : {
15297 : 0 : tree keywordexpr;
15298 : 0 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
15299 : 0 : return error_mark_node;
15300 : 0 : keywordexpr = c_parser_objc_keywordexpr (parser);
15301 : 0 : list = chainon (list, build_tree_list (sel, keywordexpr));
15302 : 0 : sel = c_parser_objc_selector (parser);
15303 : 0 : if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
15304 : : break;
15305 : : }
15306 : : return list;
15307 : : }
15308 : :
15309 : : /* Parse an objc-keywordexpr.
15310 : :
15311 : : objc-keywordexpr:
15312 : : nonempty-expr-list
15313 : : */
15314 : :
15315 : : static tree
15316 : 0 : c_parser_objc_keywordexpr (c_parser *parser)
15317 : : {
15318 : 0 : tree ret;
15319 : 0 : vec<tree, va_gc> *expr_list = c_parser_expr_list (parser, true, true,
15320 : : NULL, NULL, NULL, NULL);
15321 : 0 : if (vec_safe_length (expr_list) == 1)
15322 : : {
15323 : : /* Just return the expression, remove a level of
15324 : : indirection. */
15325 : 0 : ret = (*expr_list)[0];
15326 : : }
15327 : : else
15328 : : {
15329 : : /* We have a comma expression, we will collapse later. */
15330 : 0 : ret = build_tree_list_vec (expr_list);
15331 : : }
15332 : 0 : release_tree_vector (expr_list);
15333 : 0 : return ret;
15334 : : }
15335 : :
15336 : : /* A check, needed in several places, that ObjC interface, implementation or
15337 : : method definitions are not prefixed by incorrect items. */
15338 : : static bool
15339 : 0 : c_parser_objc_diagnose_bad_element_prefix (c_parser *parser,
15340 : : struct c_declspecs *specs)
15341 : : {
15342 : 0 : if (!specs->declspecs_seen_p || specs->non_sc_seen_p
15343 : 0 : || specs->typespec_kind != ctsk_none)
15344 : : {
15345 : 0 : c_parser_error (parser,
15346 : : "no type or storage class may be specified here,");
15347 : 0 : c_parser_skip_to_end_of_block_or_statement (parser);
15348 : 0 : return true;
15349 : : }
15350 : : return false;
15351 : : }
15352 : :
15353 : : /* Parse an Objective-C @property declaration. The syntax is:
15354 : :
15355 : : objc-property-declaration:
15356 : : '@property' objc-property-attributes[opt] struct-declaration ;
15357 : :
15358 : : objc-property-attributes:
15359 : : '(' objc-property-attribute-list ')'
15360 : :
15361 : : objc-property-attribute-list:
15362 : : objc-property-attribute
15363 : : objc-property-attribute-list, objc-property-attribute
15364 : :
15365 : : objc-property-attribute
15366 : : 'getter' = identifier
15367 : : 'setter' = identifier
15368 : : 'readonly'
15369 : : 'readwrite'
15370 : : 'assign'
15371 : : 'retain'
15372 : : 'copy'
15373 : : 'nonatomic'
15374 : :
15375 : : For example:
15376 : : @property NSString *name;
15377 : : @property (readonly) id object;
15378 : : @property (retain, nonatomic, getter=getTheName) id name;
15379 : : @property int a, b, c;
15380 : :
15381 : : PS: This function is identical to cp_parser_objc_at_propery_declaration
15382 : : for C++. Keep them in sync. */
15383 : : static void
15384 : 0 : c_parser_objc_at_property_declaration (c_parser *parser)
15385 : : {
15386 : 0 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_PROPERTY));
15387 : 0 : location_t loc = c_parser_peek_token (parser)->location;
15388 : 0 : c_parser_consume_token (parser); /* Eat '@property'. */
15389 : :
15390 : : /* Parse the optional attribute list.
15391 : :
15392 : : A list of parsed, but not verified, attributes. */
15393 : 0 : vec<property_attribute_info *> prop_attr_list = vNULL;
15394 : :
15395 : 0 : bool syntax_error = false;
15396 : 0 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
15397 : : {
15398 : 0 : matching_parens parens;
15399 : :
15400 : 0 : location_t attr_start = c_parser_peek_token (parser)->location;
15401 : : /* Eat the '(' */
15402 : 0 : parens.consume_open (parser);
15403 : :
15404 : : /* Property attribute keywords are valid now. */
15405 : 0 : parser->objc_property_attr_context = true;
15406 : :
15407 : : /* Allow @property (), with a warning. */
15408 : 0 : location_t attr_end = c_parser_peek_token (parser)->location;
15409 : :
15410 : 0 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
15411 : : {
15412 : 0 : location_t attr_comb = make_location (attr_end, attr_start, attr_end);
15413 : 0 : warning_at (attr_comb, OPT_Wattributes,
15414 : : "empty property attribute list");
15415 : : }
15416 : : else
15417 : 0 : while (true)
15418 : : {
15419 : 0 : c_token *token = c_parser_peek_token (parser);
15420 : 0 : attr_start = token->location;
15421 : 0 : attr_end = get_finish (token->location);
15422 : 0 : location_t attr_comb = make_location (attr_start, attr_start,
15423 : : attr_end);
15424 : :
15425 : 0 : if (token->type == CPP_CLOSE_PAREN || token->type == CPP_COMMA)
15426 : : {
15427 : 0 : warning_at (attr_comb, OPT_Wattributes,
15428 : : "missing property attribute");
15429 : 0 : if (token->type == CPP_CLOSE_PAREN)
15430 : : break;
15431 : 0 : c_parser_consume_token (parser);
15432 : 0 : continue;
15433 : : }
15434 : :
15435 : 0 : tree attr_name = NULL_TREE;
15436 : 0 : enum rid keyword = RID_MAX; /* Not a valid property attribute. */
15437 : 0 : bool add_at = false;
15438 : 0 : if (token->type == CPP_KEYWORD)
15439 : : {
15440 : 0 : keyword = token->keyword;
15441 : 0 : if (OBJC_IS_AT_KEYWORD (keyword))
15442 : : {
15443 : : /* For '@' keywords the token value has the keyword,
15444 : : prepend the '@' for diagnostics. */
15445 : 0 : attr_name = token->value;
15446 : 0 : add_at = true;
15447 : : }
15448 : : else
15449 : 0 : attr_name = ridpointers[(int)keyword];
15450 : : }
15451 : 0 : else if (token->type == CPP_NAME)
15452 : 0 : attr_name = token->value;
15453 : 0 : c_parser_consume_token (parser);
15454 : :
15455 : 0 : enum objc_property_attribute_kind prop_kind
15456 : 0 : = objc_prop_attr_kind_for_rid (keyword);
15457 : 0 : property_attribute_info *prop
15458 : 0 : = new property_attribute_info (attr_name, attr_comb, prop_kind);
15459 : 0 : prop_attr_list.safe_push (prop);
15460 : :
15461 : 0 : tree meth_name;
15462 : 0 : switch (prop->prop_kind)
15463 : : {
15464 : : default: break;
15465 : 0 : case OBJC_PROPERTY_ATTR_UNKNOWN:
15466 : 0 : if (attr_name)
15467 : 0 : error_at (attr_comb, "unknown property attribute %<%s%s%>",
15468 : 0 : add_at ? "@" : "", IDENTIFIER_POINTER (attr_name));
15469 : : else
15470 : 0 : error_at (attr_comb, "unknown property attribute");
15471 : 0 : prop->parse_error = syntax_error = true;
15472 : 0 : break;
15473 : :
15474 : 0 : case OBJC_PROPERTY_ATTR_GETTER:
15475 : 0 : case OBJC_PROPERTY_ATTR_SETTER:
15476 : 0 : if (c_parser_next_token_is_not (parser, CPP_EQ))
15477 : : {
15478 : 0 : attr_comb = make_location (attr_end, attr_start, attr_end);
15479 : 0 : error_at (attr_comb, "expected %<=%> after Objective-C %qE",
15480 : : attr_name);
15481 : 0 : prop->parse_error = syntax_error = true;
15482 : 0 : break;
15483 : : }
15484 : 0 : token = c_parser_peek_token (parser);
15485 : 0 : attr_end = token->location;
15486 : 0 : c_parser_consume_token (parser); /* eat the = */
15487 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
15488 : : {
15489 : 0 : attr_comb = make_location (attr_end, attr_start, attr_end);
15490 : 0 : error_at (attr_comb, "expected %qE selector name",
15491 : : attr_name);
15492 : 0 : prop->parse_error = syntax_error = true;
15493 : 0 : break;
15494 : : }
15495 : : /* Get the end of the method name, and consume the name. */
15496 : 0 : token = c_parser_peek_token (parser);
15497 : 0 : attr_end = get_finish (token->location);
15498 : 0 : meth_name = token->value;
15499 : 0 : c_parser_consume_token (parser);
15500 : 0 : if (prop->prop_kind == OBJC_PROPERTY_ATTR_SETTER)
15501 : : {
15502 : 0 : if (c_parser_next_token_is_not (parser, CPP_COLON))
15503 : : {
15504 : 0 : attr_comb = make_location (attr_end, attr_start,
15505 : : attr_end);
15506 : 0 : error_at (attr_comb, "setter method names must"
15507 : : " terminate with %<:%>");
15508 : 0 : prop->parse_error = syntax_error = true;
15509 : : }
15510 : : else
15511 : : {
15512 : 0 : attr_end = get_finish (c_parser_peek_token
15513 : 0 : (parser)->location);
15514 : 0 : c_parser_consume_token (parser);
15515 : : }
15516 : 0 : attr_comb = make_location (attr_start, attr_start,
15517 : : attr_end);
15518 : : }
15519 : : else
15520 : 0 : attr_comb = make_location (attr_start, attr_start,
15521 : : attr_end);
15522 : 0 : prop->ident = meth_name;
15523 : : /* Updated location including all that was successfully
15524 : : parsed. */
15525 : 0 : prop->prop_loc = attr_comb;
15526 : 0 : break;
15527 : : }
15528 : :
15529 : : /* If we see a comma here, then keep going - even if we already
15530 : : saw a syntax error. For simple mistakes e.g. (asign, getter=x)
15531 : : this makes a more useful output and avoid spurious warnings about
15532 : : missing attributes that are, in fact, specified after the one with
15533 : : the syntax error. */
15534 : 0 : if (c_parser_next_token_is (parser, CPP_COMMA))
15535 : 0 : c_parser_consume_token (parser);
15536 : : else
15537 : : break;
15538 : : }
15539 : 0 : parser->objc_property_attr_context = false;
15540 : :
15541 : 0 : if (syntax_error && c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
15542 : : /* We don't really want to chew the whole of the file looking for a
15543 : : matching closing parenthesis, so we will try to read the decl and
15544 : : let the error handling for that close out the statement. */
15545 : : ;
15546 : : else
15547 : 0 : syntax_error = false, parens.skip_until_found_close (parser);
15548 : : }
15549 : :
15550 : : /* 'properties' is the list of properties that we read. Usually a
15551 : : single one, but maybe more (eg, in "@property int a, b, c;" there
15552 : : are three). */
15553 : 0 : tree properties = c_parser_struct_declaration (parser, NULL);
15554 : :
15555 : 0 : if (properties == error_mark_node)
15556 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
15557 : : else
15558 : : {
15559 : 0 : if (properties == NULL_TREE)
15560 : 0 : c_parser_error (parser, "expected identifier");
15561 : : else
15562 : : {
15563 : : /* Comma-separated properties are chained together in reverse order;
15564 : : add them one by one. */
15565 : 0 : properties = nreverse (properties);
15566 : 0 : for (; properties; properties = TREE_CHAIN (properties))
15567 : 0 : objc_add_property_declaration (loc, copy_node (properties),
15568 : : prop_attr_list);
15569 : : }
15570 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
15571 : : }
15572 : :
15573 : 0 : while (!prop_attr_list.is_empty())
15574 : 0 : delete prop_attr_list.pop ();
15575 : 0 : prop_attr_list.release ();
15576 : 0 : parser->error = false;
15577 : 0 : }
15578 : :
15579 : : /* Parse an Objective-C @synthesize declaration. The syntax is:
15580 : :
15581 : : objc-synthesize-declaration:
15582 : : @synthesize objc-synthesize-identifier-list ;
15583 : :
15584 : : objc-synthesize-identifier-list:
15585 : : objc-synthesize-identifier
15586 : : objc-synthesize-identifier-list, objc-synthesize-identifier
15587 : :
15588 : : objc-synthesize-identifier
15589 : : identifier
15590 : : identifier = identifier
15591 : :
15592 : : For example:
15593 : : @synthesize MyProperty;
15594 : : @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
15595 : :
15596 : : PS: This function is identical to cp_parser_objc_at_synthesize_declaration
15597 : : for C++. Keep them in sync.
15598 : : */
15599 : : static void
15600 : 0 : c_parser_objc_at_synthesize_declaration (c_parser *parser)
15601 : : {
15602 : 0 : tree list = NULL_TREE;
15603 : 0 : location_t loc;
15604 : 0 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_SYNTHESIZE));
15605 : 0 : loc = c_parser_peek_token (parser)->location;
15606 : :
15607 : 0 : c_parser_consume_token (parser);
15608 : 0 : while (true)
15609 : : {
15610 : 0 : tree property, ivar;
15611 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
15612 : : {
15613 : 0 : c_parser_error (parser, "expected identifier");
15614 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
15615 : : /* Once we find the semicolon, we can resume normal parsing.
15616 : : We have to reset parser->error manually because
15617 : : c_parser_skip_until_found() won't reset it for us if the
15618 : : next token is precisely a semicolon. */
15619 : 0 : parser->error = false;
15620 : 0 : return;
15621 : : }
15622 : 0 : property = c_parser_peek_token (parser)->value;
15623 : 0 : c_parser_consume_token (parser);
15624 : 0 : if (c_parser_next_token_is (parser, CPP_EQ))
15625 : : {
15626 : 0 : c_parser_consume_token (parser);
15627 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
15628 : : {
15629 : 0 : c_parser_error (parser, "expected identifier");
15630 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
15631 : 0 : parser->error = false;
15632 : 0 : return;
15633 : : }
15634 : 0 : ivar = c_parser_peek_token (parser)->value;
15635 : 0 : c_parser_consume_token (parser);
15636 : : }
15637 : : else
15638 : : ivar = NULL_TREE;
15639 : 0 : list = chainon (list, build_tree_list (ivar, property));
15640 : 0 : if (c_parser_next_token_is (parser, CPP_COMMA))
15641 : 0 : c_parser_consume_token (parser);
15642 : : else
15643 : : break;
15644 : 0 : }
15645 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
15646 : 0 : objc_add_synthesize_declaration (loc, list);
15647 : : }
15648 : :
15649 : : /* Parse an Objective-C @dynamic declaration. The syntax is:
15650 : :
15651 : : objc-dynamic-declaration:
15652 : : @dynamic identifier-list ;
15653 : :
15654 : : For example:
15655 : : @dynamic MyProperty;
15656 : : @dynamic MyProperty, AnotherProperty;
15657 : :
15658 : : PS: This function is identical to cp_parser_objc_at_dynamic_declaration
15659 : : for C++. Keep them in sync.
15660 : : */
15661 : : static void
15662 : 0 : c_parser_objc_at_dynamic_declaration (c_parser *parser)
15663 : : {
15664 : 0 : tree list = NULL_TREE;
15665 : 0 : location_t loc;
15666 : 0 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_DYNAMIC));
15667 : 0 : loc = c_parser_peek_token (parser)->location;
15668 : :
15669 : 0 : c_parser_consume_token (parser);
15670 : 0 : while (true)
15671 : : {
15672 : 0 : tree property;
15673 : 0 : if (c_parser_next_token_is_not (parser, CPP_NAME))
15674 : : {
15675 : 0 : c_parser_error (parser, "expected identifier");
15676 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
15677 : 0 : parser->error = false;
15678 : 0 : return;
15679 : : }
15680 : 0 : property = c_parser_peek_token (parser)->value;
15681 : 0 : list = chainon (list, build_tree_list (NULL_TREE, property));
15682 : 0 : c_parser_consume_token (parser);
15683 : 0 : if (c_parser_next_token_is (parser, CPP_COMMA))
15684 : 0 : c_parser_consume_token (parser);
15685 : : else
15686 : : break;
15687 : 0 : }
15688 : 0 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
15689 : 0 : objc_add_dynamic_declaration (loc, list);
15690 : : }
15691 : :
15692 : :
15693 : : /* Parse a pragma GCC ivdep. */
15694 : :
15695 : : static bool
15696 : 128 : c_parse_pragma_ivdep (c_parser *parser)
15697 : : {
15698 : 0 : c_parser_consume_pragma (parser);
15699 : 0 : c_parser_skip_to_pragma_eol (parser);
15700 : 128 : return true;
15701 : : }
15702 : :
15703 : : /* Parse a pragma GCC novector. */
15704 : :
15705 : : static bool
15706 : 2628 : c_parse_pragma_novector (c_parser *parser)
15707 : : {
15708 : 0 : c_parser_consume_pragma (parser);
15709 : 0 : c_parser_skip_to_pragma_eol (parser);
15710 : 2628 : return true;
15711 : : }
15712 : :
15713 : : /* Parse a pragma GCC unroll. */
15714 : :
15715 : : static unsigned short
15716 : 277 : c_parser_pragma_unroll (c_parser *parser)
15717 : : {
15718 : 277 : unsigned short unroll;
15719 : 277 : c_parser_consume_pragma (parser);
15720 : 277 : location_t location = c_parser_peek_token (parser)->location;
15721 : 277 : tree expr = c_parser_expr_no_commas (parser, NULL).value;
15722 : 277 : mark_exp_read (expr);
15723 : 277 : expr = c_fully_fold (expr, false, NULL);
15724 : 277 : HOST_WIDE_INT lunroll = 0;
15725 : 554 : if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
15726 : 276 : || TREE_CODE (expr) != INTEGER_CST
15727 : 275 : || (lunroll = tree_to_shwi (expr)) < 0
15728 : 551 : || lunroll >= USHRT_MAX)
15729 : : {
15730 : 4 : error_at (location, "%<#pragma GCC unroll%> requires an"
15731 : : " assignment-expression that evaluates to a non-negative"
15732 : : " integral constant less than %u", USHRT_MAX);
15733 : 4 : unroll = 0;
15734 : : }
15735 : : else
15736 : : {
15737 : 273 : unroll = (unsigned short)lunroll;
15738 : 273 : if (unroll == 0)
15739 : : unroll = 1;
15740 : : }
15741 : :
15742 : 277 : c_parser_skip_to_pragma_eol (parser);
15743 : 277 : return unroll;
15744 : : }
15745 : :
15746 : : /* Handle pragmas. Some OpenMP pragmas are associated with, and therefore
15747 : : should be considered, statements. ALLOW_STMT is true if we're within
15748 : : the context of a function and such pragmas are to be allowed. Returns
15749 : : true if we actually parsed such a pragma. BEFORE_LABELS is last statement
15750 : : before possible labels, see get_before_labels description for details. */
15751 : :
15752 : : static bool
15753 : 1948373 : c_parser_pragma (c_parser *parser, enum pragma_context context, bool *if_p,
15754 : : tree before_labels)
15755 : : {
15756 : 1948373 : unsigned int id;
15757 : 1948373 : const char *construct = NULL;
15758 : :
15759 : 1948373 : input_location = c_parser_peek_token (parser)->location;
15760 : 1948373 : id = c_parser_peek_token (parser)->pragma_kind;
15761 : 1948373 : gcc_assert (id != PRAGMA_NONE);
15762 : 1948373 : if (parser->omp_for_parse_state
15763 : 12 : && parser->omp_for_parse_state->in_intervening_code
15764 : : && id >= PRAGMA_OMP__START_
15765 : 9 : && id <= PRAGMA_OMP__LAST_)
15766 : : {
15767 : 3 : error_at (input_location,
15768 : : "intervening code must not contain OpenMP directives");
15769 : 3 : parser->omp_for_parse_state->fail = true;
15770 : 3 : c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
15771 : 3 : return false;
15772 : : }
15773 : :
15774 : 1948370 : switch (id)
15775 : : {
15776 : 144 : case PRAGMA_OACC_DECLARE:
15777 : 144 : c_parser_oacc_declare (parser);
15778 : 144 : return false;
15779 : :
15780 : 136 : case PRAGMA_OACC_ENTER_DATA:
15781 : 136 : if (context != pragma_compound)
15782 : : {
15783 : : construct = "acc enter data";
15784 : 62 : in_compound:
15785 : 62 : if (context == pragma_stmt)
15786 : : {
15787 : 59 : error_at (c_parser_peek_token (parser)->location,
15788 : : "%<#pragma %s%> may only be used in compound "
15789 : : "statements", construct);
15790 : 59 : c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
15791 : 59 : return true;
15792 : : }
15793 : 3 : goto bad_stmt;
15794 : : }
15795 : 133 : c_parser_oacc_enter_exit_data (parser, true);
15796 : 133 : return false;
15797 : :
15798 : 131 : case PRAGMA_OACC_EXIT_DATA:
15799 : 131 : if (context != pragma_compound)
15800 : : {
15801 : 3 : construct = "acc exit data";
15802 : 3 : goto in_compound;
15803 : : }
15804 : 128 : c_parser_oacc_enter_exit_data (parser, false);
15805 : 128 : return false;
15806 : :
15807 : 350 : case PRAGMA_OACC_ROUTINE:
15808 : 350 : if (context != pragma_external)
15809 : : {
15810 : 5 : error_at (c_parser_peek_token (parser)->location,
15811 : : "%<#pragma acc routine%> must be at file scope");
15812 : 5 : c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
15813 : 5 : return false;
15814 : : }
15815 : 345 : c_parser_oacc_routine (parser, context);
15816 : 345 : return false;
15817 : :
15818 : 100 : case PRAGMA_OACC_UPDATE:
15819 : 100 : if (context != pragma_compound)
15820 : : {
15821 : 8 : construct = "acc update";
15822 : 8 : goto in_compound;
15823 : : }
15824 : 92 : c_parser_oacc_update (parser);
15825 : 92 : return false;
15826 : :
15827 : 359 : case PRAGMA_OMP_BARRIER:
15828 : 359 : if (context != pragma_compound)
15829 : : {
15830 : 11 : construct = "omp barrier";
15831 : 11 : goto in_compound;
15832 : : }
15833 : 348 : c_parser_omp_barrier (parser);
15834 : 348 : return false;
15835 : :
15836 : 76 : case PRAGMA_OMP_DEPOBJ:
15837 : 76 : if (context != pragma_compound)
15838 : : {
15839 : 1 : construct = "omp depobj";
15840 : 1 : goto in_compound;
15841 : : }
15842 : 75 : c_parser_omp_depobj (parser);
15843 : 75 : return false;
15844 : :
15845 : 70 : case PRAGMA_OMP_FLUSH:
15846 : 70 : if (context != pragma_compound)
15847 : : {
15848 : 9 : construct = "omp flush";
15849 : 9 : goto in_compound;
15850 : : }
15851 : 61 : c_parser_omp_flush (parser);
15852 : 61 : return false;
15853 : :
15854 : 183 : case PRAGMA_OMP_INTEROP:
15855 : 183 : if (context != pragma_compound)
15856 : : {
15857 : 0 : construct = "omp interop";
15858 : 0 : goto in_compound;
15859 : : }
15860 : 183 : c_parser_omp_interop (parser);
15861 : 183 : return false;
15862 : :
15863 : 101 : case PRAGMA_OMP_TASKWAIT:
15864 : 101 : if (context != pragma_compound)
15865 : : {
15866 : 8 : construct = "omp taskwait";
15867 : 8 : goto in_compound;
15868 : : }
15869 : 93 : c_parser_omp_taskwait (parser);
15870 : 93 : return false;
15871 : :
15872 : 14 : case PRAGMA_OMP_TASKYIELD:
15873 : 14 : if (context != pragma_compound)
15874 : : {
15875 : 8 : construct = "omp taskyield";
15876 : 8 : goto in_compound;
15877 : : }
15878 : 6 : c_parser_omp_taskyield (parser);
15879 : 6 : return false;
15880 : :
15881 : 221 : case PRAGMA_OMP_CANCEL:
15882 : 221 : if (context != pragma_compound)
15883 : : {
15884 : 8 : construct = "omp cancel";
15885 : 8 : goto in_compound;
15886 : : }
15887 : 213 : c_parser_omp_cancel (parser);
15888 : 213 : return false;
15889 : :
15890 : 179 : case PRAGMA_OMP_CANCELLATION_POINT:
15891 : 179 : return c_parser_omp_cancellation_point (parser, context);
15892 : :
15893 : 78 : case PRAGMA_OMP_THREADPRIVATE:
15894 : 78 : c_parser_omp_threadprivate (parser);
15895 : 78 : return false;
15896 : :
15897 : 7395 : case PRAGMA_OMP_TARGET:
15898 : 7395 : return c_parser_omp_target (parser, context, if_p);
15899 : :
15900 : 91 : case PRAGMA_OMP_BEGIN:
15901 : 91 : c_parser_omp_begin (parser);
15902 : 91 : return false;
15903 : :
15904 : 199 : case PRAGMA_OMP_END:
15905 : 199 : c_parser_omp_end (parser);
15906 : 199 : return false;
15907 : :
15908 : 22 : case PRAGMA_OMP_SCAN:
15909 : 22 : error_at (c_parser_peek_token (parser)->location,
15910 : : "%<#pragma omp scan%> may only be used in "
15911 : : "a loop construct with %<inscan%> %<reduction%> clause");
15912 : 22 : c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
15913 : 22 : return false;
15914 : :
15915 : 5 : case PRAGMA_OMP_SECTION:
15916 : 5 : error_at (c_parser_peek_token (parser)->location,
15917 : : "%<#pragma omp section%> may only be used in "
15918 : : "%<#pragma omp sections%> construct");
15919 : 5 : c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
15920 : 5 : return false;
15921 : :
15922 : 1206 : case PRAGMA_OMP_DECLARE:
15923 : 1206 : return c_parser_omp_declare (parser, context);
15924 : :
15925 : 70 : case PRAGMA_OMP_REQUIRES:
15926 : 70 : if (context != pragma_external)
15927 : : {
15928 : 8 : error_at (c_parser_peek_token (parser)->location,
15929 : : "%<#pragma %s%> may only be used at file scope",
15930 : : "omp requires");
15931 : 8 : c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
15932 : 8 : return false;
15933 : : }
15934 : 62 : c_parser_omp_requires (parser);
15935 : 62 : return false;
15936 : :
15937 : 69 : case PRAGMA_OMP_ALLOCATE:
15938 : 69 : c_parser_omp_allocate (parser);
15939 : 69 : return false;
15940 : :
15941 : 38 : case PRAGMA_OMP_ASSUMES:
15942 : 38 : if (context != pragma_external)
15943 : : {
15944 : 1 : error_at (c_parser_peek_token (parser)->location,
15945 : : "%<#pragma %s%> may only be used at file scope",
15946 : : "omp assumes");
15947 : 1 : c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
15948 : 1 : return false;
15949 : : }
15950 : 37 : c_parser_omp_assumes (parser);
15951 : 37 : return false;
15952 : :
15953 : 79 : case PRAGMA_OMP_NOTHING:
15954 : 79 : c_parser_omp_nothing (parser);
15955 : 79 : return false;
15956 : :
15957 : 108 : case PRAGMA_OMP_METADIRECTIVE:
15958 : 108 : c_parser_omp_metadirective (parser, if_p);
15959 : 108 : return true;
15960 : :
15961 : 124 : case PRAGMA_OMP_ERROR:
15962 : 124 : return c_parser_omp_error (parser, context);
15963 : :
15964 : 543 : case PRAGMA_OMP_ORDERED:
15965 : 543 : return c_parser_omp_ordered (parser, context, if_p);
15966 : :
15967 : 3017 : case PRAGMA_NOVECTOR:
15968 : 3017 : case PRAGMA_UNROLL:
15969 : 3017 : case PRAGMA_IVDEP:
15970 : 3017 : {
15971 : 3017 : bool novector = false;
15972 : 3017 : unsigned short unroll = 0;
15973 : 3017 : bool ivdep = false;
15974 : :
15975 : 3017 : switch (id)
15976 : : {
15977 : 2624 : case PRAGMA_NOVECTOR:
15978 : 2624 : novector = c_parse_pragma_novector (parser);
15979 : 2624 : break;
15980 : 268 : case PRAGMA_UNROLL:
15981 : 268 : unroll = c_parser_pragma_unroll (parser);
15982 : 268 : break;
15983 : 125 : case PRAGMA_IVDEP:
15984 : 125 : ivdep = c_parse_pragma_ivdep (parser);
15985 : 125 : break;
15986 : : default:
15987 : : gcc_unreachable ();
15988 : : }
15989 : :
15990 : 3017 : c_token *tok = c_parser_peek_token (parser);
15991 : 3017 : bool has_more = tok->type == CPP_PRAGMA;
15992 : 3033 : while (has_more)
15993 : : {
15994 : 16 : switch (tok->pragma_kind)
15995 : : {
15996 : 3 : case PRAGMA_IVDEP:
15997 : 3 : ivdep = c_parse_pragma_ivdep (parser);
15998 : 3 : break;
15999 : 9 : case PRAGMA_UNROLL:
16000 : 9 : unroll = c_parser_pragma_unroll (parser);
16001 : 9 : break;
16002 : 4 : case PRAGMA_NOVECTOR:
16003 : 4 : novector = c_parse_pragma_novector (parser);
16004 : 4 : break;
16005 : : default:
16006 : : has_more = false;
16007 : : break;
16008 : : }
16009 : 16 : tok = c_parser_peek_token (parser);
16010 : 16 : has_more = has_more && tok->type == CPP_PRAGMA;
16011 : : }
16012 : 3017 : if (!c_parser_next_token_is_keyword (parser, RID_FOR)
16013 : 74 : && !c_parser_next_token_is_keyword (parser, RID_WHILE)
16014 : 3076 : && !c_parser_next_token_is_keyword (parser, RID_DO))
16015 : : {
16016 : 0 : c_parser_error (parser, "for, while or do statement expected");
16017 : 0 : return false;
16018 : : }
16019 : 3017 : if (c_parser_next_token_is_keyword (parser, RID_FOR))
16020 : 2943 : c_parser_for_statement (parser, ivdep, unroll, novector, if_p,
16021 : : before_labels);
16022 : 74 : else if (c_parser_next_token_is_keyword (parser, RID_WHILE))
16023 : 15 : c_parser_while_statement (parser, ivdep, unroll, novector, if_p,
16024 : : before_labels);
16025 : : else
16026 : 59 : c_parser_do_statement (parser, ivdep, unroll, novector,
16027 : : before_labels);
16028 : : }
16029 : : return true;
16030 : :
16031 : 1 : case PRAGMA_GCC_PCH_PREPROCESS:
16032 : 1 : c_parser_error (parser, "%<#pragma GCC pch_preprocess%> must be first");
16033 : 1 : c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
16034 : 1 : return false;
16035 : :
16036 : 89 : case PRAGMA_OACC_WAIT:
16037 : 89 : if (context != pragma_compound)
16038 : : {
16039 : 3 : construct = "acc wait";
16040 : 3 : goto in_compound;
16041 : : }
16042 : : /* FALL THROUGH. */
16043 : :
16044 : 1933258 : default:
16045 : 1933258 : if (id < PRAGMA_FIRST_EXTERNAL)
16046 : : {
16047 : 17232 : if (context != pragma_stmt && context != pragma_compound)
16048 : : {
16049 : 2 : bad_stmt:
16050 : 5 : c_parser_error (parser, "expected declaration specifiers");
16051 : 5 : c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
16052 : 5 : return false;
16053 : : }
16054 : 17230 : c_parser_omp_construct (parser, if_p);
16055 : 17230 : return true;
16056 : : }
16057 : 1916026 : break;
16058 : : }
16059 : :
16060 : 1916026 : c_parser_consume_pragma (parser);
16061 : 1916026 : c_invoke_pragma_handler (id);
16062 : :
16063 : : /* Skip to EOL, but suppress any error message. Those will have been
16064 : : generated by the handler routine through calling error, as opposed
16065 : : to calling c_parser_error. */
16066 : 1916026 : parser->error = true;
16067 : 1916026 : c_parser_skip_to_pragma_eol (parser);
16068 : :
16069 : 1916026 : return false;
16070 : : }
16071 : :
16072 : : /* The interface the pragma parsers have to the lexer. */
16073 : :
16074 : : enum cpp_ttype
16075 : 3628305 : pragma_lex (tree *value, location_t *loc)
16076 : : {
16077 : 3628305 : c_token *tok = c_parser_peek_token (the_parser);
16078 : 3628305 : enum cpp_ttype ret = tok->type;
16079 : :
16080 : 3628305 : *value = tok->value;
16081 : 3628305 : if (loc)
16082 : 1507851 : *loc = tok->location;
16083 : :
16084 : 3628305 : if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF)
16085 : : ret = CPP_EOF;
16086 : 2041191 : else if (ret == CPP_STRING)
16087 : 641536 : *value = c_parser_string_literal (the_parser, false, false).value;
16088 : : else
16089 : : {
16090 : 1399655 : if (ret == CPP_KEYWORD)
16091 : 344 : ret = CPP_NAME;
16092 : 1399655 : c_parser_consume_token (the_parser);
16093 : : }
16094 : :
16095 : 3628305 : return ret;
16096 : : }
16097 : :
16098 : : void
16099 : 9508 : pragma_lex_discard_to_eol ()
16100 : : {
16101 : 9508 : cpp_ttype type;
16102 : 9508 : do
16103 : : {
16104 : 9508 : type = c_parser_peek_token (the_parser)->type;
16105 : 9508 : gcc_assert (type != CPP_EOF);
16106 : 9508 : c_parser_consume_token (the_parser);
16107 : 9508 : } while (type != CPP_PRAGMA_EOL);
16108 : 9508 : }
16109 : :
16110 : : static void
16111 : 12 : c_parser_pragma_pch_preprocess (c_parser *parser)
16112 : : {
16113 : 12 : tree name = NULL;
16114 : :
16115 : 12 : parser->lex_joined_string = true;
16116 : 12 : c_parser_consume_pragma (parser);
16117 : 12 : if (c_parser_next_token_is (parser, CPP_STRING))
16118 : : {
16119 : 12 : name = c_parser_peek_token (parser)->value;
16120 : 12 : c_parser_consume_token (parser);
16121 : : }
16122 : : else
16123 : 0 : c_parser_error (parser, "expected string literal");
16124 : 12 : c_parser_skip_to_pragma_eol (parser);
16125 : 12 : parser->lex_joined_string = false;
16126 : :
16127 : 12 : if (name)
16128 : 12 : c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name));
16129 : 12 : }
16130 : :
16131 : : /* OpenACC and OpenMP parsing routines. */
16132 : :
16133 : : /* Returns name of the next clause.
16134 : : If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
16135 : : the token is not consumed. Otherwise appropriate pragma_omp_clause is
16136 : : returned and the token is consumed. */
16137 : :
16138 : : static pragma_omp_clause
16139 : 34084 : c_parser_omp_clause_name (c_parser *parser)
16140 : : {
16141 : 34084 : pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE;
16142 : :
16143 : 34084 : if (c_parser_next_token_is_keyword (parser, RID_AUTO))
16144 : : result = PRAGMA_OACC_CLAUSE_AUTO;
16145 : 33959 : else if (c_parser_next_token_is_keyword (parser, RID_IF))
16146 : : result = PRAGMA_OMP_CLAUSE_IF;
16147 : 33076 : else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
16148 : : result = PRAGMA_OMP_CLAUSE_DEFAULT;
16149 : 32348 : else if (c_parser_next_token_is_keyword (parser, RID_FOR))
16150 : : result = PRAGMA_OMP_CLAUSE_FOR;
16151 : 32264 : else if (c_parser_next_token_is (parser, CPP_NAME))
16152 : : {
16153 : 32181 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
16154 : :
16155 : 32181 : switch (p[0])
16156 : : {
16157 : 1111 : case 'a':
16158 : 1111 : if (!strcmp ("affinity", p))
16159 : : result = PRAGMA_OMP_CLAUSE_AFFINITY;
16160 : 965 : else if (!strcmp ("aligned", p))
16161 : : result = PRAGMA_OMP_CLAUSE_ALIGNED;
16162 : 737 : else if (!strcmp ("allocate", p))
16163 : : result = PRAGMA_OMP_CLAUSE_ALLOCATE;
16164 : 270 : else if (!strcmp ("async", p))
16165 : : result = PRAGMA_OACC_CLAUSE_ASYNC;
16166 : 30 : else if (!strcmp ("attach", p))
16167 : 34084 : result = PRAGMA_OACC_CLAUSE_ATTACH;
16168 : : break;
16169 : 116 : case 'b':
16170 : 116 : if (!strcmp ("bind", p))
16171 : 34084 : result = PRAGMA_OMP_CLAUSE_BIND;
16172 : : break;
16173 : 4584 : case 'c':
16174 : 4584 : if (!strcmp ("collapse", p))
16175 : : result = PRAGMA_OMP_CLAUSE_COLLAPSE;
16176 : 1638 : else if (!strcmp ("copy", p))
16177 : : result = PRAGMA_OACC_CLAUSE_COPY;
16178 : 854 : else if (!strcmp ("copyin", p))
16179 : : result = PRAGMA_OMP_CLAUSE_COPYIN;
16180 : 419 : else if (!strcmp ("copyout", p))
16181 : : result = PRAGMA_OACC_CLAUSE_COPYOUT;
16182 : 96 : else if (!strcmp ("copyprivate", p))
16183 : : result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
16184 : 75 : else if (!strcmp ("create", p))
16185 : 34084 : result = PRAGMA_OACC_CLAUSE_CREATE;
16186 : : break;
16187 : 3503 : case 'd':
16188 : 3503 : if (!strcmp ("defaultmap", p))
16189 : : result = PRAGMA_OMP_CLAUSE_DEFAULTMAP;
16190 : 3264 : else if (!strcmp ("delete", p))
16191 : : result = PRAGMA_OACC_CLAUSE_DELETE;
16192 : 3196 : else if (!strcmp ("depend", p))
16193 : : result = PRAGMA_OMP_CLAUSE_DEPEND;
16194 : 2341 : else if (!strcmp ("destroy", p))
16195 : : result = PRAGMA_OMP_CLAUSE_DESTROY;
16196 : 2300 : else if (!strcmp ("detach", p))
16197 : : result = PRAGMA_OACC_CLAUSE_DETACH;
16198 : 2246 : else if (!strcmp ("device", p))
16199 : : result = PRAGMA_OMP_CLAUSE_DEVICE;
16200 : 1843 : else if (!strcmp ("deviceptr", p))
16201 : : result = PRAGMA_OACC_CLAUSE_DEVICEPTR;
16202 : 1786 : else if (!strcmp ("device_resident", p))
16203 : : result = PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT;
16204 : 1770 : else if (!strcmp ("device_type", p))
16205 : : result = PRAGMA_OMP_CLAUSE_DEVICE_TYPE;
16206 : 1728 : else if (!strcmp ("dist_schedule", p))
16207 : : result = PRAGMA_OMP_CLAUSE_DIST_SCHEDULE;
16208 : 146 : else if (!strcmp ("doacross", p))
16209 : 34084 : result = PRAGMA_OMP_CLAUSE_DOACROSS;
16210 : : break;
16211 : 42 : case 'e':
16212 : 42 : if (!strcmp ("enter", p))
16213 : 34084 : result = PRAGMA_OMP_CLAUSE_ENTER;
16214 : : break;
16215 : 3471 : case 'f':
16216 : 3471 : if (!strcmp ("filter", p))
16217 : : result = PRAGMA_OMP_CLAUSE_FILTER;
16218 : 3409 : else if (!strcmp ("final", p))
16219 : : result = PRAGMA_OMP_CLAUSE_FINAL;
16220 : 3311 : else if (!strcmp ("finalize", p))
16221 : : result = PRAGMA_OACC_CLAUSE_FINALIZE;
16222 : 3299 : else if (!strcmp ("firstprivate", p))
16223 : : result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
16224 : 2521 : else if (!strcmp ("from", p))
16225 : : result = PRAGMA_OMP_CLAUSE_FROM;
16226 : 71 : else if (!strcmp ("full", p))
16227 : 34084 : result = PRAGMA_OMP_CLAUSE_FULL;
16228 : : break;
16229 : 651 : case 'g':
16230 : 651 : if (!strcmp ("gang", p))
16231 : : result = PRAGMA_OACC_CLAUSE_GANG;
16232 : 62 : else if (!strcmp ("grainsize", p))
16233 : 34084 : result = PRAGMA_OMP_CLAUSE_GRAINSIZE;
16234 : : break;
16235 : 157 : case 'h':
16236 : 157 : if (!strcmp ("has_device_addr", p))
16237 : : result = PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR;
16238 : 70 : else if (!strcmp ("hint", p))
16239 : : result = PRAGMA_OMP_CLAUSE_HINT;
16240 : 41 : else if (!strcmp ("host", p))
16241 : 34084 : result = PRAGMA_OACC_CLAUSE_HOST;
16242 : : break;
16243 : 797 : case 'i':
16244 : 797 : if (!strcmp ("if_present", p))
16245 : : result = PRAGMA_OACC_CLAUSE_IF_PRESENT;
16246 : 778 : else if (!strcmp ("in_reduction", p))
16247 : : result = PRAGMA_OMP_CLAUSE_IN_REDUCTION;
16248 : 458 : else if (!strcmp ("inbranch", p))
16249 : : result = PRAGMA_OMP_CLAUSE_INBRANCH;
16250 : 395 : else if (!strcmp ("independent", p))
16251 : : result = PRAGMA_OACC_CLAUSE_INDEPENDENT;
16252 : 350 : else if (!strcmp ("indirect", p))
16253 : : result = PRAGMA_OMP_CLAUSE_INDIRECT;
16254 : 324 : else if (!strcmp ("init", p))
16255 : : result = PRAGMA_OMP_CLAUSE_INIT;
16256 : 157 : else if (!strcmp ("is_device_ptr", p))
16257 : : result = PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR;
16258 : 43 : else if (!strcmp ("interop", p))
16259 : 34084 : result = PRAGMA_OMP_CLAUSE_INTEROP;
16260 : : break;
16261 : 1250 : case 'l':
16262 : 1250 : if (!strcmp ("lastprivate", p))
16263 : : result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
16264 : 519 : else if (!strcmp ("linear", p))
16265 : : result = PRAGMA_OMP_CLAUSE_LINEAR;
16266 : 45 : else if (!strcmp ("link", p))
16267 : 34084 : result = PRAGMA_OMP_CLAUSE_LINK;
16268 : : break;
16269 : 1809 : case 'm':
16270 : 1809 : if (!strcmp ("map", p))
16271 : : result = PRAGMA_OMP_CLAUSE_MAP;
16272 : 78 : else if (!strcmp ("mergeable", p))
16273 : 34084 : result = PRAGMA_OMP_CLAUSE_MERGEABLE;
16274 : : break;
16275 : 1922 : case 'n':
16276 : 1922 : if (!strcmp ("no_create", p))
16277 : : result = PRAGMA_OACC_CLAUSE_NO_CREATE;
16278 : 1912 : else if (!strcmp ("nocontext", p))
16279 : : result = PRAGMA_OMP_CLAUSE_NOCONTEXT;
16280 : 1889 : else if (!strcmp ("nogroup", p))
16281 : : result = PRAGMA_OMP_CLAUSE_NOGROUP;
16282 : 1871 : else if (!strcmp ("nohost", p))
16283 : : result = PRAGMA_OACC_CLAUSE_NOHOST;
16284 : 1846 : else if (!strcmp ("nontemporal", p))
16285 : : result = PRAGMA_OMP_CLAUSE_NONTEMPORAL;
16286 : 1725 : else if (!strcmp ("notinbranch", p))
16287 : : result = PRAGMA_OMP_CLAUSE_NOTINBRANCH;
16288 : 1589 : else if (!strcmp ("novariants", p))
16289 : : result = PRAGMA_OMP_CLAUSE_NOVARIANTS;
16290 : 1568 : else if (!strcmp ("nowait", p))
16291 : : result = PRAGMA_OMP_CLAUSE_NOWAIT;
16292 : 1177 : else if (!strcmp ("num_gangs", p))
16293 : : result = PRAGMA_OACC_CLAUSE_NUM_GANGS;
16294 : 875 : else if (!strcmp ("num_tasks", p))
16295 : : result = PRAGMA_OMP_CLAUSE_NUM_TASKS;
16296 : 826 : else if (!strcmp ("num_teams", p))
16297 : : result = PRAGMA_OMP_CLAUSE_NUM_TEAMS;
16298 : 631 : else if (!strcmp ("num_threads", p))
16299 : : result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
16300 : 207 : else if (!strcmp ("num_workers", p))
16301 : 34084 : result = PRAGMA_OACC_CLAUSE_NUM_WORKERS;
16302 : : break;
16303 : 689 : case 'o':
16304 : 689 : if (!strcmp ("ordered", p))
16305 : : result = PRAGMA_OMP_CLAUSE_ORDERED;
16306 : 380 : else if (!strcmp ("order", p))
16307 : 34084 : result = PRAGMA_OMP_CLAUSE_ORDER;
16308 : : break;
16309 : 1634 : case 'p':
16310 : 1634 : if (!strcmp ("parallel", p))
16311 : : result = PRAGMA_OMP_CLAUSE_PARALLEL;
16312 : 1527 : else if (!strcmp ("partial", p))
16313 : : result = PRAGMA_OMP_CLAUSE_PARTIAL;
16314 : 1297 : else if (!strcmp ("present", p))
16315 : : result = PRAGMA_OACC_CLAUSE_PRESENT;
16316 : : /* As of OpenACC 2.5, these are now aliases of the non-present_or
16317 : : clauses. */
16318 : 1169 : else if (!strcmp ("present_or_copy", p)
16319 : 1156 : || !strcmp ("pcopy", p))
16320 : : result = PRAGMA_OACC_CLAUSE_COPY;
16321 : 1147 : else if (!strcmp ("present_or_copyin", p)
16322 : 1131 : || !strcmp ("pcopyin", p))
16323 : : result = PRAGMA_OACC_CLAUSE_COPYIN;
16324 : 1122 : else if (!strcmp ("present_or_copyout", p)
16325 : 1069 : || !strcmp ("pcopyout", p))
16326 : : result = PRAGMA_OACC_CLAUSE_COPYOUT;
16327 : 1055 : else if (!strcmp ("present_or_create", p)
16328 : 1041 : || !strcmp ("pcreate", p))
16329 : : result = PRAGMA_OACC_CLAUSE_CREATE;
16330 : 1036 : else if (!strcmp ("priority", p))
16331 : : result = PRAGMA_OMP_CLAUSE_PRIORITY;
16332 : 939 : else if (!strcmp ("private", p))
16333 : : result = PRAGMA_OMP_CLAUSE_PRIVATE;
16334 : 204 : else if (!strcmp ("proc_bind", p))
16335 : 34084 : result = PRAGMA_OMP_CLAUSE_PROC_BIND;
16336 : : break;
16337 : 2683 : case 'r':
16338 : 2683 : if (!strcmp ("reduction", p))
16339 : 34084 : result = PRAGMA_OMP_CLAUSE_REDUCTION;
16340 : : break;
16341 : 5162 : case 's':
16342 : 5162 : if (!strcmp ("safelen", p))
16343 : : result = PRAGMA_OMP_CLAUSE_SAFELEN;
16344 : 4935 : else if (!strcmp ("schedule", p))
16345 : : result = PRAGMA_OMP_CLAUSE_SCHEDULE;
16346 : 1468 : else if (!strcmp ("sections", p))
16347 : : result = PRAGMA_OMP_CLAUSE_SECTIONS;
16348 : 1390 : else if (!strcmp ("self", p))
16349 : : result = PRAGMA_OACC_CLAUSE_SELF;
16350 : 1324 : else if (!strcmp ("seq", p))
16351 : : result = PRAGMA_OACC_CLAUSE_SEQ;
16352 : 1063 : else if (!strcmp ("shared", p))
16353 : : result = PRAGMA_OMP_CLAUSE_SHARED;
16354 : 374 : else if (!strcmp ("simd", p))
16355 : : result = PRAGMA_OMP_CLAUSE_SIMD;
16356 : 317 : else if (!strcmp ("simdlen", p))
16357 : 34084 : result = PRAGMA_OMP_CLAUSE_SIMDLEN;
16358 : : break;
16359 : 996 : case 't':
16360 : 996 : if (!strcmp ("task_reduction", p))
16361 : : result = PRAGMA_OMP_CLAUSE_TASK_REDUCTION;
16362 : 910 : else if (!strcmp ("taskgroup", p))
16363 : : result = PRAGMA_OMP_CLAUSE_TASKGROUP;
16364 : 800 : else if (!strcmp ("thread_limit", p))
16365 : : result = PRAGMA_OMP_CLAUSE_THREAD_LIMIT;
16366 : 646 : else if (!strcmp ("threads", p))
16367 : : result = PRAGMA_OMP_CLAUSE_THREADS;
16368 : 600 : else if (!strcmp ("tile", p))
16369 : : result = PRAGMA_OACC_CLAUSE_TILE;
16370 : 477 : else if (!strcmp ("to", p))
16371 : 34084 : result = PRAGMA_OMP_CLAUSE_TO;
16372 : : break;
16373 : 320 : case 'u':
16374 : 320 : if (!strcmp ("uniform", p))
16375 : : result = PRAGMA_OMP_CLAUSE_UNIFORM;
16376 : 205 : else if (!strcmp ("untied", p))
16377 : : result = PRAGMA_OMP_CLAUSE_UNTIED;
16378 : 109 : else if (!strcmp ("use", p))
16379 : : result = PRAGMA_OMP_CLAUSE_USE;
16380 : 66 : else if (!strcmp ("use_device", p))
16381 : : result = PRAGMA_OACC_CLAUSE_USE_DEVICE;
16382 : 45 : else if (!strcmp ("use_device_addr", p))
16383 : : result = PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR;
16384 : 10 : else if (!strcmp ("use_device_ptr", p))
16385 : 34084 : result = PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR;
16386 : : break;
16387 : 741 : case 'v':
16388 : 741 : if (!strcmp ("vector", p))
16389 : : result = PRAGMA_OACC_CLAUSE_VECTOR;
16390 : 223 : else if (!strcmp ("vector_length", p))
16391 : 34084 : result = PRAGMA_OACC_CLAUSE_VECTOR_LENGTH;
16392 : : break;
16393 : 542 : case 'w':
16394 : 542 : if (!strcmp ("wait", p))
16395 : : result = PRAGMA_OACC_CLAUSE_WAIT;
16396 : 453 : else if (!strcmp ("worker", p))
16397 : 34084 : result = PRAGMA_OACC_CLAUSE_WORKER;
16398 : : break;
16399 : : }
16400 : : }
16401 : :
16402 : 34084 : if (result != PRAGMA_OMP_CLAUSE_NONE)
16403 : 33975 : c_parser_consume_token (parser);
16404 : :
16405 : 34084 : return result;
16406 : : }
16407 : :
16408 : : /* Validate that a clause of the given type does not already exist. */
16409 : :
16410 : : static void
16411 : 17528 : check_no_duplicate_clause (tree clauses, enum omp_clause_code code,
16412 : : const char *name)
16413 : : {
16414 : 17528 : if (tree c = omp_find_clause (clauses, code))
16415 : 347 : error_at (OMP_CLAUSE_LOCATION (c), "too many %qs clauses", name);
16416 : 17528 : }
16417 : :
16418 : : /* OpenACC 2.0
16419 : : Parse wait clause or wait directive parameters. */
16420 : :
16421 : : static tree
16422 : 123 : c_parser_oacc_wait_list (c_parser *parser, location_t clause_loc, tree list)
16423 : : {
16424 : 123 : vec<tree, va_gc> *args;
16425 : 123 : tree t, args_tree;
16426 : :
16427 : 123 : matching_parens parens;
16428 : 123 : if (!parens.require_open (parser))
16429 : : return list;
16430 : :
16431 : 123 : args = c_parser_expr_list (parser, false, true, NULL, NULL, NULL, NULL);
16432 : 123 : args_tree = build_tree_list_vec (args);
16433 : :
16434 : 289 : for (t = args_tree; t; t = TREE_CHAIN (t))
16435 : : {
16436 : 166 : tree targ = TREE_VALUE (t);
16437 : :
16438 : 166 : if (targ != error_mark_node)
16439 : : {
16440 : 152 : if (!INTEGRAL_TYPE_P (TREE_TYPE (targ)))
16441 : : {
16442 : 6 : c_parser_error (parser, "expression must be integral");
16443 : 6 : targ = error_mark_node;
16444 : : }
16445 : : else
16446 : : {
16447 : 146 : tree c = build_omp_clause (clause_loc, OMP_CLAUSE_WAIT);
16448 : :
16449 : 146 : OMP_CLAUSE_DECL (c) = targ;
16450 : 146 : OMP_CLAUSE_CHAIN (c) = list;
16451 : 146 : list = c;
16452 : : }
16453 : : }
16454 : : }
16455 : :
16456 : 123 : release_tree_vector (args);
16457 : 123 : parens.require_close (parser);
16458 : 123 : return list;
16459 : : }
16460 : :
16461 : : /* OpenACC 2.0, OpenMP 2.5:
16462 : : variable-list:
16463 : : identifier
16464 : : variable-list , identifier
16465 : :
16466 : : If KIND is nonzero, create the appropriate node and install the
16467 : : decl in OMP_CLAUSE_DECL and add the node to the head of the list.
16468 : : If KIND is nonzero, CLAUSE_LOC is the location of the clause.
16469 : :
16470 : : If KIND is zero (= OMP_CLAUSE_ERROR), create a TREE_LIST with the decl
16471 : : in TREE_PURPOSE and the location in TREE_VALUE (accessible using
16472 : : EXPR_LOCATION); return the list created.
16473 : :
16474 : : The optional ALLOW_DEREF argument is true if list items can use the deref
16475 : : (->) operator. */
16476 : :
16477 : : struct omp_dim
16478 : : {
16479 : : tree low_bound, length;
16480 : : location_t loc;
16481 : : bool no_colon;
16482 : 3306 : omp_dim (tree lb, tree len, location_t lo, bool nc)
16483 : 3306 : : low_bound (lb), length (len), loc (lo), no_colon (nc) {}
16484 : : };
16485 : :
16486 : : static tree
16487 : 16261 : c_parser_omp_variable_list (c_parser *parser,
16488 : : location_t clause_loc,
16489 : : enum omp_clause_code kind, tree list,
16490 : : bool map_lvalue = false)
16491 : : {
16492 : 16261 : auto_vec<omp_dim> dims;
16493 : 16261 : bool array_section_p;
16494 : 16261 : auto_vec<c_token> tokens;
16495 : 16261 : unsigned int tokens_avail = 0;
16496 : 16261 : c_token *saved_tokens = NULL;
16497 : :
16498 : 19447 : while (1)
16499 : : {
16500 : 19447 : tree t = NULL_TREE;
16501 : 19447 : location_t tloc = c_parser_peek_token (parser)->location;
16502 : :
16503 : 19447 : if (kind == OMP_CLAUSE_DEPEND || kind == OMP_CLAUSE_AFFINITY)
16504 : : {
16505 : 888 : if (c_parser_next_token_is_not (parser, CPP_NAME)
16506 : 888 : || c_parser_peek_token (parser)->id_kind != C_ID_ID)
16507 : : {
16508 : 29 : struct c_expr expr;
16509 : 29 : if (kind == OMP_CLAUSE_DEPEND
16510 : 27 : && c_parser_next_token_is_keyword (parser,
16511 : : RID_OMP_ALL_MEMORY)
16512 : 45 : && (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
16513 : 13 : || (c_parser_peek_2nd_token (parser)->type
16514 : : == CPP_CLOSE_PAREN)))
16515 : : {
16516 : 15 : expr.value = ridpointers[RID_OMP_ALL_MEMORY];
16517 : 15 : c_parser_consume_token (parser);
16518 : : }
16519 : : else
16520 : 14 : expr = c_parser_expr_no_commas (parser, NULL);
16521 : 29 : if (expr.value != error_mark_node)
16522 : : {
16523 : 27 : tree u = build_omp_clause (clause_loc, kind);
16524 : 27 : OMP_CLAUSE_DECL (u) = expr.value;
16525 : 27 : OMP_CLAUSE_CHAIN (u) = list;
16526 : 27 : list = u;
16527 : : }
16528 : :
16529 : 29 : if (c_parser_next_token_is_not (parser, CPP_COMMA))
16530 : : break;
16531 : :
16532 : 4 : c_parser_consume_token (parser);
16533 : 4 : continue;
16534 : 4 : }
16535 : :
16536 : 859 : tokens.truncate (0);
16537 : 859 : unsigned int nesting_depth = 0;
16538 : 11227 : while (1)
16539 : : {
16540 : 6043 : c_token *token = c_parser_peek_token (parser);
16541 : 6043 : switch (token->type)
16542 : : {
16543 : : case CPP_EOF:
16544 : : case CPP_PRAGMA_EOL:
16545 : : break;
16546 : 930 : case CPP_OPEN_BRACE:
16547 : 930 : case CPP_OPEN_PAREN:
16548 : 930 : case CPP_OPEN_SQUARE:
16549 : 930 : ++nesting_depth;
16550 : 930 : goto add;
16551 : 1723 : case CPP_CLOSE_BRACE:
16552 : 1723 : case CPP_CLOSE_PAREN:
16553 : 1723 : case CPP_CLOSE_SQUARE:
16554 : 1723 : if (nesting_depth-- == 0)
16555 : : break;
16556 : 930 : goto add;
16557 : 138 : case CPP_COMMA:
16558 : 138 : if (nesting_depth == 0)
16559 : : break;
16560 : 72 : goto add;
16561 : 5184 : default:
16562 : 5184 : add:
16563 : 5184 : tokens.safe_push (*token);
16564 : 5184 : c_parser_consume_token (parser);
16565 : 5184 : continue;
16566 : : }
16567 : 859 : break;
16568 : 5184 : }
16569 : :
16570 : : /* Make sure nothing tries to read past the end of the tokens. */
16571 : 859 : c_token eof_token;
16572 : 859 : memset (&eof_token, 0, sizeof (eof_token));
16573 : 859 : eof_token.type = CPP_EOF;
16574 : 859 : tokens.safe_push (eof_token);
16575 : 859 : tokens.safe_push (eof_token);
16576 : :
16577 : 859 : saved_tokens = parser->tokens;
16578 : 859 : tokens_avail = parser->tokens_avail;
16579 : 859 : parser->tokens = tokens.address ();
16580 : 1718 : parser->tokens_avail = tokens.length ();
16581 : : }
16582 : 18559 : else if (map_lvalue
16583 : 2119 : && (kind == OMP_CLAUSE_MAP
16584 : : || kind == OMP_CLAUSE_TO
16585 : 2119 : || kind == OMP_CLAUSE_FROM))
16586 : : {
16587 : 2119 : location_t loc = c_parser_peek_token (parser)->location;
16588 : 2119 : bool save_c_omp_array_section_p = c_omp_array_section_p;
16589 : 2119 : c_omp_array_section_p = true;
16590 : 2119 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
16591 : 2119 : if (expr.value != error_mark_node)
16592 : 2111 : mark_exp_read (expr.value);
16593 : 2119 : c_omp_array_section_p = save_c_omp_array_section_p;
16594 : 2119 : tree decl = expr.value;
16595 : :
16596 : : /* This code rewrites a parsed expression containing various tree
16597 : : codes used to represent array accesses into a more uniform nest of
16598 : : OMP_ARRAY_SECTION nodes before it is processed by
16599 : : c-typeck.cc:handle_omp_array_sections_1. It might be more
16600 : : efficient to move this logic to that function instead, analysing
16601 : : the parsed expression directly rather than this preprocessed
16602 : : form. (See also equivalent code in cp/parser.cc,
16603 : : cp/semantics.cc). */
16604 : 2119 : dims.truncate (0);
16605 : 2119 : if (TREE_CODE (decl) == OMP_ARRAY_SECTION)
16606 : : {
16607 : 1050 : while (TREE_CODE (decl) == OMP_ARRAY_SECTION)
16608 : : {
16609 : 555 : tree low_bound = TREE_OPERAND (decl, 1);
16610 : 555 : tree length = TREE_OPERAND (decl, 2);
16611 : 555 : dims.safe_push (omp_dim (low_bound, length, loc, false));
16612 : 555 : decl = TREE_OPERAND (decl, 0);
16613 : : }
16614 : :
16615 : 528 : while (TREE_CODE (decl) == ARRAY_REF
16616 : : || TREE_CODE (decl) == INDIRECT_REF
16617 : 528 : || TREE_CODE (decl) == COMPOUND_EXPR)
16618 : : {
16619 : 33 : if (TREE_CODE (decl) == COMPOUND_EXPR)
16620 : : {
16621 : 2 : decl = TREE_OPERAND (decl, 1);
16622 : 2 : STRIP_NOPS (decl);
16623 : : }
16624 : 31 : else if (TREE_CODE (decl) == INDIRECT_REF)
16625 : : {
16626 : 46 : dims.safe_push (omp_dim (integer_zero_node,
16627 : 23 : integer_one_node, loc, true));
16628 : 23 : decl = TREE_OPERAND (decl, 0);
16629 : : }
16630 : : else /* ARRAY_REF. */
16631 : : {
16632 : 8 : tree index = TREE_OPERAND (decl, 1);
16633 : 16 : dims.safe_push (omp_dim (index, integer_one_node, loc,
16634 : 8 : true));
16635 : 8 : decl = TREE_OPERAND (decl, 0);
16636 : : }
16637 : : }
16638 : :
16639 : 1576 : for (int i = dims.length () - 1; i >= 0; i--)
16640 : 586 : decl = build_omp_array_section (loc, decl, dims[i].low_bound,
16641 : 586 : dims[i].length);
16642 : : }
16643 : 1624 : else if (TREE_CODE (decl) == INDIRECT_REF)
16644 : : {
16645 : : /* Turn indirection of a pointer "*foo" into "foo[0:1]". */
16646 : 50 : decl = TREE_OPERAND (decl, 0);
16647 : 50 : STRIP_NOPS (decl);
16648 : :
16649 : 50 : decl = build_omp_array_section (loc, decl, integer_zero_node,
16650 : : integer_one_node);
16651 : : }
16652 : 1574 : else if (TREE_CODE (decl) == ARRAY_REF)
16653 : : {
16654 : 12 : tree idx = TREE_OPERAND (decl, 1);
16655 : :
16656 : 12 : decl = TREE_OPERAND (decl, 0);
16657 : 12 : STRIP_NOPS (decl);
16658 : :
16659 : 12 : decl = build_omp_array_section (loc, decl, idx, integer_one_node);
16660 : : }
16661 : 1562 : else if (TREE_CODE (decl) == NON_LVALUE_EXPR
16662 : 1562 : || CONVERT_EXPR_P (decl))
16663 : 0 : decl = TREE_OPERAND (decl, 0);
16664 : :
16665 : 2119 : tree u = build_omp_clause (loc, kind);
16666 : 2119 : OMP_CLAUSE_DECL (u) = decl;
16667 : 2119 : OMP_CLAUSE_CHAIN (u) = list;
16668 : 2119 : list = u;
16669 : :
16670 : 2119 : goto next_item;
16671 : : }
16672 : :
16673 : 17299 : if (c_parser_next_token_is (parser, CPP_NAME)
16674 : 17299 : && c_parser_peek_token (parser)->id_kind == C_ID_ID)
16675 : : {
16676 : 17262 : t = lookup_name (c_parser_peek_token (parser)->value);
16677 : :
16678 : 17262 : if (t == NULL_TREE)
16679 : : {
16680 : 14 : undeclared_variable (c_parser_peek_token (parser)->location,
16681 : 14 : c_parser_peek_token (parser)->value);
16682 : 14 : t = error_mark_node;
16683 : : }
16684 : :
16685 : 17262 : c_parser_consume_token (parser);
16686 : : }
16687 : 37 : else if (c_parser_next_token_is (parser, CPP_KEYWORD)
16688 : 37 : && (c_parser_peek_token (parser)->keyword == RID_FUNCTION_NAME
16689 : 15 : || (c_parser_peek_token (parser)->keyword
16690 : : == RID_PRETTY_FUNCTION_NAME)
16691 : 9 : || (c_parser_peek_token (parser)->keyword
16692 : : == RID_C99_FUNCTION_NAME)))
16693 : 20 : t = c_parser_predefined_identifier (parser).value;
16694 : : else
16695 : : {
16696 : 17 : c_parser_error (parser, "expected identifier");
16697 : 17 : break;
16698 : : }
16699 : :
16700 : 17282 : if (t == error_mark_node)
16701 : : ;
16702 : 17264 : else if (kind != 0) /* kind != OMP_CLAUSE_ERROR */
16703 : : {
16704 : 17037 : switch (kind)
16705 : : {
16706 : 139 : case OMP_CLAUSE__CACHE_:
16707 : : /* The OpenACC cache directive explicitly only allows "array
16708 : : elements or subarrays". */
16709 : 139 : if (c_parser_peek_token (parser)->type != CPP_OPEN_SQUARE)
16710 : : {
16711 : 3 : c_parser_error (parser, "expected %<[%>");
16712 : 3 : t = error_mark_node;
16713 : 3 : break;
16714 : : }
16715 : : /* FALLTHROUGH */
16716 : : case OMP_CLAUSE_MAP:
16717 : : case OMP_CLAUSE_FROM:
16718 : : case OMP_CLAUSE_TO:
16719 : 136 : start_component_ref:
16720 : 5963 : while (c_parser_next_token_is (parser, CPP_DOT)
16721 : 11719 : || c_parser_next_token_is (parser, CPP_DEREF))
16722 : : {
16723 : 316 : location_t op_loc = c_parser_peek_token (parser)->location;
16724 : 316 : location_t arrow_loc = UNKNOWN_LOCATION;
16725 : 316 : if (c_parser_next_token_is (parser, CPP_DEREF))
16726 : : {
16727 : 109 : c_expr t_expr;
16728 : 109 : t_expr.value = t;
16729 : 109 : t_expr.original_code = ERROR_MARK;
16730 : 109 : t_expr.original_type = NULL;
16731 : 109 : set_c_expr_source_range (&t_expr, op_loc, op_loc);
16732 : 109 : t_expr.m_decimal = 0;
16733 : 109 : t_expr = convert_lvalue_to_rvalue (op_loc, t_expr,
16734 : : true, false);
16735 : 109 : t = build_indirect_ref (op_loc, t_expr.value, RO_ARROW);
16736 : 109 : arrow_loc = t_expr.get_location ();
16737 : : }
16738 : 316 : c_parser_consume_token (parser);
16739 : 316 : if (!c_parser_next_token_is (parser, CPP_NAME))
16740 : : {
16741 : 0 : c_parser_error (parser, "expected identifier");
16742 : 0 : t = error_mark_node;
16743 : 0 : break;
16744 : : }
16745 : :
16746 : 316 : c_token *comp_tok = c_parser_peek_token (parser);
16747 : 316 : tree ident = comp_tok->value;
16748 : 316 : location_t comp_loc = comp_tok->location;
16749 : 316 : c_parser_consume_token (parser);
16750 : 316 : t = build_component_ref (op_loc, t, ident, comp_loc,
16751 : : arrow_loc);
16752 : : }
16753 : : /* FALLTHROUGH */
16754 : 10292 : case OMP_CLAUSE_AFFINITY:
16755 : 10292 : case OMP_CLAUSE_DEPEND:
16756 : 10292 : case OMP_CLAUSE_REDUCTION:
16757 : 10292 : case OMP_CLAUSE_IN_REDUCTION:
16758 : 10292 : case OMP_CLAUSE_TASK_REDUCTION:
16759 : 10292 : case OMP_CLAUSE_HAS_DEVICE_ADDR:
16760 : 10292 : array_section_p = false;
16761 : 10292 : dims.truncate (0);
16762 : 23304 : while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
16763 : : {
16764 : 2720 : location_t loc = UNKNOWN_LOCATION;
16765 : 2720 : tree low_bound = NULL_TREE, length = NULL_TREE;
16766 : 2720 : bool no_colon = false;
16767 : :
16768 : 2720 : c_parser_consume_token (parser);
16769 : 2720 : if (!c_parser_next_token_is (parser, CPP_COLON))
16770 : : {
16771 : 2300 : location_t expr_loc
16772 : 2300 : = c_parser_peek_token (parser)->location;
16773 : 2300 : c_expr expr = c_parser_expression (parser);
16774 : 2300 : expr = convert_lvalue_to_rvalue (expr_loc, expr,
16775 : : false, true);
16776 : 2300 : low_bound = expr.value;
16777 : 2300 : loc = expr_loc;
16778 : : }
16779 : 2720 : if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
16780 : : {
16781 : 432 : length = integer_one_node;
16782 : 432 : no_colon = true;
16783 : : }
16784 : : else
16785 : : {
16786 : : /* Look for `:'. */
16787 : 2288 : if (!c_parser_require (parser, CPP_COLON,
16788 : : "expected %<:%>"))
16789 : : {
16790 : 0 : t = error_mark_node;
16791 : 0 : break;
16792 : : }
16793 : 2288 : array_section_p = true;
16794 : 2288 : if (!c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
16795 : : {
16796 : 2103 : location_t expr_loc
16797 : 2103 : = c_parser_peek_token (parser)->location;
16798 : 2103 : c_expr expr = c_parser_expression (parser);
16799 : 2103 : expr = convert_lvalue_to_rvalue (expr_loc, expr,
16800 : : false, true);
16801 : 2103 : length = expr.value;
16802 : : }
16803 : : }
16804 : : /* Look for the closing `]'. */
16805 : 2720 : if (!c_parser_require (parser, CPP_CLOSE_SQUARE,
16806 : : "expected %<]%>"))
16807 : : {
16808 : 0 : t = error_mark_node;
16809 : 0 : break;
16810 : : }
16811 : :
16812 : 2720 : dims.safe_push (omp_dim (low_bound, length, loc, no_colon));
16813 : : }
16814 : :
16815 : 10292 : if (t != error_mark_node)
16816 : : {
16817 : 10292 : if ((kind == OMP_CLAUSE_MAP
16818 : 10292 : || kind == OMP_CLAUSE_FROM
16819 : 5188 : || kind == OMP_CLAUSE_TO)
16820 : 5511 : && !array_section_p
16821 : 14548 : && (c_parser_next_token_is (parser, CPP_DOT)
16822 : 4252 : || c_parser_next_token_is (parser, CPP_DEREF)))
16823 : : {
16824 : 8 : for (unsigned i = 0; i < dims.length (); i++)
16825 : : {
16826 : 4 : gcc_assert (dims[i].length == integer_one_node);
16827 : 4 : t = build_array_ref (dims[i].loc,
16828 : 4 : t, dims[i].low_bound);
16829 : : }
16830 : 4 : goto start_component_ref;
16831 : : }
16832 : : else
16833 : 13004 : for (unsigned i = 0; i < dims.length (); i++)
16834 : 5432 : t = build_omp_array_section (clause_loc, t,
16835 : 2716 : dims[i].low_bound,
16836 : 2716 : dims[i].length);
16837 : : }
16838 : :
16839 : 10288 : if ((kind == OMP_CLAUSE_DEPEND || kind == OMP_CLAUSE_AFFINITY)
16840 : 855 : && t != error_mark_node
16841 : 855 : && parser->tokens_avail != 2)
16842 : : {
16843 : 44 : if (array_section_p)
16844 : : {
16845 : 12 : error_at (c_parser_peek_token (parser)->location,
16846 : : "expected %<)%> or %<,%>");
16847 : 12 : t = error_mark_node;
16848 : : }
16849 : : else
16850 : : {
16851 : 32 : parser->tokens = tokens.address ();
16852 : 32 : parser->tokens_avail = tokens.length ();
16853 : :
16854 : 32 : t = c_parser_expr_no_commas (parser, NULL).value;
16855 : 32 : if (t != error_mark_node && parser->tokens_avail != 2)
16856 : : {
16857 : 0 : error_at (c_parser_peek_token (parser)->location,
16858 : : "expected %<)%> or %<,%>");
16859 : 0 : t = error_mark_node;
16860 : : }
16861 : : }
16862 : : }
16863 : : break;
16864 : : default:
16865 : : break;
16866 : : }
16867 : :
16868 : 17037 : if (t != error_mark_node)
16869 : : {
16870 : 17022 : tree u = build_omp_clause (clause_loc, kind);
16871 : 17022 : OMP_CLAUSE_DECL (u) = t;
16872 : 17022 : OMP_CLAUSE_CHAIN (u) = list;
16873 : 17022 : list = u;
16874 : : }
16875 : : }
16876 : : else /* kind == OMP_CLAUSE_ERROR */
16877 : 227 : list = tree_cons (t, build_empty_stmt (tloc), list);
16878 : :
16879 : 17282 : if (kind == OMP_CLAUSE_DEPEND || kind == OMP_CLAUSE_AFFINITY)
16880 : : {
16881 : 859 : parser->tokens = saved_tokens;
16882 : 859 : parser->tokens_avail = tokens_avail;
16883 : : }
16884 : :
16885 : 16423 : next_item:
16886 : 19401 : if (c_parser_next_token_is_not (parser, CPP_COMMA))
16887 : : break;
16888 : :
16889 : 3182 : c_parser_consume_token (parser);
16890 : : }
16891 : :
16892 : 16261 : return list;
16893 : 16261 : }
16894 : :
16895 : : /* Similarly, but expect leading and trailing parenthesis. This is a very
16896 : : common case for OpenACC and OpenMP clauses. The optional ALLOW_DEREF
16897 : : argument is true if list items can use the deref (->) operator. */
16898 : :
16899 : : static tree
16900 : 3492 : c_parser_omp_var_list_parens (c_parser *parser, enum omp_clause_code kind,
16901 : : tree list, bool map_lvalue = false)
16902 : : {
16903 : : /* The clauses location. */
16904 : 3492 : location_t loc = c_parser_peek_token (parser)->location;
16905 : :
16906 : 3492 : if (parser->in_omp_decl_attribute)
16907 : : {
16908 : 37 : if (kind)
16909 : : {
16910 : 22 : tree u = build_omp_clause (loc, kind);
16911 : 22 : OMP_CLAUSE_DECL (u) = parser->in_omp_decl_attribute;
16912 : 22 : OMP_CLAUSE_CHAIN (u) = list;
16913 : 22 : return u;
16914 : : }
16915 : : else
16916 : 15 : return tree_cons (parser->in_omp_decl_attribute, NULL_TREE, list);
16917 : : }
16918 : :
16919 : 3455 : matching_parens parens;
16920 : 3455 : if (parens.require_open (parser))
16921 : : {
16922 : 3451 : list = c_parser_omp_variable_list (parser, loc, kind, list, map_lvalue);
16923 : 3451 : parens.skip_until_found_close (parser);
16924 : : }
16925 : : return list;
16926 : : }
16927 : :
16928 : : /* OpenACC 2.0:
16929 : : copy ( variable-list )
16930 : : copyin ( variable-list )
16931 : : copyout ( variable-list )
16932 : : create ( variable-list )
16933 : : delete ( variable-list )
16934 : : present ( variable-list )
16935 : :
16936 : : OpenACC 2.6:
16937 : : no_create ( variable-list )
16938 : : attach ( variable-list )
16939 : : detach ( variable-list )
16940 : :
16941 : : OpenACC 2.7:
16942 : : copyin (readonly : variable-list )
16943 : : */
16944 : :
16945 : : static tree
16946 : 2026 : c_parser_oacc_data_clause (c_parser *parser, pragma_omp_clause c_kind,
16947 : : tree list)
16948 : : {
16949 : 2026 : enum gomp_map_kind kind;
16950 : 2026 : switch (c_kind)
16951 : : {
16952 : : case PRAGMA_OACC_CLAUSE_ATTACH:
16953 : : kind = GOMP_MAP_ATTACH;
16954 : : break;
16955 : 806 : case PRAGMA_OACC_CLAUSE_COPY:
16956 : 806 : kind = GOMP_MAP_TOFROM;
16957 : 806 : break;
16958 : 359 : case PRAGMA_OACC_CLAUSE_COPYIN:
16959 : 359 : kind = GOMP_MAP_TO;
16960 : 359 : break;
16961 : 390 : case PRAGMA_OACC_CLAUSE_COPYOUT:
16962 : 390 : kind = GOMP_MAP_FROM;
16963 : 390 : break;
16964 : 94 : case PRAGMA_OACC_CLAUSE_CREATE:
16965 : 94 : kind = GOMP_MAP_ALLOC;
16966 : 94 : break;
16967 : 68 : case PRAGMA_OACC_CLAUSE_DELETE:
16968 : 68 : kind = GOMP_MAP_RELEASE;
16969 : 68 : break;
16970 : 20 : case PRAGMA_OACC_CLAUSE_DETACH:
16971 : 20 : kind = GOMP_MAP_DETACH;
16972 : 20 : break;
16973 : 36 : case PRAGMA_OACC_CLAUSE_DEVICE:
16974 : 36 : kind = GOMP_MAP_FORCE_TO;
16975 : 36 : break;
16976 : 16 : case PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT:
16977 : 16 : kind = GOMP_MAP_DEVICE_RESIDENT;
16978 : 16 : break;
16979 : 13 : case PRAGMA_OACC_CLAUSE_LINK:
16980 : 13 : kind = GOMP_MAP_LINK;
16981 : 13 : break;
16982 : 10 : case PRAGMA_OACC_CLAUSE_NO_CREATE:
16983 : 10 : kind = GOMP_MAP_IF_PRESENT;
16984 : 10 : break;
16985 : 128 : case PRAGMA_OACC_CLAUSE_PRESENT:
16986 : 128 : kind = GOMP_MAP_FORCE_PRESENT;
16987 : 128 : break;
16988 : 59 : case PRAGMA_OACC_CLAUSE_SELF:
16989 : : /* "The 'host' clause is a synonym for the 'self' clause." */
16990 : 59 : case PRAGMA_OACC_CLAUSE_HOST:
16991 : 59 : kind = GOMP_MAP_FORCE_FROM;
16992 : 59 : break;
16993 : 0 : default:
16994 : 0 : gcc_unreachable ();
16995 : : }
16996 : :
16997 : 2026 : tree nl = list;
16998 : 2026 : bool readonly = false;
16999 : 2026 : location_t open_loc = c_parser_peek_token (parser)->location;
17000 : 2026 : matching_parens parens;
17001 : 2026 : if (parens.require_open (parser))
17002 : : {
17003 : : /* Turn on readonly modifier parsing for copyin clause. */
17004 : 2026 : if (c_kind == PRAGMA_OACC_CLAUSE_COPYIN)
17005 : : {
17006 : 359 : c_token *token = c_parser_peek_token (parser);
17007 : 359 : if (token->type == CPP_NAME
17008 : 359 : && !strcmp (IDENTIFIER_POINTER (token->value), "readonly")
17009 : 366 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
17010 : : {
17011 : 7 : c_parser_consume_token (parser);
17012 : 7 : c_parser_consume_token (parser);
17013 : 7 : readonly = true;
17014 : : }
17015 : : }
17016 : 2026 : nl = c_parser_omp_variable_list (parser, open_loc, OMP_CLAUSE_MAP, list,
17017 : : false);
17018 : 2026 : parens.skip_until_found_close (parser);
17019 : : }
17020 : :
17021 : 4671 : for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
17022 : : {
17023 : 2645 : OMP_CLAUSE_SET_MAP_KIND (c, kind);
17024 : 2645 : if (readonly)
17025 : 13 : OMP_CLAUSE_MAP_READONLY (c) = 1;
17026 : : }
17027 : :
17028 : 2026 : return nl;
17029 : : }
17030 : :
17031 : : /* OpenACC 2.0:
17032 : : deviceptr ( variable-list ) */
17033 : :
17034 : : static tree
17035 : 57 : c_parser_oacc_data_clause_deviceptr (c_parser *parser, tree list)
17036 : : {
17037 : 57 : tree vars, t;
17038 : :
17039 : : /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
17040 : : c_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
17041 : : variable-list must only allow for pointer variables. */
17042 : 57 : vars = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
17043 : 118 : for (t = vars; t && t; t = TREE_CHAIN (t))
17044 : : {
17045 : 61 : tree v = TREE_PURPOSE (t);
17046 : 61 : location_t loc = EXPR_LOCATION (TREE_VALUE (t));
17047 : :
17048 : 61 : if (!VAR_P (v) && TREE_CODE (v) != PARM_DECL)
17049 : 3 : error_at (loc, "%qD is not a variable", v);
17050 : 58 : else if (TREE_TYPE (v) == error_mark_node)
17051 : : ;
17052 : 57 : else if (!POINTER_TYPE_P (TREE_TYPE (v)))
17053 : 7 : error_at (loc, "%qD is not a pointer variable", v);
17054 : :
17055 : 61 : tree u = build_omp_clause (loc, OMP_CLAUSE_MAP);
17056 : 61 : OMP_CLAUSE_SET_MAP_KIND (u, GOMP_MAP_FORCE_DEVICEPTR);
17057 : 61 : OMP_CLAUSE_DECL (u) = v;
17058 : 61 : OMP_CLAUSE_CHAIN (u) = list;
17059 : 61 : list = u;
17060 : : }
17061 : :
17062 : 57 : return list;
17063 : : }
17064 : :
17065 : : /* OpenACC 2.0, OpenMP 3.0:
17066 : : collapse ( constant-expression ) */
17067 : :
17068 : : static tree
17069 : 2946 : c_parser_omp_clause_collapse (c_parser *parser, tree list)
17070 : : {
17071 : 2946 : tree c, num = error_mark_node;
17072 : 2946 : HOST_WIDE_INT n;
17073 : 2946 : location_t loc;
17074 : :
17075 : 2946 : check_no_duplicate_clause (list, OMP_CLAUSE_COLLAPSE, "collapse");
17076 : 2946 : check_no_duplicate_clause (list, OMP_CLAUSE_TILE, "tile");
17077 : :
17078 : 2946 : loc = c_parser_peek_token (parser)->location;
17079 : 2946 : matching_parens parens;
17080 : 2946 : if (parens.require_open (parser))
17081 : : {
17082 : 2946 : num = c_parser_expr_no_commas (parser, NULL).value;
17083 : 2946 : parens.skip_until_found_close (parser);
17084 : : }
17085 : 2946 : if (num == error_mark_node)
17086 : : return list;
17087 : 2946 : mark_exp_read (num);
17088 : 2946 : num = c_fully_fold (num, false, NULL);
17089 : 5892 : if (!INTEGRAL_TYPE_P (TREE_TYPE (num))
17090 : 2946 : || !tree_fits_shwi_p (num)
17091 : 2946 : || (n = tree_to_shwi (num)) <= 0
17092 : 5892 : || (int) n != n)
17093 : : {
17094 : 0 : error_at (loc,
17095 : : "collapse argument needs positive constant integer expression");
17096 : 0 : return list;
17097 : : }
17098 : 2946 : c = build_omp_clause (loc, OMP_CLAUSE_COLLAPSE);
17099 : 2946 : OMP_CLAUSE_COLLAPSE_EXPR (c) = num;
17100 : 2946 : OMP_CLAUSE_CHAIN (c) = list;
17101 : 2946 : return c;
17102 : : }
17103 : :
17104 : : /* OpenMP 2.5:
17105 : : copyin ( variable-list ) */
17106 : :
17107 : : static tree
17108 : 101 : c_parser_omp_clause_copyin (c_parser *parser, tree list)
17109 : : {
17110 : 0 : return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYIN, list);
17111 : : }
17112 : :
17113 : : /* OpenMP 2.5:
17114 : : copyprivate ( variable-list ) */
17115 : :
17116 : : static tree
17117 : 21 : c_parser_omp_clause_copyprivate (c_parser *parser, tree list)
17118 : : {
17119 : 0 : return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYPRIVATE, list);
17120 : : }
17121 : :
17122 : : /* OpenMP 2.5:
17123 : : default ( none | shared )
17124 : :
17125 : : OpenMP 5.1:
17126 : : default ( private | firstprivate )
17127 : :
17128 : : OpenACC:
17129 : : default ( none | present ) */
17130 : :
17131 : : static tree
17132 : 728 : c_parser_omp_clause_default (c_parser *parser, tree list, bool is_oacc)
17133 : : {
17134 : 728 : enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
17135 : 728 : location_t loc = c_parser_peek_token (parser)->location;
17136 : 728 : tree c;
17137 : :
17138 : 728 : matching_parens parens;
17139 : 728 : if (!parens.require_open (parser))
17140 : : return list;
17141 : 725 : if (c_parser_next_token_is (parser, CPP_NAME))
17142 : : {
17143 : 713 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
17144 : :
17145 : 713 : switch (p[0])
17146 : : {
17147 : 391 : case 'n':
17148 : 391 : if (strcmp ("none", p) != 0)
17149 : 0 : goto invalid_kind;
17150 : : kind = OMP_CLAUSE_DEFAULT_NONE;
17151 : : break;
17152 : :
17153 : 23 : case 'p':
17154 : 23 : if (is_oacc)
17155 : : {
17156 : 18 : if (strcmp ("present", p) != 0)
17157 : 3 : goto invalid_kind;
17158 : : kind = OMP_CLAUSE_DEFAULT_PRESENT;
17159 : : }
17160 : : else
17161 : : {
17162 : 5 : if (strcmp ("private", p) != 0)
17163 : 0 : goto invalid_kind;
17164 : : kind = OMP_CLAUSE_DEFAULT_PRIVATE;
17165 : : }
17166 : : break;
17167 : :
17168 : 9 : case 'f':
17169 : 9 : if (strcmp ("firstprivate", p) != 0 || is_oacc)
17170 : 0 : goto invalid_kind;
17171 : : kind = OMP_CLAUSE_DEFAULT_FIRSTPRIVATE;
17172 : : break;
17173 : :
17174 : 286 : case 's':
17175 : 286 : if (strcmp ("shared", p) != 0 || is_oacc)
17176 : 0 : goto invalid_kind;
17177 : : kind = OMP_CLAUSE_DEFAULT_SHARED;
17178 : : break;
17179 : :
17180 : 4 : default:
17181 : 4 : goto invalid_kind;
17182 : : }
17183 : :
17184 : 700 : c_parser_consume_token (parser);
17185 : : }
17186 : : else
17187 : : {
17188 : 25 : invalid_kind:
17189 : 25 : if (is_oacc)
17190 : 21 : c_parser_error (parser, "expected %<none%> or %<present%>");
17191 : : else
17192 : 4 : c_parser_error (parser, "expected %<none%>, %<shared%>, "
17193 : : "%<private%> or %<firstprivate%>");
17194 : : }
17195 : 725 : parens.skip_until_found_close (parser);
17196 : :
17197 : 725 : if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED)
17198 : : return list;
17199 : :
17200 : 700 : check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default");
17201 : 700 : c = build_omp_clause (loc, OMP_CLAUSE_DEFAULT);
17202 : 700 : OMP_CLAUSE_CHAIN (c) = list;
17203 : 700 : OMP_CLAUSE_DEFAULT_KIND (c) = kind;
17204 : :
17205 : 700 : return c;
17206 : : }
17207 : :
17208 : : /* OpenMP 2.5:
17209 : : firstprivate ( variable-list ) */
17210 : :
17211 : : static tree
17212 : 777 : c_parser_omp_clause_firstprivate (c_parser *parser, tree list)
17213 : : {
17214 : 0 : return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_FIRSTPRIVATE, list);
17215 : : }
17216 : :
17217 : : /* OpenMP 3.1:
17218 : : final ( expression ) */
17219 : :
17220 : : static tree
17221 : 98 : c_parser_omp_clause_final (c_parser *parser, tree list)
17222 : : {
17223 : 98 : location_t loc = c_parser_peek_token (parser)->location;
17224 : 98 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
17225 : : {
17226 : 98 : matching_parens parens;
17227 : 98 : tree t, c;
17228 : 98 : if (!parens.require_open (parser))
17229 : 0 : t = error_mark_node;
17230 : : else
17231 : : {
17232 : 98 : location_t eloc = c_parser_peek_token (parser)->location;
17233 : 98 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
17234 : 98 : t = convert_lvalue_to_rvalue (eloc, expr, true, true).value;
17235 : 98 : t = c_objc_common_truthvalue_conversion (eloc, t);
17236 : 98 : t = c_fully_fold (t, false, NULL);
17237 : 98 : parens.skip_until_found_close (parser);
17238 : : }
17239 : :
17240 : 98 : check_no_duplicate_clause (list, OMP_CLAUSE_FINAL, "final");
17241 : :
17242 : 98 : c = build_omp_clause (loc, OMP_CLAUSE_FINAL);
17243 : 98 : OMP_CLAUSE_FINAL_EXPR (c) = t;
17244 : 98 : OMP_CLAUSE_CHAIN (c) = list;
17245 : 98 : list = c;
17246 : : }
17247 : : else
17248 : 0 : c_parser_error (parser, "expected %<(%>");
17249 : :
17250 : 98 : return list;
17251 : : }
17252 : :
17253 : : /* OpenMP 5.1:
17254 : : indirect [( expression )]
17255 : : */
17256 : :
17257 : : static tree
17258 : 26 : c_parser_omp_clause_indirect (c_parser *parser, tree list)
17259 : : {
17260 : 26 : location_t location = c_parser_peek_token (parser)->location;
17261 : 26 : tree t;
17262 : :
17263 : 26 : if (c_parser_peek_token (parser)->type == CPP_OPEN_PAREN)
17264 : : {
17265 : 17 : matching_parens parens;
17266 : 17 : if (!parens.require_open (parser))
17267 : 1 : return list;
17268 : :
17269 : 17 : location_t loc = c_parser_peek_token (parser)->location;
17270 : 17 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
17271 : 17 : expr = convert_lvalue_to_rvalue (loc, expr, true, true);
17272 : 17 : t = c_objc_common_truthvalue_conversion (loc, expr.value);
17273 : 17 : t = c_fully_fold (t, false, NULL);
17274 : 34 : if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
17275 : 34 : || TREE_CODE (t) != INTEGER_CST)
17276 : : {
17277 : 1 : c_parser_error (parser, "expected constant logical expression");
17278 : 1 : return list;
17279 : : }
17280 : 16 : parens.skip_until_found_close (parser);
17281 : : }
17282 : : else
17283 : 9 : t = integer_one_node;
17284 : :
17285 : 25 : check_no_duplicate_clause (list, OMP_CLAUSE_INDIRECT, "indirect");
17286 : :
17287 : 25 : tree c = build_omp_clause (location, OMP_CLAUSE_INDIRECT);
17288 : 25 : OMP_CLAUSE_INDIRECT_EXPR (c) = t;
17289 : 25 : OMP_CLAUSE_CHAIN (c) = list;
17290 : :
17291 : 25 : return c;
17292 : : }
17293 : :
17294 : : /* OpenACC, OpenMP 2.5:
17295 : : if ( expression )
17296 : :
17297 : : OpenMP 4.5:
17298 : : if ( directive-name-modifier : expression )
17299 : :
17300 : : directive-name-modifier:
17301 : : parallel | task | taskloop | target data | target | target update
17302 : : | target enter data | target exit data
17303 : :
17304 : : OpenMP 5.0:
17305 : : directive-name-modifier:
17306 : : ... | simd | cancel */
17307 : :
17308 : : static tree
17309 : 883 : c_parser_omp_clause_if (c_parser *parser, tree list, bool is_omp)
17310 : : {
17311 : 883 : location_t location = c_parser_peek_token (parser)->location;
17312 : 883 : enum tree_code if_modifier = ERROR_MARK;
17313 : :
17314 : 883 : matching_parens parens;
17315 : 883 : if (!parens.require_open (parser))
17316 : : return list;
17317 : :
17318 : 1661 : if (is_omp && c_parser_next_token_is (parser, CPP_NAME))
17319 : : {
17320 : 637 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
17321 : 637 : int n = 2;
17322 : 637 : if (strcmp (p, "cancel") == 0)
17323 : : if_modifier = VOID_CST;
17324 : 622 : else if (strcmp (p, "parallel") == 0)
17325 : : if_modifier = OMP_PARALLEL;
17326 : 483 : else if (strcmp (p, "simd") == 0)
17327 : : if_modifier = OMP_SIMD;
17328 : 377 : else if (strcmp (p, "task") == 0)
17329 : : if_modifier = OMP_TASK;
17330 : 366 : else if (strcmp (p, "taskloop") == 0)
17331 : : if_modifier = OMP_TASKLOOP;
17332 : 315 : else if (strcmp (p, "target") == 0)
17333 : : {
17334 : 102 : if_modifier = OMP_TARGET;
17335 : 102 : if (c_parser_peek_2nd_token (parser)->type == CPP_NAME)
17336 : : {
17337 : 37 : p = IDENTIFIER_POINTER (c_parser_peek_2nd_token (parser)->value);
17338 : 37 : if (strcmp ("data", p) == 0)
17339 : : if_modifier = OMP_TARGET_DATA;
17340 : 29 : else if (strcmp ("update", p) == 0)
17341 : : if_modifier = OMP_TARGET_UPDATE;
17342 : 18 : else if (strcmp ("enter", p) == 0)
17343 : : if_modifier = OMP_TARGET_ENTER_DATA;
17344 : 10 : else if (strcmp ("exit", p) == 0)
17345 : : if_modifier = OMP_TARGET_EXIT_DATA;
17346 : 0 : if (if_modifier != OMP_TARGET)
17347 : : {
17348 : 37 : n = 3;
17349 : 37 : c_parser_consume_token (parser);
17350 : : }
17351 : : else
17352 : : {
17353 : 0 : location_t loc = c_parser_peek_2nd_token (parser)->location;
17354 : 0 : error_at (loc, "expected %<data%>, %<update%>, %<enter%> "
17355 : : "or %<exit%>");
17356 : 0 : if_modifier = ERROR_MARK;
17357 : : }
17358 : 0 : if (if_modifier == OMP_TARGET_ENTER_DATA
17359 : 37 : || if_modifier == OMP_TARGET_EXIT_DATA)
17360 : : {
17361 : 18 : if (c_parser_peek_2nd_token (parser)->type == CPP_NAME)
17362 : : {
17363 : 18 : p = IDENTIFIER_POINTER
17364 : : (c_parser_peek_2nd_token (parser)->value);
17365 : 18 : if (strcmp ("data", p) == 0)
17366 : 18 : n = 4;
17367 : : }
17368 : 18 : if (n == 4)
17369 : 18 : c_parser_consume_token (parser);
17370 : : else
17371 : : {
17372 : 0 : location_t loc
17373 : 0 : = c_parser_peek_2nd_token (parser)->location;
17374 : 0 : error_at (loc, "expected %<data%>");
17375 : 0 : if_modifier = ERROR_MARK;
17376 : : }
17377 : : }
17378 : : }
17379 : : }
17380 : 37 : if (if_modifier != ERROR_MARK)
17381 : : {
17382 : 424 : if (c_parser_peek_2nd_token (parser)->type == CPP_COLON)
17383 : : {
17384 : 423 : c_parser_consume_token (parser);
17385 : 423 : c_parser_consume_token (parser);
17386 : : }
17387 : : else
17388 : : {
17389 : 1 : if (n > 2)
17390 : : {
17391 : 0 : location_t loc = c_parser_peek_2nd_token (parser)->location;
17392 : 0 : error_at (loc, "expected %<:%>");
17393 : : }
17394 : : if_modifier = ERROR_MARK;
17395 : : }
17396 : : }
17397 : : }
17398 : :
17399 : 883 : location_t loc = c_parser_peek_token (parser)->location;
17400 : 883 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
17401 : 883 : expr = convert_lvalue_to_rvalue (loc, expr, true, true);
17402 : 883 : tree t = c_objc_common_truthvalue_conversion (loc, expr.value), c;
17403 : 883 : t = c_fully_fold (t, false, NULL);
17404 : 883 : parens.skip_until_found_close (parser);
17405 : :
17406 : 3979 : for (c = list; c ; c = OMP_CLAUSE_CHAIN (c))
17407 : 3136 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IF)
17408 : : {
17409 : 174 : if (if_modifier != ERROR_MARK
17410 : 174 : && OMP_CLAUSE_IF_MODIFIER (c) == if_modifier)
17411 : : {
17412 : 9 : const char *p = NULL;
17413 : 9 : switch (if_modifier)
17414 : : {
17415 : : case VOID_CST: p = "cancel"; break;
17416 : 1 : case OMP_PARALLEL: p = "parallel"; break;
17417 : 0 : case OMP_SIMD: p = "simd"; break;
17418 : 1 : case OMP_TASK: p = "task"; break;
17419 : 1 : case OMP_TASKLOOP: p = "taskloop"; break;
17420 : 1 : case OMP_TARGET_DATA: p = "target data"; break;
17421 : 1 : case OMP_TARGET: p = "target"; break;
17422 : 1 : case OMP_TARGET_UPDATE: p = "target update"; break;
17423 : 1 : case OMP_TARGET_ENTER_DATA: p = "target enter data"; break;
17424 : 1 : case OMP_TARGET_EXIT_DATA: p = "target exit data"; break;
17425 : 0 : default: gcc_unreachable ();
17426 : : }
17427 : 9 : error_at (location, "too many %<if%> clauses with %qs modifier",
17428 : : p);
17429 : 9 : return list;
17430 : : }
17431 : 165 : else if (OMP_CLAUSE_IF_MODIFIER (c) == if_modifier)
17432 : : {
17433 : 13 : if (!is_omp)
17434 : 1 : error_at (location, "too many %<if%> clauses");
17435 : : else
17436 : 12 : error_at (location, "too many %<if%> clauses without modifier");
17437 : 13 : return list;
17438 : : }
17439 : 152 : else if (if_modifier == ERROR_MARK
17440 : 152 : || OMP_CLAUSE_IF_MODIFIER (c) == ERROR_MARK)
17441 : : {
17442 : 18 : error_at (location, "if any %<if%> clause has modifier, then all "
17443 : : "%<if%> clauses have to use modifier");
17444 : 18 : return list;
17445 : : }
17446 : : }
17447 : :
17448 : 843 : c = build_omp_clause (location, OMP_CLAUSE_IF);
17449 : 843 : OMP_CLAUSE_IF_MODIFIER (c) = if_modifier;
17450 : 843 : OMP_CLAUSE_IF_EXPR (c) = t;
17451 : 843 : OMP_CLAUSE_CHAIN (c) = list;
17452 : 843 : return c;
17453 : : }
17454 : :
17455 : : /* OpenMP 2.5:
17456 : : lastprivate ( variable-list )
17457 : :
17458 : : OpenMP 5.0:
17459 : : lastprivate ( [ lastprivate-modifier : ] variable-list ) */
17460 : :
17461 : : static tree
17462 : 731 : c_parser_omp_clause_lastprivate (c_parser *parser, tree list)
17463 : : {
17464 : : /* The clauses location. */
17465 : 731 : location_t loc = c_parser_peek_token (parser)->location;
17466 : :
17467 : 731 : if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
17468 : : {
17469 : 731 : bool conditional = false;
17470 : 731 : if (c_parser_next_token_is (parser, CPP_NAME)
17471 : 731 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
17472 : : {
17473 : 107 : const char *p
17474 : 107 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
17475 : 107 : if (strcmp (p, "conditional") == 0)
17476 : : {
17477 : 107 : conditional = true;
17478 : 107 : c_parser_consume_token (parser);
17479 : 107 : c_parser_consume_token (parser);
17480 : : }
17481 : : }
17482 : 731 : tree nlist = c_parser_omp_variable_list (parser, loc,
17483 : : OMP_CLAUSE_LASTPRIVATE, list);
17484 : 731 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
17485 : 731 : if (conditional)
17486 : 246 : for (tree c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
17487 : 139 : OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c) = 1;
17488 : 731 : return nlist;
17489 : : }
17490 : : return list;
17491 : : }
17492 : :
17493 : : /* OpenMP 3.1:
17494 : : mergeable */
17495 : :
17496 : : static tree
17497 : 78 : c_parser_omp_clause_mergeable (c_parser *parser ATTRIBUTE_UNUSED, tree list)
17498 : : {
17499 : 78 : tree c;
17500 : :
17501 : : /* FIXME: Should we allow duplicates? */
17502 : 78 : check_no_duplicate_clause (list, OMP_CLAUSE_MERGEABLE, "mergeable");
17503 : :
17504 : 78 : c = build_omp_clause (c_parser_peek_token (parser)->location,
17505 : : OMP_CLAUSE_MERGEABLE);
17506 : 78 : OMP_CLAUSE_CHAIN (c) = list;
17507 : :
17508 : 78 : return c;
17509 : : }
17510 : :
17511 : : /* OpenMP 2.5:
17512 : : nowait */
17513 : :
17514 : : static tree
17515 : 391 : c_parser_omp_clause_nowait (c_parser *parser ATTRIBUTE_UNUSED, tree list)
17516 : : {
17517 : 391 : tree c;
17518 : 391 : location_t loc = c_parser_peek_token (parser)->location;
17519 : :
17520 : 391 : check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait");
17521 : :
17522 : 391 : c = build_omp_clause (loc, OMP_CLAUSE_NOWAIT);
17523 : 391 : OMP_CLAUSE_CHAIN (c) = list;
17524 : 391 : return c;
17525 : : }
17526 : :
17527 : : /* OpenMP 2.5:
17528 : : num_threads ( expression ) */
17529 : :
17530 : : static tree
17531 : 424 : c_parser_omp_clause_num_threads (c_parser *parser, tree list)
17532 : : {
17533 : 424 : location_t num_threads_loc = c_parser_peek_token (parser)->location;
17534 : 424 : matching_parens parens;
17535 : 424 : if (parens.require_open (parser))
17536 : : {
17537 : 424 : location_t expr_loc = c_parser_peek_token (parser)->location;
17538 : 424 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
17539 : 424 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
17540 : 424 : tree c, t = expr.value;
17541 : 424 : t = c_fully_fold (t, false, NULL);
17542 : :
17543 : 424 : parens.skip_until_found_close (parser);
17544 : :
17545 : 424 : if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
17546 : : {
17547 : 0 : c_parser_error (parser, "expected integer expression");
17548 : 0 : return list;
17549 : : }
17550 : :
17551 : : /* Attempt to statically determine when the number isn't positive. */
17552 : 424 : c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, t,
17553 : 424 : build_int_cst (TREE_TYPE (t), 0));
17554 : 424 : protected_set_expr_location (c, expr_loc);
17555 : 424 : if (c == boolean_true_node)
17556 : : {
17557 : 1 : warning_at (expr_loc, OPT_Wopenmp,
17558 : : "%<num_threads%> value must be positive");
17559 : 1 : t = integer_one_node;
17560 : : }
17561 : :
17562 : 424 : check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads");
17563 : :
17564 : 424 : c = build_omp_clause (num_threads_loc, OMP_CLAUSE_NUM_THREADS);
17565 : 424 : OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
17566 : 424 : OMP_CLAUSE_CHAIN (c) = list;
17567 : 424 : list = c;
17568 : : }
17569 : :
17570 : : return list;
17571 : : }
17572 : :
17573 : : /* OpenMP 4.5:
17574 : : num_tasks ( expression )
17575 : :
17576 : : OpenMP 5.1:
17577 : : num_tasks ( strict : expression ) */
17578 : :
17579 : : static tree
17580 : 49 : c_parser_omp_clause_num_tasks (c_parser *parser, tree list)
17581 : : {
17582 : 49 : location_t num_tasks_loc = c_parser_peek_token (parser)->location;
17583 : 49 : matching_parens parens;
17584 : 49 : if (parens.require_open (parser))
17585 : : {
17586 : 49 : bool strict = false;
17587 : 49 : if (c_parser_next_token_is (parser, CPP_NAME)
17588 : 39 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON
17589 : 50 : && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser)->value),
17590 : : "strict") == 0)
17591 : : {
17592 : 1 : strict = true;
17593 : 1 : c_parser_consume_token (parser);
17594 : 1 : c_parser_consume_token (parser);
17595 : : }
17596 : :
17597 : 49 : location_t expr_loc = c_parser_peek_token (parser)->location;
17598 : 49 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
17599 : 49 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
17600 : 49 : tree c, t = expr.value;
17601 : 49 : t = c_fully_fold (t, false, NULL);
17602 : :
17603 : 49 : parens.skip_until_found_close (parser);
17604 : :
17605 : 49 : if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
17606 : : {
17607 : 0 : c_parser_error (parser, "expected integer expression");
17608 : 0 : return list;
17609 : : }
17610 : :
17611 : : /* Attempt to statically determine when the number isn't positive. */
17612 : 49 : c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, t,
17613 : 49 : build_int_cst (TREE_TYPE (t), 0));
17614 : 49 : if (CAN_HAVE_LOCATION_P (c))
17615 : 39 : SET_EXPR_LOCATION (c, expr_loc);
17616 : 49 : if (c == boolean_true_node)
17617 : : {
17618 : 0 : warning_at (expr_loc, OPT_Wopenmp,
17619 : : "%<num_tasks%> value must be positive");
17620 : 0 : t = integer_one_node;
17621 : : }
17622 : :
17623 : 49 : check_no_duplicate_clause (list, OMP_CLAUSE_NUM_TASKS, "num_tasks");
17624 : :
17625 : 49 : c = build_omp_clause (num_tasks_loc, OMP_CLAUSE_NUM_TASKS);
17626 : 49 : OMP_CLAUSE_NUM_TASKS_EXPR (c) = t;
17627 : 49 : OMP_CLAUSE_NUM_TASKS_STRICT (c) = strict;
17628 : 49 : OMP_CLAUSE_CHAIN (c) = list;
17629 : 49 : list = c;
17630 : : }
17631 : :
17632 : : return list;
17633 : : }
17634 : :
17635 : : /* OpenMP 4.5:
17636 : : grainsize ( expression )
17637 : :
17638 : : OpenMP 5.1:
17639 : : grainsize ( strict : expression ) */
17640 : :
17641 : : static tree
17642 : 62 : c_parser_omp_clause_grainsize (c_parser *parser, tree list)
17643 : : {
17644 : 62 : location_t grainsize_loc = c_parser_peek_token (parser)->location;
17645 : 62 : matching_parens parens;
17646 : 62 : if (parens.require_open (parser))
17647 : : {
17648 : 62 : bool strict = false;
17649 : 62 : if (c_parser_next_token_is (parser, CPP_NAME)
17650 : 47 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON
17651 : 63 : && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser)->value),
17652 : : "strict") == 0)
17653 : : {
17654 : 1 : strict = true;
17655 : 1 : c_parser_consume_token (parser);
17656 : 1 : c_parser_consume_token (parser);
17657 : : }
17658 : :
17659 : 62 : location_t expr_loc = c_parser_peek_token (parser)->location;
17660 : 62 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
17661 : 62 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
17662 : 62 : tree c, t = expr.value;
17663 : 62 : t = c_fully_fold (t, false, NULL);
17664 : :
17665 : 62 : parens.skip_until_found_close (parser);
17666 : :
17667 : 62 : if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
17668 : : {
17669 : 0 : c_parser_error (parser, "expected integer expression");
17670 : 0 : return list;
17671 : : }
17672 : :
17673 : : /* Attempt to statically determine when the number isn't positive. */
17674 : 62 : c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, t,
17675 : 62 : build_int_cst (TREE_TYPE (t), 0));
17676 : 62 : if (CAN_HAVE_LOCATION_P (c))
17677 : 47 : SET_EXPR_LOCATION (c, expr_loc);
17678 : 62 : if (c == boolean_true_node)
17679 : : {
17680 : 0 : warning_at (expr_loc, OPT_Wopenmp,
17681 : : "%<grainsize%> value must be positive");
17682 : 0 : t = integer_one_node;
17683 : : }
17684 : :
17685 : 62 : check_no_duplicate_clause (list, OMP_CLAUSE_GRAINSIZE, "grainsize");
17686 : :
17687 : 62 : c = build_omp_clause (grainsize_loc, OMP_CLAUSE_GRAINSIZE);
17688 : 62 : OMP_CLAUSE_GRAINSIZE_EXPR (c) = t;
17689 : 62 : OMP_CLAUSE_GRAINSIZE_STRICT (c) = strict;
17690 : 62 : OMP_CLAUSE_CHAIN (c) = list;
17691 : 62 : list = c;
17692 : : }
17693 : :
17694 : : return list;
17695 : : }
17696 : :
17697 : : /* OpenMP 4.5:
17698 : : priority ( expression ) */
17699 : :
17700 : : static tree
17701 : 97 : c_parser_omp_clause_priority (c_parser *parser, tree list)
17702 : : {
17703 : 97 : location_t priority_loc = c_parser_peek_token (parser)->location;
17704 : 97 : matching_parens parens;
17705 : 97 : if (parens.require_open (parser))
17706 : : {
17707 : 97 : location_t expr_loc = c_parser_peek_token (parser)->location;
17708 : 97 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
17709 : 97 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
17710 : 97 : tree c, t = expr.value;
17711 : 97 : t = c_fully_fold (t, false, NULL);
17712 : :
17713 : 97 : parens.skip_until_found_close (parser);
17714 : :
17715 : 97 : if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
17716 : : {
17717 : 0 : c_parser_error (parser, "expected integer expression");
17718 : 0 : return list;
17719 : : }
17720 : :
17721 : : /* Attempt to statically determine when the number isn't
17722 : : non-negative. */
17723 : 97 : c = fold_build2_loc (expr_loc, LT_EXPR, boolean_type_node, t,
17724 : 97 : build_int_cst (TREE_TYPE (t), 0));
17725 : 97 : if (CAN_HAVE_LOCATION_P (c))
17726 : 86 : SET_EXPR_LOCATION (c, expr_loc);
17727 : 97 : if (c == boolean_true_node)
17728 : : {
17729 : 0 : warning_at (expr_loc, OPT_Wopenmp,
17730 : : "%<priority%> value must be non-negative");
17731 : 0 : t = integer_one_node;
17732 : : }
17733 : :
17734 : 97 : check_no_duplicate_clause (list, OMP_CLAUSE_PRIORITY, "priority");
17735 : :
17736 : 97 : c = build_omp_clause (priority_loc, OMP_CLAUSE_PRIORITY);
17737 : 97 : OMP_CLAUSE_PRIORITY_EXPR (c) = t;
17738 : 97 : OMP_CLAUSE_CHAIN (c) = list;
17739 : 97 : list = c;
17740 : : }
17741 : :
17742 : : return list;
17743 : : }
17744 : :
17745 : : /* OpenMP 4.5:
17746 : : hint ( expression ) */
17747 : :
17748 : : static tree
17749 : 58 : c_parser_omp_clause_hint (c_parser *parser, tree list)
17750 : : {
17751 : 58 : location_t hint_loc = c_parser_peek_token (parser)->location;
17752 : 58 : matching_parens parens;
17753 : 58 : if (parens.require_open (parser))
17754 : : {
17755 : 58 : location_t expr_loc = c_parser_peek_token (parser)->location;
17756 : 58 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
17757 : 58 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
17758 : 58 : tree c, t = expr.value;
17759 : 58 : t = c_fully_fold (t, false, NULL);
17760 : 116 : if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
17761 : 57 : || TREE_CODE (t) != INTEGER_CST
17762 : 111 : || tree_int_cst_sgn (t) == -1)
17763 : : {
17764 : 6 : c_parser_error (parser, "expected constant integer expression "
17765 : : "with valid sync-hint value");
17766 : 6 : return list;
17767 : : }
17768 : 52 : parens.skip_until_found_close (parser);
17769 : 52 : check_no_duplicate_clause (list, OMP_CLAUSE_HINT, "hint");
17770 : :
17771 : 52 : c = build_omp_clause (hint_loc, OMP_CLAUSE_HINT);
17772 : 52 : OMP_CLAUSE_HINT_EXPR (c) = t;
17773 : 52 : OMP_CLAUSE_CHAIN (c) = list;
17774 : 52 : list = c;
17775 : : }
17776 : :
17777 : : return list;
17778 : : }
17779 : :
17780 : : /* OpenMP 5.1:
17781 : : filter ( integer-expression ) */
17782 : :
17783 : : static tree
17784 : 62 : c_parser_omp_clause_filter (c_parser *parser, tree list)
17785 : : {
17786 : 62 : location_t hint_loc = c_parser_peek_token (parser)->location;
17787 : 62 : matching_parens parens;
17788 : 62 : if (parens.require_open (parser))
17789 : : {
17790 : 62 : location_t expr_loc = c_parser_peek_token (parser)->location;
17791 : 62 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
17792 : 62 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
17793 : 62 : tree c, t = expr.value;
17794 : 62 : t = c_fully_fold (t, false, NULL);
17795 : 62 : if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
17796 : : {
17797 : 2 : c_parser_error (parser, "expected integer expression");
17798 : 2 : return list;
17799 : : }
17800 : 60 : parens.skip_until_found_close (parser);
17801 : 60 : check_no_duplicate_clause (list, OMP_CLAUSE_FILTER, "filter");
17802 : :
17803 : 60 : c = build_omp_clause (hint_loc, OMP_CLAUSE_FILTER);
17804 : 60 : OMP_CLAUSE_FILTER_EXPR (c) = t;
17805 : 60 : OMP_CLAUSE_CHAIN (c) = list;
17806 : 60 : list = c;
17807 : : }
17808 : :
17809 : : return list;
17810 : : }
17811 : :
17812 : : /* OpenMP 4.5:
17813 : : defaultmap ( tofrom : scalar )
17814 : :
17815 : : OpenMP 5.0:
17816 : : defaultmap ( implicit-behavior [ : variable-category ] ) */
17817 : :
17818 : : static tree
17819 : 239 : c_parser_omp_clause_defaultmap (c_parser *parser, tree list)
17820 : : {
17821 : 239 : location_t loc = c_parser_peek_token (parser)->location;
17822 : 239 : tree c;
17823 : 239 : const char *p;
17824 : 239 : enum omp_clause_defaultmap_kind behavior = OMP_CLAUSE_DEFAULTMAP_DEFAULT;
17825 : 239 : enum omp_clause_defaultmap_kind category
17826 : : = OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED;
17827 : :
17828 : 239 : matching_parens parens;
17829 : 239 : if (!parens.require_open (parser))
17830 : : return list;
17831 : 239 : if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
17832 : : p = "default";
17833 : 231 : else if (!c_parser_next_token_is (parser, CPP_NAME))
17834 : : {
17835 : 2 : invalid_behavior:
17836 : 3 : c_parser_error (parser, "expected %<alloc%>, %<to%>, %<from%>, "
17837 : : "%<tofrom%>, %<firstprivate%>, %<none%> "
17838 : : "or %<default%>");
17839 : 3 : goto out_err;
17840 : : }
17841 : : else
17842 : 229 : p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
17843 : :
17844 : 237 : switch (p[0])
17845 : : {
17846 : 7 : case 'a':
17847 : 7 : if (strcmp ("alloc", p) == 0)
17848 : : behavior = OMP_CLAUSE_DEFAULTMAP_ALLOC;
17849 : : else
17850 : 0 : goto invalid_behavior;
17851 : : break;
17852 : :
17853 : 8 : case 'd':
17854 : 8 : if (strcmp ("default", p) == 0)
17855 : : behavior = OMP_CLAUSE_DEFAULTMAP_DEFAULT;
17856 : : else
17857 : 0 : goto invalid_behavior;
17858 : : break;
17859 : :
17860 : 27 : case 'f':
17861 : 27 : if (strcmp ("firstprivate", p) == 0)
17862 : : behavior = OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE;
17863 : 3 : else if (strcmp ("from", p) == 0)
17864 : : behavior = OMP_CLAUSE_DEFAULTMAP_FROM;
17865 : : else
17866 : 0 : goto invalid_behavior;
17867 : : break;
17868 : :
17869 : 101 : case 'n':
17870 : 101 : if (strcmp ("none", p) == 0)
17871 : : behavior = OMP_CLAUSE_DEFAULTMAP_NONE;
17872 : : else
17873 : 0 : goto invalid_behavior;
17874 : : break;
17875 : :
17876 : 4 : case 'p':
17877 : 4 : if (strcmp ("present", p) == 0)
17878 : : behavior = OMP_CLAUSE_DEFAULTMAP_PRESENT;
17879 : : else
17880 : 0 : goto invalid_behavior;
17881 : : break;
17882 : :
17883 : 89 : case 't':
17884 : 89 : if (strcmp ("tofrom", p) == 0)
17885 : : behavior = OMP_CLAUSE_DEFAULTMAP_TOFROM;
17886 : 4 : else if (strcmp ("to", p) == 0)
17887 : : behavior = OMP_CLAUSE_DEFAULTMAP_TO;
17888 : : else
17889 : 0 : goto invalid_behavior;
17890 : : break;
17891 : :
17892 : 1 : default:
17893 : 1 : goto invalid_behavior;
17894 : : }
17895 : 236 : c_parser_consume_token (parser);
17896 : :
17897 : 236 : if (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
17898 : : {
17899 : 132 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
17900 : 3 : goto out_err;
17901 : 129 : if (!c_parser_next_token_is (parser, CPP_NAME))
17902 : : {
17903 : 1 : invalid_category:
17904 : 2 : c_parser_error (parser, "expected %<scalar%>, %<aggregate%>, "
17905 : : "%<pointer%> or %<all%>");
17906 : 2 : goto out_err;
17907 : : }
17908 : 128 : p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
17909 : 128 : switch (p[0])
17910 : : {
17911 : 22 : case 'a':
17912 : 22 : if (strcmp ("aggregate", p) == 0)
17913 : : category = OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE;
17914 : 8 : else if (strcmp ("all", p) == 0)
17915 : : category = OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL;
17916 : : else
17917 : 0 : goto invalid_category;
17918 : : break;
17919 : :
17920 : 15 : case 'p':
17921 : 15 : if (strcmp ("pointer", p) == 0)
17922 : : category = OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER;
17923 : : else
17924 : 0 : goto invalid_category;
17925 : : break;
17926 : :
17927 : 90 : case 's':
17928 : 90 : if (strcmp ("scalar", p) == 0)
17929 : : category = OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR;
17930 : : else
17931 : 0 : goto invalid_category;
17932 : : break;
17933 : :
17934 : 1 : default:
17935 : 1 : goto invalid_category;
17936 : : }
17937 : :
17938 : 127 : c_parser_consume_token (parser);
17939 : : }
17940 : 231 : parens.skip_until_found_close (parser);
17941 : :
17942 : 961 : for (c = list; c ; c = OMP_CLAUSE_CHAIN (c))
17943 : 512 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEFAULTMAP
17944 : 512 : && (category == OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
17945 : : || category == OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL
17946 : 32 : || OMP_CLAUSE_DEFAULTMAP_CATEGORY (c) == category
17947 : 31 : || (OMP_CLAUSE_DEFAULTMAP_CATEGORY (c)
17948 : : == OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED)
17949 : 29 : || (OMP_CLAUSE_DEFAULTMAP_CATEGORY (c)
17950 : : == OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL)))
17951 : : {
17952 : 13 : enum omp_clause_defaultmap_kind cat = category;
17953 : 13 : location_t loc = OMP_CLAUSE_LOCATION (c);
17954 : 13 : if (cat == OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
17955 : 13 : || (cat == OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL
17956 : 3 : && (OMP_CLAUSE_DEFAULTMAP_CATEGORY (c)
17957 : : != OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED)))
17958 : 8 : cat = OMP_CLAUSE_DEFAULTMAP_CATEGORY (c);
17959 : 13 : p = NULL;
17960 : 13 : switch (cat)
17961 : : {
17962 : : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED:
17963 : : p = NULL;
17964 : : break;
17965 : 3 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL:
17966 : 3 : p = "all";
17967 : 3 : break;
17968 : 2 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE:
17969 : 2 : p = "aggregate";
17970 : 2 : break;
17971 : 3 : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER:
17972 : 3 : p = "pointer";
17973 : 3 : break;
17974 : : case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR:
17975 : : p = "scalar";
17976 : : break;
17977 : 0 : default:
17978 : 0 : gcc_unreachable ();
17979 : : }
17980 : 8 : if (p)
17981 : 10 : error_at (loc, "too many %<defaultmap%> clauses with %qs category",
17982 : : p);
17983 : : else
17984 : 3 : error_at (loc, "too many %<defaultmap%> clauses with unspecified "
17985 : : "category");
17986 : : break;
17987 : : }
17988 : :
17989 : 231 : c = build_omp_clause (loc, OMP_CLAUSE_DEFAULTMAP);
17990 : 231 : OMP_CLAUSE_DEFAULTMAP_SET_KIND (c, behavior, category);
17991 : 231 : OMP_CLAUSE_CHAIN (c) = list;
17992 : 231 : return c;
17993 : :
17994 : 8 : out_err:
17995 : 8 : parens.skip_until_found_close (parser);
17996 : 8 : return list;
17997 : : }
17998 : :
17999 : : /* OpenACC 2.0:
18000 : : use_device ( variable-list )
18001 : :
18002 : : OpenMP 4.5:
18003 : : use_device_ptr ( variable-list ) */
18004 : :
18005 : : static tree
18006 : 31 : c_parser_omp_clause_use_device_ptr (c_parser *parser, tree list)
18007 : : {
18008 : 0 : return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_USE_DEVICE_PTR,
18009 : 0 : list);
18010 : : }
18011 : :
18012 : : /* OpenMP 5.0:
18013 : : use_device_addr ( variable-list ) */
18014 : :
18015 : : static tree
18016 : 35 : c_parser_omp_clause_use_device_addr (c_parser *parser, tree list)
18017 : : {
18018 : 0 : return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_USE_DEVICE_ADDR,
18019 : 0 : list);
18020 : : }
18021 : :
18022 : : /* OpenMP 5.1:
18023 : : has_device_addr ( variable-list ) */
18024 : :
18025 : : static tree
18026 : 87 : c_parser_omp_clause_has_device_addr (c_parser *parser, tree list)
18027 : : {
18028 : 0 : return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_HAS_DEVICE_ADDR,
18029 : 0 : list);
18030 : : }
18031 : :
18032 : : /* OpenMP 4.5:
18033 : : is_device_ptr ( variable-list ) */
18034 : :
18035 : : static tree
18036 : 114 : c_parser_omp_clause_is_device_ptr (c_parser *parser, tree list)
18037 : : {
18038 : 0 : return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_IS_DEVICE_PTR, list);
18039 : : }
18040 : :
18041 : : /* OpenACC:
18042 : : num_gangs ( expression )
18043 : : num_workers ( expression )
18044 : : vector_length ( expression ) */
18045 : :
18046 : : static tree
18047 : 732 : c_parser_oacc_single_int_clause (c_parser *parser, omp_clause_code code,
18048 : : tree list)
18049 : : {
18050 : 732 : location_t loc = c_parser_peek_token (parser)->location;
18051 : :
18052 : 732 : matching_parens parens;
18053 : 732 : if (!parens.require_open (parser))
18054 : : return list;
18055 : :
18056 : 726 : location_t expr_loc = c_parser_peek_token (parser)->location;
18057 : 726 : c_expr expr = c_parser_expression (parser);
18058 : 726 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
18059 : 726 : tree c, t = expr.value;
18060 : 726 : t = c_fully_fold (t, false, NULL);
18061 : :
18062 : 726 : parens.skip_until_found_close (parser);
18063 : :
18064 : 726 : if (t == error_mark_node)
18065 : : return list;
18066 : 702 : else if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
18067 : : {
18068 : 16 : error_at (expr_loc, "%qs expression must be integral",
18069 : 16 : omp_clause_code_name[code]);
18070 : 16 : return list;
18071 : : }
18072 : :
18073 : : /* Attempt to statically determine when the number isn't positive. */
18074 : 686 : c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, t,
18075 : 686 : build_int_cst (TREE_TYPE (t), 0));
18076 : 686 : protected_set_expr_location (c, expr_loc);
18077 : 686 : if (c == boolean_true_node)
18078 : : {
18079 : 36 : warning_at (expr_loc, 0,
18080 : : "%qs value must be positive",
18081 : 18 : omp_clause_code_name[code]);
18082 : 18 : t = integer_one_node;
18083 : : }
18084 : :
18085 : 686 : check_no_duplicate_clause (list, code, omp_clause_code_name[code]);
18086 : :
18087 : 686 : c = build_omp_clause (loc, code);
18088 : 686 : OMP_CLAUSE_OPERAND (c, 0) = t;
18089 : 686 : OMP_CLAUSE_CHAIN (c) = list;
18090 : 686 : return c;
18091 : : }
18092 : :
18093 : : /* OpenACC:
18094 : :
18095 : : gang [( gang-arg-list )]
18096 : : worker [( [num:] int-expr )]
18097 : : vector [( [length:] int-expr )]
18098 : :
18099 : : where gang-arg is one of:
18100 : :
18101 : : [num:] int-expr
18102 : : static: size-expr
18103 : :
18104 : : and size-expr may be:
18105 : :
18106 : : *
18107 : : int-expr
18108 : : */
18109 : :
18110 : : static tree
18111 : 1560 : c_parser_oacc_shape_clause (c_parser *parser, location_t loc,
18112 : : omp_clause_code kind,
18113 : : const char *str, tree list)
18114 : : {
18115 : 1560 : const char *id = "num";
18116 : 1560 : tree ops[2] = { NULL_TREE, NULL_TREE }, c;
18117 : :
18118 : 1560 : if (kind == OMP_CLAUSE_VECTOR)
18119 : 518 : id = "length";
18120 : :
18121 : 1560 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
18122 : : {
18123 : 246 : c_parser_consume_token (parser);
18124 : :
18125 : 276 : do
18126 : : {
18127 : 261 : c_token *next = c_parser_peek_token (parser);
18128 : 261 : int idx = 0;
18129 : :
18130 : : /* Gang static argument. */
18131 : 261 : if (kind == OMP_CLAUSE_GANG
18132 : 403 : && c_parser_next_token_is_keyword (parser, RID_STATIC))
18133 : : {
18134 : 70 : c_parser_consume_token (parser);
18135 : :
18136 : 70 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
18137 : 12 : goto cleanup_error;
18138 : :
18139 : 70 : idx = 1;
18140 : 70 : if (ops[idx] != NULL_TREE)
18141 : : {
18142 : 0 : c_parser_error (parser, "too many %<static%> arguments");
18143 : 0 : goto cleanup_error;
18144 : : }
18145 : :
18146 : : /* Check for the '*' argument. */
18147 : 70 : if (c_parser_next_token_is (parser, CPP_MULT)
18148 : 70 : && (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
18149 : 30 : || c_parser_peek_2nd_token (parser)->type
18150 : : == CPP_CLOSE_PAREN))
18151 : : {
18152 : 29 : c_parser_consume_token (parser);
18153 : 29 : ops[idx] = integer_minus_one_node;
18154 : :
18155 : 29 : if (c_parser_next_token_is (parser, CPP_COMMA))
18156 : : {
18157 : 1 : c_parser_consume_token (parser);
18158 : 1 : continue;
18159 : : }
18160 : : else
18161 : : break;
18162 : : }
18163 : : }
18164 : : /* Worker num: argument and vector length: arguments. */
18165 : 191 : else if (c_parser_next_token_is (parser, CPP_NAME)
18166 : 149 : && strcmp (id, IDENTIFIER_POINTER (next->value)) == 0
18167 : 324 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
18168 : : {
18169 : 127 : c_parser_consume_token (parser); /* id */
18170 : 127 : c_parser_consume_token (parser); /* ':' */
18171 : : }
18172 : :
18173 : : /* Now collect the actual argument. */
18174 : 232 : if (ops[idx] != NULL_TREE)
18175 : : {
18176 : 5 : c_parser_error (parser, "unexpected argument");
18177 : 5 : goto cleanup_error;
18178 : : }
18179 : :
18180 : 227 : location_t expr_loc = c_parser_peek_token (parser)->location;
18181 : 227 : c_expr cexpr = c_parser_expr_no_commas (parser, NULL);
18182 : 227 : cexpr = convert_lvalue_to_rvalue (expr_loc, cexpr, false, true);
18183 : 227 : tree expr = cexpr.value;
18184 : 227 : if (expr == error_mark_node)
18185 : 7 : goto cleanup_error;
18186 : :
18187 : 220 : expr = c_fully_fold (expr, false, NULL);
18188 : :
18189 : : /* Attempt to statically determine when the number isn't a
18190 : : positive integer. */
18191 : :
18192 : 220 : if (!INTEGRAL_TYPE_P (TREE_TYPE (expr)))
18193 : : {
18194 : 14 : c_parser_error (parser, "expected integer expression");
18195 : 14 : return list;
18196 : : }
18197 : :
18198 : 206 : tree c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, expr,
18199 : 206 : build_int_cst (TREE_TYPE (expr), 0));
18200 : 206 : if (c == boolean_true_node)
18201 : : {
18202 : 1 : warning_at (loc, 0,
18203 : : "%qs value must be positive", str);
18204 : 1 : expr = integer_one_node;
18205 : : }
18206 : :
18207 : 206 : ops[idx] = expr;
18208 : :
18209 : 220 : if (kind == OMP_CLAUSE_GANG
18210 : 305 : && c_parser_next_token_is (parser, CPP_COMMA))
18211 : : {
18212 : 14 : c_parser_consume_token (parser);
18213 : 14 : continue;
18214 : : }
18215 : : break;
18216 : 15 : }
18217 : : while (1);
18218 : :
18219 : 220 : if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
18220 : 7 : goto cleanup_error;
18221 : : }
18222 : :
18223 : 1527 : check_no_duplicate_clause (list, kind, str);
18224 : :
18225 : 1527 : c = build_omp_clause (loc, kind);
18226 : :
18227 : 1527 : if (ops[1])
18228 : 67 : OMP_CLAUSE_OPERAND (c, 1) = ops[1];
18229 : :
18230 : 1527 : OMP_CLAUSE_OPERAND (c, 0) = ops[0];
18231 : 1527 : OMP_CLAUSE_CHAIN (c) = list;
18232 : :
18233 : 1527 : return c;
18234 : :
18235 : 19 : cleanup_error:
18236 : 19 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
18237 : 19 : return list;
18238 : : }
18239 : :
18240 : : /* OpenACC 2.5:
18241 : : auto
18242 : : finalize
18243 : : independent
18244 : : nohost
18245 : : seq */
18246 : :
18247 : : static tree
18248 : 487 : c_parser_oacc_simple_clause (location_t loc, enum omp_clause_code code,
18249 : : tree list)
18250 : : {
18251 : 487 : check_no_duplicate_clause (list, code, omp_clause_code_name[code]);
18252 : :
18253 : 487 : tree c = build_omp_clause (loc, code);
18254 : 487 : OMP_CLAUSE_CHAIN (c) = list;
18255 : :
18256 : 487 : return c;
18257 : : }
18258 : :
18259 : : /* OpenACC:
18260 : : async [( int-expr )] */
18261 : :
18262 : : static tree
18263 : 240 : c_parser_oacc_clause_async (c_parser *parser, tree list)
18264 : : {
18265 : 240 : tree c, t;
18266 : 240 : location_t loc = c_parser_peek_token (parser)->location;
18267 : :
18268 : 240 : t = build_int_cst (integer_type_node, GOMP_ASYNC_NOVAL);
18269 : :
18270 : 240 : if (c_parser_peek_token (parser)->type == CPP_OPEN_PAREN)
18271 : : {
18272 : 187 : c_parser_consume_token (parser);
18273 : :
18274 : 187 : t = c_parser_expr_no_commas (parser, NULL).value;
18275 : 187 : if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
18276 : 9 : c_parser_error (parser, "expected integer expression");
18277 : 178 : else if (t == error_mark_node
18278 : 178 : || !c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
18279 : 14 : return list;
18280 : : }
18281 : : else
18282 : 53 : t = c_fully_fold (t, false, NULL);
18283 : :
18284 : 226 : check_no_duplicate_clause (list, OMP_CLAUSE_ASYNC, "async");
18285 : :
18286 : 226 : c = build_omp_clause (loc, OMP_CLAUSE_ASYNC);
18287 : 226 : OMP_CLAUSE_ASYNC_EXPR (c) = t;
18288 : 226 : OMP_CLAUSE_CHAIN (c) = list;
18289 : 226 : list = c;
18290 : :
18291 : 226 : return list;
18292 : : }
18293 : :
18294 : : /* OpenACC 2.0:
18295 : : tile ( size-expr-list ) */
18296 : :
18297 : : static tree
18298 : 123 : c_parser_oacc_clause_tile (c_parser *parser, tree list)
18299 : : {
18300 : 123 : tree c, expr = error_mark_node;
18301 : 123 : location_t loc;
18302 : 123 : tree tile = NULL_TREE;
18303 : :
18304 : 123 : check_no_duplicate_clause (list, OMP_CLAUSE_TILE, "tile");
18305 : 123 : check_no_duplicate_clause (list, OMP_CLAUSE_COLLAPSE, "collapse");
18306 : :
18307 : 123 : loc = c_parser_peek_token (parser)->location;
18308 : 123 : if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
18309 : : return list;
18310 : :
18311 : 163 : do
18312 : : {
18313 : 163 : if (tile && !c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
18314 : : return list;
18315 : :
18316 : 163 : if (c_parser_next_token_is (parser, CPP_MULT)
18317 : 163 : && (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
18318 : 53 : || c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_PAREN))
18319 : : {
18320 : 60 : c_parser_consume_token (parser);
18321 : 60 : expr = integer_zero_node;
18322 : : }
18323 : : else
18324 : : {
18325 : 103 : location_t expr_loc = c_parser_peek_token (parser)->location;
18326 : 103 : c_expr cexpr = c_parser_expr_no_commas (parser, NULL);
18327 : 103 : cexpr = convert_lvalue_to_rvalue (expr_loc, cexpr, false, true);
18328 : 103 : expr = cexpr.value;
18329 : :
18330 : 103 : if (expr == error_mark_node)
18331 : : {
18332 : 7 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
18333 : : "expected %<)%>");
18334 : 7 : return list;
18335 : : }
18336 : :
18337 : 96 : expr = c_fully_fold (expr, false, NULL);
18338 : :
18339 : 192 : if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
18340 : 95 : || !tree_fits_shwi_p (expr)
18341 : 183 : || tree_to_shwi (expr) <= 0)
18342 : : {
18343 : 16 : error_at (expr_loc, "%<tile%> argument needs positive"
18344 : : " integral constant");
18345 : 16 : expr = integer_zero_node;
18346 : : }
18347 : : }
18348 : :
18349 : 156 : tile = tree_cons (NULL_TREE, expr, tile);
18350 : : }
18351 : 156 : while (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN));
18352 : :
18353 : : /* Consume the trailing ')'. */
18354 : 111 : c_parser_consume_token (parser);
18355 : :
18356 : 111 : c = build_omp_clause (loc, OMP_CLAUSE_TILE);
18357 : 111 : tile = nreverse (tile);
18358 : 111 : OMP_CLAUSE_TILE_LIST (c) = tile;
18359 : 111 : OMP_CLAUSE_CHAIN (c) = list;
18360 : 111 : return c;
18361 : : }
18362 : :
18363 : : /* OpenACC:
18364 : : wait [( int-expr-list )] */
18365 : :
18366 : : static tree
18367 : 89 : c_parser_oacc_clause_wait (c_parser *parser, tree list)
18368 : : {
18369 : 89 : location_t clause_loc = c_parser_peek_token (parser)->location;
18370 : :
18371 : 89 : if (c_parser_peek_token (parser)->type == CPP_OPEN_PAREN)
18372 : 74 : list = c_parser_oacc_wait_list (parser, clause_loc, list);
18373 : : else
18374 : : {
18375 : 15 : tree c = build_omp_clause (clause_loc, OMP_CLAUSE_WAIT);
18376 : :
18377 : 15 : OMP_CLAUSE_DECL (c) = build_int_cst (integer_type_node, GOMP_ASYNC_NOVAL);
18378 : 15 : OMP_CLAUSE_CHAIN (c) = list;
18379 : 15 : list = c;
18380 : : }
18381 : :
18382 : 89 : return list;
18383 : : }
18384 : :
18385 : : /* OpenACC 2.7:
18386 : : self [( expression )] */
18387 : :
18388 : : static tree
18389 : 48 : c_parser_oacc_compute_clause_self (c_parser *parser, tree list)
18390 : : {
18391 : 48 : tree t;
18392 : 48 : location_t location = c_parser_peek_token (parser)->location;
18393 : 48 : if (c_parser_peek_token (parser)->type == CPP_OPEN_PAREN)
18394 : : {
18395 : 42 : matching_parens parens;
18396 : 42 : parens.consume_open (parser);
18397 : :
18398 : 42 : location_t loc = c_parser_peek_token (parser)->location;
18399 : 42 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
18400 : 42 : expr = convert_lvalue_to_rvalue (loc, expr, true, true);
18401 : 42 : t = c_objc_common_truthvalue_conversion (loc, expr.value);
18402 : 42 : t = c_fully_fold (t, false, NULL);
18403 : 42 : parens.skip_until_found_close (parser);
18404 : : }
18405 : : else
18406 : 6 : t = truthvalue_true_node;
18407 : :
18408 : 78 : for (tree c = list; c; c = OMP_CLAUSE_CHAIN (c))
18409 : 36 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SELF)
18410 : : {
18411 : 6 : error_at (location, "too many %<self%> clauses");
18412 : 6 : return list;
18413 : : }
18414 : :
18415 : 42 : tree c = build_omp_clause (location, OMP_CLAUSE_SELF);
18416 : 42 : OMP_CLAUSE_SELF_EXPR (c) = t;
18417 : 42 : OMP_CLAUSE_CHAIN (c) = list;
18418 : 42 : return c;
18419 : : }
18420 : :
18421 : : /* OpenMP 5.0:
18422 : : order ( concurrent )
18423 : :
18424 : : OpenMP 5.1:
18425 : : order ( order-modifier : concurrent )
18426 : :
18427 : : order-modifier:
18428 : : reproducible
18429 : : unconstrained */
18430 : :
18431 : : static tree
18432 : 375 : c_parser_omp_clause_order (c_parser *parser, tree list)
18433 : : {
18434 : 375 : location_t loc = c_parser_peek_token (parser)->location;
18435 : 375 : tree c;
18436 : 375 : const char *p;
18437 : 375 : bool unconstrained = false;
18438 : 375 : bool reproducible = false;
18439 : :
18440 : 375 : matching_parens parens;
18441 : 375 : if (!parens.require_open (parser))
18442 : : return list;
18443 : 373 : if (c_parser_next_token_is (parser, CPP_NAME)
18444 : 373 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
18445 : : {
18446 : 107 : p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
18447 : 107 : if (strcmp (p, "unconstrained") == 0)
18448 : : unconstrained = true;
18449 : 56 : else if (strcmp (p, "reproducible") == 0)
18450 : : reproducible = true;
18451 : : else
18452 : : {
18453 : 1 : c_parser_error (parser, "expected %<reproducible%> or "
18454 : : "%<unconstrained%>");
18455 : 1 : goto out_err;
18456 : : }
18457 : 106 : c_parser_consume_token (parser);
18458 : 106 : c_parser_consume_token (parser);
18459 : : }
18460 : 372 : if (!c_parser_next_token_is (parser, CPP_NAME))
18461 : : {
18462 : 0 : c_parser_error (parser, "expected %<concurrent%>");
18463 : 0 : goto out_err;
18464 : : }
18465 : 372 : p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
18466 : 372 : if (strcmp (p, "concurrent") != 0)
18467 : : {
18468 : 1 : c_parser_error (parser, "expected %<concurrent%>");
18469 : 1 : goto out_err;
18470 : : }
18471 : 371 : c_parser_consume_token (parser);
18472 : 371 : parens.skip_until_found_close (parser);
18473 : 371 : check_no_duplicate_clause (list, OMP_CLAUSE_ORDER, "order");
18474 : 371 : c = build_omp_clause (loc, OMP_CLAUSE_ORDER);
18475 : 371 : OMP_CLAUSE_ORDER_UNCONSTRAINED (c) = unconstrained;
18476 : 371 : OMP_CLAUSE_ORDER_REPRODUCIBLE (c) = reproducible;
18477 : 371 : OMP_CLAUSE_CHAIN (c) = list;
18478 : 371 : return c;
18479 : :
18480 : 2 : out_err:
18481 : 2 : parens.skip_until_found_close (parser);
18482 : 2 : return list;
18483 : : }
18484 : :
18485 : :
18486 : : /* OpenMP 5.0:
18487 : : bind ( teams | parallel | thread ) */
18488 : :
18489 : : static tree
18490 : 115 : c_parser_omp_clause_bind (c_parser *parser, tree list)
18491 : : {
18492 : 115 : location_t loc = c_parser_peek_token (parser)->location;
18493 : 115 : tree c;
18494 : 115 : const char *p;
18495 : 115 : enum omp_clause_bind_kind kind = OMP_CLAUSE_BIND_THREAD;
18496 : :
18497 : 115 : matching_parens parens;
18498 : 115 : if (!parens.require_open (parser))
18499 : : return list;
18500 : 113 : if (!c_parser_next_token_is (parser, CPP_NAME))
18501 : : {
18502 : 3 : invalid:
18503 : 4 : c_parser_error (parser,
18504 : : "expected %<teams%>, %<parallel%> or %<thread%>");
18505 : 4 : parens.skip_until_found_close (parser);
18506 : 4 : return list;
18507 : : }
18508 : 110 : p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
18509 : 110 : if (strcmp (p, "teams") == 0)
18510 : : kind = OMP_CLAUSE_BIND_TEAMS;
18511 : 72 : else if (strcmp (p, "parallel") == 0)
18512 : : kind = OMP_CLAUSE_BIND_PARALLEL;
18513 : 35 : else if (strcmp (p, "thread") != 0)
18514 : 1 : goto invalid;
18515 : 109 : c_parser_consume_token (parser);
18516 : 109 : parens.skip_until_found_close (parser);
18517 : : /* check_no_duplicate_clause (list, OMP_CLAUSE_BIND, "bind"); */
18518 : 109 : c = build_omp_clause (loc, OMP_CLAUSE_BIND);
18519 : 109 : OMP_CLAUSE_BIND_KIND (c) = kind;
18520 : 109 : OMP_CLAUSE_CHAIN (c) = list;
18521 : 109 : return c;
18522 : : }
18523 : :
18524 : :
18525 : : /* OpenMP 2.5:
18526 : : ordered
18527 : :
18528 : : OpenMP 4.5:
18529 : : ordered ( constant-expression ) */
18530 : :
18531 : : static tree
18532 : 309 : c_parser_omp_clause_ordered (c_parser *parser, tree list)
18533 : : {
18534 : 309 : check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered");
18535 : :
18536 : 309 : tree c, num = NULL_TREE;
18537 : 309 : HOST_WIDE_INT n;
18538 : 309 : location_t loc = c_parser_peek_token (parser)->location;
18539 : 309 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
18540 : : {
18541 : 168 : matching_parens parens;
18542 : 168 : parens.consume_open (parser);
18543 : 168 : num = c_parser_expr_no_commas (parser, NULL).value;
18544 : 168 : parens.skip_until_found_close (parser);
18545 : : }
18546 : 309 : if (num == error_mark_node)
18547 : : return list;
18548 : 309 : if (num)
18549 : : {
18550 : 168 : mark_exp_read (num);
18551 : 168 : num = c_fully_fold (num, false, NULL);
18552 : 336 : if (!INTEGRAL_TYPE_P (TREE_TYPE (num))
18553 : 168 : || !tree_fits_shwi_p (num)
18554 : 168 : || (n = tree_to_shwi (num)) <= 0
18555 : 336 : || (int) n != n)
18556 : : {
18557 : 0 : error_at (loc, "ordered argument needs positive "
18558 : : "constant integer expression");
18559 : 0 : return list;
18560 : : }
18561 : : }
18562 : 309 : c = build_omp_clause (loc, OMP_CLAUSE_ORDERED);
18563 : 309 : OMP_CLAUSE_ORDERED_EXPR (c) = num;
18564 : 309 : OMP_CLAUSE_CHAIN (c) = list;
18565 : 309 : return c;
18566 : : }
18567 : :
18568 : : /* OpenMP 2.5:
18569 : : private ( variable-list ) */
18570 : :
18571 : : static tree
18572 : 735 : c_parser_omp_clause_private (c_parser *parser, tree list)
18573 : : {
18574 : 0 : return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_PRIVATE, list);
18575 : : }
18576 : :
18577 : : /* OpenMP 2.5:
18578 : : reduction ( reduction-operator : variable-list )
18579 : :
18580 : : reduction-operator:
18581 : : One of: + * - & ^ | && ||
18582 : :
18583 : : OpenMP 3.1:
18584 : :
18585 : : reduction-operator:
18586 : : One of: + * - & ^ | && || max min
18587 : :
18588 : : OpenMP 4.0:
18589 : :
18590 : : reduction-operator:
18591 : : One of: + * - & ^ | && ||
18592 : : identifier
18593 : :
18594 : : OpenMP 5.0:
18595 : : reduction ( reduction-modifier, reduction-operator : variable-list )
18596 : : in_reduction ( reduction-operator : variable-list )
18597 : : task_reduction ( reduction-operator : variable-list ) */
18598 : :
18599 : : static tree
18600 : 3089 : c_parser_omp_clause_reduction (c_parser *parser, enum omp_clause_code kind,
18601 : : bool is_omp, tree list)
18602 : : {
18603 : 3089 : location_t clause_loc = c_parser_peek_token (parser)->location;
18604 : 3089 : matching_parens parens;
18605 : 3089 : if (parens.require_open (parser))
18606 : : {
18607 : 3089 : bool task = false;
18608 : 3089 : bool inscan = false;
18609 : 3089 : enum tree_code code = ERROR_MARK;
18610 : 3089 : tree reduc_id = NULL_TREE;
18611 : :
18612 : 3089 : if (kind == OMP_CLAUSE_REDUCTION && is_omp)
18613 : : {
18614 : 1778 : if (c_parser_next_token_is_keyword (parser, RID_DEFAULT)
18615 : 1778 : && c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
18616 : : {
18617 : 86 : c_parser_consume_token (parser);
18618 : 86 : c_parser_consume_token (parser);
18619 : : }
18620 : 1692 : else if (c_parser_next_token_is (parser, CPP_NAME)
18621 : 1692 : && c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
18622 : : {
18623 : 465 : const char *p
18624 : 465 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
18625 : 465 : if (strcmp (p, "task") == 0)
18626 : : task = true;
18627 : 285 : else if (strcmp (p, "inscan") == 0)
18628 : : inscan = true;
18629 : : if (task || inscan)
18630 : : {
18631 : 465 : c_parser_consume_token (parser);
18632 : 465 : c_parser_consume_token (parser);
18633 : : }
18634 : : }
18635 : : }
18636 : :
18637 : 3089 : switch (c_parser_peek_token (parser)->type)
18638 : : {
18639 : : case CPP_PLUS:
18640 : : code = PLUS_EXPR;
18641 : : break;
18642 : 253 : case CPP_MULT:
18643 : 253 : code = MULT_EXPR;
18644 : 253 : break;
18645 : 155 : case CPP_MINUS:
18646 : 155 : code = MINUS_EXPR;
18647 : 155 : break;
18648 : 27 : case CPP_AND:
18649 : 27 : code = BIT_AND_EXPR;
18650 : 27 : break;
18651 : 14 : case CPP_XOR:
18652 : 14 : code = BIT_XOR_EXPR;
18653 : 14 : break;
18654 : 82 : case CPP_OR:
18655 : 82 : code = BIT_IOR_EXPR;
18656 : 82 : break;
18657 : 67 : case CPP_AND_AND:
18658 : 67 : code = TRUTH_ANDIF_EXPR;
18659 : 67 : break;
18660 : 78 : case CPP_OR_OR:
18661 : 78 : code = TRUTH_ORIF_EXPR;
18662 : 78 : break;
18663 : 253 : case CPP_NAME:
18664 : 253 : {
18665 : 253 : const char *p
18666 : 253 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
18667 : 253 : if (strcmp (p, "min") == 0)
18668 : : {
18669 : : code = MIN_EXPR;
18670 : : break;
18671 : : }
18672 : 213 : if (strcmp (p, "max") == 0)
18673 : : {
18674 : : code = MAX_EXPR;
18675 : : break;
18676 : : }
18677 : 130 : reduc_id = c_parser_peek_token (parser)->value;
18678 : 130 : break;
18679 : : }
18680 : 0 : default:
18681 : 0 : c_parser_error (parser,
18682 : : "expected %<+%>, %<*%>, %<-%>, %<&%>, "
18683 : : "%<^%>, %<|%>, %<&&%>, %<||%> or identifier");
18684 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
18685 : 0 : return list;
18686 : : }
18687 : 3089 : c_parser_consume_token (parser);
18688 : 3089 : reduc_id = c_omp_reduction_id (code, reduc_id);
18689 : 3089 : if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
18690 : : {
18691 : 3089 : tree nl, c;
18692 : :
18693 : 3089 : nl = c_parser_omp_variable_list (parser, clause_loc, kind, list);
18694 : 6791 : for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
18695 : : {
18696 : 3702 : tree d = OMP_CLAUSE_DECL (c), type;
18697 : 3702 : if (TREE_CODE (d) != OMP_ARRAY_SECTION)
18698 : 3183 : type = TREE_TYPE (d);
18699 : : else
18700 : : {
18701 : : int cnt = 0;
18702 : : tree t;
18703 : 636 : for (t = d;
18704 : 1155 : TREE_CODE (t) == OMP_ARRAY_SECTION;
18705 : 636 : t = TREE_OPERAND (t, 0))
18706 : 636 : cnt++;
18707 : 519 : type = TREE_TYPE (t);
18708 : 1153 : while (cnt > 0)
18709 : : {
18710 : 636 : if (TREE_CODE (type) != POINTER_TYPE
18711 : 399 : && TREE_CODE (type) != ARRAY_TYPE)
18712 : : break;
18713 : 634 : type = TREE_TYPE (type);
18714 : 634 : cnt--;
18715 : : }
18716 : : }
18717 : 3795 : while (TREE_CODE (type) == ARRAY_TYPE)
18718 : 93 : type = TREE_TYPE (type);
18719 : 3702 : OMP_CLAUSE_REDUCTION_CODE (c) = code;
18720 : 3702 : if (task)
18721 : 212 : OMP_CLAUSE_REDUCTION_TASK (c) = 1;
18722 : 3490 : else if (inscan)
18723 : 400 : OMP_CLAUSE_REDUCTION_INSCAN (c) = 1;
18724 : 3702 : if (code == ERROR_MARK
18725 : 219 : || !(INTEGRAL_TYPE_P (type)
18726 : 3562 : || SCALAR_FLOAT_TYPE_P (type)
18727 : : || TREE_CODE (type) == COMPLEX_TYPE))
18728 : 273 : OMP_CLAUSE_REDUCTION_PLACEHOLDER (c)
18729 : 546 : = c_omp_reduction_lookup (reduc_id,
18730 : 273 : TYPE_MAIN_VARIANT (type));
18731 : : }
18732 : :
18733 : : list = nl;
18734 : : }
18735 : 3089 : parens.skip_until_found_close (parser);
18736 : : }
18737 : : return list;
18738 : : }
18739 : :
18740 : : /* OpenMP 2.5:
18741 : : schedule ( schedule-kind )
18742 : : schedule ( schedule-kind , expression )
18743 : :
18744 : : schedule-kind:
18745 : : static | dynamic | guided | runtime | auto
18746 : :
18747 : : OpenMP 4.5:
18748 : : schedule ( schedule-modifier : schedule-kind )
18749 : : schedule ( schedule-modifier [ , schedule-modifier ] : schedule-kind , expression )
18750 : :
18751 : : schedule-modifier:
18752 : : simd
18753 : : monotonic
18754 : : nonmonotonic */
18755 : :
18756 : : static tree
18757 : 3467 : c_parser_omp_clause_schedule (c_parser *parser, tree list)
18758 : : {
18759 : 3467 : tree c, t;
18760 : 3467 : location_t loc = c_parser_peek_token (parser)->location;
18761 : 3467 : int modifiers = 0, nmodifiers = 0;
18762 : :
18763 : 3467 : matching_parens parens;
18764 : 3467 : if (!parens.require_open (parser))
18765 : : return list;
18766 : :
18767 : 3465 : c = build_omp_clause (loc, OMP_CLAUSE_SCHEDULE);
18768 : :
18769 : 3465 : location_t comma = UNKNOWN_LOCATION;
18770 : 6944 : while (c_parser_next_token_is (parser, CPP_NAME))
18771 : : {
18772 : 1780 : tree kind = c_parser_peek_token (parser)->value;
18773 : 1780 : const char *p = IDENTIFIER_POINTER (kind);
18774 : 1780 : if (strcmp ("simd", p) == 0)
18775 : 31 : OMP_CLAUSE_SCHEDULE_SIMD (c) = 1;
18776 : 1749 : else if (strcmp ("monotonic", p) == 0)
18777 : 74 : modifiers |= OMP_CLAUSE_SCHEDULE_MONOTONIC;
18778 : 1675 : else if (strcmp ("nonmonotonic", p) == 0)
18779 : 84 : modifiers |= OMP_CLAUSE_SCHEDULE_NONMONOTONIC;
18780 : : else
18781 : : break;
18782 : 189 : comma = UNKNOWN_LOCATION;
18783 : 189 : c_parser_consume_token (parser);
18784 : 189 : if (nmodifiers++ == 0
18785 : 367 : && c_parser_next_token_is (parser, CPP_COMMA))
18786 : : {
18787 : 14 : comma = c_parser_peek_token (parser)->location;
18788 : 14 : c_parser_consume_token (parser);
18789 : : }
18790 : : else
18791 : : {
18792 : 175 : c_parser_require (parser, CPP_COLON, "expected %<:%>");
18793 : 175 : break;
18794 : : }
18795 : : }
18796 : 3465 : if (comma != UNKNOWN_LOCATION)
18797 : 3 : error_at (comma, "expected %<:%>");
18798 : :
18799 : 3465 : if ((modifiers & (OMP_CLAUSE_SCHEDULE_MONOTONIC
18800 : : | OMP_CLAUSE_SCHEDULE_NONMONOTONIC))
18801 : : == (OMP_CLAUSE_SCHEDULE_MONOTONIC
18802 : : | OMP_CLAUSE_SCHEDULE_NONMONOTONIC))
18803 : : {
18804 : 2 : error_at (loc, "both %<monotonic%> and %<nonmonotonic%> modifiers "
18805 : : "specified");
18806 : 2 : modifiers = 0;
18807 : : }
18808 : :
18809 : 3465 : if (c_parser_next_token_is (parser, CPP_NAME))
18810 : : {
18811 : 1708 : tree kind = c_parser_peek_token (parser)->value;
18812 : 1708 : const char *p = IDENTIFIER_POINTER (kind);
18813 : :
18814 : 1708 : switch (p[0])
18815 : : {
18816 : 169 : case 'd':
18817 : 169 : if (strcmp ("dynamic", p) != 0)
18818 : 0 : goto invalid_kind;
18819 : 169 : OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
18820 : 169 : break;
18821 : :
18822 : 761 : case 'g':
18823 : 761 : if (strcmp ("guided", p) != 0)
18824 : 0 : goto invalid_kind;
18825 : 761 : OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
18826 : 761 : break;
18827 : :
18828 : 777 : case 'r':
18829 : 777 : if (strcmp ("runtime", p) != 0)
18830 : 0 : goto invalid_kind;
18831 : 777 : OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
18832 : 777 : break;
18833 : :
18834 : 1 : default:
18835 : 1 : goto invalid_kind;
18836 : : }
18837 : : }
18838 : 1757 : else if (c_parser_next_token_is_keyword (parser, RID_STATIC))
18839 : 1076 : OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
18840 : 681 : else if (c_parser_next_token_is_keyword (parser, RID_AUTO))
18841 : 680 : OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_AUTO;
18842 : : else
18843 : 1 : goto invalid_kind;
18844 : :
18845 : 3463 : c_parser_consume_token (parser);
18846 : 3463 : if (c_parser_next_token_is (parser, CPP_COMMA))
18847 : : {
18848 : 1795 : location_t here;
18849 : 1795 : c_parser_consume_token (parser);
18850 : :
18851 : 1795 : here = c_parser_peek_token (parser)->location;
18852 : 1795 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
18853 : 1795 : expr = convert_lvalue_to_rvalue (here, expr, false, true);
18854 : 1795 : t = expr.value;
18855 : 1795 : t = c_fully_fold (t, false, NULL);
18856 : :
18857 : 1795 : if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
18858 : 1 : error_at (here, "schedule %<runtime%> does not take "
18859 : : "a %<chunk_size%> parameter");
18860 : 1794 : else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_AUTO)
18861 : 0 : error_at (here,
18862 : : "schedule %<auto%> does not take "
18863 : : "a %<chunk_size%> parameter");
18864 : 1794 : else if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
18865 : 1794 : || TREE_CODE (TREE_TYPE (t)) == BITINT_TYPE)
18866 : : {
18867 : : /* Attempt to statically determine when the number isn't
18868 : : positive. */
18869 : 1793 : tree s = fold_build2_loc (loc, LE_EXPR, boolean_type_node, t,
18870 : 1793 : build_int_cst (TREE_TYPE (t), 0));
18871 : 1793 : protected_set_expr_location (s, loc);
18872 : 1793 : if (s == boolean_true_node)
18873 : : {
18874 : 2 : warning_at (loc, OPT_Wopenmp,
18875 : : "chunk size value must be positive");
18876 : 2 : t = integer_one_node;
18877 : : }
18878 : 1793 : OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
18879 : : }
18880 : : else
18881 : 1 : c_parser_error (parser, "expected integer expression");
18882 : :
18883 : 1795 : parens.skip_until_found_close (parser);
18884 : : }
18885 : : else
18886 : 1668 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
18887 : : "expected %<,%> or %<)%>");
18888 : :
18889 : 6926 : OMP_CLAUSE_SCHEDULE_KIND (c)
18890 : 6926 : = (enum omp_clause_schedule_kind)
18891 : 3463 : (OMP_CLAUSE_SCHEDULE_KIND (c) | modifiers);
18892 : :
18893 : 3463 : check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule");
18894 : 3463 : OMP_CLAUSE_CHAIN (c) = list;
18895 : 3463 : return c;
18896 : :
18897 : 2 : invalid_kind:
18898 : 2 : c_parser_error (parser, "invalid schedule kind");
18899 : 2 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
18900 : 2 : return list;
18901 : : }
18902 : :
18903 : : /* OpenMP 2.5:
18904 : : shared ( variable-list ) */
18905 : :
18906 : : static tree
18907 : 689 : c_parser_omp_clause_shared (c_parser *parser, tree list)
18908 : : {
18909 : 0 : return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_SHARED, list);
18910 : : }
18911 : :
18912 : : /* OpenMP 3.0:
18913 : : untied */
18914 : :
18915 : : static tree
18916 : 96 : c_parser_omp_clause_untied (c_parser *parser ATTRIBUTE_UNUSED, tree list)
18917 : : {
18918 : 96 : tree c;
18919 : :
18920 : : /* FIXME: Should we allow duplicates? */
18921 : 96 : check_no_duplicate_clause (list, OMP_CLAUSE_UNTIED, "untied");
18922 : :
18923 : 96 : c = build_omp_clause (c_parser_peek_token (parser)->location,
18924 : : OMP_CLAUSE_UNTIED);
18925 : 96 : OMP_CLAUSE_CHAIN (c) = list;
18926 : :
18927 : 96 : return c;
18928 : : }
18929 : :
18930 : : /* OpenMP 4.0:
18931 : : inbranch
18932 : : notinbranch */
18933 : :
18934 : : static tree
18935 : 199 : c_parser_omp_clause_branch (c_parser *parser ATTRIBUTE_UNUSED,
18936 : : enum omp_clause_code code, tree list)
18937 : : {
18938 : 199 : check_no_duplicate_clause (list, code, omp_clause_code_name[code]);
18939 : :
18940 : 199 : tree c = build_omp_clause (c_parser_peek_token (parser)->location, code);
18941 : 199 : OMP_CLAUSE_CHAIN (c) = list;
18942 : :
18943 : 199 : return c;
18944 : : }
18945 : :
18946 : : /* OpenMP 4.0:
18947 : : parallel
18948 : : for
18949 : : sections
18950 : : taskgroup */
18951 : :
18952 : : static tree
18953 : 379 : c_parser_omp_clause_cancelkind (c_parser *parser ATTRIBUTE_UNUSED,
18954 : : enum omp_clause_code code, tree list)
18955 : : {
18956 : 379 : tree c = build_omp_clause (c_parser_peek_token (parser)->location, code);
18957 : 379 : OMP_CLAUSE_CHAIN (c) = list;
18958 : :
18959 : 379 : return c;
18960 : : }
18961 : :
18962 : : /* OpenMP 4.5:
18963 : : nogroup */
18964 : :
18965 : : static tree
18966 : 18 : c_parser_omp_clause_nogroup (c_parser *parser ATTRIBUTE_UNUSED, tree list)
18967 : : {
18968 : 18 : check_no_duplicate_clause (list, OMP_CLAUSE_NOGROUP, "nogroup");
18969 : 18 : tree c = build_omp_clause (c_parser_peek_token (parser)->location,
18970 : : OMP_CLAUSE_NOGROUP);
18971 : 18 : OMP_CLAUSE_CHAIN (c) = list;
18972 : 18 : return c;
18973 : : }
18974 : :
18975 : : /* OpenMP 4.5:
18976 : : simd
18977 : : threads */
18978 : :
18979 : : static tree
18980 : 103 : c_parser_omp_clause_orderedkind (c_parser *parser ATTRIBUTE_UNUSED,
18981 : : enum omp_clause_code code, tree list)
18982 : : {
18983 : 103 : check_no_duplicate_clause (list, code, omp_clause_code_name[code]);
18984 : 103 : tree c = build_omp_clause (c_parser_peek_token (parser)->location, code);
18985 : 103 : OMP_CLAUSE_CHAIN (c) = list;
18986 : 103 : return c;
18987 : : }
18988 : :
18989 : : /* OpenMP 4.0:
18990 : : num_teams ( expression )
18991 : :
18992 : : OpenMP 5.1:
18993 : : num_teams ( expression : expression ) */
18994 : :
18995 : : static tree
18996 : 195 : c_parser_omp_clause_num_teams (c_parser *parser, tree list)
18997 : : {
18998 : 195 : location_t num_teams_loc = c_parser_peek_token (parser)->location;
18999 : 195 : matching_parens parens;
19000 : 195 : if (parens.require_open (parser))
19001 : : {
19002 : 195 : location_t upper_loc = c_parser_peek_token (parser)->location;
19003 : 195 : location_t lower_loc = UNKNOWN_LOCATION;
19004 : 195 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
19005 : 195 : expr = convert_lvalue_to_rvalue (upper_loc, expr, false, true);
19006 : 195 : tree c, upper = expr.value, lower = NULL_TREE;
19007 : 195 : upper = c_fully_fold (upper, false, NULL);
19008 : :
19009 : 195 : if (c_parser_next_token_is (parser, CPP_COLON))
19010 : : {
19011 : 51 : c_parser_consume_token (parser);
19012 : 51 : lower_loc = upper_loc;
19013 : 51 : lower = upper;
19014 : 51 : upper_loc = c_parser_peek_token (parser)->location;
19015 : 51 : expr = c_parser_expr_no_commas (parser, NULL);
19016 : 51 : expr = convert_lvalue_to_rvalue (upper_loc, expr, false, true);
19017 : 51 : upper = expr.value;
19018 : 51 : upper = c_fully_fold (upper, false, NULL);
19019 : : }
19020 : :
19021 : 195 : parens.skip_until_found_close (parser);
19022 : :
19023 : 390 : if (!INTEGRAL_TYPE_P (TREE_TYPE (upper))
19024 : 390 : || (lower && !INTEGRAL_TYPE_P (TREE_TYPE (lower))))
19025 : : {
19026 : 0 : c_parser_error (parser, "expected integer expression");
19027 : 0 : return list;
19028 : : }
19029 : :
19030 : : /* Attempt to statically determine when the number isn't positive. */
19031 : 195 : c = fold_build2_loc (upper_loc, LE_EXPR, boolean_type_node, upper,
19032 : 195 : build_int_cst (TREE_TYPE (upper), 0));
19033 : 195 : protected_set_expr_location (c, upper_loc);
19034 : 195 : if (c == boolean_true_node)
19035 : : {
19036 : 4 : warning_at (upper_loc, OPT_Wopenmp,
19037 : : "%<num_teams%> value must be positive");
19038 : 4 : upper = integer_one_node;
19039 : : }
19040 : 195 : if (lower)
19041 : : {
19042 : 51 : c = fold_build2_loc (lower_loc, LE_EXPR, boolean_type_node, lower,
19043 : 51 : build_int_cst (TREE_TYPE (lower), 0));
19044 : 51 : protected_set_expr_location (c, lower_loc);
19045 : 51 : if (c == boolean_true_node)
19046 : : {
19047 : 2 : warning_at (lower_loc, OPT_Wopenmp,
19048 : : "%<num_teams%> value must be positive");
19049 : 2 : lower = NULL_TREE;
19050 : : }
19051 : 49 : else if (TREE_CODE (lower) == INTEGER_CST
19052 : 7 : && TREE_CODE (upper) == INTEGER_CST
19053 : 54 : && tree_int_cst_lt (upper, lower))
19054 : : {
19055 : 2 : warning_at (lower_loc, OPT_Wopenmp,
19056 : : "%<num_teams%> lower bound %qE bigger than upper "
19057 : : "bound %qE", lower, upper);
19058 : 2 : lower = NULL_TREE;
19059 : : }
19060 : : }
19061 : :
19062 : 195 : check_no_duplicate_clause (list, OMP_CLAUSE_NUM_TEAMS, "num_teams");
19063 : :
19064 : 195 : c = build_omp_clause (num_teams_loc, OMP_CLAUSE_NUM_TEAMS);
19065 : 195 : OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR (c) = upper;
19066 : 195 : OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (c) = lower;
19067 : 195 : OMP_CLAUSE_CHAIN (c) = list;
19068 : 195 : list = c;
19069 : : }
19070 : :
19071 : : return list;
19072 : : }
19073 : :
19074 : : /* OpenMP 4.0:
19075 : : thread_limit ( expression ) */
19076 : :
19077 : : static tree
19078 : 154 : c_parser_omp_clause_thread_limit (c_parser *parser, tree list)
19079 : : {
19080 : 154 : location_t num_thread_limit_loc = c_parser_peek_token (parser)->location;
19081 : 154 : matching_parens parens;
19082 : 154 : if (parens.require_open (parser))
19083 : : {
19084 : 154 : location_t expr_loc = c_parser_peek_token (parser)->location;
19085 : 154 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
19086 : 154 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
19087 : 154 : tree c, t = expr.value;
19088 : 154 : t = c_fully_fold (t, false, NULL);
19089 : :
19090 : 154 : parens.skip_until_found_close (parser);
19091 : :
19092 : 154 : if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
19093 : : {
19094 : 0 : c_parser_error (parser, "expected integer expression");
19095 : 0 : return list;
19096 : : }
19097 : :
19098 : : /* Attempt to statically determine when the number isn't positive. */
19099 : 154 : c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, t,
19100 : 154 : build_int_cst (TREE_TYPE (t), 0));
19101 : 154 : protected_set_expr_location (c, expr_loc);
19102 : 154 : if (c == boolean_true_node)
19103 : : {
19104 : 0 : warning_at (expr_loc, OPT_Wopenmp,
19105 : : "%<thread_limit%> value must be positive");
19106 : 0 : t = integer_one_node;
19107 : : }
19108 : :
19109 : 154 : check_no_duplicate_clause (list, OMP_CLAUSE_THREAD_LIMIT,
19110 : : "thread_limit");
19111 : :
19112 : 154 : c = build_omp_clause (num_thread_limit_loc, OMP_CLAUSE_THREAD_LIMIT);
19113 : 154 : OMP_CLAUSE_THREAD_LIMIT_EXPR (c) = t;
19114 : 154 : OMP_CLAUSE_CHAIN (c) = list;
19115 : 154 : list = c;
19116 : : }
19117 : :
19118 : : return list;
19119 : : }
19120 : :
19121 : : /* OpenMP 4.0:
19122 : : aligned ( variable-list )
19123 : : aligned ( variable-list : constant-expression ) */
19124 : :
19125 : : static tree
19126 : 228 : c_parser_omp_clause_aligned (c_parser *parser, tree list)
19127 : : {
19128 : 228 : location_t clause_loc = c_parser_peek_token (parser)->location;
19129 : 228 : tree nl, c;
19130 : :
19131 : 228 : matching_parens parens;
19132 : 228 : if (!parens.require_open (parser))
19133 : : return list;
19134 : :
19135 : 228 : nl = c_parser_omp_variable_list (parser, clause_loc,
19136 : : OMP_CLAUSE_ALIGNED, list);
19137 : :
19138 : 228 : if (c_parser_next_token_is (parser, CPP_COLON))
19139 : : {
19140 : 212 : c_parser_consume_token (parser);
19141 : 212 : location_t expr_loc = c_parser_peek_token (parser)->location;
19142 : 212 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
19143 : 212 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
19144 : 212 : tree alignment = expr.value;
19145 : 212 : alignment = c_fully_fold (alignment, false, NULL);
19146 : 212 : if (TREE_CODE (alignment) != INTEGER_CST
19147 : 210 : || !INTEGRAL_TYPE_P (TREE_TYPE (alignment))
19148 : 422 : || tree_int_cst_sgn (alignment) != 1)
19149 : : {
19150 : 4 : error_at (clause_loc, "%<aligned%> clause alignment expression must "
19151 : : "be positive constant integer expression");
19152 : 4 : alignment = NULL_TREE;
19153 : : }
19154 : :
19155 : 444 : for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
19156 : 232 : OMP_CLAUSE_ALIGNED_ALIGNMENT (c) = alignment;
19157 : : }
19158 : :
19159 : 228 : parens.skip_until_found_close (parser);
19160 : 228 : return nl;
19161 : : }
19162 : :
19163 : : /* OpenMP 5.0:
19164 : : allocate ( variable-list )
19165 : : allocate ( expression : variable-list )
19166 : :
19167 : : OpenMP 5.1:
19168 : : allocate ( allocator-modifier : variable-list )
19169 : : allocate ( allocator-modifier , allocator-modifier : variable-list )
19170 : :
19171 : : allocator-modifier:
19172 : : allocator ( expression )
19173 : : align ( expression ) */
19174 : :
19175 : : static tree
19176 : 467 : c_parser_omp_clause_allocate (c_parser *parser, tree list)
19177 : : {
19178 : 467 : location_t clause_loc = c_parser_peek_token (parser)->location;
19179 : 467 : tree nl, c;
19180 : 467 : tree allocator = NULL_TREE;
19181 : 467 : tree align = NULL_TREE;
19182 : :
19183 : 467 : matching_parens parens;
19184 : 467 : if (!parens.require_open (parser))
19185 : : return list;
19186 : :
19187 : 467 : if ((c_parser_next_token_is_not (parser, CPP_NAME)
19188 : 5 : && c_parser_next_token_is_not (parser, CPP_KEYWORD))
19189 : 467 : || (c_parser_peek_2nd_token (parser)->type != CPP_COMMA
19190 : 448 : && c_parser_peek_2nd_token (parser)->type != CPP_CLOSE_PAREN))
19191 : : {
19192 : 202 : bool has_modifiers = false;
19193 : 202 : tree orig_type = NULL_TREE;
19194 : 202 : if (c_parser_next_token_is (parser, CPP_NAME)
19195 : 202 : && c_parser_peek_2nd_token (parser)->type == CPP_OPEN_PAREN)
19196 : : {
19197 : 61 : unsigned int n = 3;
19198 : 61 : const char *p
19199 : 61 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
19200 : 29 : if ((strcmp (p, "allocator") == 0 || strcmp (p, "align") == 0)
19201 : 59 : && c_parser_check_balanced_raw_token_sequence (parser, &n)
19202 : 120 : && (c_parser_peek_nth_token_raw (parser, n)->type
19203 : : == CPP_CLOSE_PAREN))
19204 : : {
19205 : 59 : if (c_parser_peek_nth_token_raw (parser, n + 1)->type
19206 : : == CPP_COLON)
19207 : : has_modifiers = true;
19208 : 27 : else if (c_parser_peek_nth_token_raw (parser, n + 1)->type
19209 : : == CPP_COMMA
19210 : 27 : && (c_parser_peek_nth_token_raw (parser, n + 2)->type
19211 : : == CPP_NAME)
19212 : 54 : && (c_parser_peek_nth_token_raw (parser, n + 3)->type
19213 : : == CPP_OPEN_PAREN))
19214 : : {
19215 : 27 : c_token *tok = c_parser_peek_nth_token_raw (parser, n + 2);
19216 : 27 : const char *q = IDENTIFIER_POINTER (tok->value);
19217 : 27 : n += 4;
19218 : 27 : if ((strcmp (q, "allocator") == 0
19219 : 14 : || strcmp (q, "align") == 0)
19220 : 27 : && c_parser_check_balanced_raw_token_sequence (parser,
19221 : : &n)
19222 : 27 : && (c_parser_peek_nth_token_raw (parser, n)->type
19223 : : == CPP_CLOSE_PAREN)
19224 : 54 : && (c_parser_peek_nth_token_raw (parser, n + 1)->type
19225 : : == CPP_COLON))
19226 : : has_modifiers = true;
19227 : : }
19228 : : }
19229 : : if (has_modifiers)
19230 : : {
19231 : 59 : c_parser_consume_token (parser);
19232 : 59 : matching_parens parens2;
19233 : 59 : parens2.require_open (parser);
19234 : 59 : location_t expr_loc = c_parser_peek_token (parser)->location;
19235 : 59 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
19236 : 59 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
19237 : 59 : if (expr.value == error_mark_node)
19238 : : ;
19239 : 58 : else if (strcmp (p, "allocator") == 0)
19240 : : {
19241 : 31 : allocator = expr.value;
19242 : 31 : allocator = c_fully_fold (allocator, false, NULL);
19243 : 3 : orig_type = expr.original_type
19244 : 31 : ? expr.original_type : TREE_TYPE (allocator);
19245 : 31 : orig_type = TYPE_MAIN_VARIANT (orig_type);
19246 : : }
19247 : : else
19248 : : {
19249 : 27 : align = expr.value;
19250 : 27 : align = c_fully_fold (align, false, NULL);
19251 : : }
19252 : 59 : parens2.skip_until_found_close (parser);
19253 : 59 : if (c_parser_next_token_is (parser, CPP_COMMA))
19254 : : {
19255 : 27 : c_parser_consume_token (parser);
19256 : 27 : c_token *tok = c_parser_peek_token (parser);
19257 : 27 : const char *q = "";
19258 : 27 : if (c_parser_next_token_is (parser, CPP_NAME))
19259 : 27 : q = IDENTIFIER_POINTER (tok->value);
19260 : 27 : if (strcmp (q, "allocator") != 0 && strcmp (q, "align") != 0)
19261 : : {
19262 : 0 : c_parser_error (parser, "expected %<allocator%> or "
19263 : : "%<align%>");
19264 : 0 : parens.skip_until_found_close (parser);
19265 : 2 : return list;
19266 : : }
19267 : 27 : else if (strcmp (p, q) == 0)
19268 : : {
19269 : 2 : error_at (tok->location, "duplicate %qs modifier", p);
19270 : 2 : parens.skip_until_found_close (parser);
19271 : 2 : return list;
19272 : : }
19273 : 25 : c_parser_consume_token (parser);
19274 : 25 : if (!parens2.require_open (parser))
19275 : : {
19276 : 0 : parens.skip_until_found_close (parser);
19277 : 0 : return list;
19278 : : }
19279 : 25 : expr_loc = c_parser_peek_token (parser)->location;
19280 : 25 : expr = c_parser_expr_no_commas (parser, NULL);
19281 : 25 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false,
19282 : : true);
19283 : 25 : if (strcmp (q, "allocator") == 0)
19284 : : {
19285 : 12 : allocator = expr.value;
19286 : 12 : allocator = c_fully_fold (allocator, false, NULL);
19287 : 2 : orig_type = expr.original_type
19288 : 12 : ? expr.original_type : TREE_TYPE (allocator);
19289 : 12 : orig_type = TYPE_MAIN_VARIANT (orig_type);
19290 : : }
19291 : : else
19292 : : {
19293 : 13 : align = expr.value;
19294 : 13 : align = c_fully_fold (align, false, NULL);
19295 : : }
19296 : 25 : parens2.skip_until_found_close (parser);
19297 : : }
19298 : : }
19299 : : }
19300 : 59 : if (!has_modifiers)
19301 : : {
19302 : 143 : location_t expr_loc = c_parser_peek_token (parser)->location;
19303 : 143 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
19304 : 143 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
19305 : 143 : allocator = expr.value;
19306 : 143 : allocator = c_fully_fold (allocator, false, NULL);
19307 : 7 : orig_type = expr.original_type
19308 : 143 : ? expr.original_type : TREE_TYPE (allocator);
19309 : 143 : orig_type = TYPE_MAIN_VARIANT (orig_type);
19310 : : }
19311 : 200 : if (allocator
19312 : 200 : && (!INTEGRAL_TYPE_P (TREE_TYPE (allocator))
19313 : 183 : || TREE_CODE (orig_type) != ENUMERAL_TYPE
19314 : 362 : || (TYPE_NAME (orig_type)
19315 : 181 : != get_identifier ("omp_allocator_handle_t"))))
19316 : : {
19317 : 8 : error_at (clause_loc, "%<allocate%> clause allocator expression "
19318 : : "has type %qT rather than "
19319 : : "%<omp_allocator_handle_t%>",
19320 : 4 : TREE_TYPE (allocator));
19321 : 4 : allocator = NULL_TREE;
19322 : : }
19323 : 200 : if (align
19324 : 200 : && (!INTEGRAL_TYPE_P (TREE_TYPE (align))
19325 : 38 : || !tree_fits_uhwi_p (align)
19326 : 37 : || !integer_pow2p (align)))
19327 : : {
19328 : 4 : error_at (clause_loc, "%<allocate%> clause %<align%> modifier "
19329 : : "argument needs to be positive constant "
19330 : : "power of two integer expression");
19331 : 4 : align = NULL_TREE;
19332 : : }
19333 : 200 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
19334 : : {
19335 : 0 : parens.skip_until_found_close (parser);
19336 : 0 : return list;
19337 : : }
19338 : : }
19339 : :
19340 : 465 : nl = c_parser_omp_variable_list (parser, clause_loc,
19341 : : OMP_CLAUSE_ALLOCATE, list);
19342 : :
19343 : 465 : if (allocator || align)
19344 : 465 : for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
19345 : : {
19346 : 274 : OMP_CLAUSE_ALLOCATE_ALLOCATOR (c) = allocator;
19347 : 274 : OMP_CLAUSE_ALLOCATE_ALIGN (c) = align;
19348 : : }
19349 : :
19350 : 465 : parens.skip_until_found_close (parser);
19351 : 465 : return nl;
19352 : : }
19353 : :
19354 : : /* OpenMP 4.0:
19355 : : linear ( variable-list )
19356 : : linear ( variable-list : expression )
19357 : :
19358 : : OpenMP 4.5:
19359 : : linear ( modifier ( variable-list ) )
19360 : : linear ( modifier ( variable-list ) : expression )
19361 : :
19362 : : modifier:
19363 : : val
19364 : :
19365 : : OpenMP 5.2:
19366 : : linear ( variable-list : modifiers-list )
19367 : :
19368 : : modifiers:
19369 : : val
19370 : : step ( expression ) */
19371 : :
19372 : : static tree
19373 : 474 : c_parser_omp_clause_linear (c_parser *parser, tree list)
19374 : : {
19375 : 474 : location_t clause_loc = c_parser_peek_token (parser)->location;
19376 : 474 : tree nl, c, step;
19377 : 474 : enum omp_clause_linear_kind kind = OMP_CLAUSE_LINEAR_DEFAULT;
19378 : 474 : bool old_linear_modifier = false;
19379 : :
19380 : 474 : matching_parens parens;
19381 : 474 : if (!parens.require_open (parser))
19382 : : return list;
19383 : :
19384 : 474 : if (c_parser_next_token_is (parser, CPP_NAME))
19385 : : {
19386 : 474 : c_token *tok = c_parser_peek_token (parser);
19387 : 474 : const char *p = IDENTIFIER_POINTER (tok->value);
19388 : 474 : if (strcmp ("val", p) == 0)
19389 : 12 : kind = OMP_CLAUSE_LINEAR_VAL;
19390 : 474 : if (c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN)
19391 : : kind = OMP_CLAUSE_LINEAR_DEFAULT;
19392 : 12 : if (kind != OMP_CLAUSE_LINEAR_DEFAULT)
19393 : : {
19394 : 12 : old_linear_modifier = true;
19395 : 12 : c_parser_consume_token (parser);
19396 : 12 : c_parser_consume_token (parser);
19397 : : }
19398 : : }
19399 : :
19400 : 474 : nl = c_parser_omp_variable_list (parser, clause_loc,
19401 : : OMP_CLAUSE_LINEAR, list);
19402 : :
19403 : 474 : if (kind != OMP_CLAUSE_LINEAR_DEFAULT)
19404 : 12 : parens.skip_until_found_close (parser);
19405 : :
19406 : 474 : if (c_parser_next_token_is (parser, CPP_COLON))
19407 : : {
19408 : 348 : c_parser_consume_token (parser);
19409 : 348 : location_t expr_loc = c_parser_peek_token (parser)->location;
19410 : 348 : bool has_modifiers = false;
19411 : 348 : if (kind == OMP_CLAUSE_LINEAR_DEFAULT
19412 : 684 : && c_parser_next_token_is (parser, CPP_NAME))
19413 : : {
19414 : 72 : c_token *tok = c_parser_peek_token (parser);
19415 : 72 : const char *p = IDENTIFIER_POINTER (tok->value);
19416 : 72 : unsigned int pos = 0;
19417 : 72 : if (strcmp ("val", p) == 0)
19418 : 7 : pos = 2;
19419 : 65 : else if (strcmp ("step", p) == 0
19420 : 65 : && c_parser_peek_2nd_token (parser)->type == CPP_OPEN_PAREN)
19421 : : {
19422 : 13 : pos = 3;
19423 : 13 : if (c_parser_check_balanced_raw_token_sequence (parser, &pos)
19424 : 13 : && (c_parser_peek_nth_token_raw (parser, pos)->type
19425 : : == CPP_CLOSE_PAREN))
19426 : 13 : ++pos;
19427 : : else
19428 : 0 : pos = 0;
19429 : : }
19430 : 72 : if (pos)
19431 : : {
19432 : 20 : tok = c_parser_peek_nth_token_raw (parser, pos);
19433 : 20 : if (tok->type == CPP_COMMA || tok->type == CPP_CLOSE_PAREN)
19434 : 17 : has_modifiers = true;
19435 : : }
19436 : : }
19437 : 72 : if (has_modifiers)
19438 : : {
19439 : : step = NULL_TREE;
19440 : 25 : while (c_parser_next_token_is (parser, CPP_NAME))
19441 : : {
19442 : 25 : c_token *tok = c_parser_peek_token (parser);
19443 : 25 : const char *p = IDENTIFIER_POINTER (tok->value);
19444 : 25 : if (strcmp ("val", p) == 0)
19445 : : {
19446 : 9 : if (kind != OMP_CLAUSE_LINEAR_DEFAULT)
19447 : : error_at (tok->location, "multiple linear modifiers");
19448 : 9 : kind = OMP_CLAUSE_LINEAR_DEFAULT;
19449 : 9 : c_parser_consume_token (parser);
19450 : : }
19451 : 16 : else if (strcmp ("step", p) == 0)
19452 : : {
19453 : 16 : c_parser_consume_token (parser);
19454 : 16 : matching_parens parens2;
19455 : 16 : if (parens2.require_open (parser))
19456 : : {
19457 : 16 : if (step)
19458 : 0 : error_at (tok->location,
19459 : : "multiple %<step%> modifiers");
19460 : 16 : expr_loc = c_parser_peek_token (parser)->location;
19461 : 16 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
19462 : 16 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false,
19463 : : true);
19464 : 16 : step = c_fully_fold (expr.value, false, NULL);
19465 : 16 : if (!INTEGRAL_TYPE_P (TREE_TYPE (step)))
19466 : : {
19467 : 0 : error_at (clause_loc, "%<linear%> clause step "
19468 : : "expression must be integral");
19469 : 0 : step = integer_one_node;
19470 : : }
19471 : 16 : parens2.skip_until_found_close (parser);
19472 : : }
19473 : : else
19474 : : break;
19475 : : }
19476 : : else
19477 : : break;
19478 : 25 : if (c_parser_next_token_is (parser, CPP_COMMA))
19479 : : {
19480 : 8 : c_parser_consume_token (parser);
19481 : 8 : continue;
19482 : : }
19483 : : break;
19484 : : }
19485 : 17 : if (!step)
19486 : 1 : step = integer_one_node;
19487 : : }
19488 : : else
19489 : : {
19490 : 331 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
19491 : 331 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
19492 : 331 : step = c_fully_fold (expr.value, false, NULL);
19493 : 331 : if (!INTEGRAL_TYPE_P (TREE_TYPE (step)))
19494 : : {
19495 : 2 : error_at (clause_loc, "%<linear%> clause step expression must "
19496 : : "be integral");
19497 : 2 : step = integer_one_node;
19498 : : }
19499 : : }
19500 : :
19501 : : }
19502 : : else
19503 : 126 : step = integer_one_node;
19504 : :
19505 : 957 : for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
19506 : : {
19507 : 483 : OMP_CLAUSE_LINEAR_STEP (c) = step;
19508 : 483 : OMP_CLAUSE_LINEAR_KIND (c) = kind;
19509 : 483 : OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (c) = old_linear_modifier;
19510 : : }
19511 : :
19512 : 474 : parens.skip_until_found_close (parser);
19513 : 474 : return nl;
19514 : : }
19515 : :
19516 : : /* OpenMP 5.0:
19517 : : nontemporal ( variable-list ) */
19518 : :
19519 : : static tree
19520 : 121 : c_parser_omp_clause_nontemporal (c_parser *parser, tree list)
19521 : : {
19522 : 0 : return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_NONTEMPORAL, list);
19523 : : }
19524 : :
19525 : : /* OpenMP 4.0:
19526 : : safelen ( constant-expression ) */
19527 : :
19528 : : static tree
19529 : 227 : c_parser_omp_clause_safelen (c_parser *parser, tree list)
19530 : : {
19531 : 227 : location_t clause_loc = c_parser_peek_token (parser)->location;
19532 : 227 : tree c, t;
19533 : :
19534 : 227 : matching_parens parens;
19535 : 227 : if (!parens.require_open (parser))
19536 : : return list;
19537 : :
19538 : 227 : location_t expr_loc = c_parser_peek_token (parser)->location;
19539 : 227 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
19540 : 227 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
19541 : 227 : t = expr.value;
19542 : 227 : t = c_fully_fold (t, false, NULL);
19543 : 227 : if (TREE_CODE (t) != INTEGER_CST
19544 : 225 : || !INTEGRAL_TYPE_P (TREE_TYPE (t))
19545 : 452 : || tree_int_cst_sgn (t) != 1)
19546 : : {
19547 : 4 : error_at (clause_loc, "%<safelen%> clause expression must "
19548 : : "be positive constant integer expression");
19549 : 4 : t = NULL_TREE;
19550 : : }
19551 : :
19552 : 227 : parens.skip_until_found_close (parser);
19553 : 227 : if (t == NULL_TREE || t == error_mark_node)
19554 : : return list;
19555 : :
19556 : 223 : check_no_duplicate_clause (list, OMP_CLAUSE_SAFELEN, "safelen");
19557 : :
19558 : 223 : c = build_omp_clause (clause_loc, OMP_CLAUSE_SAFELEN);
19559 : 223 : OMP_CLAUSE_SAFELEN_EXPR (c) = t;
19560 : 223 : OMP_CLAUSE_CHAIN (c) = list;
19561 : 223 : return c;
19562 : : }
19563 : :
19564 : : /* OpenMP 4.0:
19565 : : simdlen ( constant-expression ) */
19566 : :
19567 : : static tree
19568 : 317 : c_parser_omp_clause_simdlen (c_parser *parser, tree list)
19569 : : {
19570 : 317 : location_t clause_loc = c_parser_peek_token (parser)->location;
19571 : 317 : tree c, t;
19572 : :
19573 : 317 : matching_parens parens;
19574 : 317 : if (!parens.require_open (parser))
19575 : : return list;
19576 : :
19577 : 317 : location_t expr_loc = c_parser_peek_token (parser)->location;
19578 : 317 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
19579 : 317 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
19580 : 317 : t = expr.value;
19581 : 317 : t = c_fully_fold (t, false, NULL);
19582 : 317 : if (TREE_CODE (t) != INTEGER_CST
19583 : 315 : || !INTEGRAL_TYPE_P (TREE_TYPE (t))
19584 : 632 : || tree_int_cst_sgn (t) != 1)
19585 : : {
19586 : 4 : error_at (clause_loc, "%<simdlen%> clause expression must "
19587 : : "be positive constant integer expression");
19588 : 4 : t = NULL_TREE;
19589 : : }
19590 : :
19591 : 317 : parens.skip_until_found_close (parser);
19592 : 317 : if (t == NULL_TREE || t == error_mark_node)
19593 : : return list;
19594 : :
19595 : 313 : check_no_duplicate_clause (list, OMP_CLAUSE_SIMDLEN, "simdlen");
19596 : :
19597 : 313 : c = build_omp_clause (clause_loc, OMP_CLAUSE_SIMDLEN);
19598 : 313 : OMP_CLAUSE_SIMDLEN_EXPR (c) = t;
19599 : 313 : OMP_CLAUSE_CHAIN (c) = list;
19600 : 313 : return c;
19601 : : }
19602 : :
19603 : : /* OpenMP 4.5:
19604 : : vec:
19605 : : identifier [+/- integer]
19606 : : vec , identifier [+/- integer]
19607 : : */
19608 : :
19609 : : static tree
19610 : 206 : c_parser_omp_clause_doacross_sink (c_parser *parser, location_t clause_loc,
19611 : : tree list, bool depend_p)
19612 : : {
19613 : 206 : tree vec = NULL;
19614 : 206 : if (c_parser_next_token_is_not (parser, CPP_NAME)
19615 : 206 : || c_parser_peek_token (parser)->id_kind != C_ID_ID)
19616 : : {
19617 : 0 : c_parser_error (parser, "expected identifier");
19618 : 0 : return list;
19619 : : }
19620 : :
19621 : 206 : if (!depend_p)
19622 : : {
19623 : 83 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
19624 : 83 : if (strcmp (p, "omp_cur_iteration") == 0
19625 : 36 : && c_parser_peek_2nd_token (parser)->type == CPP_MINUS
19626 : 34 : && c_parser_peek_nth_token (parser, 3)->type == CPP_NUMBER
19627 : 116 : && c_parser_peek_nth_token (parser, 4)->type == CPP_CLOSE_PAREN)
19628 : : {
19629 : 33 : tree val = c_parser_peek_nth_token (parser, 3)->value;
19630 : 33 : if (integer_onep (val))
19631 : : {
19632 : 33 : c_parser_consume_token (parser);
19633 : 33 : c_parser_consume_token (parser);
19634 : 33 : c_parser_consume_token (parser);
19635 : 33 : tree u = build_omp_clause (clause_loc, OMP_CLAUSE_DOACROSS);
19636 : 33 : OMP_CLAUSE_DOACROSS_KIND (u) = OMP_CLAUSE_DOACROSS_SINK;
19637 : 33 : OMP_CLAUSE_CHAIN (u) = list;
19638 : 33 : return u;
19639 : : }
19640 : : }
19641 : : }
19642 : :
19643 : :
19644 : :
19645 : 1151 : while (c_parser_next_token_is (parser, CPP_NAME)
19646 : 1151 : && c_parser_peek_token (parser)->id_kind == C_ID_ID)
19647 : : {
19648 : 1151 : tree t = lookup_name (c_parser_peek_token (parser)->value);
19649 : 1151 : tree addend = NULL;
19650 : :
19651 : 1151 : if (t == NULL_TREE)
19652 : : {
19653 : 6 : undeclared_variable (c_parser_peek_token (parser)->location,
19654 : 6 : c_parser_peek_token (parser)->value);
19655 : 6 : t = error_mark_node;
19656 : : }
19657 : :
19658 : 1151 : c_parser_consume_token (parser);
19659 : :
19660 : 1151 : bool neg = false;
19661 : 1151 : if (c_parser_next_token_is (parser, CPP_MINUS))
19662 : : neg = true;
19663 : 920 : else if (!c_parser_next_token_is (parser, CPP_PLUS))
19664 : : {
19665 : 857 : addend = integer_zero_node;
19666 : 857 : neg = false;
19667 : 857 : goto add_to_vector;
19668 : : }
19669 : 294 : c_parser_consume_token (parser);
19670 : :
19671 : 294 : if (c_parser_next_token_is_not (parser, CPP_NUMBER))
19672 : : {
19673 : 1 : c_parser_error (parser, "expected integer");
19674 : 1 : return list;
19675 : : }
19676 : :
19677 : 293 : addend = c_parser_peek_token (parser)->value;
19678 : 293 : if (TREE_CODE (addend) != INTEGER_CST)
19679 : : {
19680 : 0 : c_parser_error (parser, "expected integer");
19681 : 0 : return list;
19682 : : }
19683 : 293 : c_parser_consume_token (parser);
19684 : :
19685 : 1150 : add_to_vector:
19686 : 1150 : if (t != error_mark_node)
19687 : : {
19688 : 1145 : vec = tree_cons (addend, t, vec);
19689 : 1145 : if (neg)
19690 : 228 : OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (vec) = 1;
19691 : : }
19692 : :
19693 : 1150 : if (c_parser_next_token_is_not (parser, CPP_COMMA)
19694 : 979 : || c_parser_peek_2nd_token (parser)->type != CPP_NAME
19695 : 2128 : || c_parser_peek_2nd_token (parser)->id_kind != C_ID_ID)
19696 : : break;
19697 : :
19698 : 978 : c_parser_consume_token (parser);
19699 : : }
19700 : :
19701 : 172 : if (vec == NULL_TREE)
19702 : : return list;
19703 : :
19704 : 168 : tree u = build_omp_clause (clause_loc, OMP_CLAUSE_DOACROSS);
19705 : 168 : OMP_CLAUSE_DOACROSS_KIND (u) = OMP_CLAUSE_DOACROSS_SINK;
19706 : 168 : OMP_CLAUSE_DOACROSS_DEPEND (u) = depend_p;
19707 : 168 : OMP_CLAUSE_DECL (u) = nreverse (vec);
19708 : 168 : OMP_CLAUSE_CHAIN (u) = list;
19709 : 168 : return u;
19710 : : }
19711 : :
19712 : : /* OpenMP 5.0:
19713 : : iterators ( iterators-definition )
19714 : :
19715 : : iterators-definition:
19716 : : iterator-specifier
19717 : : iterator-specifier , iterators-definition
19718 : :
19719 : : iterator-specifier:
19720 : : identifier = range-specification
19721 : : iterator-type identifier = range-specification
19722 : :
19723 : : range-specification:
19724 : : begin : end
19725 : : begin : end : step */
19726 : :
19727 : : static tree
19728 : 150 : c_parser_omp_iterators (c_parser *parser)
19729 : : {
19730 : 150 : tree ret = NULL_TREE, *last = &ret;
19731 : 150 : c_parser_consume_token (parser);
19732 : :
19733 : 150 : push_scope ();
19734 : :
19735 : 150 : matching_parens parens;
19736 : 150 : if (!parens.require_open (parser))
19737 : 1 : return error_mark_node;
19738 : :
19739 : 215 : do
19740 : : {
19741 : 182 : tree iter_type = NULL_TREE, type_expr = NULL_TREE;
19742 : 182 : if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
19743 : : {
19744 : 50 : struct c_type_name *type = c_parser_type_name (parser);
19745 : 50 : if (type != NULL)
19746 : 50 : iter_type = groktypename (type, &type_expr, NULL);
19747 : : }
19748 : 50 : if (iter_type == NULL_TREE)
19749 : 132 : iter_type = integer_type_node;
19750 : :
19751 : 182 : location_t loc = c_parser_peek_token (parser)->location;
19752 : 182 : if (!c_parser_next_token_is (parser, CPP_NAME))
19753 : : {
19754 : 8 : c_parser_error (parser, "expected identifier");
19755 : 8 : break;
19756 : : }
19757 : :
19758 : 174 : tree id = c_parser_peek_token (parser)->value;
19759 : 174 : c_parser_consume_token (parser);
19760 : :
19761 : 174 : if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
19762 : : break;
19763 : :
19764 : 172 : location_t eloc = c_parser_peek_token (parser)->location;
19765 : 172 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
19766 : 172 : expr = convert_lvalue_to_rvalue (eloc, expr, true, false);
19767 : 172 : tree begin = expr.value;
19768 : :
19769 : 172 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
19770 : : break;
19771 : :
19772 : 170 : eloc = c_parser_peek_token (parser)->location;
19773 : 170 : expr = c_parser_expr_no_commas (parser, NULL);
19774 : 170 : expr = convert_lvalue_to_rvalue (eloc, expr, true, false);
19775 : 170 : tree end = expr.value;
19776 : :
19777 : 170 : tree step = integer_one_node;
19778 : 170 : if (c_parser_next_token_is (parser, CPP_COLON))
19779 : : {
19780 : 58 : c_parser_consume_token (parser);
19781 : 58 : eloc = c_parser_peek_token (parser)->location;
19782 : 58 : expr = c_parser_expr_no_commas (parser, NULL);
19783 : 58 : expr = convert_lvalue_to_rvalue (eloc, expr, true, false);
19784 : 58 : step = expr.value;
19785 : : }
19786 : :
19787 : 170 : tree iter_var = build_decl (loc, VAR_DECL, id, iter_type);
19788 : 170 : DECL_ARTIFICIAL (iter_var) = 1;
19789 : 170 : DECL_CONTEXT (iter_var) = current_function_decl;
19790 : 170 : pushdecl (iter_var);
19791 : :
19792 : 170 : *last = make_tree_vec (6);
19793 : 170 : TREE_VEC_ELT (*last, 0) = iter_var;
19794 : 170 : TREE_VEC_ELT (*last, 1) = begin;
19795 : 170 : TREE_VEC_ELT (*last, 2) = end;
19796 : 170 : TREE_VEC_ELT (*last, 3) = step;
19797 : 170 : last = &TREE_CHAIN (*last);
19798 : :
19799 : 170 : if (c_parser_next_token_is (parser, CPP_COMMA))
19800 : : {
19801 : 33 : c_parser_consume_token (parser);
19802 : 33 : continue;
19803 : : }
19804 : : break;
19805 : : }
19806 : : while (1);
19807 : :
19808 : 149 : parens.skip_until_found_close (parser);
19809 : 149 : return ret ? ret : error_mark_node;
19810 : : }
19811 : :
19812 : : /* OpenMP 5.0:
19813 : : affinity ( [aff-modifier :] variable-list )
19814 : : aff-modifier:
19815 : : iterator ( iterators-definition ) */
19816 : :
19817 : : static tree
19818 : 146 : c_parser_omp_clause_affinity (c_parser *parser, tree list)
19819 : : {
19820 : 146 : location_t clause_loc = c_parser_peek_token (parser)->location;
19821 : 146 : tree nl, iterators = NULL_TREE;
19822 : :
19823 : 146 : matching_parens parens;
19824 : 146 : if (!parens.require_open (parser))
19825 : : return list;
19826 : :
19827 : 146 : if (c_parser_next_token_is (parser, CPP_NAME))
19828 : : {
19829 : 144 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
19830 : 144 : bool parse_iter = ((strcmp ("iterator", p) == 0)
19831 : 144 : && (c_parser_peek_2nd_token (parser)->type
19832 : 50 : == CPP_OPEN_PAREN));
19833 : 50 : if (parse_iter)
19834 : : {
19835 : 50 : unsigned n = 3;
19836 : 50 : parse_iter = (c_parser_check_balanced_raw_token_sequence (parser, &n)
19837 : 50 : && (c_parser_peek_nth_token_raw (parser, n)->type
19838 : : == CPP_CLOSE_PAREN)
19839 : 100 : && (c_parser_peek_nth_token_raw (parser, n + 1)->type
19840 : : == CPP_COLON));
19841 : : }
19842 : 3 : if (parse_iter)
19843 : : {
19844 : 47 : iterators = c_parser_omp_iterators (parser);
19845 : 47 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
19846 : : {
19847 : 0 : if (iterators)
19848 : 0 : pop_scope ();
19849 : 0 : parens.skip_until_found_close (parser);
19850 : 0 : return list;
19851 : : }
19852 : : }
19853 : : }
19854 : 146 : nl = c_parser_omp_variable_list (parser, clause_loc, OMP_CLAUSE_AFFINITY,
19855 : : list);
19856 : 146 : if (iterators)
19857 : : {
19858 : 47 : tree block = pop_scope ();
19859 : 47 : if (iterators != error_mark_node)
19860 : : {
19861 : 43 : TREE_VEC_ELT (iterators, 5) = block;
19862 : 99 : for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
19863 : 112 : OMP_CLAUSE_DECL (c) = build_tree_list (iterators,
19864 : 56 : OMP_CLAUSE_DECL (c));
19865 : : }
19866 : : }
19867 : :
19868 : 146 : parens.skip_until_found_close (parser);
19869 : 146 : return nl;
19870 : : }
19871 : :
19872 : :
19873 : : /* OpenMP 4.0:
19874 : : depend ( depend-kind: variable-list )
19875 : :
19876 : : depend-kind:
19877 : : in | out | inout
19878 : :
19879 : : OpenMP 4.5:
19880 : : depend ( source )
19881 : :
19882 : : depend ( sink : vec )
19883 : :
19884 : : OpenMP 5.0:
19885 : : depend ( depend-modifier , depend-kind: variable-list )
19886 : :
19887 : : depend-kind:
19888 : : in | out | inout | mutexinoutset | depobj | inoutset
19889 : :
19890 : : depend-modifier:
19891 : : iterator ( iterators-definition ) */
19892 : :
19893 : : static tree
19894 : 893 : c_parser_omp_clause_depend (c_parser *parser, tree list)
19895 : : {
19896 : 893 : location_t clause_loc = c_parser_peek_token (parser)->location;
19897 : 893 : enum omp_clause_depend_kind kind = OMP_CLAUSE_DEPEND_LAST;
19898 : 893 : enum omp_clause_doacross_kind dkind = OMP_CLAUSE_DOACROSS_LAST;
19899 : 893 : tree nl, c, iterators = NULL_TREE;
19900 : :
19901 : 893 : matching_parens parens;
19902 : 893 : if (!parens.require_open (parser))
19903 : : return list;
19904 : :
19905 : 1047 : do
19906 : : {
19907 : 970 : if (c_parser_next_token_is_not (parser, CPP_NAME))
19908 : 0 : goto invalid_kind;
19909 : :
19910 : 970 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
19911 : 970 : if (strcmp ("iterator", p) == 0 && iterators == NULL_TREE)
19912 : : {
19913 : 77 : iterators = c_parser_omp_iterators (parser);
19914 : 77 : c_parser_require (parser, CPP_COMMA, "expected %<,%>");
19915 : 77 : continue;
19916 : : }
19917 : 893 : if (strcmp ("in", p) == 0)
19918 : : kind = OMP_CLAUSE_DEPEND_IN;
19919 : 642 : else if (strcmp ("inout", p) == 0)
19920 : : kind = OMP_CLAUSE_DEPEND_INOUT;
19921 : 423 : else if (strcmp ("inoutset", p) == 0)
19922 : : kind = OMP_CLAUSE_DEPEND_INOUTSET;
19923 : 408 : else if (strcmp ("mutexinoutset", p) == 0)
19924 : : kind = OMP_CLAUSE_DEPEND_MUTEXINOUTSET;
19925 : 387 : else if (strcmp ("out", p) == 0)
19926 : : kind = OMP_CLAUSE_DEPEND_OUT;
19927 : 242 : else if (strcmp ("depobj", p) == 0)
19928 : : kind = OMP_CLAUSE_DEPEND_DEPOBJ;
19929 : 221 : else if (strcmp ("sink", p) == 0)
19930 : : dkind = OMP_CLAUSE_DOACROSS_SINK;
19931 : 98 : else if (strcmp ("source", p) == 0)
19932 : : dkind = OMP_CLAUSE_DOACROSS_SOURCE;
19933 : : else
19934 : 2 : goto invalid_kind;
19935 : 891 : break;
19936 : 77 : }
19937 : : while (1);
19938 : :
19939 : 891 : c_parser_consume_token (parser);
19940 : :
19941 : 891 : if (iterators
19942 : 891 : && (dkind == OMP_CLAUSE_DOACROSS_SOURCE
19943 : 891 : || dkind == OMP_CLAUSE_DOACROSS_SINK))
19944 : : {
19945 : 2 : pop_scope ();
19946 : 2 : error_at (clause_loc, "%<iterator%> modifier incompatible with %qs",
19947 : : dkind == OMP_CLAUSE_DOACROSS_SOURCE ? "source" : "sink");
19948 : 2 : iterators = NULL_TREE;
19949 : : }
19950 : :
19951 : 891 : if (dkind == OMP_CLAUSE_DOACROSS_SOURCE)
19952 : : {
19953 : 96 : c = build_omp_clause (clause_loc, OMP_CLAUSE_DOACROSS);
19954 : 96 : OMP_CLAUSE_DOACROSS_KIND (c) = dkind;
19955 : 96 : OMP_CLAUSE_DOACROSS_DEPEND (c) = 1;
19956 : 96 : OMP_CLAUSE_DECL (c) = NULL_TREE;
19957 : 96 : OMP_CLAUSE_CHAIN (c) = list;
19958 : 96 : parens.skip_until_found_close (parser);
19959 : 96 : return c;
19960 : : }
19961 : :
19962 : 795 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
19963 : 0 : goto resync_fail;
19964 : :
19965 : 795 : if (dkind == OMP_CLAUSE_DOACROSS_SINK)
19966 : 123 : nl = c_parser_omp_clause_doacross_sink (parser, clause_loc, list, true);
19967 : : else
19968 : : {
19969 : 672 : nl = c_parser_omp_variable_list (parser, clause_loc,
19970 : : OMP_CLAUSE_DEPEND, list);
19971 : :
19972 : 672 : if (iterators)
19973 : : {
19974 : 73 : tree block = pop_scope ();
19975 : 73 : if (iterators == error_mark_node)
19976 : : iterators = NULL_TREE;
19977 : : else
19978 : 68 : TREE_VEC_ELT (iterators, 5) = block;
19979 : : }
19980 : :
19981 : 1385 : for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
19982 : : {
19983 : 713 : OMP_CLAUSE_DEPEND_KIND (c) = kind;
19984 : 713 : if (iterators)
19985 : 150 : OMP_CLAUSE_DECL (c)
19986 : 150 : = build_tree_list (iterators, OMP_CLAUSE_DECL (c));
19987 : : }
19988 : : }
19989 : :
19990 : 795 : parens.skip_until_found_close (parser);
19991 : 795 : return nl;
19992 : :
19993 : 2 : invalid_kind:
19994 : 2 : c_parser_error (parser, "invalid depend kind");
19995 : 2 : resync_fail:
19996 : 2 : parens.skip_until_found_close (parser);
19997 : 2 : if (iterators)
19998 : 2 : pop_scope ();
19999 : : return list;
20000 : : }
20001 : :
20002 : : /* OpenMP 5.2:
20003 : : doacross ( source : )
20004 : : doacross ( source : omp_cur_iteration )
20005 : :
20006 : : doacross ( sink : vec )
20007 : : doacross ( sink : omp_cur_iteration - logical_iteration ) */
20008 : :
20009 : : static tree
20010 : 145 : c_parser_omp_clause_doacross (c_parser *parser, tree list)
20011 : : {
20012 : 145 : location_t clause_loc = c_parser_peek_token (parser)->location;
20013 : 145 : enum omp_clause_doacross_kind kind = OMP_CLAUSE_DOACROSS_LAST;
20014 : 145 : tree nl;
20015 : 145 : const char *p;
20016 : :
20017 : 145 : matching_parens parens;
20018 : 145 : if (!parens.require_open (parser))
20019 : : return list;
20020 : :
20021 : 145 : if (c_parser_next_token_is_not (parser, CPP_NAME))
20022 : 0 : goto invalid_kind;
20023 : :
20024 : 145 : p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
20025 : 145 : if (strcmp ("sink", p) == 0)
20026 : : kind = OMP_CLAUSE_DOACROSS_SINK;
20027 : 60 : else if (strcmp ("source", p) == 0)
20028 : : kind = OMP_CLAUSE_DOACROSS_SOURCE;
20029 : : else
20030 : 0 : goto invalid_kind;
20031 : :
20032 : 145 : c_parser_consume_token (parser);
20033 : :
20034 : 145 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
20035 : 4 : goto resync_fail;
20036 : :
20037 : 141 : if (kind == OMP_CLAUSE_DOACROSS_SOURCE)
20038 : : {
20039 : 58 : if (c_parser_next_token_is (parser, CPP_NAME)
20040 : 58 : && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser)->value),
20041 : : "omp_cur_iteration") == 0)
20042 : 28 : c_parser_consume_token (parser);
20043 : 58 : nl = build_omp_clause (clause_loc, OMP_CLAUSE_DOACROSS);
20044 : 58 : OMP_CLAUSE_DOACROSS_KIND (nl) = OMP_CLAUSE_DOACROSS_SOURCE;
20045 : 58 : OMP_CLAUSE_DECL (nl) = NULL_TREE;
20046 : 58 : OMP_CLAUSE_CHAIN (nl) = list;
20047 : : }
20048 : : else
20049 : 83 : nl = c_parser_omp_clause_doacross_sink (parser, clause_loc, list, false);
20050 : :
20051 : 141 : parens.skip_until_found_close (parser);
20052 : 141 : return nl;
20053 : :
20054 : 0 : invalid_kind:
20055 : 0 : c_parser_error (parser, "invalid doacross kind");
20056 : 4 : resync_fail:
20057 : 4 : parens.skip_until_found_close (parser);
20058 : 4 : return list;
20059 : : }
20060 : :
20061 : : /* OpenMP 4.0:
20062 : : map ( map-kind: variable-list )
20063 : : map ( variable-list )
20064 : :
20065 : : map-kind:
20066 : : alloc | to | from | tofrom
20067 : :
20068 : : OpenMP 4.5:
20069 : : map-kind:
20070 : : alloc | to | from | tofrom | release | delete
20071 : :
20072 : : map ( always [,] map-kind: variable-list )
20073 : :
20074 : : OpenMP 5.0:
20075 : : map ( [map-type-modifier[,] ...] map-kind: variable-list )
20076 : :
20077 : : map-type-modifier:
20078 : : always | close | present | iterator (iterators-definition) */
20079 : :
20080 : : static tree
20081 : 1731 : c_parser_omp_clause_map (c_parser *parser, tree list, bool declare_mapper_p)
20082 : : {
20083 : 1731 : location_t clause_loc = c_parser_peek_token (parser)->location;
20084 : 1731 : tree nl, c;
20085 : 1731 : enum gomp_map_kind kind = declare_mapper_p ? GOMP_MAP_UNSET : GOMP_MAP_TOFROM;
20086 : :
20087 : 1731 : matching_parens parens;
20088 : 1731 : if (!parens.require_open (parser))
20089 : : return list;
20090 : :
20091 : : int pos = 1;
20092 : 2300 : int map_kind_pos = 0;
20093 : : int iterator_length = 0;
20094 : 2869 : for (;;)
20095 : : {
20096 : 2300 : c_token *tok = c_parser_peek_nth_token_raw (parser, pos);
20097 : 2300 : if (tok->type != CPP_NAME)
20098 : : break;
20099 : :
20100 : 1984 : const char *p = IDENTIFIER_POINTER (tok->value);
20101 : 1984 : c_token *next_tok = c_parser_peek_nth_token_raw (parser, pos + 1);
20102 : 1984 : if (strcmp (p, "iterator") == 0 && next_tok->type == CPP_OPEN_PAREN)
20103 : : {
20104 : 16 : unsigned n = pos + 2;
20105 : 16 : if (c_parser_check_balanced_raw_token_sequence (parser, &n)
20106 : 16 : && c_parser_peek_nth_token_raw (parser, n)->type
20107 : : == CPP_CLOSE_PAREN)
20108 : : {
20109 : 16 : iterator_length = n - pos + 1;
20110 : 16 : pos = n;
20111 : 16 : next_tok = c_parser_peek_nth_token_raw (parser, pos + 1);
20112 : : }
20113 : : }
20114 : :
20115 : 1984 : if (next_tok->type == CPP_COLON)
20116 : : {
20117 : : map_kind_pos = pos;
20118 : : break;
20119 : : }
20120 : :
20121 : 569 : if (next_tok->type == CPP_COMMA)
20122 : 191 : pos++;
20123 : 378 : else if (c_parser_peek_nth_token_raw (parser, pos + 1)->type
20124 : : == CPP_OPEN_PAREN)
20125 : : {
20126 : 13 : unsigned int npos = pos + 2;
20127 : 13 : if (c_parser_check_balanced_raw_token_sequence (parser, &npos)
20128 : 13 : && (c_parser_peek_nth_token_raw (parser, npos)->type
20129 : : == CPP_CLOSE_PAREN)
20130 : 26 : && (c_parser_peek_nth_token_raw (parser, npos + 1)->type
20131 : : == CPP_COMMA))
20132 : 12 : pos = npos + 1;
20133 : : }
20134 : :
20135 : 569 : pos++;
20136 : 569 : }
20137 : :
20138 : 1731 : int always_modifier = 0;
20139 : 1731 : int close_modifier = 0;
20140 : 1731 : int present_modifier = 0;
20141 : 1731 : int mapper_modifier = 0;
20142 : 1731 : tree mapper_name = NULL_TREE;
20143 : 1731 : tree iterators = NULL_TREE;
20144 : 2097 : for (int pos = 1; pos < map_kind_pos; ++pos)
20145 : : {
20146 : 384 : c_token *tok = c_parser_peek_token (parser);
20147 : :
20148 : 384 : if (tok->type == CPP_COMMA)
20149 : : {
20150 : 162 : c_parser_consume_token (parser);
20151 : 162 : continue;
20152 : : }
20153 : :
20154 : 222 : const char *p = IDENTIFIER_POINTER (tok->value);
20155 : 222 : if (strcmp ("always", p) == 0)
20156 : : {
20157 : 75 : if (always_modifier)
20158 : : {
20159 : 4 : c_parser_error (parser, "too many %<always%> modifiers");
20160 : 4 : parens.skip_until_found_close (parser);
20161 : 4 : return list;
20162 : : }
20163 : 71 : always_modifier++;
20164 : 71 : c_parser_consume_token (parser);
20165 : : }
20166 : 147 : else if (strcmp ("close", p) == 0)
20167 : : {
20168 : 62 : if (close_modifier)
20169 : : {
20170 : 4 : c_parser_error (parser, "too many %<close%> modifiers");
20171 : 4 : parens.skip_until_found_close (parser);
20172 : 4 : return list;
20173 : : }
20174 : 58 : close_modifier++;
20175 : 58 : c_parser_consume_token (parser);
20176 : : }
20177 : 85 : else if (strcmp ("iterator", p) == 0)
20178 : : {
20179 : 16 : if (iterators)
20180 : : {
20181 : 1 : c_parser_error (parser, "too many %<iterator%> modifiers");
20182 : 1 : parens.skip_until_found_close (parser);
20183 : 1 : return list;
20184 : : }
20185 : 15 : iterators = c_parser_omp_iterators (parser);
20186 : 15 : pos += iterator_length - 1;
20187 : : }
20188 : 69 : else if (strcmp ("mapper", p) == 0)
20189 : : {
20190 : 12 : c_parser_consume_token (parser);
20191 : :
20192 : 12 : matching_parens mparens;
20193 : 12 : if (mparens.require_open (parser))
20194 : : {
20195 : 12 : if (mapper_modifier)
20196 : : {
20197 : 0 : c_parser_error (parser, "too many %<mapper%> modifiers");
20198 : : /* Assume it's a well-formed mapper modifier, even if it
20199 : : seems to be in the wrong place. */
20200 : 0 : c_parser_consume_token (parser);
20201 : 0 : mparens.require_close (parser);
20202 : 0 : parens.skip_until_found_close (parser);
20203 : 0 : return list;
20204 : : }
20205 : :
20206 : 12 : tok = c_parser_peek_token (parser);
20207 : :
20208 : 12 : switch (tok->type)
20209 : : {
20210 : 5 : case CPP_NAME:
20211 : 5 : {
20212 : 5 : mapper_name = tok->value;
20213 : 5 : c_parser_consume_token (parser);
20214 : 5 : if (declare_mapper_p)
20215 : : {
20216 : 1 : error_at (tok->location,
20217 : : "in %<declare mapper%> directives, parameter "
20218 : : "to %<mapper%> modifier must be %<default%>");
20219 : : }
20220 : : }
20221 : : break;
20222 : :
20223 : 7 : case CPP_KEYWORD:
20224 : 7 : if (tok->keyword == RID_DEFAULT)
20225 : : {
20226 : 7 : c_parser_consume_token (parser);
20227 : 7 : break;
20228 : : }
20229 : : /* Fallthrough. */
20230 : :
20231 : 0 : default:
20232 : 0 : error_at (tok->location,
20233 : : "expected identifier or %<default%>");
20234 : 0 : return list;
20235 : : }
20236 : :
20237 : 12 : if (!mparens.require_close (parser))
20238 : : {
20239 : 0 : parens.skip_until_found_close (parser);
20240 : 0 : return list;
20241 : : }
20242 : :
20243 : 12 : mapper_modifier++;
20244 : 12 : pos += 3;
20245 : : }
20246 : : }
20247 : 57 : else if (strcmp ("present", p) == 0)
20248 : : {
20249 : 52 : if (present_modifier)
20250 : : {
20251 : 4 : c_parser_error (parser, "too many %<present%> modifiers");
20252 : 4 : parens.skip_until_found_close (parser);
20253 : 4 : return list;
20254 : : }
20255 : 48 : present_modifier++;
20256 : 48 : c_parser_consume_token (parser);
20257 : : }
20258 : : else
20259 : : {
20260 : 5 : c_parser_error (parser, "%<map%> clause with map-type modifier other "
20261 : : "than %<always%>, %<close%>, %<iterator%>, "
20262 : : "%<mapper%> or %<present%>");
20263 : 5 : parens.skip_until_found_close (parser);
20264 : 5 : return list;
20265 : : }
20266 : : }
20267 : :
20268 : 1713 : if (c_parser_next_token_is (parser, CPP_NAME)
20269 : 1713 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
20270 : : {
20271 : 1397 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
20272 : 1397 : int always_present_modifier = always_modifier && present_modifier;
20273 : :
20274 : 1397 : if (strcmp ("alloc", p) == 0)
20275 : 128 : kind = present_modifier ? GOMP_MAP_PRESENT_ALLOC : GOMP_MAP_ALLOC;
20276 : 1269 : else if (strcmp ("to", p) == 0)
20277 : 869 : kind = (always_present_modifier ? GOMP_MAP_ALWAYS_PRESENT_TO
20278 : 447 : : present_modifier ? GOMP_MAP_PRESENT_TO
20279 : 439 : : always_modifier ? GOMP_MAP_ALWAYS_TO
20280 : : : GOMP_MAP_TO);
20281 : 819 : else if (strcmp ("from", p) == 0)
20282 : 954 : kind = (always_present_modifier ? GOMP_MAP_ALWAYS_PRESENT_FROM
20283 : 479 : : present_modifier ? GOMP_MAP_PRESENT_FROM
20284 : 476 : : always_modifier ? GOMP_MAP_ALWAYS_FROM
20285 : : : GOMP_MAP_FROM);
20286 : 335 : else if (strcmp ("tofrom", p) == 0)
20287 : 544 : kind = (always_present_modifier ? GOMP_MAP_ALWAYS_PRESENT_TOFROM
20288 : 280 : : present_modifier ? GOMP_MAP_PRESENT_TOFROM
20289 : 274 : : always_modifier ? GOMP_MAP_ALWAYS_TOFROM
20290 : : : GOMP_MAP_TOFROM);
20291 : 50 : else if (strcmp ("release", p) == 0)
20292 : : kind = GOMP_MAP_RELEASE;
20293 : 15 : else if (strcmp ("delete", p) == 0)
20294 : : kind = GOMP_MAP_DELETE;
20295 : : else
20296 : : {
20297 : 0 : c_parser_error (parser, "invalid map kind");
20298 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
20299 : : "expected %<)%>");
20300 : 0 : return list;
20301 : : }
20302 : 1397 : c_parser_consume_token (parser);
20303 : 1397 : c_parser_consume_token (parser);
20304 : : }
20305 : :
20306 : 1713 : nl = c_parser_omp_variable_list (parser, clause_loc, OMP_CLAUSE_MAP, list,
20307 : : true);
20308 : :
20309 : 1713 : tree last_new = NULL_TREE;
20310 : :
20311 : 1713 : if (iterators)
20312 : : {
20313 : 14 : tree block = pop_scope ();
20314 : 14 : if (iterators == error_mark_node)
20315 : : iterators = NULL_TREE;
20316 : : else
20317 : 14 : TREE_VEC_ELT (iterators, 5) = block;
20318 : : }
20319 : :
20320 : 3832 : for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
20321 : : {
20322 : 2119 : OMP_CLAUSE_SET_MAP_KIND (c, kind);
20323 : 2119 : OMP_CLAUSE_ITERATORS (c) = iterators;
20324 : 2119 : last_new = c;
20325 : : }
20326 : :
20327 : 1713 : if (mapper_name)
20328 : : {
20329 : 5 : tree name = build_omp_clause (input_location, OMP_CLAUSE_MAP);
20330 : 5 : OMP_CLAUSE_SET_MAP_KIND (name, GOMP_MAP_PUSH_MAPPER_NAME);
20331 : 5 : OMP_CLAUSE_DECL (name) = mapper_name;
20332 : 5 : OMP_CLAUSE_CHAIN (name) = nl;
20333 : 5 : nl = name;
20334 : :
20335 : 5 : gcc_assert (last_new);
20336 : :
20337 : 5 : name = build_omp_clause (input_location, OMP_CLAUSE_MAP);
20338 : 5 : OMP_CLAUSE_SET_MAP_KIND (name, GOMP_MAP_POP_MAPPER_NAME);
20339 : 5 : OMP_CLAUSE_DECL (name) = null_pointer_node;
20340 : 5 : OMP_CLAUSE_CHAIN (name) = OMP_CLAUSE_CHAIN (last_new);
20341 : 5 : OMP_CLAUSE_CHAIN (last_new) = name;
20342 : : }
20343 : :
20344 : 1713 : parens.skip_until_found_close (parser);
20345 : 1713 : return nl;
20346 : : }
20347 : :
20348 : : /* OpenMP 4.0:
20349 : : device ( expression )
20350 : :
20351 : : OpenMP 5.0:
20352 : : device ( [device-modifier :] integer-expression )
20353 : :
20354 : : device-modifier:
20355 : : ancestor | device_num */
20356 : :
20357 : : static tree
20358 : 367 : c_parser_omp_clause_device (c_parser *parser, tree list)
20359 : : {
20360 : 367 : location_t clause_loc = c_parser_peek_token (parser)->location;
20361 : 367 : location_t expr_loc;
20362 : 367 : c_expr expr;
20363 : 367 : tree c, t;
20364 : 367 : bool ancestor = false;
20365 : :
20366 : 367 : matching_parens parens;
20367 : 367 : if (!parens.require_open (parser))
20368 : : return list;
20369 : :
20370 : 367 : if (c_parser_next_token_is (parser, CPP_NAME)
20371 : 367 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
20372 : : {
20373 : 50 : c_token *tok = c_parser_peek_token (parser);
20374 : 50 : const char *p = IDENTIFIER_POINTER (tok->value);
20375 : 50 : if (strcmp ("ancestor", p) == 0)
20376 : : {
20377 : : /* A requires directive with the reverse_offload clause must be
20378 : : specified. */
20379 : 25 : if ((omp_requires_mask & OMP_REQUIRES_REVERSE_OFFLOAD) == 0)
20380 : : {
20381 : 1 : error_at (tok->location, "%<ancestor%> device modifier not "
20382 : : "preceded by %<requires%> directive "
20383 : : "with %<reverse_offload%> clause");
20384 : 1 : parens.skip_until_found_close (parser);
20385 : 1 : return list;
20386 : : }
20387 : : ancestor = true;
20388 : : }
20389 : 25 : else if (strcmp ("device_num", p) == 0)
20390 : : ;
20391 : : else
20392 : : {
20393 : 1 : error_at (tok->location, "expected %<ancestor%> or %<device_num%>");
20394 : 1 : parens.skip_until_found_close (parser);
20395 : 1 : return list;
20396 : : }
20397 : 48 : c_parser_consume_token (parser);
20398 : 48 : c_parser_consume_token (parser);
20399 : : }
20400 : :
20401 : 365 : expr_loc = c_parser_peek_token (parser)->location;
20402 : 365 : expr = c_parser_expr_no_commas (parser, NULL);
20403 : 365 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
20404 : 365 : t = expr.value;
20405 : 365 : t = c_fully_fold (t, false, NULL);
20406 : :
20407 : 365 : parens.skip_until_found_close (parser);
20408 : :
20409 : 365 : if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
20410 : : {
20411 : 2 : c_parser_error (parser, "expected integer expression");
20412 : 2 : return list;
20413 : : }
20414 : 363 : if (ancestor && TREE_CODE (t) == INTEGER_CST && !integer_onep (t))
20415 : : {
20416 : 1 : error_at (expr_loc, "the %<device%> clause expression must evaluate to "
20417 : : "%<1%>");
20418 : 1 : return list;
20419 : : }
20420 : :
20421 : 362 : check_no_duplicate_clause (list, OMP_CLAUSE_DEVICE, "device");
20422 : :
20423 : 362 : c = build_omp_clause (clause_loc, OMP_CLAUSE_DEVICE);
20424 : :
20425 : 362 : OMP_CLAUSE_DEVICE_ID (c) = t;
20426 : 362 : OMP_CLAUSE_CHAIN (c) = list;
20427 : 362 : OMP_CLAUSE_DEVICE_ANCESTOR (c) = ancestor;
20428 : :
20429 : 362 : list = c;
20430 : 362 : return list;
20431 : : }
20432 : :
20433 : : /* OpenMP 4.0:
20434 : : dist_schedule ( static )
20435 : : dist_schedule ( static , expression ) */
20436 : :
20437 : : static tree
20438 : 1582 : c_parser_omp_clause_dist_schedule (c_parser *parser, tree list)
20439 : : {
20440 : 1582 : tree c, t = NULL_TREE;
20441 : 1582 : location_t loc = c_parser_peek_token (parser)->location;
20442 : :
20443 : 1582 : matching_parens parens;
20444 : 1582 : if (!parens.require_open (parser))
20445 : : return list;
20446 : :
20447 : 1582 : if (!c_parser_next_token_is_keyword (parser, RID_STATIC))
20448 : : {
20449 : 0 : c_parser_error (parser, "invalid dist_schedule kind");
20450 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
20451 : : "expected %<)%>");
20452 : 0 : return list;
20453 : : }
20454 : :
20455 : 1582 : c_parser_consume_token (parser);
20456 : 1582 : if (c_parser_next_token_is (parser, CPP_COMMA))
20457 : : {
20458 : 1575 : c_parser_consume_token (parser);
20459 : :
20460 : 1575 : location_t expr_loc = c_parser_peek_token (parser)->location;
20461 : 1575 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
20462 : 1575 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
20463 : 1575 : t = expr.value;
20464 : 1575 : t = c_fully_fold (t, false, NULL);
20465 : 1575 : parens.skip_until_found_close (parser);
20466 : : }
20467 : : else
20468 : 7 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
20469 : : "expected %<,%> or %<)%>");
20470 : :
20471 : : /* check_no_duplicate_clause (list, OMP_CLAUSE_DIST_SCHEDULE,
20472 : : "dist_schedule"); */
20473 : 1582 : if (omp_find_clause (list, OMP_CLAUSE_DIST_SCHEDULE))
20474 : 2 : warning_at (loc, OPT_Wopenmp, "too many %qs clauses", "dist_schedule");
20475 : 1582 : if (t == error_mark_node)
20476 : : return list;
20477 : :
20478 : 1582 : c = build_omp_clause (loc, OMP_CLAUSE_DIST_SCHEDULE);
20479 : 1582 : OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c) = t;
20480 : 1582 : OMP_CLAUSE_CHAIN (c) = list;
20481 : 1582 : return c;
20482 : : }
20483 : :
20484 : : /* OpenMP 4.0:
20485 : : proc_bind ( proc-bind-kind )
20486 : :
20487 : : proc-bind-kind:
20488 : : primary | master | close | spread
20489 : : where OpenMP 5.1 added 'primary' and deprecated the alias 'master'. */
20490 : :
20491 : : static tree
20492 : 194 : c_parser_omp_clause_proc_bind (c_parser *parser, tree list)
20493 : : {
20494 : 194 : location_t clause_loc = c_parser_peek_token (parser)->location;
20495 : 194 : enum omp_clause_proc_bind_kind kind;
20496 : 194 : tree c;
20497 : :
20498 : 194 : matching_parens parens;
20499 : 194 : if (!parens.require_open (parser))
20500 : : return list;
20501 : :
20502 : 194 : if (c_parser_next_token_is (parser, CPP_NAME))
20503 : : {
20504 : 194 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
20505 : 194 : if (strcmp ("primary", p) == 0)
20506 : : kind = OMP_CLAUSE_PROC_BIND_PRIMARY;
20507 : 193 : else if (strcmp ("master", p) == 0)
20508 : : kind = OMP_CLAUSE_PROC_BIND_MASTER;
20509 : 177 : else if (strcmp ("close", p) == 0)
20510 : : kind = OMP_CLAUSE_PROC_BIND_CLOSE;
20511 : 165 : else if (strcmp ("spread", p) == 0)
20512 : : kind = OMP_CLAUSE_PROC_BIND_SPREAD;
20513 : : else
20514 : 0 : goto invalid_kind;
20515 : : }
20516 : : else
20517 : 0 : goto invalid_kind;
20518 : :
20519 : 194 : check_no_duplicate_clause (list, OMP_CLAUSE_PROC_BIND, "proc_bind");
20520 : 194 : c_parser_consume_token (parser);
20521 : 194 : parens.skip_until_found_close (parser);
20522 : 194 : c = build_omp_clause (clause_loc, OMP_CLAUSE_PROC_BIND);
20523 : 194 : OMP_CLAUSE_PROC_BIND_KIND (c) = kind;
20524 : 194 : OMP_CLAUSE_CHAIN (c) = list;
20525 : 194 : return c;
20526 : :
20527 : 0 : invalid_kind:
20528 : 0 : c_parser_error (parser, "invalid proc_bind kind");
20529 : 0 : parens.skip_until_found_close (parser);
20530 : 0 : return list;
20531 : : }
20532 : :
20533 : : /* OpenMP 5.0:
20534 : : device_type ( host | nohost | any ) */
20535 : :
20536 : : static tree
20537 : 42 : c_parser_omp_clause_device_type (c_parser *parser, tree list)
20538 : : {
20539 : 42 : location_t clause_loc = c_parser_peek_token (parser)->location;
20540 : 42 : enum omp_clause_device_type_kind kind;
20541 : 42 : tree c;
20542 : :
20543 : 42 : matching_parens parens;
20544 : 42 : if (!parens.require_open (parser))
20545 : : return list;
20546 : :
20547 : 42 : if (c_parser_next_token_is (parser, CPP_NAME))
20548 : : {
20549 : 42 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
20550 : 42 : if (strcmp ("host", p) == 0)
20551 : : kind = OMP_CLAUSE_DEVICE_TYPE_HOST;
20552 : 26 : else if (strcmp ("nohost", p) == 0)
20553 : : kind = OMP_CLAUSE_DEVICE_TYPE_NOHOST;
20554 : 17 : else if (strcmp ("any", p) == 0)
20555 : : kind = OMP_CLAUSE_DEVICE_TYPE_ANY;
20556 : : else
20557 : 0 : goto invalid_kind;
20558 : : }
20559 : : else
20560 : 0 : goto invalid_kind;
20561 : :
20562 : 42 : check_no_duplicate_clause (list, OMP_CLAUSE_DEVICE_TYPE,
20563 : : "device_type");
20564 : 42 : c_parser_consume_token (parser);
20565 : 42 : parens.skip_until_found_close (parser);
20566 : 42 : c = build_omp_clause (clause_loc, OMP_CLAUSE_DEVICE_TYPE);
20567 : 42 : OMP_CLAUSE_DEVICE_TYPE_KIND (c) = kind;
20568 : 42 : OMP_CLAUSE_CHAIN (c) = list;
20569 : 42 : return c;
20570 : :
20571 : 0 : invalid_kind:
20572 : 0 : c_parser_error (parser, "expected %<host%>, %<nohost%> or %<any%>");
20573 : 0 : parens.skip_until_found_close (parser);
20574 : 0 : return list;
20575 : : }
20576 : :
20577 : : /* OpenMP 4.0:
20578 : : from ( variable-list )
20579 : : to ( variable-list )
20580 : :
20581 : : OpenMP 5.1:
20582 : : from ( [motion-modifier[,] [motion-modifier[,]...]:] variable-list )
20583 : : to ( [motion-modifier[,] [motion-modifier[,]...]:] variable-list )
20584 : :
20585 : : motion-modifier:
20586 : : present | iterator (iterators-definition) */
20587 : :
20588 : : static tree
20589 : 2842 : c_parser_omp_clause_from_to (c_parser *parser, enum omp_clause_code kind,
20590 : : tree list)
20591 : : {
20592 : 2842 : location_t loc = c_parser_peek_token (parser)->location;
20593 : 2842 : matching_parens parens;
20594 : 2842 : if (!parens.require_open (parser))
20595 : : return list;
20596 : :
20597 : 5676 : int pos = 1, colon_pos = 0;
20598 : : int iterator_length = 0;
20599 : :
20600 : 5676 : while (c_parser_peek_nth_token_raw (parser, pos)->type == CPP_NAME)
20601 : : {
20602 : 2850 : const char *identifier =
20603 : 2850 : IDENTIFIER_POINTER (c_parser_peek_nth_token_raw (parser, pos)->value);
20604 : 2850 : if (c_parser_peek_nth_token_raw (parser, pos + 1)->type
20605 : : == CPP_OPEN_PAREN)
20606 : : {
20607 : 12 : unsigned int npos = pos + 2;
20608 : 12 : if (c_parser_check_balanced_raw_token_sequence (parser, &npos)
20609 : 12 : && (c_parser_peek_nth_token_raw (parser, npos)->type
20610 : : == CPP_CLOSE_PAREN))
20611 : : {
20612 : 12 : if (strcmp (identifier, "iterator") == 0)
20613 : 12 : iterator_length = npos - pos + 1;
20614 : 12 : pos = npos;
20615 : : }
20616 : : }
20617 : 2850 : if (c_parser_peek_nth_token_raw (parser, pos + 1)->type == CPP_COMMA)
20618 : 8 : pos += 2;
20619 : : else
20620 : : pos++;
20621 : 2850 : if (c_parser_peek_nth_token_raw (parser, pos)->type == CPP_COLON)
20622 : : {
20623 : : colon_pos = pos;
20624 : : break;
20625 : : }
20626 : : }
20627 : :
20628 : 2842 : bool present = false;
20629 : 2842 : tree iterators = NULL_TREE;
20630 : :
20631 : 2862 : for (int pos = 1; pos < colon_pos; ++pos)
20632 : : {
20633 : 22 : c_token *token = c_parser_peek_token (parser);
20634 : 22 : if (token->type == CPP_COMMA)
20635 : : {
20636 : 3 : c_parser_consume_token (parser);
20637 : 3 : continue;
20638 : : }
20639 : 19 : const char *p = IDENTIFIER_POINTER (token->value);
20640 : 19 : if (strcmp ("present", p) == 0)
20641 : : {
20642 : 6 : if (present)
20643 : : {
20644 : 0 : c_parser_error (parser, "too many %<present%> modifiers");
20645 : 0 : parens.skip_until_found_close (parser);
20646 : 0 : return list;
20647 : : }
20648 : 6 : present = true;
20649 : 6 : c_parser_consume_token (parser);
20650 : : }
20651 : 13 : else if (strcmp ("iterator", p) == 0)
20652 : : {
20653 : 12 : if (iterators)
20654 : : {
20655 : 1 : c_parser_error (parser, "too many %<iterator%> modifiers");
20656 : 1 : parens.skip_until_found_close (parser);
20657 : 1 : return list;
20658 : : }
20659 : 11 : iterators = c_parser_omp_iterators (parser);
20660 : 11 : pos += iterator_length - 1;
20661 : : }
20662 : : else
20663 : : {
20664 : 2 : error_at (token->location,
20665 : : "%qs clause with modifier other than %<iterator%> or "
20666 : : "%<present%>",
20667 : : kind == OMP_CLAUSE_TO ? "to" : "from");
20668 : 1 : parens.skip_until_found_close (parser);
20669 : 1 : return list;
20670 : : }
20671 : : }
20672 : :
20673 : 2840 : if (colon_pos)
20674 : 14 : c_parser_require (parser, CPP_COLON, "expected %<:%>");
20675 : :
20676 : 2840 : tree nl = c_parser_omp_variable_list (parser, loc, kind, list);
20677 : 2840 : parens.skip_until_found_close (parser);
20678 : :
20679 : 2840 : if (present)
20680 : 12 : for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
20681 : 6 : OMP_CLAUSE_MOTION_PRESENT (c) = 1;
20682 : :
20683 : 2840 : if (iterators)
20684 : : {
20685 : 9 : tree block = pop_scope ();
20686 : 9 : if (iterators == error_mark_node)
20687 : : iterators = NULL_TREE;
20688 : : else
20689 : 9 : TREE_VEC_ELT (iterators, 5) = block;
20690 : : }
20691 : :
20692 : 9 : if (iterators)
20693 : 22 : for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
20694 : 13 : OMP_CLAUSE_ITERATORS (c) = iterators;
20695 : :
20696 : : return nl;
20697 : : }
20698 : :
20699 : : /* OpenMP 4.0:
20700 : : uniform ( variable-list ) */
20701 : :
20702 : : static tree
20703 : 115 : c_parser_omp_clause_uniform (c_parser *parser, tree list)
20704 : : {
20705 : : /* The clauses location. */
20706 : 115 : location_t loc = c_parser_peek_token (parser)->location;
20707 : :
20708 : 115 : matching_parens parens;
20709 : 115 : if (parens.require_open (parser))
20710 : : {
20711 : 115 : list = c_parser_omp_variable_list (parser, loc, OMP_CLAUSE_UNIFORM,
20712 : : list);
20713 : 115 : parens.skip_until_found_close (parser);
20714 : : }
20715 : 115 : return list;
20716 : : }
20717 : :
20718 : : /* OpenMP 5.1
20719 : : full */
20720 : :
20721 : : static tree
20722 : 69 : c_parser_omp_clause_full (c_parser *parser, tree list)
20723 : : {
20724 : 69 : check_no_duplicate_clause (list, OMP_CLAUSE_FULL, "full");
20725 : :
20726 : 69 : location_t loc = c_parser_peek_token (parser)->location;
20727 : 69 : tree c = build_omp_clause (loc, OMP_CLAUSE_FULL);
20728 : 69 : OMP_CLAUSE_CHAIN (c) = list;
20729 : 69 : return c;
20730 : : }
20731 : :
20732 : : /* OpenMP 5.1
20733 : : partial ( constant-expression ) */
20734 : :
20735 : : static tree
20736 : 230 : c_parser_omp_clause_partial (c_parser *parser, tree list)
20737 : : {
20738 : 230 : tree num = NULL_TREE;
20739 : 230 : location_t loc = c_parser_peek_token (parser)->location;
20740 : :
20741 : 230 : check_no_duplicate_clause (list, OMP_CLAUSE_PARTIAL, "partial");
20742 : :
20743 : 230 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
20744 : : {
20745 : 173 : matching_parens parens;
20746 : 173 : parens.consume_open (parser);
20747 : 173 : num = c_parser_expr_no_commas (parser, NULL).value;
20748 : 173 : parens.skip_until_found_close (parser);
20749 : :
20750 : 173 : if (num == error_mark_node)
20751 : 7 : return list;
20752 : :
20753 : 171 : mark_exp_read (num);
20754 : 171 : num = c_fully_fold (num, false, NULL);
20755 : 171 : HOST_WIDE_INT n;
20756 : 342 : if (!INTEGRAL_TYPE_P (TREE_TYPE (num))
20757 : 170 : || !tree_fits_shwi_p (num)
20758 : 168 : || (n = tree_to_shwi (num)) <= 0
20759 : 337 : || (int) n != n)
20760 : : {
20761 : 5 : error_at (loc, "%<partial%> argument needs positive constant "
20762 : : "integer expression");
20763 : 5 : return list;
20764 : : }
20765 : : }
20766 : :
20767 : 223 : tree c = build_omp_clause (loc, OMP_CLAUSE_PARTIAL);
20768 : 223 : OMP_CLAUSE_PARTIAL_EXPR (c) = num;
20769 : 223 : OMP_CLAUSE_CHAIN (c) = list;
20770 : 223 : return c;
20771 : : }
20772 : :
20773 : : /* OpenMP 5.1
20774 : : novariants ( scalar-expression ) */
20775 : :
20776 : : static tree
20777 : 21 : c_parser_omp_clause_novariants (c_parser *parser, tree list)
20778 : : {
20779 : 21 : matching_parens parens;
20780 : 21 : if (!parens.require_open (parser))
20781 : : return list;
20782 : :
20783 : 21 : location_t loc = c_parser_peek_token (parser)->location;
20784 : 21 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
20785 : 21 : tree t = convert_lvalue_to_rvalue (loc, expr, true, true).value;
20786 : 21 : t = c_objc_common_truthvalue_conversion (loc, t);
20787 : 21 : t = c_fully_fold (t, false, NULL);
20788 : 21 : parens.skip_until_found_close (parser);
20789 : :
20790 : 21 : check_no_duplicate_clause (list, OMP_CLAUSE_NOVARIANTS, "novariants");
20791 : :
20792 : 21 : tree c = build_omp_clause (loc, OMP_CLAUSE_NOVARIANTS);
20793 : 21 : OMP_CLAUSE_NOVARIANTS_EXPR (c) = t;
20794 : 21 : OMP_CLAUSE_CHAIN (c) = list;
20795 : 21 : list = c;
20796 : :
20797 : 21 : return list;
20798 : : }
20799 : :
20800 : : /* OpenMP 5.1
20801 : : nocontext ( scalar-expression ) */
20802 : :
20803 : : static tree
20804 : 23 : c_parser_omp_clause_nocontext (c_parser *parser, tree list)
20805 : : {
20806 : 23 : matching_parens parens;
20807 : 23 : if (!parens.require_open (parser))
20808 : : return list;
20809 : :
20810 : 23 : location_t loc = c_parser_peek_token (parser)->location;
20811 : 23 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
20812 : 23 : tree t = convert_lvalue_to_rvalue (loc, expr, true, true).value;
20813 : 23 : t = c_objc_common_truthvalue_conversion (loc, t);
20814 : 23 : t = c_fully_fold (t, false, NULL);
20815 : 23 : parens.skip_until_found_close (parser);
20816 : :
20817 : 23 : check_no_duplicate_clause (list, OMP_CLAUSE_NOCONTEXT, "nocontext");
20818 : :
20819 : 23 : tree c = build_omp_clause (loc, OMP_CLAUSE_NOCONTEXT);
20820 : 23 : OMP_CLAUSE_NOCONTEXT_EXPR (c) = t;
20821 : 23 : OMP_CLAUSE_CHAIN (c) = list;
20822 : 23 : list = c;
20823 : :
20824 : 23 : return list;
20825 : : }
20826 : :
20827 : : /* OpenMP 5.0:
20828 : : detach ( event-handle ) */
20829 : :
20830 : : static tree
20831 : 34 : c_parser_omp_clause_detach (c_parser *parser, tree list)
20832 : : {
20833 : 34 : matching_parens parens;
20834 : 34 : location_t clause_loc = c_parser_peek_token (parser)->location;
20835 : :
20836 : 34 : if (!parens.require_open (parser))
20837 : : return list;
20838 : :
20839 : 34 : if (c_parser_next_token_is_not (parser, CPP_NAME)
20840 : 34 : || c_parser_peek_token (parser)->id_kind != C_ID_ID)
20841 : : {
20842 : 1 : c_parser_error (parser, "expected identifier");
20843 : 1 : parens.skip_until_found_close (parser);
20844 : 1 : return list;
20845 : : }
20846 : :
20847 : 33 : tree t = lookup_name (c_parser_peek_token (parser)->value);
20848 : 33 : if (t == NULL_TREE)
20849 : : {
20850 : 0 : undeclared_variable (c_parser_peek_token (parser)->location,
20851 : 0 : c_parser_peek_token (parser)->value);
20852 : 0 : parens.skip_until_found_close (parser);
20853 : 0 : return list;
20854 : : }
20855 : 33 : c_parser_consume_token (parser);
20856 : :
20857 : 33 : tree type = TYPE_MAIN_VARIANT (TREE_TYPE (t));
20858 : 33 : if (!INTEGRAL_TYPE_P (type)
20859 : : || TREE_CODE (type) != ENUMERAL_TYPE
20860 : 33 : || TYPE_NAME (type) != get_identifier ("omp_event_handle_t"))
20861 : : {
20862 : 1 : error_at (clause_loc, "%<detach%> clause event handle "
20863 : : "has type %qT rather than "
20864 : : "%<omp_event_handle_t%>",
20865 : : type);
20866 : 1 : parens.skip_until_found_close (parser);
20867 : 1 : return list;
20868 : : }
20869 : :
20870 : 32 : tree u = build_omp_clause (clause_loc, OMP_CLAUSE_DETACH);
20871 : 32 : OMP_CLAUSE_DECL (u) = t;
20872 : 32 : OMP_CLAUSE_CHAIN (u) = list;
20873 : 32 : parens.skip_until_found_close (parser);
20874 : 32 : return u;
20875 : : }
20876 : :
20877 : : /* OpenMP 5.0:
20878 : : destroy ( variable-list ) */
20879 : :
20880 : : static tree
20881 : 41 : c_parser_omp_clause_destroy (c_parser *parser, tree list)
20882 : : {
20883 : 41 : tree nl = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_DESTROY, list);
20884 : 86 : for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
20885 : 45 : TREE_ADDRESSABLE (OMP_CLAUSE_DECL (c)) = 1;
20886 : 41 : return nl;
20887 : : }
20888 : :
20889 : : /* OpenMP 5.1:
20890 : : prefer_type ( const-int-expr-or-string-literal-list )
20891 : :
20892 : : OpenMP 6.0:
20893 : : prefer_type ( { preference-selector-list }, { ... } )
20894 : :
20895 : : with preference-selector being:
20896 : : fr ( identifier-or-string-literal-list )
20897 : : attr ( string-list )
20898 : :
20899 : : Data format:
20900 : : For the foreign runtime identifiers, string values are converted to
20901 : : their integer value; unknown string or integer values are set to
20902 : : GOMP_INTEROP_IFR_KNOWN.
20903 : :
20904 : : Each item (a) GOMP_INTEROP_IFR_SEPARATOR
20905 : : (b) for any 'fr', its integer value.
20906 : : Note: Spec only permits 1 'fr' entry (6.0; changed after TR13)
20907 : : (c) GOMP_INTEROP_IFR_SEPARATOR
20908 : : (d) list of \0-terminated non-empty strings for 'attr'
20909 : : (e) '\0'
20910 : : Tailing '\0'. */
20911 : :
20912 : : static tree
20913 : 125 : c_parser_omp_modifier_prefer_type (c_parser *parser)
20914 : : {
20915 : 125 : if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
20916 : 2 : return error_mark_node;
20917 : :
20918 : 123 : std::string str;
20919 : :
20920 : : /* Old Format: const-int-expr-or-string-literal-list */
20921 : 123 : if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE))
20922 : 240 : while (true)
20923 : : {
20924 : 150 : str += (char) GOMP_INTEROP_IFR_SEPARATOR;
20925 : 150 : if (c_parser_next_token_is (parser, CPP_STRING))
20926 : : {
20927 : 117 : c_expr cval = c_parser_string_literal (parser, false, false);
20928 : 117 : if (cval.value == error_mark_node)
20929 : 1 : return error_mark_node;
20930 : 117 : if ((size_t) TREE_STRING_LENGTH (cval.value)
20931 : 117 : != strlen (TREE_STRING_POINTER (cval.value)) + 1)
20932 : : {
20933 : 1 : error_at (cval.get_location (), "string literal must "
20934 : : "not contain %<\\0%>");
20935 : 1 : parser->error = true;
20936 : 1 : return error_mark_node;
20937 : : }
20938 : :
20939 : 116 : char c = omp_get_fr_id_from_name (TREE_STRING_POINTER (cval.value));
20940 : 116 : if (c == GOMP_INTEROP_IFR_UNKNOWN)
20941 : 3 : warning_at (cval.get_location (), OPT_Wopenmp,
20942 : : "unknown foreign runtime identifier %qs",
20943 : 3 : TREE_STRING_POINTER (cval.value));
20944 : 116 : str += c;
20945 : : }
20946 : : else
20947 : : {
20948 : 33 : c_expr cval = c_parser_expr_no_commas (parser, NULL);
20949 : 33 : tree value = c_fully_fold (cval.value, false, NULL);
20950 : 64 : if (INTEGRAL_TYPE_P (TREE_TYPE (value))
20951 : 61 : && TREE_CODE (value) != INTEGER_CST)
20952 : 3 : value = convert_lvalue_to_rvalue (cval.get_start (), cval,
20953 : : false, true).value;
20954 : 33 : if (TREE_CODE (value) != INTEGER_CST
20955 : 28 : || !tree_fits_shwi_p (value))
20956 : : {
20957 : 5 : c_parser_error (parser, "expected string literal or constant "
20958 : : "integer expression");
20959 : 5 : return error_mark_node;
20960 : : }
20961 : 28 : HOST_WIDE_INT n = tree_to_shwi (value);
20962 : 28 : if (n < 1 || n > GOMP_INTEROP_IFR_LAST)
20963 : : {
20964 : 3 : warning_at (cval.get_location (), OPT_Wopenmp,
20965 : : "unknown foreign runtime identifier %qwd", n);
20966 : 3 : n = GOMP_INTEROP_IFR_UNKNOWN;
20967 : : }
20968 : 28 : str += (char) n;
20969 : : }
20970 : 144 : str += (char) GOMP_INTEROP_IFR_SEPARATOR;
20971 : 144 : str += '\0';
20972 : 144 : if (c_parser_next_token_is (parser, CPP_COMMA))
20973 : : {
20974 : 90 : c_parser_consume_token (parser);
20975 : 90 : continue;
20976 : : }
20977 : 54 : if (!c_parser_require (parser, CPP_CLOSE_PAREN,
20978 : : "expected %<,%> or %<)%>"))
20979 : 0 : return error_mark_node;
20980 : 54 : str += '\0';
20981 : 54 : tree res = build_string (str.length (), str.data ());
20982 : 54 : TREE_TYPE (res) = build_array_type_nelts (unsigned_char_type_node,
20983 : 54 : str.length ());
20984 : 54 : return res;
20985 : 90 : }
20986 : :
20987 : : /* New format. */
20988 : 63 : std::string str2;
20989 : 128 : while (true)
20990 : : {
20991 : 128 : if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
20992 : 1 : return error_mark_node;
20993 : 127 : str += (char) GOMP_INTEROP_IFR_SEPARATOR;
20994 : 127 : str2.clear ();
20995 : 127 : bool has_fr = false;
20996 : 205 : while (true)
20997 : : {
20998 : 166 : c_token *tok = c_parser_peek_token (parser);
20999 : 166 : if (tok->type != CPP_NAME
21000 : 166 : || (strcmp("fr", IDENTIFIER_POINTER (tok->value)) != 0
21001 : 63 : && strcmp("attr", IDENTIFIER_POINTER (tok->value)) != 0))
21002 : : {
21003 : 0 : c_parser_error (parser, "expected %<fr%> or %<attr%> preference "
21004 : : "selector");
21005 : 0 : return error_mark_node;
21006 : : }
21007 : 166 : c_parser_consume_token (parser);
21008 : 166 : bool is_fr = IDENTIFIER_POINTER (tok->value)[0] == 'f';
21009 : 166 : if (is_fr && has_fr)
21010 : : {
21011 : 1 : c_parser_error (parser, "duplicated %<fr%> preference selector");
21012 : 1 : return error_mark_node;
21013 : : }
21014 : 165 : if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
21015 : 0 : return error_mark_node;
21016 : 175 : while (true)
21017 : : {
21018 : 170 : if (c_parser_next_token_is (parser, CPP_STRING))
21019 : : {
21020 : 133 : c_expr cval = c_parser_string_literal (parser, false, false);
21021 : 133 : tree value = cval.value;
21022 : 133 : if (value == error_mark_node)
21023 : 6 : return error_mark_node;
21024 : 133 : if ((size_t) TREE_STRING_LENGTH (value)
21025 : 133 : != strlen (TREE_STRING_POINTER (value)) + 1)
21026 : : {
21027 : 2 : error_at (cval.get_location (), "string literal must "
21028 : : "not contain %<\\0%>");
21029 : 2 : parser->error = true;
21030 : 2 : return error_mark_node;
21031 : : }
21032 : 131 : if (!is_fr)
21033 : : {
21034 : 67 : if (!startswith (TREE_STRING_POINTER (value), "ompx_"))
21035 : : {
21036 : 1 : error_at (cval.get_location (),
21037 : : "%<attr%> string literal must start with "
21038 : : "%<ompx_%>");
21039 : 1 : parser->error = true;
21040 : 1 : return error_mark_node;
21041 : : }
21042 : 66 : if (strchr (TREE_STRING_POINTER (value), ','))
21043 : : {
21044 : 2 : error_at (cval.get_location (),
21045 : : "%<attr%> string literal must not contain "
21046 : : "a comma");
21047 : 2 : parser->error = true;
21048 : 2 : return error_mark_node;
21049 : : }
21050 : 64 : str2 += TREE_STRING_POINTER (value);
21051 : 64 : str2 += '\0';
21052 : : }
21053 : : else
21054 : : {
21055 : 64 : if (*TREE_STRING_POINTER (value) == '\0')
21056 : : {
21057 : 1 : c_parser_error (parser, "non-empty string literal expected");
21058 : 1 : return error_mark_node;
21059 : : }
21060 : 63 : char c = omp_get_fr_id_from_name (TREE_STRING_POINTER (value));
21061 : 63 : if (c == GOMP_INTEROP_IFR_UNKNOWN)
21062 : 3 : warning_at (cval.get_location (), OPT_Wopenmp,
21063 : : "unknown foreign runtime identifier %qs",
21064 : 3 : TREE_STRING_POINTER (value));
21065 : 63 : str += c;
21066 : 63 : has_fr = true;
21067 : : }
21068 : : }
21069 : 37 : else if (!is_fr)
21070 : : {
21071 : 1 : c_parser_error (parser, "expected string literal");
21072 : 1 : return error_mark_node;
21073 : : }
21074 : : else
21075 : : {
21076 : 36 : c_expr cval = c_parser_expr_no_commas (parser, NULL);
21077 : 36 : tree value = c_fully_fold (cval.value, false, NULL);
21078 : 70 : if (INTEGRAL_TYPE_P (TREE_TYPE (value))
21079 : 68 : && TREE_CODE (value) != INTEGER_CST)
21080 : 3 : value = convert_lvalue_to_rvalue (cval.get_start (), cval,
21081 : : false, true).value;
21082 : :
21083 : 36 : if (TREE_CODE (value) != INTEGER_CST
21084 : 32 : || !tree_fits_shwi_p (value))
21085 : : {
21086 : 4 : c_parser_error (parser, "expected string literal or "
21087 : : "constant integer expression");
21088 : 4 : return error_mark_node;
21089 : : }
21090 : 32 : HOST_WIDE_INT n = tree_to_shwi (value);
21091 : 32 : if (n < 1 || n > GOMP_INTEROP_IFR_LAST)
21092 : : {
21093 : 0 : warning_at (cval.get_location (), OPT_Wopenmp,
21094 : : "unknown foreign runtime identifier %qwd", n);
21095 : 0 : n = GOMP_INTEROP_IFR_UNKNOWN;
21096 : : }
21097 : 32 : str += (char) n;
21098 : 32 : has_fr = true;
21099 : : }
21100 : 164 : if (!is_fr
21101 : 223 : && c_parser_next_token_is (parser, CPP_COMMA))
21102 : : {
21103 : 5 : c_parser_consume_token (parser);
21104 : 5 : continue;
21105 : : }
21106 : 213 : if (!c_parser_require (parser, CPP_CLOSE_PAREN,
21107 : : is_fr ? G_("expected %<)%>")
21108 : : : G_("expected %<)%> or %<,%>")))
21109 : 4 : return error_mark_node;
21110 : 150 : break;
21111 : 5 : }
21112 : 150 : if (c_parser_next_token_is (parser, CPP_COMMA))
21113 : : {
21114 : 39 : c_parser_consume_token (parser);
21115 : 39 : continue;
21116 : : }
21117 : 111 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
21118 : : break;
21119 : 2 : c_parser_error (parser, "expected %<,%> or %<}%>");
21120 : 2 : return error_mark_node;
21121 : 39 : }
21122 : 109 : str += (char) GOMP_INTEROP_IFR_SEPARATOR;
21123 : 109 : str += str2;
21124 : 109 : str += '\0';
21125 : 109 : c_parser_consume_token (parser);
21126 : 109 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
21127 : : break;
21128 : 66 : if (!c_parser_require (parser, CPP_COMMA, "expected %<)%> or %<,%>"))
21129 : 1 : return error_mark_node;
21130 : : }
21131 : 43 : c_parser_consume_token (parser);
21132 : 43 : str += '\0';
21133 : 43 : tree res = build_string (str.length (), str.data ());
21134 : 43 : TREE_TYPE (res) = build_array_type_nelts (unsigned_char_type_node,
21135 : 43 : str.length ());
21136 : 43 : return res;
21137 : 186 : }
21138 : :
21139 : : /* OpenMP 5.1
21140 : : modifiers of the 'init' clause, used by the 'init' and the
21141 : : 'append_args' clauses.
21142 : :
21143 : : Modifiers:
21144 : : target
21145 : : targetsync
21146 : : prefer_type (preference-specification)
21147 : :
21148 : : Returns 'false' if an error has been issued. */
21149 : :
21150 : : static bool
21151 : 234 : c_parser_omp_clause_init_modifiers (c_parser *parser, bool *target,
21152 : : bool *targetsync, tree *prefer_type_tree)
21153 : : {
21154 : 234 : *target = false;
21155 : 234 : *targetsync = false;
21156 : 234 : *prefer_type_tree = NULL_TREE;
21157 : :
21158 : 540 : do
21159 : : {
21160 : 387 : c_token *tok = c_parser_peek_token (parser);
21161 : 387 : if (tok->type != CPP_NAME)
21162 : 1 : goto fail;
21163 : 386 : const char *p = IDENTIFIER_POINTER (tok->value);
21164 : 386 : if (strcmp ("targetsync", p) == 0)
21165 : : {
21166 : 105 : if (*targetsync)
21167 : 1 : error_at (tok->location, "duplicate %<targetsync%> modifier");
21168 : 105 : *targetsync = true;
21169 : 105 : c_parser_consume_token (parser);
21170 : : }
21171 : 281 : else if (strcmp ("target", p) == 0)
21172 : : {
21173 : 148 : if (*target)
21174 : 3 : error_at (tok->location, "duplicate %<target%> modifier");
21175 : 148 : *target = true;
21176 : 148 : c_parser_consume_token (parser);
21177 : : }
21178 : 133 : else if (strcmp ("prefer_type", p) == 0)
21179 : : {
21180 : 125 : if (*prefer_type_tree != NULL_TREE)
21181 : 1 : error_at (tok->location, "duplicate %<prefer_type%> modifier");
21182 : 125 : c_parser_consume_token (parser);
21183 : 125 : *prefer_type_tree = c_parser_omp_modifier_prefer_type (parser);
21184 : 125 : if (*prefer_type_tree == error_mark_node)
21185 : : return false;
21186 : : }
21187 : : else
21188 : 8 : goto fail;
21189 : 350 : tok = c_parser_peek_token (parser);
21190 : 350 : if (tok->type == CPP_COMMA)
21191 : : {
21192 : 153 : c_parser_consume_token (parser);
21193 : 153 : continue;
21194 : : }
21195 : : /* Unknown token - either done or an error; handle it in the caller. */
21196 : : return true;
21197 : 153 : }
21198 : : while (true);
21199 : :
21200 : 9 : fail:
21201 : 9 : c_parser_error (parser,
21202 : : "expected %<prefer_type%>, %<target%>, or %<targetsync%>");
21203 : 9 : return false;
21204 : : }
21205 : :
21206 : : /* OpenMP 5.1:
21207 : : init ( [init-modifier-list : ] variable-list )
21208 : :
21209 : : Modifiers:
21210 : : target
21211 : : targetsync
21212 : : prefer_type (preference-specification) */
21213 : :
21214 : : static tree
21215 : 167 : c_parser_omp_clause_init (c_parser *parser, tree list)
21216 : : {
21217 : 167 : location_t loc = c_parser_peek_token (parser)->location;
21218 : :
21219 : 167 : matching_parens parens;
21220 : 167 : if (!parens.require_open (parser))
21221 : : return list;
21222 : :
21223 : 167 : bool target = false;
21224 : 167 : bool targetsync = false;
21225 : 167 : tree prefer_type_tree = NULL_TREE;
21226 : :
21227 : 167 : if (!c_parser_omp_clause_init_modifiers (parser, &target, &targetsync,
21228 : : &prefer_type_tree)
21229 : 167 : || !c_parser_require (parser, CPP_COLON, "expected %<:%>"))
21230 : : {
21231 : 39 : if (prefer_type_tree != error_mark_node)
21232 : 11 : parens.skip_until_found_close (parser);
21233 : 39 : return list;
21234 : : }
21235 : :
21236 : 128 : if (!target && !targetsync)
21237 : 2 : error_at (loc,
21238 : : "missing required %<target%> and/or %<targetsync%> modifier");
21239 : :
21240 : 128 : tree nl = c_parser_omp_variable_list (parser, loc, OMP_CLAUSE_INIT, list,
21241 : : false);
21242 : 128 : parens.skip_until_found_close (parser);
21243 : :
21244 : 280 : for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
21245 : : {
21246 : 152 : TREE_ADDRESSABLE (OMP_CLAUSE_DECL (c)) = 1;
21247 : 152 : if (target)
21248 : 90 : OMP_CLAUSE_INIT_TARGET (c) = 1;
21249 : 152 : if (targetsync)
21250 : 81 : OMP_CLAUSE_INIT_TARGETSYNC (c) = 1;
21251 : 152 : if (prefer_type_tree)
21252 : 73 : OMP_CLAUSE_INIT_PREFER_TYPE (c) = prefer_type_tree;
21253 : : }
21254 : : return nl;
21255 : : }
21256 : :
21257 : : /* OpenMP 5.0:
21258 : : use ( variable-list ) */
21259 : :
21260 : : static tree
21261 : 43 : c_parser_omp_clause_use (c_parser *parser, tree list)
21262 : : {
21263 : 0 : return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_USE, list);
21264 : : }
21265 : :
21266 : : /* OpenMP 6.0:
21267 : : interop ( variable-list ) */
21268 : :
21269 : : static tree
21270 : 43 : c_parser_omp_clause_interop (c_parser *parser, tree list)
21271 : : {
21272 : 43 : check_no_duplicate_clause (list, OMP_CLAUSE_INTEROP, "interop");
21273 : 43 : tree nl = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_INTEROP, list);
21274 : 102 : for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
21275 : : {
21276 : 59 : TREE_USED (OMP_CLAUSE_DECL (c)) = 1;
21277 : 59 : DECL_READ_P (OMP_CLAUSE_DECL (c)) = 1;
21278 : : }
21279 : 43 : return nl;
21280 : : }
21281 : :
21282 : : /* Parse all OpenACC clauses. The set clauses allowed by the directive
21283 : : is a bitmask in MASK. Return the list of clauses found. */
21284 : :
21285 : : static tree
21286 : 5352 : c_parser_oacc_all_clauses (c_parser *parser, omp_clause_mask mask,
21287 : : const char *where, bool finish_p = true,
21288 : : bool target_p = false)
21289 : : {
21290 : 5352 : tree clauses = NULL;
21291 : 5352 : bool first = true;
21292 : :
21293 : 12071 : while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
21294 : : {
21295 : 6765 : location_t here;
21296 : 6765 : pragma_omp_clause c_kind;
21297 : 6765 : const char *c_name;
21298 : 6765 : tree prev = clauses;
21299 : :
21300 : 9375 : if (!first && c_parser_next_token_is (parser, CPP_COMMA))
21301 : 11 : c_parser_consume_token (parser);
21302 : :
21303 : 6765 : here = c_parser_peek_token (parser)->location;
21304 : 6765 : c_kind = c_parser_omp_clause_name (parser);
21305 : :
21306 : 6765 : switch (c_kind)
21307 : : {
21308 : 240 : case PRAGMA_OACC_CLAUSE_ASYNC:
21309 : 240 : clauses = c_parser_oacc_clause_async (parser, clauses);
21310 : 240 : c_name = "async";
21311 : 240 : break;
21312 : 125 : case PRAGMA_OACC_CLAUSE_AUTO:
21313 : 125 : clauses = c_parser_oacc_simple_clause (here, OMP_CLAUSE_AUTO,
21314 : : clauses);
21315 : 125 : c_name = "auto";
21316 : 125 : break;
21317 : 27 : case PRAGMA_OACC_CLAUSE_ATTACH:
21318 : 27 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21319 : 27 : c_name = "attach";
21320 : 27 : break;
21321 : 59 : case PRAGMA_OACC_CLAUSE_COLLAPSE:
21322 : 59 : clauses = c_parser_omp_clause_collapse (parser, clauses);
21323 : 59 : c_name = "collapse";
21324 : 59 : break;
21325 : 806 : case PRAGMA_OACC_CLAUSE_COPY:
21326 : 806 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21327 : 806 : c_name = "copy";
21328 : 806 : break;
21329 : 359 : case PRAGMA_OACC_CLAUSE_COPYIN:
21330 : 359 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21331 : 359 : c_name = "copyin";
21332 : 359 : break;
21333 : 390 : case PRAGMA_OACC_CLAUSE_COPYOUT:
21334 : 390 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21335 : 390 : c_name = "copyout";
21336 : 390 : break;
21337 : 94 : case PRAGMA_OACC_CLAUSE_CREATE:
21338 : 94 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21339 : 94 : c_name = "create";
21340 : 94 : break;
21341 : 68 : case PRAGMA_OACC_CLAUSE_DELETE:
21342 : 68 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21343 : 68 : c_name = "delete";
21344 : 68 : break;
21345 : 88 : case PRAGMA_OMP_CLAUSE_DEFAULT:
21346 : 88 : clauses = c_parser_omp_clause_default (parser, clauses, true);
21347 : 88 : c_name = "default";
21348 : 88 : break;
21349 : 20 : case PRAGMA_OACC_CLAUSE_DETACH:
21350 : 20 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21351 : 20 : c_name = "detach";
21352 : 20 : break;
21353 : 36 : case PRAGMA_OACC_CLAUSE_DEVICE:
21354 : 36 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21355 : 36 : c_name = "device";
21356 : 36 : break;
21357 : 57 : case PRAGMA_OACC_CLAUSE_DEVICEPTR:
21358 : 57 : clauses = c_parser_oacc_data_clause_deviceptr (parser, clauses);
21359 : 57 : c_name = "deviceptr";
21360 : 57 : break;
21361 : 16 : case PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT:
21362 : 16 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21363 : 16 : c_name = "device_resident";
21364 : 16 : break;
21365 : 12 : case PRAGMA_OACC_CLAUSE_FINALIZE:
21366 : 12 : clauses = c_parser_oacc_simple_clause (here, OMP_CLAUSE_FINALIZE,
21367 : : clauses);
21368 : 12 : c_name = "finalize";
21369 : 12 : break;
21370 : 113 : case PRAGMA_OACC_CLAUSE_FIRSTPRIVATE:
21371 : 113 : clauses = c_parser_omp_clause_firstprivate (parser, clauses);
21372 : 113 : c_name = "firstprivate";
21373 : 113 : break;
21374 : 589 : case PRAGMA_OACC_CLAUSE_GANG:
21375 : 589 : c_name = "gang";
21376 : 589 : clauses = c_parser_oacc_shape_clause (parser, here, OMP_CLAUSE_GANG,
21377 : : c_name, clauses);
21378 : 589 : break;
21379 : 41 : case PRAGMA_OACC_CLAUSE_HOST:
21380 : 41 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21381 : 41 : c_name = "host";
21382 : 41 : break;
21383 : 105 : case PRAGMA_OACC_CLAUSE_IF:
21384 : 105 : clauses = c_parser_omp_clause_if (parser, clauses, false);
21385 : 105 : c_name = "if";
21386 : 105 : break;
21387 : 19 : case PRAGMA_OACC_CLAUSE_IF_PRESENT:
21388 : 19 : clauses = c_parser_oacc_simple_clause (here, OMP_CLAUSE_IF_PRESENT,
21389 : : clauses);
21390 : 19 : c_name = "if_present";
21391 : 19 : break;
21392 : 45 : case PRAGMA_OACC_CLAUSE_INDEPENDENT:
21393 : 45 : clauses = c_parser_oacc_simple_clause (here, OMP_CLAUSE_INDEPENDENT,
21394 : : clauses);
21395 : 45 : c_name = "independent";
21396 : 45 : break;
21397 : 13 : case PRAGMA_OACC_CLAUSE_LINK:
21398 : 13 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21399 : 13 : c_name = "link";
21400 : 13 : break;
21401 : 10 : case PRAGMA_OACC_CLAUSE_NO_CREATE:
21402 : 10 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21403 : 10 : c_name = "no_create";
21404 : 10 : break;
21405 : 25 : case PRAGMA_OACC_CLAUSE_NOHOST:
21406 : 25 : clauses = c_parser_oacc_simple_clause (here, OMP_CLAUSE_NOHOST,
21407 : : clauses);
21408 : 25 : c_name = "nohost";
21409 : 25 : break;
21410 : 302 : case PRAGMA_OACC_CLAUSE_NUM_GANGS:
21411 : 302 : clauses = c_parser_oacc_single_int_clause (parser,
21412 : : OMP_CLAUSE_NUM_GANGS,
21413 : : clauses);
21414 : 302 : c_name = "num_gangs";
21415 : 302 : break;
21416 : 207 : case PRAGMA_OACC_CLAUSE_NUM_WORKERS:
21417 : 207 : clauses = c_parser_oacc_single_int_clause (parser,
21418 : : OMP_CLAUSE_NUM_WORKERS,
21419 : : clauses);
21420 : 207 : c_name = "num_workers";
21421 : 207 : break;
21422 : 128 : case PRAGMA_OACC_CLAUSE_PRESENT:
21423 : 128 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21424 : 128 : c_name = "present";
21425 : 128 : break;
21426 : 66 : case PRAGMA_OACC_CLAUSE_PRIVATE:
21427 : 66 : clauses = c_parser_omp_clause_private (parser, clauses);
21428 : 66 : c_name = "private";
21429 : 66 : break;
21430 : 905 : case PRAGMA_OACC_CLAUSE_REDUCTION:
21431 : 905 : clauses
21432 : 905 : = c_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
21433 : : false, clauses);
21434 : 905 : c_name = "reduction";
21435 : 905 : break;
21436 : 66 : case PRAGMA_OACC_CLAUSE_SELF:
21437 : 66 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST)) == 0)
21438 : : /* OpenACC compute construct */
21439 : 48 : clauses = c_parser_oacc_compute_clause_self (parser, clauses);
21440 : : else
21441 : : /* OpenACC 'update' directive */
21442 : 18 : clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
21443 : : c_name = "self";
21444 : : break;
21445 : 261 : case PRAGMA_OACC_CLAUSE_SEQ:
21446 : 261 : clauses = c_parser_oacc_simple_clause (here, OMP_CLAUSE_SEQ,
21447 : : clauses);
21448 : 261 : c_name = "seq";
21449 : 261 : break;
21450 : 123 : case PRAGMA_OACC_CLAUSE_TILE:
21451 : 123 : clauses = c_parser_oacc_clause_tile (parser, clauses);
21452 : 123 : c_name = "tile";
21453 : 123 : break;
21454 : 21 : case PRAGMA_OACC_CLAUSE_USE_DEVICE:
21455 : 21 : clauses = c_parser_omp_clause_use_device_ptr (parser, clauses);
21456 : 21 : c_name = "use_device";
21457 : 21 : break;
21458 : 518 : case PRAGMA_OACC_CLAUSE_VECTOR:
21459 : 518 : c_name = "vector";
21460 : 518 : clauses = c_parser_oacc_shape_clause (parser, here, OMP_CLAUSE_VECTOR,
21461 : : c_name, clauses);
21462 : 518 : break;
21463 : 223 : case PRAGMA_OACC_CLAUSE_VECTOR_LENGTH:
21464 : 223 : clauses = c_parser_oacc_single_int_clause (parser,
21465 : : OMP_CLAUSE_VECTOR_LENGTH,
21466 : : clauses);
21467 : 223 : c_name = "vector_length";
21468 : 223 : break;
21469 : 89 : case PRAGMA_OACC_CLAUSE_WAIT:
21470 : 89 : clauses = c_parser_oacc_clause_wait (parser, clauses);
21471 : 89 : c_name = "wait";
21472 : 89 : break;
21473 : 453 : case PRAGMA_OACC_CLAUSE_WORKER:
21474 : 453 : c_name = "worker";
21475 : 453 : clauses = c_parser_oacc_shape_clause (parser, here, OMP_CLAUSE_WORKER,
21476 : : c_name, clauses);
21477 : 453 : break;
21478 : 46 : default:
21479 : 46 : c_parser_error (parser, "expected an OpenACC clause");
21480 : 46 : goto saw_error;
21481 : : }
21482 : :
21483 : 6719 : first = false;
21484 : :
21485 : 6719 : if (((mask >> c_kind) & 1) == 0)
21486 : : {
21487 : : /* Remove the invalid clause(s) from the list to avoid
21488 : : confusing the rest of the compiler. */
21489 : 18 : clauses = prev;
21490 : 18 : error_at (here, "%qs is not valid for %qs", c_name, where);
21491 : : }
21492 : : }
21493 : :
21494 : 5306 : saw_error:
21495 : 5352 : c_parser_skip_to_pragma_eol (parser);
21496 : :
21497 : 5352 : if (finish_p)
21498 : 7831 : return c_finish_omp_clauses (clauses, target_p ? C_ORT_ACC_TARGET
21499 : 4656 : : C_ORT_ACC);
21500 : :
21501 : : return clauses;
21502 : : }
21503 : :
21504 : : /* Parse all OpenMP clauses. The set clauses allowed by the directive
21505 : : is a bitmask in MASK. Return the list of clauses found.
21506 : : FINISH_P set if c_finish_omp_clauses should be called.
21507 : : NESTED non-zero if clauses should be terminated by closing paren instead
21508 : : of end of pragma. If it is 2, additionally commas are required in between
21509 : : the clauses. */
21510 : :
21511 : : static tree
21512 : 19910 : c_parser_omp_all_clauses (c_parser *parser, omp_clause_mask mask,
21513 : : const char *where, bool finish_p = true,
21514 : : int nested = 0)
21515 : : {
21516 : 19910 : tree clauses = NULL;
21517 : 19910 : bool first = true;
21518 : :
21519 : 47096 : while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
21520 : : {
21521 : 27271 : location_t here;
21522 : 27271 : pragma_omp_clause c_kind;
21523 : 27271 : const char *c_name;
21524 : 27271 : tree prev = clauses;
21525 : :
21526 : 27368 : if (nested && c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
21527 : : break;
21528 : :
21529 : 27249 : if (!first || nested != 2)
21530 : : {
21531 : 27226 : if (c_parser_next_token_is (parser, CPP_COMMA))
21532 : 2693 : c_parser_consume_token (parser);
21533 : 24533 : else if (nested == 2)
21534 : 3 : error_at (c_parser_peek_token (parser)->location,
21535 : : "clauses in %<simd%> trait should be separated "
21536 : : "by %<,%>");
21537 : : }
21538 : :
21539 : 27249 : here = c_parser_peek_token (parser)->location;
21540 : 27249 : c_kind = c_parser_omp_clause_name (parser);
21541 : :
21542 : 27249 : switch (c_kind)
21543 : : {
21544 : 115 : case PRAGMA_OMP_CLAUSE_BIND:
21545 : 115 : clauses = c_parser_omp_clause_bind (parser, clauses);
21546 : 115 : c_name = "bind";
21547 : 115 : break;
21548 : 2887 : case PRAGMA_OMP_CLAUSE_COLLAPSE:
21549 : 2887 : clauses = c_parser_omp_clause_collapse (parser, clauses);
21550 : 2887 : c_name = "collapse";
21551 : 2887 : break;
21552 : 101 : case PRAGMA_OMP_CLAUSE_COPYIN:
21553 : 101 : clauses = c_parser_omp_clause_copyin (parser, clauses);
21554 : 101 : c_name = "copyin";
21555 : 101 : break;
21556 : 21 : case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
21557 : 21 : clauses = c_parser_omp_clause_copyprivate (parser, clauses);
21558 : 21 : c_name = "copyprivate";
21559 : 21 : break;
21560 : 640 : case PRAGMA_OMP_CLAUSE_DEFAULT:
21561 : 640 : clauses = c_parser_omp_clause_default (parser, clauses, false);
21562 : 640 : c_name = "default";
21563 : 640 : break;
21564 : 34 : case PRAGMA_OMP_CLAUSE_DETACH:
21565 : 34 : clauses = c_parser_omp_clause_detach (parser, clauses);
21566 : 34 : c_name = "detach";
21567 : 34 : break;
21568 : 62 : case PRAGMA_OMP_CLAUSE_FILTER:
21569 : 62 : clauses = c_parser_omp_clause_filter (parser, clauses);
21570 : 62 : c_name = "filter";
21571 : 62 : break;
21572 : 664 : case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
21573 : 664 : clauses = c_parser_omp_clause_firstprivate (parser, clauses);
21574 : 664 : c_name = "firstprivate";
21575 : 664 : break;
21576 : 98 : case PRAGMA_OMP_CLAUSE_FINAL:
21577 : 98 : clauses = c_parser_omp_clause_final (parser, clauses);
21578 : 98 : c_name = "final";
21579 : 98 : break;
21580 : 62 : case PRAGMA_OMP_CLAUSE_GRAINSIZE:
21581 : 62 : clauses = c_parser_omp_clause_grainsize (parser, clauses);
21582 : 62 : c_name = "grainsize";
21583 : 62 : break;
21584 : 29 : case PRAGMA_OMP_CLAUSE_HINT:
21585 : 29 : clauses = c_parser_omp_clause_hint (parser, clauses);
21586 : 29 : c_name = "hint";
21587 : 29 : break;
21588 : 239 : case PRAGMA_OMP_CLAUSE_DEFAULTMAP:
21589 : 239 : clauses = c_parser_omp_clause_defaultmap (parser, clauses);
21590 : 239 : c_name = "defaultmap";
21591 : 239 : break;
21592 : 778 : case PRAGMA_OMP_CLAUSE_IF:
21593 : 778 : clauses = c_parser_omp_clause_if (parser, clauses, true);
21594 : 778 : c_name = "if";
21595 : 778 : break;
21596 : 320 : case PRAGMA_OMP_CLAUSE_IN_REDUCTION:
21597 : 320 : clauses
21598 : 320 : = c_parser_omp_clause_reduction (parser, OMP_CLAUSE_IN_REDUCTION,
21599 : : true, clauses);
21600 : 320 : c_name = "in_reduction";
21601 : 320 : break;
21602 : 26 : case PRAGMA_OMP_CLAUSE_INDIRECT:
21603 : 26 : clauses = c_parser_omp_clause_indirect (parser, clauses);
21604 : 26 : c_name = "indirect";
21605 : 26 : break;
21606 : 731 : case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
21607 : 731 : clauses = c_parser_omp_clause_lastprivate (parser, clauses);
21608 : 731 : c_name = "lastprivate";
21609 : 731 : break;
21610 : 78 : case PRAGMA_OMP_CLAUSE_MERGEABLE:
21611 : 78 : clauses = c_parser_omp_clause_mergeable (parser, clauses);
21612 : 78 : c_name = "mergeable";
21613 : 78 : break;
21614 : 391 : case PRAGMA_OMP_CLAUSE_NOWAIT:
21615 : 391 : clauses = c_parser_omp_clause_nowait (parser, clauses);
21616 : 391 : c_name = "nowait";
21617 : 391 : break;
21618 : 49 : case PRAGMA_OMP_CLAUSE_NUM_TASKS:
21619 : 49 : clauses = c_parser_omp_clause_num_tasks (parser, clauses);
21620 : 49 : c_name = "num_tasks";
21621 : 49 : break;
21622 : 424 : case PRAGMA_OMP_CLAUSE_NUM_THREADS:
21623 : 424 : clauses = c_parser_omp_clause_num_threads (parser, clauses);
21624 : 424 : c_name = "num_threads";
21625 : 424 : break;
21626 : 375 : case PRAGMA_OMP_CLAUSE_ORDER:
21627 : 375 : clauses = c_parser_omp_clause_order (parser, clauses);
21628 : 375 : c_name = "order";
21629 : 375 : break;
21630 : 309 : case PRAGMA_OMP_CLAUSE_ORDERED:
21631 : 309 : clauses = c_parser_omp_clause_ordered (parser, clauses);
21632 : 309 : c_name = "ordered";
21633 : 309 : break;
21634 : 97 : case PRAGMA_OMP_CLAUSE_PRIORITY:
21635 : 97 : clauses = c_parser_omp_clause_priority (parser, clauses);
21636 : 97 : c_name = "priority";
21637 : 97 : break;
21638 : 669 : case PRAGMA_OMP_CLAUSE_PRIVATE:
21639 : 669 : clauses = c_parser_omp_clause_private (parser, clauses);
21640 : 669 : c_name = "private";
21641 : 669 : break;
21642 : 1778 : case PRAGMA_OMP_CLAUSE_REDUCTION:
21643 : 1778 : clauses
21644 : 1778 : = c_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
21645 : : true, clauses);
21646 : 1778 : c_name = "reduction";
21647 : 1778 : break;
21648 : 3467 : case PRAGMA_OMP_CLAUSE_SCHEDULE:
21649 : 3467 : clauses = c_parser_omp_clause_schedule (parser, clauses);
21650 : 3467 : c_name = "schedule";
21651 : 3467 : break;
21652 : 689 : case PRAGMA_OMP_CLAUSE_SHARED:
21653 : 689 : clauses = c_parser_omp_clause_shared (parser, clauses);
21654 : 689 : c_name = "shared";
21655 : 689 : break;
21656 : 86 : case PRAGMA_OMP_CLAUSE_TASK_REDUCTION:
21657 : 86 : clauses
21658 : 86 : = c_parser_omp_clause_reduction (parser, OMP_CLAUSE_TASK_REDUCTION,
21659 : : true, clauses);
21660 : 86 : c_name = "task_reduction";
21661 : 86 : break;
21662 : 96 : case PRAGMA_OMP_CLAUSE_UNTIED:
21663 : 96 : clauses = c_parser_omp_clause_untied (parser, clauses);
21664 : 96 : c_name = "untied";
21665 : 96 : break;
21666 : 63 : case PRAGMA_OMP_CLAUSE_INBRANCH:
21667 : 63 : clauses = c_parser_omp_clause_branch (parser, OMP_CLAUSE_INBRANCH,
21668 : : clauses);
21669 : 63 : c_name = "inbranch";
21670 : 63 : break;
21671 : 121 : case PRAGMA_OMP_CLAUSE_NONTEMPORAL:
21672 : 121 : clauses = c_parser_omp_clause_nontemporal (parser, clauses);
21673 : 121 : c_name = "nontemporal";
21674 : 121 : break;
21675 : 136 : case PRAGMA_OMP_CLAUSE_NOTINBRANCH:
21676 : 136 : clauses = c_parser_omp_clause_branch (parser, OMP_CLAUSE_NOTINBRANCH,
21677 : : clauses);
21678 : 136 : c_name = "notinbranch";
21679 : 136 : break;
21680 : 107 : case PRAGMA_OMP_CLAUSE_PARALLEL:
21681 : 107 : clauses
21682 : 107 : = c_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_PARALLEL,
21683 : : clauses);
21684 : 107 : c_name = "parallel";
21685 : 107 : if (!first)
21686 : : {
21687 : 0 : clause_not_first:
21688 : 0 : error_at (here, "%qs must be the first clause of %qs",
21689 : : c_name, where);
21690 : 0 : clauses = prev;
21691 : : }
21692 : : break;
21693 : 84 : case PRAGMA_OMP_CLAUSE_FOR:
21694 : 84 : clauses
21695 : 84 : = c_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_FOR,
21696 : : clauses);
21697 : 84 : c_name = "for";
21698 : 84 : if (!first)
21699 : 0 : goto clause_not_first;
21700 : : break;
21701 : 78 : case PRAGMA_OMP_CLAUSE_SECTIONS:
21702 : 78 : clauses
21703 : 78 : = c_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_SECTIONS,
21704 : : clauses);
21705 : 78 : c_name = "sections";
21706 : 78 : if (!first)
21707 : 0 : goto clause_not_first;
21708 : : break;
21709 : 110 : case PRAGMA_OMP_CLAUSE_TASKGROUP:
21710 : 110 : clauses
21711 : 110 : = c_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_TASKGROUP,
21712 : : clauses);
21713 : 110 : c_name = "taskgroup";
21714 : 110 : if (!first)
21715 : 0 : goto clause_not_first;
21716 : : break;
21717 : 32 : case PRAGMA_OMP_CLAUSE_LINK:
21718 : 32 : clauses
21719 : 32 : = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_LINK, clauses);
21720 : 32 : c_name = "link";
21721 : 32 : break;
21722 : 475 : case PRAGMA_OMP_CLAUSE_TO:
21723 : 475 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK)) != 0)
21724 : : {
21725 : 83 : tree nl = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ENTER,
21726 : : clauses);
21727 : 185 : for (tree c = nl; c != clauses; c = OMP_CLAUSE_CHAIN (c))
21728 : 102 : OMP_CLAUSE_ENTER_TO (c) = 1;
21729 : : clauses = nl;
21730 : : }
21731 : : else
21732 : 392 : clauses = c_parser_omp_clause_from_to (parser, OMP_CLAUSE_TO,
21733 : : clauses);
21734 : : c_name = "to";
21735 : : break;
21736 : 2450 : case PRAGMA_OMP_CLAUSE_FROM:
21737 : 2450 : clauses = c_parser_omp_clause_from_to (parser, OMP_CLAUSE_FROM,
21738 : : clauses);
21739 : 2450 : c_name = "from";
21740 : 2450 : break;
21741 : 115 : case PRAGMA_OMP_CLAUSE_UNIFORM:
21742 : 115 : clauses = c_parser_omp_clause_uniform (parser, clauses);
21743 : 115 : c_name = "uniform";
21744 : 115 : break;
21745 : 195 : case PRAGMA_OMP_CLAUSE_NUM_TEAMS:
21746 : 195 : clauses = c_parser_omp_clause_num_teams (parser, clauses);
21747 : 195 : c_name = "num_teams";
21748 : 195 : break;
21749 : 154 : case PRAGMA_OMP_CLAUSE_THREAD_LIMIT:
21750 : 154 : clauses = c_parser_omp_clause_thread_limit (parser, clauses);
21751 : 154 : c_name = "thread_limit";
21752 : 154 : break;
21753 : 228 : case PRAGMA_OMP_CLAUSE_ALIGNED:
21754 : 228 : clauses = c_parser_omp_clause_aligned (parser, clauses);
21755 : 228 : c_name = "aligned";
21756 : 228 : break;
21757 : 467 : case PRAGMA_OMP_CLAUSE_ALLOCATE:
21758 : 467 : clauses = c_parser_omp_clause_allocate (parser, clauses);
21759 : 467 : c_name = "allocate";
21760 : 467 : break;
21761 : 474 : case PRAGMA_OMP_CLAUSE_LINEAR:
21762 : 474 : clauses = c_parser_omp_clause_linear (parser, clauses);
21763 : 474 : c_name = "linear";
21764 : 474 : break;
21765 : 146 : case PRAGMA_OMP_CLAUSE_AFFINITY:
21766 : 146 : clauses = c_parser_omp_clause_affinity (parser, clauses);
21767 : 146 : c_name = "affinity";
21768 : 146 : break;
21769 : 855 : case PRAGMA_OMP_CLAUSE_DEPEND:
21770 : 855 : clauses = c_parser_omp_clause_depend (parser, clauses);
21771 : 855 : c_name = "depend";
21772 : 855 : break;
21773 : 145 : case PRAGMA_OMP_CLAUSE_DOACROSS:
21774 : 145 : clauses = c_parser_omp_clause_doacross (parser, clauses);
21775 : 145 : c_name = "doacross";
21776 : 145 : break;
21777 : 41 : case PRAGMA_OMP_CLAUSE_DESTROY:
21778 : 41 : clauses = c_parser_omp_clause_destroy (parser, clauses);
21779 : 41 : c_name = "destroy";
21780 : 41 : break;
21781 : 167 : case PRAGMA_OMP_CLAUSE_INIT:
21782 : 167 : clauses = c_parser_omp_clause_init (parser, clauses);
21783 : 167 : c_name = "init";
21784 : 167 : break;
21785 : 43 : case PRAGMA_OMP_CLAUSE_USE:
21786 : 43 : clauses = c_parser_omp_clause_use (parser, clauses);
21787 : 43 : c_name = "use";
21788 : 43 : break;
21789 : 43 : case PRAGMA_OMP_CLAUSE_INTEROP:
21790 : 43 : clauses = c_parser_omp_clause_interop (parser, clauses);
21791 : 43 : c_name = "interop";
21792 : 43 : break;
21793 : 1662 : case PRAGMA_OMP_CLAUSE_MAP:
21794 : 1662 : clauses = c_parser_omp_clause_map (parser, clauses, false);
21795 : 1662 : c_name = "map";
21796 : 1662 : break;
21797 : 10 : case PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR:
21798 : 10 : clauses = c_parser_omp_clause_use_device_ptr (parser, clauses);
21799 : 10 : c_name = "use_device_ptr";
21800 : 10 : break;
21801 : 35 : case PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR:
21802 : 35 : clauses = c_parser_omp_clause_use_device_addr (parser, clauses);
21803 : 35 : c_name = "use_device_addr";
21804 : 35 : break;
21805 : 87 : case PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR:
21806 : 87 : clauses = c_parser_omp_clause_has_device_addr (parser, clauses);
21807 : 87 : c_name = "has_device_addr";
21808 : 87 : break;
21809 : 114 : case PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR:
21810 : 114 : clauses = c_parser_omp_clause_is_device_ptr (parser, clauses);
21811 : 114 : c_name = "is_device_ptr";
21812 : 114 : break;
21813 : 367 : case PRAGMA_OMP_CLAUSE_DEVICE:
21814 : 367 : clauses = c_parser_omp_clause_device (parser, clauses);
21815 : 367 : c_name = "device";
21816 : 367 : break;
21817 : 1582 : case PRAGMA_OMP_CLAUSE_DIST_SCHEDULE:
21818 : 1582 : clauses = c_parser_omp_clause_dist_schedule (parser, clauses);
21819 : 1582 : c_name = "dist_schedule";
21820 : 1582 : break;
21821 : 194 : case PRAGMA_OMP_CLAUSE_PROC_BIND:
21822 : 194 : clauses = c_parser_omp_clause_proc_bind (parser, clauses);
21823 : 194 : c_name = "proc_bind";
21824 : 194 : break;
21825 : 42 : case PRAGMA_OMP_CLAUSE_DEVICE_TYPE:
21826 : 42 : clauses = c_parser_omp_clause_device_type (parser, clauses);
21827 : 42 : c_name = "device_type";
21828 : 42 : break;
21829 : 227 : case PRAGMA_OMP_CLAUSE_SAFELEN:
21830 : 227 : clauses = c_parser_omp_clause_safelen (parser, clauses);
21831 : 227 : c_name = "safelen";
21832 : 227 : break;
21833 : 317 : case PRAGMA_OMP_CLAUSE_SIMDLEN:
21834 : 317 : clauses = c_parser_omp_clause_simdlen (parser, clauses);
21835 : 317 : c_name = "simdlen";
21836 : 317 : break;
21837 : 18 : case PRAGMA_OMP_CLAUSE_NOGROUP:
21838 : 18 : clauses = c_parser_omp_clause_nogroup (parser, clauses);
21839 : 18 : c_name = "nogroup";
21840 : 18 : break;
21841 : 46 : case PRAGMA_OMP_CLAUSE_THREADS:
21842 : 46 : clauses
21843 : 46 : = c_parser_omp_clause_orderedkind (parser, OMP_CLAUSE_THREADS,
21844 : : clauses);
21845 : 46 : c_name = "threads";
21846 : 46 : break;
21847 : 57 : case PRAGMA_OMP_CLAUSE_SIMD:
21848 : 57 : clauses
21849 : 57 : = c_parser_omp_clause_orderedkind (parser, OMP_CLAUSE_SIMD,
21850 : : clauses);
21851 : 57 : c_name = "simd";
21852 : 57 : break;
21853 : 41 : case PRAGMA_OMP_CLAUSE_ENTER:
21854 : 41 : clauses
21855 : 41 : = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ENTER,
21856 : : clauses);
21857 : 41 : c_name = "enter";
21858 : 41 : break;
21859 : 69 : case PRAGMA_OMP_CLAUSE_FULL:
21860 : 69 : c_name = "full";
21861 : 69 : clauses = c_parser_omp_clause_full (parser, clauses);
21862 : 69 : break;
21863 : 230 : case PRAGMA_OMP_CLAUSE_PARTIAL:
21864 : 230 : c_name = "partial";
21865 : 230 : clauses = c_parser_omp_clause_partial (parser, clauses);
21866 : 230 : break;
21867 : 21 : case PRAGMA_OMP_CLAUSE_NOVARIANTS:
21868 : 21 : c_name = "novariants";
21869 : 21 : clauses = c_parser_omp_clause_novariants (parser, clauses);
21870 : 21 : break;
21871 : 23 : case PRAGMA_OMP_CLAUSE_NOCONTEXT:
21872 : 23 : c_name = "nocontext";
21873 : 23 : clauses = c_parser_omp_clause_nocontext (parser, clauses);
21874 : 23 : break;
21875 : 63 : default:
21876 : 63 : c_parser_error (parser, "expected an OpenMP clause");
21877 : 63 : goto saw_error;
21878 : : }
21879 : :
21880 : 27186 : first = false;
21881 : :
21882 : 27186 : if (((mask >> c_kind) & 1) == 0)
21883 : : {
21884 : : /* Remove the invalid clause(s) from the list to avoid
21885 : : confusing the rest of the compiler. */
21886 : 24 : clauses = prev;
21887 : 24 : error_at (here, "%qs is not valid for %qs", c_name, where);
21888 : : }
21889 : : }
21890 : :
21891 : 19825 : saw_error:
21892 : 19910 : if (!nested)
21893 : 19887 : c_parser_skip_to_pragma_eol (parser);
21894 : :
21895 : 19910 : if (finish_p)
21896 : : {
21897 : 11357 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM)) != 0)
21898 : 386 : return c_finish_omp_clauses (clauses, C_ORT_OMP_DECLARE_SIMD);
21899 : 10971 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE)) != 0)
21900 : 183 : return c_finish_omp_clauses (clauses, C_ORT_OMP_INTEROP);
21901 : 10788 : return c_finish_omp_clauses (clauses, C_ORT_OMP);
21902 : : }
21903 : :
21904 : : return clauses;
21905 : : }
21906 : :
21907 : : /* OpenACC 2.0, OpenMP 2.5:
21908 : : structured-block:
21909 : : statement
21910 : :
21911 : : In practice, we're also interested in adding the statement to an
21912 : : outer node. So it is convenient if we work around the fact that
21913 : : c_parser_statement calls add_stmt. */
21914 : :
21915 : : static tree
21916 : 6545 : c_parser_omp_structured_block (c_parser *parser, bool *if_p)
21917 : : {
21918 : 6545 : tree stmt = push_stmt_list ();
21919 : 6545 : parser->omp_attrs_forbidden_p = true;
21920 : 6545 : c_parser_statement (parser, if_p);
21921 : 6545 : return pop_stmt_list (stmt);
21922 : : }
21923 : :
21924 : : /* OpenACC 2.0:
21925 : : # pragma acc cache (variable-list) new-line
21926 : :
21927 : : OpenACC 2.7:
21928 : : # pragma acc cache (readonly: variable-list) new-line
21929 : :
21930 : : LOC is the location of the #pragma token.
21931 : : */
21932 : :
21933 : : static tree
21934 : 137 : c_parser_oacc_cache (location_t loc, c_parser *parser)
21935 : : {
21936 : 137 : tree stmt, clauses = NULL_TREE;
21937 : 137 : bool readonly = false;
21938 : 137 : location_t open_loc = c_parser_peek_token (parser)->location;
21939 : 137 : matching_parens parens;
21940 : 137 : if (parens.require_open (parser))
21941 : : {
21942 : 135 : c_token *token = c_parser_peek_token (parser);
21943 : 135 : if (token->type == CPP_NAME
21944 : 131 : && !strcmp (IDENTIFIER_POINTER (token->value), "readonly")
21945 : 139 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
21946 : : {
21947 : 4 : c_parser_consume_token (parser);
21948 : 4 : c_parser_consume_token (parser);
21949 : 4 : readonly = true;
21950 : : }
21951 : 135 : clauses = c_parser_omp_variable_list (parser, open_loc,
21952 : : OMP_CLAUSE__CACHE_, NULL_TREE);
21953 : 135 : parens.skip_until_found_close (parser);
21954 : : }
21955 : :
21956 : 135 : if (readonly)
21957 : 8 : for (tree c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
21958 : 4 : OMP_CLAUSE__CACHE__READONLY (c) = 1;
21959 : :
21960 : 137 : clauses = c_finish_omp_clauses (clauses, C_ORT_ACC);
21961 : :
21962 : 137 : c_parser_skip_to_pragma_eol (parser);
21963 : :
21964 : 137 : stmt = make_node (OACC_CACHE);
21965 : 137 : TREE_TYPE (stmt) = void_type_node;
21966 : 137 : OACC_CACHE_CLAUSES (stmt) = clauses;
21967 : 137 : SET_EXPR_LOCATION (stmt, loc);
21968 : 137 : add_stmt (stmt);
21969 : :
21970 : 137 : return stmt;
21971 : : }
21972 : :
21973 : : /* OpenACC 2.0:
21974 : : # pragma acc data oacc-data-clause[optseq] new-line
21975 : : structured-block
21976 : :
21977 : : LOC is the location of the #pragma token.
21978 : : */
21979 : :
21980 : : #define OACC_DATA_CLAUSE_MASK \
21981 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
21982 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
21983 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
21984 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
21985 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
21986 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
21987 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
21988 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
21989 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
21990 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT))
21991 : :
21992 : : static tree
21993 : 497 : c_parser_oacc_data (location_t loc, c_parser *parser, bool *if_p)
21994 : : {
21995 : 497 : tree stmt, clauses, block;
21996 : :
21997 : 497 : clauses = c_parser_oacc_all_clauses (parser, OACC_DATA_CLAUSE_MASK,
21998 : : "#pragma acc data");
21999 : :
22000 : 497 : block = c_begin_omp_parallel ();
22001 : 497 : add_stmt (c_parser_omp_structured_block (parser, if_p));
22002 : :
22003 : 497 : stmt = c_finish_oacc_data (loc, clauses, block);
22004 : :
22005 : 497 : return stmt;
22006 : : }
22007 : :
22008 : : /* OpenACC 2.0:
22009 : : # pragma acc declare oacc-data-clause[optseq] new-line
22010 : : */
22011 : :
22012 : : #define OACC_DECLARE_CLAUSE_MASK \
22013 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
22014 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
22015 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
22016 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
22017 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
22018 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT) \
22019 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_LINK) \
22020 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT))
22021 : :
22022 : : static void
22023 : 144 : c_parser_oacc_declare (c_parser *parser)
22024 : : {
22025 : 144 : location_t pragma_loc = c_parser_peek_token (parser)->location;
22026 : 144 : tree clauses, stmt, t, decl;
22027 : :
22028 : 144 : bool error = false;
22029 : :
22030 : 144 : c_parser_consume_pragma (parser);
22031 : :
22032 : 144 : clauses = c_parser_oacc_all_clauses (parser, OACC_DECLARE_CLAUSE_MASK,
22033 : : "#pragma acc declare");
22034 : 144 : if (!clauses)
22035 : : {
22036 : 2 : error_at (pragma_loc,
22037 : : "no valid clauses specified in %<#pragma acc declare%>");
22038 : 2 : return;
22039 : : }
22040 : :
22041 : 296 : for (t = clauses; t; t = OMP_CLAUSE_CHAIN (t))
22042 : : {
22043 : 154 : location_t loc = OMP_CLAUSE_LOCATION (t);
22044 : 154 : decl = OMP_CLAUSE_DECL (t);
22045 : 154 : if (!DECL_P (decl))
22046 : : {
22047 : 1 : error_at (loc, "array section in %<#pragma acc declare%>");
22048 : 1 : error = true;
22049 : 1 : continue;
22050 : : }
22051 : :
22052 : 153 : switch (OMP_CLAUSE_MAP_KIND (t))
22053 : : {
22054 : : case GOMP_MAP_FIRSTPRIVATE_POINTER:
22055 : : case GOMP_MAP_ALLOC:
22056 : : case GOMP_MAP_TO:
22057 : : case GOMP_MAP_FORCE_DEVICEPTR:
22058 : : case GOMP_MAP_DEVICE_RESIDENT:
22059 : : break;
22060 : :
22061 : 13 : case GOMP_MAP_LINK:
22062 : 13 : if (!global_bindings_p ()
22063 : 13 : && (TREE_STATIC (decl)
22064 : 6 : || !DECL_EXTERNAL (decl)))
22065 : : {
22066 : 2 : error_at (loc,
22067 : : "%qD must be a global variable in "
22068 : : "%<#pragma acc declare link%>",
22069 : : decl);
22070 : 2 : error = true;
22071 : 2 : continue;
22072 : : }
22073 : : break;
22074 : :
22075 : 42 : default:
22076 : 42 : if (global_bindings_p ())
22077 : : {
22078 : 5 : error_at (loc, "invalid OpenACC clause at file scope");
22079 : 5 : error = true;
22080 : 5 : continue;
22081 : : }
22082 : 37 : if (DECL_EXTERNAL (decl))
22083 : : {
22084 : 10 : error_at (loc,
22085 : : "invalid use of %<extern%> variable %qD "
22086 : : "in %<#pragma acc declare%>", decl);
22087 : 10 : error = true;
22088 : 10 : continue;
22089 : : }
22090 : 27 : else if (TREE_PUBLIC (decl))
22091 : : {
22092 : 2 : error_at (loc,
22093 : : "invalid use of %<global%> variable %qD "
22094 : : "in %<#pragma acc declare%>", decl);
22095 : 2 : error = true;
22096 : 2 : continue;
22097 : : }
22098 : : break;
22099 : : }
22100 : :
22101 : 134 : if (!c_check_in_current_scope (decl))
22102 : : {
22103 : 2 : error_at (loc,
22104 : : "%qD must be a variable declared in the same scope as "
22105 : : "%<#pragma acc declare%>", decl);
22106 : 2 : error = true;
22107 : 2 : continue;
22108 : : }
22109 : :
22110 : 132 : if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl))
22111 : 250 : || lookup_attribute ("omp declare target link",
22112 : 118 : DECL_ATTRIBUTES (decl)))
22113 : : {
22114 : 17 : error_at (loc, "variable %qD used more than once with "
22115 : : "%<#pragma acc declare%>", decl);
22116 : 17 : error = true;
22117 : 17 : continue;
22118 : : }
22119 : :
22120 : 115 : if (!error)
22121 : : {
22122 : 115 : tree id;
22123 : :
22124 : 115 : if (OMP_CLAUSE_MAP_KIND (t) == GOMP_MAP_LINK)
22125 : 7 : id = get_identifier ("omp declare target link");
22126 : : else
22127 : 108 : id = get_identifier ("omp declare target");
22128 : :
22129 : 115 : DECL_ATTRIBUTES (decl)
22130 : 115 : = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (decl));
22131 : :
22132 : 115 : if (global_bindings_p ())
22133 : : {
22134 : 45 : symtab_node *node = symtab_node::get (decl);
22135 : 45 : if (node != NULL)
22136 : : {
22137 : 33 : node->offloadable = 1;
22138 : 33 : if (ENABLE_OFFLOADING)
22139 : : {
22140 : : g->have_offload = true;
22141 : : if (is_a <varpool_node *> (node))
22142 : : vec_safe_push (offload_vars, decl);
22143 : : }
22144 : : }
22145 : : }
22146 : : }
22147 : : }
22148 : :
22149 : 142 : if (error || global_bindings_p ())
22150 : 74 : return;
22151 : :
22152 : 68 : stmt = make_node (OACC_DECLARE);
22153 : 68 : TREE_TYPE (stmt) = void_type_node;
22154 : 68 : OACC_DECLARE_CLAUSES (stmt) = clauses;
22155 : 68 : SET_EXPR_LOCATION (stmt, pragma_loc);
22156 : :
22157 : 68 : add_stmt (stmt);
22158 : :
22159 : 68 : return;
22160 : : }
22161 : :
22162 : : /* OpenACC 2.0:
22163 : : # pragma acc enter data oacc-enter-data-clause[optseq] new-line
22164 : :
22165 : : or
22166 : :
22167 : : # pragma acc exit data oacc-exit-data-clause[optseq] new-line
22168 : :
22169 : :
22170 : : LOC is the location of the #pragma token.
22171 : : */
22172 : :
22173 : : #define OACC_ENTER_DATA_CLAUSE_MASK \
22174 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
22175 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
22176 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
22177 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
22178 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
22179 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
22180 : :
22181 : : #define OACC_EXIT_DATA_CLAUSE_MASK \
22182 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
22183 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
22184 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
22185 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
22186 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
22187 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FINALIZE) \
22188 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
22189 : :
22190 : : static void
22191 : 261 : c_parser_oacc_enter_exit_data (c_parser *parser, bool enter)
22192 : : {
22193 : 261 : location_t loc = c_parser_peek_token (parser)->location;
22194 : 261 : tree clauses, stmt;
22195 : 261 : const char *p = "";
22196 : :
22197 : 261 : c_parser_consume_pragma (parser);
22198 : :
22199 : 261 : if (c_parser_next_token_is (parser, CPP_NAME))
22200 : : {
22201 : 258 : p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
22202 : 258 : c_parser_consume_token (parser);
22203 : : }
22204 : :
22205 : 261 : if (strcmp (p, "data") != 0)
22206 : : {
22207 : 8 : error_at (loc, "expected %<data%> after %<#pragma acc %s%>",
22208 : : enter ? "enter" : "exit");
22209 : 6 : parser->error = true;
22210 : 6 : c_parser_skip_to_pragma_eol (parser);
22211 : 6 : return;
22212 : : }
22213 : :
22214 : 255 : if (enter)
22215 : 129 : clauses = c_parser_oacc_all_clauses (parser, OACC_ENTER_DATA_CLAUSE_MASK,
22216 : : "#pragma acc enter data");
22217 : : else
22218 : 126 : clauses = c_parser_oacc_all_clauses (parser, OACC_EXIT_DATA_CLAUSE_MASK,
22219 : : "#pragma acc exit data");
22220 : :
22221 : 255 : if (omp_find_clause (clauses, OMP_CLAUSE_MAP) == NULL_TREE)
22222 : : {
22223 : 15 : error_at (loc, "%<#pragma acc %s data%> has no data movement clause",
22224 : : enter ? "enter" : "exit");
22225 : 15 : return;
22226 : : }
22227 : :
22228 : 240 : stmt = enter ? make_node (OACC_ENTER_DATA) : make_node (OACC_EXIT_DATA);
22229 : 240 : TREE_TYPE (stmt) = void_type_node;
22230 : 240 : OMP_STANDALONE_CLAUSES (stmt) = clauses;
22231 : 240 : SET_EXPR_LOCATION (stmt, loc);
22232 : 240 : add_stmt (stmt);
22233 : : }
22234 : :
22235 : :
22236 : : /* OpenACC 2.0:
22237 : : # pragma acc host_data oacc-data-clause[optseq] new-line
22238 : : structured-block
22239 : : */
22240 : :
22241 : : #define OACC_HOST_DATA_CLAUSE_MASK \
22242 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_USE_DEVICE) \
22243 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
22244 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) )
22245 : :
22246 : : static tree
22247 : 23 : c_parser_oacc_host_data (location_t loc, c_parser *parser, bool *if_p)
22248 : : {
22249 : 23 : tree stmt, clauses, block;
22250 : :
22251 : 23 : clauses = c_parser_oacc_all_clauses (parser, OACC_HOST_DATA_CLAUSE_MASK,
22252 : : "#pragma acc host_data", false);
22253 : 23 : if (!omp_find_clause (clauses, OMP_CLAUSE_USE_DEVICE_PTR))
22254 : : {
22255 : 2 : error_at (loc, "%<host_data%> construct requires %<use_device%> clause");
22256 : 2 : return error_mark_node;
22257 : : }
22258 : 21 : clauses = c_finish_omp_clauses (clauses, C_ORT_ACC);
22259 : 21 : block = c_begin_omp_parallel ();
22260 : 21 : add_stmt (c_parser_omp_structured_block (parser, if_p));
22261 : 21 : stmt = c_finish_oacc_host_data (loc, clauses, block);
22262 : 21 : return stmt;
22263 : : }
22264 : :
22265 : :
22266 : : /* OpenACC 2.0:
22267 : :
22268 : : # pragma acc loop oacc-loop-clause[optseq] new-line
22269 : : structured-block
22270 : :
22271 : : LOC is the location of the #pragma token.
22272 : : */
22273 : :
22274 : : #define OACC_LOOP_CLAUSE_MASK \
22275 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
22276 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
22277 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
22278 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
22279 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
22280 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
22281 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_AUTO) \
22282 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_INDEPENDENT) \
22283 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
22284 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_TILE) )
22285 : : static tree
22286 : 2444 : c_parser_oacc_loop (location_t loc, c_parser *parser, char *p_name,
22287 : : omp_clause_mask mask, tree *cclauses, bool *if_p)
22288 : : {
22289 : 2444 : bool is_parallel = ((mask >> PRAGMA_OACC_CLAUSE_REDUCTION) & 1) == 1;
22290 : :
22291 : 2444 : strcat (p_name, " loop");
22292 : 2444 : mask |= OACC_LOOP_CLAUSE_MASK;
22293 : :
22294 : 2444 : tree clauses = c_parser_oacc_all_clauses (parser, mask, p_name,
22295 : : /*finish_p=*/cclauses == NULL,
22296 : : /*target=*/is_parallel);
22297 : 2444 : if (cclauses)
22298 : : {
22299 : 673 : clauses = c_oacc_split_loop_clauses (clauses, cclauses, is_parallel);
22300 : 673 : if (*cclauses)
22301 : 152 : *cclauses = c_finish_omp_clauses (*cclauses, C_ORT_ACC_TARGET);
22302 : 673 : if (clauses)
22303 : 271 : clauses = c_finish_omp_clauses (clauses, C_ORT_ACC);
22304 : : }
22305 : :
22306 : 2444 : tree block = c_begin_compound_stmt (true);
22307 : 2444 : tree stmt = c_parser_omp_for_loop (loc, parser, OACC_LOOP, clauses, NULL,
22308 : : if_p);
22309 : 2444 : block = c_end_compound_stmt (loc, block, true);
22310 : 2444 : add_stmt (block);
22311 : :
22312 : 2444 : return stmt;
22313 : : }
22314 : :
22315 : : /* OpenACC 2.0:
22316 : : # pragma acc kernels oacc-kernels-clause[optseq] new-line
22317 : : structured-block
22318 : :
22319 : : or
22320 : :
22321 : : # pragma acc parallel oacc-parallel-clause[optseq] new-line
22322 : : structured-block
22323 : :
22324 : : OpenACC 2.6:
22325 : :
22326 : : # pragma acc serial oacc-serial-clause[optseq] new-line
22327 : : structured-block
22328 : :
22329 : : LOC is the location of the #pragma token.
22330 : : */
22331 : :
22332 : : #define OACC_KERNELS_CLAUSE_MASK \
22333 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
22334 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
22335 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
22336 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
22337 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
22338 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
22339 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
22340 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
22341 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
22342 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
22343 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
22344 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
22345 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
22346 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
22347 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
22348 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
22349 : :
22350 : : #define OACC_PARALLEL_CLAUSE_MASK \
22351 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
22352 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
22353 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
22354 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
22355 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
22356 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
22357 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
22358 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
22359 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
22360 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
22361 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
22362 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
22363 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
22364 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
22365 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
22366 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
22367 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
22368 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
22369 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
22370 : :
22371 : : #define OACC_SERIAL_CLAUSE_MASK \
22372 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
22373 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
22374 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
22375 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
22376 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
22377 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
22378 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
22379 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
22380 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
22381 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
22382 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
22383 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
22384 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
22385 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
22386 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
22387 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
22388 : :
22389 : : static tree
22390 : 2154 : c_parser_oacc_compute (location_t loc, c_parser *parser,
22391 : : enum pragma_kind p_kind, char *p_name, bool *if_p)
22392 : : {
22393 : 2154 : omp_clause_mask mask;
22394 : 2154 : enum tree_code code;
22395 : 2154 : switch (p_kind)
22396 : : {
22397 : 522 : case PRAGMA_OACC_KERNELS:
22398 : 522 : strcat (p_name, " kernels");
22399 : 522 : mask = OACC_KERNELS_CLAUSE_MASK;
22400 : 522 : code = OACC_KERNELS;
22401 : 522 : break;
22402 : 1457 : case PRAGMA_OACC_PARALLEL:
22403 : 1457 : strcat (p_name, " parallel");
22404 : 1457 : mask = OACC_PARALLEL_CLAUSE_MASK;
22405 : 1457 : code = OACC_PARALLEL;
22406 : 1457 : break;
22407 : 175 : case PRAGMA_OACC_SERIAL:
22408 : 175 : strcat (p_name, " serial");
22409 : 175 : mask = OACC_SERIAL_CLAUSE_MASK;
22410 : 175 : code = OACC_SERIAL;
22411 : 175 : break;
22412 : 0 : default:
22413 : 0 : gcc_unreachable ();
22414 : : }
22415 : :
22416 : 2154 : if (c_parser_next_token_is (parser, CPP_NAME))
22417 : : {
22418 : 1710 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
22419 : 1710 : if (strcmp (p, "loop") == 0)
22420 : : {
22421 : 673 : c_parser_consume_token (parser);
22422 : 673 : tree block = c_begin_omp_parallel ();
22423 : 673 : tree clauses;
22424 : 673 : c_parser_oacc_loop (loc, parser, p_name, mask, &clauses, if_p);
22425 : 673 : return c_finish_omp_construct (loc, code, block, clauses);
22426 : : }
22427 : : }
22428 : :
22429 : 1481 : tree clauses = c_parser_oacc_all_clauses (parser, mask, p_name,
22430 : : /*finish_p=*/true,
22431 : : /*target=*/true);
22432 : :
22433 : 1481 : tree block = c_begin_omp_parallel ();
22434 : 1481 : add_stmt (c_parser_omp_structured_block (parser, if_p));
22435 : :
22436 : 1481 : return c_finish_omp_construct (loc, code, block, clauses);
22437 : : }
22438 : :
22439 : : /* OpenACC 2.0:
22440 : : # pragma acc routine oacc-routine-clause[optseq] new-line
22441 : : function-definition
22442 : :
22443 : : # pragma acc routine ( name ) oacc-routine-clause[optseq] new-line
22444 : : */
22445 : :
22446 : : #define OACC_ROUTINE_CLAUSE_MASK \
22447 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
22448 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
22449 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
22450 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
22451 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NOHOST) )
22452 : :
22453 : : /* Parse an OpenACC routine directive. For named directives, we apply
22454 : : immediately to the named function. For unnamed ones we then parse
22455 : : a declaration or definition, which must be for a function. */
22456 : :
22457 : : static void
22458 : 345 : c_parser_oacc_routine (c_parser *parser, enum pragma_context context)
22459 : : {
22460 : 345 : gcc_checking_assert (context == pragma_external);
22461 : :
22462 : 345 : oacc_routine_data data;
22463 : 345 : data.error_seen = false;
22464 : 345 : data.fndecl_seen = false;
22465 : 345 : data.loc = c_parser_peek_token (parser)->location;
22466 : :
22467 : 345 : c_parser_consume_pragma (parser);
22468 : :
22469 : : /* Look for optional '( name )'. */
22470 : 345 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
22471 : : {
22472 : 143 : c_parser_consume_token (parser); /* '(' */
22473 : :
22474 : 143 : tree decl = NULL_TREE;
22475 : 143 : c_token *name_token = c_parser_peek_token (parser);
22476 : 143 : location_t name_loc = name_token->location;
22477 : 143 : if (name_token->type == CPP_NAME
22478 : 135 : && (name_token->id_kind == C_ID_ID
22479 : : || name_token->id_kind == C_ID_TYPENAME))
22480 : : {
22481 : 135 : decl = lookup_name (name_token->value);
22482 : 135 : if (!decl)
22483 : 5 : error_at (name_loc,
22484 : : "%qE has not been declared", name_token->value);
22485 : 135 : c_parser_consume_token (parser);
22486 : : }
22487 : : else
22488 : 8 : c_parser_error (parser, "expected function name");
22489 : :
22490 : 8 : if (!decl
22491 : 135 : || !c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
22492 : : {
22493 : 15 : c_parser_skip_to_pragma_eol (parser, false);
22494 : 43 : return;
22495 : : }
22496 : :
22497 : 128 : data.clauses
22498 : 128 : = c_parser_oacc_all_clauses (parser, OACC_ROUTINE_CLAUSE_MASK,
22499 : : "#pragma acc routine");
22500 : : /* The clauses are in reverse order; fix that to make later diagnostic
22501 : : emission easier. */
22502 : 128 : data.clauses = nreverse (data.clauses);
22503 : :
22504 : 128 : if (TREE_CODE (decl) != FUNCTION_DECL)
22505 : : {
22506 : 3 : error_at (name_loc, "%qD does not refer to a function", decl);
22507 : 3 : return;
22508 : : }
22509 : :
22510 : 125 : c_finish_oacc_routine (&data, decl, false);
22511 : : }
22512 : : else /* No optional '( name )'. */
22513 : : {
22514 : 202 : data.clauses
22515 : 202 : = c_parser_oacc_all_clauses (parser, OACC_ROUTINE_CLAUSE_MASK,
22516 : : "#pragma acc routine");
22517 : : /* The clauses are in reverse order; fix that to make later diagnostic
22518 : : emission easier. */
22519 : 202 : data.clauses = nreverse (data.clauses);
22520 : :
22521 : : /* Emit a helpful diagnostic if there's another pragma following this
22522 : : one. Also don't allow a static assertion declaration, as in the
22523 : : following we'll just parse a *single* "declaration or function
22524 : : definition", and the static assertion counts an one. */
22525 : 202 : if (c_parser_next_token_is (parser, CPP_PRAGMA)
22526 : 395 : || c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
22527 : : {
22528 : 10 : error_at (data.loc,
22529 : : "%<#pragma acc routine%> not immediately followed by"
22530 : : " function declaration or definition");
22531 : : /* ..., and then just keep going. */
22532 : 10 : return;
22533 : : }
22534 : :
22535 : : /* We only have to consider the pragma_external case here. */
22536 : 192 : if (c_parser_next_token_is (parser, CPP_KEYWORD)
22537 : 192 : && c_parser_peek_token (parser)->keyword == RID_EXTENSION)
22538 : : {
22539 : 3 : int ext = disable_extension_diagnostics ();
22540 : 7 : do
22541 : 7 : c_parser_consume_token (parser);
22542 : 7 : while (c_parser_next_token_is (parser, CPP_KEYWORD)
22543 : 10 : && c_parser_peek_token (parser)->keyword == RID_EXTENSION);
22544 : 3 : c_parser_declaration_or_fndef (parser, true, true, true, false, true,
22545 : : false, NULL, NULL, false, NULL, &data);
22546 : 3 : restore_extension_diagnostics (ext);
22547 : : }
22548 : : else
22549 : 189 : c_parser_declaration_or_fndef (parser, true, true, true, false, true,
22550 : : false, NULL, NULL, false, NULL, &data);
22551 : : }
22552 : : }
22553 : :
22554 : : /* Finalize an OpenACC routine pragma, applying it to FNDECL.
22555 : : IS_DEFN is true if we're applying it to the definition. */
22556 : :
22557 : : static void
22558 : 327 : c_finish_oacc_routine (struct oacc_routine_data *data, tree fndecl,
22559 : : bool is_defn)
22560 : : {
22561 : : /* Keep going if we're in error reporting mode. */
22562 : 327 : if (data->error_seen
22563 : 321 : || fndecl == error_mark_node)
22564 : : return;
22565 : :
22566 : 321 : if (data->fndecl_seen)
22567 : : {
22568 : 4 : error_at (data->loc,
22569 : : "%<#pragma acc routine%> not immediately followed by"
22570 : : " a single function declaration or definition");
22571 : 4 : data->error_seen = true;
22572 : 4 : return;
22573 : : }
22574 : 317 : if (fndecl == NULL_TREE || TREE_CODE (fndecl) != FUNCTION_DECL)
22575 : : {
22576 : 10 : error_at (data->loc,
22577 : : "%<#pragma acc routine%> not immediately followed by"
22578 : : " function declaration or definition");
22579 : 10 : data->error_seen = true;
22580 : 10 : return;
22581 : : }
22582 : :
22583 : 307 : int compatible
22584 : 307 : = oacc_verify_routine_clauses (fndecl, &data->clauses, data->loc,
22585 : : "#pragma acc routine");
22586 : 307 : if (compatible < 0)
22587 : : {
22588 : 47 : data->error_seen = true;
22589 : 47 : return;
22590 : : }
22591 : 260 : if (compatible > 0)
22592 : : {
22593 : : }
22594 : : else
22595 : : {
22596 : 269 : if (TREE_USED (fndecl) || (!is_defn && DECL_SAVED_TREE (fndecl)))
22597 : : {
22598 : 3 : error_at (data->loc,
22599 : : TREE_USED (fndecl)
22600 : : ? G_("%<#pragma acc routine%> must be applied before use")
22601 : : : G_("%<#pragma acc routine%> must be applied before"
22602 : : " definition"));
22603 : 2 : data->error_seen = true;
22604 : 2 : return;
22605 : : }
22606 : :
22607 : : /* Set the routine's level of parallelism. */
22608 : 197 : tree dims = oacc_build_routine_dims (data->clauses);
22609 : 197 : oacc_replace_fn_attrib (fndecl, dims);
22610 : :
22611 : : /* Add an "omp declare target" attribute. */
22612 : 197 : DECL_ATTRIBUTES (fndecl)
22613 : 394 : = tree_cons (get_identifier ("omp declare target"),
22614 : 197 : data->clauses, DECL_ATTRIBUTES (fndecl));
22615 : : }
22616 : :
22617 : : /* Remember that we've used this "#pragma acc routine". */
22618 : 258 : data->fndecl_seen = true;
22619 : : }
22620 : :
22621 : : /* OpenACC 2.0:
22622 : : # pragma acc update oacc-update-clause[optseq] new-line
22623 : : */
22624 : :
22625 : : #define OACC_UPDATE_CLAUSE_MASK \
22626 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
22627 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
22628 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
22629 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
22630 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) \
22631 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
22632 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
22633 : :
22634 : : static void
22635 : 92 : c_parser_oacc_update (c_parser *parser)
22636 : : {
22637 : 92 : location_t loc = c_parser_peek_token (parser)->location;
22638 : :
22639 : 92 : c_parser_consume_pragma (parser);
22640 : :
22641 : 92 : tree clauses = c_parser_oacc_all_clauses (parser, OACC_UPDATE_CLAUSE_MASK,
22642 : : "#pragma acc update");
22643 : 92 : if (omp_find_clause (clauses, OMP_CLAUSE_MAP) == NULL_TREE)
22644 : : {
22645 : 1 : error_at (loc,
22646 : : "%<#pragma acc update%> must contain at least one "
22647 : : "%<device%> or %<host%> or %<self%> clause");
22648 : 1 : return;
22649 : : }
22650 : :
22651 : 91 : if (parser->error)
22652 : : return;
22653 : :
22654 : 91 : tree stmt = make_node (OACC_UPDATE);
22655 : 91 : TREE_TYPE (stmt) = void_type_node;
22656 : 91 : OACC_UPDATE_CLAUSES (stmt) = clauses;
22657 : 91 : SET_EXPR_LOCATION (stmt, loc);
22658 : 91 : add_stmt (stmt);
22659 : : }
22660 : :
22661 : : /* OpenACC 2.0:
22662 : : # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
22663 : :
22664 : : LOC is the location of the #pragma token.
22665 : : */
22666 : :
22667 : : #define OACC_WAIT_CLAUSE_MASK \
22668 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
22669 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) )
22670 : :
22671 : : static tree
22672 : 86 : c_parser_oacc_wait (location_t loc, c_parser *parser, char *p_name)
22673 : : {
22674 : 86 : tree clauses, list = NULL_TREE, stmt = NULL_TREE;
22675 : :
22676 : 86 : if (c_parser_peek_token (parser)->type == CPP_OPEN_PAREN)
22677 : 49 : list = c_parser_oacc_wait_list (parser, loc, list);
22678 : :
22679 : 86 : strcpy (p_name, " wait");
22680 : 86 : clauses = c_parser_oacc_all_clauses (parser, OACC_WAIT_CLAUSE_MASK, p_name);
22681 : 86 : stmt = c_finish_oacc_wait (loc, list, clauses);
22682 : 86 : add_stmt (stmt);
22683 : :
22684 : 86 : return stmt;
22685 : : }
22686 : :
22687 : : struct c_omp_loc_tree
22688 : : {
22689 : : location_t loc;
22690 : : tree var;
22691 : : };
22692 : :
22693 : : /* Check whether the expression used in the allocator clause is declared or
22694 : : modified between the variable declaration and its allocate directive. */
22695 : : static tree
22696 : 48 : c_check_omp_allocate_allocator_r (tree *tp, int *, void *data)
22697 : : {
22698 : 48 : tree var = ((struct c_omp_loc_tree *) data)->var;
22699 : 48 : location_t loc = ((struct c_omp_loc_tree *) data)->loc;
22700 : 48 : if (TREE_CODE (*tp) == VAR_DECL && c_check_in_current_scope (*tp))
22701 : : {
22702 : 10 : if (linemap_location_before_p (line_table, DECL_SOURCE_LOCATION (var),
22703 : 10 : DECL_SOURCE_LOCATION (*tp)))
22704 : : {
22705 : 2 : error_at (loc, "variable %qD used in the %<allocator%> clause must "
22706 : : "be declared before %qD", *tp, var);
22707 : 2 : inform (DECL_SOURCE_LOCATION (*tp), "declared here");
22708 : 2 : inform (DECL_SOURCE_LOCATION (var),
22709 : : "to be allocated variable declared here");
22710 : 2 : return *tp;
22711 : : }
22712 : : else
22713 : : {
22714 : 8 : gcc_assert (cur_stmt_list
22715 : : && TREE_CODE (cur_stmt_list) == STATEMENT_LIST);
22716 : :
22717 : 8 : tree_stmt_iterator l = tsi_last (cur_stmt_list);
22718 : 9 : while (!tsi_end_p (l))
22719 : : {
22720 : 9 : if (linemap_location_before_p (line_table, EXPR_LOCATION (*l),
22721 : 9 : DECL_SOURCE_LOCATION (var)))
22722 : : break;
22723 : 3 : if (TREE_CODE (*l) == MODIFY_EXPR
22724 : 3 : && TREE_OPERAND (*l, 0) == *tp)
22725 : : {
22726 : 2 : error_at (loc,
22727 : : "variable %qD used in the %<allocator%> clause "
22728 : : "must not be modified between declaration of %qD "
22729 : : "and its %<allocate%> directive", *tp, var);
22730 : 2 : inform (EXPR_LOCATION (*l), "modified here");
22731 : 2 : inform (DECL_SOURCE_LOCATION (var),
22732 : : "to be allocated variable declared here");
22733 : 2 : return *tp;
22734 : : }
22735 : 1 : --l;
22736 : : }
22737 : : }
22738 : : }
22739 : : return NULL_TREE;
22740 : : }
22741 : :
22742 : : /* OpenMP 5.x:
22743 : : # pragma omp allocate (list) clauses
22744 : :
22745 : : OpenMP 5.0 clause:
22746 : : allocator (omp_allocator_handle_t expression)
22747 : :
22748 : : OpenMP 5.1 additional clause:
22749 : : align (constant-expression)] */
22750 : :
22751 : : static void
22752 : 69 : c_parser_omp_allocate (c_parser *parser)
22753 : : {
22754 : 69 : tree alignment = NULL_TREE;
22755 : 69 : tree allocator = NULL_TREE;
22756 : 69 : c_parser_consume_pragma (parser);
22757 : 69 : location_t loc = c_parser_peek_token (parser)->location;
22758 : 69 : location_t allocator_loc = UNKNOWN_LOCATION;
22759 : 69 : tree nl = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ALLOCATE, NULL_TREE);
22760 : 215 : do
22761 : : {
22762 : 142 : if (c_parser_next_token_is (parser, CPP_COMMA)
22763 : 142 : && c_parser_peek_2nd_token (parser)->type == CPP_NAME)
22764 : 9 : c_parser_consume_token (parser);
22765 : 142 : if (!c_parser_next_token_is (parser, CPP_NAME))
22766 : : break;
22767 : 76 : matching_parens parens;
22768 : 76 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
22769 : 76 : c_parser_consume_token (parser);
22770 : 76 : location_t expr_loc = c_parser_peek_token (parser)->location;
22771 : 76 : if (strcmp ("align", p) != 0 && strcmp ("allocator", p) != 0)
22772 : : {
22773 : 1 : error_at (c_parser_peek_token (parser)->location,
22774 : : "expected %<allocator%> or %<align%>");
22775 : 1 : break;
22776 : : }
22777 : 75 : if (!parens.require_open (parser))
22778 : : break;
22779 : :
22780 : 75 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
22781 : 75 : expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true);
22782 : 75 : expr_loc = c_parser_peek_token (parser)->location;
22783 : 75 : if (expr.value == error_mark_node)
22784 : : ;
22785 : 74 : else if (p[2] == 'i' && alignment)
22786 : : {
22787 : 1 : error_at (expr_loc, "too many %qs clauses", "align");
22788 : 1 : break;
22789 : : }
22790 : 73 : else if (p[2] == 'i')
22791 : : {
22792 : 32 : alignment = c_fully_fold (expr.value, false, NULL);
22793 : 32 : if (TREE_CODE (alignment) != INTEGER_CST
22794 : 31 : || !INTEGRAL_TYPE_P (TREE_TYPE (alignment))
22795 : 31 : || tree_int_cst_sgn (alignment) != 1
22796 : 62 : || !integer_pow2p (alignment))
22797 : : {
22798 : 4 : error_at (expr_loc, "%<align%> clause argument needs to be "
22799 : : "positive constant power of two integer "
22800 : : "expression");
22801 : 4 : alignment = NULL_TREE;
22802 : : }
22803 : : }
22804 : 41 : else if (allocator)
22805 : : {
22806 : 1 : error_at (expr_loc, "too many %qs clauses", "allocator");
22807 : 1 : break;
22808 : : }
22809 : : else
22810 : : {
22811 : 40 : allocator = c_fully_fold (expr.value, false, NULL);
22812 : 40 : allocator_loc = expr_loc;
22813 : 40 : tree orig_type
22814 : 40 : = expr.original_type ? expr.original_type : TREE_TYPE (allocator);
22815 : 40 : orig_type = TYPE_MAIN_VARIANT (orig_type);
22816 : 41 : if (!INTEGRAL_TYPE_P (TREE_TYPE (allocator))
22817 : 40 : || TREE_CODE (orig_type) != ENUMERAL_TYPE
22818 : 118 : || TYPE_NAME (orig_type)
22819 : 39 : != get_identifier ("omp_allocator_handle_t"))
22820 : : {
22821 : 1 : error_at (expr_loc,
22822 : : "%<allocator%> clause allocator expression has type "
22823 : : "%qT rather than %<omp_allocator_handle_t%>",
22824 : 1 : TREE_TYPE (allocator));
22825 : 1 : allocator = NULL_TREE;
22826 : : }
22827 : : }
22828 : 73 : parens.skip_until_found_close (parser);
22829 : 73 : } while (true);
22830 : 69 : c_parser_skip_to_pragma_eol (parser);
22831 : :
22832 : 69 : c_mark_decl_jump_unsafe_in_current_scope ();
22833 : 149 : for (tree c = nl; c != NULL_TREE; c = OMP_CLAUSE_CHAIN (c))
22834 : : {
22835 : 80 : tree var = OMP_CLAUSE_DECL (c);
22836 : 80 : if (TREE_CODE (var) == PARM_DECL)
22837 : : {
22838 : 1 : error_at (OMP_CLAUSE_LOCATION (nl),
22839 : : "function parameter %qD may not appear as list item in an "
22840 : : "%<allocate%> directive", var);
22841 : 1 : continue;
22842 : : }
22843 : 79 : if (!parser->in_omp_decl_attribute && !c_check_in_current_scope (var))
22844 : : {
22845 : 2 : error_at (OMP_CLAUSE_LOCATION (nl),
22846 : : "%<allocate%> directive must be in the same scope as %qD",
22847 : : var);
22848 : 2 : inform (DECL_SOURCE_LOCATION (var), "declared here");
22849 : 2 : continue;
22850 : : }
22851 : 77 : if (lookup_attribute ("omp allocate", DECL_ATTRIBUTES (var)))
22852 : : {
22853 : 1 : error_at (OMP_CLAUSE_LOCATION (nl),
22854 : : "%qD already appeared as list item in an "
22855 : : "%<allocate%> directive", var);
22856 : 1 : continue;
22857 : : }
22858 : 76 : if (TREE_STATIC (var))
22859 : : {
22860 : 19 : if (allocator == NULL_TREE && allocator_loc == UNKNOWN_LOCATION)
22861 : : {
22862 : 3 : error_at (loc,
22863 : : "%<allocator%> clause required for "
22864 : : "static variable %qD", var);
22865 : 3 : continue;
22866 : : }
22867 : 16 : else if (allocator
22868 : 16 : && (wi::to_widest (allocator) < 1
22869 : 15 : || wi::to_widest (allocator) > GOMP_OMP_PREDEF_ALLOC_MAX)
22870 : 23 : && (wi::to_widest (allocator) < GOMP_OMPX_PREDEF_ALLOC_MIN
22871 : 12 : || wi::to_widest (allocator) > GOMP_OMPX_PREDEF_ALLOC_MAX))
22872 : : {
22873 : 6 : error_at (allocator_loc,
22874 : : "%<allocator%> clause requires a predefined allocator as "
22875 : : "%qD is static", var);
22876 : : }
22877 : : }
22878 : 73 : if (allocator)
22879 : : {
22880 : 40 : struct c_omp_loc_tree data
22881 : 78 : = {EXPR_LOC_OR_LOC (allocator, OMP_CLAUSE_LOCATION (nl)), var};
22882 : 40 : walk_tree (&allocator, c_check_omp_allocate_allocator_r, &data, NULL);
22883 : : }
22884 : 73 : DECL_ATTRIBUTES (var) = tree_cons (get_identifier ("omp allocate"),
22885 : : build_tree_list (allocator, alignment),
22886 : 73 : DECL_ATTRIBUTES (var));
22887 : : }
22888 : 69 : }
22889 : :
22890 : : /* OpenMP 2.5:
22891 : : # pragma omp atomic new-line
22892 : : expression-stmt
22893 : :
22894 : : expression-stmt:
22895 : : x binop= expr | x++ | ++x | x-- | --x
22896 : : binop:
22897 : : +, *, -, /, &, ^, |, <<, >>
22898 : :
22899 : : where x is an lvalue expression with scalar type.
22900 : :
22901 : : OpenMP 3.1:
22902 : : # pragma omp atomic new-line
22903 : : update-stmt
22904 : :
22905 : : # pragma omp atomic read new-line
22906 : : read-stmt
22907 : :
22908 : : # pragma omp atomic write new-line
22909 : : write-stmt
22910 : :
22911 : : # pragma omp atomic update new-line
22912 : : update-stmt
22913 : :
22914 : : # pragma omp atomic capture new-line
22915 : : capture-stmt
22916 : :
22917 : : # pragma omp atomic capture new-line
22918 : : capture-block
22919 : :
22920 : : read-stmt:
22921 : : v = x
22922 : : write-stmt:
22923 : : x = expr
22924 : : update-stmt:
22925 : : expression-stmt | x = x binop expr
22926 : : capture-stmt:
22927 : : v = expression-stmt
22928 : : capture-block:
22929 : : { v = x; update-stmt; } | { update-stmt; v = x; }
22930 : :
22931 : : OpenMP 4.0:
22932 : : update-stmt:
22933 : : expression-stmt | x = x binop expr | x = expr binop x
22934 : : capture-stmt:
22935 : : v = update-stmt
22936 : : capture-block:
22937 : : { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
22938 : :
22939 : : OpenMP 5.1:
22940 : : # pragma omp atomic compare new-line
22941 : : conditional-update-atomic
22942 : :
22943 : : # pragma omp atomic compare capture new-line
22944 : : conditional-update-capture-atomic
22945 : :
22946 : : conditional-update-atomic:
22947 : : cond-expr-stmt | cond-update-stmt
22948 : : cond-expr-stmt:
22949 : : x = expr ordop x ? expr : x;
22950 : : x = x ordop expr ? expr : x;
22951 : : x = x == e ? d : x;
22952 : : cond-update-stmt:
22953 : : if (expr ordop x) { x = expr; }
22954 : : if (x ordop expr) { x = expr; }
22955 : : if (x == e) { x = d; }
22956 : : ordop:
22957 : : <, >
22958 : : conditional-update-capture-atomic:
22959 : : v = cond-expr-stmt
22960 : : { v = x; cond-expr-stmt }
22961 : : { cond-expr-stmt v = x; }
22962 : : { v = x; cond-update-stmt }
22963 : : { cond-update-stmt v = x; }
22964 : : if (x == e) { x = d; } else { v = x; }
22965 : : { r = x == e; if (r) { x = d; } }
22966 : : { r = x == e; if (r) { x = d; } else { v = x; } }
22967 : :
22968 : : where x, r and v are lvalue expressions with scalar type,
22969 : : expr, e and d are expressions with scalar type and e might be
22970 : : the same as v.
22971 : :
22972 : : LOC is the location of the #pragma token. */
22973 : :
22974 : : static void
22975 : 1718 : c_parser_omp_atomic (location_t loc, c_parser *parser, bool openacc)
22976 : : {
22977 : 1718 : tree lhs = NULL_TREE, rhs = NULL_TREE, v = NULL_TREE, r = NULL_TREE;
22978 : 1718 : tree lhs1 = NULL_TREE, rhs1 = NULL_TREE;
22979 : 1718 : tree stmt, orig_lhs, unfolded_lhs = NULL_TREE, unfolded_lhs1 = NULL_TREE;
22980 : 1718 : enum tree_code code = ERROR_MARK, opcode = NOP_EXPR;
22981 : 1718 : enum omp_memory_order memory_order = OMP_MEMORY_ORDER_UNSPECIFIED;
22982 : 1718 : struct c_expr expr;
22983 : 1718 : location_t eloc;
22984 : 1718 : bool structured_block = false;
22985 : 1718 : bool swapped = false;
22986 : 1718 : bool non_lvalue_p;
22987 : 1718 : tree clauses = NULL_TREE;
22988 : 1718 : bool capture = false;
22989 : 1718 : bool compare = false;
22990 : 1718 : bool weak = false;
22991 : 1718 : enum omp_memory_order fail = OMP_MEMORY_ORDER_UNSPECIFIED;
22992 : 1718 : bool no_semicolon = false;
22993 : 1718 : bool extra_scope = false;
22994 : :
22995 : 3197 : while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
22996 : : {
22997 : 1489 : if (c_parser_next_token_is (parser, CPP_COMMA)
22998 : 1489 : && c_parser_peek_2nd_token (parser)->type == CPP_NAME)
22999 : 82 : c_parser_consume_token (parser);
23000 : :
23001 : 1489 : if (c_parser_next_token_is (parser, CPP_NAME))
23002 : : {
23003 : 1485 : const char *p
23004 : 1485 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
23005 : 1485 : location_t cloc = c_parser_peek_token (parser)->location;
23006 : 1485 : enum tree_code new_code = ERROR_MARK;
23007 : 1485 : enum omp_memory_order new_memory_order
23008 : : = OMP_MEMORY_ORDER_UNSPECIFIED;
23009 : 1485 : bool new_capture = false;
23010 : 1485 : bool new_compare = false;
23011 : 1485 : bool new_weak = false;
23012 : 1485 : enum omp_memory_order new_fail = OMP_MEMORY_ORDER_UNSPECIFIED;
23013 : :
23014 : 1485 : if (!strcmp (p, "read"))
23015 : : new_code = OMP_ATOMIC_READ;
23016 : 1227 : else if (!strcmp (p, "write"))
23017 : : new_code = NOP_EXPR;
23018 : 1050 : else if (!strcmp (p, "update"))
23019 : : new_code = OMP_ATOMIC;
23020 : 890 : else if (openacc && !strcmp (p, "capture"))
23021 : : new_code = OMP_ATOMIC_CAPTURE_NEW;
23022 : 4 : else if (openacc)
23023 : : {
23024 : 4 : p = NULL;
23025 : 4 : error_at (cloc, "expected %<read%>, %<write%>, %<update%>, "
23026 : : "or %<capture%> clause");
23027 : : }
23028 : 652 : else if (!strcmp (p, "capture"))
23029 : : new_capture = true;
23030 : 408 : else if (!strcmp (p, "compare"))
23031 : : new_compare = true;
23032 : 235 : else if (!strcmp (p, "weak"))
23033 : : new_weak = true;
23034 : 222 : else if (!strcmp (p, "fail"))
23035 : : {
23036 : 33 : matching_parens parens;
23037 : :
23038 : 33 : c_parser_consume_token (parser);
23039 : 33 : if (!parens.require_open (parser))
23040 : 1 : continue;
23041 : :
23042 : 32 : if (c_parser_next_token_is (parser, CPP_NAME))
23043 : : {
23044 : 30 : const char *q
23045 : 30 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
23046 : :
23047 : 30 : if (!strcmp (q, "seq_cst"))
23048 : : new_fail = OMP_MEMORY_ORDER_SEQ_CST;
23049 : 24 : else if (!strcmp (q, "acquire"))
23050 : : new_fail = OMP_MEMORY_ORDER_ACQUIRE;
23051 : 17 : else if (!strcmp (q, "relaxed"))
23052 : : new_fail = OMP_MEMORY_ORDER_RELAXED;
23053 : : }
23054 : :
23055 : : if (new_fail != OMP_MEMORY_ORDER_UNSPECIFIED)
23056 : : {
23057 : 27 : c_parser_consume_token (parser);
23058 : 27 : if (fail != OMP_MEMORY_ORDER_UNSPECIFIED)
23059 : 2 : error_at (cloc, "too many %qs clauses", "fail");
23060 : : else
23061 : : fail = new_fail;
23062 : : }
23063 : : else
23064 : 5 : c_parser_error (parser, "expected %<seq_cst%>, %<acquire%> "
23065 : : "or %<relaxed%>");
23066 : 32 : parens.skip_until_found_close (parser);
23067 : 32 : continue;
23068 : 32 : }
23069 : 189 : else if (!strcmp (p, "seq_cst"))
23070 : : new_memory_order = OMP_MEMORY_ORDER_SEQ_CST;
23071 : 112 : else if (!strcmp (p, "acq_rel"))
23072 : : new_memory_order = OMP_MEMORY_ORDER_ACQ_REL;
23073 : 100 : else if (!strcmp (p, "release"))
23074 : : new_memory_order = OMP_MEMORY_ORDER_RELEASE;
23075 : 70 : else if (!strcmp (p, "acquire"))
23076 : : new_memory_order = OMP_MEMORY_ORDER_ACQUIRE;
23077 : 57 : else if (!strcmp (p, "relaxed"))
23078 : : new_memory_order = OMP_MEMORY_ORDER_RELAXED;
23079 : 31 : else if (!strcmp (p, "hint"))
23080 : : {
23081 : 29 : c_parser_consume_token (parser);
23082 : 29 : clauses = c_parser_omp_clause_hint (parser, clauses);
23083 : 29 : continue;
23084 : : }
23085 : : else
23086 : : {
23087 : 2 : p = NULL;
23088 : 2 : error_at (cloc, "expected %<read%>, %<write%>, %<update%>, "
23089 : : "%<capture%>, %<compare%>, %<weak%>, %<fail%>, "
23090 : : "%<seq_cst%>, %<acq_rel%>, %<release%>, "
23091 : : "%<relaxed%> or %<hint%> clause");
23092 : : }
23093 : 6 : if (p)
23094 : : {
23095 : 1417 : if (new_code != ERROR_MARK)
23096 : : {
23097 : : /* OpenACC permits 'update capture'. */
23098 : 829 : if (openacc
23099 : 829 : && code == OMP_ATOMIC
23100 : 4 : && new_code == OMP_ATOMIC_CAPTURE_NEW)
23101 : : code = new_code;
23102 : 826 : else if (code != ERROR_MARK)
23103 : 5 : error_at (cloc, "too many atomic clauses");
23104 : : else
23105 : : code = new_code;
23106 : : }
23107 : 588 : else if (new_memory_order != OMP_MEMORY_ORDER_UNSPECIFIED)
23108 : : {
23109 : 158 : if (memory_order != OMP_MEMORY_ORDER_UNSPECIFIED)
23110 : 35 : error_at (cloc, "too many memory order clauses");
23111 : : else
23112 : : memory_order = new_memory_order;
23113 : : }
23114 : 430 : else if (new_capture)
23115 : : {
23116 : 244 : if (capture)
23117 : 1 : error_at (cloc, "too many %qs clauses", "capture");
23118 : : else
23119 : : capture = true;
23120 : : }
23121 : 186 : else if (new_compare)
23122 : : {
23123 : 173 : if (compare)
23124 : 1 : error_at (cloc, "too many %qs clauses", "compare");
23125 : : else
23126 : : compare = true;
23127 : : }
23128 : 13 : else if (new_weak)
23129 : : {
23130 : 13 : if (weak)
23131 : 1 : error_at (cloc, "too many %qs clauses", "weak");
23132 : : else
23133 : : weak = true;
23134 : : }
23135 : 1417 : c_parser_consume_token (parser);
23136 : 1417 : continue;
23137 : : }
23138 : : }
23139 : : break;
23140 : : }
23141 : 1718 : c_parser_skip_to_pragma_eol (parser);
23142 : :
23143 : 1718 : if (code == ERROR_MARK)
23144 : 897 : code = OMP_ATOMIC;
23145 : 1718 : if (capture)
23146 : : {
23147 : 243 : if (code != OMP_ATOMIC)
23148 : 2 : error_at (loc, "%qs clause is incompatible with %<read%> or %<write%> "
23149 : : "clauses", "capture");
23150 : : else
23151 : : code = OMP_ATOMIC_CAPTURE_NEW;
23152 : : }
23153 : 1718 : if (compare && code != OMP_ATOMIC && code != OMP_ATOMIC_CAPTURE_NEW)
23154 : : {
23155 : 2 : error_at (loc, "%qs clause is incompatible with %<read%> or %<write%> "
23156 : : "clauses", "compare");
23157 : 2 : compare = false;
23158 : : }
23159 : 1718 : if (fail != OMP_MEMORY_ORDER_UNSPECIFIED && !compare)
23160 : : {
23161 : 5 : error_at (loc, "%qs clause requires %qs clause", "fail", "compare");
23162 : 5 : fail = OMP_MEMORY_ORDER_UNSPECIFIED;
23163 : : }
23164 : 1718 : if (weak && !compare)
23165 : : {
23166 : 5 : error_at (loc, "%qs clause requires %qs clause", "weak", "compare");
23167 : 5 : weak = false;
23168 : : }
23169 : 1718 : if (openacc)
23170 : : memory_order = OMP_MEMORY_ORDER_RELAXED;
23171 : 1409 : else if (memory_order == OMP_MEMORY_ORDER_UNSPECIFIED)
23172 : : {
23173 : 1286 : omp_requires_mask
23174 : 1286 : = (enum omp_requires) (omp_requires_mask
23175 : : | OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER_USED);
23176 : 1286 : switch ((enum omp_memory_order)
23177 : : (omp_requires_mask & OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER))
23178 : : {
23179 : : case OMP_MEMORY_ORDER_UNSPECIFIED:
23180 : : case OMP_MEMORY_ORDER_RELAXED:
23181 : : memory_order = OMP_MEMORY_ORDER_RELAXED;
23182 : : break;
23183 : : case OMP_MEMORY_ORDER_SEQ_CST:
23184 : 9 : memory_order = OMP_MEMORY_ORDER_SEQ_CST;
23185 : : break;
23186 : 4 : case OMP_MEMORY_ORDER_ACQUIRE:
23187 : 4 : if (code == NOP_EXPR) /* atomic write */
23188 : : {
23189 : 1 : error_at (loc, "%<#pragma omp atomic write%> incompatible with "
23190 : : "%<acquire%> clause implicitly provided by a "
23191 : : "%<requires%> directive");
23192 : 1 : memory_order = OMP_MEMORY_ORDER_SEQ_CST;
23193 : : }
23194 : : else
23195 : : memory_order = OMP_MEMORY_ORDER_ACQUIRE;
23196 : : break;
23197 : 3 : case OMP_MEMORY_ORDER_RELEASE:
23198 : 3 : if (code == OMP_ATOMIC_READ)
23199 : : {
23200 : 1 : error_at (loc, "%<#pragma omp atomic read%> incompatible with "
23201 : : "%<release%> clause implicitly provided by a "
23202 : : "%<requires%> directive");
23203 : 1 : memory_order = OMP_MEMORY_ORDER_SEQ_CST;
23204 : : }
23205 : : else
23206 : : memory_order = OMP_MEMORY_ORDER_RELEASE;
23207 : : break;
23208 : 9 : case OMP_MEMORY_ORDER_ACQ_REL:
23209 : 9 : switch (code)
23210 : : {
23211 : : case OMP_ATOMIC_READ:
23212 : : memory_order = OMP_MEMORY_ORDER_ACQUIRE;
23213 : : break;
23214 : : case NOP_EXPR: /* atomic write */
23215 : 5 : memory_order = OMP_MEMORY_ORDER_RELEASE;
23216 : : break;
23217 : : default:
23218 : 1718 : memory_order = OMP_MEMORY_ORDER_ACQ_REL;
23219 : : break;
23220 : : }
23221 : : break;
23222 : 0 : default:
23223 : 0 : gcc_unreachable ();
23224 : : }
23225 : : }
23226 : : else
23227 : 123 : switch (code)
23228 : : {
23229 : 25 : case OMP_ATOMIC_READ:
23230 : 25 : if (memory_order == OMP_MEMORY_ORDER_RELEASE)
23231 : : {
23232 : 1 : error_at (loc, "%<#pragma omp atomic read%> incompatible with "
23233 : : "%<release%> clause");
23234 : 1 : memory_order = OMP_MEMORY_ORDER_SEQ_CST;
23235 : : }
23236 : 24 : else if (memory_order == OMP_MEMORY_ORDER_ACQ_REL)
23237 : 6 : memory_order = OMP_MEMORY_ORDER_ACQUIRE;
23238 : : break;
23239 : 16 : case NOP_EXPR: /* atomic write */
23240 : 16 : if (memory_order == OMP_MEMORY_ORDER_ACQUIRE)
23241 : : {
23242 : 1 : error_at (loc, "%<#pragma omp atomic write%> incompatible with "
23243 : : "%<acquire%> clause");
23244 : 1 : memory_order = OMP_MEMORY_ORDER_SEQ_CST;
23245 : : }
23246 : 15 : else if (memory_order == OMP_MEMORY_ORDER_ACQ_REL)
23247 : 5 : memory_order = OMP_MEMORY_ORDER_RELEASE;
23248 : : break;
23249 : : default:
23250 : : break;
23251 : : }
23252 : 1718 : if (fail != OMP_MEMORY_ORDER_UNSPECIFIED)
23253 : 20 : memory_order
23254 : 20 : = (enum omp_memory_order) (memory_order
23255 : : | (fail << OMP_FAIL_MEMORY_ORDER_SHIFT));
23256 : :
23257 : 1718 : switch (code)
23258 : : {
23259 : 434 : case OMP_ATOMIC_READ:
23260 : 434 : case NOP_EXPR: /* atomic write */
23261 : 434 : v = c_parser_cast_expression (parser, NULL).value;
23262 : 434 : non_lvalue_p = !lvalue_p (v);
23263 : 434 : v = c_fully_fold (v, false, NULL, true);
23264 : 434 : if (v == error_mark_node)
23265 : 0 : goto saw_error;
23266 : 434 : if (non_lvalue_p)
23267 : 4 : v = non_lvalue (v);
23268 : 434 : loc = c_parser_peek_token (parser)->location;
23269 : 434 : if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
23270 : 0 : goto saw_error;
23271 : 434 : if (code == NOP_EXPR)
23272 : : {
23273 : 176 : eloc = c_parser_peek_token (parser)->location;
23274 : 176 : expr = c_parser_expression (parser);
23275 : 176 : expr = default_function_array_read_conversion (eloc, expr);
23276 : : /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
23277 : : opcode. */
23278 : 176 : code = OMP_ATOMIC;
23279 : 176 : lhs = v;
23280 : 176 : v = NULL_TREE;
23281 : 176 : rhs = c_fully_fold (expr.value, false, NULL);
23282 : 176 : if (rhs == error_mark_node)
23283 : 0 : goto saw_error;
23284 : : }
23285 : : else
23286 : : {
23287 : 258 : lhs = c_parser_cast_expression (parser, NULL).value;
23288 : 258 : non_lvalue_p = !lvalue_p (lhs);
23289 : 258 : lhs = c_fully_fold (lhs, false, NULL, true);
23290 : 258 : if (lhs == error_mark_node)
23291 : 0 : goto saw_error;
23292 : 258 : if (non_lvalue_p)
23293 : 2 : lhs = non_lvalue (lhs);
23294 : : }
23295 : 434 : goto done;
23296 : 473 : case OMP_ATOMIC_CAPTURE_NEW:
23297 : 473 : if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
23298 : : {
23299 : 314 : c_parser_consume_token (parser);
23300 : 314 : structured_block = true;
23301 : : }
23302 : 159 : else if (compare
23303 : 188 : && c_parser_next_token_is_keyword (parser, RID_IF))
23304 : : break;
23305 : : else
23306 : : {
23307 : 142 : v = c_parser_cast_expression (parser, NULL).value;
23308 : 142 : non_lvalue_p = !lvalue_p (v);
23309 : 142 : v = c_fully_fold (v, false, NULL, true);
23310 : 142 : if (v == error_mark_node)
23311 : 0 : goto saw_error;
23312 : 142 : if (non_lvalue_p)
23313 : 2 : v = non_lvalue (v);
23314 : 142 : if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
23315 : 0 : goto saw_error;
23316 : 154 : if (compare && c_parser_next_token_is_keyword (parser, RID_IF))
23317 : : {
23318 : 1 : eloc = c_parser_peek_token (parser)->location;
23319 : 1 : error_at (eloc, "expected expression");
23320 : 1 : goto saw_error;
23321 : : }
23322 : : }
23323 : : break;
23324 : : default:
23325 : : break;
23326 : : }
23327 : :
23328 : : /* For structured_block case we don't know yet whether
23329 : : old or new x should be captured. */
23330 : 1283 : restart:
23331 : 1675 : if (compare && c_parser_next_token_is_keyword (parser, RID_IF))
23332 : : {
23333 : 85 : c_parser_consume_token (parser);
23334 : :
23335 : 85 : matching_parens parens;
23336 : 85 : if (!parens.require_open (parser))
23337 : 34 : goto saw_error;
23338 : 84 : eloc = c_parser_peek_token (parser)->location;
23339 : 84 : c_expr cmp_expr;
23340 : 84 : if (r)
23341 : : {
23342 : 17 : cmp_expr = c_parser_cast_expression (parser, NULL);
23343 : 17 : cmp_expr = default_function_array_conversion (eloc, cmp_expr);
23344 : : }
23345 : : else
23346 : 67 : cmp_expr = c_parser_binary_expression (parser, NULL, void_list_node);
23347 : 84 : parens.skip_until_found_close (parser);
23348 : 84 : if (cmp_expr.value == error_mark_node)
23349 : 0 : goto saw_error;
23350 : 84 : if (r)
23351 : : {
23352 : 17 : if (!c_tree_equal (cmp_expr.value, unfolded_lhs))
23353 : 1 : goto bad_if;
23354 : 16 : cmp_expr.value = rhs1;
23355 : 16 : rhs1 = NULL_TREE;
23356 : 16 : gcc_assert (TREE_CODE (cmp_expr.value) == EQ_EXPR);
23357 : : }
23358 : 83 : if (TREE_CODE (cmp_expr.value) == EQ_EXPR)
23359 : : ;
23360 : 36 : else if (!structured_block && code == OMP_ATOMIC_CAPTURE_NEW)
23361 : : {
23362 : 4 : error_at (EXPR_LOC_OR_LOC (cmp_expr.value, eloc),
23363 : : "expected %<==%> comparison in %<if%> condition");
23364 : 2 : goto saw_error;
23365 : : }
23366 : 34 : else if (TREE_CODE (cmp_expr.value) != GT_EXPR
23367 : 25 : && TREE_CODE (cmp_expr.value) != LT_EXPR)
23368 : : {
23369 : 16 : error_at (EXPR_LOC_OR_LOC (cmp_expr.value, eloc),
23370 : : "expected %<==%>, %<<%> or %<>%> comparison in %<if%> "
23371 : : "condition");
23372 : 10 : goto saw_error;
23373 : : }
23374 : 71 : if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
23375 : 2 : goto saw_error;
23376 : :
23377 : 69 : extra_scope = true;
23378 : 69 : eloc = c_parser_peek_token (parser)->location;
23379 : 69 : expr = c_parser_cast_expression (parser, NULL);
23380 : 69 : lhs = expr.value;
23381 : 69 : expr = default_function_array_conversion (eloc, expr);
23382 : 69 : unfolded_lhs = expr.value;
23383 : 69 : lhs = c_fully_fold (lhs, false, NULL, true);
23384 : 69 : orig_lhs = lhs;
23385 : 69 : if (lhs == error_mark_node)
23386 : 0 : goto saw_error;
23387 : 69 : if (!lvalue_p (unfolded_lhs))
23388 : 0 : lhs = non_lvalue (lhs);
23389 : 69 : if (!c_parser_next_token_is (parser, CPP_EQ))
23390 : : {
23391 : 1 : c_parser_error (parser, "expected %<=%>");
23392 : 1 : goto saw_error;
23393 : : }
23394 : 68 : c_parser_consume_token (parser);
23395 : 68 : eloc = c_parser_peek_token (parser)->location;
23396 : 68 : expr = c_parser_expr_no_commas (parser, NULL);
23397 : 68 : rhs1 = expr.value;
23398 : :
23399 : 68 : if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
23400 : 1 : goto saw_error;
23401 : :
23402 : 67 : if (!c_parser_require (parser, CPP_CLOSE_BRACE, "expected %<}%>"))
23403 : 1 : goto saw_error;
23404 : :
23405 : 66 : extra_scope = false;
23406 : 66 : no_semicolon = true;
23407 : :
23408 : 66 : if (c_tree_equal (TREE_OPERAND (cmp_expr.value, 0), unfolded_lhs))
23409 : : {
23410 : 59 : if (TREE_CODE (cmp_expr.value) == EQ_EXPR)
23411 : : {
23412 : 44 : opcode = COND_EXPR;
23413 : 44 : rhs = c_fully_fold (TREE_OPERAND (cmp_expr.value, 1),
23414 : : false, NULL, true);
23415 : 44 : rhs1 = c_fully_fold (rhs1, false, NULL, true);
23416 : : }
23417 : 15 : else if (c_tree_equal (TREE_OPERAND (cmp_expr.value, 1), rhs1))
23418 : : {
23419 : 7 : opcode = (TREE_CODE (cmp_expr.value) == GT_EXPR
23420 : 13 : ? MIN_EXPR : MAX_EXPR);
23421 : 13 : rhs = c_fully_fold (rhs1, false, NULL, true);
23422 : 13 : rhs1 = c_fully_fold (TREE_OPERAND (cmp_expr.value, 0),
23423 : : false, NULL, true);
23424 : : }
23425 : : else
23426 : 2 : goto bad_if;
23427 : : }
23428 : 7 : else if (TREE_CODE (cmp_expr.value) == EQ_EXPR)
23429 : 2 : goto bad_if;
23430 : 5 : else if (c_tree_equal (TREE_OPERAND (cmp_expr.value, 1), unfolded_lhs)
23431 : 5 : && c_tree_equal (TREE_OPERAND (cmp_expr.value, 0), rhs1))
23432 : : {
23433 : 2 : opcode = (TREE_CODE (cmp_expr.value) == GT_EXPR
23434 : 3 : ? MAX_EXPR : MIN_EXPR);
23435 : 3 : rhs = c_fully_fold (rhs1, false, NULL, true);
23436 : 3 : rhs1 = c_fully_fold (TREE_OPERAND (cmp_expr.value, 1),
23437 : : false, NULL, true);
23438 : : }
23439 : : else
23440 : : {
23441 : 8 : bad_if:
23442 : 8 : c_parser_error (parser,
23443 : : "invalid form of %<#pragma omp atomic compare%>");
23444 : 8 : goto saw_error;
23445 : : }
23446 : :
23447 : 60 : if (c_parser_next_token_is_keyword (parser, RID_ELSE))
23448 : : {
23449 : 24 : if (code != OMP_ATOMIC_CAPTURE_NEW
23450 : 22 : || (structured_block && r == NULL_TREE)
23451 : 21 : || TREE_CODE (cmp_expr.value) != EQ_EXPR)
23452 : : {
23453 : 3 : eloc = c_parser_peek_token (parser)->location;
23454 : 3 : error_at (eloc, "unexpected %<else%>");
23455 : 3 : goto saw_error;
23456 : : }
23457 : :
23458 : 21 : c_parser_consume_token (parser);
23459 : :
23460 : 21 : if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
23461 : 1 : goto saw_error;
23462 : :
23463 : 20 : extra_scope = true;
23464 : 20 : v = c_parser_cast_expression (parser, NULL).value;
23465 : 20 : non_lvalue_p = !lvalue_p (v);
23466 : 20 : v = c_fully_fold (v, false, NULL, true);
23467 : 20 : if (v == error_mark_node)
23468 : 0 : goto saw_error;
23469 : 20 : if (non_lvalue_p)
23470 : 0 : v = non_lvalue (v);
23471 : 20 : if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
23472 : 1 : goto saw_error;
23473 : :
23474 : 19 : expr = c_parser_expr_no_commas (parser, NULL);
23475 : :
23476 : 19 : if (!c_tree_equal (expr.value, unfolded_lhs))
23477 : 1 : goto bad_if;
23478 : :
23479 : 18 : if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
23480 : 1 : goto saw_error;
23481 : :
23482 : 17 : if (!c_parser_require (parser, CPP_CLOSE_BRACE, "expected %<}%>"))
23483 : 0 : goto saw_error;
23484 : :
23485 : 17 : extra_scope = false;
23486 : 17 : code = OMP_ATOMIC_CAPTURE_OLD;
23487 : 17 : if (r == NULL_TREE)
23488 : : /* Signal to c_finish_omp_atomic that in
23489 : : if (x == e) { x = d; } else { v = x; }
23490 : : case the store to v should be conditional. */
23491 : 10 : r = void_list_node;
23492 : : }
23493 : 36 : else if (code == OMP_ATOMIC_CAPTURE_NEW && !structured_block)
23494 : : {
23495 : 1 : c_parser_require_keyword (parser, RID_ELSE, "expected %<else%>");
23496 : 1 : goto saw_error;
23497 : : }
23498 : 35 : else if (code == OMP_ATOMIC_CAPTURE_NEW
23499 : 35 : && r != NULL_TREE
23500 : 9 : && v == NULL_TREE)
23501 : 52 : code = OMP_ATOMIC;
23502 : 52 : goto stmt_done;
23503 : : }
23504 : 1382 : eloc = c_parser_peek_token (parser)->location;
23505 : 1382 : expr = c_parser_cast_expression (parser, NULL);
23506 : 1382 : lhs = expr.value;
23507 : 1382 : expr = default_function_array_conversion (eloc, expr);
23508 : 1382 : unfolded_lhs = expr.value;
23509 : 1382 : lhs = c_fully_fold (lhs, false, NULL, true);
23510 : 1382 : orig_lhs = lhs;
23511 : 1382 : switch (TREE_CODE (lhs))
23512 : : {
23513 : 4 : invalid_compare:
23514 : 4 : error_at (eloc, "invalid form of %<pragma omp atomic compare%>");
23515 : : /* FALLTHRU */
23516 : 84 : case ERROR_MARK:
23517 : 84 : saw_error:
23518 : 84 : c_parser_skip_to_end_of_block_or_statement (parser);
23519 : 90 : if (extra_scope && c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
23520 : 4 : c_parser_consume_token (parser);
23521 : 84 : if (structured_block)
23522 : : {
23523 : 10 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
23524 : 9 : c_parser_consume_token (parser);
23525 : 1 : else if (code == OMP_ATOMIC_CAPTURE_NEW)
23526 : : {
23527 : 1 : c_parser_skip_to_end_of_block_or_statement (parser);
23528 : 1 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
23529 : 1 : c_parser_consume_token (parser);
23530 : : }
23531 : : }
23532 : 84 : return;
23533 : :
23534 : 158 : case POSTINCREMENT_EXPR:
23535 : 158 : if (code == OMP_ATOMIC_CAPTURE_NEW && !structured_block)
23536 : 20 : code = OMP_ATOMIC_CAPTURE_OLD;
23537 : : /* FALLTHROUGH */
23538 : 220 : case PREINCREMENT_EXPR:
23539 : 220 : lhs = TREE_OPERAND (lhs, 0);
23540 : 220 : unfolded_lhs = NULL_TREE;
23541 : 220 : opcode = PLUS_EXPR;
23542 : 220 : rhs = integer_one_node;
23543 : 220 : if (compare)
23544 : 2 : goto invalid_compare;
23545 : : break;
23546 : :
23547 : 24 : case POSTDECREMENT_EXPR:
23548 : 24 : if (code == OMP_ATOMIC_CAPTURE_NEW && !structured_block)
23549 : 2 : code = OMP_ATOMIC_CAPTURE_OLD;
23550 : : /* FALLTHROUGH */
23551 : 52 : case PREDECREMENT_EXPR:
23552 : 52 : lhs = TREE_OPERAND (lhs, 0);
23553 : 52 : unfolded_lhs = NULL_TREE;
23554 : 52 : opcode = MINUS_EXPR;
23555 : 52 : rhs = integer_one_node;
23556 : 52 : if (compare)
23557 : 2 : goto invalid_compare;
23558 : : break;
23559 : :
23560 : 12 : case COMPOUND_EXPR:
23561 : 12 : if (TREE_CODE (TREE_OPERAND (lhs, 0)) == SAVE_EXPR
23562 : 12 : && TREE_CODE (TREE_OPERAND (lhs, 1)) == COMPOUND_EXPR
23563 : 12 : && TREE_CODE (TREE_OPERAND (TREE_OPERAND (lhs, 1), 0)) == MODIFY_EXPR
23564 : 12 : && TREE_OPERAND (TREE_OPERAND (lhs, 1), 1) == TREE_OPERAND (lhs, 0)
23565 : 24 : && C_BOOLEAN_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND
23566 : : (TREE_OPERAND (lhs, 1), 0), 0))))
23567 : : /* Undo effects of boolean_increment for post {in,de}crement. */
23568 : 12 : lhs = TREE_OPERAND (TREE_OPERAND (lhs, 1), 0);
23569 : : /* FALLTHRU */
23570 : 24 : case MODIFY_EXPR:
23571 : 24 : if (TREE_CODE (lhs) == MODIFY_EXPR
23572 : 24 : && C_BOOLEAN_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs, 0))))
23573 : : {
23574 : : /* Undo effects of boolean_increment. */
23575 : 24 : if (integer_onep (TREE_OPERAND (lhs, 1)))
23576 : : {
23577 : : /* This is pre or post increment. */
23578 : 12 : rhs = TREE_OPERAND (lhs, 1);
23579 : 12 : lhs = TREE_OPERAND (lhs, 0);
23580 : 12 : unfolded_lhs = NULL_TREE;
23581 : 12 : opcode = NOP_EXPR;
23582 : 12 : if (code == OMP_ATOMIC_CAPTURE_NEW
23583 : 12 : && !structured_block
23584 : 2 : && TREE_CODE (orig_lhs) == COMPOUND_EXPR)
23585 : 1 : code = OMP_ATOMIC_CAPTURE_OLD;
23586 : 12 : if (compare)
23587 : 0 : goto invalid_compare;
23588 : : break;
23589 : : }
23590 : 12 : if (TREE_CODE (TREE_OPERAND (lhs, 1)) == TRUTH_NOT_EXPR
23591 : 12 : && TREE_OPERAND (lhs, 0)
23592 : 12 : == TREE_OPERAND (TREE_OPERAND (lhs, 1), 0))
23593 : : {
23594 : : /* This is pre or post decrement. */
23595 : 12 : rhs = TREE_OPERAND (lhs, 1);
23596 : 12 : lhs = TREE_OPERAND (lhs, 0);
23597 : 12 : unfolded_lhs = NULL_TREE;
23598 : 12 : opcode = NOP_EXPR;
23599 : 12 : if (code == OMP_ATOMIC_CAPTURE_NEW
23600 : 12 : && !structured_block
23601 : 2 : && TREE_CODE (orig_lhs) == COMPOUND_EXPR)
23602 : 1 : code = OMP_ATOMIC_CAPTURE_OLD;
23603 : 12 : if (compare)
23604 : 0 : goto invalid_compare;
23605 : : break;
23606 : : }
23607 : : }
23608 : : /* FALLTHRU */
23609 : 1082 : default:
23610 : 1082 : if (!lvalue_p (unfolded_lhs))
23611 : 5 : lhs = non_lvalue (lhs);
23612 : 1201 : if (compare && !c_parser_next_token_is (parser, CPP_EQ))
23613 : : {
23614 : 7 : c_parser_error (parser, "expected %<=%>");
23615 : 7 : goto saw_error;
23616 : : }
23617 : 1075 : switch (c_parser_peek_token (parser)->type)
23618 : : {
23619 : : case CPP_MULT_EQ:
23620 : : opcode = MULT_EXPR;
23621 : : break;
23622 : : case CPP_DIV_EQ:
23623 : : opcode = TRUNC_DIV_EXPR;
23624 : : break;
23625 : : case CPP_PLUS_EQ:
23626 : : opcode = PLUS_EXPR;
23627 : : break;
23628 : : case CPP_MINUS_EQ:
23629 : : opcode = MINUS_EXPR;
23630 : : break;
23631 : : case CPP_LSHIFT_EQ:
23632 : : opcode = LSHIFT_EXPR;
23633 : : break;
23634 : : case CPP_RSHIFT_EQ:
23635 : : opcode = RSHIFT_EXPR;
23636 : : break;
23637 : : case CPP_AND_EQ:
23638 : : opcode = BIT_AND_EXPR;
23639 : : break;
23640 : : case CPP_OR_EQ:
23641 : : opcode = BIT_IOR_EXPR;
23642 : : break;
23643 : : case CPP_XOR_EQ:
23644 : : opcode = BIT_XOR_EXPR;
23645 : : break;
23646 : 556 : case CPP_EQ:
23647 : 556 : c_parser_consume_token (parser);
23648 : 556 : eloc = c_parser_peek_token (parser)->location;
23649 : 556 : expr = c_parser_expr_no_commas (parser, NULL, unfolded_lhs);
23650 : 556 : rhs1 = expr.value;
23651 : 556 : switch (TREE_CODE (rhs1))
23652 : : {
23653 : 289 : case MULT_EXPR:
23654 : 289 : case TRUNC_DIV_EXPR:
23655 : 289 : case RDIV_EXPR:
23656 : 289 : case PLUS_EXPR:
23657 : 289 : case MINUS_EXPR:
23658 : 289 : case LSHIFT_EXPR:
23659 : 289 : case RSHIFT_EXPR:
23660 : 289 : case BIT_AND_EXPR:
23661 : 289 : case BIT_IOR_EXPR:
23662 : 289 : case BIT_XOR_EXPR:
23663 : 289 : if (compare)
23664 : : break;
23665 : 282 : if (c_tree_equal (TREE_OPERAND (rhs1, 0), unfolded_lhs))
23666 : : {
23667 : 147 : opcode = TREE_CODE (rhs1);
23668 : 147 : rhs = c_fully_fold (TREE_OPERAND (rhs1, 1), false, NULL,
23669 : : true);
23670 : 147 : rhs1 = c_fully_fold (TREE_OPERAND (rhs1, 0), false, NULL,
23671 : : true);
23672 : 147 : goto stmt_done;
23673 : : }
23674 : 135 : if (c_tree_equal (TREE_OPERAND (rhs1, 1), unfolded_lhs))
23675 : : {
23676 : 117 : opcode = TREE_CODE (rhs1);
23677 : 117 : rhs = c_fully_fold (TREE_OPERAND (rhs1, 0), false, NULL,
23678 : : true);
23679 : 117 : rhs1 = c_fully_fold (TREE_OPERAND (rhs1, 1), false, NULL,
23680 : : true);
23681 : 117 : swapped = !commutative_tree_code (opcode);
23682 : 117 : goto stmt_done;
23683 : : }
23684 : : break;
23685 : 69 : case COND_EXPR:
23686 : 69 : if (!compare)
23687 : : break;
23688 : 66 : if (TREE_CODE (TREE_OPERAND (rhs1, 0)) != GT_EXPR
23689 : 44 : && TREE_CODE (TREE_OPERAND (rhs1, 0)) != LT_EXPR
23690 : 97 : && TREE_CODE (TREE_OPERAND (rhs1, 0)) != EQ_EXPR)
23691 : : break;
23692 : 63 : if (!TREE_OPERAND (rhs1, 1))
23693 : : break;
23694 : 63 : if (!c_tree_equal (TREE_OPERAND (rhs1, 2), unfolded_lhs))
23695 : : break;
23696 : 58 : if (c_tree_equal (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 0),
23697 : : unfolded_lhs))
23698 : : {
23699 : 39 : if (TREE_CODE (TREE_OPERAND (rhs1, 0)) == EQ_EXPR)
23700 : : {
23701 : 23 : opcode = COND_EXPR;
23702 : 23 : rhs = c_fully_fold (TREE_OPERAND (TREE_OPERAND (rhs1,
23703 : : 0), 1),
23704 : : false, NULL, true);
23705 : 23 : rhs1 = c_fully_fold (TREE_OPERAND (rhs1, 1), false,
23706 : : NULL, true);
23707 : 23 : goto stmt_done;
23708 : : }
23709 : 16 : if (c_tree_equal (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 1),
23710 : 16 : TREE_OPERAND (rhs1, 1)))
23711 : : {
23712 : 21 : opcode = (TREE_CODE (TREE_OPERAND (rhs1, 0)) == GT_EXPR
23713 : 14 : ? MIN_EXPR : MAX_EXPR);
23714 : 14 : rhs = c_fully_fold (TREE_OPERAND (rhs1, 1), false, NULL,
23715 : : true);
23716 : 14 : rhs1 = c_fully_fold (TREE_OPERAND (TREE_OPERAND (rhs1,
23717 : : 0), 0),
23718 : : false, NULL, true);
23719 : 14 : goto stmt_done;
23720 : : }
23721 : : }
23722 : 19 : else if (TREE_CODE (TREE_OPERAND (rhs1, 0)) == EQ_EXPR)
23723 : : break;
23724 : 17 : else if (c_tree_equal (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 1),
23725 : : unfolded_lhs))
23726 : : {
23727 : 15 : if (c_tree_equal (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 0),
23728 : 15 : TREE_OPERAND (rhs1, 1)))
23729 : : {
23730 : 18 : opcode = (TREE_CODE (TREE_OPERAND (rhs1, 0)) == GT_EXPR
23731 : 15 : ? MAX_EXPR : MIN_EXPR);
23732 : 15 : rhs = c_fully_fold (TREE_OPERAND (rhs1, 1), false, NULL,
23733 : : true);
23734 : 15 : rhs1 = c_fully_fold (TREE_OPERAND (TREE_OPERAND (rhs1,
23735 : : 0), 1),
23736 : : false, NULL, true);
23737 : 15 : goto stmt_done;
23738 : : }
23739 : : }
23740 : : break;
23741 : 17 : case EQ_EXPR:
23742 : 17 : if (!compare
23743 : 17 : || code != OMP_ATOMIC_CAPTURE_NEW
23744 : 17 : || !structured_block
23745 : 17 : || v
23746 : 17 : || r)
23747 : : break;
23748 : 17 : if (c_parser_next_token_is (parser, CPP_SEMICOLON)
23749 : 17 : && c_parser_peek_2nd_token (parser)->keyword == RID_IF)
23750 : : {
23751 : 17 : r = lhs;
23752 : 17 : lhs = NULL_TREE;
23753 : 17 : c_parser_consume_token (parser);
23754 : 17 : goto restart;
23755 : : }
23756 : : break;
23757 : 0 : case ERROR_MARK:
23758 : 0 : goto saw_error;
23759 : : default:
23760 : : break;
23761 : : }
23762 : 223 : if (c_parser_peek_token (parser)->type == CPP_SEMICOLON)
23763 : : {
23764 : 223 : if (structured_block && code == OMP_ATOMIC_CAPTURE_NEW)
23765 : : {
23766 : 167 : code = OMP_ATOMIC_CAPTURE_OLD;
23767 : 167 : v = lhs;
23768 : 167 : lhs = NULL_TREE;
23769 : 167 : expr = default_function_array_read_conversion (eloc, expr);
23770 : 167 : unfolded_lhs1 = expr.value;
23771 : 167 : lhs1 = c_fully_fold (unfolded_lhs1, false, NULL, true);
23772 : 167 : rhs1 = NULL_TREE;
23773 : 167 : c_parser_consume_token (parser);
23774 : 167 : goto restart;
23775 : : }
23776 : 56 : if (structured_block && !compare)
23777 : : {
23778 : 26 : opcode = NOP_EXPR;
23779 : 26 : expr = default_function_array_read_conversion (eloc, expr);
23780 : 26 : rhs = c_fully_fold (expr.value, false, NULL, true);
23781 : 26 : rhs1 = NULL_TREE;
23782 : 26 : goto stmt_done;
23783 : : }
23784 : : }
23785 : 30 : c_parser_error (parser, "invalid form of %<#pragma omp atomic%>");
23786 : 30 : goto saw_error;
23787 : 5 : default:
23788 : 5 : c_parser_error (parser,
23789 : : "invalid operator for %<#pragma omp atomic%>");
23790 : 5 : goto saw_error;
23791 : : }
23792 : :
23793 : : /* Arrange to pass the location of the assignment operator to
23794 : : c_finish_omp_atomic. */
23795 : 514 : loc = c_parser_peek_token (parser)->location;
23796 : 514 : c_parser_consume_token (parser);
23797 : 514 : eloc = c_parser_peek_token (parser)->location;
23798 : 514 : expr = c_parser_expression (parser);
23799 : 514 : expr = default_function_array_read_conversion (eloc, expr);
23800 : 514 : rhs = expr.value;
23801 : 514 : rhs = c_fully_fold (rhs, false, NULL, true);
23802 : 514 : break;
23803 : : }
23804 : 1200 : stmt_done:
23805 : 1200 : if (structured_block && code == OMP_ATOMIC_CAPTURE_NEW && r == NULL_TREE)
23806 : : {
23807 : 129 : if (!no_semicolon
23808 : 129 : && !c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
23809 : 0 : goto saw_error;
23810 : 129 : no_semicolon = false;
23811 : 129 : v = c_parser_cast_expression (parser, NULL).value;
23812 : 129 : non_lvalue_p = !lvalue_p (v);
23813 : 129 : v = c_fully_fold (v, false, NULL, true);
23814 : 129 : if (v == error_mark_node)
23815 : 0 : goto saw_error;
23816 : 129 : if (non_lvalue_p)
23817 : 2 : v = non_lvalue (v);
23818 : 129 : if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
23819 : 0 : goto saw_error;
23820 : 129 : eloc = c_parser_peek_token (parser)->location;
23821 : 129 : expr = c_parser_cast_expression (parser, NULL);
23822 : 129 : lhs1 = expr.value;
23823 : 129 : expr = default_function_array_read_conversion (eloc, expr);
23824 : 129 : unfolded_lhs1 = expr.value;
23825 : 129 : lhs1 = c_fully_fold (lhs1, false, NULL, true);
23826 : 129 : if (lhs1 == error_mark_node)
23827 : 0 : goto saw_error;
23828 : 129 : if (!lvalue_p (unfolded_lhs1))
23829 : 2 : lhs1 = non_lvalue (lhs1);
23830 : : }
23831 : 1200 : if (structured_block)
23832 : : {
23833 : 304 : if (!no_semicolon)
23834 : 280 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
23835 : 304 : c_parser_require (parser, CPP_CLOSE_BRACE, "expected %<}%>");
23836 : : }
23837 : 896 : done:
23838 : 1634 : if (weak && opcode != COND_EXPR)
23839 : : {
23840 : 1 : error_at (loc, "%<weak%> clause requires atomic equality comparison");
23841 : 1 : weak = false;
23842 : : }
23843 : 1634 : if (unfolded_lhs && unfolded_lhs1
23844 : 1634 : && !c_tree_equal (unfolded_lhs, unfolded_lhs1))
23845 : : {
23846 : 5 : error ("%<#pragma omp atomic capture%> uses two different "
23847 : : "expressions for memory");
23848 : 5 : stmt = error_mark_node;
23849 : : }
23850 : : else
23851 : 1629 : stmt = c_finish_omp_atomic (loc, code, opcode, lhs, rhs, v, lhs1, rhs1, r,
23852 : : swapped, memory_order, weak);
23853 : 1634 : if (stmt != error_mark_node)
23854 : 1604 : add_stmt (stmt);
23855 : :
23856 : 1634 : if (!structured_block && !no_semicolon)
23857 : 1311 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
23858 : : }
23859 : :
23860 : :
23861 : : /* OpenMP 2.5:
23862 : : # pragma omp barrier new-line
23863 : : */
23864 : :
23865 : : static void
23866 : 348 : c_parser_omp_barrier (c_parser *parser)
23867 : : {
23868 : 348 : location_t loc = c_parser_peek_token (parser)->location;
23869 : 348 : c_parser_consume_pragma (parser);
23870 : 348 : c_parser_skip_to_pragma_eol (parser);
23871 : :
23872 : 348 : c_finish_omp_barrier (loc);
23873 : 348 : }
23874 : :
23875 : : /* OpenMP 2.5:
23876 : : # pragma omp critical [(name)] new-line
23877 : : structured-block
23878 : :
23879 : : OpenMP 4.5:
23880 : : # pragma omp critical [(name) [hint(expression)]] new-line
23881 : :
23882 : : LOC is the location of the #pragma itself. */
23883 : :
23884 : : #define OMP_CRITICAL_CLAUSE_MASK \
23885 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HINT) )
23886 : :
23887 : : static tree
23888 : 144 : c_parser_omp_critical (location_t loc, c_parser *parser, bool *if_p)
23889 : : {
23890 : 144 : tree stmt, name = NULL_TREE, clauses = NULL_TREE;
23891 : :
23892 : 144 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
23893 : : {
23894 : 49 : c_parser_consume_token (parser);
23895 : 49 : if (c_parser_next_token_is (parser, CPP_NAME))
23896 : : {
23897 : 48 : name = c_parser_peek_token (parser)->value;
23898 : 48 : c_parser_consume_token (parser);
23899 : 48 : c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>");
23900 : : }
23901 : : else
23902 : 1 : c_parser_error (parser, "expected identifier");
23903 : :
23904 : 49 : if (c_parser_next_token_is (parser, CPP_COMMA)
23905 : 49 : && c_parser_peek_2nd_token (parser)->type == CPP_NAME)
23906 : 4 : c_parser_consume_token (parser);
23907 : : }
23908 : 144 : clauses = c_parser_omp_all_clauses (parser, OMP_CRITICAL_CLAUSE_MASK,
23909 : : "#pragma omp critical");
23910 : 144 : stmt = c_parser_omp_structured_block (parser, if_p);
23911 : 144 : return c_finish_omp_critical (loc, stmt, name, clauses);
23912 : : }
23913 : :
23914 : : /* OpenMP 5.0:
23915 : : # pragma omp depobj ( depobj ) depobj-clause new-line
23916 : :
23917 : : depobj-clause:
23918 : : depend (dependence-type : locator)
23919 : : destroy
23920 : : update (dependence-type)
23921 : :
23922 : : OpenMP 5.2 additionally:
23923 : : destroy ( depobj )
23924 : :
23925 : : dependence-type:
23926 : : in
23927 : : out
23928 : : inout
23929 : : mutexinout */
23930 : :
23931 : : static void
23932 : 75 : c_parser_omp_depobj (c_parser *parser)
23933 : : {
23934 : 75 : location_t loc = c_parser_peek_token (parser)->location;
23935 : 75 : c_parser_consume_pragma (parser);
23936 : 75 : matching_parens parens;
23937 : 75 : if (!parens.require_open (parser))
23938 : : {
23939 : 3 : c_parser_skip_to_pragma_eol (parser);
23940 : 3 : return;
23941 : : }
23942 : :
23943 : 72 : tree depobj = c_parser_expr_no_commas (parser, NULL).value;
23944 : 72 : if (depobj != error_mark_node)
23945 : : {
23946 : 71 : if (!lvalue_p (depobj))
23947 : : {
23948 : 1 : error_at (EXPR_LOC_OR_LOC (depobj, loc),
23949 : : "%<depobj%> expression is not lvalue expression");
23950 : 1 : depobj = error_mark_node;
23951 : : }
23952 : : else
23953 : : {
23954 : 123 : tree addr = build_unary_op (EXPR_LOC_OR_LOC (depobj, loc), ADDR_EXPR,
23955 : : depobj, false);
23956 : 70 : if (addr == error_mark_node)
23957 : : depobj = error_mark_node;
23958 : : else
23959 : 123 : depobj = build_indirect_ref (EXPR_LOC_OR_LOC (depobj, loc),
23960 : : addr, RO_UNARY_STAR);
23961 : : }
23962 : : }
23963 : :
23964 : 72 : parens.skip_until_found_close (parser);
23965 : 72 : tree clause = NULL_TREE;
23966 : 72 : enum omp_clause_depend_kind kind = OMP_CLAUSE_DEPEND_INVALID;
23967 : 72 : if (c_parser_next_token_is (parser, CPP_COMMA))
23968 : 3 : c_parser_consume_token (parser);
23969 : 72 : location_t c_loc = c_parser_peek_token (parser)->location;
23970 : 72 : if (c_parser_next_token_is (parser, CPP_NAME))
23971 : : {
23972 : 71 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
23973 : :
23974 : 71 : c_parser_consume_token (parser);
23975 : 71 : if (!strcmp ("depend", p))
23976 : : {
23977 : 38 : clause = c_parser_omp_clause_depend (parser, NULL_TREE);
23978 : 38 : clause = c_finish_omp_clauses (clause, C_ORT_OMP);
23979 : 38 : if (!clause)
23980 : 2 : clause = error_mark_node;
23981 : : }
23982 : 33 : else if (!strcmp ("destroy", p))
23983 : : {
23984 : 22 : matching_parens c_parens;
23985 : 22 : kind = OMP_CLAUSE_DEPEND_LAST;
23986 : 22 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
23987 : 22 : && c_parens.require_open (parser))
23988 : : {
23989 : 7 : tree destobj = c_parser_expr_no_commas (parser, NULL).value;
23990 : 7 : if (!lvalue_p (destobj))
23991 : 1 : error_at (EXPR_LOC_OR_LOC (destobj, c_loc),
23992 : : "%<destroy%> expression is not lvalue expression");
23993 : 6 : else if (depobj != error_mark_node
23994 : 6 : && !operand_equal_p (destobj, depobj,
23995 : : OEP_MATCH_SIDE_EFFECTS
23996 : : | OEP_LEXICOGRAPHIC))
23997 : 4 : warning_at (EXPR_LOC_OR_LOC (destobj, c_loc), OPT_Wopenmp,
23998 : : "the %<destroy%> expression %qE should be the same "
23999 : : "as the %<depobj%> argument %qE", destobj, depobj);
24000 : 7 : c_parens.skip_until_found_close (parser);
24001 : : }
24002 : : }
24003 : 11 : else if (!strcmp ("update", p))
24004 : : {
24005 : 10 : matching_parens c_parens;
24006 : 10 : if (c_parens.require_open (parser))
24007 : : {
24008 : 10 : location_t c2_loc = c_parser_peek_token (parser)->location;
24009 : 10 : if (c_parser_next_token_is (parser, CPP_NAME))
24010 : : {
24011 : 10 : const char *p2
24012 : 10 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
24013 : :
24014 : 10 : c_parser_consume_token (parser);
24015 : 10 : if (!strcmp ("in", p2))
24016 : : kind = OMP_CLAUSE_DEPEND_IN;
24017 : 8 : else if (!strcmp ("out", p2))
24018 : : kind = OMP_CLAUSE_DEPEND_OUT;
24019 : 7 : else if (!strcmp ("inout", p2))
24020 : : kind = OMP_CLAUSE_DEPEND_INOUT;
24021 : 4 : else if (!strcmp ("mutexinoutset", p2))
24022 : : kind = OMP_CLAUSE_DEPEND_MUTEXINOUTSET;
24023 : 3 : else if (!strcmp ("inoutset", p2))
24024 : : kind = OMP_CLAUSE_DEPEND_INOUTSET;
24025 : : }
24026 : : if (kind == OMP_CLAUSE_DEPEND_INVALID)
24027 : : {
24028 : 1 : clause = error_mark_node;
24029 : 1 : error_at (c2_loc, "expected %<in%>, %<out%>, %<inout%>, "
24030 : : "%<mutexinoutset%> or %<inoutset%>");
24031 : : }
24032 : 10 : c_parens.skip_until_found_close (parser);
24033 : : }
24034 : : else
24035 : 0 : clause = error_mark_node;
24036 : : }
24037 : : }
24038 : 72 : if (!clause && kind == OMP_CLAUSE_DEPEND_INVALID)
24039 : : {
24040 : 2 : clause = error_mark_node;
24041 : 2 : error_at (c_loc, "expected %<depend%>, %<destroy%> or %<update%> clause");
24042 : : }
24043 : 72 : c_parser_skip_to_pragma_eol (parser);
24044 : :
24045 : 72 : c_finish_omp_depobj (loc, depobj, kind, clause);
24046 : : }
24047 : :
24048 : :
24049 : : /* OpenMP 2.5:
24050 : : # pragma omp flush flush-vars[opt] new-line
24051 : :
24052 : : flush-vars:
24053 : : ( variable-list )
24054 : :
24055 : : OpenMP 5.0:
24056 : : # pragma omp flush memory-order-clause new-line */
24057 : :
24058 : : static void
24059 : 61 : c_parser_omp_flush (c_parser *parser)
24060 : : {
24061 : 61 : location_t loc = c_parser_peek_token (parser)->location;
24062 : 61 : c_parser_consume_pragma (parser);
24063 : 61 : enum memmodel mo = MEMMODEL_LAST;
24064 : 61 : if (c_parser_next_token_is (parser, CPP_COMMA)
24065 : 61 : && c_parser_peek_2nd_token (parser)->type == CPP_NAME)
24066 : 8 : c_parser_consume_token (parser);
24067 : 61 : if (c_parser_next_token_is (parser, CPP_NAME))
24068 : : {
24069 : 27 : const char *p
24070 : 27 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
24071 : :
24072 : 27 : if (!strcmp (p, "seq_cst"))
24073 : : mo = MEMMODEL_SEQ_CST;
24074 : 21 : else if (!strcmp (p, "acq_rel"))
24075 : : mo = MEMMODEL_ACQ_REL;
24076 : 15 : else if (!strcmp (p, "release"))
24077 : : mo = MEMMODEL_RELEASE;
24078 : 9 : else if (!strcmp (p, "acquire"))
24079 : : mo = MEMMODEL_ACQUIRE;
24080 : : else
24081 : 3 : error_at (c_parser_peek_token (parser)->location,
24082 : : "expected %<seq_cst%>, %<acq_rel%>, %<release%> or "
24083 : : "%<acquire%>");
24084 : 27 : c_parser_consume_token (parser);
24085 : : }
24086 : 61 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
24087 : : {
24088 : 20 : if (mo != MEMMODEL_LAST)
24089 : 4 : error_at (c_parser_peek_token (parser)->location,
24090 : : "%<flush%> list specified together with memory order "
24091 : : "clause");
24092 : 20 : c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
24093 : : }
24094 : 41 : else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
24095 : 1 : c_parser_error (parser, "expected %<(%> or end of line");
24096 : 61 : c_parser_skip_to_pragma_eol (parser);
24097 : :
24098 : 61 : c_finish_omp_flush (loc, mo);
24099 : 61 : }
24100 : :
24101 : : /* Return true if next tokens contain a standard attribute that contains
24102 : : omp::directive (DIRECTIVE). */
24103 : :
24104 : : static bool
24105 : 363 : c_parser_omp_section_scan (c_parser *parser, const char *directive,
24106 : : bool tentative)
24107 : : {
24108 : 363 : if (!c_parser_nth_token_starts_std_attributes (parser, 1))
24109 : : return false;
24110 : 36 : unsigned int n = 3;
24111 : 36 : if (!c_parser_check_balanced_raw_token_sequence (parser, &n))
24112 : : return false;
24113 : 36 : c_token *token = c_parser_peek_nth_token_raw (parser, n);
24114 : 36 : if (token->type != CPP_CLOSE_SQUARE)
24115 : : return false;
24116 : 36 : token = c_parser_peek_nth_token_raw (parser, n + 1);
24117 : 36 : if (token->type != CPP_CLOSE_SQUARE)
24118 : : return false;
24119 : 36 : if (n < 9)
24120 : : return false;
24121 : 35 : if (c_parser_peek_nth_token_raw (parser, 3)->type == CPP_NAME
24122 : 35 : && c_parser_peek_nth_token_raw (parser, 4)->type == CPP_OPEN_PAREN
24123 : 35 : && c_parser_peek_nth_token_raw (parser, 5)->type == CPP_NAME)
24124 : : {
24125 : 0 : tree first = c_parser_peek_nth_token_raw (parser, 3)->value;
24126 : 0 : tree second = c_parser_peek_nth_token_raw (parser, 5)->value;
24127 : 0 : if (strcmp (IDENTIFIER_POINTER (first), "directive")
24128 : 0 : && strcmp (IDENTIFIER_POINTER (first), "__directive__"))
24129 : : return false;
24130 : 0 : if (strcmp (IDENTIFIER_POINTER (second), directive))
24131 : : return false;
24132 : : }
24133 : 35 : if (tentative)
24134 : : return true;
24135 : 32 : location_t first_loc = c_parser_peek_token (parser)->location;
24136 : 32 : location_t last_loc = c_parser_peek_nth_token_raw (parser, n + 1)->location;
24137 : 32 : location_t middle_loc = UNKNOWN_LOCATION;
24138 : 32 : tree std_attrs = c_parser_std_attribute_specifier_sequence (parser);
24139 : 32 : bool seen = false;
24140 : 32 : int cnt = 0;
24141 : 67 : for (tree attr = std_attrs; attr; attr = TREE_CHAIN (attr))
24142 : 35 : if (is_attribute_namespace_p ("omp", attr)
24143 : 35 : && is_attribute_p ("directive", get_attribute_name (attr)))
24144 : : {
24145 : 68 : for (tree a = TREE_VALUE (attr); a; a = TREE_CHAIN (a))
24146 : : {
24147 : 36 : tree d = TREE_VALUE (a);
24148 : 36 : gcc_assert (TREE_CODE (d) == C_TOKEN_VEC);
24149 : 36 : c_token *first = C_TOKEN_VEC_TOKENS (d)->address ();
24150 : 36 : cnt++;
24151 : 36 : if (first->type == CPP_NAME
24152 : 36 : && strcmp (IDENTIFIER_POINTER (first->value),
24153 : : directive) == 0)
24154 : : {
24155 : 31 : seen = true;
24156 : 31 : if (middle_loc == UNKNOWN_LOCATION)
24157 : 31 : middle_loc = first->location;
24158 : : }
24159 : : }
24160 : : }
24161 : 32 : if (!seen)
24162 : : return false;
24163 : 31 : if (cnt != 1 || TREE_CHAIN (std_attrs))
24164 : : {
24165 : 7 : error_at (make_location (first_loc, last_loc, middle_loc),
24166 : : "%<[[omp::directive(%s)]]%> must be the only specified "
24167 : : "attribute on a statement", directive);
24168 : 7 : return false;
24169 : : }
24170 : 24 : c_parser_handle_statement_omp_attributes (parser, std_attrs, NULL);
24171 : 24 : return true;
24172 : : }
24173 : :
24174 : : /* Parse an OpenMP structured block sequence. KIND is the corresponding
24175 : : separating directive. */
24176 : :
24177 : : static tree
24178 : 815 : c_parser_omp_structured_block_sequence (c_parser *parser,
24179 : : enum pragma_kind kind)
24180 : : {
24181 : 815 : tree stmt = push_stmt_list ();
24182 : 815 : c_parser_statement (parser, NULL);
24183 : 909 : do
24184 : : {
24185 : 862 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
24186 : : break;
24187 : 461 : if (c_parser_next_token_is (parser, CPP_EOF))
24188 : : break;
24189 : :
24190 : 461 : if (kind != PRAGMA_NONE
24191 : 461 : && c_parser_peek_token (parser)->pragma_kind == kind)
24192 : : break;
24193 : :
24194 : 69 : if (kind != PRAGMA_NONE
24195 : 104 : && c_parser_omp_section_scan (parser,
24196 : : kind == PRAGMA_OMP_SCAN
24197 : : ? "scan" : "section", false))
24198 : : break;
24199 : :
24200 : 47 : c_parser_statement (parser, NULL);
24201 : : }
24202 : : while (1);
24203 : 815 : return pop_stmt_list (stmt);
24204 : : }
24205 : :
24206 : : /* OpenMP 5.0:
24207 : :
24208 : : scan-loop-body:
24209 : : { structured-block scan-directive structured-block } */
24210 : :
24211 : : static void
24212 : 264 : c_parser_omp_scan_loop_body (c_parser *parser, bool open_brace_parsed)
24213 : : {
24214 : 264 : tree substmt;
24215 : 264 : location_t loc;
24216 : 264 : tree clauses = NULL_TREE;
24217 : 264 : bool found_scan = false;
24218 : :
24219 : 264 : loc = c_parser_peek_token (parser)->location;
24220 : 264 : if (!open_brace_parsed
24221 : 264 : && !c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
24222 : : {
24223 : : /* Avoid skipping until the end of the block. */
24224 : 1 : parser->error = false;
24225 : 1 : return;
24226 : : }
24227 : :
24228 : 263 : if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_SCAN)
24229 : 261 : substmt = c_parser_omp_structured_block_sequence (parser, PRAGMA_OMP_SCAN);
24230 : : else
24231 : : {
24232 : 2 : warning_at (c_parser_peek_token (parser)->location, OPT_Wopenmp,
24233 : : "%<#pragma omp scan%> with zero preceding executable "
24234 : : "statements");
24235 : 2 : substmt = build_empty_stmt (loc);
24236 : : }
24237 : 263 : substmt = build2 (OMP_SCAN, void_type_node, substmt, NULL_TREE);
24238 : 263 : SET_EXPR_LOCATION (substmt, loc);
24239 : 263 : add_stmt (substmt);
24240 : :
24241 : 263 : loc = c_parser_peek_token (parser)->location;
24242 : 263 : if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SCAN)
24243 : : {
24244 : 256 : enum omp_clause_code clause = OMP_CLAUSE_ERROR;
24245 : 256 : found_scan = true;
24246 : :
24247 : 256 : c_parser_consume_pragma (parser);
24248 : :
24249 : 256 : if (c_parser_next_token_is (parser, CPP_COMMA))
24250 : 4 : c_parser_consume_token (parser);
24251 : :
24252 : 256 : if (c_parser_next_token_is (parser, CPP_NAME))
24253 : : {
24254 : 254 : const char *p
24255 : 254 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
24256 : 254 : if (strcmp (p, "inclusive") == 0)
24257 : : clause = OMP_CLAUSE_INCLUSIVE;
24258 : 126 : else if (strcmp (p, "exclusive") == 0)
24259 : : clause = OMP_CLAUSE_EXCLUSIVE;
24260 : : }
24261 : : if (clause != OMP_CLAUSE_ERROR)
24262 : : {
24263 : 254 : c_parser_consume_token (parser);
24264 : 254 : clauses = c_parser_omp_var_list_parens (parser, clause, NULL_TREE);
24265 : : }
24266 : : else
24267 : 2 : c_parser_error (parser, "expected %<inclusive%> or "
24268 : : "%<exclusive%> clause");
24269 : 256 : c_parser_skip_to_pragma_eol (parser);
24270 : : }
24271 : : else
24272 : 7 : error ("expected %<#pragma omp scan%>");
24273 : :
24274 : 263 : clauses = c_finish_omp_clauses (clauses, C_ORT_OMP);
24275 : 263 : if (!c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
24276 : 254 : substmt = c_parser_omp_structured_block_sequence (parser, PRAGMA_NONE);
24277 : : else
24278 : : {
24279 : 9 : if (found_scan)
24280 : 2 : warning_at (loc, OPT_Wopenmp,
24281 : : "%<#pragma omp scan%> with zero succeeding executable "
24282 : : "statements");
24283 : 9 : substmt = build_empty_stmt (loc);
24284 : : }
24285 : 263 : substmt = build2 (OMP_SCAN, void_type_node, substmt, clauses);
24286 : 263 : SET_EXPR_LOCATION (substmt, loc);
24287 : 263 : add_stmt (substmt);
24288 : :
24289 : 263 : c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
24290 : : "expected %<}%>");
24291 : : }
24292 : :
24293 : :
24294 : : /* Check if the next tokens can start a canonical loop. Return true if yes,
24295 : : otherwise diagnose an error if ERROR_P is true, and return false. */
24296 : : static bool
24297 : 17287 : c_parser_omp_next_tokens_can_be_canon_loop (c_parser *parser,
24298 : : enum tree_code code,
24299 : : bool error_p)
24300 : : {
24301 : 17287 : if (code == OACC_LOOP)
24302 : : {
24303 : 2581 : if (c_parser_next_token_is_keyword (parser, RID_FOR))
24304 : : return true;
24305 : 27 : if (error_p)
24306 : 4 : c_parser_error (parser, "for statement expected");
24307 : : }
24308 : : else
24309 : : {
24310 : 14706 : if (c_parser_next_token_is_keyword (parser, RID_FOR))
24311 : : return true;
24312 : :
24313 : 887 : if (c_parser_next_token_is (parser, CPP_PRAGMA))
24314 : 578 : switch (c_parser_peek_token (parser)->pragma_kind)
24315 : : {
24316 : : case PRAGMA_OMP_UNROLL:
24317 : : case PRAGMA_OMP_TILE:
24318 : : return true;
24319 : : default:
24320 : : break;
24321 : : }
24322 : :
24323 : : /* Skip standard attributes on next for in case they are
24324 : : [[omp::directive (unroll partial (4))]] or
24325 : : [[omp::directive (tile sizes (1, 2, 3))]] etc. */
24326 : 319 : size_t n = c_parser_skip_std_attribute_spec_seq (parser, 1);
24327 : 319 : c_token *token = c_parser_peek_nth_token_raw (parser, n);
24328 : : /* TOKEN is a raw token that hasn't been converted to a keyword yet,
24329 : : we have to do the lookup explicitly. */
24330 : 319 : if (token->type == CPP_NAME
24331 : 108 : && C_IS_RESERVED_WORD (token->value)
24332 : 331 : && C_RID_CODE (token->value) == RID_FOR)
24333 : : return true;
24334 : 307 : if (error_p)
24335 : 7 : c_parser_error (parser, "loop nest expected");
24336 : : }
24337 : :
24338 : : return false;
24339 : : }
24340 : :
24341 : : static tree c_parser_omp_tile (location_t, c_parser *, bool *);
24342 : : static tree c_parser_omp_unroll (location_t, c_parser *, bool *);
24343 : :
24344 : : /* This function parses a single level of a loop nest, invoking itself
24345 : : recursively if necessary.
24346 : :
24347 : : loop-nest :: for (...) loop-body
24348 : : loop-body :: loop-nest
24349 : : | { [intervening-code] loop-body [intervening-code] }
24350 : : | final-loop-body
24351 : : intervening-code :: structured-block-sequence
24352 : : final-loop-body :: structured-block
24353 : :
24354 : : For a collapsed loop nest, only a single OMP_FOR is built, pulling out
24355 : : all the iterator information from the inner loops into the
24356 : : parser->omp_for_parse_state structure.
24357 : :
24358 : : The iterator decl, init, cond, and incr are stored in vectors.
24359 : :
24360 : : Initialization code for iterator variables is collected into
24361 : : parser->omp_for_parse_state->pre_body and ends up inserted directly
24362 : : into the OMP_FOR structure. */
24363 : :
24364 : : static tree
24365 : 16953 : c_parser_omp_loop_nest (c_parser *parser, bool *if_p)
24366 : : {
24367 : 16953 : tree decl = NULL_TREE, cond = NULL_TREE, incr = NULL_TREE, init = NULL_TREE;
24368 : 16953 : tree body = NULL_TREE;
24369 : 16953 : matching_parens parens;
24370 : 16953 : bool moreloops;
24371 : 16953 : unsigned char save_in_statement;
24372 : 16953 : tree loop_scope;
24373 : 16953 : location_t loc;
24374 : 16953 : struct omp_for_parse_data *omp_for_parse_state
24375 : : = parser->omp_for_parse_state;
24376 : 16953 : gcc_assert (omp_for_parse_state);
24377 : 16953 : int depth = omp_for_parse_state->depth;
24378 : :
24379 : : /* Arrange for C23 standard attribute syntax to be parsed as regular
24380 : : pragmas. */
24381 : 16953 : if (c_parser_nth_token_starts_std_attributes (parser, 1))
24382 : : {
24383 : 12 : tree std_attrs = c_parser_std_attribute_specifier_sequence (parser);
24384 : 12 : c_parser_handle_statement_omp_attributes (parser, std_attrs, NULL);
24385 : 12 : if (std_attrs)
24386 : 0 : error_at (c_parser_peek_token (parser)->location,
24387 : : "attributes other than OpenMP directives "
24388 : : "are not allowed on %<for%> in loop nest");
24389 : : }
24390 : :
24391 : 16953 : loc = c_parser_peek_token (parser)->location;
24392 : :
24393 : : /* Handle loop transformations first. */
24394 : 16953 : if (c_parser_next_token_is (parser, CPP_PRAGMA))
24395 : : {
24396 : 576 : tree transform = NULL_TREE, sizes, body = NULL_TREE;
24397 : 576 : int count = 0;
24398 : 576 : switch (c_parser_peek_token (parser)->pragma_kind)
24399 : : {
24400 : 208 : case PRAGMA_OMP_UNROLL:
24401 : 208 : c_parser_consume_pragma (parser);
24402 : 208 : body = push_stmt_list ();
24403 : 208 : transform = c_parser_omp_unroll (loc, parser, if_p);
24404 : 208 : body = pop_stmt_list (body);
24405 : 208 : if (transform == NULL_TREE || transform == error_mark_node)
24406 : : {
24407 : 7 : transform = error_mark_node;
24408 : 7 : break;
24409 : : }
24410 : 201 : gcc_assert (TREE_CODE (transform) == OMP_UNROLL);
24411 : 201 : if (omp_find_clause (OMP_FOR_CLAUSES (transform),
24412 : : OMP_CLAUSE_PARTIAL))
24413 : : {
24414 : 172 : if (omp_for_parse_state->count - depth > 1)
24415 : : {
24416 : 10 : error_at (loc, "%<unroll%> construct with %<partial%> "
24417 : : "clause generates just one loop with "
24418 : : "canonical form but %d loops are needed",
24419 : : omp_for_parse_state->count - depth);
24420 : 10 : transform = error_mark_node;
24421 : : }
24422 : : else
24423 : 576 : count = 1;
24424 : : }
24425 : : else
24426 : : {
24427 : 29 : error_at (loc, "generated loop of %<unroll%> construct "
24428 : : "without %<partial%> clause does not have "
24429 : : "canonical form");
24430 : 29 : transform = error_mark_node;
24431 : : }
24432 : : break;
24433 : 366 : case PRAGMA_OMP_TILE:
24434 : 366 : c_parser_consume_pragma (parser);
24435 : 366 : body = push_stmt_list ();
24436 : 366 : transform = c_parser_omp_tile (loc, parser, if_p);
24437 : 366 : body = pop_stmt_list (body);
24438 : 366 : if (transform == NULL_TREE || transform == error_mark_node)
24439 : : {
24440 : 40 : transform = error_mark_node;
24441 : 40 : break;
24442 : : }
24443 : 326 : gcc_assert (TREE_CODE (transform) == OMP_TILE);
24444 : 326 : sizes = omp_find_clause (OMP_FOR_CLAUSES (transform),
24445 : : OMP_CLAUSE_SIZES);
24446 : 326 : gcc_assert (sizes);
24447 : 326 : count = list_length (OMP_CLAUSE_SIZES_LIST (sizes));
24448 : 326 : if (depth + count < omp_for_parse_state->count)
24449 : : {
24450 : 16 : error_at (loc, "%<tile%> construct generates %d loops "
24451 : : "with canonical form but %d loops are needed",
24452 : : count, omp_for_parse_state->count - depth);
24453 : 16 : transform = error_mark_node;
24454 : : }
24455 : : break;
24456 : 2 : default:
24457 : 2 : c_parser_pragma (parser, pragma_stmt, NULL, void_list_node);
24458 : 2 : break;
24459 : : }
24460 : 576 : if (transform == NULL_TREE)
24461 : 2 : error_at (loc, "expected %<for%> loop or OpenMP loop "
24462 : : "transformation construct");
24463 : 576 : if (transform == NULL_TREE || transform == error_mark_node)
24464 : : {
24465 : 104 : omp_for_parse_state->fail = true;
24466 : 104 : return NULL_TREE;
24467 : : }
24468 : 1030 : for (count = omp_for_parse_state->count; depth < count; ++depth)
24469 : : {
24470 : 558 : TREE_VEC_ELT (omp_for_parse_state->declv, depth) = NULL_TREE;
24471 : 558 : TREE_VEC_ELT (omp_for_parse_state->initv, depth) = NULL_TREE;
24472 : 558 : TREE_VEC_ELT (omp_for_parse_state->condv, depth) = NULL_TREE;
24473 : 558 : TREE_VEC_ELT (omp_for_parse_state->incrv, depth) = NULL_TREE;
24474 : : }
24475 : 472 : omp_for_parse_state->want_nested_loop = false;
24476 : 472 : return body;
24477 : : }
24478 : :
24479 : : /* We have already matched the FOR token but not consumed it yet. */
24480 : 16377 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR));
24481 : 16377 : c_parser_consume_token (parser);
24482 : :
24483 : : /* Forbid break/continue in the loop initializer, condition, and
24484 : : increment expressions. */
24485 : 16377 : save_in_statement = in_statement;
24486 : 16377 : in_statement = IN_OMP_BLOCK;
24487 : :
24488 : : /* We are not in intervening code now. */
24489 : 16377 : omp_for_parse_state->in_intervening_code = false;
24490 : :
24491 : 16377 : if (!parens.require_open (parser))
24492 : : {
24493 : 0 : omp_for_parse_state->fail = true;
24494 : 0 : return NULL_TREE;
24495 : : }
24496 : :
24497 : : /* An implicit scope block surrounds each level of FOR loop, for
24498 : : declarations of iteration variables at this loop depth. */
24499 : 16377 : loop_scope = c_begin_compound_stmt (true);
24500 : :
24501 : : /* Parse the initialization declaration or expression. */
24502 : 16377 : if (c_parser_next_tokens_start_declaration (parser))
24503 : : {
24504 : : /* This is a declaration, which must be added to the pre_body code. */
24505 : 4737 : tree this_pre_body = push_stmt_list ();
24506 : 4737 : c_in_omp_for = true;
24507 : 4737 : c_parser_declaration_or_fndef (parser, true, true, true, true, true,
24508 : : false);
24509 : 4737 : c_in_omp_for = false;
24510 : 4737 : this_pre_body = pop_stmt_list (this_pre_body);
24511 : 4737 : append_to_statement_list_force (this_pre_body,
24512 : : &(omp_for_parse_state->pre_body));
24513 : 4737 : decl = check_for_loop_decls (omp_for_parse_state->for_loc, flag_isoc99);
24514 : 4737 : if (decl == NULL)
24515 : 0 : goto error_init;
24516 : 4737 : if (DECL_INITIAL (decl) == error_mark_node)
24517 : 1 : decl = error_mark_node;
24518 : : init = decl;
24519 : : }
24520 : 11640 : else if (c_parser_next_token_is (parser, CPP_NAME)
24521 : 11640 : && c_parser_peek_2nd_token (parser)->type == CPP_EQ)
24522 : : {
24523 : 11638 : struct c_expr decl_exp;
24524 : 11638 : struct c_expr init_exp;
24525 : 11638 : location_t init_loc;
24526 : :
24527 : 11638 : decl_exp = c_parser_postfix_expression (parser);
24528 : 11638 : decl = decl_exp.value;
24529 : :
24530 : 11638 : c_parser_require (parser, CPP_EQ, "expected %<=%>");
24531 : :
24532 : 11638 : init_loc = c_parser_peek_token (parser)->location;
24533 : 11638 : init_exp = c_parser_expr_no_commas (parser, NULL);
24534 : 11638 : init_exp = default_function_array_read_conversion (init_loc,
24535 : : init_exp);
24536 : 11638 : c_in_omp_for = true;
24537 : 11638 : init = build_modify_expr (init_loc, decl, decl_exp.original_type,
24538 : : NOP_EXPR, init_loc, init_exp.value,
24539 : : init_exp.original_type);
24540 : 11638 : c_in_omp_for = false;
24541 : 11638 : init = c_process_expr_stmt (init_loc, init);
24542 : :
24543 : 11638 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
24544 : : }
24545 : : else
24546 : : {
24547 : 2 : error_init:
24548 : 2 : c_parser_error (parser,
24549 : : "expected iteration declaration or initialization");
24550 : 2 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
24551 : : "expected %<)%>");
24552 : 2 : omp_for_parse_state->fail = true;
24553 : 2 : goto parse_next;
24554 : : }
24555 : :
24556 : : /* Parse the loop condition. */
24557 : 16375 : if (c_parser_next_token_is_not (parser, CPP_SEMICOLON))
24558 : : {
24559 : 16373 : location_t cond_loc = c_parser_peek_token (parser)->location;
24560 : 16373 : c_in_omp_for = true;
24561 : 16373 : struct c_expr cond_expr
24562 : 16373 : = c_parser_binary_expression (parser, NULL, NULL_TREE);
24563 : 16373 : c_in_omp_for = false;
24564 : :
24565 : 16373 : cond = cond_expr.value;
24566 : 16373 : cond = c_objc_common_truthvalue_conversion (cond_loc, cond);
24567 : 16373 : switch (cond_expr.original_code)
24568 : : {
24569 : : case GT_EXPR:
24570 : : case GE_EXPR:
24571 : : case LT_EXPR:
24572 : : case LE_EXPR:
24573 : : break;
24574 : 2425 : case NE_EXPR:
24575 : 2425 : if (omp_for_parse_state->code != OACC_LOOP)
24576 : : break;
24577 : : /* FALLTHRU. */
24578 : 7 : default:
24579 : : /* Can't be cond = error_mark_node, because we want to preserve
24580 : : the location until c_finish_omp_for. */
24581 : 7 : cond = build1 (NOP_EXPR, boolean_type_node, error_mark_node);
24582 : 7 : break;
24583 : : }
24584 : 16373 : protected_set_expr_location (cond, cond_loc);
24585 : : }
24586 : 16375 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
24587 : :
24588 : : /* Parse the increment expression. */
24589 : 16375 : if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
24590 : : {
24591 : 16375 : location_t incr_loc = c_parser_peek_token (parser)->location;
24592 : :
24593 : 16375 : incr = c_process_expr_stmt (incr_loc,
24594 : 32750 : c_parser_expression (parser).value);
24595 : : }
24596 : 16375 : parens.skip_until_found_close (parser);
24597 : :
24598 : 16375 : if (decl == NULL || decl == error_mark_node || init == error_mark_node)
24599 : 3 : omp_for_parse_state->fail = true;
24600 : : else
24601 : : {
24602 : 16372 : TREE_VEC_ELT (omp_for_parse_state->declv, depth) = decl;
24603 : 16372 : TREE_VEC_ELT (omp_for_parse_state->initv, depth) = init;
24604 : 16372 : TREE_VEC_ELT (omp_for_parse_state->condv, depth) = cond;
24605 : 16372 : TREE_VEC_ELT (omp_for_parse_state->incrv, depth) = incr;
24606 : : }
24607 : :
24608 : 16377 : parse_next:
24609 : 16377 : moreloops = depth < omp_for_parse_state->count - 1;
24610 : 16377 : omp_for_parse_state->want_nested_loop = moreloops;
24611 : 16377 : if (moreloops
24612 : 16377 : && c_parser_omp_next_tokens_can_be_canon_loop (parser,
24613 : : omp_for_parse_state->code,
24614 : : false))
24615 : : {
24616 : 5325 : omp_for_parse_state->depth++;
24617 : 5325 : body = c_parser_omp_loop_nest (parser, if_p);
24618 : 5325 : omp_for_parse_state->depth--;
24619 : : }
24620 : 11192 : else if (moreloops && c_parser_next_token_is (parser, CPP_OPEN_BRACE))
24621 : : {
24622 : : /* This is the open brace in the loop-body grammar production. Rather
24623 : : than trying to special-case braces, just parse it as a compound
24624 : : statement and handle the nested loop-body case there. Note that
24625 : : when we see a further open brace inside the compound statement
24626 : : loop-body, we don't know whether it is the start of intervening
24627 : : code that is a compound statement, or a level of braces
24628 : : surrounding a nested loop-body. Use the WANT_NESTED_LOOP state
24629 : : bit to ensure we have only one nested loop at each level. */
24630 : 121 : omp_for_parse_state->in_intervening_code = true;
24631 : 121 : body = c_parser_compound_statement (parser, NULL);
24632 : 121 : omp_for_parse_state->in_intervening_code = false;
24633 : 121 : if (omp_for_parse_state->want_nested_loop)
24634 : : {
24635 : : /* We have already parsed the whole loop body and not found a
24636 : : nested loop. */
24637 : 11 : error_at (omp_for_parse_state->for_loc,
24638 : : "not enough nested loops");
24639 : 11 : omp_for_parse_state->fail = true;
24640 : : }
24641 : 16377 : if_p = NULL;
24642 : : }
24643 : : else
24644 : : {
24645 : : /* This is the final-loop-body case in the grammar: we have
24646 : : something that is not a FOR and not an open brace. */
24647 : 10931 : if (moreloops)
24648 : : {
24649 : : /* If we were expecting a nested loop, give an error and mark
24650 : : that parsing has failed, and try to recover by parsing the
24651 : : body as regular code without further collapsing. */
24652 : 19 : error_at (omp_for_parse_state->for_loc,
24653 : : "not enough nested loops");
24654 : 19 : omp_for_parse_state->fail = true;
24655 : : }
24656 : 10931 : in_statement = IN_OMP_FOR;
24657 : 10931 : parser->omp_for_parse_state = NULL;
24658 : 10931 : body = push_stmt_list ();
24659 : 10931 : if (omp_for_parse_state->inscan)
24660 : 264 : c_parser_omp_scan_loop_body (parser, false);
24661 : : else
24662 : 10667 : add_stmt (c_parser_c99_block_statement (parser, if_p));
24663 : 10931 : body = pop_stmt_list (body);
24664 : 10931 : parser->omp_for_parse_state = omp_for_parse_state;
24665 : : }
24666 : 16377 : in_statement = save_in_statement;
24667 : 16377 : omp_for_parse_state->want_nested_loop = false;
24668 : 16377 : omp_for_parse_state->in_intervening_code = true;
24669 : :
24670 : : /* Pop and return the implicit scope surrounding this level of loop.
24671 : : If the iteration variable at this depth was bound in the for loop,
24672 : : pull out and save the binding. Later in c_parser_omp_for_loop,
24673 : : these bindings will be moved to the scope surrounding the entire
24674 : : OMP_FOR. That keeps the gimplifier happy later on, and meanwhile
24675 : : we have already resolved all references to the iteration variable
24676 : : in its true scope. */
24677 : 16377 : if (body)
24678 : 16371 : add_stmt (body);
24679 : 16377 : body = c_end_compound_stmt (loc, loop_scope, true);
24680 : 16377 : if (decl && TREE_CODE (body) == BIND_EXPR)
24681 : : {
24682 : 5123 : tree t = BIND_EXPR_VARS (body);
24683 : 5123 : tree prev = NULL_TREE, next = NULL_TREE;
24684 : 5559 : while (t)
24685 : : {
24686 : 5172 : next = DECL_CHAIN (t);
24687 : 5172 : if (t == decl)
24688 : : {
24689 : 4736 : if (prev)
24690 : 0 : DECL_CHAIN (prev) = next;
24691 : : else
24692 : : {
24693 : 4736 : BIND_EXPR_VARS (body) = next;
24694 : 4736 : BLOCK_VARS (BIND_EXPR_BLOCK (body)) = next;
24695 : : }
24696 : 4736 : DECL_CHAIN (t) = omp_for_parse_state->bindings;
24697 : 4736 : omp_for_parse_state->bindings = t;
24698 : 4736 : break;
24699 : : }
24700 : : else
24701 : : {
24702 : : prev = t;
24703 : : t = next;
24704 : : }
24705 : : }
24706 : 5123 : if (BIND_EXPR_VARS (body) == NULL_TREE)
24707 : 4736 : body = BIND_EXPR_BODY (body);
24708 : : }
24709 : :
24710 : : return body;
24711 : : }
24712 : :
24713 : : /* Parse the restricted form of loop statements allowed by OpenACC and OpenMP.
24714 : : The real trick here is to determine the loop control variable early
24715 : : so that we can push a new decl if necessary to make it private.
24716 : : LOC is the location of the "acc" or "omp" in "#pragma acc" or "#pragma omp",
24717 : : respectively. */
24718 : :
24719 : : static tree
24720 : 11529 : c_parser_omp_for_loop (location_t loc, c_parser *parser, enum tree_code code,
24721 : : tree clauses, tree *cclauses, bool *if_p)
24722 : : {
24723 : 11529 : tree body, stmt, cl;
24724 : 11529 : tree ret = NULL_TREE;
24725 : 11529 : tree ordered_cl = NULL_TREE;
24726 : 11529 : int i, collapse = 1, ordered = 0, count;
24727 : 11529 : bool oacc_tiling = false;
24728 : 11529 : bool inscan = false;
24729 : 11529 : struct omp_for_parse_data data;
24730 : 11529 : struct omp_for_parse_data *save_data = parser->omp_for_parse_state;
24731 : :
24732 : 27444 : for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
24733 : 15915 : if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
24734 : 2946 : collapse = tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (cl));
24735 : 12969 : else if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_TILE)
24736 : : {
24737 : 111 : oacc_tiling = true;
24738 : 111 : collapse = list_length (OMP_CLAUSE_TILE_LIST (cl));
24739 : : }
24740 : 12858 : else if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_SIZES)
24741 : 464 : collapse = list_length (OMP_CLAUSE_SIZES_LIST (cl));
24742 : 12394 : else if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_ORDERED
24743 : 12394 : && OMP_CLAUSE_ORDERED_EXPR (cl))
24744 : : {
24745 : 160 : ordered_cl = cl;
24746 : 160 : ordered = tree_to_shwi (OMP_CLAUSE_ORDERED_EXPR (cl));
24747 : : }
24748 : 12234 : else if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_REDUCTION
24749 : 2106 : && OMP_CLAUSE_REDUCTION_INSCAN (cl)
24750 : 12619 : && (code == OMP_SIMD || code == OMP_FOR))
24751 : : inscan = true;
24752 : :
24753 : 11529 : if (ordered && ordered < collapse)
24754 : : {
24755 : 2 : error_at (OMP_CLAUSE_LOCATION (ordered_cl),
24756 : : "%<ordered%> clause parameter is less than %<collapse%>");
24757 : 2 : OMP_CLAUSE_ORDERED_EXPR (ordered_cl)
24758 : 2 : = build_int_cst (NULL_TREE, collapse);
24759 : 2 : ordered = collapse;
24760 : : }
24761 : :
24762 : 11529 : gcc_assert (oacc_tiling || (collapse >= 1 && ordered >= 0));
24763 : 11529 : count = ordered ? ordered : collapse;
24764 : :
24765 : 11529 : if (!c_parser_omp_next_tokens_can_be_canon_loop (parser, code, true))
24766 : : return NULL;
24767 : :
24768 : : /* Initialize parse state for recursive descent. */
24769 : 11518 : data.declv = make_tree_vec (count);
24770 : 11518 : data.initv = make_tree_vec (count);
24771 : 11518 : data.condv = make_tree_vec (count);
24772 : 11518 : data.incrv = make_tree_vec (count);
24773 : 11518 : data.pre_body = NULL_TREE;
24774 : 11518 : data.bindings = NULL_TREE;
24775 : 11518 : data.for_loc = c_parser_peek_token (parser)->location;
24776 : 11518 : data.count = count;
24777 : 11518 : data.depth = 0;
24778 : 11518 : data.want_nested_loop = true;
24779 : 11518 : data.ordered = ordered > 0;
24780 : 11518 : data.in_intervening_code = false;
24781 : 11518 : data.perfect_nesting_fail = false;
24782 : 11518 : data.fail = false;
24783 : 11518 : data.inscan = inscan;
24784 : 11518 : data.saw_intervening_code = false;
24785 : 11518 : data.code = code;
24786 : 11518 : parser->omp_for_parse_state = &data;
24787 : :
24788 : 11518 : body = c_parser_omp_loop_nest (parser, if_p);
24789 : :
24790 : : /* Add saved bindings for iteration variables that were declared in
24791 : : the nested for loop to the scope surrounding the entire loop. */
24792 : 16254 : for (tree t = data.bindings; t; )
24793 : : {
24794 : 4736 : tree n = TREE_CHAIN (t);
24795 : 4736 : TREE_CHAIN (t) = NULL_TREE;
24796 : 4736 : pushdecl (t);
24797 : 4736 : t = n;
24798 : : }
24799 : :
24800 : : /* Only bother calling c_finish_omp_for if we haven't already generated
24801 : : an error from the initialization parsing. */
24802 : 11518 : if (!data.fail)
24803 : : {
24804 : 11355 : c_in_omp_for = true;
24805 : 11355 : stmt = c_finish_omp_for (loc, code, data.declv, NULL, data.initv,
24806 : : data.condv, data.incrv,
24807 : : body, data.pre_body, true);
24808 : 11355 : c_in_omp_for = false;
24809 : :
24810 : : /* Check for iterators appearing in lb, b or incr expressions. */
24811 : 11355 : if (stmt && !c_omp_check_loop_iv (stmt, data.declv, NULL))
24812 : : stmt = NULL_TREE;
24813 : :
24814 : : /* Check for errors involving lb/ub/incr expressions referencing
24815 : : variables declared in intervening code. */
24816 : 11355 : if (data.saw_intervening_code
24817 : 38 : && stmt
24818 : 11393 : && !c_omp_check_loop_binding_exprs (stmt, NULL))
24819 : : stmt = NULL_TREE;
24820 : :
24821 : 11345 : if (stmt)
24822 : : {
24823 : 11200 : add_stmt (stmt);
24824 : :
24825 : 27275 : for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (stmt)); i++)
24826 : : {
24827 : 16533 : tree init = TREE_VEC_ELT (OMP_FOR_INIT (stmt), i);
24828 : 16533 : if (init == NULL_TREE)
24829 : : break;
24830 : 16075 : gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
24831 : 16075 : tree decl = TREE_OPERAND (init, 0);
24832 : 16075 : tree cond = TREE_VEC_ELT (OMP_FOR_COND (stmt), i);
24833 : 16075 : gcc_assert (COMPARISON_CLASS_P (cond));
24834 : 16075 : gcc_assert (TREE_OPERAND (cond, 0) == decl);
24835 : :
24836 : 16075 : tree op0 = TREE_OPERAND (init, 1);
24837 : 16075 : if (!OMP_FOR_NON_RECTANGULAR (stmt)
24838 : 16075 : || TREE_CODE (op0) != TREE_VEC)
24839 : 15888 : TREE_OPERAND (init, 1) = c_fully_fold (op0, false, NULL);
24840 : : else
24841 : : {
24842 : 187 : TREE_VEC_ELT (op0, 1)
24843 : 187 : = c_fully_fold (TREE_VEC_ELT (op0, 1), false, NULL);
24844 : 187 : TREE_VEC_ELT (op0, 2)
24845 : 374 : = c_fully_fold (TREE_VEC_ELT (op0, 2), false, NULL);
24846 : : }
24847 : :
24848 : 16075 : tree op1 = TREE_OPERAND (cond, 1);
24849 : 16075 : if (!OMP_FOR_NON_RECTANGULAR (stmt)
24850 : 16075 : || TREE_CODE (op1) != TREE_VEC)
24851 : 15869 : TREE_OPERAND (cond, 1) = c_fully_fold (op1, false, NULL);
24852 : : else
24853 : : {
24854 : 206 : TREE_VEC_ELT (op1, 1)
24855 : 206 : = c_fully_fold (TREE_VEC_ELT (op1, 1), false, NULL);
24856 : 206 : TREE_VEC_ELT (op1, 2)
24857 : 412 : = c_fully_fold (TREE_VEC_ELT (op1, 2), false, NULL);
24858 : : }
24859 : : }
24860 : :
24861 : 11200 : if (cclauses != NULL
24862 : 5258 : && cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL] != NULL)
24863 : : {
24864 : 755 : tree *c;
24865 : 3313 : for (c = &cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL]; *c ; )
24866 : 2558 : if (OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_FIRSTPRIVATE
24867 : 2558 : && OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_LASTPRIVATE)
24868 : 1858 : c = &OMP_CLAUSE_CHAIN (*c);
24869 : : else
24870 : : {
24871 : 1441 : for (i = 0; i < count; i++)
24872 : 923 : if (TREE_VEC_ELT (data.declv, i) == OMP_CLAUSE_DECL (*c))
24873 : : break;
24874 : 700 : if (i == count)
24875 : 518 : c = &OMP_CLAUSE_CHAIN (*c);
24876 : 182 : else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE)
24877 : : {
24878 : 1 : error_at (loc,
24879 : : "iteration variable %qD should not be firstprivate",
24880 : 1 : OMP_CLAUSE_DECL (*c));
24881 : 1 : *c = OMP_CLAUSE_CHAIN (*c);
24882 : : }
24883 : : else
24884 : : {
24885 : : /* Move lastprivate (decl) clause to
24886 : : OMP_FOR_CLAUSES. */
24887 : 181 : tree l = *c;
24888 : 181 : *c = OMP_CLAUSE_CHAIN (*c);
24889 : 181 : if (code == OMP_SIMD)
24890 : : {
24891 : 46 : OMP_CLAUSE_CHAIN (l)
24892 : 46 : = cclauses[C_OMP_CLAUSE_SPLIT_FOR];
24893 : 46 : cclauses[C_OMP_CLAUSE_SPLIT_FOR] = l;
24894 : : }
24895 : : else
24896 : : {
24897 : 135 : OMP_CLAUSE_CHAIN (l) = clauses;
24898 : 135 : clauses = l;
24899 : : }
24900 : : }
24901 : : }
24902 : : }
24903 : 11200 : OMP_FOR_CLAUSES (stmt) = clauses;
24904 : : }
24905 : : ret = stmt;
24906 : : }
24907 : :
24908 : 11518 : parser->omp_for_parse_state = save_data;
24909 : 11518 : return ret;
24910 : : }
24911 : :
24912 : : /* Helper function for OpenMP parsing, split clauses and call
24913 : : finish_omp_clauses on each of the set of clauses afterwards. */
24914 : :
24915 : : static void
24916 : 6564 : omp_split_clauses (location_t loc, enum tree_code code,
24917 : : omp_clause_mask mask, tree clauses, tree *cclauses)
24918 : : {
24919 : 6564 : int i;
24920 : 6564 : c_omp_split_clauses (loc, code, mask, clauses, cclauses);
24921 : 52512 : for (i = 0; i < C_OMP_CLAUSE_SPLIT_COUNT; i++)
24922 : 39384 : if (cclauses[i])
24923 : 20230 : cclauses[i] = c_finish_omp_clauses (cclauses[i],
24924 : : i == C_OMP_CLAUSE_SPLIT_TARGET
24925 : : ? C_ORT_OMP_TARGET : C_ORT_OMP);
24926 : 6564 : }
24927 : :
24928 : : /* OpenMP 5.0:
24929 : : #pragma omp loop loop-clause[optseq] new-line
24930 : : for-loop
24931 : :
24932 : : LOC is the location of the #pragma token.
24933 : : */
24934 : :
24935 : : #define OMP_LOOP_CLAUSE_MASK \
24936 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
24937 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
24938 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
24939 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
24940 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_BIND) \
24941 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
24942 : :
24943 : : static tree
24944 : 237 : c_parser_omp_loop (location_t loc, c_parser *parser,
24945 : : char *p_name, omp_clause_mask mask, tree *cclauses,
24946 : : bool *if_p)
24947 : : {
24948 : 237 : tree block, clauses, ret;
24949 : :
24950 : 237 : strcat (p_name, " loop");
24951 : 237 : mask |= OMP_LOOP_CLAUSE_MASK;
24952 : :
24953 : 237 : clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
24954 : 237 : if (cclauses)
24955 : : {
24956 : 80 : omp_split_clauses (loc, OMP_LOOP, mask, clauses, cclauses);
24957 : 80 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_LOOP];
24958 : : }
24959 : :
24960 : 237 : block = c_begin_compound_stmt (true);
24961 : 237 : ret = c_parser_omp_for_loop (loc, parser, OMP_LOOP, clauses, cclauses, if_p);
24962 : 237 : block = c_end_compound_stmt (loc, block, true);
24963 : 237 : add_stmt (block);
24964 : :
24965 : 237 : return ret;
24966 : : }
24967 : :
24968 : : /* OpenMP 4.0:
24969 : : #pragma omp simd simd-clause[optseq] new-line
24970 : : for-loop
24971 : :
24972 : : LOC is the location of the #pragma token.
24973 : : */
24974 : :
24975 : : #define OMP_SIMD_CLAUSE_MASK \
24976 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
24977 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
24978 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
24979 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
24980 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
24981 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
24982 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
24983 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
24984 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
24985 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NONTEMPORAL) \
24986 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
24987 : :
24988 : : static tree
24989 : 3507 : c_parser_omp_simd (location_t loc, c_parser *parser,
24990 : : char *p_name, omp_clause_mask mask, tree *cclauses,
24991 : : bool *if_p)
24992 : : {
24993 : 3507 : tree block, clauses, ret;
24994 : :
24995 : 3507 : strcat (p_name, " simd");
24996 : 3507 : mask |= OMP_SIMD_CLAUSE_MASK;
24997 : :
24998 : 3507 : clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
24999 : 3507 : if (cclauses)
25000 : : {
25001 : 2781 : omp_split_clauses (loc, OMP_SIMD, mask, clauses, cclauses);
25002 : 2781 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_SIMD];
25003 : : }
25004 : :
25005 : 3507 : block = c_begin_compound_stmt (true);
25006 : 3507 : ret = c_parser_omp_for_loop (loc, parser, OMP_SIMD, clauses, cclauses, if_p);
25007 : 3507 : block = c_end_compound_stmt (loc, block, true);
25008 : 3507 : add_stmt (block);
25009 : :
25010 : 3507 : return ret;
25011 : : }
25012 : :
25013 : : /* OpenMP 2.5:
25014 : : #pragma omp for for-clause[optseq] new-line
25015 : : for-loop
25016 : :
25017 : : OpenMP 4.0:
25018 : : #pragma omp for simd for-simd-clause[optseq] new-line
25019 : : for-loop
25020 : :
25021 : : LOC is the location of the #pragma token.
25022 : : */
25023 : :
25024 : : #define OMP_FOR_CLAUSE_MASK \
25025 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
25026 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
25027 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
25028 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
25029 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
25030 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
25031 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
25032 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
25033 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
25034 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
25035 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
25036 : :
25037 : : static tree
25038 : 6178 : c_parser_omp_for (location_t loc, c_parser *parser,
25039 : : char *p_name, omp_clause_mask mask, tree *cclauses,
25040 : : bool *if_p)
25041 : : {
25042 : 6178 : tree block, clauses, ret;
25043 : :
25044 : 6178 : strcat (p_name, " for");
25045 : 6178 : mask |= OMP_FOR_CLAUSE_MASK;
25046 : : /* parallel for{, simd} disallows nowait clause, but for
25047 : : target {teams distribute ,}parallel for{, simd} it should be accepted. */
25048 : 6178 : if (cclauses && (mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP)) == 0)
25049 : 3247 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT);
25050 : : /* Composite distribute parallel for{, simd} disallows ordered clause. */
25051 : 6178 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
25052 : 2724 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED);
25053 : :
25054 : 6178 : if (c_parser_next_token_is (parser, CPP_NAME))
25055 : : {
25056 : 5430 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
25057 : :
25058 : 5430 : if (strcmp (p, "simd") == 0)
25059 : : {
25060 : 2203 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
25061 : 2203 : if (cclauses == NULL)
25062 : 300 : cclauses = cclauses_buf;
25063 : :
25064 : 2203 : c_parser_consume_token (parser);
25065 : 2203 : if (!flag_openmp) /* flag_openmp_simd */
25066 : 14 : return c_parser_omp_simd (loc, parser, p_name, mask, cclauses,
25067 : 14 : if_p);
25068 : 2189 : block = c_begin_compound_stmt (true);
25069 : 2189 : ret = c_parser_omp_simd (loc, parser, p_name, mask, cclauses, if_p);
25070 : 2189 : block = c_end_compound_stmt (loc, block, true);
25071 : 2189 : if (ret == NULL_TREE)
25072 : : return ret;
25073 : 2178 : ret = make_node (OMP_FOR);
25074 : 2178 : TREE_TYPE (ret) = void_type_node;
25075 : 2178 : OMP_FOR_BODY (ret) = block;
25076 : 2178 : OMP_FOR_CLAUSES (ret) = cclauses[C_OMP_CLAUSE_SPLIT_FOR];
25077 : 2178 : SET_EXPR_LOCATION (ret, loc);
25078 : 2178 : add_stmt (ret);
25079 : 2178 : return ret;
25080 : : }
25081 : : }
25082 : 3975 : if (!flag_openmp) /* flag_openmp_simd */
25083 : : {
25084 : 9 : c_parser_skip_to_pragma_eol (parser, false);
25085 : 9 : return NULL_TREE;
25086 : : }
25087 : :
25088 : : /* Composite distribute parallel for disallows linear clause. */
25089 : 3966 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
25090 : 1371 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR);
25091 : :
25092 : 3966 : clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
25093 : 3966 : if (cclauses)
25094 : : {
25095 : 2461 : omp_split_clauses (loc, OMP_FOR, mask, clauses, cclauses);
25096 : 2461 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_FOR];
25097 : : }
25098 : :
25099 : 3966 : block = c_begin_compound_stmt (true);
25100 : 3966 : ret = c_parser_omp_for_loop (loc, parser, OMP_FOR, clauses, cclauses, if_p);
25101 : 3966 : block = c_end_compound_stmt (loc, block, true);
25102 : 3966 : add_stmt (block);
25103 : :
25104 : 3966 : return ret;
25105 : : }
25106 : :
25107 : : static tree c_parser_omp_taskloop (location_t, c_parser *, char *,
25108 : : omp_clause_mask, tree *, bool *);
25109 : :
25110 : : /* OpenMP 2.5:
25111 : : # pragma omp master new-line
25112 : : structured-block
25113 : :
25114 : : LOC is the location of the #pragma token.
25115 : : */
25116 : :
25117 : : static tree
25118 : 231 : c_parser_omp_master (location_t loc, c_parser *parser,
25119 : : char *p_name, omp_clause_mask mask, tree *cclauses,
25120 : : bool *if_p)
25121 : : {
25122 : 231 : tree block, clauses, ret;
25123 : :
25124 : 231 : strcat (p_name, " master");
25125 : :
25126 : 231 : if (c_parser_next_token_is (parser, CPP_NAME))
25127 : : {
25128 : 123 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
25129 : :
25130 : 123 : if (strcmp (p, "taskloop") == 0)
25131 : : {
25132 : 94 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
25133 : 94 : if (cclauses == NULL)
25134 : 47 : cclauses = cclauses_buf;
25135 : :
25136 : 94 : c_parser_consume_token (parser);
25137 : 94 : if (!flag_openmp) /* flag_openmp_simd */
25138 : 4 : return c_parser_omp_taskloop (loc, parser, p_name, mask, cclauses,
25139 : 4 : if_p);
25140 : 90 : block = c_begin_compound_stmt (true);
25141 : 90 : ret = c_parser_omp_taskloop (loc, parser, p_name, mask, cclauses,
25142 : : if_p);
25143 : 90 : block = c_end_compound_stmt (loc, block, true);
25144 : 90 : if (ret == NULL_TREE)
25145 : : return ret;
25146 : 90 : ret = c_finish_omp_master (loc, block);
25147 : 90 : OMP_MASTER_COMBINED (ret) = 1;
25148 : 90 : return ret;
25149 : : }
25150 : : }
25151 : 137 : if (!flag_openmp) /* flag_openmp_simd */
25152 : : {
25153 : 2 : c_parser_skip_to_pragma_eol (parser, false);
25154 : 2 : return NULL_TREE;
25155 : : }
25156 : :
25157 : 135 : if (cclauses)
25158 : : {
25159 : 41 : clauses = c_parser_omp_all_clauses (parser, mask, p_name, false);
25160 : 41 : omp_split_clauses (loc, OMP_MASTER, mask, clauses, cclauses);
25161 : : }
25162 : : else
25163 : 94 : c_parser_skip_to_pragma_eol (parser);
25164 : :
25165 : 135 : return c_finish_omp_master (loc, c_parser_omp_structured_block (parser,
25166 : 135 : if_p));
25167 : : }
25168 : :
25169 : : /* OpenMP 5.1:
25170 : : # pragma omp masked masked-clauses new-line
25171 : : structured-block
25172 : :
25173 : : LOC is the location of the #pragma token.
25174 : : */
25175 : :
25176 : : #define OMP_MASKED_CLAUSE_MASK \
25177 : : (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FILTER)
25178 : :
25179 : : static tree
25180 : 116 : c_parser_omp_masked (location_t loc, c_parser *parser,
25181 : : char *p_name, omp_clause_mask mask, tree *cclauses,
25182 : : bool *if_p)
25183 : : {
25184 : 116 : tree block, clauses, ret;
25185 : :
25186 : 116 : strcat (p_name, " masked");
25187 : 116 : mask |= OMP_MASKED_CLAUSE_MASK;
25188 : :
25189 : 116 : if (c_parser_next_token_is (parser, CPP_NAME))
25190 : : {
25191 : 86 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
25192 : :
25193 : 86 : if (strcmp (p, "taskloop") == 0)
25194 : : {
25195 : 67 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
25196 : 67 : if (cclauses == NULL)
25197 : 20 : cclauses = cclauses_buf;
25198 : :
25199 : 67 : c_parser_consume_token (parser);
25200 : 67 : if (!flag_openmp) /* flag_openmp_simd */
25201 : 0 : return c_parser_omp_taskloop (loc, parser, p_name, mask, cclauses,
25202 : 0 : if_p);
25203 : 67 : block = c_begin_compound_stmt (true);
25204 : 67 : ret = c_parser_omp_taskloop (loc, parser, p_name, mask, cclauses,
25205 : : if_p);
25206 : 67 : block = c_end_compound_stmt (loc, block, true);
25207 : 67 : if (ret == NULL_TREE)
25208 : : return ret;
25209 : 67 : ret = c_finish_omp_masked (loc, block,
25210 : : cclauses[C_OMP_CLAUSE_SPLIT_MASKED]);
25211 : 67 : OMP_MASKED_COMBINED (ret) = 1;
25212 : 67 : return ret;
25213 : : }
25214 : : }
25215 : 49 : if (!flag_openmp) /* flag_openmp_simd */
25216 : : {
25217 : 0 : c_parser_skip_to_pragma_eol (parser, false);
25218 : 0 : return NULL_TREE;
25219 : : }
25220 : :
25221 : 49 : clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
25222 : 49 : if (cclauses)
25223 : : {
25224 : 9 : omp_split_clauses (loc, OMP_MASKED, mask, clauses, cclauses);
25225 : 9 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_MASKED];
25226 : : }
25227 : :
25228 : 49 : return c_finish_omp_masked (loc, c_parser_omp_structured_block (parser,
25229 : : if_p),
25230 : 49 : clauses);
25231 : : }
25232 : :
25233 : : /* OpenMP 5.1:
25234 : : # pragma omp interop clauses[opt] new-line */
25235 : :
25236 : : #define OMP_INTEROP_CLAUSE_MASK \
25237 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
25238 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DESTROY) \
25239 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
25240 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INIT) \
25241 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
25242 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE))
25243 : :
25244 : : static void
25245 : 183 : c_parser_omp_interop (c_parser *parser)
25246 : : {
25247 : 183 : location_t loc = c_parser_peek_token (parser)->location;
25248 : 183 : c_parser_consume_pragma (parser);
25249 : 366 : tree clauses = c_parser_omp_all_clauses (parser,
25250 : 183 : OMP_INTEROP_CLAUSE_MASK,
25251 : : "#pragma omp interop");
25252 : 183 : tree stmt = make_node (OMP_INTEROP);
25253 : 183 : TREE_TYPE (stmt) = void_type_node;
25254 : 183 : OMP_INTEROP_CLAUSES (stmt) = clauses;
25255 : 183 : SET_EXPR_LOCATION (stmt, loc);
25256 : 183 : add_stmt (stmt);
25257 : 183 : }
25258 : :
25259 : : /* OpenMP 2.5:
25260 : : # pragma omp ordered new-line
25261 : : structured-block
25262 : :
25263 : : OpenMP 4.5:
25264 : : # pragma omp ordered ordered-clauses new-line
25265 : : structured-block
25266 : :
25267 : : # pragma omp ordered depend-clauses new-line
25268 : :
25269 : : OpenMP 5.2
25270 : : # pragma omp ordered doacross-clauses new-line */
25271 : :
25272 : : #define OMP_ORDERED_CLAUSE_MASK \
25273 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREADS) \
25274 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMD))
25275 : :
25276 : : #define OMP_ORDERED_DEPEND_CLAUSE_MASK \
25277 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
25278 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DOACROSS))
25279 : :
25280 : : static bool
25281 : 543 : c_parser_omp_ordered (c_parser *parser, enum pragma_context context,
25282 : : bool *if_p)
25283 : : {
25284 : 543 : location_t loc = c_parser_peek_token (parser)->location;
25285 : 543 : c_parser_consume_pragma (parser);
25286 : :
25287 : 543 : if (context != pragma_stmt && context != pragma_compound)
25288 : : {
25289 : 1 : c_parser_error (parser, "expected declaration specifiers");
25290 : 1 : c_parser_skip_to_pragma_eol (parser, false);
25291 : 1 : return false;
25292 : : }
25293 : :
25294 : 542 : int n = 1;
25295 : 542 : if (c_parser_next_token_is (parser, CPP_COMMA))
25296 : 8 : n = 2;
25297 : :
25298 : 542 : if (c_parser_peek_nth_token (parser, n)->type == CPP_NAME)
25299 : : {
25300 : 431 : const char *p
25301 : 431 : = IDENTIFIER_POINTER (c_parser_peek_nth_token (parser, n)->value);
25302 : :
25303 : 431 : if (!strcmp ("depend", p) || !strcmp ("doacross", p))
25304 : : {
25305 : 347 : if (!flag_openmp) /* flag_openmp_simd */
25306 : : {
25307 : 2 : c_parser_skip_to_pragma_eol (parser, false);
25308 : 2 : return false;
25309 : : }
25310 : 345 : if (context == pragma_stmt)
25311 : : {
25312 : 16 : error_at (loc,
25313 : : "%<#pragma omp ordered%> with %qs clause may "
25314 : : "only be used in compound statements", p);
25315 : 16 : c_parser_skip_to_pragma_eol (parser, false);
25316 : 16 : return true;
25317 : : }
25318 : :
25319 : 329 : tree clauses
25320 : 658 : = c_parser_omp_all_clauses (parser,
25321 : 329 : OMP_ORDERED_DEPEND_CLAUSE_MASK,
25322 : : "#pragma omp ordered");
25323 : 329 : c_finish_omp_ordered (loc, clauses, NULL_TREE);
25324 : 329 : return false;
25325 : : }
25326 : : }
25327 : :
25328 : 195 : tree clauses = c_parser_omp_all_clauses (parser, OMP_ORDERED_CLAUSE_MASK,
25329 : : "#pragma omp ordered");
25330 : :
25331 : 195 : if (!flag_openmp /* flag_openmp_simd */
25332 : 195 : && omp_find_clause (clauses, OMP_CLAUSE_SIMD) == NULL_TREE)
25333 : : return false;
25334 : :
25335 : 193 : c_finish_omp_ordered (loc, clauses,
25336 : : c_parser_omp_structured_block (parser, if_p));
25337 : 193 : return true;
25338 : : }
25339 : :
25340 : : /* OpenMP 2.5:
25341 : :
25342 : : section-scope:
25343 : : { section-sequence }
25344 : :
25345 : : section-sequence:
25346 : : section-directive[opt] structured-block
25347 : : section-sequence section-directive structured-block
25348 : :
25349 : : OpenMP 5.1 allows structured-block-sequence instead of structured-block.
25350 : :
25351 : : SECTIONS_LOC is the location of the #pragma omp sections. */
25352 : :
25353 : : static tree
25354 : 142 : c_parser_omp_sections_scope (location_t sections_loc, c_parser *parser)
25355 : : {
25356 : 142 : tree stmt, substmt;
25357 : 142 : bool error_suppress = false;
25358 : 142 : location_t loc;
25359 : :
25360 : 142 : loc = c_parser_peek_token (parser)->location;
25361 : 142 : if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
25362 : : {
25363 : : /* Avoid skipping until the end of the block. */
25364 : 2 : parser->error = false;
25365 : 2 : return NULL_TREE;
25366 : : }
25367 : :
25368 : 140 : stmt = push_stmt_list ();
25369 : :
25370 : 140 : if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_SECTION
25371 : 140 : && !c_parser_omp_section_scan (parser, "section", true))
25372 : : {
25373 : 81 : substmt = c_parser_omp_structured_block_sequence (parser,
25374 : : PRAGMA_OMP_SECTION);
25375 : 81 : substmt = build1 (OMP_SECTION, void_type_node, substmt);
25376 : 81 : SET_EXPR_LOCATION (substmt, loc);
25377 : 81 : add_stmt (substmt);
25378 : : }
25379 : :
25380 : 578 : while (1)
25381 : : {
25382 : 359 : if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
25383 : : break;
25384 : 219 : if (c_parser_next_token_is (parser, CPP_EOF))
25385 : : break;
25386 : :
25387 : 219 : loc = c_parser_peek_token (parser)->location;
25388 : 219 : c_parser_omp_section_scan (parser, "section", false);
25389 : 219 : if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
25390 : : {
25391 : 218 : c_parser_consume_pragma (parser);
25392 : 218 : c_parser_skip_to_pragma_eol (parser);
25393 : 218 : error_suppress = false;
25394 : : }
25395 : 1 : else if (!error_suppress)
25396 : : {
25397 : 1 : error_at (loc, "expected %<#pragma omp section%> or %<}%>");
25398 : 1 : error_suppress = true;
25399 : : }
25400 : :
25401 : 219 : substmt = c_parser_omp_structured_block_sequence (parser,
25402 : : PRAGMA_OMP_SECTION);
25403 : 219 : substmt = build1 (OMP_SECTION, void_type_node, substmt);
25404 : 219 : SET_EXPR_LOCATION (substmt, loc);
25405 : 219 : add_stmt (substmt);
25406 : : }
25407 : 140 : c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
25408 : : "expected %<#pragma omp section%> or %<}%>");
25409 : :
25410 : 140 : substmt = pop_stmt_list (stmt);
25411 : :
25412 : 140 : stmt = make_node (OMP_SECTIONS);
25413 : 140 : SET_EXPR_LOCATION (stmt, sections_loc);
25414 : 140 : TREE_TYPE (stmt) = void_type_node;
25415 : 140 : OMP_SECTIONS_BODY (stmt) = substmt;
25416 : :
25417 : 140 : return add_stmt (stmt);
25418 : : }
25419 : :
25420 : : /* OpenMP 2.5:
25421 : : # pragma omp sections sections-clause[optseq] newline
25422 : : sections-scope
25423 : :
25424 : : LOC is the location of the #pragma token.
25425 : : */
25426 : :
25427 : : #define OMP_SECTIONS_CLAUSE_MASK \
25428 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
25429 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
25430 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
25431 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
25432 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
25433 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
25434 : :
25435 : : static tree
25436 : 142 : c_parser_omp_sections (location_t loc, c_parser *parser,
25437 : : char *p_name, omp_clause_mask mask, tree *cclauses)
25438 : : {
25439 : 142 : tree block, clauses, ret;
25440 : :
25441 : 142 : strcat (p_name, " sections");
25442 : 142 : mask |= OMP_SECTIONS_CLAUSE_MASK;
25443 : 142 : if (cclauses)
25444 : 36 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT);
25445 : :
25446 : 142 : clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
25447 : 142 : if (cclauses)
25448 : : {
25449 : 36 : omp_split_clauses (loc, OMP_SECTIONS, mask, clauses, cclauses);
25450 : 36 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_SECTIONS];
25451 : : }
25452 : :
25453 : 142 : block = c_begin_compound_stmt (true);
25454 : 142 : ret = c_parser_omp_sections_scope (loc, parser);
25455 : 142 : if (ret)
25456 : 140 : OMP_SECTIONS_CLAUSES (ret) = clauses;
25457 : 142 : block = c_end_compound_stmt (loc, block, true);
25458 : 142 : add_stmt (block);
25459 : :
25460 : 142 : return ret;
25461 : : }
25462 : :
25463 : : /* OpenMP 2.5:
25464 : : # pragma omp parallel parallel-clause[optseq] new-line
25465 : : structured-block
25466 : : # pragma omp parallel for parallel-for-clause[optseq] new-line
25467 : : structured-block
25468 : : # pragma omp parallel sections parallel-sections-clause[optseq] new-line
25469 : : structured-block
25470 : :
25471 : : OpenMP 4.0:
25472 : : # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
25473 : : structured-block
25474 : :
25475 : : LOC is the location of the #pragma token.
25476 : : */
25477 : :
25478 : : #define OMP_PARALLEL_CLAUSE_MASK \
25479 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
25480 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
25481 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
25482 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
25483 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
25484 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
25485 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
25486 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
25487 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
25488 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
25489 : :
25490 : : static tree
25491 : 5691 : c_parser_omp_parallel (location_t loc, c_parser *parser,
25492 : : char *p_name, omp_clause_mask mask, tree *cclauses,
25493 : : bool *if_p)
25494 : : {
25495 : 5691 : tree stmt, clauses, block;
25496 : :
25497 : 5691 : strcat (p_name, " parallel");
25498 : 5691 : mask |= OMP_PARALLEL_CLAUSE_MASK;
25499 : : /* #pragma omp target parallel{, for, for simd} disallow copyin clause. */
25500 : 5691 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP)) != 0
25501 : 1165 : && (mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) == 0)
25502 : 489 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN);
25503 : :
25504 : 5691 : if (c_parser_next_token_is_keyword (parser, RID_FOR))
25505 : : {
25506 : 4372 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
25507 : 4372 : if (cclauses == NULL)
25508 : 1199 : cclauses = cclauses_buf;
25509 : :
25510 : 4372 : c_parser_consume_token (parser);
25511 : 4372 : if (!flag_openmp) /* flag_openmp_simd */
25512 : 20 : return c_parser_omp_for (loc, parser, p_name, mask, cclauses, if_p);
25513 : 4352 : block = c_begin_omp_parallel ();
25514 : 4352 : tree ret = c_parser_omp_for (loc, parser, p_name, mask, cclauses, if_p);
25515 : 4352 : stmt
25516 : 4352 : = c_finish_omp_parallel (loc, cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
25517 : : block);
25518 : 4352 : if (ret == NULL_TREE)
25519 : : return ret;
25520 : 4291 : OMP_PARALLEL_COMBINED (stmt) = 1;
25521 : 4291 : return stmt;
25522 : : }
25523 : : /* When combined with distribute, parallel has to be followed by for.
25524 : : #pragma omp target parallel is allowed though. */
25525 : 1319 : else if (cclauses
25526 : 1319 : && (mask & (OMP_CLAUSE_MASK_1
25527 : 40 : << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
25528 : : {
25529 : 0 : error_at (loc, "expected %<for%> after %qs", p_name);
25530 : 0 : c_parser_skip_to_pragma_eol (parser);
25531 : 0 : return NULL_TREE;
25532 : : }
25533 : 1319 : else if (c_parser_next_token_is (parser, CPP_NAME))
25534 : : {
25535 : 713 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
25536 : 713 : if (cclauses == NULL && strcmp (p, "masked") == 0)
25537 : : {
25538 : 56 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
25539 : 56 : cclauses = cclauses_buf;
25540 : :
25541 : 56 : c_parser_consume_token (parser);
25542 : 56 : if (!flag_openmp) /* flag_openmp_simd */
25543 : 0 : return c_parser_omp_masked (loc, parser, p_name, mask, cclauses,
25544 : 0 : if_p);
25545 : 56 : block = c_begin_omp_parallel ();
25546 : 56 : tree ret = c_parser_omp_masked (loc, parser, p_name, mask, cclauses,
25547 : : if_p);
25548 : 56 : stmt = c_finish_omp_parallel (loc,
25549 : : cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
25550 : : block);
25551 : 56 : if (ret == NULL)
25552 : : return ret;
25553 : : /* masked does have just filter clause, but during gimplification
25554 : : isn't represented by a gimplification omp context, so for
25555 : : #pragma omp parallel masked don't set OMP_PARALLEL_COMBINED,
25556 : : so that
25557 : : #pragma omp parallel masked
25558 : : #pragma omp taskloop simd lastprivate (x)
25559 : : isn't confused with
25560 : : #pragma omp parallel masked taskloop simd lastprivate (x) */
25561 : 56 : if (OMP_MASKED_COMBINED (ret))
25562 : 47 : OMP_PARALLEL_COMBINED (stmt) = 1;
25563 : 56 : return stmt;
25564 : : }
25565 : 622 : else if (cclauses == NULL && strcmp (p, "master") == 0)
25566 : : {
25567 : 89 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
25568 : 89 : cclauses = cclauses_buf;
25569 : :
25570 : 89 : c_parser_consume_token (parser);
25571 : 89 : if (!flag_openmp) /* flag_openmp_simd */
25572 : 3 : return c_parser_omp_master (loc, parser, p_name, mask, cclauses,
25573 : 3 : if_p);
25574 : 86 : block = c_begin_omp_parallel ();
25575 : 86 : tree ret = c_parser_omp_master (loc, parser, p_name, mask, cclauses,
25576 : : if_p);
25577 : 86 : stmt = c_finish_omp_parallel (loc,
25578 : : cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
25579 : : block);
25580 : 86 : if (ret == NULL)
25581 : : return ret;
25582 : : /* master doesn't have any clauses and during gimplification
25583 : : isn't represented by a gimplification omp context, so for
25584 : : #pragma omp parallel master don't set OMP_PARALLEL_COMBINED,
25585 : : so that
25586 : : #pragma omp parallel master
25587 : : #pragma omp taskloop simd lastprivate (x)
25588 : : isn't confused with
25589 : : #pragma omp parallel master taskloop simd lastprivate (x) */
25590 : 86 : if (OMP_MASTER_COMBINED (ret))
25591 : 45 : OMP_PARALLEL_COMBINED (stmt) = 1;
25592 : 86 : return stmt;
25593 : : }
25594 : 568 : else if (strcmp (p, "loop") == 0)
25595 : : {
25596 : 46 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
25597 : 46 : if (cclauses == NULL)
25598 : 27 : cclauses = cclauses_buf;
25599 : :
25600 : 46 : c_parser_consume_token (parser);
25601 : 46 : if (!flag_openmp) /* flag_openmp_simd */
25602 : 2 : return c_parser_omp_loop (loc, parser, p_name, mask, cclauses,
25603 : 2 : if_p);
25604 : 44 : block = c_begin_omp_parallel ();
25605 : 44 : tree ret = c_parser_omp_loop (loc, parser, p_name, mask, cclauses,
25606 : : if_p);
25607 : 44 : stmt
25608 : 44 : = c_finish_omp_parallel (loc,
25609 : : cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
25610 : : block);
25611 : 44 : if (ret == NULL_TREE)
25612 : : return ret;
25613 : 44 : OMP_PARALLEL_COMBINED (stmt) = 1;
25614 : 44 : return stmt;
25615 : : }
25616 : 522 : else if (!flag_openmp) /* flag_openmp_simd */
25617 : : {
25618 : 1 : c_parser_skip_to_pragma_eol (parser, false);
25619 : 1 : return NULL_TREE;
25620 : : }
25621 : 521 : else if (cclauses == NULL && strcmp (p, "sections") == 0)
25622 : : {
25623 : 36 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
25624 : 36 : cclauses = cclauses_buf;
25625 : :
25626 : 36 : c_parser_consume_token (parser);
25627 : 36 : block = c_begin_omp_parallel ();
25628 : 36 : c_parser_omp_sections (loc, parser, p_name, mask, cclauses);
25629 : 36 : stmt = c_finish_omp_parallel (loc,
25630 : : cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
25631 : : block);
25632 : 36 : OMP_PARALLEL_COMBINED (stmt) = 1;
25633 : 36 : return stmt;
25634 : : }
25635 : : }
25636 : 606 : else if (!flag_openmp) /* flag_openmp_simd */
25637 : : {
25638 : 1 : c_parser_skip_to_pragma_eol (parser, false);
25639 : 1 : return NULL_TREE;
25640 : : }
25641 : :
25642 : 1090 : clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
25643 : 1090 : if (cclauses)
25644 : : {
25645 : 20 : omp_split_clauses (loc, OMP_PARALLEL, mask, clauses, cclauses);
25646 : 20 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL];
25647 : : }
25648 : :
25649 : 1090 : block = c_begin_omp_parallel ();
25650 : 1090 : parser->omp_attrs_forbidden_p = true;
25651 : 1090 : c_parser_statement (parser, if_p);
25652 : 1090 : stmt = c_finish_omp_parallel (loc, clauses, block);
25653 : :
25654 : 1090 : return stmt;
25655 : : }
25656 : :
25657 : : /* OpenMP 2.5:
25658 : : # pragma omp single single-clause[optseq] new-line
25659 : : structured-block
25660 : :
25661 : : LOC is the location of the #pragma.
25662 : : */
25663 : :
25664 : : #define OMP_SINGLE_CLAUSE_MASK \
25665 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
25666 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
25667 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
25668 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
25669 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
25670 : :
25671 : : static tree
25672 : 222 : c_parser_omp_single (location_t loc, c_parser *parser, bool *if_p)
25673 : : {
25674 : 222 : tree stmt = make_node (OMP_SINGLE);
25675 : 222 : SET_EXPR_LOCATION (stmt, loc);
25676 : 222 : TREE_TYPE (stmt) = void_type_node;
25677 : :
25678 : 222 : OMP_SINGLE_CLAUSES (stmt)
25679 : 222 : = c_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
25680 : : "#pragma omp single");
25681 : 222 : OMP_SINGLE_BODY (stmt) = c_parser_omp_structured_block (parser, if_p);
25682 : :
25683 : 222 : return add_stmt (stmt);
25684 : : }
25685 : :
25686 : : /* OpenMP 5.1:
25687 : : # pragma omp scope scope-clause[optseq] new-line
25688 : : structured-block
25689 : :
25690 : : LOC is the location of the #pragma.
25691 : : */
25692 : :
25693 : : #define OMP_SCOPE_CLAUSE_MASK \
25694 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
25695 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
25696 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
25697 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
25698 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
25699 : :
25700 : : static tree
25701 : 61 : c_parser_omp_scope (location_t loc, c_parser *parser, bool *if_p)
25702 : : {
25703 : 61 : tree stmt = make_node (OMP_SCOPE);
25704 : 61 : SET_EXPR_LOCATION (stmt, loc);
25705 : 61 : TREE_TYPE (stmt) = void_type_node;
25706 : :
25707 : 61 : OMP_SCOPE_CLAUSES (stmt)
25708 : 61 : = c_parser_omp_all_clauses (parser, OMP_SCOPE_CLAUSE_MASK,
25709 : : "#pragma omp scope");
25710 : 61 : OMP_SCOPE_BODY (stmt) = c_parser_omp_structured_block (parser, if_p);
25711 : :
25712 : 61 : return add_stmt (stmt);
25713 : : }
25714 : :
25715 : : /* Parse a function dispatch structured block:
25716 : :
25717 : : lvalue-expression = target-call ( [expression-list] );
25718 : : or
25719 : : target-call ( [expression-list] );
25720 : :
25721 : : Adapted from c_parser_expr_no_commas and c_parser_postfix_expression
25722 : : (CPP_NAME/C_ID_ID) for the function name.
25723 : : */
25724 : : static tree
25725 : 152 : c_parser_omp_dispatch_body (c_parser *parser)
25726 : : {
25727 : 152 : struct c_expr lhs, rhs, ret;
25728 : 152 : location_t expr_loc = c_parser_peek_token (parser)->location;
25729 : 152 : source_range tok_range = c_parser_peek_token (parser)->get_range ();
25730 : :
25731 : 152 : lhs = c_parser_conditional_expression (parser, NULL, NULL);
25732 : 152 : if (TREE_CODE (lhs.value) == CALL_EXPR)
25733 : : return lhs.value;
25734 : :
25735 : 53 : location_t op_location = c_parser_peek_token (parser)->location;
25736 : 53 : if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
25737 : 4 : return error_mark_node;
25738 : :
25739 : : /* Parse function name. */
25740 : 49 : if (!c_parser_next_token_is (parser, CPP_NAME))
25741 : : {
25742 : 1 : c_parser_error (parser, "expected a function name");
25743 : 1 : return error_mark_node;
25744 : : }
25745 : 48 : expr_loc = c_parser_peek_token (parser)->location;
25746 : 48 : tree id = c_parser_peek_token (parser)->value;
25747 : 48 : c_parser_consume_token (parser);
25748 : 48 : if (!c_parser_next_token_is (parser, CPP_OPEN_PAREN))
25749 : : {
25750 : 1 : c_parser_error (parser, "expected a function name");
25751 : 1 : return error_mark_node;
25752 : : }
25753 : :
25754 : 47 : rhs.value = build_external_ref (expr_loc, id, true, &rhs.original_type);
25755 : 47 : set_c_expr_source_range (&rhs, tok_range);
25756 : :
25757 : : /* Parse argument list. */
25758 : 47 : rhs = c_parser_postfix_expression_after_primary (
25759 : 47 : parser, EXPR_LOC_OR_LOC (rhs.value, expr_loc), rhs);
25760 : 47 : if (TREE_CODE (rhs.value) != CALL_EXPR)
25761 : : {
25762 : 0 : error_at (EXPR_LOC_OR_LOC (rhs.value, expr_loc),
25763 : : "expected target-function call");
25764 : 0 : return error_mark_node;
25765 : : }
25766 : :
25767 : : /* Build assignment. */
25768 : 47 : rhs = convert_lvalue_to_rvalue (expr_loc, rhs, true, true);
25769 : 47 : ret.value
25770 : 47 : = build_modify_expr (op_location, lhs.value, lhs.original_type, NOP_EXPR,
25771 : : expr_loc, rhs.value, rhs.original_type);
25772 : 47 : ret.m_decimal = 0;
25773 : 47 : set_c_expr_source_range (&ret, lhs.get_start (), rhs.get_finish ());
25774 : 47 : ret.original_code = MODIFY_EXPR;
25775 : 47 : ret.original_type = NULL;
25776 : 47 : return ret.value;
25777 : : }
25778 : :
25779 : : /* OpenMP 5.1:
25780 : : # pragma omp dispatch dispatch-clause[optseq] new-line
25781 : : expression-stmt
25782 : :
25783 : : LOC is the location of the #pragma.
25784 : : */
25785 : :
25786 : : #define OMP_DISPATCH_CLAUSE_MASK \
25787 : : ((OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
25788 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
25789 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOVARIANTS) \
25790 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOCONTEXT) \
25791 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR) \
25792 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INTEROP) \
25793 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR) \
25794 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
25795 : :
25796 : : static tree
25797 : 152 : c_parser_omp_dispatch (location_t loc, c_parser *parser)
25798 : : {
25799 : 152 : tree stmt = make_node (OMP_DISPATCH);
25800 : 152 : SET_EXPR_LOCATION (stmt, loc);
25801 : 152 : TREE_TYPE (stmt) = void_type_node;
25802 : :
25803 : 152 : OMP_DISPATCH_CLAUSES (stmt)
25804 : 152 : = c_parser_omp_all_clauses (parser, OMP_DISPATCH_CLAUSE_MASK,
25805 : : "#pragma omp dispatch");
25806 : :
25807 : : // Extract depend clauses and create taskwait
25808 : 152 : tree depend_clauses = NULL_TREE;
25809 : 152 : tree *depend_clauses_ptr = &depend_clauses;
25810 : 336 : for (tree c = OMP_DISPATCH_CLAUSES (stmt); c; c = OMP_CLAUSE_CHAIN (c))
25811 : : {
25812 : 184 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND)
25813 : : {
25814 : 5 : *depend_clauses_ptr = c;
25815 : 5 : depend_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
25816 : : }
25817 : : }
25818 : 152 : if (depend_clauses != NULL_TREE)
25819 : : {
25820 : 5 : tree stmt = make_node (OMP_TASK);
25821 : 5 : TREE_TYPE (stmt) = void_node;
25822 : 5 : OMP_TASK_CLAUSES (stmt) = depend_clauses;
25823 : 5 : OMP_TASK_BODY (stmt) = NULL_TREE;
25824 : 5 : SET_EXPR_LOCATION (stmt, loc);
25825 : 5 : add_stmt (stmt);
25826 : : }
25827 : :
25828 : : // Parse body as expression statement
25829 : 152 : loc = c_parser_peek_token (parser)->location;
25830 : 152 : tree dispatch_body = c_parser_omp_dispatch_body (parser);
25831 : 152 : if (dispatch_body == error_mark_node)
25832 : : {
25833 : 6 : inform (loc, "%<#pragma omp dispatch%> must be followed by a function "
25834 : : "call with optional assignment");
25835 : 6 : c_parser_skip_to_end_of_block_or_statement (parser);
25836 : 6 : return NULL_TREE;
25837 : : }
25838 : :
25839 : : // Walk the tree to find the dispatch function call and wrap it into an IFN
25840 : 146 : gcc_assert (TREE_CODE (dispatch_body) == CALL_EXPR
25841 : : || TREE_CODE (dispatch_body) == MODIFY_EXPR);
25842 : 146 : tree *dispatch_call = TREE_CODE (dispatch_body) == MODIFY_EXPR
25843 : 146 : ? &TREE_OPERAND (dispatch_body, 1)
25844 : : : &dispatch_body;
25845 : 151 : while (TREE_CODE (*dispatch_call) == FLOAT_EXPR
25846 : : || TREE_CODE (*dispatch_call) == CONVERT_EXPR
25847 : 151 : || TREE_CODE (*dispatch_call) == NOP_EXPR)
25848 : 5 : dispatch_call = &TREE_OPERAND (*dispatch_call, 0);
25849 : 146 : *dispatch_call = build_call_expr_internal_loc (
25850 : : loc, IFN_GOMP_DISPATCH,
25851 : 146 : TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*dispatch_call))), 1, *dispatch_call);
25852 : :
25853 : 146 : c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
25854 : 146 : OMP_DISPATCH_BODY (stmt) = dispatch_body;
25855 : :
25856 : 146 : return add_stmt (stmt);
25857 : : }
25858 : :
25859 : : /* OpenMP 3.0:
25860 : : # pragma omp task task-clause[optseq] new-line
25861 : :
25862 : : LOC is the location of the #pragma.
25863 : : */
25864 : :
25865 : : #define OMP_TASK_CLAUSE_MASK \
25866 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
25867 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
25868 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
25869 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
25870 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
25871 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
25872 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
25873 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
25874 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
25875 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
25876 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
25877 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
25878 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DETACH) \
25879 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_AFFINITY))
25880 : :
25881 : : static tree
25882 : 894 : c_parser_omp_task (location_t loc, c_parser *parser, bool *if_p)
25883 : : {
25884 : 894 : tree clauses, block;
25885 : :
25886 : 894 : clauses = c_parser_omp_all_clauses (parser, OMP_TASK_CLAUSE_MASK,
25887 : : "#pragma omp task");
25888 : :
25889 : 894 : block = c_begin_omp_task ();
25890 : 894 : parser->omp_attrs_forbidden_p = true;
25891 : 894 : c_parser_statement (parser, if_p);
25892 : 894 : return c_finish_omp_task (loc, clauses, block);
25893 : : }
25894 : :
25895 : : /* OpenMP 3.0:
25896 : : # pragma omp taskwait new-line
25897 : :
25898 : : OpenMP 5.0:
25899 : : # pragma omp taskwait taskwait-clause[optseq] new-line
25900 : : */
25901 : :
25902 : : #define OMP_TASKWAIT_CLAUSE_MASK \
25903 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
25904 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
25905 : :
25906 : : static void
25907 : 93 : c_parser_omp_taskwait (c_parser *parser)
25908 : : {
25909 : 93 : location_t loc = c_parser_peek_token (parser)->location;
25910 : 93 : c_parser_consume_pragma (parser);
25911 : :
25912 : 93 : tree clauses
25913 : 93 : = c_parser_omp_all_clauses (parser, OMP_TASKWAIT_CLAUSE_MASK,
25914 : : "#pragma omp taskwait");
25915 : :
25916 : 93 : if (clauses)
25917 : : {
25918 : 21 : tree stmt = make_node (OMP_TASK);
25919 : 21 : TREE_TYPE (stmt) = void_node;
25920 : 21 : OMP_TASK_CLAUSES (stmt) = clauses;
25921 : 21 : OMP_TASK_BODY (stmt) = NULL_TREE;
25922 : 21 : SET_EXPR_LOCATION (stmt, loc);
25923 : 21 : add_stmt (stmt);
25924 : : }
25925 : : else
25926 : 72 : c_finish_omp_taskwait (loc);
25927 : 93 : }
25928 : :
25929 : : /* OpenMP 3.1:
25930 : : # pragma omp taskyield new-line
25931 : : */
25932 : :
25933 : : static void
25934 : 6 : c_parser_omp_taskyield (c_parser *parser)
25935 : : {
25936 : 6 : location_t loc = c_parser_peek_token (parser)->location;
25937 : 6 : c_parser_consume_pragma (parser);
25938 : 6 : c_parser_skip_to_pragma_eol (parser);
25939 : :
25940 : 6 : c_finish_omp_taskyield (loc);
25941 : 6 : }
25942 : :
25943 : : /* OpenMP 4.0:
25944 : : # pragma omp taskgroup new-line
25945 : :
25946 : : OpenMP 5.0:
25947 : : # pragma omp taskgroup taskgroup-clause[optseq] new-line
25948 : : */
25949 : :
25950 : : #define OMP_TASKGROUP_CLAUSE_MASK \
25951 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
25952 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASK_REDUCTION))
25953 : :
25954 : : static tree
25955 : 138 : c_parser_omp_taskgroup (location_t loc, c_parser *parser, bool *if_p)
25956 : : {
25957 : 138 : tree clauses = c_parser_omp_all_clauses (parser, OMP_TASKGROUP_CLAUSE_MASK,
25958 : : "#pragma omp taskgroup");
25959 : :
25960 : 138 : tree body = c_parser_omp_structured_block (parser, if_p);
25961 : 138 : return c_finish_omp_taskgroup (loc, body, clauses);
25962 : : }
25963 : :
25964 : : /* OpenMP 4.0:
25965 : : # pragma omp cancel cancel-clause[optseq] new-line
25966 : :
25967 : : LOC is the location of the #pragma.
25968 : : */
25969 : :
25970 : : #define OMP_CANCEL_CLAUSE_MASK \
25971 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
25972 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
25973 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
25974 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
25975 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
25976 : :
25977 : : static void
25978 : 213 : c_parser_omp_cancel (c_parser *parser)
25979 : : {
25980 : 213 : location_t loc = c_parser_peek_token (parser)->location;
25981 : :
25982 : 213 : c_parser_consume_pragma (parser);
25983 : 213 : tree clauses = c_parser_omp_all_clauses (parser, OMP_CANCEL_CLAUSE_MASK,
25984 : : "#pragma omp cancel");
25985 : :
25986 : 213 : c_finish_omp_cancel (loc, clauses);
25987 : 213 : }
25988 : :
25989 : : /* OpenMP 4.0:
25990 : : # pragma omp cancellation point cancelpt-clause[optseq] new-line
25991 : :
25992 : : LOC is the location of the #pragma.
25993 : : */
25994 : :
25995 : : #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
25996 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
25997 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
25998 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
25999 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
26000 : :
26001 : : static bool
26002 : 179 : c_parser_omp_cancellation_point (c_parser *parser, enum pragma_context context)
26003 : : {
26004 : 179 : location_t loc = c_parser_peek_token (parser)->location;
26005 : 179 : tree clauses;
26006 : 179 : bool point_seen = false;
26007 : :
26008 : 179 : c_parser_consume_pragma (parser);
26009 : 179 : if (c_parser_next_token_is (parser, CPP_NAME))
26010 : : {
26011 : 179 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
26012 : 179 : if (strcmp (p, "point") == 0)
26013 : : {
26014 : 177 : c_parser_consume_token (parser);
26015 : 177 : point_seen = true;
26016 : : }
26017 : : }
26018 : 177 : if (!point_seen)
26019 : : {
26020 : 2 : c_parser_error (parser, "expected %<point%>");
26021 : 2 : c_parser_skip_to_pragma_eol (parser);
26022 : 2 : return false;
26023 : : }
26024 : :
26025 : 177 : if (context != pragma_compound)
26026 : : {
26027 : 10 : if (context == pragma_stmt)
26028 : 9 : error_at (loc,
26029 : : "%<#pragma %s%> may only be used in compound statements",
26030 : : "omp cancellation point");
26031 : : else
26032 : 1 : c_parser_error (parser, "expected declaration specifiers");
26033 : 10 : c_parser_skip_to_pragma_eol (parser, false);
26034 : 10 : return true;
26035 : : }
26036 : :
26037 : 167 : clauses
26038 : 167 : = c_parser_omp_all_clauses (parser, OMP_CANCELLATION_POINT_CLAUSE_MASK,
26039 : : "#pragma omp cancellation point");
26040 : :
26041 : 167 : c_finish_omp_cancellation_point (loc, clauses);
26042 : 167 : return true;
26043 : : }
26044 : :
26045 : : /* OpenMP 4.0:
26046 : : #pragma omp distribute distribute-clause[optseq] new-line
26047 : : for-loop */
26048 : :
26049 : : #define OMP_DISTRIBUTE_CLAUSE_MASK \
26050 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
26051 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
26052 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
26053 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
26054 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
26055 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
26056 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
26057 : :
26058 : : static tree
26059 : 3427 : c_parser_omp_distribute (location_t loc, c_parser *parser,
26060 : : char *p_name, omp_clause_mask mask, tree *cclauses,
26061 : : bool *if_p)
26062 : : {
26063 : 3427 : tree clauses, block, ret;
26064 : :
26065 : 3427 : strcat (p_name, " distribute");
26066 : 3427 : mask |= OMP_DISTRIBUTE_CLAUSE_MASK;
26067 : :
26068 : 3427 : if (c_parser_next_token_is (parser, CPP_NAME))
26069 : : {
26070 : 3331 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
26071 : 3331 : bool simd = false;
26072 : 3331 : bool parallel = false;
26073 : :
26074 : 3331 : if (strcmp (p, "simd") == 0)
26075 : : simd = true;
26076 : : else
26077 : 2991 : parallel = strcmp (p, "parallel") == 0;
26078 : 2991 : if (parallel || simd)
26079 : : {
26080 : 3064 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
26081 : 3064 : if (cclauses == NULL)
26082 : 1147 : cclauses = cclauses_buf;
26083 : 3064 : c_parser_consume_token (parser);
26084 : 3064 : if (!flag_openmp) /* flag_openmp_simd */
26085 : : {
26086 : 15 : if (simd)
26087 : 6 : return c_parser_omp_simd (loc, parser, p_name, mask, cclauses,
26088 : 6 : if_p);
26089 : : else
26090 : 9 : return c_parser_omp_parallel (loc, parser, p_name, mask,
26091 : 9 : cclauses, if_p);
26092 : : }
26093 : 3049 : block = c_begin_compound_stmt (true);
26094 : 3049 : if (simd)
26095 : 334 : ret = c_parser_omp_simd (loc, parser, p_name, mask, cclauses,
26096 : : if_p);
26097 : : else
26098 : 2715 : ret = c_parser_omp_parallel (loc, parser, p_name, mask, cclauses,
26099 : : if_p);
26100 : 3049 : block = c_end_compound_stmt (loc, block, true);
26101 : 3049 : if (ret == NULL)
26102 : : return ret;
26103 : 3044 : ret = make_node (OMP_DISTRIBUTE);
26104 : 3044 : TREE_TYPE (ret) = void_type_node;
26105 : 3044 : OMP_FOR_BODY (ret) = block;
26106 : 3044 : OMP_FOR_CLAUSES (ret) = cclauses[C_OMP_CLAUSE_SPLIT_DISTRIBUTE];
26107 : 3044 : SET_EXPR_LOCATION (ret, loc);
26108 : 3044 : add_stmt (ret);
26109 : 3044 : return ret;
26110 : : }
26111 : : }
26112 : 363 : if (!flag_openmp) /* flag_openmp_simd */
26113 : : {
26114 : 2 : c_parser_skip_to_pragma_eol (parser, false);
26115 : 2 : return NULL_TREE;
26116 : : }
26117 : :
26118 : 361 : clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
26119 : 361 : if (cclauses)
26120 : : {
26121 : 194 : omp_split_clauses (loc, OMP_DISTRIBUTE, mask, clauses, cclauses);
26122 : 194 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_DISTRIBUTE];
26123 : : }
26124 : :
26125 : 361 : block = c_begin_compound_stmt (true);
26126 : 361 : ret = c_parser_omp_for_loop (loc, parser, OMP_DISTRIBUTE, clauses, NULL,
26127 : : if_p);
26128 : 361 : block = c_end_compound_stmt (loc, block, true);
26129 : 361 : add_stmt (block);
26130 : :
26131 : 361 : return ret;
26132 : : }
26133 : :
26134 : : /* OpenMP 4.0:
26135 : : # pragma omp teams teams-clause[optseq] new-line
26136 : : structured-block */
26137 : :
26138 : : #define OMP_TEAMS_CLAUSE_MASK \
26139 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
26140 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
26141 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
26142 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
26143 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
26144 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
26145 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
26146 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
26147 : :
26148 : : static tree
26149 : 3669 : c_parser_omp_teams (location_t loc, c_parser *parser,
26150 : : char *p_name, omp_clause_mask mask, tree *cclauses,
26151 : : bool *if_p)
26152 : : {
26153 : 3669 : tree clauses, block, ret;
26154 : :
26155 : 3669 : strcat (p_name, " teams");
26156 : 3669 : mask |= OMP_TEAMS_CLAUSE_MASK;
26157 : :
26158 : 3669 : if (c_parser_next_token_is (parser, CPP_NAME))
26159 : : {
26160 : 2340 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
26161 : 2340 : if (strcmp (p, "distribute") == 0)
26162 : : {
26163 : 2113 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
26164 : 2113 : if (cclauses == NULL)
26165 : 1271 : cclauses = cclauses_buf;
26166 : :
26167 : 2113 : c_parser_consume_token (parser);
26168 : 2113 : if (!flag_openmp) /* flag_openmp_simd */
26169 : 12 : return c_parser_omp_distribute (loc, parser, p_name, mask,
26170 : 12 : cclauses, if_p);
26171 : 2101 : block = c_begin_omp_parallel ();
26172 : 2101 : ret = c_parser_omp_distribute (loc, parser, p_name, mask, cclauses,
26173 : : if_p);
26174 : 2101 : block = c_end_compound_stmt (loc, block, true);
26175 : 2101 : if (ret == NULL)
26176 : : return ret;
26177 : 2101 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
26178 : 2101 : ret = make_node (OMP_TEAMS);
26179 : 2101 : TREE_TYPE (ret) = void_type_node;
26180 : 2101 : OMP_TEAMS_CLAUSES (ret) = clauses;
26181 : 2101 : OMP_TEAMS_BODY (ret) = block;
26182 : 2101 : OMP_TEAMS_COMBINED (ret) = 1;
26183 : 2101 : SET_EXPR_LOCATION (ret, loc);
26184 : 2101 : return add_stmt (ret);
26185 : : }
26186 : 227 : else if (strcmp (p, "loop") == 0)
26187 : : {
26188 : 34 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
26189 : 34 : if (cclauses == NULL)
26190 : 16 : cclauses = cclauses_buf;
26191 : :
26192 : 34 : c_parser_consume_token (parser);
26193 : 34 : if (!flag_openmp) /* flag_openmp_simd */
26194 : 2 : return c_parser_omp_loop (loc, parser, p_name, mask, cclauses,
26195 : 2 : if_p);
26196 : 32 : block = c_begin_omp_parallel ();
26197 : 32 : ret = c_parser_omp_loop (loc, parser, p_name, mask, cclauses, if_p);
26198 : 32 : block = c_end_compound_stmt (loc, block, true);
26199 : 32 : if (ret == NULL)
26200 : : return ret;
26201 : 31 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
26202 : 31 : ret = make_node (OMP_TEAMS);
26203 : 31 : TREE_TYPE (ret) = void_type_node;
26204 : 31 : OMP_TEAMS_CLAUSES (ret) = clauses;
26205 : 31 : OMP_TEAMS_BODY (ret) = block;
26206 : 31 : OMP_TEAMS_COMBINED (ret) = 1;
26207 : 31 : SET_EXPR_LOCATION (ret, loc);
26208 : 31 : return add_stmt (ret);
26209 : : }
26210 : : }
26211 : 1522 : if (!flag_openmp) /* flag_openmp_simd */
26212 : : {
26213 : 2 : c_parser_skip_to_pragma_eol (parser, false);
26214 : 2 : return NULL_TREE;
26215 : : }
26216 : :
26217 : 1520 : clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
26218 : 1520 : if (cclauses)
26219 : : {
26220 : 877 : omp_split_clauses (loc, OMP_TEAMS, mask, clauses, cclauses);
26221 : 877 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
26222 : : }
26223 : :
26224 : 1520 : tree stmt = make_node (OMP_TEAMS);
26225 : 1520 : TREE_TYPE (stmt) = void_type_node;
26226 : 1520 : OMP_TEAMS_CLAUSES (stmt) = clauses;
26227 : 1520 : block = c_begin_omp_parallel ();
26228 : 1520 : add_stmt (c_parser_omp_structured_block (parser, if_p));
26229 : 1520 : OMP_TEAMS_BODY (stmt) = c_end_compound_stmt (loc, block, true);
26230 : 1520 : SET_EXPR_LOCATION (stmt, loc);
26231 : :
26232 : 1520 : return add_stmt (stmt);
26233 : : }
26234 : :
26235 : : /* OpenMP 4.0:
26236 : : # pragma omp target data target-data-clause[optseq] new-line
26237 : : structured-block */
26238 : :
26239 : : #define OMP_TARGET_DATA_CLAUSE_MASK \
26240 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
26241 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
26242 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
26243 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR) \
26244 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR))
26245 : :
26246 : : static tree
26247 : 155 : c_parser_omp_target_data (location_t loc, c_parser *parser, bool *if_p)
26248 : : {
26249 : 155 : if (flag_openmp)
26250 : 155 : omp_requires_mask
26251 : 155 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
26252 : :
26253 : 155 : tree clauses
26254 : 155 : = c_parser_omp_all_clauses (parser, OMP_TARGET_DATA_CLAUSE_MASK,
26255 : 155 : "#pragma omp target data");
26256 : 155 : c_omp_adjust_map_clauses (clauses, false);
26257 : 155 : int map_seen = 0;
26258 : 455 : for (tree *pc = &clauses; *pc;)
26259 : : {
26260 : 300 : if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_MAP)
26261 : 218 : switch (OMP_CLAUSE_MAP_KIND (*pc))
26262 : : {
26263 : : case GOMP_MAP_TO:
26264 : : case GOMP_MAP_ALWAYS_TO:
26265 : : case GOMP_MAP_PRESENT_TO:
26266 : : case GOMP_MAP_ALWAYS_PRESENT_TO:
26267 : : case GOMP_MAP_FROM:
26268 : : case GOMP_MAP_ALWAYS_FROM:
26269 : : case GOMP_MAP_PRESENT_FROM:
26270 : : case GOMP_MAP_ALWAYS_PRESENT_FROM:
26271 : : case GOMP_MAP_TOFROM:
26272 : : case GOMP_MAP_ALWAYS_TOFROM:
26273 : : case GOMP_MAP_PRESENT_TOFROM:
26274 : : case GOMP_MAP_ALWAYS_PRESENT_TOFROM:
26275 : : case GOMP_MAP_ALLOC:
26276 : : case GOMP_MAP_PRESENT_ALLOC:
26277 : 300 : map_seen = 3;
26278 : : break;
26279 : : case GOMP_MAP_FIRSTPRIVATE_POINTER:
26280 : : case GOMP_MAP_ALWAYS_POINTER:
26281 : : case GOMP_MAP_ATTACH_DETACH:
26282 : : case GOMP_MAP_ATTACH:
26283 : : break;
26284 : 0 : default:
26285 : 0 : map_seen |= 1;
26286 : 0 : error_at (OMP_CLAUSE_LOCATION (*pc),
26287 : : "%<#pragma omp target data%> with map-type other "
26288 : : "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
26289 : : "on %<map%> clause");
26290 : 0 : *pc = OMP_CLAUSE_CHAIN (*pc);
26291 : 0 : continue;
26292 : : }
26293 : 82 : else if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_USE_DEVICE_PTR
26294 : 82 : || OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_USE_DEVICE_ADDR)
26295 : : map_seen = 3;
26296 : 300 : pc = &OMP_CLAUSE_CHAIN (*pc);
26297 : : }
26298 : :
26299 : 155 : if (map_seen != 3)
26300 : : {
26301 : 3 : if (map_seen == 0)
26302 : 3 : error_at (loc,
26303 : : "%<#pragma omp target data%> must contain at least "
26304 : : "one %<map%>, %<use_device_ptr%> or %<use_device_addr%> "
26305 : : "clause");
26306 : 3 : return NULL_TREE;
26307 : : }
26308 : :
26309 : 152 : tree stmt = make_node (OMP_TARGET_DATA);
26310 : 152 : TREE_TYPE (stmt) = void_type_node;
26311 : 152 : OMP_TARGET_DATA_CLAUSES (stmt) = clauses;
26312 : 152 : keep_next_level ();
26313 : 152 : tree block = c_begin_compound_stmt (true);
26314 : 152 : add_stmt (c_parser_omp_structured_block (parser, if_p));
26315 : 152 : OMP_TARGET_DATA_BODY (stmt) = c_end_compound_stmt (loc, block, true);
26316 : :
26317 : 152 : SET_EXPR_LOCATION (stmt, loc);
26318 : 152 : return add_stmt (stmt);
26319 : : }
26320 : :
26321 : : /* OpenMP 4.0:
26322 : : # pragma omp target update target-update-clause[optseq] new-line */
26323 : :
26324 : : #define OMP_TARGET_UPDATE_CLAUSE_MASK \
26325 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
26326 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
26327 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
26328 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
26329 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
26330 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
26331 : :
26332 : : static bool
26333 : 2837 : c_parser_omp_target_update (location_t loc, c_parser *parser,
26334 : : enum pragma_context context)
26335 : : {
26336 : 2837 : if (context == pragma_stmt)
26337 : : {
26338 : 8 : error_at (loc, "%<#pragma %s%> may only be used in compound statements",
26339 : : "omp target update");
26340 : 8 : c_parser_skip_to_pragma_eol (parser, false);
26341 : 8 : return true;
26342 : : }
26343 : :
26344 : 2829 : tree clauses
26345 : 2829 : = c_parser_omp_all_clauses (parser, OMP_TARGET_UPDATE_CLAUSE_MASK,
26346 : : "#pragma omp target update");
26347 : 2829 : if (omp_find_clause (clauses, OMP_CLAUSE_TO) == NULL_TREE
26348 : 2829 : && omp_find_clause (clauses, OMP_CLAUSE_FROM) == NULL_TREE)
26349 : : {
26350 : 5 : error_at (loc,
26351 : : "%<#pragma omp target update%> must contain at least one "
26352 : : "%<from%> or %<to%> clauses");
26353 : 5 : return false;
26354 : : }
26355 : :
26356 : 2824 : if (flag_openmp)
26357 : 2824 : omp_requires_mask
26358 : 2824 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
26359 : :
26360 : 2824 : tree stmt = make_node (OMP_TARGET_UPDATE);
26361 : 2824 : TREE_TYPE (stmt) = void_type_node;
26362 : 2824 : OMP_TARGET_UPDATE_CLAUSES (stmt) = clauses;
26363 : 2824 : SET_EXPR_LOCATION (stmt, loc);
26364 : 2824 : add_stmt (stmt);
26365 : 2824 : return false;
26366 : : }
26367 : :
26368 : : /* OpenMP 4.5:
26369 : : # pragma omp target enter data target-data-clause[optseq] new-line */
26370 : :
26371 : : #define OMP_TARGET_ENTER_DATA_CLAUSE_MASK \
26372 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
26373 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
26374 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
26375 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
26376 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
26377 : :
26378 : : static bool
26379 : 116 : c_parser_omp_target_enter_data (location_t loc, c_parser *parser,
26380 : : enum pragma_context context)
26381 : : {
26382 : 116 : bool data_seen = false;
26383 : 116 : if (c_parser_next_token_is (parser, CPP_NAME))
26384 : : {
26385 : 116 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
26386 : 116 : if (strcmp (p, "data") == 0)
26387 : : {
26388 : 116 : c_parser_consume_token (parser);
26389 : 116 : data_seen = true;
26390 : : }
26391 : : }
26392 : 116 : if (!data_seen)
26393 : : {
26394 : 0 : c_parser_error (parser, "expected %<data%>");
26395 : 0 : c_parser_skip_to_pragma_eol (parser);
26396 : 0 : return false;
26397 : : }
26398 : :
26399 : 116 : if (context == pragma_stmt)
26400 : : {
26401 : 8 : error_at (loc, "%<#pragma %s%> may only be used in compound statements",
26402 : : "omp target enter data");
26403 : 8 : c_parser_skip_to_pragma_eol (parser, false);
26404 : 8 : return true;
26405 : : }
26406 : :
26407 : 108 : if (flag_openmp)
26408 : 108 : omp_requires_mask
26409 : 108 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
26410 : :
26411 : 108 : tree clauses
26412 : 108 : = c_parser_omp_all_clauses (parser, OMP_TARGET_ENTER_DATA_CLAUSE_MASK,
26413 : 108 : "#pragma omp target enter data");
26414 : 108 : c_omp_adjust_map_clauses (clauses, false);
26415 : 108 : int map_seen = 0;
26416 : 388 : for (tree *pc = &clauses; *pc;)
26417 : : {
26418 : 280 : if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_MAP)
26419 : 237 : switch (OMP_CLAUSE_MAP_KIND (*pc))
26420 : : {
26421 : : case GOMP_MAP_TO:
26422 : : case GOMP_MAP_ALWAYS_TO:
26423 : : case GOMP_MAP_PRESENT_TO:
26424 : : case GOMP_MAP_ALWAYS_PRESENT_TO:
26425 : : case GOMP_MAP_ALLOC:
26426 : : case GOMP_MAP_PRESENT_ALLOC:
26427 : 184 : map_seen = 3;
26428 : : break;
26429 : 34 : case GOMP_MAP_TOFROM:
26430 : 34 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_TO);
26431 : 34 : map_seen = 3;
26432 : 34 : break;
26433 : 3 : case GOMP_MAP_ALWAYS_TOFROM:
26434 : 3 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_ALWAYS_TO);
26435 : 3 : map_seen = 3;
26436 : 3 : break;
26437 : 2 : case GOMP_MAP_PRESENT_TOFROM:
26438 : 2 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_PRESENT_TO);
26439 : 2 : map_seen = 3;
26440 : 2 : break;
26441 : 2 : case GOMP_MAP_ALWAYS_PRESENT_TOFROM:
26442 : 2 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_ALWAYS_PRESENT_TO);
26443 : 2 : map_seen = 3;
26444 : 2 : break;
26445 : : case GOMP_MAP_FIRSTPRIVATE_POINTER:
26446 : : case GOMP_MAP_ALWAYS_POINTER:
26447 : : case GOMP_MAP_ATTACH_DETACH:
26448 : : case GOMP_MAP_ATTACH:
26449 : : break;
26450 : 2 : default:
26451 : 2 : map_seen |= 1;
26452 : 2 : error_at (OMP_CLAUSE_LOCATION (*pc),
26453 : : "%<#pragma omp target enter data%> with map-type other "
26454 : : "than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause");
26455 : 2 : *pc = OMP_CLAUSE_CHAIN (*pc);
26456 : 2 : continue;
26457 : : }
26458 : 278 : pc = &OMP_CLAUSE_CHAIN (*pc);
26459 : : }
26460 : :
26461 : 108 : if (map_seen != 3)
26462 : : {
26463 : 4 : if (map_seen == 0)
26464 : 2 : error_at (loc,
26465 : : "%<#pragma omp target enter data%> must contain at least "
26466 : : "one %<map%> clause");
26467 : 4 : return true;
26468 : : }
26469 : :
26470 : 104 : tree stmt = make_node (OMP_TARGET_ENTER_DATA);
26471 : 104 : TREE_TYPE (stmt) = void_type_node;
26472 : 104 : OMP_TARGET_ENTER_DATA_CLAUSES (stmt) = clauses;
26473 : 104 : SET_EXPR_LOCATION (stmt, loc);
26474 : 104 : add_stmt (stmt);
26475 : 104 : return true;
26476 : : }
26477 : :
26478 : : /* OpenMP 4.5:
26479 : : # pragma omp target exit data target-data-clause[optseq] new-line */
26480 : :
26481 : : #define OMP_TARGET_EXIT_DATA_CLAUSE_MASK \
26482 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
26483 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
26484 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
26485 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
26486 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
26487 : :
26488 : : static bool
26489 : 107 : c_parser_omp_target_exit_data (location_t loc, c_parser *parser,
26490 : : enum pragma_context context)
26491 : : {
26492 : 107 : bool data_seen = false;
26493 : 107 : if (c_parser_next_token_is (parser, CPP_NAME))
26494 : : {
26495 : 107 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
26496 : 107 : if (strcmp (p, "data") == 0)
26497 : : {
26498 : 107 : c_parser_consume_token (parser);
26499 : 107 : data_seen = true;
26500 : : }
26501 : : }
26502 : 107 : if (!data_seen)
26503 : : {
26504 : 0 : c_parser_error (parser, "expected %<data%>");
26505 : 0 : c_parser_skip_to_pragma_eol (parser);
26506 : 0 : return false;
26507 : : }
26508 : :
26509 : 107 : if (context == pragma_stmt)
26510 : : {
26511 : 8 : error_at (loc, "%<#pragma %s%> may only be used in compound statements",
26512 : : "omp target exit data");
26513 : 8 : c_parser_skip_to_pragma_eol (parser, false);
26514 : 8 : return true;
26515 : : }
26516 : :
26517 : 99 : if (flag_openmp)
26518 : 99 : omp_requires_mask
26519 : 99 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
26520 : :
26521 : 99 : tree clauses
26522 : 99 : = c_parser_omp_all_clauses (parser, OMP_TARGET_EXIT_DATA_CLAUSE_MASK,
26523 : : "#pragma omp target exit data", false);
26524 : 99 : clauses = c_finish_omp_clauses (clauses, C_ORT_OMP_EXIT_DATA);
26525 : 99 : c_omp_adjust_map_clauses (clauses, false);
26526 : 99 : int map_seen = 0;
26527 : 349 : for (tree *pc = &clauses; *pc;)
26528 : : {
26529 : 250 : if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_MAP)
26530 : 207 : switch (OMP_CLAUSE_MAP_KIND (*pc))
26531 : : {
26532 : : case GOMP_MAP_FROM:
26533 : : case GOMP_MAP_ALWAYS_FROM:
26534 : : case GOMP_MAP_PRESENT_FROM:
26535 : : case GOMP_MAP_ALWAYS_PRESENT_FROM:
26536 : : case GOMP_MAP_RELEASE:
26537 : : case GOMP_MAP_DELETE:
26538 : 158 : map_seen = 3;
26539 : : break;
26540 : 30 : case GOMP_MAP_TOFROM:
26541 : 30 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_FROM);
26542 : 30 : map_seen = 3;
26543 : 30 : break;
26544 : 1 : case GOMP_MAP_ALWAYS_TOFROM:
26545 : 1 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_ALWAYS_FROM);
26546 : 1 : map_seen = 3;
26547 : 1 : break;
26548 : 0 : case GOMP_MAP_PRESENT_TOFROM:
26549 : 0 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_PRESENT_FROM);
26550 : 0 : map_seen = 3;
26551 : 0 : break;
26552 : 0 : case GOMP_MAP_ALWAYS_PRESENT_TOFROM:
26553 : 0 : OMP_CLAUSE_SET_MAP_KIND (*pc, GOMP_MAP_ALWAYS_PRESENT_FROM);
26554 : 0 : map_seen = 3;
26555 : 0 : break;
26556 : : case GOMP_MAP_FIRSTPRIVATE_POINTER:
26557 : : case GOMP_MAP_ALWAYS_POINTER:
26558 : : case GOMP_MAP_ATTACH_DETACH:
26559 : : case GOMP_MAP_DETACH:
26560 : : break;
26561 : 2 : default:
26562 : 2 : map_seen |= 1;
26563 : 2 : error_at (OMP_CLAUSE_LOCATION (*pc),
26564 : : "%<#pragma omp target exit data%> with map-type other "
26565 : : "than %<from%>, %<tofrom%>, %<release%> or %<delete%> "
26566 : : "on %<map%> clause");
26567 : 2 : *pc = OMP_CLAUSE_CHAIN (*pc);
26568 : 2 : continue;
26569 : : }
26570 : 248 : pc = &OMP_CLAUSE_CHAIN (*pc);
26571 : : }
26572 : :
26573 : 99 : if (map_seen != 3)
26574 : : {
26575 : 2 : if (map_seen == 0)
26576 : 0 : error_at (loc,
26577 : : "%<#pragma omp target exit data%> must contain at least one "
26578 : : "%<map%> clause");
26579 : 2 : return true;
26580 : : }
26581 : :
26582 : 97 : tree stmt = make_node (OMP_TARGET_EXIT_DATA);
26583 : 97 : TREE_TYPE (stmt) = void_type_node;
26584 : 97 : OMP_TARGET_EXIT_DATA_CLAUSES (stmt) = clauses;
26585 : 97 : SET_EXPR_LOCATION (stmt, loc);
26586 : 97 : add_stmt (stmt);
26587 : 97 : return true;
26588 : : }
26589 : :
26590 : : /* OpenMP 4.0:
26591 : : # pragma omp target target-clause[optseq] new-line
26592 : : structured-block */
26593 : :
26594 : : #define OMP_TARGET_CLAUSE_MASK \
26595 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
26596 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
26597 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
26598 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
26599 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
26600 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
26601 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
26602 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
26603 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULTMAP) \
26604 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
26605 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
26606 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR)\
26607 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR))
26608 : :
26609 : : static bool
26610 : 7395 : c_parser_omp_target (c_parser *parser, enum pragma_context context, bool *if_p)
26611 : : {
26612 : 7395 : location_t loc = c_parser_peek_token (parser)->location;
26613 : 7395 : c_parser_consume_pragma (parser);
26614 : 7395 : tree *pc = NULL, stmt, block, body, clauses;
26615 : :
26616 : 7395 : if (context != pragma_stmt && context != pragma_compound)
26617 : : {
26618 : 2 : c_parser_error (parser, "expected declaration specifiers");
26619 : 2 : c_parser_skip_to_pragma_eol (parser);
26620 : 2 : return false;
26621 : : }
26622 : :
26623 : 7393 : if (flag_openmp)
26624 : 7379 : omp_requires_mask
26625 : 7379 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
26626 : :
26627 : 7393 : if (c_parser_next_token_is (parser, CPP_NAME))
26628 : : {
26629 : 6470 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
26630 : 6470 : enum tree_code ccode = ERROR_MARK;
26631 : :
26632 : 6470 : if (strcmp (p, "teams") == 0)
26633 : : ccode = OMP_TEAMS;
26634 : 4732 : else if (strcmp (p, "parallel") == 0)
26635 : : ccode = OMP_PARALLEL;
26636 : 4243 : else if (strcmp (p, "simd") == 0)
26637 : : ccode = OMP_SIMD;
26638 : 4183 : if (ccode != ERROR_MARK)
26639 : : {
26640 : 2287 : tree cclauses[C_OMP_CLAUSE_SPLIT_COUNT];
26641 : 2287 : char p_name[sizeof ("#pragma omp target teams distribute "
26642 : : "parallel for simd")];
26643 : :
26644 : 2287 : c_parser_consume_token (parser);
26645 : 2287 : strcpy (p_name, "#pragma omp target");
26646 : 2287 : if (!flag_openmp) /* flag_openmp_simd */
26647 : : {
26648 : 13 : tree stmt;
26649 : 13 : switch (ccode)
26650 : : {
26651 : 8 : case OMP_TEAMS:
26652 : 8 : stmt = c_parser_omp_teams (loc, parser, p_name,
26653 : 8 : OMP_TARGET_CLAUSE_MASK,
26654 : : cclauses, if_p);
26655 : 8 : break;
26656 : 4 : case OMP_PARALLEL:
26657 : 4 : stmt = c_parser_omp_parallel (loc, parser, p_name,
26658 : 4 : OMP_TARGET_CLAUSE_MASK,
26659 : : cclauses, if_p);
26660 : 4 : break;
26661 : 1 : case OMP_SIMD:
26662 : 1 : stmt = c_parser_omp_simd (loc, parser, p_name,
26663 : 1 : OMP_TARGET_CLAUSE_MASK,
26664 : : cclauses, if_p);
26665 : 1 : break;
26666 : 0 : default:
26667 : 0 : gcc_unreachable ();
26668 : : }
26669 : 22 : return stmt != NULL_TREE;
26670 : : }
26671 : 2274 : keep_next_level ();
26672 : 2274 : tree block = c_begin_compound_stmt (true), ret;
26673 : 2274 : switch (ccode)
26674 : : {
26675 : 1730 : case OMP_TEAMS:
26676 : 1730 : ret = c_parser_omp_teams (loc, parser, p_name,
26677 : 1730 : OMP_TARGET_CLAUSE_MASK, cclauses,
26678 : : if_p);
26679 : 1730 : break;
26680 : 485 : case OMP_PARALLEL:
26681 : 485 : ret = c_parser_omp_parallel (loc, parser, p_name,
26682 : 485 : OMP_TARGET_CLAUSE_MASK, cclauses,
26683 : : if_p);
26684 : 485 : break;
26685 : 59 : case OMP_SIMD:
26686 : 59 : ret = c_parser_omp_simd (loc, parser, p_name,
26687 : 59 : OMP_TARGET_CLAUSE_MASK, cclauses,
26688 : : if_p);
26689 : 59 : break;
26690 : 0 : default:
26691 : 0 : gcc_unreachable ();
26692 : : }
26693 : 2274 : block = c_end_compound_stmt (loc, block, true);
26694 : 2274 : if (ret == NULL_TREE)
26695 : : return false;
26696 : 2265 : if (ccode == OMP_TEAMS)
26697 : : /* For combined target teams, ensure the num_teams and
26698 : : thread_limit clause expressions are evaluated on the host,
26699 : : before entering the target construct. */
26700 : 2210 : for (tree c = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
26701 : 2210 : c; c = OMP_CLAUSE_CHAIN (c))
26702 : 481 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_NUM_TEAMS
26703 : 481 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_THREAD_LIMIT)
26704 : 202 : for (int i = 0;
26705 : 332 : i <= (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_NUM_TEAMS); ++i)
26706 : 202 : if (OMP_CLAUSE_OPERAND (c, i)
26707 : 202 : && TREE_CODE (OMP_CLAUSE_OPERAND (c, i)) != INTEGER_CST)
26708 : : {
26709 : 129 : tree expr = OMP_CLAUSE_OPERAND (c, i);
26710 : 129 : tree tmp = create_tmp_var_raw (TREE_TYPE (expr));
26711 : 129 : expr = build4 (TARGET_EXPR, TREE_TYPE (expr), tmp,
26712 : : expr, NULL_TREE, NULL_TREE);
26713 : 129 : add_stmt (expr);
26714 : 129 : OMP_CLAUSE_OPERAND (c, i) = expr;
26715 : 129 : tree tc = build_omp_clause (OMP_CLAUSE_LOCATION (c),
26716 : : OMP_CLAUSE_FIRSTPRIVATE);
26717 : 129 : OMP_CLAUSE_DECL (tc) = tmp;
26718 : 129 : OMP_CLAUSE_CHAIN (tc)
26719 : 129 : = cclauses[C_OMP_CLAUSE_SPLIT_TARGET];
26720 : 129 : cclauses[C_OMP_CLAUSE_SPLIT_TARGET] = tc;
26721 : : }
26722 : 2265 : tree stmt = make_node (OMP_TARGET);
26723 : 2265 : TREE_TYPE (stmt) = void_type_node;
26724 : 2265 : OMP_TARGET_CLAUSES (stmt) = cclauses[C_OMP_CLAUSE_SPLIT_TARGET];
26725 : 2265 : c_omp_adjust_map_clauses (OMP_TARGET_CLAUSES (stmt), true);
26726 : 2265 : OMP_TARGET_BODY (stmt) = block;
26727 : 2265 : OMP_TARGET_COMBINED (stmt) = 1;
26728 : 2265 : SET_EXPR_LOCATION (stmt, loc);
26729 : 2265 : add_stmt (stmt);
26730 : 2265 : pc = &OMP_TARGET_CLAUSES (stmt);
26731 : 2265 : goto check_clauses;
26732 : : }
26733 : 4183 : else if (!flag_openmp) /* flag_openmp_simd */
26734 : : {
26735 : 0 : c_parser_skip_to_pragma_eol (parser, false);
26736 : 0 : return false;
26737 : : }
26738 : 4183 : else if (strcmp (p, "data") == 0)
26739 : : {
26740 : 155 : c_parser_consume_token (parser);
26741 : 155 : c_parser_omp_target_data (loc, parser, if_p);
26742 : 155 : return true;
26743 : : }
26744 : 4028 : else if (strcmp (p, "enter") == 0)
26745 : : {
26746 : 116 : c_parser_consume_token (parser);
26747 : 116 : return c_parser_omp_target_enter_data (loc, parser, context);
26748 : : }
26749 : 3912 : else if (strcmp (p, "exit") == 0)
26750 : : {
26751 : 107 : c_parser_consume_token (parser);
26752 : 107 : return c_parser_omp_target_exit_data (loc, parser, context);
26753 : : }
26754 : 3805 : else if (strcmp (p, "update") == 0)
26755 : : {
26756 : 2837 : c_parser_consume_token (parser);
26757 : 2837 : return c_parser_omp_target_update (loc, parser, context);
26758 : : }
26759 : : }
26760 : 1891 : if (!flag_openmp) /* flag_openmp_simd */
26761 : : {
26762 : 1 : c_parser_skip_to_pragma_eol (parser, false);
26763 : 1 : return false;
26764 : : }
26765 : :
26766 : 1890 : stmt = make_node (OMP_TARGET);
26767 : 1890 : TREE_TYPE (stmt) = void_type_node;
26768 : :
26769 : 1890 : clauses = c_parser_omp_all_clauses (parser, OMP_TARGET_CLAUSE_MASK,
26770 : : "#pragma omp target", false);
26771 : 3701 : for (tree c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
26772 : 1811 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_IN_REDUCTION)
26773 : : {
26774 : 50 : tree nc = build_omp_clause (OMP_CLAUSE_LOCATION (c), OMP_CLAUSE_MAP);
26775 : 50 : OMP_CLAUSE_DECL (nc) = OMP_CLAUSE_DECL (c);
26776 : 50 : OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_ALWAYS_TOFROM);
26777 : 50 : OMP_CLAUSE_CHAIN (nc) = OMP_CLAUSE_CHAIN (c);
26778 : 50 : OMP_CLAUSE_CHAIN (c) = nc;
26779 : : }
26780 : 1890 : clauses = c_omp_instantiate_mappers (clauses);
26781 : 1890 : clauses = c_finish_omp_clauses (clauses, C_ORT_OMP_TARGET);
26782 : 1890 : c_omp_adjust_map_clauses (clauses, true);
26783 : :
26784 : 1890 : keep_next_level ();
26785 : 1890 : block = c_begin_compound_stmt (true);
26786 : 1890 : body = c_parser_omp_structured_block (parser, if_p);
26787 : :
26788 : 1890 : c_omp_scan_mapper_bindings (loc, &clauses, body);
26789 : :
26790 : 1890 : add_stmt (body);
26791 : 1890 : OMP_TARGET_CLAUSES (stmt) = clauses;
26792 : 1890 : pc = &OMP_TARGET_CLAUSES (stmt);
26793 : 1890 : OMP_TARGET_BODY (stmt) = c_end_compound_stmt (loc, block, true);
26794 : :
26795 : 1890 : SET_EXPR_LOCATION (stmt, loc);
26796 : 1890 : add_stmt (stmt);
26797 : :
26798 : : check_clauses:
26799 : 7746 : while (*pc)
26800 : : {
26801 : 3591 : if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_MAP)
26802 : 1991 : switch (OMP_CLAUSE_MAP_KIND (*pc))
26803 : : {
26804 : : case GOMP_MAP_TO:
26805 : : case GOMP_MAP_ALWAYS_TO:
26806 : : case GOMP_MAP_PRESENT_TO:
26807 : : case GOMP_MAP_ALWAYS_PRESENT_TO:
26808 : : case GOMP_MAP_FROM:
26809 : : case GOMP_MAP_ALWAYS_FROM:
26810 : : case GOMP_MAP_PRESENT_FROM:
26811 : : case GOMP_MAP_ALWAYS_PRESENT_FROM:
26812 : : case GOMP_MAP_TOFROM:
26813 : : case GOMP_MAP_ALWAYS_TOFROM:
26814 : : case GOMP_MAP_PRESENT_TOFROM:
26815 : : case GOMP_MAP_ALWAYS_PRESENT_TOFROM:
26816 : : case GOMP_MAP_ALLOC:
26817 : : case GOMP_MAP_PRESENT_ALLOC:
26818 : : case GOMP_MAP_FIRSTPRIVATE_POINTER:
26819 : : case GOMP_MAP_ALWAYS_POINTER:
26820 : : case GOMP_MAP_POINTER:
26821 : : case GOMP_MAP_ATTACH_DETACH:
26822 : : case GOMP_MAP_ATTACH:
26823 : : break;
26824 : 1 : default:
26825 : 1 : error_at (OMP_CLAUSE_LOCATION (*pc),
26826 : : "%<#pragma omp target%> with map-type other "
26827 : : "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
26828 : : "on %<map%> clause");
26829 : 1 : *pc = OMP_CLAUSE_CHAIN (*pc);
26830 : 1 : continue;
26831 : : }
26832 : 3590 : pc = &OMP_CLAUSE_CHAIN (*pc);
26833 : : }
26834 : 4155 : cfun->has_omp_target = true;
26835 : 4155 : return true;
26836 : : }
26837 : :
26838 : : /* OpenMP 4.0:
26839 : : # pragma omp declare simd declare-simd-clauses[optseq] new-line
26840 : :
26841 : : OpenMP 5.0:
26842 : : # pragma omp declare variant (identifier) match(context-selector) new-line
26843 : :
26844 : : OpenMP 5.1
26845 : : # pragma omp declare variant (identifier) match(context-selector) \
26846 : : adjust_args(adjust-op:argument-list) append_args(interop-list) new-line
26847 : : */
26848 : :
26849 : : #define OMP_DECLARE_SIMD_CLAUSE_MASK \
26850 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
26851 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
26852 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
26853 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
26854 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
26855 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
26856 : :
26857 : : static void
26858 : 704 : c_parser_omp_declare_simd (c_parser *parser, enum pragma_context context)
26859 : : {
26860 : 704 : c_token *token = c_parser_peek_token (parser);
26861 : 704 : gcc_assert (token->type == CPP_NAME);
26862 : 704 : tree kind = token->value;
26863 : 704 : gcc_assert (strcmp (IDENTIFIER_POINTER (kind), "simd") == 0
26864 : : || strcmp (IDENTIFIER_POINTER (kind), "variant") == 0);
26865 : :
26866 : 704 : auto_vec<c_token> clauses;
26867 : 11176 : while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
26868 : : {
26869 : 10472 : c_token *token = c_parser_peek_token (parser);
26870 : 10472 : if (token->type == CPP_EOF)
26871 : : {
26872 : 0 : c_parser_skip_to_pragma_eol (parser);
26873 : 0 : return;
26874 : : }
26875 : 10472 : clauses.safe_push (*token);
26876 : 10472 : c_parser_consume_token (parser);
26877 : : }
26878 : 704 : clauses.safe_push (*c_parser_peek_token (parser));
26879 : 704 : c_parser_skip_to_pragma_eol (parser);
26880 : :
26881 : 1612 : while (c_parser_next_token_is (parser, CPP_PRAGMA))
26882 : : {
26883 : 206 : if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_DECLARE
26884 : 204 : || c_parser_peek_2nd_token (parser)->type != CPP_NAME
26885 : 410 : || c_parser_peek_2nd_token (parser)->value != kind)
26886 : : {
26887 : 2 : error ("%<#pragma omp declare %s%> must be followed by "
26888 : : "function declaration or definition or another "
26889 : : "%<#pragma omp declare %s%>",
26890 : 2 : IDENTIFIER_POINTER (kind), IDENTIFIER_POINTER (kind));
26891 : 2 : return;
26892 : : }
26893 : 204 : c_parser_consume_pragma (parser);
26894 : 4460 : while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
26895 : : {
26896 : 4052 : c_token *token = c_parser_peek_token (parser);
26897 : 4052 : if (token->type == CPP_EOF)
26898 : : {
26899 : 0 : c_parser_skip_to_pragma_eol (parser);
26900 : 0 : return;
26901 : : }
26902 : 4052 : clauses.safe_push (*token);
26903 : 4052 : c_parser_consume_token (parser);
26904 : : }
26905 : 204 : clauses.safe_push (*c_parser_peek_token (parser));
26906 : 204 : c_parser_skip_to_pragma_eol (parser);
26907 : : }
26908 : :
26909 : : /* Make sure nothing tries to read past the end of the tokens. */
26910 : 702 : c_token eof_token;
26911 : 702 : memset (&eof_token, 0, sizeof (eof_token));
26912 : 702 : eof_token.type = CPP_EOF;
26913 : 702 : clauses.safe_push (eof_token);
26914 : 702 : clauses.safe_push (eof_token);
26915 : :
26916 : 702 : switch (context)
26917 : : {
26918 : 685 : case pragma_external:
26919 : 685 : if (c_parser_next_token_is (parser, CPP_KEYWORD)
26920 : 685 : && c_parser_peek_token (parser)->keyword == RID_EXTENSION)
26921 : : {
26922 : 1 : int ext = disable_extension_diagnostics ();
26923 : 1 : do
26924 : 1 : c_parser_consume_token (parser);
26925 : 1 : while (c_parser_next_token_is (parser, CPP_KEYWORD)
26926 : 2 : && c_parser_peek_token (parser)->keyword == RID_EXTENSION);
26927 : 1 : c_parser_declaration_or_fndef (parser, true, true, true, false, true,
26928 : : false, NULL, &clauses);
26929 : 1 : restore_extension_diagnostics (ext);
26930 : : }
26931 : : else
26932 : 684 : c_parser_declaration_or_fndef (parser, true, true, true, false, true,
26933 : : false, NULL, &clauses);
26934 : : break;
26935 : 6 : case pragma_struct:
26936 : 6 : case pragma_param:
26937 : 6 : case pragma_stmt:
26938 : 6 : error ("%<#pragma omp declare %s%> must be followed by "
26939 : : "function declaration or definition",
26940 : 6 : IDENTIFIER_POINTER (kind));
26941 : 6 : break;
26942 : 11 : case pragma_compound:
26943 : 11 : bool have_std_attrs;
26944 : 11 : tree std_attrs;
26945 : 11 : have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1);
26946 : 11 : if (have_std_attrs)
26947 : 1 : std_attrs = c_parser_std_attribute_specifier_sequence (parser);
26948 : : else
26949 : : std_attrs = NULL_TREE;
26950 : 11 : if (c_parser_next_token_is (parser, CPP_KEYWORD)
26951 : 11 : && c_parser_peek_token (parser)->keyword == RID_EXTENSION)
26952 : : {
26953 : 1 : int ext = disable_extension_diagnostics ();
26954 : 3 : do
26955 : 3 : c_parser_consume_token (parser);
26956 : 3 : while (c_parser_next_token_is (parser, CPP_KEYWORD)
26957 : 4 : && c_parser_peek_token (parser)->keyword == RID_EXTENSION);
26958 : 1 : if (c_parser_next_tokens_start_declaration (parser)
26959 : 1 : || c_parser_nth_token_starts_std_attributes (parser, 1))
26960 : : {
26961 : 1 : c_parser_declaration_or_fndef (parser, true, true, true, true,
26962 : : true, false, NULL, &clauses,
26963 : : have_std_attrs, std_attrs);
26964 : 1 : restore_extension_diagnostics (ext);
26965 : 1 : break;
26966 : : }
26967 : 0 : restore_extension_diagnostics (ext);
26968 : : }
26969 : 10 : else if (c_parser_next_tokens_start_declaration (parser))
26970 : : {
26971 : 10 : c_parser_declaration_or_fndef (parser, true, true, true, true, true,
26972 : : false, NULL, &clauses, have_std_attrs,
26973 : : std_attrs);
26974 : 10 : break;
26975 : : }
26976 : 0 : error ("%<#pragma omp declare %s%> must be followed by "
26977 : : "function declaration or definition",
26978 : 0 : IDENTIFIER_POINTER (kind));
26979 : 0 : break;
26980 : 0 : default:
26981 : 0 : gcc_unreachable ();
26982 : : }
26983 : 704 : }
26984 : :
26985 : : /* OpenMP 5.0:
26986 : :
26987 : : trait-selector:
26988 : : trait-selector-name[([trait-score:]trait-property[,trait-property[,...]])]
26989 : :
26990 : : trait-score:
26991 : : score(score-expression)
26992 : :
26993 : : Note that this function returns a list of trait selectors for the
26994 : : trait-selector-set SET. */
26995 : :
26996 : : static tree
26997 : 949 : c_parser_omp_context_selector (c_parser *parser, enum omp_tss_code set,
26998 : : tree parms)
26999 : : {
27000 : 949 : tree ret = NULL_TREE;
27001 : 1127 : do
27002 : : {
27003 : 1127 : tree selector;
27004 : 1127 : if (c_parser_next_token_is (parser, CPP_KEYWORD)
27005 : 2196 : || c_parser_next_token_is (parser, CPP_NAME))
27006 : 1125 : selector = c_parser_peek_token (parser)->value;
27007 : : else
27008 : : {
27009 : 2 : c_parser_error (parser, "expected trait selector name");
27010 : 2 : return error_mark_node;
27011 : : }
27012 : 1125 : enum omp_ts_code sel
27013 : 1125 : = omp_lookup_ts_code (set, IDENTIFIER_POINTER (selector));
27014 : :
27015 : 1125 : if (sel == OMP_TRAIT_INVALID)
27016 : : {
27017 : : /* Per the spec, "Implementations can ignore specified selectors
27018 : : that are not those described in this section"; however, we
27019 : : must record such selectors because they cause match failures. */
27020 : 18 : warning_at (c_parser_peek_token (parser)->location, OPT_Wopenmp,
27021 : : "unknown selector %qs for context selector set %qs",
27022 : 18 : IDENTIFIER_POINTER (selector), omp_tss_map[set]);
27023 : 18 : c_parser_consume_token (parser);
27024 : 18 : ret = make_trait_selector (sel, NULL_TREE, NULL_TREE, ret);
27025 : 18 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
27026 : 5 : c_parser_balanced_token_sequence (parser);
27027 : 18 : if (c_parser_next_token_is (parser, CPP_COMMA))
27028 : : {
27029 : 1 : c_parser_consume_token (parser);
27030 : 1 : continue;
27031 : : }
27032 : : else
27033 : : break;
27034 : : }
27035 : :
27036 : 1107 : c_parser_consume_token (parser);
27037 : :
27038 : 1107 : tree properties = NULL_TREE;
27039 : 1107 : tree scoreval = NULL_TREE;
27040 : 1107 : enum omp_tp_type property_kind = omp_ts_map[sel].tp_type;
27041 : 1107 : bool allow_score = omp_ts_map[sel].allow_score;
27042 : 1107 : tree t;
27043 : :
27044 : 1107 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
27045 : : {
27046 : 642 : if (property_kind == OMP_TRAIT_PROPERTY_NONE)
27047 : : {
27048 : 12 : error_at (c_parser_peek_token (parser)->location,
27049 : : "selector %qs does not accept any properties",
27050 : 6 : IDENTIFIER_POINTER (selector));
27051 : 16 : return error_mark_node;
27052 : : }
27053 : :
27054 : 636 : matching_parens parens;
27055 : 636 : parens.require_open (parser);
27056 : :
27057 : 636 : c_token *token = c_parser_peek_token (parser);
27058 : 636 : if (c_parser_next_token_is (parser, CPP_NAME)
27059 : 473 : && strcmp (IDENTIFIER_POINTER (token->value), "score") == 0
27060 : 725 : && c_parser_peek_2nd_token (parser)->type == CPP_OPEN_PAREN)
27061 : : {
27062 : 89 : c_parser_consume_token (parser);
27063 : :
27064 : 89 : matching_parens parens2;
27065 : 89 : parens2.require_open (parser);
27066 : 89 : tree score = c_parser_expr_no_commas (parser, NULL).value;
27067 : 89 : parens2.skip_until_found_close (parser);
27068 : 89 : c_parser_require (parser, CPP_COLON, "expected %<:%>");
27069 : 89 : if (!allow_score)
27070 : 13 : error_at (token->location,
27071 : : "%<score%> cannot be specified in traits "
27072 : : "in the %qs trait-selector-set",
27073 : : omp_tss_map[set]);
27074 : 76 : else if (score != error_mark_node)
27075 : : {
27076 : 76 : mark_exp_read (score);
27077 : 76 : score = c_fully_fold (score, false, NULL);
27078 : 152 : if (!INTEGRAL_TYPE_P (TREE_TYPE (score))
27079 : 151 : || TREE_CODE (score) != INTEGER_CST)
27080 : 1 : error_at (token->location, "%<score%> argument must "
27081 : : "be constant integer expression");
27082 : 75 : else if (tree_int_cst_sgn (score) < 0)
27083 : 1 : error_at (token->location, "%<score%> argument must "
27084 : : "be non-negative");
27085 : : else
27086 : : scoreval = score;
27087 : : }
27088 : 89 : token = c_parser_peek_token (parser);
27089 : : }
27090 : :
27091 : 636 : switch (property_kind)
27092 : : {
27093 : 25 : case OMP_TRAIT_PROPERTY_ID:
27094 : 25 : if (c_parser_next_token_is (parser, CPP_KEYWORD)
27095 : 50 : || c_parser_next_token_is (parser, CPP_NAME))
27096 : : {
27097 : 24 : tree prop = c_parser_peek_token (parser)->value;
27098 : 24 : c_parser_consume_token (parser);
27099 : 24 : properties = make_trait_property (prop, NULL_TREE,
27100 : : properties);
27101 : : }
27102 : : else
27103 : : {
27104 : 1 : c_parser_error (parser, "expected identifier");
27105 : 1 : return error_mark_node;
27106 : : }
27107 : 24 : break;
27108 : 523 : case OMP_TRAIT_PROPERTY_NAME_LIST:
27109 : 581 : do
27110 : : {
27111 : 523 : tree prop = OMP_TP_NAMELIST_NODE;
27112 : 523 : tree value = NULL_TREE;
27113 : 523 : if (c_parser_next_token_is (parser, CPP_KEYWORD)
27114 : 1046 : || c_parser_next_token_is (parser, CPP_NAME))
27115 : : {
27116 : 390 : value = c_parser_peek_token (parser)->value;
27117 : 390 : c_parser_consume_token (parser);
27118 : : }
27119 : 133 : else if (c_parser_next_token_is (parser, CPP_STRING))
27120 : 128 : value = c_parser_string_literal (parser, false,
27121 : : false).value;
27122 : : else
27123 : : {
27124 : 5 : c_parser_error (parser, "expected identifier or "
27125 : : "string literal");
27126 : 5 : return error_mark_node;
27127 : : }
27128 : :
27129 : 518 : properties = make_trait_property (prop, value, properties);
27130 : :
27131 : 518 : if (c_parser_next_token_is (parser, CPP_COMMA))
27132 : 58 : c_parser_consume_token (parser);
27133 : : else
27134 : : break;
27135 : 58 : }
27136 : : while (1);
27137 : : break;
27138 : 123 : case OMP_TRAIT_PROPERTY_DEV_NUM_EXPR:
27139 : 123 : case OMP_TRAIT_PROPERTY_BOOL_EXPR:
27140 : 123 : {
27141 : 123 : c_expr texpr = c_parser_expr_no_commas (parser, NULL);
27142 : 123 : texpr = convert_lvalue_to_rvalue (token->location, texpr,
27143 : : true, true);
27144 : 123 : t = texpr.value;
27145 : : }
27146 : 123 : if (t == error_mark_node)
27147 : : return error_mark_node;
27148 : 121 : mark_exp_read (t);
27149 : 121 : if (property_kind == OMP_TRAIT_PROPERTY_BOOL_EXPR)
27150 : : {
27151 : 98 : t = c_objc_common_truthvalue_conversion (token->location,
27152 : : t,
27153 : : boolean_type_node);
27154 : 98 : if (t == error_mark_node)
27155 : : return error_mark_node;
27156 : : }
27157 : 23 : else if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
27158 : : {
27159 : 0 : error_at (token->location,
27160 : : "property must be integer expression");
27161 : 0 : return error_mark_node;
27162 : : }
27163 : 119 : t = c_fully_fold (t, false, NULL);
27164 : 119 : properties = make_trait_property (NULL_TREE, t, properties);
27165 : 119 : break;
27166 : 23 : case OMP_TRAIT_PROPERTY_CLAUSE_LIST:
27167 : 23 : if (sel == OMP_TRAIT_CONSTRUCT_SIMD)
27168 : : {
27169 : 23 : if (parms == NULL_TREE)
27170 : : {
27171 : 0 : error_at (token->location, "properties for %<simd%> "
27172 : : "selector may not be specified in "
27173 : : "%<metadirective%>");
27174 : 0 : return error_mark_node;
27175 : : }
27176 : 23 : tree c;
27177 : 46 : c = c_parser_omp_all_clauses (parser,
27178 : 23 : OMP_DECLARE_SIMD_CLAUSE_MASK,
27179 : : "simd", true, 2);
27180 : 46 : c = c_omp_declare_simd_clauses_to_numbers (parms
27181 : 23 : == error_mark_node
27182 : : ? NULL_TREE : parms,
27183 : : c);
27184 : 23 : properties = c;
27185 : : }
27186 : 0 : else if (sel == OMP_TRAIT_IMPLEMENTATION_REQUIRES)
27187 : : {
27188 : : /* FIXME: The "requires" selector was added in OpenMP 5.1.
27189 : : Currently only the now-deprecated syntax
27190 : : from OpenMP 5.0 is supported. */
27191 : 0 : sorry_at (token->location,
27192 : : "%<requires%> selector is not supported yet");
27193 : 0 : return error_mark_node;
27194 : : }
27195 : : else
27196 : 0 : gcc_unreachable ();
27197 : 23 : break;
27198 : 0 : default:
27199 : 0 : gcc_unreachable ();
27200 : : }
27201 : :
27202 : 626 : parens.skip_until_found_close (parser);
27203 : 626 : properties = nreverse (properties);
27204 : : }
27205 : 465 : else if (property_kind != OMP_TRAIT_PROPERTY_NONE
27206 : 465 : && property_kind != OMP_TRAIT_PROPERTY_CLAUSE_LIST
27207 : 8 : && property_kind != OMP_TRAIT_PROPERTY_EXTENSION)
27208 : : {
27209 : 8 : c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>");
27210 : 8 : return error_mark_node;
27211 : : }
27212 : :
27213 : 1083 : ret = make_trait_selector (sel, scoreval, properties, ret);
27214 : :
27215 : 1083 : if (c_parser_next_token_is (parser, CPP_COMMA))
27216 : 177 : c_parser_consume_token (parser);
27217 : : else
27218 : : break;
27219 : : }
27220 : : while (1);
27221 : :
27222 : 923 : return nreverse (ret);
27223 : : }
27224 : :
27225 : : /* OpenMP 5.0:
27226 : :
27227 : : trait-set-selector[,trait-set-selector[,...]]
27228 : :
27229 : : trait-set-selector:
27230 : : trait-set-selector-name = { trait-selector[, trait-selector[, ...]] }
27231 : :
27232 : : trait-set-selector-name:
27233 : : constructor
27234 : : device
27235 : : implementation
27236 : : user */
27237 : :
27238 : : static tree
27239 : 731 : c_parser_omp_context_selector_specification (c_parser *parser, tree parms)
27240 : : {
27241 : 731 : tree ret = NULL_TREE;
27242 : 1183 : do
27243 : : {
27244 : 957 : const char *setp = "";
27245 : 957 : if (c_parser_next_token_is (parser, CPP_NAME))
27246 : 955 : setp = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
27247 : 957 : enum omp_tss_code set = omp_lookup_tss_code (setp);
27248 : :
27249 : 957 : if (set == OMP_TRAIT_SET_INVALID)
27250 : : {
27251 : 5 : c_parser_error (parser, "expected context selector set name");
27252 : 8 : return error_mark_node;
27253 : : }
27254 : :
27255 : 952 : c_parser_consume_token (parser);
27256 : :
27257 : 952 : if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
27258 : 1 : return error_mark_node;
27259 : :
27260 : 951 : matching_braces braces;
27261 : 951 : if (!braces.require_open (parser))
27262 : 2 : return error_mark_node;
27263 : :
27264 : 949 : tree selectors = c_parser_omp_context_selector (parser, set, parms);
27265 : 949 : if (selectors == error_mark_node)
27266 : : {
27267 : 26 : c_parser_skip_to_closing_brace (parser);
27268 : 26 : ret = error_mark_node;
27269 : : }
27270 : 923 : else if (ret != error_mark_node)
27271 : 923 : ret = make_trait_set_selector (set, selectors, ret);
27272 : :
27273 : 949 : braces.require_close (parser);
27274 : :
27275 : 949 : if (c_parser_next_token_is (parser, CPP_COMMA))
27276 : 226 : c_parser_consume_token (parser);
27277 : : else
27278 : : break;
27279 : 226 : }
27280 : : while (1);
27281 : :
27282 : 723 : if (ret == error_mark_node)
27283 : : return ret;
27284 : 697 : return nreverse (ret);
27285 : : }
27286 : :
27287 : : /* Finalize #pragma omp declare variant after FNDECL has been parsed, and put
27288 : : that into "omp declare variant base" attribute. */
27289 : :
27290 : : static void
27291 : 614 : c_finish_omp_declare_variant (c_parser *parser, tree fndecl, tree parms)
27292 : : {
27293 : 614 : matching_parens parens;
27294 : 614 : if (!parens.require_open (parser))
27295 : : {
27296 : 3 : fail:
27297 : 50 : c_parser_skip_to_pragma_eol (parser, false);
27298 : 50 : return;
27299 : : }
27300 : :
27301 : 611 : if (c_parser_next_token_is_not (parser, CPP_NAME)
27302 : 611 : || c_parser_peek_token (parser)->id_kind != C_ID_ID)
27303 : : {
27304 : 3 : c_parser_error (parser, "expected identifier");
27305 : 3 : goto fail;
27306 : : }
27307 : :
27308 : 608 : c_token *token = c_parser_peek_token (parser);
27309 : 608 : tree variant = lookup_name (token->value);
27310 : :
27311 : 608 : if (variant == NULL_TREE)
27312 : : {
27313 : 3 : undeclared_variable (token->location, token->value);
27314 : 3 : variant = error_mark_node;
27315 : : }
27316 : 605 : else if (TREE_CODE (variant) != FUNCTION_DECL)
27317 : : {
27318 : 1 : error_at (token->location, "variant %qD is not a function",
27319 : : variant);
27320 : 1 : variant = error_mark_node;
27321 : : }
27322 : 604 : else if (fndecl_built_in_p (variant)
27323 : 604 : && (strncmp (IDENTIFIER_POINTER (DECL_NAME (variant)),
27324 : : "__builtin_", strlen ("__builtin_")) == 0
27325 : 0 : || strncmp (IDENTIFIER_POINTER (DECL_NAME (variant)),
27326 : : "__sync_", strlen ("__sync_")) == 0
27327 : 0 : || strncmp (IDENTIFIER_POINTER (DECL_NAME (variant)),
27328 : : "__atomic_", strlen ("__atomic_")) == 0))
27329 : : {
27330 : 1 : error_at (token->location, "variant %qD is a built-in",
27331 : : variant);
27332 : 1 : variant = error_mark_node;
27333 : : }
27334 : 603 : else if (variant == fndecl)
27335 : : {
27336 : 2 : error_at (token->location, "variant %qD is the same as base function",
27337 : : variant);
27338 : 2 : variant = error_mark_node;
27339 : : }
27340 : :
27341 : 608 : c_parser_consume_token (parser);
27342 : :
27343 : 608 : parens.require_close (parser);
27344 : :
27345 : 608 : tree append_args_tree = NULL_TREE;
27346 : 608 : tree append_args_last;
27347 : 608 : vec<tree> adjust_args_list = vNULL;
27348 : 608 : bool has_match = false, has_adjust_args = false;
27349 : 608 : location_t adjust_args_loc = UNKNOWN_LOCATION;
27350 : 608 : location_t append_args_loc = UNKNOWN_LOCATION;
27351 : 608 : location_t match_loc = UNKNOWN_LOCATION;
27352 : 608 : tree need_device_ptr_list = NULL_TREE;
27353 : 608 : tree ctx = error_mark_node;
27354 : :
27355 : 707 : do
27356 : : {
27357 : 707 : if (c_parser_next_token_is (parser, CPP_COMMA)
27358 : 707 : && c_parser_peek_2nd_token (parser)->type == CPP_NAME)
27359 : 9 : c_parser_consume_token (parser);
27360 : :
27361 : 707 : const char *clause = "";
27362 : 707 : location_t loc = c_parser_peek_token (parser)->location;
27363 : 707 : if (c_parser_next_token_is (parser, CPP_NAME))
27364 : 706 : clause = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
27365 : :
27366 : 707 : enum clause
27367 : : {
27368 : : match,
27369 : : adjust_args,
27370 : : append_args
27371 : : } ccode;
27372 : :
27373 : 707 : if (strcmp (clause, "match") == 0)
27374 : : {
27375 : : ccode = match;
27376 : : match_loc = loc;
27377 : : }
27378 : 102 : else if (strcmp (clause, "adjust_args") == 0)
27379 : : {
27380 : : ccode = adjust_args;
27381 : : adjust_args_loc = loc;
27382 : : }
27383 : 50 : else if (strcmp (clause, "append_args") == 0)
27384 : : {
27385 : : ccode = append_args;
27386 : : append_args_loc = loc;
27387 : : }
27388 : : else
27389 : : {
27390 : 2 : c_parser_error (parser, "expected %<match%>, %<adjust_args%> or "
27391 : : "%<append_args%> clause");
27392 : 2 : goto fail;
27393 : : }
27394 : :
27395 : 705 : c_parser_consume_token (parser);
27396 : :
27397 : 705 : if (!parens.require_open (parser))
27398 : 1 : goto fail;
27399 : :
27400 : 704 : if (parms == NULL_TREE)
27401 : 447 : parms = error_mark_node;
27402 : :
27403 : 704 : if (ccode == match)
27404 : : {
27405 : 604 : if (has_match)
27406 : 1 : error_at (match_loc, "too many %<match%> clauses");
27407 : 604 : has_match = true;
27408 : 604 : ctx = c_parser_omp_context_selector_specification (parser, parms);
27409 : 604 : if (ctx == error_mark_node)
27410 : 32 : goto fail;
27411 : 572 : ctx = omp_check_context_selector (match_loc, ctx,
27412 : : OMP_CTX_DECLARE_VARIANT);
27413 : : }
27414 : 100 : else if (ccode == adjust_args)
27415 : : {
27416 : 52 : has_adjust_args = true;
27417 : 52 : if (c_parser_next_token_is (parser, CPP_NAME)
27418 : 52 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
27419 : : {
27420 : 50 : const char *p
27421 : 50 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
27422 : 50 : if (strcmp (p, "need_device_ptr") == 0
27423 : 15 : || strcmp (p, "nothing") == 0)
27424 : : {
27425 : 48 : c_parser_consume_token (parser); // need_device_ptr
27426 : 48 : c_parser_consume_token (parser); // :
27427 : :
27428 : 48 : loc = c_parser_peek_token (parser)->location;
27429 : 48 : tree list
27430 : 48 : = c_parser_omp_variable_list (parser, loc, OMP_CLAUSE_ERROR,
27431 : : NULL_TREE);
27432 : :
27433 : 48 : tree arg;
27434 : 48 : if (variant != error_mark_node)
27435 : 103 : for (tree c = list; c != NULL_TREE; c = TREE_CHAIN (c))
27436 : : {
27437 : 61 : tree decl = TREE_PURPOSE (c);
27438 : 61 : location_t arg_loc = EXPR_LOCATION (TREE_VALUE (c));
27439 : 61 : int idx;
27440 : 111 : for (arg = parms, idx = 0; arg != NULL;
27441 : 50 : arg = TREE_CHAIN (arg), idx++)
27442 : 110 : if (arg == decl)
27443 : : break;
27444 : 61 : if (arg == NULL_TREE)
27445 : : {
27446 : 1 : error_at (arg_loc,
27447 : : "%qD is not a function argument",
27448 : : decl);
27449 : 5 : goto fail;
27450 : : }
27451 : 60 : if (adjust_args_list.contains (arg))
27452 : : {
27453 : 3 : error_at (arg_loc,
27454 : : "%qD is specified more than once",
27455 : : decl);
27456 : 3 : goto fail;
27457 : : }
27458 : 57 : if (strcmp (p, "need_device_ptr") == 0
27459 : 57 : && TREE_CODE (TREE_TYPE (arg)) != POINTER_TYPE)
27460 : : {
27461 : 1 : error_at (loc, "%qD is not of pointer type", decl);
27462 : 1 : goto fail;
27463 : : }
27464 : 56 : adjust_args_list.safe_push (arg);
27465 : 56 : if (strcmp (p, "need_device_ptr") == 0)
27466 : : {
27467 : 46 : need_device_ptr_list = chainon (
27468 : : need_device_ptr_list,
27469 : : build_tree_list (
27470 : : NULL_TREE,
27471 : : build_int_cst (
27472 : : integer_type_node,
27473 : 46 : idx))); // Store 0-based argument index,
27474 : : // as in gimplify_call_expr
27475 : : }
27476 : : }
27477 : 43 : }
27478 : : else
27479 : : {
27480 : 2 : error_at (c_parser_peek_token (parser)->location,
27481 : : "expected %<nothing%> or %<need_device_ptr%>");
27482 : 2 : if (strcmp (p, "need_device_addr") == 0)
27483 : 1 : inform (c_parser_peek_token (parser)->location,
27484 : : "%<need_device_addr%> is not valid for C");
27485 : 2 : goto fail;
27486 : : }
27487 : : }
27488 : : else
27489 : : {
27490 : 2 : error_at (c_parser_peek_token (parser)->location,
27491 : : "expected %<nothing%> or %<need_device_ptr%> "
27492 : : "followed by %<:%>");
27493 : 2 : goto fail;
27494 : : }
27495 : : }
27496 : 48 : else if (ccode == append_args)
27497 : : {
27498 : 48 : if (append_args_tree)
27499 : : {
27500 : 1 : error_at (append_args_loc, "too many %qs clauses", "append_args");
27501 : 1 : append_args_tree = NULL_TREE;
27502 : : }
27503 : 86 : do
27504 : : {
27505 : 67 : location_t loc = c_parser_peek_token (parser)->location;
27506 : 67 : if (!c_parser_next_token_is (parser, CPP_NAME)
27507 : 67 : || strcmp ("interop",
27508 : 67 : IDENTIFIER_POINTER (
27509 : : c_parser_peek_token (parser)->value)))
27510 : : {
27511 : 0 : error_at (loc, "expected %<interop%>");
27512 : 0 : goto fail;
27513 : : }
27514 : 67 : c_parser_consume_token (parser);
27515 : :
27516 : 67 : if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
27517 : 0 : goto fail;
27518 : 67 : bool target = false;
27519 : 67 : bool targetsync = false;
27520 : 67 : tree prefer_type_tree = NULL_TREE;
27521 : 67 : if (!c_parser_omp_clause_init_modifiers (parser, &target,
27522 : : &targetsync,
27523 : : &prefer_type_tree)
27524 : 67 : || !c_parser_require (parser, CPP_CLOSE_PAREN,
27525 : : "expected %<)%> or %<,%>"))
27526 : 0 : goto fail;
27527 : 67 : if (!target && !targetsync)
27528 : 3 : error_at (loc,
27529 : : "missing required %<target%> and/or "
27530 : : "%<targetsync%> modifier");
27531 : 67 : tree t = build_tree_list (target ? boolean_true_node
27532 : : : boolean_false_node,
27533 : : targetsync ? boolean_true_node
27534 : : : boolean_false_node);
27535 : 67 : t = build1_loc (loc, NOP_EXPR, void_type_node, t);
27536 : 67 : t = build_tree_list (t, prefer_type_tree);
27537 : 67 : if (append_args_tree)
27538 : : {
27539 : 19 : TREE_CHAIN (append_args_last) = t;
27540 : 19 : append_args_last = t;
27541 : : }
27542 : : else
27543 : : append_args_tree = append_args_last = t;
27544 : 67 : if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
27545 : : break;
27546 : 19 : if (!c_parser_require (parser, CPP_COMMA, "expected %<)%> or %<,%>"))
27547 : 0 : goto fail;
27548 : 19 : }
27549 : : while (true);
27550 : : }
27551 : :
27552 : 663 : parens.require_close (parser);
27553 : 663 : } while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL));
27554 : 564 : if (variant != error_mark_node && !has_match)
27555 : : {
27556 : 1 : c_parser_error (parser, "expected %<match%> clause");
27557 : 1 : variant = error_mark_node;
27558 : : }
27559 : 564 : c_parser_skip_to_pragma_eol (parser);
27560 : :
27561 : : /* At this point, we have completed parsing of the pragma, now it's
27562 : : on to error checking. */
27563 : 564 : if (variant == error_mark_node || ctx == error_mark_node)
27564 : : /* Previously diagnosed error. */
27565 : : return;
27566 : :
27567 : 534 : if ((has_adjust_args || append_args_tree)
27568 : 534 : && !omp_get_context_selector (ctx, OMP_TRAIT_SET_CONSTRUCT,
27569 : : OMP_TRAIT_CONSTRUCT_DISPATCH))
27570 : : {
27571 : 1 : error_at (has_adjust_args ? adjust_args_loc : append_args_loc,
27572 : : "an %qs clause can only be specified if the "
27573 : : "%<dispatch%> selector of the %<construct%> selector "
27574 : : "set appears in the %<match%> clause",
27575 : : has_adjust_args ? "adjust_args" : "append_args");
27576 : 1 : return;
27577 : : }
27578 : :
27579 : 533 : if (!omp_get_context_selector (ctx, OMP_TRAIT_SET_CONSTRUCT,
27580 : : OMP_TRAIT_CONSTRUCT_SIMD))
27581 : : /* Check that the base and variant have compatible types. */
27582 : : {
27583 : 510 : tree base_type = TREE_TYPE (fndecl);
27584 : 510 : tree variant_type = TREE_TYPE (variant);
27585 : 510 : bool unprototyped_variant
27586 : 510 : = (TYPE_ARG_TYPES (variant_type) == NULL_TREE
27587 : 510 : && !TYPE_NO_NAMED_ARGS_STDARG_P (variant_type));
27588 : :
27589 : 510 : if (append_args_tree
27590 : 47 : && TYPE_ARG_TYPES (base_type) == NULL_TREE
27591 : 518 : && !TYPE_NO_NAMED_ARGS_STDARG_P (base_type))
27592 : : {
27593 : : /* The base function is a pre-C23 unprototyped function. Without
27594 : : a prototype, we don't know the offset where the append_args go.
27595 : : That offset needs to be stored with the append_args in the
27596 : : variant function attributes, so we cannot presently handle
27597 : : this case. */
27598 : 6 : sorry_at (append_args_loc,
27599 : : "%<append_args%> with unprototyped base function "
27600 : : "is not supported yet");
27601 : 6 : inform (DECL_SOURCE_LOCATION (fndecl),
27602 : : "base function %qD declared here", fndecl);
27603 : 6 : return;
27604 : : }
27605 : 504 : else if (append_args_tree)
27606 : : {
27607 : : /* Find nbase_args, the number of fixed arguments in the base
27608 : : function. */
27609 : 41 : int nappend_args = 0;
27610 : 41 : int nbase_args = 0;
27611 : 41 : for (tree t = TYPE_ARG_TYPES (base_type);
27612 : 183 : t && TREE_VALUE (t) != void_type_node; t = TREE_CHAIN (t))
27613 : 55 : nbase_args++;
27614 : 101 : for (tree t = append_args_tree; t; t = TREE_CHAIN (t))
27615 : 60 : nappend_args++;
27616 : :
27617 : : /* Store as purpose = arg number after which to append
27618 : : and value = list of interop items. */
27619 : 41 : append_args_tree = build_tree_list (build_int_cst (integer_type_node,
27620 : 41 : nbase_args),
27621 : : append_args_tree);
27622 : :
27623 : : /* Give a specific diagnostic if the append_args parameters
27624 : : of the variant are of the wrong type, or missing. The
27625 : : compatible types test below could fail to detect this if
27626 : : the variant is a varargs function. */
27627 : 41 : if (!unprototyped_variant)
27628 : : {
27629 : 39 : tree args = TYPE_ARG_TYPES (variant_type);
27630 : 90 : for (int i = 0; args && i < nbase_args;
27631 : 51 : i++, args = TREE_CHAIN (args))
27632 : : ;
27633 : 89 : for (int i = 0; i < nappend_args; i++, args = TREE_CHAIN (args))
27634 : 109 : if (!args || !c_omp_interop_t_p (TREE_VALUE (args)))
27635 : : {
27636 : 5 : error_at (DECL_SOURCE_LOCATION (variant),
27637 : : "argument %d of %qD must be of "
27638 : : "%<omp_interop_t%>",
27639 : 5 : nbase_args + i + 1, variant);
27640 : 5 : inform (append_args_loc,
27641 : : "%<append_args%> specified here");
27642 : 100 : return;
27643 : : }
27644 : : }
27645 : :
27646 : : /* Perform the "implementation defined transformation" on the type
27647 : : of the base function to add the append_args before checking it
27648 : : for compatibility with the function variant's type. */
27649 : 36 : tree args = TYPE_ARG_TYPES (base_type);
27650 : 36 : tree newargs = NULL_TREE;
27651 : 36 : tree lastarg = NULL_TREE;
27652 : 89 : for (int j = 0; j < nbase_args; j++, args = TREE_CHAIN (args))
27653 : : {
27654 : 53 : tree t = tree_cons (TREE_PURPOSE (args),
27655 : 53 : TREE_VALUE (args), NULL_TREE);
27656 : 53 : if (lastarg)
27657 : 31 : TREE_CHAIN (lastarg) = t;
27658 : : else
27659 : : newargs = t;
27660 : 53 : lastarg = t;
27661 : : }
27662 : 36 : tree type = lookup_name (get_identifier ("omp_interop_t"));
27663 : 36 : type = type ? TREE_TYPE (type) : pointer_sized_int_node;
27664 : 87 : for (int j = 0; j < nappend_args; j++)
27665 : : {
27666 : 51 : tree t = tree_cons (NULL_TREE, type, NULL_TREE);
27667 : 51 : if (lastarg)
27668 : 37 : TREE_CHAIN (lastarg) = t;
27669 : : else
27670 : : newargs = t;
27671 : 51 : lastarg = t;
27672 : : }
27673 : 36 : TREE_CHAIN (lastarg) = args;
27674 : :
27675 : : /* Temporarily stuff newargs into the original base_type. */
27676 : 36 : tree saveargs = TYPE_ARG_TYPES (base_type);
27677 : 36 : TYPE_ARG_TYPES (base_type) = newargs;
27678 : 36 : bool fail = !comptypes (base_type, variant_type);
27679 : 36 : TYPE_ARG_TYPES (base_type) = saveargs;
27680 : :
27681 : 36 : if (fail)
27682 : : {
27683 : 2 : error_at (token->location,
27684 : : "variant %qD and base %qD have incompatible types "
27685 : : "after %<append_args%> adjustment",
27686 : : variant, fndecl);
27687 : 2 : inform (DECL_SOURCE_LOCATION (variant),
27688 : : "%<declare variant%> candidate %qD declared here",
27689 : : variant);
27690 : 2 : return;
27691 : : }
27692 : 34 : else if (unprototyped_variant)
27693 : : /* If we've got an unprototyped variant, copy the transformed
27694 : : base arg types to the variant. This is needed later by
27695 : : modify_call_for_omp_dispatch. */
27696 : 2 : TYPE_ARG_TYPES (variant_type) = newargs;
27697 : : }
27698 : : else /* No append_args present. */
27699 : : {
27700 : 463 : if (!comptypes (base_type, variant_type))
27701 : : {
27702 : 1 : error_at (token->location,
27703 : : "variant %qD and base %qD have incompatible types",
27704 : : variant, fndecl);
27705 : 1 : inform (DECL_SOURCE_LOCATION (variant),
27706 : : "%<declare variant%> candidate %qD declared here",
27707 : : variant);
27708 : 1 : return;
27709 : : }
27710 : 462 : else if (TYPE_ARG_TYPES (variant_type) == NULL_TREE
27711 : 3 : && !TYPE_NO_NAMED_ARGS_STDARG_P (variant_type)
27712 : 464 : && TYPE_ARG_TYPES (base_type) != NULL_TREE)
27713 : : /* If we've got an unprototyped variant but the base has
27714 : : a prototype, copy the base arg types to the variant. */
27715 : 1 : TYPE_ARG_TYPES (variant_type) = TYPE_ARG_TYPES (base_type);
27716 : : }
27717 : : }
27718 : :
27719 : : /* If we made it here, store the parsed information. */
27720 : 519 : C_DECL_USED (variant) = 1;
27721 : 519 : tree construct = omp_get_context_selector_list (ctx,
27722 : : OMP_TRAIT_SET_CONSTRUCT);
27723 : 519 : omp_mark_declare_variant (match_loc, variant, construct);
27724 : 519 : if (omp_context_selector_matches (ctx, NULL_TREE, false))
27725 : : {
27726 : 243 : tree attr = tree_cons (get_identifier ("omp declare variant base"),
27727 : : build_tree_list (variant, ctx),
27728 : 243 : DECL_ATTRIBUTES (fndecl));
27729 : 243 : DECL_ATTRIBUTES (fndecl) = attr;
27730 : : }
27731 : :
27732 : 519 : if (need_device_ptr_list || append_args_tree)
27733 : : {
27734 : 49 : tree variant_decl = tree_strip_nop_conversions (variant);
27735 : 49 : tree t = build_tree_list (need_device_ptr_list,
27736 : : NULL_TREE /* need_device_addr */);
27737 : 49 : TREE_CHAIN (t) = append_args_tree;
27738 : 49 : DECL_ATTRIBUTES (variant_decl)
27739 : 98 : = tree_cons (get_identifier ("omp declare variant variant args"), t,
27740 : 49 : DECL_ATTRIBUTES (variant_decl));
27741 : : }
27742 : : }
27743 : :
27744 : : /* Finalize #pragma omp declare simd or #pragma omp declare variant
27745 : : clauses after FNDECL has been parsed, and put that into "omp declare simd"
27746 : : or "omp declare variant base" attribute. */
27747 : :
27748 : : static void
27749 : 776 : c_finish_omp_declare_simd (c_parser *parser, tree fndecl, tree parms,
27750 : : vec<c_token> *pclauses)
27751 : : {
27752 : 776 : vec<c_token> &clauses = *pclauses;
27753 : :
27754 : : /* Normally first token is CPP_NAME "simd" or "variant". CPP_EOF there
27755 : : indicates error has been reported and CPP_PRAGMA that
27756 : : c_finish_omp_declare_simd has already processed the tokens. */
27757 : 1552 : if (clauses.exists () && clauses[0].type == CPP_EOF)
27758 : : return;
27759 : 772 : const char *kind = "simd";
27760 : 772 : if (clauses.exists ()
27761 : 1544 : && (clauses[0].type == CPP_NAME || clauses[0].type == CPP_PRAGMA))
27762 : 772 : kind = IDENTIFIER_POINTER (clauses[0].value);
27763 : 772 : gcc_assert (strcmp (kind, "simd") == 0 || strcmp (kind, "variant") == 0);
27764 : 772 : if (fndecl == NULL_TREE || TREE_CODE (fndecl) != FUNCTION_DECL)
27765 : : {
27766 : 15 : error ("%<#pragma omp declare %s%> not immediately followed by "
27767 : : "a function declaration or definition", kind);
27768 : 15 : clauses[0].type = CPP_EOF;
27769 : 15 : return;
27770 : : }
27771 : 1514 : if (clauses.exists () && clauses[0].type != CPP_NAME)
27772 : : {
27773 : 2 : error_at (DECL_SOURCE_LOCATION (fndecl),
27774 : : "%<#pragma omp declare %s%> not immediately followed by "
27775 : : "a single function declaration or definition", kind);
27776 : 2 : clauses[0].type = CPP_EOF;
27777 : 2 : return;
27778 : : }
27779 : :
27780 : 755 : if (parms == NULL_TREE)
27781 : 519 : parms = DECL_ARGUMENTS (fndecl);
27782 : :
27783 : 755 : unsigned int tokens_avail = parser->tokens_avail;
27784 : 755 : gcc_assert (parser->tokens == &parser->tokens_buf[0]);
27785 : :
27786 : 755 : parser->tokens = clauses.address ();
27787 : 755 : parser->tokens_avail = clauses.length ();
27788 : :
27789 : : /* c_parser_omp_declare_simd pushed 2 extra CPP_EOF tokens at the end. */
27790 : 1732 : while (parser->tokens_avail > 3)
27791 : : {
27792 : 977 : c_token *token = c_parser_peek_token (parser);
27793 : 977 : gcc_assert (token->type == CPP_NAME);
27794 : 977 : kind = IDENTIFIER_POINTER (token->value);
27795 : 977 : c_parser_consume_token (parser);
27796 : 977 : parser->in_pragma = true;
27797 : :
27798 : 977 : if (strcmp (kind, "simd") == 0)
27799 : : {
27800 : 363 : tree c;
27801 : 363 : c = c_parser_omp_all_clauses (parser, OMP_DECLARE_SIMD_CLAUSE_MASK,
27802 : : "#pragma omp declare simd");
27803 : 363 : c = c_omp_declare_simd_clauses_to_numbers (parms, c);
27804 : 363 : if (c != NULL_TREE)
27805 : 258 : c = tree_cons (NULL_TREE, c, NULL_TREE);
27806 : 363 : c = build_tree_list (get_identifier ("omp declare simd"), c);
27807 : 363 : TREE_CHAIN (c) = DECL_ATTRIBUTES (fndecl);
27808 : 363 : DECL_ATTRIBUTES (fndecl) = c;
27809 : : }
27810 : : else
27811 : : {
27812 : 614 : gcc_assert (strcmp (kind, "variant") == 0);
27813 : 614 : c_finish_omp_declare_variant (parser, fndecl, parms);
27814 : : }
27815 : : }
27816 : :
27817 : 755 : parser->tokens = &parser->tokens_buf[0];
27818 : 755 : parser->tokens_avail = tokens_avail;
27819 : 755 : if (clauses.exists ())
27820 : 755 : clauses[0].type = CPP_PRAGMA;
27821 : : }
27822 : :
27823 : : /* D should be C_TOKEN_VEC from omp::decl attribute. If it contains
27824 : : a threadprivate, groupprivate, allocate or declare target directive,
27825 : : return true and parse it for DECL. */
27826 : :
27827 : : bool
27828 : 38 : c_maybe_parse_omp_decl (tree decl, tree d)
27829 : : {
27830 : 38 : gcc_assert (TREE_CODE (d) == C_TOKEN_VEC);
27831 : 38 : vec<c_token, va_gc> *toks = C_TOKEN_VEC_TOKENS (d);
27832 : 38 : c_token *first = toks->address ();
27833 : 38 : c_token *last = first + toks->length ();
27834 : 38 : const char *directive[3] = {};
27835 : 109 : for (int j = 0; j < 3; j++)
27836 : : {
27837 : 97 : tree id = NULL_TREE;
27838 : 97 : if (first + j == last)
27839 : : break;
27840 : 78 : if (first[j].type == CPP_NAME)
27841 : 71 : id = first[j].value;
27842 : 7 : else if (first[j].type == CPP_KEYWORD)
27843 : 0 : id = ridpointers[(int) first[j].keyword];
27844 : : else
27845 : : break;
27846 : 71 : directive[j] = IDENTIFIER_POINTER (id);
27847 : : }
27848 : 38 : const c_omp_directive *dir = NULL;
27849 : 38 : if (directive[0])
27850 : 38 : dir = c_omp_categorize_directive (directive[0], directive[1],
27851 : : directive[2]);
27852 : 38 : if (dir == NULL)
27853 : : {
27854 : 0 : error_at (first->location,
27855 : : "unknown OpenMP directive name in "
27856 : : "%qs attribute argument", "omp::decl");
27857 : 0 : return false;
27858 : : }
27859 : 38 : if (dir->id != PRAGMA_OMP_THREADPRIVATE
27860 : : /* && dir->id != PRAGMA_OMP_GROUPPRIVATE */
27861 : 23 : && dir->id != PRAGMA_OMP_ALLOCATE
27862 : 21 : && (dir->id != PRAGMA_OMP_DECLARE
27863 : 21 : || strcmp (directive[1], "target") != 0))
27864 : : return false;
27865 : :
27866 : 38 : if (!flag_openmp && !dir->simd)
27867 : : return true;
27868 : :
27869 : 38 : c_parser *parser = the_parser;
27870 : 38 : unsigned int tokens_avail = parser->tokens_avail;
27871 : 38 : gcc_assert (parser->tokens == &parser->tokens_buf[0]);
27872 : 38 : toks = NULL;
27873 : 38 : vec_safe_reserve (toks, last - first + 2, true);
27874 : 38 : c_token tok = {};
27875 : 38 : tok.type = CPP_PRAGMA;
27876 : 38 : tok.keyword = RID_MAX;
27877 : 38 : tok.pragma_kind = pragma_kind (dir->id);
27878 : 38 : tok.location = first->location;
27879 : 38 : toks->quick_push (tok);
27880 : 176 : while (++first < last)
27881 : 100 : toks->quick_push (*first);
27882 : 38 : tok = {};
27883 : 38 : tok.type = CPP_PRAGMA_EOL;
27884 : 38 : tok.keyword = RID_MAX;
27885 : 38 : tok.location = last[-1].location;
27886 : 38 : toks->quick_push (tok);
27887 : 38 : tok = {};
27888 : 38 : tok.type = CPP_EOF;
27889 : 38 : tok.keyword = RID_MAX;
27890 : 38 : tok.location = last[-1].location;
27891 : 38 : toks->quick_push (tok);
27892 : 38 : parser->in_omp_decl_attribute = decl;
27893 : 38 : gcc_assert (!parser->in_omp_attribute_pragma);
27894 : 38 : parser->in_omp_attribute_pragma = ggc_alloc<omp_attribute_pragma_state> ();
27895 : 38 : parser->in_omp_attribute_pragma->token_vec = toks;
27896 : 38 : parser->in_omp_attribute_pragma->save_tokens = parser->tokens;
27897 : 38 : parser->in_omp_attribute_pragma->save_tokens_avail = tokens_avail;
27898 : 38 : parser->tokens = toks->address ();
27899 : 38 : parser->tokens_avail = toks->length ();
27900 : 38 : c_parser_pragma (parser, pragma_external, NULL, NULL_TREE);
27901 : 38 : parser->in_omp_decl_attribute = NULL_TREE;
27902 : 38 : return true;
27903 : : }
27904 : :
27905 : : /* OpenMP 4.0:
27906 : : # pragma omp declare target new-line
27907 : : declarations and definitions
27908 : : # pragma omp end declare target new-line
27909 : :
27910 : : OpenMP 4.5:
27911 : : # pragma omp declare target ( extended-list ) new-line
27912 : :
27913 : : # pragma omp declare target declare-target-clauses[seq] new-line */
27914 : :
27915 : : #define OMP_DECLARE_TARGET_CLAUSE_MASK \
27916 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
27917 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ENTER) \
27918 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK) \
27919 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \
27920 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT))
27921 : :
27922 : : static void
27923 : 273 : c_parser_omp_declare_target (c_parser *parser)
27924 : : {
27925 : 273 : tree clauses = NULL_TREE;
27926 : 273 : int device_type = 0;
27927 : 273 : bool indirect = false;
27928 : 273 : bool only_device_type_or_indirect = true;
27929 : 273 : if (flag_openmp)
27930 : 273 : omp_requires_mask
27931 : 273 : = (enum omp_requires) (omp_requires_mask | OMP_REQUIRES_TARGET_USED);
27932 : 273 : if (c_parser_next_token_is (parser, CPP_NAME)
27933 : 407 : || (c_parser_next_token_is (parser, CPP_COMMA)
27934 : 5 : && c_parser_peek_2nd_token (parser)->type == CPP_NAME))
27935 : 143 : clauses = c_parser_omp_all_clauses (parser, OMP_DECLARE_TARGET_CLAUSE_MASK,
27936 : : "#pragma omp declare target");
27937 : 130 : else if (parser->in_omp_decl_attribute
27938 : 254 : || c_parser_next_token_is (parser, CPP_OPEN_PAREN))
27939 : : {
27940 : 20 : clauses = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ENTER,
27941 : : clauses);
27942 : 20 : clauses = c_finish_omp_clauses (clauses, C_ORT_OMP);
27943 : 20 : c_parser_skip_to_pragma_eol (parser);
27944 : : }
27945 : : else
27946 : : {
27947 : 110 : bool attr_syntax = parser->in_omp_attribute_pragma != NULL;
27948 : 110 : c_parser_skip_to_pragma_eol (parser);
27949 : 110 : c_omp_declare_target_attr attr = { attr_syntax, -1, 0 };
27950 : 110 : vec_safe_push (current_omp_declare_target_attribute, attr);
27951 : 110 : return;
27952 : : }
27953 : 412 : for (tree c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
27954 : : {
27955 : 249 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEVICE_TYPE)
27956 : 27 : device_type |= OMP_CLAUSE_DEVICE_TYPE_KIND (c);
27957 : 249 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_INDIRECT)
27958 : 16 : indirect |= !integer_zerop (OMP_CLAUSE_INDIRECT_EXPR (c));
27959 : : }
27960 : 412 : for (tree c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
27961 : : {
27962 : 249 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEVICE_TYPE
27963 : 249 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_INDIRECT)
27964 : 249 : continue;
27965 : 206 : tree t = OMP_CLAUSE_DECL (c), id;
27966 : 206 : tree at1 = lookup_attribute ("omp declare target", DECL_ATTRIBUTES (t));
27967 : 206 : tree at2 = lookup_attribute ("omp declare target link",
27968 : 206 : DECL_ATTRIBUTES (t));
27969 : 206 : only_device_type_or_indirect = false;
27970 : 206 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINK)
27971 : : {
27972 : 34 : id = get_identifier ("omp declare target link");
27973 : 34 : std::swap (at1, at2);
27974 : : }
27975 : : else
27976 : 172 : id = get_identifier ("omp declare target");
27977 : 206 : if (at2)
27978 : : {
27979 : 6 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_ENTER)
27980 : 3 : error_at (OMP_CLAUSE_LOCATION (c),
27981 : : "%qD specified both in declare target %<link%> and %qs"
27982 : 3 : " clauses", t, OMP_CLAUSE_ENTER_TO (c) ? "to" : "enter");
27983 : : else
27984 : 3 : error_at (OMP_CLAUSE_LOCATION (c),
27985 : : "%qD specified both in declare target %<link%> and "
27986 : : "%<to%> or %<enter%> clauses", t);
27987 : 6 : continue;
27988 : : }
27989 : 200 : if (!at1)
27990 : : {
27991 : 171 : DECL_ATTRIBUTES (t) = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (t));
27992 : 171 : if (TREE_CODE (t) != FUNCTION_DECL && !is_global_var (t))
27993 : 1 : continue;
27994 : :
27995 : 170 : symtab_node *node = symtab_node::get (t);
27996 : 170 : if (node != NULL)
27997 : : {
27998 : 123 : node->offloadable = 1;
27999 : 123 : if (ENABLE_OFFLOADING)
28000 : : {
28001 : : g->have_offload = true;
28002 : : if (is_a <varpool_node *> (node))
28003 : : vec_safe_push (offload_vars, t);
28004 : : }
28005 : : }
28006 : : }
28007 : 199 : if (TREE_CODE (t) != FUNCTION_DECL)
28008 : 121 : continue;
28009 : 78 : if ((device_type & OMP_CLAUSE_DEVICE_TYPE_HOST) != 0)
28010 : : {
28011 : 13 : tree at3 = lookup_attribute ("omp declare target host",
28012 : 13 : DECL_ATTRIBUTES (t));
28013 : 13 : if (at3 == NULL_TREE)
28014 : : {
28015 : 11 : id = get_identifier ("omp declare target host");
28016 : 11 : DECL_ATTRIBUTES (t)
28017 : 22 : = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (t));
28018 : : }
28019 : : }
28020 : 78 : if ((device_type & OMP_CLAUSE_DEVICE_TYPE_NOHOST) != 0)
28021 : : {
28022 : 13 : tree at3 = lookup_attribute ("omp declare target nohost",
28023 : 13 : DECL_ATTRIBUTES (t));
28024 : 13 : if (at3 == NULL_TREE)
28025 : : {
28026 : 11 : id = get_identifier ("omp declare target nohost");
28027 : 11 : DECL_ATTRIBUTES (t)
28028 : 22 : = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (t));
28029 : : }
28030 : : }
28031 : 78 : if (indirect)
28032 : : {
28033 : 9 : tree at4 = lookup_attribute ("omp declare target indirect",
28034 : 9 : DECL_ATTRIBUTES (t));
28035 : 9 : if (at4 == NULL_TREE)
28036 : : {
28037 : 9 : id = get_identifier ("omp declare target indirect");
28038 : 9 : DECL_ATTRIBUTES (t)
28039 : 18 : = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (t));
28040 : : }
28041 : : }
28042 : : }
28043 : 163 : if ((device_type || indirect) && only_device_type_or_indirect)
28044 : 3 : error_at (OMP_CLAUSE_LOCATION (clauses),
28045 : : "directive with only %<device_type%> or %<indirect%> clauses");
28046 : 163 : if (indirect && device_type && device_type != OMP_CLAUSE_DEVICE_TYPE_ANY)
28047 : 1 : error_at (OMP_CLAUSE_LOCATION (clauses),
28048 : : "%<device_type%> clause must specify 'any' when used with "
28049 : : "an %<indirect%> clause");
28050 : : }
28051 : :
28052 : : /* OpenMP 5.1
28053 : : #pragma omp begin assumes clauses[optseq] new-line
28054 : :
28055 : : #pragma omp begin declare target clauses[optseq] new-line */
28056 : :
28057 : : #define OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK \
28058 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \
28059 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT))
28060 : :
28061 : : static void
28062 : 91 : c_parser_omp_begin (c_parser *parser)
28063 : : {
28064 : 91 : const char *p = "";
28065 : 91 : c_parser_consume_pragma (parser);
28066 : 91 : if (c_parser_next_token_is (parser, CPP_NAME))
28067 : 91 : p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
28068 : 91 : if (strcmp (p, "declare") == 0)
28069 : : {
28070 : 46 : c_parser_consume_token (parser);
28071 : 46 : p = "";
28072 : 46 : if (c_parser_next_token_is (parser, CPP_NAME))
28073 : 46 : p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
28074 : 46 : if (strcmp (p, "target") == 0)
28075 : : {
28076 : 46 : c_parser_consume_token (parser);
28077 : 46 : bool attr_syntax = parser->in_omp_attribute_pragma != NULL;
28078 : 46 : tree clauses
28079 : 46 : = c_parser_omp_all_clauses (parser,
28080 : 46 : OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK,
28081 : : "#pragma omp begin declare target");
28082 : 46 : int device_type = 0;
28083 : 46 : int indirect = 0;
28084 : 70 : for (tree c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
28085 : : {
28086 : 24 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEVICE_TYPE)
28087 : 15 : device_type |= OMP_CLAUSE_DEVICE_TYPE_KIND (c);
28088 : 24 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_INDIRECT)
28089 : 9 : indirect |= !integer_zerop (OMP_CLAUSE_INDIRECT_EXPR (c));
28090 : : }
28091 : 46 : c_omp_declare_target_attr attr = { attr_syntax, device_type,
28092 : 46 : indirect };
28093 : 46 : vec_safe_push (current_omp_declare_target_attribute, attr);
28094 : : }
28095 : : else
28096 : : {
28097 : 0 : c_parser_error (parser, "expected %<target%>");
28098 : 0 : c_parser_skip_to_pragma_eol (parser);
28099 : : }
28100 : : }
28101 : 45 : else if (strcmp (p, "assumes") == 0)
28102 : : {
28103 : 45 : c_parser_consume_token (parser);
28104 : 45 : bool attr_syntax = parser->in_omp_attribute_pragma != NULL;
28105 : 45 : c_parser_omp_assumption_clauses (parser, false);
28106 : 45 : struct c_omp_begin_assumes_data a = { attr_syntax };
28107 : 45 : vec_safe_push (current_omp_begin_assumes, a);
28108 : : }
28109 : : else
28110 : : {
28111 : 0 : c_parser_error (parser, "expected %<declare target%> or %<assumes%>");
28112 : 0 : c_parser_skip_to_pragma_eol (parser);
28113 : : }
28114 : 91 : }
28115 : :
28116 : : /* OpenMP 4.0
28117 : : #pragma omp end declare target
28118 : :
28119 : : OpenMP 5.1
28120 : : #pragma omp end assumes */
28121 : :
28122 : : static void
28123 : 199 : c_parser_omp_end (c_parser *parser)
28124 : : {
28125 : 199 : location_t loc = c_parser_peek_token (parser)->location;
28126 : 199 : const char *p = "";
28127 : 199 : c_parser_consume_pragma (parser);
28128 : 199 : if (c_parser_next_token_is (parser, CPP_NAME))
28129 : 199 : p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
28130 : 199 : if (strcmp (p, "declare") == 0)
28131 : : {
28132 : 154 : c_parser_consume_token (parser);
28133 : 154 : if (c_parser_next_token_is (parser, CPP_NAME)
28134 : 154 : && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser)->value),
28135 : : "target") == 0)
28136 : 154 : c_parser_consume_token (parser);
28137 : : else
28138 : : {
28139 : 0 : c_parser_error (parser, "expected %<target%>");
28140 : 0 : c_parser_skip_to_pragma_eol (parser);
28141 : 0 : return;
28142 : : }
28143 : 154 : bool attr_syntax = parser->in_omp_attribute_pragma != NULL;
28144 : 154 : c_parser_skip_to_pragma_eol (parser);
28145 : 154 : if (!vec_safe_length (current_omp_declare_target_attribute))
28146 : 2 : error_at (loc, "%<#pragma omp end declare target%> without "
28147 : : "corresponding %<#pragma omp declare target%> or "
28148 : : "%<#pragma omp begin declare target%>");
28149 : : else
28150 : : {
28151 : 152 : c_omp_declare_target_attr
28152 : 152 : a = current_omp_declare_target_attribute->pop ();
28153 : 152 : if (a.attr_syntax != attr_syntax)
28154 : : {
28155 : 16 : if (a.attr_syntax)
28156 : 12 : error_at (loc,
28157 : : "%qs in attribute syntax terminated "
28158 : : "with %qs in pragma syntax",
28159 : : a.device_type >= 0 ? "begin declare target"
28160 : : : "declare target",
28161 : : "end declare target");
28162 : : else
28163 : 12 : error_at (loc,
28164 : : "%qs in pragma syntax terminated "
28165 : : "with %qs in attribute syntax",
28166 : : a.device_type >= 0 ? "begin declare target"
28167 : : : "declare target",
28168 : : "end declare target");
28169 : : }
28170 : : }
28171 : : }
28172 : 45 : else if (strcmp (p, "assumes") == 0)
28173 : : {
28174 : 45 : c_parser_consume_token (parser);
28175 : 45 : bool attr_syntax = parser->in_omp_attribute_pragma != NULL;
28176 : 45 : c_parser_skip_to_pragma_eol (parser);
28177 : 45 : if (!vec_safe_length (current_omp_begin_assumes))
28178 : 1 : error_at (loc, "%qs without corresponding %qs",
28179 : : "#pragma omp end assumes", "#pragma omp begin assumes");
28180 : : else
28181 : : {
28182 : 44 : c_omp_begin_assumes_data
28183 : 44 : a = current_omp_begin_assumes->pop ();
28184 : 44 : if (a.attr_syntax != attr_syntax)
28185 : : {
28186 : 8 : if (a.attr_syntax)
28187 : 4 : error_at (loc,
28188 : : "%qs in attribute syntax terminated "
28189 : : "with %qs in pragma syntax",
28190 : : "begin assumes", "end assumes");
28191 : : else
28192 : 4 : error_at (loc,
28193 : : "%qs in pragma syntax terminated "
28194 : : "with %qs in attribute syntax",
28195 : : "begin assumes", "end assumes");
28196 : : }
28197 : : }
28198 : : }
28199 : : else
28200 : : {
28201 : 0 : c_parser_error (parser, "expected %<declare%> or %<assumes%>");
28202 : 0 : c_parser_skip_to_pragma_eol (parser);
28203 : : }
28204 : : }
28205 : :
28206 : : /* OpenMP 5.0
28207 : : #pragma omp declare mapper ([mapper-identifier :] type var) \
28208 : : [clause [ [,] clause ] ... ] new-line */
28209 : :
28210 : : static void
28211 : 65 : c_parser_omp_declare_mapper (c_parser *parser, enum pragma_context context)
28212 : : {
28213 : 65 : tree type, mapper_name = NULL_TREE, var = NULL_TREE, stmt, stmtlist;
28214 : 65 : tree maplist = NULL_TREE, mapper_id, mapper_decl, t;
28215 : 65 : c_token *token;
28216 : :
28217 : 65 : if (context == pragma_struct || context == pragma_param)
28218 : : {
28219 : 2 : error ("%<#pragma omp declare mapper%> not at file or block scope");
28220 : 2 : goto fail;
28221 : : }
28222 : :
28223 : 63 : if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
28224 : 0 : goto fail;
28225 : :
28226 : 63 : token = c_parser_peek_token (parser);
28227 : :
28228 : 63 : if (c_parser_peek_2nd_token (parser)->type == CPP_COLON)
28229 : : {
28230 : 22 : switch (token->type)
28231 : : {
28232 : 15 : case CPP_NAME:
28233 : 15 : mapper_name = token->value;
28234 : 15 : c_parser_consume_token (parser);
28235 : 15 : break;
28236 : 7 : case CPP_KEYWORD:
28237 : 7 : if (token->keyword == RID_DEFAULT)
28238 : : {
28239 : 6 : mapper_name = NULL_TREE;
28240 : 6 : c_parser_consume_token (parser);
28241 : 6 : break;
28242 : : }
28243 : : /* Fallthrough. */
28244 : 1 : default:
28245 : 1 : error_at (token->location, "expected identifier or %<default%>");
28246 : 1 : c_parser_skip_to_pragma_eol (parser, false);
28247 : 1 : return;
28248 : : }
28249 : :
28250 : 21 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
28251 : 0 : goto fail;
28252 : : }
28253 : :
28254 : 62 : mapper_id = c_omp_mapper_id (mapper_name);
28255 : 62 : mapper_decl = c_omp_mapper_decl (mapper_id);
28256 : :
28257 : 62 : {
28258 : 62 : location_t loc = c_parser_peek_token (parser)->location;
28259 : 62 : struct c_type_name *ctype = c_parser_type_name (parser);
28260 : 62 : type = groktypename (ctype, NULL, NULL);
28261 : 62 : if (type == error_mark_node)
28262 : 3 : goto fail;
28263 : 59 : if (!RECORD_OR_UNION_TYPE_P (type))
28264 : : {
28265 : 4 : error_at (loc, "%qT is not a struct or union type in "
28266 : : "%<#pragma omp declare mapper%>", type);
28267 : 4 : c_parser_skip_to_pragma_eol (parser, false);
28268 : 4 : return;
28269 : : }
28270 : 65 : for (tree t = DECL_INITIAL (mapper_decl); t; t = TREE_CHAIN (t))
28271 : 17 : if (comptypes (TREE_PURPOSE (t), type))
28272 : : {
28273 : 7 : error_at (loc, "redeclaration of %qs %<#pragma omp declare "
28274 : 7 : "mapper%> for type %qT", IDENTIFIER_POINTER (mapper_id)
28275 : : + sizeof ("omp declare mapper ") - 1,
28276 : : type);
28277 : 7 : tree prevmapper = TREE_VALUE (t);
28278 : : /* Hmm, this location might not be very accurate. */
28279 : 7 : location_t ploc
28280 : 7 : = DECL_SOURCE_LOCATION (OMP_DECLARE_MAPPER_DECL (prevmapper));
28281 : 7 : inform (ploc, "%<#pragma omp declare mapper%> "
28282 : : "previously declared here");
28283 : 7 : c_parser_skip_to_pragma_eol (parser, false);
28284 : 7 : return;
28285 : : }
28286 : : }
28287 : :
28288 : 48 : token = c_parser_peek_token (parser);
28289 : 48 : if (token->type == CPP_NAME)
28290 : : {
28291 : 46 : var = build_decl (token->location, VAR_DECL, token->value, type);
28292 : 46 : c_parser_consume_token (parser);
28293 : 46 : DECL_ARTIFICIAL (var) = 1;
28294 : : }
28295 : : else
28296 : : {
28297 : 2 : error_at (token->location, "expected identifier");
28298 : 2 : goto fail;
28299 : : }
28300 : :
28301 : 46 : if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
28302 : 0 : goto fail;
28303 : :
28304 : 46 : push_scope ();
28305 : 46 : stmtlist = push_stmt_list ();
28306 : 46 : pushdecl (var);
28307 : 46 : DECL_CONTEXT (var) = current_function_decl;
28308 : :
28309 : 115 : while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
28310 : : {
28311 : 70 : location_t here;
28312 : 70 : pragma_omp_clause c_kind;
28313 : 70 : here = c_parser_peek_token (parser)->location;
28314 : 70 : c_kind = c_parser_omp_clause_name (parser);
28315 : 70 : if (c_kind != PRAGMA_OMP_CLAUSE_MAP)
28316 : : {
28317 : 1 : error_at (here, "unexpected clause");
28318 : 1 : goto fail;
28319 : : }
28320 : 69 : maplist = c_parser_omp_clause_map (parser, maplist, true);
28321 : : }
28322 : :
28323 : 45 : if (maplist == NULL_TREE)
28324 : : {
28325 : 1 : error_at (input_location, "missing %<map%> clause");
28326 : 1 : goto fail;
28327 : : }
28328 : :
28329 : 44 : stmt = make_node (OMP_DECLARE_MAPPER);
28330 : 44 : TREE_TYPE (stmt) = type;
28331 : 44 : OMP_DECLARE_MAPPER_ID (stmt) = mapper_name;
28332 : 44 : OMP_DECLARE_MAPPER_DECL (stmt) = var;
28333 : 44 : OMP_DECLARE_MAPPER_CLAUSES (stmt) = maplist;
28334 : :
28335 : 44 : add_stmt (stmt);
28336 : :
28337 : 44 : pop_stmt_list (stmtlist);
28338 : 44 : pop_scope ();
28339 : :
28340 : 44 : c_parser_skip_to_pragma_eol (parser);
28341 : :
28342 : 44 : t = tree_cons (type, stmt, DECL_INITIAL (mapper_decl));
28343 : 44 : DECL_INITIAL (mapper_decl) = t;
28344 : :
28345 : 44 : return;
28346 : :
28347 : 9 : fail:
28348 : 9 : c_parser_skip_to_pragma_eol (parser);
28349 : : }
28350 : :
28351 : : /* OpenMP 4.0
28352 : : #pragma omp declare reduction (reduction-id : typename-list : expression) \
28353 : : initializer-clause[opt] new-line
28354 : :
28355 : : initializer-clause:
28356 : : initializer (omp_priv = initializer)
28357 : : initializer (function-name (argument-list)) */
28358 : :
28359 : : static void
28360 : 164 : c_parser_omp_declare_reduction (c_parser *parser, enum pragma_context context)
28361 : : {
28362 : 164 : unsigned int tokens_avail = 0, i;
28363 : 164 : c_token *saved_tokens = NULL;
28364 : 164 : vec<tree> types = vNULL;
28365 : 164 : vec<c_token> clauses = vNULL;
28366 : 164 : enum tree_code reduc_code = ERROR_MARK;
28367 : 164 : tree reduc_id = NULL_TREE;
28368 : 164 : tree type;
28369 : 164 : location_t rloc = c_parser_peek_token (parser)->location;
28370 : :
28371 : 164 : if (context == pragma_struct || context == pragma_param)
28372 : : {
28373 : 2 : error ("%<#pragma omp declare reduction%> not at file or block scope");
28374 : 2 : goto fail;
28375 : : }
28376 : :
28377 : 162 : if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
28378 : 1 : goto fail;
28379 : :
28380 : 161 : switch (c_parser_peek_token (parser)->type)
28381 : : {
28382 : : case CPP_PLUS:
28383 : : reduc_code = PLUS_EXPR;
28384 : : break;
28385 : 14 : case CPP_MULT:
28386 : 14 : reduc_code = MULT_EXPR;
28387 : 14 : break;
28388 : 0 : case CPP_MINUS:
28389 : 0 : reduc_code = MINUS_EXPR;
28390 : 0 : break;
28391 : 4 : case CPP_AND:
28392 : 4 : reduc_code = BIT_AND_EXPR;
28393 : 4 : break;
28394 : 0 : case CPP_XOR:
28395 : 0 : reduc_code = BIT_XOR_EXPR;
28396 : 0 : break;
28397 : 10 : case CPP_OR:
28398 : 10 : reduc_code = BIT_IOR_EXPR;
28399 : 10 : break;
28400 : 0 : case CPP_AND_AND:
28401 : 0 : reduc_code = TRUTH_ANDIF_EXPR;
28402 : 0 : break;
28403 : 0 : case CPP_OR_OR:
28404 : 0 : reduc_code = TRUTH_ORIF_EXPR;
28405 : 0 : break;
28406 : 89 : case CPP_NAME:
28407 : 89 : const char *p;
28408 : 89 : p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
28409 : 89 : if (strcmp (p, "min") == 0)
28410 : : {
28411 : : reduc_code = MIN_EXPR;
28412 : : break;
28413 : : }
28414 : 83 : if (strcmp (p, "max") == 0)
28415 : : {
28416 : : reduc_code = MAX_EXPR;
28417 : : break;
28418 : : }
28419 : 83 : reduc_id = c_parser_peek_token (parser)->value;
28420 : 83 : break;
28421 : 0 : default:
28422 : 0 : c_parser_error (parser,
28423 : : "expected %<+%>, %<*%>, %<-%>, %<&%>, "
28424 : : "%<^%>, %<|%>, %<&&%>, %<||%> or identifier");
28425 : 0 : goto fail;
28426 : : }
28427 : :
28428 : 161 : tree orig_reduc_id, reduc_decl;
28429 : 161 : orig_reduc_id = reduc_id;
28430 : 161 : reduc_id = c_omp_reduction_id (reduc_code, reduc_id);
28431 : 161 : reduc_decl = c_omp_reduction_decl (reduc_id);
28432 : 161 : c_parser_consume_token (parser);
28433 : :
28434 : 161 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
28435 : 0 : goto fail;
28436 : :
28437 : 165 : while (true)
28438 : : {
28439 : 163 : location_t loc = c_parser_peek_token (parser)->location;
28440 : 163 : struct c_type_name *ctype = c_parser_type_name (parser);
28441 : 163 : if (ctype != NULL)
28442 : : {
28443 : 163 : type = groktypename (ctype, NULL, NULL);
28444 : 163 : if (type == error_mark_node)
28445 : : ;
28446 : 163 : else if ((INTEGRAL_TYPE_P (type)
28447 : 163 : || SCALAR_FLOAT_TYPE_P (type)
28448 : 98 : || TREE_CODE (type) == COMPLEX_TYPE)
28449 : 69 : && orig_reduc_id == NULL_TREE)
28450 : 8 : error_at (loc, "predeclared arithmetic type in "
28451 : : "%<#pragma omp declare reduction%>");
28452 : 155 : else if (TREE_CODE (type) == FUNCTION_TYPE
28453 : 150 : || TREE_CODE (type) == ARRAY_TYPE)
28454 : 8 : error_at (loc, "function or array type in "
28455 : : "%<#pragma omp declare reduction%>");
28456 : 147 : else if (TYPE_ATOMIC (type))
28457 : 1 : error_at (loc, "%<_Atomic%> qualified type in "
28458 : : "%<#pragma omp declare reduction%>");
28459 : 146 : else if (TYPE_QUALS_NO_ADDR_SPACE (type))
28460 : 8 : error_at (loc, "const, volatile or restrict qualified type in "
28461 : : "%<#pragma omp declare reduction%>");
28462 : : else
28463 : : {
28464 : 138 : tree t;
28465 : 200 : for (t = DECL_INITIAL (reduc_decl); t; t = TREE_CHAIN (t))
28466 : 66 : if (comptypes (TREE_PURPOSE (t), type))
28467 : : {
28468 : 4 : error_at (loc, "redeclaration of %qs "
28469 : : "%<#pragma omp declare reduction%> for "
28470 : : "type %qT",
28471 : 4 : IDENTIFIER_POINTER (reduc_id)
28472 : : + sizeof ("omp declare reduction ") - 1,
28473 : : type);
28474 : 4 : location_t ploc
28475 : 4 : = DECL_SOURCE_LOCATION (TREE_VEC_ELT (TREE_VALUE (t),
28476 : : 0));
28477 : 4 : inform (ploc, "%<#pragma omp declare reduction%> "
28478 : : "previously declared here");
28479 : 4 : break;
28480 : : }
28481 : 4 : if (t == NULL_TREE)
28482 : 134 : types.safe_push (type);
28483 : : }
28484 : 163 : if (c_parser_next_token_is (parser, CPP_COMMA))
28485 : 2 : c_parser_consume_token (parser);
28486 : : else
28487 : : break;
28488 : : }
28489 : : else
28490 : : break;
28491 : 2 : }
28492 : :
28493 : 161 : if (!c_parser_require (parser, CPP_COLON, "expected %<:%>")
28494 : 161 : || types.is_empty ())
28495 : : {
28496 : 34 : fail:
28497 : 34 : clauses.release ();
28498 : 34 : types.release ();
28499 : 460 : while (true)
28500 : : {
28501 : 247 : c_token *token = c_parser_peek_token (parser);
28502 : 247 : if (token->type == CPP_EOF || token->type == CPP_PRAGMA_EOL)
28503 : : break;
28504 : 213 : c_parser_consume_token (parser);
28505 : 213 : }
28506 : 34 : c_parser_skip_to_pragma_eol (parser);
28507 : 34 : return;
28508 : : }
28509 : :
28510 : 132 : if (types.length () > 1)
28511 : : {
28512 : 13 : while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
28513 : : {
28514 : 12 : c_token *token = c_parser_peek_token (parser);
28515 : 12 : if (token->type == CPP_EOF)
28516 : 0 : goto fail;
28517 : 12 : clauses.safe_push (*token);
28518 : 12 : c_parser_consume_token (parser);
28519 : : }
28520 : 1 : clauses.safe_push (*c_parser_peek_token (parser));
28521 : 1 : c_parser_skip_to_pragma_eol (parser);
28522 : :
28523 : : /* Make sure nothing tries to read past the end of the tokens. */
28524 : 1 : c_token eof_token;
28525 : 1 : memset (&eof_token, 0, sizeof (eof_token));
28526 : 1 : eof_token.type = CPP_EOF;
28527 : 1 : clauses.safe_push (eof_token);
28528 : 1 : clauses.safe_push (eof_token);
28529 : : }
28530 : :
28531 : 132 : int errs = errorcount;
28532 : 238 : FOR_EACH_VEC_ELT (types, i, type)
28533 : : {
28534 : 134 : saved_tokens = parser->tokens;
28535 : 134 : tokens_avail = parser->tokens_avail;
28536 : 134 : if (!clauses.is_empty ())
28537 : : {
28538 : 3 : parser->tokens = clauses.address ();
28539 : 3 : parser->tokens_avail = clauses.length ();
28540 : 3 : parser->in_pragma = true;
28541 : : }
28542 : :
28543 : 134 : bool nested = current_function_decl != NULL_TREE;
28544 : 134 : if (nested)
28545 : 27 : c_push_function_context ();
28546 : 134 : tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
28547 : : reduc_id, default_function_type);
28548 : 134 : current_function_decl = fndecl;
28549 : 134 : allocate_struct_function (fndecl, true);
28550 : 134 : push_scope ();
28551 : 134 : tree stmt = push_stmt_list ();
28552 : : /* Intentionally BUILTINS_LOCATION, so that -Wshadow doesn't
28553 : : warn about these. */
28554 : 134 : tree omp_out = build_decl (BUILTINS_LOCATION, VAR_DECL,
28555 : : get_identifier ("omp_out"), type);
28556 : 134 : DECL_ARTIFICIAL (omp_out) = 1;
28557 : 134 : DECL_CONTEXT (omp_out) = fndecl;
28558 : 134 : pushdecl (omp_out);
28559 : 134 : tree omp_in = build_decl (BUILTINS_LOCATION, VAR_DECL,
28560 : : get_identifier ("omp_in"), type);
28561 : 134 : DECL_ARTIFICIAL (omp_in) = 1;
28562 : 134 : DECL_CONTEXT (omp_in) = fndecl;
28563 : 134 : pushdecl (omp_in);
28564 : 134 : struct c_expr combiner = c_parser_expression (parser);
28565 : 134 : struct c_expr initializer;
28566 : 134 : tree omp_priv = NULL_TREE, omp_orig = NULL_TREE;
28567 : 134 : bool bad = false;
28568 : 134 : initializer.set_error ();
28569 : 134 : if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
28570 : : bad = true;
28571 : 134 : else if (c_parser_next_token_is (parser, CPP_COMMA)
28572 : 134 : && c_parser_peek_2nd_token (parser)->type == CPP_NAME)
28573 : 2 : c_parser_consume_token (parser);
28574 : 2 : if (!bad
28575 : 134 : && (c_parser_next_token_is (parser, CPP_NAME)
28576 : 77 : && strcmp (IDENTIFIER_POINTER
28577 : : (c_parser_peek_token (parser)->value),
28578 : : "initializer") == 0))
28579 : : {
28580 : 77 : c_parser_consume_token (parser);
28581 : 77 : pop_scope ();
28582 : 77 : push_scope ();
28583 : 77 : omp_priv = build_decl (BUILTINS_LOCATION, VAR_DECL,
28584 : : get_identifier ("omp_priv"), type);
28585 : 77 : DECL_ARTIFICIAL (omp_priv) = 1;
28586 : 77 : DECL_INITIAL (omp_priv) = error_mark_node;
28587 : 77 : DECL_CONTEXT (omp_priv) = fndecl;
28588 : 77 : pushdecl (omp_priv);
28589 : 77 : omp_orig = build_decl (BUILTINS_LOCATION, VAR_DECL,
28590 : : get_identifier ("omp_orig"), type);
28591 : 77 : DECL_ARTIFICIAL (omp_orig) = 1;
28592 : 77 : DECL_CONTEXT (omp_orig) = fndecl;
28593 : 77 : pushdecl (omp_orig);
28594 : 77 : if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
28595 : : bad = true;
28596 : 77 : else if (!c_parser_next_token_is (parser, CPP_NAME))
28597 : : {
28598 : 0 : c_parser_error (parser, "expected %<omp_priv%> or "
28599 : : "function-name");
28600 : 0 : bad = true;
28601 : : }
28602 : 77 : else if (strcmp (IDENTIFIER_POINTER
28603 : : (c_parser_peek_token (parser)->value),
28604 : : "omp_priv") != 0)
28605 : : {
28606 : 20 : if (c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN
28607 : 20 : || c_parser_peek_token (parser)->id_kind != C_ID_ID)
28608 : : {
28609 : 0 : c_parser_error (parser, "expected function-name %<(%>");
28610 : 0 : bad = true;
28611 : : }
28612 : : else
28613 : 20 : initializer = c_parser_postfix_expression (parser);
28614 : 20 : if (initializer.value
28615 : 20 : && TREE_CODE (initializer.value) == CALL_EXPR)
28616 : : {
28617 : : int j;
28618 : : tree c = initializer.value;
28619 : 21 : for (j = 0; j < call_expr_nargs (c); j++)
28620 : : {
28621 : 20 : tree a = CALL_EXPR_ARG (c, j);
28622 : 20 : STRIP_NOPS (a);
28623 : 20 : if (TREE_CODE (a) == ADDR_EXPR
28624 : 20 : && TREE_OPERAND (a, 0) == omp_priv)
28625 : : break;
28626 : : }
28627 : 20 : if (j == call_expr_nargs (c))
28628 : 1 : error ("one of the initializer call arguments should be "
28629 : : "%<&omp_priv%>");
28630 : : }
28631 : : }
28632 : : else
28633 : : {
28634 : 57 : c_parser_consume_token (parser);
28635 : 57 : if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
28636 : : bad = true;
28637 : : else
28638 : : {
28639 : 55 : tree st = push_stmt_list ();
28640 : 55 : location_t loc = c_parser_peek_token (parser)->location;
28641 : 55 : rich_location richloc (line_table, loc);
28642 : 55 : start_init (omp_priv, NULL_TREE, false, false, &richloc);
28643 : 55 : struct c_expr init = c_parser_initializer (parser, omp_priv);
28644 : 55 : finish_init ();
28645 : 55 : finish_decl (omp_priv, loc, init.value,
28646 : : init.original_type, NULL_TREE);
28647 : 55 : pop_stmt_list (st);
28648 : 55 : }
28649 : : }
28650 : 0 : if (!bad
28651 : 75 : && !c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
28652 : : bad = true;
28653 : : }
28654 : :
28655 : 134 : if (!bad)
28656 : : {
28657 : 132 : c_parser_skip_to_pragma_eol (parser);
28658 : :
28659 : 189 : tree t = tree_cons (type, make_tree_vec (omp_priv ? 6 : 3),
28660 : 132 : DECL_INITIAL (reduc_decl));
28661 : 132 : DECL_INITIAL (reduc_decl) = t;
28662 : 132 : DECL_SOURCE_LOCATION (omp_out) = rloc;
28663 : 132 : TREE_VEC_ELT (TREE_VALUE (t), 0) = omp_out;
28664 : 132 : TREE_VEC_ELT (TREE_VALUE (t), 1) = omp_in;
28665 : 132 : TREE_VEC_ELT (TREE_VALUE (t), 2) = combiner.value;
28666 : 132 : walk_tree (&combiner.value, c_check_omp_declare_reduction_r,
28667 : : &TREE_VEC_ELT (TREE_VALUE (t), 0), NULL);
28668 : 132 : if (omp_priv)
28669 : : {
28670 : 75 : DECL_SOURCE_LOCATION (omp_priv) = rloc;
28671 : 75 : TREE_VEC_ELT (TREE_VALUE (t), 3) = omp_priv;
28672 : 75 : TREE_VEC_ELT (TREE_VALUE (t), 4) = omp_orig;
28673 : 75 : TREE_VEC_ELT (TREE_VALUE (t), 5) = initializer.value;
28674 : 75 : walk_tree (&initializer.value, c_check_omp_declare_reduction_r,
28675 : : &TREE_VEC_ELT (TREE_VALUE (t), 3), NULL);
28676 : 75 : walk_tree (&DECL_INITIAL (omp_priv),
28677 : : c_check_omp_declare_reduction_r,
28678 : : &TREE_VEC_ELT (TREE_VALUE (t), 3), NULL);
28679 : : }
28680 : : }
28681 : :
28682 : 134 : pop_stmt_list (stmt);
28683 : 134 : pop_scope ();
28684 : 134 : if (cfun->language != NULL)
28685 : : {
28686 : 0 : ggc_free (cfun->language);
28687 : 0 : cfun->language = NULL;
28688 : : }
28689 : 134 : set_cfun (NULL);
28690 : 134 : current_function_decl = NULL_TREE;
28691 : 134 : if (nested)
28692 : 27 : c_pop_function_context ();
28693 : :
28694 : 134 : if (!clauses.is_empty ())
28695 : : {
28696 : 3 : parser->tokens = saved_tokens;
28697 : 3 : parser->tokens_avail = tokens_avail;
28698 : : }
28699 : 134 : if (bad)
28700 : 2 : goto fail;
28701 : 132 : if (errs != errorcount)
28702 : : break;
28703 : : }
28704 : :
28705 : 130 : clauses.release ();
28706 : 130 : types.release ();
28707 : : }
28708 : :
28709 : : /* OpenMP 4.0
28710 : : #pragma omp declare simd declare-simd-clauses[optseq] new-line
28711 : : #pragma omp declare reduction (reduction-id : typename-list : expression) \
28712 : : initializer-clause[opt] new-line
28713 : : #pragma omp declare target new-line
28714 : :
28715 : : OpenMP 5.0
28716 : : #pragma omp declare variant (identifier) match (context-selector)
28717 : :
28718 : : OpenMP 5.1
28719 : : #pragma omp declare variant (identifier) match (context-selector) \
28720 : : adjust_args(adjust-op:argument-list) */
28721 : :
28722 : : static bool
28723 : 1206 : c_parser_omp_declare (c_parser *parser, enum pragma_context context)
28724 : : {
28725 : 1206 : c_parser_consume_pragma (parser);
28726 : 1206 : if (c_parser_next_token_is (parser, CPP_NAME))
28727 : : {
28728 : 1206 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
28729 : 1206 : if (strcmp (p, "simd") == 0)
28730 : : {
28731 : : /* c_parser_consume_token (parser); done in
28732 : : c_parser_omp_declare_simd. */
28733 : 268 : c_parser_omp_declare_simd (parser, context);
28734 : 268 : return true;
28735 : : }
28736 : 938 : if (strcmp (p, "reduction") == 0)
28737 : : {
28738 : 164 : c_parser_consume_token (parser);
28739 : 164 : c_parser_omp_declare_reduction (parser, context);
28740 : 164 : return false;
28741 : : }
28742 : 774 : if (strcmp (p, "mapper") == 0)
28743 : : {
28744 : 65 : c_parser_consume_token (parser);
28745 : 65 : c_parser_omp_declare_mapper (parser, context);
28746 : 65 : return false;
28747 : : }
28748 : 709 : if (!flag_openmp) /* flag_openmp_simd */
28749 : : {
28750 : 0 : c_parser_skip_to_pragma_eol (parser, false);
28751 : 0 : return false;
28752 : : }
28753 : 709 : if (strcmp (p, "target") == 0)
28754 : : {
28755 : 273 : c_parser_consume_token (parser);
28756 : 273 : c_parser_omp_declare_target (parser);
28757 : 273 : return false;
28758 : : }
28759 : 436 : if (strcmp (p, "variant") == 0)
28760 : : {
28761 : : /* c_parser_consume_token (parser); done in
28762 : : c_parser_omp_declare_simd. */
28763 : 436 : c_parser_omp_declare_simd (parser, context);
28764 : 436 : return true;
28765 : : }
28766 : : }
28767 : :
28768 : 0 : c_parser_error (parser, "expected %<simd%>, %<reduction%>, "
28769 : : "%<target%> or %<variant%>");
28770 : 0 : c_parser_skip_to_pragma_eol (parser);
28771 : 0 : return false;
28772 : : }
28773 : :
28774 : : /* OpenMP 5.0
28775 : : #pragma omp requires clauses[optseq] new-line */
28776 : :
28777 : : static void
28778 : 62 : c_parser_omp_requires (c_parser *parser)
28779 : : {
28780 : 62 : enum omp_requires new_req = (enum omp_requires) 0;
28781 : :
28782 : 62 : c_parser_consume_pragma (parser);
28783 : :
28784 : 62 : location_t loc = c_parser_peek_token (parser)->location;
28785 : 138 : while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
28786 : : {
28787 : 80 : if (c_parser_next_token_is (parser, CPP_COMMA)
28788 : 80 : && c_parser_peek_2nd_token (parser)->type == CPP_NAME)
28789 : 14 : c_parser_consume_token (parser);
28790 : :
28791 : 80 : if (c_parser_next_token_is (parser, CPP_NAME))
28792 : : {
28793 : 79 : const char *p
28794 : 79 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
28795 : 79 : location_t cloc = c_parser_peek_token (parser)->location;
28796 : 79 : enum omp_requires this_req = (enum omp_requires) 0;
28797 : :
28798 : 79 : if (!strcmp (p, "unified_address"))
28799 : : this_req = OMP_REQUIRES_UNIFIED_ADDRESS;
28800 : 65 : else if (!strcmp (p, "unified_shared_memory"))
28801 : : this_req = OMP_REQUIRES_UNIFIED_SHARED_MEMORY;
28802 : 51 : else if (!strcmp (p, "self_maps"))
28803 : : this_req = OMP_REQUIRES_SELF_MAPS;
28804 : 49 : else if (!strcmp (p, "dynamic_allocators"))
28805 : : this_req = OMP_REQUIRES_DYNAMIC_ALLOCATORS;
28806 : 38 : else if (!strcmp (p, "reverse_offload"))
28807 : : this_req = OMP_REQUIRES_REVERSE_OFFLOAD;
28808 : 21 : else if (!strcmp (p, "atomic_default_mem_order"))
28809 : : {
28810 : 20 : c_parser_consume_token (parser);
28811 : :
28812 : 20 : matching_parens parens;
28813 : 20 : if (parens.require_open (parser))
28814 : : {
28815 : 20 : if (c_parser_next_token_is (parser, CPP_NAME))
28816 : : {
28817 : 19 : tree v = c_parser_peek_token (parser)->value;
28818 : 19 : p = IDENTIFIER_POINTER (v);
28819 : :
28820 : 19 : if (!strcmp (p, "seq_cst"))
28821 : : this_req
28822 : : = (enum omp_requires) OMP_MEMORY_ORDER_SEQ_CST;
28823 : 10 : else if (!strcmp (p, "relaxed"))
28824 : : this_req
28825 : : = (enum omp_requires) OMP_MEMORY_ORDER_RELAXED;
28826 : 9 : else if (!strcmp (p, "release"))
28827 : : this_req
28828 : : = (enum omp_requires) OMP_MEMORY_ORDER_RELEASE;
28829 : 7 : else if (!strcmp (p, "acq_rel"))
28830 : : this_req
28831 : : = (enum omp_requires) OMP_MEMORY_ORDER_ACQ_REL;
28832 : 4 : else if (!strcmp (p, "acquire"))
28833 : : this_req
28834 : : = (enum omp_requires) OMP_MEMORY_ORDER_ACQUIRE;
28835 : : }
28836 : : if (this_req == 0)
28837 : : {
28838 : 2 : error_at (c_parser_peek_token (parser)->location,
28839 : : "expected %<acq_rel%>, %<acquire%>, "
28840 : : "%<relaxed%>, %<release%> or %<seq_cst%>");
28841 : 2 : switch (c_parser_peek_token (parser)->type)
28842 : : {
28843 : : case CPP_EOF:
28844 : : case CPP_PRAGMA_EOL:
28845 : : case CPP_CLOSE_PAREN:
28846 : : break;
28847 : 1 : default:
28848 : 1 : if (c_parser_peek_2nd_token (parser)->type
28849 : : == CPP_CLOSE_PAREN)
28850 : 1 : c_parser_consume_token (parser);
28851 : : break;
28852 : : }
28853 : : }
28854 : : else
28855 : 18 : c_parser_consume_token (parser);
28856 : :
28857 : 20 : parens.skip_until_found_close (parser);
28858 : 20 : if (this_req == 0)
28859 : : {
28860 : 2 : c_parser_skip_to_pragma_eol (parser, false);
28861 : 2 : return;
28862 : : }
28863 : : }
28864 : 18 : p = NULL;
28865 : : }
28866 : : else
28867 : : {
28868 : 1 : error_at (cloc, "expected %<unified_address%>, "
28869 : : "%<unified_shared_memory%>, "
28870 : : "%<self_maps%>, "
28871 : : "%<dynamic_allocators%>, "
28872 : : "%<reverse_offload%> "
28873 : : "or %<atomic_default_mem_order%> clause");
28874 : 1 : c_parser_skip_to_pragma_eol (parser, false);
28875 : 1 : return;
28876 : : }
28877 : 18 : if (p)
28878 : 58 : c_parser_consume_token (parser);
28879 : 76 : if (this_req)
28880 : : {
28881 : 76 : if ((this_req & ~OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER) != 0)
28882 : : {
28883 : 58 : if ((this_req & new_req) != 0)
28884 : 4 : error_at (cloc, "too many %qs clauses", p);
28885 : 58 : if (this_req != OMP_REQUIRES_DYNAMIC_ALLOCATORS
28886 : 47 : && (omp_requires_mask & OMP_REQUIRES_TARGET_USED) != 0)
28887 : 4 : error_at (cloc, "%qs clause used lexically after first "
28888 : : "target construct or offloading API", p);
28889 : : }
28890 : 18 : else if ((new_req & OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER) != 0)
28891 : : {
28892 : 1 : error_at (cloc, "too many %qs clauses",
28893 : : "atomic_default_mem_order");
28894 : 1 : this_req = (enum omp_requires) 0;
28895 : : }
28896 : 17 : else if ((omp_requires_mask
28897 : : & OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER) != 0)
28898 : : {
28899 : 2 : error_at (cloc, "more than one %<atomic_default_mem_order%>"
28900 : : " clause in a single compilation unit");
28901 : 2 : this_req
28902 : 2 : = (enum omp_requires)
28903 : 2 : (omp_requires_mask
28904 : : & OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER);
28905 : : }
28906 : 15 : else if ((omp_requires_mask
28907 : : & OMP_REQUIRES_ATOMIC_DEFAULT_MEM_ORDER_USED) != 0)
28908 : 1 : error_at (cloc, "%<atomic_default_mem_order%> clause used "
28909 : : "lexically after first %<atomic%> construct "
28910 : : "without memory order clause");
28911 : 76 : new_req = (enum omp_requires) (new_req | this_req);
28912 : 76 : omp_requires_mask
28913 : 76 : = (enum omp_requires) (omp_requires_mask | this_req);
28914 : 76 : continue;
28915 : : }
28916 : : }
28917 : : break;
28918 : : }
28919 : 59 : c_parser_skip_to_pragma_eol (parser);
28920 : :
28921 : 59 : if (new_req == 0)
28922 : 1 : error_at (loc, "%<pragma omp requires%> requires at least one clause");
28923 : : }
28924 : :
28925 : : /* Helper function for c_parser_omp_taskloop.
28926 : : Disallow zero sized or potentially zero sized task reductions. */
28927 : :
28928 : : static tree
28929 : 412 : c_finish_taskloop_clauses (tree clauses)
28930 : : {
28931 : 412 : tree *pc = &clauses;
28932 : 2049 : for (tree c = clauses; c; c = *pc)
28933 : : {
28934 : 1637 : bool remove = false;
28935 : 1637 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
28936 : : {
28937 : 142 : tree type = strip_array_types (TREE_TYPE (OMP_CLAUSE_DECL (c)));
28938 : 142 : if (integer_zerop (TYPE_SIZE_UNIT (type)))
28939 : : {
28940 : 2 : error_at (OMP_CLAUSE_LOCATION (c),
28941 : : "zero sized type %qT in %<reduction%> clause", type);
28942 : 2 : remove = true;
28943 : : }
28944 : 140 : else if (TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST)
28945 : : {
28946 : 0 : error_at (OMP_CLAUSE_LOCATION (c),
28947 : : "variable sized type %qT in %<reduction%> clause",
28948 : : type);
28949 : 0 : remove = true;
28950 : : }
28951 : : }
28952 : 2 : if (remove)
28953 : 2 : *pc = OMP_CLAUSE_CHAIN (c);
28954 : : else
28955 : 1635 : pc = &OMP_CLAUSE_CHAIN (c);
28956 : : }
28957 : 412 : return clauses;
28958 : : }
28959 : :
28960 : : /* OpenMP 4.5:
28961 : : #pragma omp taskloop taskloop-clause[optseq] new-line
28962 : : for-loop
28963 : :
28964 : : #pragma omp taskloop simd taskloop-simd-clause[optseq] new-line
28965 : : for-loop */
28966 : :
28967 : : #define OMP_TASKLOOP_CLAUSE_MASK \
28968 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
28969 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
28970 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
28971 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
28972 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
28973 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_GRAINSIZE) \
28974 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TASKS) \
28975 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
28976 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
28977 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
28978 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
28979 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
28980 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP) \
28981 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
28982 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
28983 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
28984 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION))
28985 : :
28986 : : static tree
28987 : 417 : c_parser_omp_taskloop (location_t loc, c_parser *parser,
28988 : : char *p_name, omp_clause_mask mask, tree *cclauses,
28989 : : bool *if_p)
28990 : : {
28991 : 417 : tree clauses, block, ret;
28992 : :
28993 : 417 : strcat (p_name, " taskloop");
28994 : 417 : mask |= OMP_TASKLOOP_CLAUSE_MASK;
28995 : : /* #pragma omp parallel master taskloop{, simd} disallow in_reduction
28996 : : clause. */
28997 : 417 : if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS)) != 0)
28998 : 94 : mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION);
28999 : :
29000 : 417 : if (c_parser_next_token_is (parser, CPP_NAME))
29001 : : {
29002 : 341 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
29003 : :
29004 : 341 : if (strcmp (p, "simd") == 0)
29005 : : {
29006 : 178 : tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
29007 : 178 : if (cclauses == NULL)
29008 : 84 : cclauses = cclauses_buf;
29009 : 178 : c_parser_consume_token (parser);
29010 : 178 : if (!flag_openmp) /* flag_openmp_simd */
29011 : 3 : return c_parser_omp_simd (loc, parser, p_name, mask, cclauses,
29012 : 3 : if_p);
29013 : 175 : block = c_begin_compound_stmt (true);
29014 : 175 : ret = c_parser_omp_simd (loc, parser, p_name, mask, cclauses, if_p);
29015 : 175 : block = c_end_compound_stmt (loc, block, true);
29016 : 175 : if (ret == NULL)
29017 : : return ret;
29018 : 175 : ret = make_node (OMP_TASKLOOP);
29019 : 175 : TREE_TYPE (ret) = void_type_node;
29020 : 175 : OMP_FOR_BODY (ret) = block;
29021 : 175 : OMP_FOR_CLAUSES (ret) = cclauses[C_OMP_CLAUSE_SPLIT_TASKLOOP];
29022 : 175 : OMP_FOR_CLAUSES (ret)
29023 : 175 : = c_finish_taskloop_clauses (OMP_FOR_CLAUSES (ret));
29024 : 175 : SET_EXPR_LOCATION (ret, loc);
29025 : 175 : add_stmt (ret);
29026 : 175 : return ret;
29027 : : }
29028 : : }
29029 : 239 : if (!flag_openmp) /* flag_openmp_simd */
29030 : : {
29031 : 2 : c_parser_skip_to_pragma_eol (parser, false);
29032 : 2 : return NULL_TREE;
29033 : : }
29034 : :
29035 : 237 : clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
29036 : 237 : if (cclauses)
29037 : : {
29038 : 65 : omp_split_clauses (loc, OMP_TASKLOOP, mask, clauses, cclauses);
29039 : 65 : clauses = cclauses[C_OMP_CLAUSE_SPLIT_TASKLOOP];
29040 : : }
29041 : :
29042 : 237 : clauses = c_finish_taskloop_clauses (clauses);
29043 : 237 : block = c_begin_compound_stmt (true);
29044 : 237 : ret = c_parser_omp_for_loop (loc, parser, OMP_TASKLOOP, clauses, NULL, if_p);
29045 : 237 : block = c_end_compound_stmt (loc, block, true);
29046 : 237 : add_stmt (block);
29047 : :
29048 : 237 : return ret;
29049 : : }
29050 : :
29051 : : /* OpenMP 5.1: Parse sizes list for "omp tile sizes"
29052 : : sizes ( size-expr-list ) */
29053 : : static tree
29054 : 476 : c_parser_omp_tile_sizes (c_parser *parser, location_t loc)
29055 : : {
29056 : 476 : tree sizes = NULL_TREE;
29057 : :
29058 : 476 : if (c_parser_next_token_is (parser, CPP_COMMA))
29059 : 2 : c_parser_consume_token (parser);
29060 : :
29061 : 476 : c_token *tok = c_parser_peek_token (parser);
29062 : 476 : if (tok->type != CPP_NAME
29063 : 476 : || strcmp ("sizes", IDENTIFIER_POINTER (tok->value)))
29064 : : {
29065 : 1 : c_parser_error (parser, "expected %<sizes%>");
29066 : 1 : return error_mark_node;
29067 : : }
29068 : 475 : c_parser_consume_token (parser);
29069 : :
29070 : 475 : matching_parens parens;
29071 : 475 : if (!parens.require_open (parser))
29072 : 4 : return error_mark_node;
29073 : :
29074 : 471 : vec<tree, va_gc> *sizes_vec
29075 : 471 : = c_parser_expr_list (parser, true, true, NULL, NULL, NULL, NULL);
29076 : 471 : sizes = build_tree_list_vec (sizes_vec);
29077 : 471 : release_tree_vector (sizes_vec);
29078 : :
29079 : 1198 : for (tree s = sizes; s; s = TREE_CHAIN (s))
29080 : : {
29081 : 734 : tree expr = TREE_VALUE (s);
29082 : 734 : if (expr == error_mark_node)
29083 : : {
29084 : 7 : parens.skip_until_found_close (parser);
29085 : 7 : return error_mark_node;
29086 : : }
29087 : :
29088 : 727 : HOST_WIDE_INT n;
29089 : 1454 : if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
29090 : 724 : || !tree_fits_shwi_p (expr)
29091 : 722 : || (n = tree_to_shwi (expr)) <= 0
29092 : 1440 : || (int) n != n)
29093 : : {
29094 : 14 : c_parser_error (parser, "%<sizes%> argument needs positive"
29095 : : " integral constant");
29096 : 14 : TREE_VALUE (s) = integer_one_node;
29097 : : }
29098 : : }
29099 : 464 : parens.require_close (parser);
29100 : :
29101 : 464 : gcc_assert (sizes);
29102 : 464 : tree c = build_omp_clause (loc, OMP_CLAUSE_SIZES);
29103 : 464 : OMP_CLAUSE_SIZES_LIST (c) = sizes;
29104 : :
29105 : 464 : return c;
29106 : : }
29107 : :
29108 : : /* OpenMP 5.1:
29109 : : #pragma omp tile sizes ( size-expr-list ) new-line
29110 : : for-loop
29111 : :
29112 : : LOC is the location of the #pragma token. */
29113 : :
29114 : : static tree
29115 : 476 : c_parser_omp_tile (location_t loc, c_parser *parser, bool *if_p)
29116 : : {
29117 : 476 : tree clauses = c_parser_omp_tile_sizes (parser, loc);
29118 : 476 : c_parser_skip_to_pragma_eol (parser);
29119 : :
29120 : 476 : if (!clauses || clauses == error_mark_node)
29121 : 12 : return error_mark_node;
29122 : :
29123 : 464 : tree block = c_begin_compound_stmt (true);
29124 : 464 : tree ret = c_parser_omp_for_loop (loc, parser, OMP_TILE, clauses,
29125 : : NULL, if_p);
29126 : 464 : block = c_end_compound_stmt (loc, block, true);
29127 : 464 : add_stmt (block);
29128 : :
29129 : 464 : return ret;
29130 : : }
29131 : :
29132 : : #define OMP_UNROLL_CLAUSE_MASK \
29133 : : ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARTIAL) \
29134 : : | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FULL))
29135 : :
29136 : : /* OpenMP 5.1
29137 : : #pragma omp unroll unroll-clause[optseq] new-line
29138 : : for-loop
29139 : :
29140 : : LOC is the location of the #pragma token. */
29141 : :
29142 : : static tree
29143 : 313 : c_parser_omp_unroll (location_t loc, c_parser *parser, bool *if_p)
29144 : : {
29145 : 313 : tree clauses = c_parser_omp_all_clauses (parser, OMP_UNROLL_CLAUSE_MASK,
29146 : : "#pragma omp unroll", true);
29147 : :
29148 : 313 : tree block = c_begin_compound_stmt (true);
29149 : 313 : tree ret = c_parser_omp_for_loop (loc, parser, OMP_UNROLL, clauses,
29150 : : NULL, if_p);
29151 : 313 : block = c_end_compound_stmt (loc, block, true);
29152 : 313 : add_stmt (block);
29153 : :
29154 : 313 : return ret;
29155 : : }
29156 : :
29157 : : /* OpenMP 5.1
29158 : : #pragma omp nothing new-line */
29159 : :
29160 : : static void
29161 : 79 : c_parser_omp_nothing (c_parser *parser)
29162 : : {
29163 : 79 : c_parser_consume_pragma (parser);
29164 : 79 : c_parser_skip_to_pragma_eol (parser);
29165 : 79 : }
29166 : :
29167 : : /* OpenMP 5.1
29168 : : #pragma omp error clauses[optseq] new-line */
29169 : :
29170 : : static bool
29171 : 124 : c_parser_omp_error (c_parser *parser, enum pragma_context context)
29172 : : {
29173 : 124 : int at_compilation = -1;
29174 : 124 : int severity_fatal = -1;
29175 : 124 : tree message = NULL_TREE;
29176 : 124 : bool bad = false;
29177 : 124 : location_t loc = c_parser_peek_token (parser)->location;
29178 : :
29179 : 124 : c_parser_consume_pragma (parser);
29180 : :
29181 : 457 : while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
29182 : : {
29183 : 212 : if (c_parser_next_token_is (parser, CPP_COMMA)
29184 : 212 : && c_parser_peek_2nd_token (parser)->type == CPP_NAME)
29185 : 21 : c_parser_consume_token (parser);
29186 : :
29187 : 212 : if (!c_parser_next_token_is (parser, CPP_NAME))
29188 : : break;
29189 : :
29190 : 211 : const char *p
29191 : 211 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
29192 : 211 : location_t cloc = c_parser_peek_token (parser)->location;
29193 : 211 : static const char *args[] = {
29194 : : "execution", "compilation", "warning", "fatal"
29195 : : };
29196 : 211 : int *v = NULL;
29197 : 211 : int idx = 0, n = -1;
29198 : 211 : tree m = NULL_TREE;
29199 : :
29200 : 211 : if (!strcmp (p, "at"))
29201 : : v = &at_compilation;
29202 : 127 : else if (!strcmp (p, "severity"))
29203 : : {
29204 : : v = &severity_fatal;
29205 : : idx += 2;
29206 : : }
29207 : 82 : else if (strcmp (p, "message"))
29208 : : {
29209 : 2 : error_at (cloc,
29210 : : "expected %<at%>, %<severity%> or %<message%> clause");
29211 : 2 : c_parser_skip_to_pragma_eol (parser, false);
29212 : 2 : return false;
29213 : : }
29214 : :
29215 : 209 : c_parser_consume_token (parser);
29216 : :
29217 : 209 : matching_parens parens;
29218 : 209 : if (parens.require_open (parser))
29219 : : {
29220 : 206 : if (v == NULL)
29221 : : {
29222 : 79 : location_t expr_loc = c_parser_peek_token (parser)->location;
29223 : 79 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
29224 : 79 : expr = convert_lvalue_to_rvalue (expr_loc, expr, true, true);
29225 : 79 : m = convert (const_string_type_node, expr.value);
29226 : 79 : m = c_fully_fold (m, false, NULL);
29227 : : }
29228 : : else
29229 : : {
29230 : 127 : if (c_parser_next_token_is (parser, CPP_NAME))
29231 : : {
29232 : 123 : tree val = c_parser_peek_token (parser)->value;
29233 : 123 : const char *q = IDENTIFIER_POINTER (val);
29234 : :
29235 : 123 : if (!strcmp (q, args[idx]))
29236 : : n = 0;
29237 : 40 : else if (!strcmp (q, args[idx + 1]))
29238 : : n = 1;
29239 : : }
29240 : : if (n == -1)
29241 : : {
29242 : 6 : error_at (c_parser_peek_token (parser)->location,
29243 : 6 : "expected %qs or %qs", args[idx], args[idx + 1]);
29244 : 6 : bad = true;
29245 : 6 : switch (c_parser_peek_token (parser)->type)
29246 : : {
29247 : : case CPP_EOF:
29248 : : case CPP_PRAGMA_EOL:
29249 : : case CPP_CLOSE_PAREN:
29250 : : break;
29251 : 4 : default:
29252 : 4 : if (c_parser_peek_2nd_token (parser)->type
29253 : : == CPP_CLOSE_PAREN)
29254 : 2 : c_parser_consume_token (parser);
29255 : : break;
29256 : : }
29257 : : }
29258 : : else
29259 : 121 : c_parser_consume_token (parser);
29260 : : }
29261 : :
29262 : 206 : parens.skip_until_found_close (parser);
29263 : :
29264 : 206 : if (v == NULL)
29265 : : {
29266 : 79 : if (message)
29267 : : {
29268 : 1 : error_at (cloc, "too many %qs clauses", p);
29269 : 1 : bad = true;
29270 : : }
29271 : : else
29272 : : message = m;
29273 : : }
29274 : 127 : else if (n != -1)
29275 : : {
29276 : 121 : if (*v != -1)
29277 : : {
29278 : 2 : error_at (cloc, "too many %qs clauses", p);
29279 : 2 : bad = true;
29280 : : }
29281 : : else
29282 : 119 : *v = n;
29283 : : }
29284 : : }
29285 : : else
29286 : : bad = true;
29287 : : }
29288 : 122 : c_parser_skip_to_pragma_eol (parser);
29289 : 122 : if (bad)
29290 : : return true;
29291 : :
29292 : 110 : if (at_compilation == -1)
29293 : 33 : at_compilation = 1;
29294 : 110 : if (severity_fatal == -1)
29295 : 72 : severity_fatal = 1;
29296 : 110 : if (!at_compilation)
29297 : : {
29298 : 57 : if (context != pragma_compound)
29299 : : {
29300 : 7 : error_at (loc, "%<#pragma omp error%> with %<at(execution)%> clause "
29301 : : "may only be used in compound statements");
29302 : 7 : return true;
29303 : : }
29304 : 50 : tree fndecl
29305 : 58 : = builtin_decl_explicit (severity_fatal ? BUILT_IN_GOMP_ERROR
29306 : : : BUILT_IN_GOMP_WARNING);
29307 : 50 : if (!message)
29308 : 4 : message = build_zero_cst (const_string_type_node);
29309 : 50 : tree stmt = build_call_expr_loc (loc, fndecl, 2, message,
29310 : : build_all_ones_cst (size_type_node));
29311 : 50 : add_stmt (stmt);
29312 : 50 : return true;
29313 : : }
29314 : 53 : const char *msg = NULL;
29315 : 53 : if (message)
29316 : : {
29317 : 27 : msg = c_getstr (message);
29318 : 27 : if (msg == NULL)
29319 : 6 : msg = _("<message unknown at compile time>");
29320 : : }
29321 : 15 : const enum diagnostics::kind diag_kind = (severity_fatal
29322 : 53 : ? diagnostics::kind::error
29323 : : : diagnostics::kind::warning);
29324 : 53 : if (msg)
29325 : 27 : emit_diagnostic (diag_kind, loc, 0,
29326 : : "%<pragma omp error%> encountered: %s", msg);
29327 : : else
29328 : 26 : emit_diagnostic (diag_kind, loc, 0,
29329 : : "%<pragma omp error%> encountered");
29330 : : return false;
29331 : : }
29332 : :
29333 : : /* Assumption clauses:
29334 : : OpenMP 5.1
29335 : : absent (directive-name-list)
29336 : : contains (directive-name-list)
29337 : : holds (expression)
29338 : : no_openmp
29339 : : no_openmp_routines
29340 : : no_parallelism */
29341 : :
29342 : : static void
29343 : 124 : c_parser_omp_assumption_clauses (c_parser *parser, bool is_assume)
29344 : : {
29345 : 124 : bool no_openmp = false;
29346 : 124 : bool no_openmp_routines = false;
29347 : 124 : bool no_parallelism = false;
29348 : 124 : bitmap_head absent_head, contains_head;
29349 : :
29350 : 124 : bitmap_obstack_initialize (NULL);
29351 : 124 : bitmap_initialize (&absent_head, &bitmap_default_obstack);
29352 : 124 : bitmap_initialize (&contains_head, &bitmap_default_obstack);
29353 : :
29354 : 124 : if (c_parser_next_token_is (parser, CPP_PRAGMA_EOL))
29355 : 3 : error_at (c_parser_peek_token (parser)->location,
29356 : : "expected at least one assumption clause");
29357 : :
29358 : 343 : while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
29359 : : {
29360 : 222 : if (c_parser_next_token_is (parser, CPP_COMMA)
29361 : 222 : && c_parser_peek_2nd_token (parser)->type == CPP_NAME)
29362 : 53 : c_parser_consume_token (parser);
29363 : :
29364 : 222 : if (!c_parser_next_token_is (parser, CPP_NAME))
29365 : : break;
29366 : :
29367 : 222 : const char *p
29368 : 222 : = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
29369 : 222 : location_t cloc = c_parser_peek_token (parser)->location;
29370 : :
29371 : 222 : if (!strcmp (p, "no_openmp"))
29372 : : {
29373 : 16 : c_parser_consume_token (parser);
29374 : 16 : if (no_openmp)
29375 : 3 : error_at (cloc, "too many %qs clauses", "no_openmp");
29376 : : no_openmp = true;
29377 : : }
29378 : 206 : else if (!strcmp (p, "no_openmp_routines"))
29379 : : {
29380 : 16 : c_parser_consume_token (parser);
29381 : 16 : if (no_openmp_routines)
29382 : 3 : error_at (cloc, "too many %qs clauses", "no_openmp_routines");
29383 : : no_openmp_routines = true;
29384 : : }
29385 : 190 : else if (!strcmp (p, "no_parallelism"))
29386 : : {
29387 : 18 : c_parser_consume_token (parser);
29388 : 18 : if (no_parallelism)
29389 : 3 : error_at (cloc, "too many %qs clauses", "no_parallelism");
29390 : : no_parallelism = true;
29391 : : }
29392 : 172 : else if (!strcmp (p, "holds"))
29393 : : {
29394 : 18 : c_parser_consume_token (parser);
29395 : 18 : matching_parens parens;
29396 : 18 : if (parens.require_open (parser))
29397 : : {
29398 : 18 : location_t eloc = c_parser_peek_token (parser)->location;
29399 : 18 : c_expr expr = c_parser_expr_no_commas (parser, NULL);
29400 : 18 : tree t = convert_lvalue_to_rvalue (eloc, expr, true, true).value;
29401 : 18 : t = c_objc_common_truthvalue_conversion (eloc, t);
29402 : 18 : t = c_fully_fold (t, false, NULL);
29403 : 18 : if (is_assume && t != error_mark_node)
29404 : : {
29405 : 10 : tree fn = build_call_expr_internal_loc (eloc, IFN_ASSUME,
29406 : : void_type_node, 1,
29407 : : t);
29408 : 10 : add_stmt (fn);
29409 : : }
29410 : 18 : parens.skip_until_found_close (parser);
29411 : : }
29412 : : }
29413 : 154 : else if (!strcmp (p, "absent") || !strcmp (p, "contains"))
29414 : : {
29415 : 145 : c_parser_consume_token (parser);
29416 : 145 : matching_parens parens;
29417 : 145 : if (parens.require_open (parser))
29418 : : {
29419 : 603 : do
29420 : : {
29421 : 374 : const char *directive[3] = {};
29422 : 374 : int i;
29423 : 374 : location_t dloc = c_parser_peek_token (parser)->location;
29424 : 841 : for (i = 0; i < 3; i++)
29425 : : {
29426 : 808 : tree id;
29427 : 808 : if (c_parser_peek_nth_token (parser, i + 1)->type
29428 : : == CPP_NAME)
29429 : 455 : id = c_parser_peek_nth_token (parser, i + 1)->value;
29430 : 353 : else if (c_parser_peek_nth_token (parser, i + 1)->keyword
29431 : : != RID_MAX)
29432 : : {
29433 : 12 : enum rid rid
29434 : 12 : = c_parser_peek_nth_token (parser, i + 1)->keyword;
29435 : 12 : id = ridpointers[rid];
29436 : : }
29437 : : else
29438 : : break;
29439 : 467 : directive[i] = IDENTIFIER_POINTER (id);
29440 : : }
29441 : 374 : if (i == 0)
29442 : 0 : error_at (dloc, "expected directive name");
29443 : : else
29444 : : {
29445 : 374 : const struct c_omp_directive *dir
29446 : 374 : = c_omp_categorize_directive (directive[0],
29447 : : directive[1],
29448 : : directive[2]);
29449 : 374 : if (dir
29450 : 371 : && (dir->kind == C_OMP_DIR_DECLARATIVE
29451 : 368 : || dir->kind == C_OMP_DIR_INFORMATIONAL
29452 : 356 : || dir->kind == C_OMP_DIR_META))
29453 : 15 : error_at (dloc, "invalid OpenMP directive name in "
29454 : : "%qs clause argument: declarative, "
29455 : : "informational, and meta directives "
29456 : : "not permitted", p);
29457 : 356 : else if (dir == NULL
29458 : 356 : || dir->id == PRAGMA_OMP_END
29459 : 356 : || (!dir->second && directive[1])
29460 : 347 : || (!dir->third && directive[2]))
29461 : 12 : error_at (dloc, "unknown OpenMP directive name in "
29462 : : "%qs clause argument", p);
29463 : : else
29464 : : {
29465 : 347 : int id = dir - c_omp_directives;
29466 : 392 : if (bitmap_bit_p (p[0] == 'a' ? &contains_head
29467 : : : &absent_head, id))
29468 : 18 : error_at (dloc, "%<%s%s%s%s%s%> directive "
29469 : : "mentioned in both %<absent%> and "
29470 : : "%<contains%> clauses",
29471 : : directive[0],
29472 : : directive[1] ? " " : "",
29473 : : directive[1] ? directive[1] : "",
29474 : : directive[2] ? " " : "",
29475 : : directive[2] ? directive[2] : "");
29476 : 383 : else if (!bitmap_set_bit (p[0] == 'a'
29477 : : ? &absent_head
29478 : : : &contains_head, id))
29479 : 36 : error_at (dloc, "%<%s%s%s%s%s%> directive "
29480 : : "mentioned multiple times in %qs "
29481 : : "clauses",
29482 : : directive[0],
29483 : : directive[1] ? " " : "",
29484 : : directive[1] ? directive[1] : "",
29485 : : directive[2] ? " " : "",
29486 : : directive[2] ? directive[2] : "", p);
29487 : : }
29488 : 841 : for (; i; --i)
29489 : 467 : c_parser_consume_token (parser);
29490 : : }
29491 : 374 : if (c_parser_next_token_is (parser, CPP_COMMA))
29492 : 229 : c_parser_consume_token (parser);
29493 : : else
29494 : : break;
29495 : 229 : }
29496 : : while (1);
29497 : 145 : parens.skip_until_found_close (parser);
29498 : : }
29499 : 145 : }
29500 : 9 : else if (startswith (p, "ext_"))
29501 : : {
29502 : 6 : warning_at (cloc, OPT_Wopenmp, "unknown assumption clause %qs", p);
29503 : 6 : c_parser_consume_token (parser);
29504 : 6 : if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
29505 : : {
29506 : 3 : matching_parens parens;
29507 : 3 : parens.consume_open (parser);
29508 : 3 : c_parser_balanced_token_sequence (parser);
29509 : 3 : parens.require_close (parser);
29510 : : }
29511 : : }
29512 : : else
29513 : : {
29514 : 3 : c_parser_consume_token (parser);
29515 : 3 : error_at (cloc, "expected assumption clause");
29516 : 3 : break;
29517 : : }
29518 : : }
29519 : 124 : c_parser_skip_to_pragma_eol (parser);
29520 : 124 : }
29521 : :
29522 : : /* OpenMP 5.1
29523 : : #pragma omp assume clauses[optseq] new-line */
29524 : :
29525 : : static void
29526 : 42 : c_parser_omp_assume (c_parser *parser, bool *if_p)
29527 : : {
29528 : 42 : c_parser_omp_assumption_clauses (parser, true);
29529 : 42 : add_stmt (c_parser_omp_structured_block (parser, if_p));
29530 : 42 : }
29531 : :
29532 : : /* OpenMP 5.1
29533 : : #pragma omp assumes clauses[optseq] new-line */
29534 : :
29535 : : static void
29536 : 37 : c_parser_omp_assumes (c_parser *parser)
29537 : : {
29538 : 37 : c_parser_consume_pragma (parser);
29539 : 37 : c_parser_omp_assumption_clauses (parser, false);
29540 : 37 : }
29541 : :
29542 : : /* Helper function for c_parser_omp_metadirective. */
29543 : :
29544 : : static void
29545 : 76 : analyze_metadirective_body (c_parser *parser,
29546 : : vec<c_token> &tokens,
29547 : : vec<tree> &labels)
29548 : : {
29549 : 76 : int nesting_depth = 0;
29550 : 76 : int bracket_depth = 0;
29551 : 76 : bool ignore_label = false;
29552 : :
29553 : : /* Read in the body tokens to the tokens for each candidate directive. */
29554 : 3928 : while (1)
29555 : : {
29556 : 2002 : c_token *token = c_parser_peek_token (parser);
29557 : 2002 : bool stop = false;
29558 : :
29559 : 2002 : if (c_parser_next_token_is_keyword (parser, RID_CASE))
29560 : 0 : ignore_label = true;
29561 : :
29562 : 2002 : switch (token->type)
29563 : : {
29564 : : case CPP_EOF:
29565 : : break;
29566 : 635 : case CPP_NAME:
29567 : 635 : if (!ignore_label
29568 : 635 : && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
29569 : 8 : labels.safe_push (token->value);
29570 : 635 : goto add;
29571 : 27 : case CPP_OPEN_BRACE:
29572 : 27 : ++nesting_depth;
29573 : 27 : goto add;
29574 : 27 : case CPP_CLOSE_BRACE:
29575 : 27 : if (--nesting_depth == 0 && bracket_depth == 0)
29576 : 27 : stop = true;
29577 : 27 : goto add;
29578 : 102 : case CPP_OPEN_PAREN:
29579 : 102 : ++bracket_depth;
29580 : 102 : goto add;
29581 : 102 : case CPP_CLOSE_PAREN:
29582 : 102 : --bracket_depth;
29583 : 102 : goto add;
29584 : 17 : case CPP_COLON:
29585 : 17 : ignore_label = false;
29586 : 17 : goto add;
29587 : 238 : case CPP_SEMICOLON:
29588 : 238 : if (nesting_depth == 0 && bracket_depth == 0)
29589 : 63 : stop = true;
29590 : 238 : goto add;
29591 : 2002 : default:
29592 : 2002 : add:
29593 : 2002 : tokens.safe_push (*token);
29594 : 2002 : if (token->type == CPP_PRAGMA)
29595 : 5 : c_parser_consume_pragma (parser);
29596 : 1997 : else if (token->type == CPP_PRAGMA_EOL)
29597 : 5 : c_parser_skip_to_pragma_eol (parser);
29598 : : else
29599 : 1992 : c_parser_consume_token (parser);
29600 : 2002 : if (stop)
29601 : : break;
29602 : 1926 : continue;
29603 : : }
29604 : 76 : break;
29605 : 1926 : }
29606 : 76 : }
29607 : :
29608 : : /* OpenMP 5.0:
29609 : :
29610 : : # pragma omp metadirective [clause[, clause]]
29611 : : */
29612 : :
29613 : : static void
29614 : 108 : c_parser_omp_metadirective (c_parser *parser, bool *if_p)
29615 : : {
29616 : 108 : static unsigned int metadirective_region_count = 0;
29617 : :
29618 : 108 : tree ret;
29619 : 108 : auto_vec<c_token> directive_tokens;
29620 : 108 : auto_vec<c_token> body_tokens;
29621 : 108 : auto_vec<tree> body_labels;
29622 : 108 : auto_vec<const struct c_omp_directive *> directives;
29623 : 108 : auto_vec<tree> ctxs;
29624 : 108 : vec<struct omp_variant> candidates;
29625 : 108 : bool default_seen = false;
29626 : 108 : int directive_token_idx = 0;
29627 : 108 : tree standalone_body = NULL_TREE;
29628 : 108 : location_t pragma_loc = c_parser_peek_token (parser)->location;
29629 : 108 : bool requires_body = false;
29630 : :
29631 : 108 : ret = make_node (OMP_METADIRECTIVE);
29632 : 108 : SET_EXPR_LOCATION (ret, pragma_loc);
29633 : 108 : TREE_TYPE (ret) = void_type_node;
29634 : 108 : OMP_METADIRECTIVE_VARIANTS (ret) = NULL_TREE;
29635 : :
29636 : 108 : c_parser_consume_pragma (parser);
29637 : 410 : while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
29638 : : {
29639 : 210 : if (c_parser_next_token_is (parser, CPP_COMMA))
29640 : 15 : c_parser_consume_token (parser);
29641 : 210 : if (c_parser_next_token_is_not (parser, CPP_NAME)
29642 : 272 : && c_parser_next_token_is_not (parser, CPP_KEYWORD))
29643 : : {
29644 : 0 : c_parser_error (parser, "expected %<when%>, "
29645 : : "%<otherwise%>, or %<default%> clause");
29646 : 0 : goto error;
29647 : : }
29648 : :
29649 : 210 : location_t match_loc = c_parser_peek_token (parser)->location;
29650 : 210 : const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
29651 : 210 : c_parser_consume_token (parser);
29652 : 420 : bool default_p
29653 : 210 : = strcmp (p, "default") == 0 || strcmp (p, "otherwise") == 0;
29654 : 131 : if (default_p)
29655 : : {
29656 : 79 : if (default_seen)
29657 : : {
29658 : 4 : error_at (match_loc, "too many %<otherwise%> or %<default%> "
29659 : : "clauses in %<metadirective%>");
29660 : 4 : goto error;
29661 : : }
29662 : : default_seen = true;
29663 : : }
29664 : 131 : else if (default_seen)
29665 : : {
29666 : 2 : error_at (match_loc, "%<otherwise%> or %<default%> clause "
29667 : : "must appear last in %<metadirective%>");
29668 : 2 : goto error;
29669 : : }
29670 : 204 : if (!default_p && strcmp (p, "when") != 0)
29671 : : {
29672 : 2 : error_at (match_loc, "%qs is not valid for %qs",
29673 : : p, "metadirective");
29674 : 2 : goto error;
29675 : : }
29676 : :
29677 : 202 : matching_parens parens;
29678 : 202 : tree ctx = NULL_TREE;
29679 : 202 : bool skip = false;
29680 : :
29681 : 202 : if (!parens.require_open (parser))
29682 : 0 : goto error;
29683 : :
29684 : 202 : if (!default_p)
29685 : : {
29686 : 127 : ctx = c_parser_omp_context_selector_specification (parser,
29687 : : NULL_TREE);
29688 : 127 : if (ctx == error_mark_node)
29689 : 2 : goto error;
29690 : 125 : ctx = omp_check_context_selector (match_loc, ctx,
29691 : : OMP_CTX_METADIRECTIVE);
29692 : 125 : if (ctx == error_mark_node)
29693 : 0 : goto error;
29694 : :
29695 : : /* Remove the selector from further consideration if it can be
29696 : : evaluated as a non-match at this point. */
29697 : 125 : skip = (omp_context_selector_matches (ctx, NULL_TREE, false) == 0);
29698 : :
29699 : 125 : if (c_parser_next_token_is_not (parser, CPP_COLON))
29700 : : {
29701 : 2 : c_parser_require (parser, CPP_COLON, "expected %<:%>");
29702 : 2 : goto error;
29703 : : }
29704 : 123 : c_parser_consume_token (parser);
29705 : : }
29706 : :
29707 : : /* Read in the directive type and create a dummy pragma token for
29708 : : it. */
29709 : 198 : location_t loc = c_parser_peek_token (parser)->location;
29710 : :
29711 : 198 : const char *directive[3] = {};
29712 : 198 : int i;
29713 : 554 : for (i = 0; i < 3; i++)
29714 : : {
29715 : 534 : tree id;
29716 : 534 : if (c_parser_peek_nth_token (parser, i + 1)->type
29717 : : == CPP_CLOSE_PAREN)
29718 : : {
29719 : 114 : if (i == 0)
29720 : 1 : directive[i++] = "nothing";
29721 : : break;
29722 : : }
29723 : 420 : else if (c_parser_peek_nth_token (parser, i + 1)->type
29724 : : == CPP_NAME)
29725 : 279 : id = c_parser_peek_nth_token (parser, i + 1)->value;
29726 : 141 : else if (c_parser_peek_nth_token (parser, i + 1)->keyword
29727 : : != RID_MAX)
29728 : : {
29729 : 77 : enum rid rid
29730 : 77 : = c_parser_peek_nth_token (parser, i + 1)->keyword;
29731 : 77 : id = ridpointers[rid];
29732 : : }
29733 : : else
29734 : : break;
29735 : :
29736 : 356 : directive[i] = IDENTIFIER_POINTER (id);
29737 : : }
29738 : 85 : if (i == 0)
29739 : : {
29740 : 0 : error_at (loc, "expected directive name");
29741 : 0 : goto error;
29742 : : }
29743 : :
29744 : 198 : const struct c_omp_directive *omp_directive
29745 : 198 : = c_omp_categorize_directive (directive[0],
29746 : : directive[1],
29747 : 198 : directive[2]);
29748 : :
29749 : 198 : if (omp_directive == NULL)
29750 : : {
29751 : 4 : for (int j = 0; j < i; j++)
29752 : 2 : c_parser_consume_token (parser);
29753 : 2 : c_parser_error (parser, "unknown directive name");
29754 : 2 : goto error;
29755 : : }
29756 : : else
29757 : : {
29758 : 196 : int token_count = 0;
29759 : 196 : if (omp_directive->first) token_count++;
29760 : 196 : if (omp_directive->second) token_count++;
29761 : 196 : if (omp_directive->third) token_count++;
29762 : 392 : for (int j = 0; j < token_count; j++)
29763 : 196 : c_parser_consume_token (parser);
29764 : : }
29765 : 196 : if (omp_directive->id == PRAGMA_OMP_METADIRECTIVE)
29766 : : {
29767 : 2 : c_parser_error (parser,
29768 : : "metadirectives cannot be used as variants of a "
29769 : : "%<metadirective%>");
29770 : 2 : goto error;
29771 : : }
29772 : 194 : if (omp_directive->kind == C_OMP_DIR_DECLARATIVE)
29773 : : {
29774 : 0 : sorry_at (loc, "declarative directive variants of a "
29775 : : "%<metadirective%> are not supported");
29776 : 0 : goto error;
29777 : : }
29778 : 194 : if (omp_directive->kind == C_OMP_DIR_CONSTRUCT)
29779 : 116 : requires_body = true;
29780 : :
29781 : 194 : if (!skip)
29782 : : {
29783 : 161 : c_token pragma_token;
29784 : 161 : pragma_token.type = CPP_PRAGMA;
29785 : 161 : pragma_token.location = loc;
29786 : 161 : pragma_token.pragma_kind = (enum pragma_kind) omp_directive->id;
29787 : :
29788 : 161 : directives.safe_push (omp_directive);
29789 : 161 : directive_tokens.safe_push (pragma_token);
29790 : 161 : ctxs.safe_push (ctx);
29791 : : }
29792 : :
29793 : : /* Read in tokens for the directive clauses. */
29794 : : int nesting_depth = 0;
29795 : 1480 : while (1)
29796 : : {
29797 : 837 : c_token *token = c_parser_peek_token (parser);
29798 : 837 : switch (token->type)
29799 : : {
29800 : : case CPP_EOF:
29801 : : case CPP_PRAGMA_EOL:
29802 : : break;
29803 : 117 : case CPP_OPEN_PAREN:
29804 : 117 : ++nesting_depth;
29805 : 117 : goto add;
29806 : 310 : case CPP_CLOSE_PAREN:
29807 : 310 : if (nesting_depth-- == 0)
29808 : : {
29809 : 193 : c_parser_consume_token (parser);
29810 : 193 : break;
29811 : : }
29812 : 117 : goto add;
29813 : 643 : default:
29814 : 643 : add:
29815 : 643 : if (!skip)
29816 : 550 : directive_tokens.safe_push (*token);
29817 : 643 : c_parser_consume_token (parser);
29818 : 643 : continue;
29819 : : }
29820 : 194 : break;
29821 : 643 : }
29822 : :
29823 : 194 : if (!skip)
29824 : : {
29825 : 161 : c_token eol_token;
29826 : 161 : memset (&eol_token, 0, sizeof (eol_token));
29827 : 161 : eol_token.type = CPP_PRAGMA_EOL;
29828 : 161 : directive_tokens.safe_push (eol_token);
29829 : : }
29830 : : }
29831 : 92 : c_parser_skip_to_pragma_eol (parser);
29832 : :
29833 : 92 : if (!default_seen)
29834 : : {
29835 : : /* Add a default clause that evaluates to 'omp nothing'. */
29836 : 27 : const struct c_omp_directive *omp_directive
29837 : 27 : = c_omp_categorize_directive ("nothing", NULL, NULL);
29838 : :
29839 : 27 : c_token pragma_token;
29840 : 27 : pragma_token.type = CPP_PRAGMA;
29841 : 27 : pragma_token.location = UNKNOWN_LOCATION;
29842 : 27 : pragma_token.pragma_kind = PRAGMA_OMP_NOTHING;
29843 : :
29844 : 27 : directives.safe_push (omp_directive);
29845 : 27 : directive_tokens.safe_push (pragma_token);
29846 : 27 : ctxs.safe_push (NULL_TREE);
29847 : :
29848 : 27 : c_token eol_token;
29849 : 27 : memset (&eol_token, 0, sizeof (eol_token));
29850 : 27 : eol_token.type = CPP_PRAGMA_EOL;
29851 : 27 : directive_tokens.safe_push (eol_token);
29852 : : }
29853 : :
29854 : 92 : if (requires_body)
29855 : 76 : analyze_metadirective_body (parser, body_tokens, body_labels);
29856 : :
29857 : : /* Process each candidate directive. */
29858 : : unsigned i;
29859 : : tree ctx;
29860 : :
29861 : 274 : FOR_EACH_VEC_ELT (ctxs, i, ctx)
29862 : : {
29863 : 182 : auto_vec<c_token> tokens;
29864 : :
29865 : : /* Add the directive tokens. */
29866 : 908 : do
29867 : 908 : tokens.safe_push (directive_tokens [directive_token_idx++]);
29868 : 908 : while (tokens.last ().type != CPP_PRAGMA_EOL);
29869 : :
29870 : : /* Add the body tokens. */
29871 : 182 : gcc_assert (requires_body || body_tokens.is_empty ());
29872 : 4042 : for (unsigned j = 0; j < body_tokens.length (); j++)
29873 : 3860 : tokens.safe_push (body_tokens[j]);
29874 : :
29875 : : /* Make sure nothing tries to read past the end of the tokens. */
29876 : 182 : c_token eof_token;
29877 : 182 : memset (&eof_token, 0, sizeof (eof_token));
29878 : 182 : eof_token.type = CPP_EOF;
29879 : 182 : tokens.safe_push (eof_token);
29880 : 182 : tokens.safe_push (eof_token);
29881 : :
29882 : 182 : unsigned int old_tokens_avail = parser->tokens_avail;
29883 : 182 : c_token *old_tokens = parser->tokens;
29884 : 182 : struct omp_attribute_pragma_state *old_in_omp_attribute_pragma
29885 : : = parser->in_omp_attribute_pragma;
29886 : 182 : struct omp_metadirective_parse_data *old_state
29887 : : = parser->omp_metadirective_state;
29888 : :
29889 : 182 : struct omp_metadirective_parse_data new_state;
29890 : 182 : new_state.body_labels = &body_labels;
29891 : 182 : new_state.region_num = ++metadirective_region_count;
29892 : :
29893 : 182 : parser->tokens = tokens.address ();
29894 : 182 : parser->tokens_avail = tokens.length ();
29895 : 182 : parser->in_omp_attribute_pragma = NULL;
29896 : 182 : parser->omp_metadirective_state = &new_state;
29897 : :
29898 : 182 : int prev_errorcount = errorcount;
29899 : 182 : tree directive = c_begin_compound_stmt (true);
29900 : :
29901 : 182 : c_parser_pragma (parser, pragma_compound, if_p, NULL_TREE);
29902 : 182 : directive = c_end_compound_stmt (pragma_loc, directive, true);
29903 : 182 : bool standalone_p
29904 : 182 : = directives[i]->kind == C_OMP_DIR_STANDALONE
29905 : 182 : || directives[i]->kind == C_OMP_DIR_UTILITY;
29906 : 96 : if (standalone_p && requires_body)
29907 : : {
29908 : : /* Parsing standalone directives will not consume the body
29909 : : tokens, so do that here. */
29910 : 58 : if (standalone_body == NULL_TREE)
29911 : : {
29912 : 56 : standalone_body = push_stmt_list ();
29913 : 56 : c_parser_statement (parser, if_p);
29914 : 56 : standalone_body = pop_stmt_list (standalone_body);
29915 : : }
29916 : : else
29917 : 2 : c_parser_skip_to_end_of_block_or_statement (parser, true);
29918 : : }
29919 : :
29920 : 182 : tree body = standalone_p ? standalone_body : NULL_TREE;
29921 : 182 : tree variant = make_omp_metadirective_variant (ctx, directive, body);
29922 : 364 : OMP_METADIRECTIVE_VARIANTS (ret)
29923 : 182 : = chainon (OMP_METADIRECTIVE_VARIANTS (ret), variant);
29924 : :
29925 : : /* Check that all valid tokens have been consumed if no parse errors
29926 : : encountered. */
29927 : 182 : if (errorcount == prev_errorcount)
29928 : : {
29929 : 179 : gcc_assert (parser->tokens_avail == 2);
29930 : 179 : gcc_assert (c_parser_next_token_is (parser, CPP_EOF));
29931 : 179 : gcc_assert (c_parser_peek_2nd_token (parser)->type == CPP_EOF);
29932 : : }
29933 : :
29934 : 182 : parser->tokens = old_tokens;
29935 : 182 : parser->tokens_avail = old_tokens_avail;
29936 : 182 : parser->in_omp_attribute_pragma = old_in_omp_attribute_pragma;
29937 : 182 : parser->omp_metadirective_state = old_state;
29938 : 182 : }
29939 : :
29940 : : /* Try to resolve the metadirective early. */
29941 : 92 : candidates = omp_early_resolve_metadirective (ret);
29942 : 92 : if (!candidates.is_empty ())
29943 : 68 : ret = c_omp_expand_variant_construct (candidates);
29944 : :
29945 : 92 : add_stmt (ret);
29946 : 92 : return;
29947 : :
29948 : 16 : error:
29949 : : /* Skip the metadirective pragma. Do not skip the metadirective body. */
29950 : 16 : if (parser->in_pragma)
29951 : 16 : c_parser_skip_to_pragma_eol (parser, false);
29952 : 108 : }
29953 : :
29954 : : /* Main entry point to parsing most OpenMP pragmas. */
29955 : :
29956 : : static void
29957 : 17230 : c_parser_omp_construct (c_parser *parser, bool *if_p)
29958 : : {
29959 : 17230 : enum pragma_kind p_kind;
29960 : 17230 : location_t loc;
29961 : 17230 : tree stmt;
29962 : 17230 : char p_name[sizeof "#pragma omp teams distribute parallel for simd"];
29963 : 17230 : omp_clause_mask mask (0);
29964 : :
29965 : 17230 : loc = c_parser_peek_token (parser)->location;
29966 : 17230 : p_kind = c_parser_peek_token (parser)->pragma_kind;
29967 : 17230 : c_parser_consume_pragma (parser);
29968 : :
29969 : 17230 : switch (p_kind)
29970 : : {
29971 : 309 : case PRAGMA_OACC_ATOMIC:
29972 : 309 : c_parser_omp_atomic (loc, parser, true);
29973 : 2069 : return;
29974 : 137 : case PRAGMA_OACC_CACHE:
29975 : 137 : strcpy (p_name, "#pragma acc");
29976 : 137 : stmt = c_parser_oacc_cache (loc, parser);
29977 : 137 : break;
29978 : 497 : case PRAGMA_OACC_DATA:
29979 : 497 : stmt = c_parser_oacc_data (loc, parser, if_p);
29980 : 497 : break;
29981 : 23 : case PRAGMA_OACC_HOST_DATA:
29982 : 23 : stmt = c_parser_oacc_host_data (loc, parser, if_p);
29983 : 23 : break;
29984 : 2154 : case PRAGMA_OACC_KERNELS:
29985 : 2154 : case PRAGMA_OACC_PARALLEL:
29986 : 2154 : case PRAGMA_OACC_SERIAL:
29987 : 2154 : strcpy (p_name, "#pragma acc");
29988 : 2154 : stmt = c_parser_oacc_compute (loc, parser, p_kind, p_name, if_p);
29989 : 2154 : break;
29990 : 1771 : case PRAGMA_OACC_LOOP:
29991 : 1771 : strcpy (p_name, "#pragma acc");
29992 : 1771 : stmt = c_parser_oacc_loop (loc, parser, p_name, mask, NULL, if_p);
29993 : 1771 : break;
29994 : 86 : case PRAGMA_OACC_WAIT:
29995 : 86 : strcpy (p_name, "#pragma wait");
29996 : 86 : stmt = c_parser_oacc_wait (loc, parser, p_name);
29997 : 86 : break;
29998 : 1409 : case PRAGMA_OMP_ATOMIC:
29999 : 1409 : c_parser_omp_atomic (loc, parser, false);
30000 : 1409 : return;
30001 : 144 : case PRAGMA_OMP_CRITICAL:
30002 : 144 : stmt = c_parser_omp_critical (loc, parser, if_p);
30003 : 144 : break;
30004 : 1314 : case PRAGMA_OMP_DISTRIBUTE:
30005 : 1314 : strcpy (p_name, "#pragma omp");
30006 : 1314 : stmt = c_parser_omp_distribute (loc, parser, p_name, mask, NULL, if_p);
30007 : 1314 : break;
30008 : 1806 : case PRAGMA_OMP_FOR:
30009 : 1806 : strcpy (p_name, "#pragma omp");
30010 : 1806 : stmt = c_parser_omp_for (loc, parser, p_name, mask, NULL, if_p);
30011 : 1806 : break;
30012 : 157 : case PRAGMA_OMP_LOOP:
30013 : 157 : strcpy (p_name, "#pragma omp");
30014 : 157 : stmt = c_parser_omp_loop (loc, parser, p_name, mask, NULL, if_p);
30015 : 157 : break;
30016 : 60 : case PRAGMA_OMP_MASKED:
30017 : 60 : strcpy (p_name, "#pragma omp");
30018 : 60 : stmt = c_parser_omp_masked (loc, parser, p_name, mask, NULL, if_p);
30019 : 60 : break;
30020 : 142 : case PRAGMA_OMP_MASTER:
30021 : 142 : strcpy (p_name, "#pragma omp");
30022 : 142 : stmt = c_parser_omp_master (loc, parser, p_name, mask, NULL, if_p);
30023 : 142 : break;
30024 : 2478 : case PRAGMA_OMP_PARALLEL:
30025 : 2478 : strcpy (p_name, "#pragma omp");
30026 : 2478 : stmt = c_parser_omp_parallel (loc, parser, p_name, mask, NULL, if_p);
30027 : 2478 : break;
30028 : 61 : case PRAGMA_OMP_SCOPE:
30029 : 61 : stmt = c_parser_omp_scope (loc, parser, if_p);
30030 : 61 : break;
30031 : 106 : case PRAGMA_OMP_SECTIONS:
30032 : 106 : strcpy (p_name, "#pragma omp");
30033 : 106 : stmt = c_parser_omp_sections (loc, parser, p_name, mask, NULL);
30034 : 106 : break;
30035 : 726 : case PRAGMA_OMP_SIMD:
30036 : 726 : strcpy (p_name, "#pragma omp");
30037 : 726 : stmt = c_parser_omp_simd (loc, parser, p_name, mask, NULL, if_p);
30038 : 726 : break;
30039 : 222 : case PRAGMA_OMP_SINGLE:
30040 : 222 : stmt = c_parser_omp_single (loc, parser, if_p);
30041 : 222 : break;
30042 : 894 : case PRAGMA_OMP_TASK:
30043 : 894 : stmt = c_parser_omp_task (loc, parser, if_p);
30044 : 894 : break;
30045 : 138 : case PRAGMA_OMP_TASKGROUP:
30046 : 138 : stmt = c_parser_omp_taskgroup (loc, parser, if_p);
30047 : 138 : break;
30048 : 256 : case PRAGMA_OMP_TASKLOOP:
30049 : 256 : strcpy (p_name, "#pragma omp");
30050 : 256 : stmt = c_parser_omp_taskloop (loc, parser, p_name, mask, NULL, if_p);
30051 : 256 : break;
30052 : 1931 : case PRAGMA_OMP_TEAMS:
30053 : 1931 : strcpy (p_name, "#pragma omp");
30054 : 1931 : stmt = c_parser_omp_teams (loc, parser, p_name, mask, NULL, if_p);
30055 : 1931 : break;
30056 : 42 : case PRAGMA_OMP_ASSUME:
30057 : 42 : c_parser_omp_assume (parser, if_p);
30058 : 42 : return;
30059 : 110 : case PRAGMA_OMP_TILE:
30060 : 110 : stmt = c_parser_omp_tile (loc, parser, if_p);
30061 : 110 : break;
30062 : 105 : case PRAGMA_OMP_UNROLL:
30063 : 105 : stmt = c_parser_omp_unroll (loc, parser, if_p);
30064 : 105 : break;
30065 : 152 : case PRAGMA_OMP_DISPATCH:
30066 : 152 : stmt = c_parser_omp_dispatch (loc, parser);
30067 : 152 : break;
30068 : 0 : default:
30069 : 0 : gcc_unreachable ();
30070 : : }
30071 : :
30072 : 15470 : if (stmt && stmt != error_mark_node)
30073 : 15162 : gcc_assert (EXPR_LOCATION (stmt) != UNKNOWN_LOCATION);
30074 : : }
30075 : :
30076 : :
30077 : : /* OpenMP 2.5:
30078 : : # pragma omp threadprivate (variable-list) */
30079 : :
30080 : : static void
30081 : 78 : c_parser_omp_threadprivate (c_parser *parser)
30082 : : {
30083 : 78 : tree vars, t;
30084 : 78 : location_t loc;
30085 : :
30086 : 78 : c_parser_consume_pragma (parser);
30087 : 78 : vars = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
30088 : :
30089 : : /* Mark every variable in VARS to be assigned thread local storage. */
30090 : 167 : for (t = vars; t; t = TREE_CHAIN (t))
30091 : : {
30092 : 89 : tree v = TREE_PURPOSE (t);
30093 : 89 : loc = EXPR_LOCATION (TREE_VALUE (t));
30094 : :
30095 : : /* If V had already been marked threadprivate, it doesn't matter
30096 : : whether it had been used prior to this point. */
30097 : 89 : if (!VAR_P (v))
30098 : 1 : error_at (loc, "%qD is not a variable", v);
30099 : 88 : else if (TREE_USED (v) && !C_DECL_THREADPRIVATE_P (v))
30100 : 2 : error_at (loc, "%qE declared %<threadprivate%> after first use", v);
30101 : 86 : else if (! is_global_var (v))
30102 : 2 : error_at (loc, "automatic variable %qE cannot be %<threadprivate%>", v);
30103 : 84 : else if (TREE_TYPE (v) == error_mark_node)
30104 : : ;
30105 : 83 : else if (! COMPLETE_TYPE_P (TREE_TYPE (v)))
30106 : 1 : error_at (loc, "%<threadprivate%> %qE has incomplete type", v);
30107 : : else
30108 : : {
30109 : 82 : if (! DECL_THREAD_LOCAL_P (v))
30110 : : {
30111 : 82 : set_decl_tls_model (v, decl_default_tls_model (v));
30112 : : /* If rtl has been already set for this var, call
30113 : : make_decl_rtl once again, so that encode_section_info
30114 : : has a chance to look at the new decl flags. */
30115 : 82 : if (DECL_RTL_SET_P (v))
30116 : 0 : make_decl_rtl (v);
30117 : : }
30118 : 82 : C_DECL_THREADPRIVATE_P (v) = 1;
30119 : : }
30120 : : }
30121 : :
30122 : 78 : c_parser_skip_to_pragma_eol (parser);
30123 : 78 : }
30124 : :
30125 : : /* Parse a transaction attribute (GCC Extension).
30126 : :
30127 : : transaction-attribute:
30128 : : gnu-attributes
30129 : : attribute-specifier
30130 : : */
30131 : :
30132 : : static tree
30133 : 139 : c_parser_transaction_attributes (c_parser *parser)
30134 : : {
30135 : 139 : if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
30136 : 0 : return c_parser_gnu_attributes (parser);
30137 : :
30138 : 139 : if (!c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
30139 : : return NULL_TREE;
30140 : 20 : return c_parser_std_attribute_specifier (parser, true);
30141 : : }
30142 : :
30143 : : /* Parse a __transaction_atomic or __transaction_relaxed statement
30144 : : (GCC Extension).
30145 : :
30146 : : transaction-statement:
30147 : : __transaction_atomic transaction-attribute[opt] compound-statement
30148 : : __transaction_relaxed compound-statement
30149 : :
30150 : : Note that the only valid attribute is: "outer".
30151 : : */
30152 : :
30153 : : static tree
30154 : 137 : c_parser_transaction (c_parser *parser, enum rid keyword)
30155 : : {
30156 : 137 : unsigned int old_in = parser->in_transaction;
30157 : 137 : unsigned int this_in = 1, new_in;
30158 : 137 : location_t loc = c_parser_peek_token (parser)->location;
30159 : 137 : tree stmt, attrs;
30160 : :
30161 : 274 : gcc_assert ((keyword == RID_TRANSACTION_ATOMIC
30162 : : || keyword == RID_TRANSACTION_RELAXED)
30163 : : && c_parser_next_token_is_keyword (parser, keyword));
30164 : 137 : c_parser_consume_token (parser);
30165 : :
30166 : 137 : if (keyword == RID_TRANSACTION_RELAXED)
30167 : : this_in |= TM_STMT_ATTR_RELAXED;
30168 : : else
30169 : : {
30170 : 106 : attrs = c_parser_transaction_attributes (parser);
30171 : 106 : if (attrs)
30172 : 14 : this_in |= parse_tm_stmt_attr (attrs, TM_STMT_ATTR_OUTER);
30173 : : }
30174 : :
30175 : : /* Keep track if we're in the lexical scope of an outer transaction. */
30176 : 137 : new_in = this_in | (old_in & TM_STMT_ATTR_OUTER);
30177 : :
30178 : 137 : parser->in_transaction = new_in;
30179 : 137 : stmt = c_parser_compound_statement (parser);
30180 : 137 : parser->in_transaction = old_in;
30181 : :
30182 : 137 : if (flag_tm)
30183 : 135 : stmt = c_finish_transaction (loc, stmt, this_in);
30184 : : else
30185 : 2 : error_at (loc,
30186 : : keyword == RID_TRANSACTION_ATOMIC
30187 : : ? G_("%<__transaction_atomic%> without transactional memory "
30188 : : "support enabled")
30189 : : : G_("%<__transaction_relaxed%> without transactional memory "
30190 : : "support enabled"));
30191 : :
30192 : 137 : return stmt;
30193 : : }
30194 : :
30195 : : /* Parse a __transaction_atomic or __transaction_relaxed expression
30196 : : (GCC Extension).
30197 : :
30198 : : transaction-expression:
30199 : : __transaction_atomic ( expression )
30200 : : __transaction_relaxed ( expression )
30201 : : */
30202 : :
30203 : : static struct c_expr
30204 : 7 : c_parser_transaction_expression (c_parser *parser, enum rid keyword)
30205 : : {
30206 : 7 : struct c_expr ret;
30207 : 7 : unsigned int old_in = parser->in_transaction;
30208 : 7 : unsigned int this_in = 1;
30209 : 7 : location_t loc = c_parser_peek_token (parser)->location;
30210 : 7 : tree attrs;
30211 : :
30212 : 14 : gcc_assert ((keyword == RID_TRANSACTION_ATOMIC
30213 : : || keyword == RID_TRANSACTION_RELAXED)
30214 : : && c_parser_next_token_is_keyword (parser, keyword));
30215 : 7 : c_parser_consume_token (parser);
30216 : :
30217 : 7 : if (keyword == RID_TRANSACTION_RELAXED)
30218 : : this_in |= TM_STMT_ATTR_RELAXED;
30219 : : else
30220 : : {
30221 : 5 : attrs = c_parser_transaction_attributes (parser);
30222 : 5 : if (attrs)
30223 : 0 : this_in |= parse_tm_stmt_attr (attrs, 0);
30224 : : }
30225 : :
30226 : 7 : parser->in_transaction = this_in;
30227 : 7 : matching_parens parens;
30228 : 7 : if (parens.require_open (parser))
30229 : : {
30230 : 7 : tree expr = c_parser_expression (parser).value;
30231 : 7 : ret.original_type = TREE_TYPE (expr);
30232 : 7 : ret.value = build1 (TRANSACTION_EXPR, ret.original_type, expr);
30233 : 7 : if (this_in & TM_STMT_ATTR_RELAXED)
30234 : 2 : TRANSACTION_EXPR_RELAXED (ret.value) = 1;
30235 : 7 : SET_EXPR_LOCATION (ret.value, loc);
30236 : 7 : ret.original_code = TRANSACTION_EXPR;
30237 : 7 : ret.m_decimal = 0;
30238 : 7 : if (!parens.require_close (parser))
30239 : : {
30240 : 0 : c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
30241 : 0 : goto error;
30242 : : }
30243 : : }
30244 : : else
30245 : : {
30246 : 0 : error:
30247 : 0 : ret.set_error ();
30248 : 0 : ret.original_code = ERROR_MARK;
30249 : 0 : ret.original_type = NULL;
30250 : : }
30251 : 7 : parser->in_transaction = old_in;
30252 : :
30253 : 7 : if (!flag_tm)
30254 : 6 : error_at (loc,
30255 : : keyword == RID_TRANSACTION_ATOMIC
30256 : : ? G_("%<__transaction_atomic%> without transactional memory "
30257 : : "support enabled")
30258 : : : G_("%<__transaction_relaxed%> without transactional memory "
30259 : : "support enabled"));
30260 : :
30261 : 7 : set_c_expr_source_range (&ret, loc, loc);
30262 : :
30263 : 7 : return ret;
30264 : : }
30265 : :
30266 : : /* Parse a __transaction_cancel statement (GCC Extension).
30267 : :
30268 : : transaction-cancel-statement:
30269 : : __transaction_cancel transaction-attribute[opt] ;
30270 : :
30271 : : Note that the only valid attribute is "outer".
30272 : : */
30273 : :
30274 : : static tree
30275 : 28 : c_parser_transaction_cancel (c_parser *parser)
30276 : : {
30277 : 28 : location_t loc = c_parser_peek_token (parser)->location;
30278 : 28 : tree attrs;
30279 : 28 : bool is_outer = false;
30280 : :
30281 : 28 : gcc_assert (c_parser_next_token_is_keyword (parser, RID_TRANSACTION_CANCEL));
30282 : 28 : c_parser_consume_token (parser);
30283 : :
30284 : 28 : attrs = c_parser_transaction_attributes (parser);
30285 : 28 : if (attrs)
30286 : 5 : is_outer = (parse_tm_stmt_attr (attrs, TM_STMT_ATTR_OUTER) != 0);
30287 : :
30288 : 28 : if (!flag_tm)
30289 : : {
30290 : 2 : error_at (loc, "%<__transaction_cancel%> without "
30291 : : "transactional memory support enabled");
30292 : 2 : goto ret_error;
30293 : : }
30294 : 26 : else if (parser->in_transaction & TM_STMT_ATTR_RELAXED)
30295 : : {
30296 : 0 : error_at (loc, "%<__transaction_cancel%> within a "
30297 : : "%<__transaction_relaxed%>");
30298 : 0 : goto ret_error;
30299 : : }
30300 : 26 : else if (is_outer)
30301 : : {
30302 : 5 : if ((parser->in_transaction & TM_STMT_ATTR_OUTER) == 0
30303 : 5 : && !is_tm_may_cancel_outer (current_function_decl))
30304 : : {
30305 : 0 : error_at (loc, "outer %<__transaction_cancel%> not "
30306 : : "within outer %<__transaction_atomic%> or "
30307 : : "a %<transaction_may_cancel_outer%> function");
30308 : 0 : goto ret_error;
30309 : : }
30310 : : }
30311 : 21 : else if (parser->in_transaction == 0)
30312 : : {
30313 : 0 : error_at (loc, "%<__transaction_cancel%> not within "
30314 : : "%<__transaction_atomic%>");
30315 : 0 : goto ret_error;
30316 : : }
30317 : :
30318 : 26 : return add_stmt (build_tm_abort_call (loc, is_outer));
30319 : :
30320 : 2 : ret_error:
30321 : 2 : return build1 (NOP_EXPR, void_type_node, error_mark_node);
30322 : : }
30323 : :
30324 : : /* Parse a single source file. */
30325 : :
30326 : : void
30327 : 104490 : c_parse_file (void)
30328 : : {
30329 : : /* Use local storage to begin. If the first token is a pragma, parse it.
30330 : : If it is #pragma GCC pch_preprocess, then this will load a PCH file
30331 : : which will cause garbage collection. */
30332 : 104490 : c_parser tparser;
30333 : :
30334 : 104490 : memset (&tparser, 0, sizeof tparser);
30335 : 104490 : tparser.translate_strings_p = true;
30336 : 104490 : tparser.tokens = &tparser.tokens_buf[0];
30337 : 104490 : the_parser = &tparser;
30338 : :
30339 : 104490 : if (c_parser_peek_token (&tparser)->pragma_kind == PRAGMA_GCC_PCH_PREPROCESS)
30340 : 12 : c_parser_pragma_pch_preprocess (&tparser);
30341 : : else
30342 : 104410 : c_common_no_more_pch ();
30343 : :
30344 : 104422 : the_parser = ggc_alloc<c_parser> ();
30345 : 104422 : *the_parser = tparser;
30346 : 104422 : if (tparser.tokens == &tparser.tokens_buf[0])
30347 : 104422 : the_parser->tokens = &the_parser->tokens_buf[0];
30348 : :
30349 : : /* Initialize EH, if we've been told to do so. */
30350 : 104422 : if (flag_exceptions)
30351 : 507 : using_eh_for_cleanups ();
30352 : :
30353 : 104422 : c_parser_translation_unit (the_parser);
30354 : 104332 : the_parser = NULL;
30355 : 104332 : }
30356 : :
30357 : : void
30358 : 5377 : c_init_preprocess (void)
30359 : : {
30360 : : /* Create a parser for use by pragma_lex during preprocessing. */
30361 : 5377 : the_parser = ggc_alloc<c_parser> ();
30362 : 5377 : memset (the_parser, 0, sizeof (c_parser));
30363 : 5377 : the_parser->tokens = &the_parser->tokens_buf[0];
30364 : 5377 : }
30365 : :
30366 : : /* Parse the body of a function declaration marked with "__RTL".
30367 : :
30368 : : The RTL parser works on the level of characters read from a
30369 : : FILE *, whereas c_parser works at the level of tokens.
30370 : : Square this circle by consuming all of the tokens up to and
30371 : : including the closing brace, recording the start/end of the RTL
30372 : : fragment, and reopening the file and re-reading the relevant
30373 : : lines within the RTL parser.
30374 : :
30375 : : This requires the opening and closing braces of the C function
30376 : : to be on separate lines from the RTL they wrap.
30377 : :
30378 : : Take ownership of START_WITH_PASS, if non-NULL. */
30379 : :
30380 : : location_t
30381 : 25 : c_parser_parse_rtl_body (c_parser *parser, char *start_with_pass)
30382 : : {
30383 : 25 : if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
30384 : : {
30385 : 0 : free (start_with_pass);
30386 : 0 : return c_parser_peek_token (parser)->location;
30387 : : }
30388 : :
30389 : 25 : location_t start_loc = c_parser_peek_token (parser)->location;
30390 : :
30391 : : /* Consume all tokens, up to the closing brace, handling
30392 : : matching pairs of braces in the rtl dump. */
30393 : 25 : int num_open_braces = 1;
30394 : 25239 : while (1)
30395 : : {
30396 : 12632 : switch (c_parser_peek_token (parser)->type)
30397 : : {
30398 : 1 : case CPP_OPEN_BRACE:
30399 : 1 : num_open_braces++;
30400 : 1 : break;
30401 : 25 : case CPP_CLOSE_BRACE:
30402 : 25 : if (--num_open_braces == 0)
30403 : 24 : goto found_closing_brace;
30404 : : break;
30405 : 1 : case CPP_EOF:
30406 : 1 : error_at (start_loc, "no closing brace");
30407 : 1 : free (start_with_pass);
30408 : 1 : return c_parser_peek_token (parser)->location;
30409 : : default:
30410 : : break;
30411 : : }
30412 : 12607 : c_parser_consume_token (parser);
30413 : : }
30414 : :
30415 : 24 : found_closing_brace:
30416 : : /* At the closing brace; record its location. */
30417 : 24 : location_t end_loc = c_parser_peek_token (parser)->location;
30418 : :
30419 : : /* Consume the closing brace. */
30420 : 24 : c_parser_consume_token (parser);
30421 : :
30422 : : /* Invoke the RTL parser. */
30423 : 24 : if (!read_rtl_function_body_from_file_range (start_loc, end_loc))
30424 : : {
30425 : 0 : free (start_with_pass);
30426 : 0 : return end_loc;
30427 : : }
30428 : :
30429 : : /* Run the backend on the cfun created above, transferring ownership of
30430 : : START_WITH_PASS. */
30431 : 23 : run_rtl_passes (start_with_pass);
30432 : 23 : return end_loc;
30433 : : }
30434 : :
30435 : : #include "gt-c-c-parser.h"
|
