1 /* Parser for C and Objective-C.
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
4 Parser actions based on the old Bison parser; structure somewhat
5 influenced by and fragments based on the C++ parser.
7 This file is part of GCC.
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
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
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/>. */
25 Make sure all relevant comments, and all relevant code from all
26 actions, brought over from old parser. Verify exact correspondence
29 Add testcases covering every input symbol in every state in old and
32 Include full syntax for GNU C, including erroneous cases accepted
33 with error messages, in syntax productions in comments.
35 Make more diagnostics in the front end generally take an explicit
36 location rather than implicitly using input_location. */
39 #define INCLUDE_UNIQUE_PTR
41 #include "coretypes.h"
46 #include "stringpool.h"
49 #include "stor-layout.h"
51 #include "trans-mem.h"
52 #include "c-family/c-pragma.h"
54 #include "c-family/c-objc.h"
56 #include "omp-general.h"
57 #include "omp-offload.h"
59 #include "gomp-constants.h"
60 #include "c-family/c-indentation.h"
61 #include "gimple-expr.h"
63 #include "gcc-rich-location.h"
65 #include "gimple-parser.h"
66 #include "read-rtl-function.h"
67 #include "run-rtl-passes.h"
69 #include "c-family/name-hint.h"
70 #include "tree-iterator.h"
72 /* We need to walk over decls with incomplete struct/union/enum types
73 after parsing the whole translation unit.
74 In finish_decl(), if the decl is static, has incomplete
75 struct/union/enum type, it is appeneded to incomplete_record_decls.
76 In c_parser_translation_unit(), we iterate over incomplete_record_decls
77 and report error if any of the decls are still incomplete. */
79 vec
<tree
> incomplete_record_decls
;
82 set_c_expr_source_range (c_expr
*expr
,
83 location_t start
, location_t finish
)
85 expr
->src_range
.m_start
= start
;
86 expr
->src_range
.m_finish
= finish
;
88 set_source_range (expr
->value
, start
, finish
);
92 set_c_expr_source_range (c_expr
*expr
,
93 source_range src_range
)
95 expr
->src_range
= src_range
;
97 set_source_range (expr
->value
, src_range
);
101 /* Initialization routine for this file. */
106 /* The only initialization required is of the reserved word
112 /* Make sure RID_MAX hasn't grown past the 8 bits used to hold the keyword in
113 the c_token structure. */
114 gcc_assert (RID_MAX
<= 255);
121 mask
|= D_ASM
| D_EXT
;
125 if (!c_dialect_objc ())
126 mask
|= D_OBJC
| D_CXX_OBJC
;
128 ridpointers
= ggc_cleared_vec_alloc
<tree
> ((int) RID_MAX
);
129 for (i
= 0; i
< num_c_common_reswords
; i
++)
131 /* If a keyword is disabled, do not enter it into the table
132 and so create a canonical spelling that isn't a keyword. */
133 if (c_common_reswords
[i
].disable
& mask
)
136 && (c_common_reswords
[i
].disable
& D_CXXWARN
))
138 id
= get_identifier (c_common_reswords
[i
].word
);
139 C_SET_RID_CODE (id
, RID_CXX_COMPAT_WARN
);
140 C_IS_RESERVED_WORD (id
) = 1;
145 id
= get_identifier (c_common_reswords
[i
].word
);
146 C_SET_RID_CODE (id
, c_common_reswords
[i
].rid
);
147 C_IS_RESERVED_WORD (id
) = 1;
148 ridpointers
[(int) c_common_reswords
[i
].rid
] = id
;
151 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
153 /* We always create the symbols but they aren't always supported. */
155 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
156 id
= get_identifier (name
);
157 C_SET_RID_CODE (id
, RID_FIRST_INT_N
+ i
);
158 C_IS_RESERVED_WORD (id
) = 1;
162 /* A parser structure recording information about the state and
163 context of parsing. Includes lexer information with up to two
164 tokens of look-ahead; more are not needed for C. */
165 struct GTY(()) c_parser
{
166 /* The look-ahead tokens. */
167 c_token
* GTY((skip
)) tokens
;
168 /* Buffer for look-ahead tokens. */
169 c_token tokens_buf
[4];
170 /* How many look-ahead tokens are available (0 - 4, or
171 more if parsing from pre-lexed tokens). */
172 unsigned int tokens_avail
;
173 /* True if a syntax error is being recovered from; false otherwise.
174 c_parser_error sets this flag. It should clear this flag when
175 enough tokens have been consumed to recover from the error. */
176 BOOL_BITFIELD error
: 1;
177 /* True if we're processing a pragma, and shouldn't automatically
178 consume CPP_PRAGMA_EOL. */
179 BOOL_BITFIELD in_pragma
: 1;
180 /* True if we're parsing the outermost block of an if statement. */
181 BOOL_BITFIELD in_if_block
: 1;
182 /* True if we want to lex an untranslated string. */
183 BOOL_BITFIELD lex_untranslated_string
: 1;
185 /* Objective-C specific parser/lexer information. */
187 /* True if we are in a context where the Objective-C "PQ" keywords
188 are considered keywords. */
189 BOOL_BITFIELD objc_pq_context
: 1;
190 /* True if we are parsing a (potential) Objective-C foreach
191 statement. This is set to true after we parsed 'for (' and while
192 we wait for 'in' or ';' to decide if it's a standard C for loop or an
193 Objective-C foreach loop. */
194 BOOL_BITFIELD objc_could_be_foreach_context
: 1;
195 /* The following flag is needed to contextualize Objective-C lexical
196 analysis. In some cases (e.g., 'int NSObject;'), it is
197 undesirable to bind an identifier to an Objective-C class, even
198 if a class with that name exists. */
199 BOOL_BITFIELD objc_need_raw_identifier
: 1;
200 /* Nonzero if we're processing a __transaction statement. The value
201 is 1 | TM_STMT_ATTR_*. */
202 unsigned int in_transaction
: 4;
203 /* True if we are in a context where the Objective-C "Property attribute"
204 keywords are valid. */
205 BOOL_BITFIELD objc_property_attr_context
: 1;
207 /* Location of the last consumed token. */
208 location_t last_token_location
;
211 /* Return a pointer to the Nth token in PARSERs tokens_buf. */
214 c_parser_tokens_buf (c_parser
*parser
, unsigned n
)
216 return &parser
->tokens_buf
[n
];
219 /* Return the error state of PARSER. */
222 c_parser_error (c_parser
*parser
)
224 return parser
->error
;
227 /* Set the error state of PARSER to ERR. */
230 c_parser_set_error (c_parser
*parser
, bool err
)
236 /* The actual parser and external interface. ??? Does this need to be
237 garbage-collected? */
239 static GTY (()) c_parser
*the_parser
;
241 /* Read in and lex a single token, storing it in *TOKEN. */
244 c_lex_one_token (c_parser
*parser
, c_token
*token
)
246 timevar_push (TV_LEX
);
248 token
->type
= c_lex_with_flags (&token
->value
, &token
->location
,
250 (parser
->lex_untranslated_string
251 ? C_LEX_STRING_NO_TRANSLATE
: 0));
252 token
->id_kind
= C_ID_NONE
;
253 token
->keyword
= RID_MAX
;
254 token
->pragma_kind
= PRAGMA_NONE
;
262 bool objc_force_identifier
= parser
->objc_need_raw_identifier
;
263 if (c_dialect_objc ())
264 parser
->objc_need_raw_identifier
= false;
266 if (C_IS_RESERVED_WORD (token
->value
))
268 enum rid rid_code
= C_RID_CODE (token
->value
);
270 if (rid_code
== RID_CXX_COMPAT_WARN
)
272 warning_at (token
->location
,
274 "identifier %qE conflicts with C++ keyword",
277 else if (rid_code
>= RID_FIRST_ADDR_SPACE
278 && rid_code
<= RID_LAST_ADDR_SPACE
)
281 as
= (addr_space_t
) (rid_code
- RID_FIRST_ADDR_SPACE
);
282 targetm
.addr_space
.diagnose_usage (as
, token
->location
);
283 token
->id_kind
= C_ID_ADDRSPACE
;
284 token
->keyword
= rid_code
;
287 else if (c_dialect_objc () && OBJC_IS_PQ_KEYWORD (rid_code
))
289 /* We found an Objective-C "pq" keyword (in, out,
290 inout, bycopy, byref, oneway). They need special
291 care because the interpretation depends on the
293 if (parser
->objc_pq_context
)
295 token
->type
= CPP_KEYWORD
;
296 token
->keyword
= rid_code
;
299 else if (parser
->objc_could_be_foreach_context
300 && rid_code
== RID_IN
)
302 /* We are in Objective-C, inside a (potential)
303 foreach context (which means after having
304 parsed 'for (', but before having parsed ';'),
305 and we found 'in'. We consider it the keyword
306 which terminates the declaration at the
307 beginning of a foreach-statement. Note that
308 this means you can't use 'in' for anything else
309 in that context; in particular, in Objective-C
310 you can't use 'in' as the name of the running
311 variable in a C for loop. We could potentially
312 try to add code here to disambiguate, but it
313 seems a reasonable limitation. */
314 token
->type
= CPP_KEYWORD
;
315 token
->keyword
= rid_code
;
318 /* Else, "pq" keywords outside of the "pq" context are
319 not keywords, and we fall through to the code for
322 else if (c_dialect_objc () && OBJC_IS_PATTR_KEYWORD (rid_code
))
324 /* We found an Objective-C "property attribute"
325 keyword (getter, setter, readonly, etc). These are
326 only valid in the property context. */
327 if (parser
->objc_property_attr_context
)
329 token
->type
= CPP_KEYWORD
;
330 token
->keyword
= rid_code
;
333 /* Else they are not special keywords.
336 else if (c_dialect_objc ()
337 && (OBJC_IS_AT_KEYWORD (rid_code
)
338 || OBJC_IS_CXX_KEYWORD (rid_code
)))
340 /* We found one of the Objective-C "@" keywords (defs,
341 selector, synchronized, etc) or one of the
342 Objective-C "cxx" keywords (class, private,
343 protected, public, try, catch, throw) without a
344 preceding '@' sign. Do nothing and fall through to
345 the code for normal tokens (in C++ we would still
346 consider the CXX ones keywords, but not in C). */
351 token
->type
= CPP_KEYWORD
;
352 token
->keyword
= rid_code
;
357 decl
= lookup_name (token
->value
);
360 if (TREE_CODE (decl
) == TYPE_DECL
)
362 token
->id_kind
= C_ID_TYPENAME
;
366 else if (c_dialect_objc ())
368 tree objc_interface_decl
= objc_is_class_name (token
->value
);
369 /* Objective-C class names are in the same namespace as
370 variables and typedefs, and hence are shadowed by local
372 if (objc_interface_decl
373 && (!objc_force_identifier
|| global_bindings_p ()))
375 token
->value
= objc_interface_decl
;
376 token
->id_kind
= C_ID_CLASSNAME
;
380 token
->id_kind
= C_ID_ID
;
384 /* This only happens in Objective-C; it must be a keyword. */
385 token
->type
= CPP_KEYWORD
;
386 switch (C_RID_CODE (token
->value
))
388 /* Replace 'class' with '@class', 'private' with '@private',
389 etc. This prevents confusion with the C++ keyword
390 'class', and makes the tokens consistent with other
391 Objective-C 'AT' keywords. For example '@class' is
392 reported as RID_AT_CLASS which is consistent with
393 '@synchronized', which is reported as
396 case RID_CLASS
: token
->keyword
= RID_AT_CLASS
; break;
397 case RID_PRIVATE
: token
->keyword
= RID_AT_PRIVATE
; break;
398 case RID_PROTECTED
: token
->keyword
= RID_AT_PROTECTED
; break;
399 case RID_PUBLIC
: token
->keyword
= RID_AT_PUBLIC
; break;
400 case RID_THROW
: token
->keyword
= RID_AT_THROW
; break;
401 case RID_TRY
: token
->keyword
= RID_AT_TRY
; break;
402 case RID_CATCH
: token
->keyword
= RID_AT_CATCH
; break;
403 case RID_SYNCHRONIZED
: token
->keyword
= RID_AT_SYNCHRONIZED
; break;
404 default: token
->keyword
= C_RID_CODE (token
->value
);
409 case CPP_CLOSE_PAREN
:
411 /* These tokens may affect the interpretation of any identifiers
412 following, if doing Objective-C. */
413 if (c_dialect_objc ())
414 parser
->objc_need_raw_identifier
= false;
417 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
418 token
->pragma_kind
= (enum pragma_kind
) TREE_INT_CST_LOW (token
->value
);
424 timevar_pop (TV_LEX
);
427 /* Return a pointer to the next token from PARSER, reading it in if
431 c_parser_peek_token (c_parser
*parser
)
433 if (parser
->tokens_avail
== 0)
435 c_lex_one_token (parser
, &parser
->tokens
[0]);
436 parser
->tokens_avail
= 1;
438 return &parser
->tokens
[0];
441 /* Return a pointer to the next-but-one token from PARSER, reading it
442 in if necessary. The next token is already read in. */
445 c_parser_peek_2nd_token (c_parser
*parser
)
447 if (parser
->tokens_avail
>= 2)
448 return &parser
->tokens
[1];
449 gcc_assert (parser
->tokens_avail
== 1);
450 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
451 gcc_assert (parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
452 c_lex_one_token (parser
, &parser
->tokens
[1]);
453 parser
->tokens_avail
= 2;
454 return &parser
->tokens
[1];
457 /* Return a pointer to the Nth token from PARSER, reading it
458 in if necessary. The N-1th token is already read in. */
461 c_parser_peek_nth_token (c_parser
*parser
, unsigned int n
)
463 /* N is 1-based, not zero-based. */
466 if (parser
->tokens_avail
>= n
)
467 return &parser
->tokens
[n
- 1];
468 gcc_assert (parser
->tokens_avail
== n
- 1);
469 c_lex_one_token (parser
, &parser
->tokens
[n
- 1]);
470 parser
->tokens_avail
= n
;
471 return &parser
->tokens
[n
- 1];
475 c_keyword_starts_typename (enum rid keyword
)
510 if (keyword
>= RID_FIRST_INT_N
511 && keyword
< RID_FIRST_INT_N
+ NUM_INT_N_ENTS
512 && int_n_enabled_p
[keyword
- RID_FIRST_INT_N
])
518 /* Return true if TOKEN can start a type name,
521 c_token_starts_typename (c_token
*token
)
526 switch (token
->id_kind
)
535 gcc_assert (c_dialect_objc ());
541 return c_keyword_starts_typename (token
->keyword
);
543 if (c_dialect_objc ())
551 /* Return true if the next token from PARSER can start a type name,
552 false otherwise. LA specifies how to do lookahead in order to
553 detect unknown type names. If unsure, pick CLA_PREFER_ID. */
556 c_parser_next_tokens_start_typename (c_parser
*parser
, enum c_lookahead_kind la
)
558 c_token
*token
= c_parser_peek_token (parser
);
559 if (c_token_starts_typename (token
))
562 /* Try a bit harder to detect an unknown typename. */
563 if (la
!= cla_prefer_id
564 && token
->type
== CPP_NAME
565 && token
->id_kind
== C_ID_ID
567 /* Do not try too hard when we could have "object in array". */
568 && !parser
->objc_could_be_foreach_context
570 && (la
== cla_prefer_type
571 || c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
572 || c_parser_peek_2nd_token (parser
)->type
== CPP_MULT
)
574 /* Only unknown identifiers. */
575 && !lookup_name (token
->value
))
581 /* Return true if TOKEN is a type qualifier, false otherwise. */
583 c_token_is_qualifier (c_token
*token
)
588 switch (token
->id_kind
)
596 switch (token
->keyword
)
614 /* Return true if the next token from PARSER is a type qualifier,
617 c_parser_next_token_is_qualifier (c_parser
*parser
)
619 c_token
*token
= c_parser_peek_token (parser
);
620 return c_token_is_qualifier (token
);
623 /* Return true if TOKEN can start declaration specifiers, false
626 c_token_starts_declspecs (c_token
*token
)
631 switch (token
->id_kind
)
640 gcc_assert (c_dialect_objc ());
646 switch (token
->keyword
)
687 if (token
->keyword
>= RID_FIRST_INT_N
688 && token
->keyword
< RID_FIRST_INT_N
+ NUM_INT_N_ENTS
689 && int_n_enabled_p
[token
->keyword
- RID_FIRST_INT_N
])
694 if (c_dialect_objc ())
703 /* Return true if TOKEN can start declaration specifiers or a static
704 assertion, false otherwise. */
706 c_token_starts_declaration (c_token
*token
)
708 if (c_token_starts_declspecs (token
)
709 || token
->keyword
== RID_STATIC_ASSERT
)
715 /* Return true if the next token from PARSER can start declaration
716 specifiers, false otherwise. */
718 c_parser_next_token_starts_declspecs (c_parser
*parser
)
720 c_token
*token
= c_parser_peek_token (parser
);
722 /* In Objective-C, a classname normally starts a declspecs unless it
723 is immediately followed by a dot. In that case, it is the
724 Objective-C 2.0 "dot-syntax" for class objects, ie, calls the
725 setter/getter on the class. c_token_starts_declspecs() can't
726 differentiate between the two cases because it only checks the
727 current token, so we have a special check here. */
728 if (c_dialect_objc ()
729 && token
->type
== CPP_NAME
730 && token
->id_kind
== C_ID_CLASSNAME
731 && c_parser_peek_2nd_token (parser
)->type
== CPP_DOT
)
734 return c_token_starts_declspecs (token
);
737 /* Return true if the next tokens from PARSER can start declaration
738 specifiers or a static assertion, false otherwise. */
740 c_parser_next_tokens_start_declaration (c_parser
*parser
)
742 c_token
*token
= c_parser_peek_token (parser
);
745 if (c_dialect_objc ()
746 && token
->type
== CPP_NAME
747 && token
->id_kind
== C_ID_CLASSNAME
748 && c_parser_peek_2nd_token (parser
)->type
== CPP_DOT
)
751 /* Labels do not start declarations. */
752 if (token
->type
== CPP_NAME
753 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
756 if (c_token_starts_declaration (token
))
759 if (c_parser_next_tokens_start_typename (parser
, cla_nonabstract_decl
))
765 /* Consume the next token from PARSER. */
768 c_parser_consume_token (c_parser
*parser
)
770 gcc_assert (parser
->tokens_avail
>= 1);
771 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
772 gcc_assert (!parser
->in_pragma
|| parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
773 gcc_assert (parser
->error
|| parser
->tokens
[0].type
!= CPP_PRAGMA
);
774 parser
->last_token_location
= parser
->tokens
[0].location
;
775 if (parser
->tokens
!= &parser
->tokens_buf
[0])
777 else if (parser
->tokens_avail
== 2)
778 parser
->tokens
[0] = parser
->tokens
[1];
779 parser
->tokens_avail
--;
782 /* Expect the current token to be a #pragma. Consume it and remember
783 that we've begun parsing a pragma. */
786 c_parser_consume_pragma (c_parser
*parser
)
788 gcc_assert (!parser
->in_pragma
);
789 gcc_assert (parser
->tokens_avail
>= 1);
790 gcc_assert (parser
->tokens
[0].type
== CPP_PRAGMA
);
791 if (parser
->tokens
!= &parser
->tokens_buf
[0])
793 else if (parser
->tokens_avail
== 2)
794 parser
->tokens
[0] = parser
->tokens
[1];
795 parser
->tokens_avail
--;
796 parser
->in_pragma
= true;
799 /* Update the global input_location from TOKEN. */
801 c_parser_set_source_position_from_token (c_token
*token
)
803 if (token
->type
!= CPP_EOF
)
805 input_location
= token
->location
;
809 /* Helper function for c_parser_error.
810 Having peeked a token of kind TOK1_KIND that might signify
811 a conflict marker, peek successor tokens to determine
812 if we actually do have a conflict marker.
813 Specifically, we consider a run of 7 '<', '=' or '>' characters
814 at the start of a line as a conflict marker.
815 These come through the lexer as three pairs and a single,
816 e.g. three CPP_LSHIFT ("<<") and a CPP_LESS ('<').
817 If it returns true, *OUT_LOC is written to with the location/range
821 c_parser_peek_conflict_marker (c_parser
*parser
, enum cpp_ttype tok1_kind
,
824 c_token
*token2
= c_parser_peek_2nd_token (parser
);
825 if (token2
->type
!= tok1_kind
)
827 c_token
*token3
= c_parser_peek_nth_token (parser
, 3);
828 if (token3
->type
!= tok1_kind
)
830 c_token
*token4
= c_parser_peek_nth_token (parser
, 4);
831 if (token4
->type
!= conflict_marker_get_final_tok_kind (tok1_kind
))
834 /* It must be at the start of the line. */
835 location_t start_loc
= c_parser_peek_token (parser
)->location
;
836 if (LOCATION_COLUMN (start_loc
) != 1)
839 /* We have a conflict marker. Construct a location of the form:
842 with start == caret, finishing at the end of the marker. */
843 location_t finish_loc
= get_finish (token4
->location
);
844 *out_loc
= make_location (start_loc
, start_loc
, finish_loc
);
849 /* Issue a diagnostic of the form
850 FILE:LINE: MESSAGE before TOKEN
851 where TOKEN is the next token in the input stream of PARSER.
852 MESSAGE (specified by the caller) is usually of the form "expected
855 Use RICHLOC as the location of the diagnostic.
857 Do not issue a diagnostic if still recovering from an error.
859 Return true iff an error was actually emitted.
861 ??? This is taken from the C++ parser, but building up messages in
862 this way is not i18n-friendly and some other approach should be
866 c_parser_error_richloc (c_parser
*parser
, const char *gmsgid
,
867 rich_location
*richloc
)
869 c_token
*token
= c_parser_peek_token (parser
);
872 parser
->error
= true;
876 /* If this is actually a conflict marker, report it as such. */
877 if (token
->type
== CPP_LSHIFT
878 || token
->type
== CPP_RSHIFT
879 || token
->type
== CPP_EQ_EQ
)
882 if (c_parser_peek_conflict_marker (parser
, token
->type
, &loc
))
884 error_at (loc
, "version control conflict marker in file");
889 c_parse_error (gmsgid
,
890 /* Because c_parse_error does not understand
891 CPP_KEYWORD, keywords are treated like
893 (token
->type
== CPP_KEYWORD
? CPP_NAME
: token
->type
),
894 /* ??? The C parser does not save the cpp flags of a
895 token, we need to pass 0 here and we will not get
896 the source spelling of some tokens but rather the
897 canonical spelling. */
898 token
->value
, /*flags=*/0, richloc
);
902 /* As c_parser_error_richloc, but issue the message at the
903 location of PARSER's next token, or at input_location
904 if the next token is EOF. */
907 c_parser_error (c_parser
*parser
, const char *gmsgid
)
909 c_token
*token
= c_parser_peek_token (parser
);
910 c_parser_set_source_position_from_token (token
);
911 rich_location
richloc (line_table
, input_location
);
912 return c_parser_error_richloc (parser
, gmsgid
, &richloc
);
915 /* Some tokens naturally come in pairs e.g.'(' and ')'.
916 This class is for tracking such a matching pair of symbols.
917 In particular, it tracks the location of the first token,
918 so that if the second token is missing, we can highlight the
919 location of the first token when notifying the user about the
922 template <typename traits_t
>
926 /* token_pair's ctor. */
927 token_pair () : m_open_loc (UNKNOWN_LOCATION
) {}
929 /* If the next token is the opening symbol for this pair, consume it and
931 Otherwise, issue an error and return false.
932 In either case, record the location of the opening token. */
934 bool require_open (c_parser
*parser
)
936 c_token
*token
= c_parser_peek_token (parser
);
938 m_open_loc
= token
->location
;
940 return c_parser_require (parser
, traits_t::open_token_type
,
941 traits_t::open_gmsgid
);
944 /* Consume the next token from PARSER, recording its location as
945 that of the opening token within the pair. */
947 void consume_open (c_parser
*parser
)
949 c_token
*token
= c_parser_peek_token (parser
);
950 gcc_assert (token
->type
== traits_t::open_token_type
);
951 m_open_loc
= token
->location
;
952 c_parser_consume_token (parser
);
955 /* If the next token is the closing symbol for this pair, consume it
957 Otherwise, issue an error, highlighting the location of the
958 corresponding opening token, and return false. */
960 bool require_close (c_parser
*parser
) const
962 return c_parser_require (parser
, traits_t::close_token_type
,
963 traits_t::close_gmsgid
, m_open_loc
);
966 /* Like token_pair::require_close, except that tokens will be skipped
967 until the desired token is found. An error message is still produced
968 if the next token is not as expected. */
970 void skip_until_found_close (c_parser
*parser
) const
972 c_parser_skip_until_found (parser
, traits_t::close_token_type
,
973 traits_t::close_gmsgid
, m_open_loc
);
977 location_t m_open_loc
;
980 /* Traits for token_pair<T> for tracking matching pairs of parentheses. */
982 struct matching_paren_traits
984 static const enum cpp_ttype open_token_type
= CPP_OPEN_PAREN
;
985 static const char * const open_gmsgid
;
986 static const enum cpp_ttype close_token_type
= CPP_CLOSE_PAREN
;
987 static const char * const close_gmsgid
;
990 const char * const matching_paren_traits::open_gmsgid
= "expected %<(%>";
991 const char * const matching_paren_traits::close_gmsgid
= "expected %<)%>";
993 /* "matching_parens" is a token_pair<T> class for tracking matching
994 pairs of parentheses. */
996 typedef token_pair
<matching_paren_traits
> matching_parens
;
998 /* Traits for token_pair<T> for tracking matching pairs of braces. */
1000 struct matching_brace_traits
1002 static const enum cpp_ttype open_token_type
= CPP_OPEN_BRACE
;
1003 static const char * const open_gmsgid
;
1004 static const enum cpp_ttype close_token_type
= CPP_CLOSE_BRACE
;
1005 static const char * const close_gmsgid
;
1008 const char * const matching_brace_traits::open_gmsgid
= "expected %<{%>";
1009 const char * const matching_brace_traits::close_gmsgid
= "expected %<}%>";
1011 /* "matching_braces" is a token_pair<T> class for tracking matching
1014 typedef token_pair
<matching_brace_traits
> matching_braces
;
1016 /* Get a description of the matching symbol to TYPE e.g. "(" for
1020 get_matching_symbol (enum cpp_ttype type
)
1027 case CPP_CLOSE_PAREN
:
1029 case CPP_CLOSE_BRACE
:
1034 /* If the next token is of the indicated TYPE, consume it. Otherwise,
1035 issue the error MSGID. If MSGID is NULL then a message has already
1036 been produced and no message will be produced this time. Returns
1037 true if found, false otherwise.
1039 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
1040 within any error as the location of an "opening" token matching
1041 the close token TYPE (e.g. the location of the '(' when TYPE is
1044 If TYPE_IS_UNIQUE is true (the default) then msgid describes exactly
1045 one type (e.g. "expected %<)%>") and thus it may be reasonable to
1046 attempt to generate a fix-it hint for the problem.
1047 Otherwise msgid describes multiple token types (e.g.
1048 "expected %<;%>, %<,%> or %<)%>"), and thus we shouldn't attempt to
1049 generate a fix-it hint. */
1052 c_parser_require (c_parser
*parser
,
1053 enum cpp_ttype type
,
1055 location_t matching_location
,
1056 bool type_is_unique
)
1058 if (c_parser_next_token_is (parser
, type
))
1060 c_parser_consume_token (parser
);
1065 location_t next_token_loc
= c_parser_peek_token (parser
)->location
;
1066 gcc_rich_location
richloc (next_token_loc
);
1068 /* Potentially supply a fix-it hint, suggesting to add the
1069 missing token immediately after the *previous* token.
1070 This may move the primary location within richloc. */
1071 if (!parser
->error
&& type_is_unique
)
1072 maybe_suggest_missing_token_insertion (&richloc
, type
,
1073 parser
->last_token_location
);
1075 /* If matching_location != UNKNOWN_LOCATION, highlight it.
1076 Attempt to consolidate diagnostics by printing it as a
1077 secondary range within the main diagnostic. */
1078 bool added_matching_location
= false;
1079 if (matching_location
!= UNKNOWN_LOCATION
)
1080 added_matching_location
1081 = richloc
.add_location_if_nearby (matching_location
);
1083 if (c_parser_error_richloc (parser
, msgid
, &richloc
))
1084 /* If we weren't able to consolidate matching_location, then
1085 print it as a secondary diagnostic. */
1086 if (matching_location
!= UNKNOWN_LOCATION
&& !added_matching_location
)
1087 inform (matching_location
, "to match this %qs",
1088 get_matching_symbol (type
));
1094 /* If the next token is the indicated keyword, consume it. Otherwise,
1095 issue the error MSGID. Returns true if found, false otherwise. */
1098 c_parser_require_keyword (c_parser
*parser
,
1102 if (c_parser_next_token_is_keyword (parser
, keyword
))
1104 c_parser_consume_token (parser
);
1109 c_parser_error (parser
, msgid
);
1114 /* Like c_parser_require, except that tokens will be skipped until the
1115 desired token is found. An error message is still produced if the
1116 next token is not as expected. If MSGID is NULL then a message has
1117 already been produced and no message will be produced this
1120 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
1121 within any error as the location of an "opening" token matching
1122 the close token TYPE (e.g. the location of the '(' when TYPE is
1123 CPP_CLOSE_PAREN). */
1126 c_parser_skip_until_found (c_parser
*parser
,
1127 enum cpp_ttype type
,
1129 location_t matching_location
)
1131 unsigned nesting_depth
= 0;
1133 if (c_parser_require (parser
, type
, msgid
, matching_location
))
1136 /* Skip tokens until the desired token is found. */
1139 /* Peek at the next token. */
1140 c_token
*token
= c_parser_peek_token (parser
);
1141 /* If we've reached the token we want, consume it and stop. */
1142 if (token
->type
== type
&& !nesting_depth
)
1144 c_parser_consume_token (parser
);
1148 /* If we've run out of tokens, stop. */
1149 if (token
->type
== CPP_EOF
)
1151 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
1153 if (token
->type
== CPP_OPEN_BRACE
1154 || token
->type
== CPP_OPEN_PAREN
1155 || token
->type
== CPP_OPEN_SQUARE
)
1157 else if (token
->type
== CPP_CLOSE_BRACE
1158 || token
->type
== CPP_CLOSE_PAREN
1159 || token
->type
== CPP_CLOSE_SQUARE
)
1161 if (nesting_depth
-- == 0)
1164 /* Consume this token. */
1165 c_parser_consume_token (parser
);
1167 parser
->error
= false;
1170 /* Skip tokens until the end of a parameter is found, but do not
1171 consume the comma, semicolon or closing delimiter. */
1174 c_parser_skip_to_end_of_parameter (c_parser
*parser
)
1176 unsigned nesting_depth
= 0;
1180 c_token
*token
= c_parser_peek_token (parser
);
1181 if ((token
->type
== CPP_COMMA
|| token
->type
== CPP_SEMICOLON
)
1184 /* If we've run out of tokens, stop. */
1185 if (token
->type
== CPP_EOF
)
1187 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
1189 if (token
->type
== CPP_OPEN_BRACE
1190 || token
->type
== CPP_OPEN_PAREN
1191 || token
->type
== CPP_OPEN_SQUARE
)
1193 else if (token
->type
== CPP_CLOSE_BRACE
1194 || token
->type
== CPP_CLOSE_PAREN
1195 || token
->type
== CPP_CLOSE_SQUARE
)
1197 if (nesting_depth
-- == 0)
1200 /* Consume this token. */
1201 c_parser_consume_token (parser
);
1203 parser
->error
= false;
1206 /* Expect to be at the end of the pragma directive and consume an
1207 end of line marker. */
1210 c_parser_skip_to_pragma_eol (c_parser
*parser
, bool error_if_not_eol
= true)
1212 gcc_assert (parser
->in_pragma
);
1213 parser
->in_pragma
= false;
1215 if (error_if_not_eol
&& c_parser_peek_token (parser
)->type
!= CPP_PRAGMA_EOL
)
1216 c_parser_error (parser
, "expected end of line");
1218 cpp_ttype token_type
;
1221 c_token
*token
= c_parser_peek_token (parser
);
1222 token_type
= token
->type
;
1223 if (token_type
== CPP_EOF
)
1225 c_parser_consume_token (parser
);
1227 while (token_type
!= CPP_PRAGMA_EOL
);
1229 parser
->error
= false;
1232 /* Skip tokens until we have consumed an entire block, or until we
1233 have consumed a non-nested ';'. */
1236 c_parser_skip_to_end_of_block_or_statement (c_parser
*parser
)
1238 unsigned nesting_depth
= 0;
1239 bool save_error
= parser
->error
;
1245 /* Peek at the next token. */
1246 token
= c_parser_peek_token (parser
);
1248 switch (token
->type
)
1253 case CPP_PRAGMA_EOL
:
1254 if (parser
->in_pragma
)
1259 /* If the next token is a ';', we have reached the
1260 end of the statement. */
1263 /* Consume the ';'. */
1264 c_parser_consume_token (parser
);
1269 case CPP_CLOSE_BRACE
:
1270 /* If the next token is a non-nested '}', then we have
1271 reached the end of the current block. */
1272 if (nesting_depth
== 0 || --nesting_depth
== 0)
1274 c_parser_consume_token (parser
);
1279 case CPP_OPEN_BRACE
:
1280 /* If it the next token is a '{', then we are entering a new
1281 block. Consume the entire block. */
1286 /* If we see a pragma, consume the whole thing at once. We
1287 have some safeguards against consuming pragmas willy-nilly.
1288 Normally, we'd expect to be here with parser->error set,
1289 which disables these safeguards. But it's possible to get
1290 here for secondary error recovery, after parser->error has
1292 c_parser_consume_pragma (parser
);
1293 c_parser_skip_to_pragma_eol (parser
);
1294 parser
->error
= save_error
;
1301 c_parser_consume_token (parser
);
1305 parser
->error
= false;
1308 /* CPP's options (initialized by c-opts.c). */
1309 extern cpp_options
*cpp_opts
;
1311 /* Save the warning flags which are controlled by __extension__. */
1314 disable_extension_diagnostics (void)
1317 | (warn_pointer_arith
<< 1)
1318 | (warn_traditional
<< 2)
1320 | (warn_long_long
<< 4)
1321 | (warn_cxx_compat
<< 5)
1322 | (warn_overlength_strings
<< 6)
1323 /* warn_c90_c99_compat has three states: -1/0/1, so we must
1324 play tricks to properly restore it. */
1325 | ((warn_c90_c99_compat
== 1) << 7)
1326 | ((warn_c90_c99_compat
== -1) << 8)
1327 /* Similarly for warn_c99_c11_compat. */
1328 | ((warn_c99_c11_compat
== 1) << 9)
1329 | ((warn_c99_c11_compat
== -1) << 10)
1331 cpp_opts
->cpp_pedantic
= pedantic
= 0;
1332 warn_pointer_arith
= 0;
1333 cpp_opts
->cpp_warn_traditional
= warn_traditional
= 0;
1335 cpp_opts
->cpp_warn_long_long
= warn_long_long
= 0;
1336 warn_cxx_compat
= 0;
1337 warn_overlength_strings
= 0;
1338 warn_c90_c99_compat
= 0;
1339 warn_c99_c11_compat
= 0;
1343 /* Restore the warning flags which are controlled by __extension__.
1344 FLAGS is the return value from disable_extension_diagnostics. */
1347 restore_extension_diagnostics (int flags
)
1349 cpp_opts
->cpp_pedantic
= pedantic
= flags
& 1;
1350 warn_pointer_arith
= (flags
>> 1) & 1;
1351 cpp_opts
->cpp_warn_traditional
= warn_traditional
= (flags
>> 2) & 1;
1352 flag_iso
= (flags
>> 3) & 1;
1353 cpp_opts
->cpp_warn_long_long
= warn_long_long
= (flags
>> 4) & 1;
1354 warn_cxx_compat
= (flags
>> 5) & 1;
1355 warn_overlength_strings
= (flags
>> 6) & 1;
1356 /* See above for why is this needed. */
1357 warn_c90_c99_compat
= (flags
>> 7) & 1 ? 1 : ((flags
>> 8) & 1 ? -1 : 0);
1358 warn_c99_c11_compat
= (flags
>> 9) & 1 ? 1 : ((flags
>> 10) & 1 ? -1 : 0);
1361 /* Helper data structure for parsing #pragma acc routine. */
1362 struct oacc_routine_data
{
1363 bool error_seen
; /* Set if error has been reported. */
1364 bool fndecl_seen
; /* Set if one fn decl/definition has been seen already. */
1369 static void c_parser_external_declaration (c_parser
*);
1370 static void c_parser_asm_definition (c_parser
*);
1371 static void c_parser_declaration_or_fndef (c_parser
*, bool, bool, bool,
1372 bool, bool, tree
*, vec
<c_token
>,
1373 struct oacc_routine_data
* = NULL
,
1375 static void c_parser_static_assert_declaration_no_semi (c_parser
*);
1376 static void c_parser_static_assert_declaration (c_parser
*);
1377 static struct c_typespec
c_parser_enum_specifier (c_parser
*);
1378 static struct c_typespec
c_parser_struct_or_union_specifier (c_parser
*);
1379 static tree
c_parser_struct_declaration (c_parser
*);
1380 static struct c_typespec
c_parser_typeof_specifier (c_parser
*);
1381 static tree
c_parser_alignas_specifier (c_parser
*);
1382 static struct c_declarator
*c_parser_direct_declarator (c_parser
*, bool,
1384 static struct c_declarator
*c_parser_direct_declarator_inner (c_parser
*,
1386 struct c_declarator
*);
1387 static struct c_arg_info
*c_parser_parms_declarator (c_parser
*, bool, tree
);
1388 static struct c_arg_info
*c_parser_parms_list_declarator (c_parser
*, tree
,
1390 static struct c_parm
*c_parser_parameter_declaration (c_parser
*, tree
);
1391 static tree
c_parser_simple_asm_expr (c_parser
*);
1392 static tree
c_parser_attributes (c_parser
*);
1393 static struct c_expr
c_parser_initializer (c_parser
*);
1394 static struct c_expr
c_parser_braced_init (c_parser
*, tree
, bool,
1396 static void c_parser_initelt (c_parser
*, struct obstack
*);
1397 static void c_parser_initval (c_parser
*, struct c_expr
*,
1399 static tree
c_parser_compound_statement (c_parser
*);
1400 static void c_parser_compound_statement_nostart (c_parser
*);
1401 static void c_parser_label (c_parser
*);
1402 static void c_parser_statement (c_parser
*, bool *, location_t
* = NULL
);
1403 static void c_parser_statement_after_labels (c_parser
*, bool *,
1404 vec
<tree
> * = NULL
);
1405 static tree
c_parser_c99_block_statement (c_parser
*, bool *,
1406 location_t
* = NULL
);
1407 static void c_parser_if_statement (c_parser
*, bool *, vec
<tree
> *);
1408 static void c_parser_switch_statement (c_parser
*, bool *);
1409 static void c_parser_while_statement (c_parser
*, bool, unsigned short, bool *);
1410 static void c_parser_do_statement (c_parser
*, bool, unsigned short);
1411 static void c_parser_for_statement (c_parser
*, bool, unsigned short, bool *);
1412 static tree
c_parser_asm_statement (c_parser
*);
1413 static tree
c_parser_asm_operands (c_parser
*);
1414 static tree
c_parser_asm_goto_operands (c_parser
*);
1415 static tree
c_parser_asm_clobbers (c_parser
*);
1416 static struct c_expr
c_parser_expr_no_commas (c_parser
*, struct c_expr
*,
1418 static struct c_expr
c_parser_conditional_expression (c_parser
*,
1419 struct c_expr
*, tree
);
1420 static struct c_expr
c_parser_binary_expression (c_parser
*, struct c_expr
*,
1422 static struct c_expr
c_parser_cast_expression (c_parser
*, struct c_expr
*);
1423 static struct c_expr
c_parser_unary_expression (c_parser
*);
1424 static struct c_expr
c_parser_sizeof_expression (c_parser
*);
1425 static struct c_expr
c_parser_alignof_expression (c_parser
*);
1426 static struct c_expr
c_parser_postfix_expression (c_parser
*);
1427 static struct c_expr
c_parser_postfix_expression_after_paren_type (c_parser
*,
1428 struct c_type_name
*,
1430 static struct c_expr
c_parser_postfix_expression_after_primary (c_parser
*,
1433 static tree
c_parser_transaction (c_parser
*, enum rid
);
1434 static struct c_expr
c_parser_transaction_expression (c_parser
*, enum rid
);
1435 static tree
c_parser_transaction_cancel (c_parser
*);
1436 static struct c_expr
c_parser_expression (c_parser
*);
1437 static struct c_expr
c_parser_expression_conv (c_parser
*);
1438 static vec
<tree
, va_gc
> *c_parser_expr_list (c_parser
*, bool, bool,
1439 vec
<tree
, va_gc
> **, location_t
*,
1440 tree
*, vec
<location_t
> *,
1441 unsigned int * = NULL
);
1442 static void c_parser_oacc_declare (c_parser
*);
1443 static void c_parser_oacc_enter_exit_data (c_parser
*, bool);
1444 static void c_parser_oacc_update (c_parser
*);
1445 static void c_parser_omp_construct (c_parser
*, bool *);
1446 static void c_parser_omp_threadprivate (c_parser
*);
1447 static void c_parser_omp_barrier (c_parser
*);
1448 static void c_parser_omp_flush (c_parser
*);
1449 static tree
c_parser_omp_for_loop (location_t
, c_parser
*, enum tree_code
,
1450 tree
, tree
*, bool *);
1451 static void c_parser_omp_taskwait (c_parser
*);
1452 static void c_parser_omp_taskyield (c_parser
*);
1453 static void c_parser_omp_cancel (c_parser
*);
1455 enum pragma_context
{ pragma_external
, pragma_struct
, pragma_param
,
1456 pragma_stmt
, pragma_compound
};
1457 static bool c_parser_pragma (c_parser
*, enum pragma_context
, bool *);
1458 static void c_parser_omp_cancellation_point (c_parser
*, enum pragma_context
);
1459 static bool c_parser_omp_target (c_parser
*, enum pragma_context
, bool *);
1460 static void c_parser_omp_end_declare_target (c_parser
*);
1461 static void c_parser_omp_declare (c_parser
*, enum pragma_context
);
1462 static bool c_parser_omp_ordered (c_parser
*, enum pragma_context
, bool *);
1463 static void c_parser_oacc_routine (c_parser
*, enum pragma_context
);
1465 /* These Objective-C parser functions are only ever called when
1466 compiling Objective-C. */
1467 static void c_parser_objc_class_definition (c_parser
*, tree
);
1468 static void c_parser_objc_class_instance_variables (c_parser
*);
1469 static void c_parser_objc_class_declaration (c_parser
*);
1470 static void c_parser_objc_alias_declaration (c_parser
*);
1471 static void c_parser_objc_protocol_definition (c_parser
*, tree
);
1472 static bool c_parser_objc_method_type (c_parser
*);
1473 static void c_parser_objc_method_definition (c_parser
*);
1474 static void c_parser_objc_methodprotolist (c_parser
*);
1475 static void c_parser_objc_methodproto (c_parser
*);
1476 static tree
c_parser_objc_method_decl (c_parser
*, bool, tree
*, tree
*);
1477 static tree
c_parser_objc_type_name (c_parser
*);
1478 static tree
c_parser_objc_protocol_refs (c_parser
*);
1479 static void c_parser_objc_try_catch_finally_statement (c_parser
*);
1480 static void c_parser_objc_synchronized_statement (c_parser
*);
1481 static tree
c_parser_objc_selector (c_parser
*);
1482 static tree
c_parser_objc_selector_arg (c_parser
*);
1483 static tree
c_parser_objc_receiver (c_parser
*);
1484 static tree
c_parser_objc_message_args (c_parser
*);
1485 static tree
c_parser_objc_keywordexpr (c_parser
*);
1486 static void c_parser_objc_at_property_declaration (c_parser
*);
1487 static void c_parser_objc_at_synthesize_declaration (c_parser
*);
1488 static void c_parser_objc_at_dynamic_declaration (c_parser
*);
1489 static bool c_parser_objc_diagnose_bad_element_prefix
1490 (c_parser
*, struct c_declspecs
*);
1492 static void c_parser_parse_rtl_body (c_parser
*parser
, char *start_with_pass
);
1494 /* Parse a translation unit (C90 6.7, C99 6.9, C11 6.9).
1497 external-declarations
1499 external-declarations:
1500 external-declaration
1501 external-declarations external-declaration
1510 c_parser_translation_unit (c_parser
*parser
)
1512 if (c_parser_next_token_is (parser
, CPP_EOF
))
1514 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
1515 "ISO C forbids an empty translation unit");
1519 void *obstack_position
= obstack_alloc (&parser_obstack
, 0);
1520 mark_valid_location_for_stdc_pragma (false);
1524 c_parser_external_declaration (parser
);
1525 obstack_free (&parser_obstack
, obstack_position
);
1527 while (c_parser_next_token_is_not (parser
, CPP_EOF
));
1532 FOR_EACH_VEC_ELT (incomplete_record_decls
, i
, decl
)
1533 if (DECL_SIZE (decl
) == NULL_TREE
&& TREE_TYPE (decl
) != error_mark_node
)
1534 error ("storage size of %q+D isn%'t known", decl
);
1537 /* Parse an external declaration (C90 6.7, C99 6.9, C11 6.9).
1539 external-declaration:
1545 external-declaration:
1548 __extension__ external-declaration
1552 external-declaration:
1553 objc-class-definition
1554 objc-class-declaration
1555 objc-alias-declaration
1556 objc-protocol-definition
1557 objc-method-definition
1562 c_parser_external_declaration (c_parser
*parser
)
1565 switch (c_parser_peek_token (parser
)->type
)
1568 switch (c_parser_peek_token (parser
)->keyword
)
1571 ext
= disable_extension_diagnostics ();
1572 c_parser_consume_token (parser
);
1573 c_parser_external_declaration (parser
);
1574 restore_extension_diagnostics (ext
);
1577 c_parser_asm_definition (parser
);
1579 case RID_AT_INTERFACE
:
1580 case RID_AT_IMPLEMENTATION
:
1581 gcc_assert (c_dialect_objc ());
1582 c_parser_objc_class_definition (parser
, NULL_TREE
);
1585 gcc_assert (c_dialect_objc ());
1586 c_parser_objc_class_declaration (parser
);
1589 gcc_assert (c_dialect_objc ());
1590 c_parser_objc_alias_declaration (parser
);
1592 case RID_AT_PROTOCOL
:
1593 gcc_assert (c_dialect_objc ());
1594 c_parser_objc_protocol_definition (parser
, NULL_TREE
);
1596 case RID_AT_PROPERTY
:
1597 gcc_assert (c_dialect_objc ());
1598 c_parser_objc_at_property_declaration (parser
);
1600 case RID_AT_SYNTHESIZE
:
1601 gcc_assert (c_dialect_objc ());
1602 c_parser_objc_at_synthesize_declaration (parser
);
1604 case RID_AT_DYNAMIC
:
1605 gcc_assert (c_dialect_objc ());
1606 c_parser_objc_at_dynamic_declaration (parser
);
1609 gcc_assert (c_dialect_objc ());
1610 c_parser_consume_token (parser
);
1611 objc_finish_implementation ();
1618 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
1619 "ISO C does not allow extra %<;%> outside of a function");
1620 c_parser_consume_token (parser
);
1623 mark_valid_location_for_stdc_pragma (true);
1624 c_parser_pragma (parser
, pragma_external
, NULL
);
1625 mark_valid_location_for_stdc_pragma (false);
1629 if (c_dialect_objc ())
1631 c_parser_objc_method_definition (parser
);
1634 /* Else fall through, and yield a syntax error trying to parse
1635 as a declaration or function definition. */
1639 /* A declaration or a function definition (or, in Objective-C,
1640 an @interface or @protocol with prefix attributes). We can
1641 only tell which after parsing the declaration specifiers, if
1642 any, and the first declarator. */
1643 c_parser_declaration_or_fndef (parser
, true, true, true, false, true,
1649 static void c_finish_omp_declare_simd (c_parser
*, tree
, tree
, vec
<c_token
>);
1650 static void c_finish_oacc_routine (struct oacc_routine_data
*, tree
, bool);
1652 /* Build and add a DEBUG_BEGIN_STMT statement with location LOC. */
1655 add_debug_begin_stmt (location_t loc
)
1657 /* Don't add DEBUG_BEGIN_STMTs outside of functions, see PR84721. */
1658 if (!MAY_HAVE_DEBUG_MARKER_STMTS
|| !building_stmt_list_p ())
1661 tree stmt
= build0 (DEBUG_BEGIN_STMT
, void_type_node
);
1662 SET_EXPR_LOCATION (stmt
, loc
);
1666 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1667 6.7, 6.9.1, C11 6.7, 6.9.1). If FNDEF_OK is true, a function definition
1668 is accepted; otherwise (old-style parameter declarations) only other
1669 declarations are accepted. If STATIC_ASSERT_OK is true, a static
1670 assertion is accepted; otherwise (old-style parameter declarations)
1671 it is not. If NESTED is true, we are inside a function or parsing
1672 old-style parameter declarations; any functions encountered are
1673 nested functions and declaration specifiers are required; otherwise
1674 we are at top level and functions are normal functions and
1675 declaration specifiers may be optional. If EMPTY_OK is true, empty
1676 declarations are OK (subject to all other constraints); otherwise
1677 (old-style parameter declarations) they are diagnosed. If
1678 START_ATTR_OK is true, the declaration specifiers may start with
1679 attributes; otherwise they may not.
1680 OBJC_FOREACH_OBJECT_DECLARATION can be used to get back the parsed
1681 declaration when parsing an Objective-C foreach statement.
1682 FALLTHRU_ATTR_P is used to signal whether this function parsed
1683 "__attribute__((fallthrough));".
1686 declaration-specifiers init-declarator-list[opt] ;
1687 static_assert-declaration
1689 function-definition:
1690 declaration-specifiers[opt] declarator declaration-list[opt]
1695 declaration-list declaration
1697 init-declarator-list:
1699 init-declarator-list , init-declarator
1702 declarator simple-asm-expr[opt] attributes[opt]
1703 declarator simple-asm-expr[opt] attributes[opt] = initializer
1707 nested-function-definition:
1708 declaration-specifiers declarator declaration-list[opt]
1714 attributes objc-class-definition
1715 attributes objc-category-definition
1716 attributes objc-protocol-definition
1718 The simple-asm-expr and attributes are GNU extensions.
1720 This function does not handle __extension__; that is handled in its
1721 callers. ??? Following the old parser, __extension__ may start
1722 external declarations, declarations in functions and declarations
1723 at the start of "for" loops, but not old-style parameter
1726 C99 requires declaration specifiers in a function definition; the
1727 absence is diagnosed through the diagnosis of implicit int. In GNU
1728 C we also allow but diagnose declarations without declaration
1729 specifiers, but only at top level (elsewhere they conflict with
1732 In Objective-C, declarations of the looping variable in a foreach
1733 statement are exceptionally terminated by 'in' (for example, 'for
1734 (NSObject *object in array) { ... }').
1739 threadprivate-directive
1743 gimple-function-definition:
1744 declaration-specifiers[opt] __GIMPLE (gimple-or-rtl-pass-list) declarator
1745 declaration-list[opt] compound-statement
1747 rtl-function-definition:
1748 declaration-specifiers[opt] __RTL (gimple-or-rtl-pass-list) declarator
1749 declaration-list[opt] compound-statement */
1752 c_parser_declaration_or_fndef (c_parser
*parser
, bool fndef_ok
,
1753 bool static_assert_ok
, bool empty_ok
,
1754 bool nested
, bool start_attr_ok
,
1755 tree
*objc_foreach_object_declaration
,
1756 vec
<c_token
> omp_declare_simd_clauses
,
1757 struct oacc_routine_data
*oacc_routine_data
,
1758 bool *fallthru_attr_p
)
1760 struct c_declspecs
*specs
;
1762 tree all_prefix_attrs
;
1763 bool diagnosed_no_specs
= false;
1764 location_t here
= c_parser_peek_token (parser
)->location
;
1766 add_debug_begin_stmt (c_parser_peek_token (parser
)->location
);
1768 if (static_assert_ok
1769 && c_parser_next_token_is_keyword (parser
, RID_STATIC_ASSERT
))
1771 c_parser_static_assert_declaration (parser
);
1774 specs
= build_null_declspecs ();
1776 /* Try to detect an unknown type name when we have "A B" or "A *B". */
1777 if (c_parser_peek_token (parser
)->type
== CPP_NAME
1778 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
1779 && (c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
1780 || c_parser_peek_2nd_token (parser
)->type
== CPP_MULT
)
1781 && (!nested
|| !lookup_name (c_parser_peek_token (parser
)->value
)))
1783 tree name
= c_parser_peek_token (parser
)->value
;
1785 /* Issue a warning about NAME being an unknown type name, perhaps
1786 with some kind of hint.
1787 If the user forgot a "struct" etc, suggest inserting
1788 it. Otherwise, attempt to look for misspellings. */
1789 gcc_rich_location
richloc (here
);
1790 if (tag_exists_p (RECORD_TYPE
, name
))
1792 /* This is not C++ with its implicit typedef. */
1793 richloc
.add_fixit_insert_before ("struct ");
1795 "unknown type name %qE;"
1796 " use %<struct%> keyword to refer to the type",
1799 else if (tag_exists_p (UNION_TYPE
, name
))
1801 richloc
.add_fixit_insert_before ("union ");
1803 "unknown type name %qE;"
1804 " use %<union%> keyword to refer to the type",
1807 else if (tag_exists_p (ENUMERAL_TYPE
, name
))
1809 richloc
.add_fixit_insert_before ("enum ");
1811 "unknown type name %qE;"
1812 " use %<enum%> keyword to refer to the type",
1817 auto_diagnostic_group d
;
1818 name_hint hint
= lookup_name_fuzzy (name
, FUZZY_LOOKUP_TYPENAME
,
1822 richloc
.add_fixit_replace (hint
.suggestion ());
1824 "unknown type name %qE; did you mean %qs?",
1825 name
, hint
.suggestion ());
1828 error_at (here
, "unknown type name %qE", name
);
1831 /* Parse declspecs normally to get a correct pointer type, but avoid
1832 a further "fails to be a type name" error. Refuse nested functions
1833 since it is not how the user likely wants us to recover. */
1834 c_parser_peek_token (parser
)->type
= CPP_KEYWORD
;
1835 c_parser_peek_token (parser
)->keyword
= RID_VOID
;
1836 c_parser_peek_token (parser
)->value
= error_mark_node
;
1840 c_parser_declspecs (parser
, specs
, true, true, start_attr_ok
,
1841 true, true, cla_nonabstract_decl
);
1844 c_parser_skip_to_end_of_block_or_statement (parser
);
1847 if (nested
&& !specs
->declspecs_seen_p
)
1849 c_parser_error (parser
, "expected declaration specifiers");
1850 c_parser_skip_to_end_of_block_or_statement (parser
);
1854 finish_declspecs (specs
);
1855 bool auto_type_p
= specs
->typespec_word
== cts_auto_type
;
1856 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1859 error_at (here
, "%<__auto_type%> in empty declaration");
1860 else if (specs
->typespec_kind
== ctsk_none
1861 && attribute_fallthrough_p (specs
->attrs
))
1863 if (fallthru_attr_p
!= NULL
)
1864 *fallthru_attr_p
= true;
1865 tree fn
= build_call_expr_internal_loc (here
, IFN_FALLTHROUGH
,
1873 shadow_tag_warned (specs
, 1);
1874 pedwarn (here
, 0, "empty declaration");
1876 c_parser_consume_token (parser
);
1877 if (oacc_routine_data
)
1878 c_finish_oacc_routine (oacc_routine_data
, NULL_TREE
, false);
1882 /* Provide better error recovery. Note that a type name here is usually
1883 better diagnosed as a redeclaration. */
1885 && specs
->typespec_kind
== ctsk_tagdef
1886 && c_parser_next_token_starts_declspecs (parser
)
1887 && !c_parser_next_token_is (parser
, CPP_NAME
))
1889 c_parser_error (parser
, "expected %<;%>, identifier or %<(%>");
1890 parser
->error
= false;
1891 shadow_tag_warned (specs
, 1);
1894 else if (c_dialect_objc () && !auto_type_p
)
1896 /* Prefix attributes are an error on method decls. */
1897 switch (c_parser_peek_token (parser
)->type
)
1901 if (c_parser_objc_diagnose_bad_element_prefix (parser
, specs
))
1905 warning_at (c_parser_peek_token (parser
)->location
,
1907 "prefix attributes are ignored for methods");
1908 specs
->attrs
= NULL_TREE
;
1911 c_parser_objc_method_definition (parser
);
1913 c_parser_objc_methodproto (parser
);
1919 /* This is where we parse 'attributes @interface ...',
1920 'attributes @implementation ...', 'attributes @protocol ...'
1921 (where attributes could be, for example, __attribute__
1924 switch (c_parser_peek_token (parser
)->keyword
)
1926 case RID_AT_INTERFACE
:
1928 if (c_parser_objc_diagnose_bad_element_prefix (parser
, specs
))
1930 c_parser_objc_class_definition (parser
, specs
->attrs
);
1934 case RID_AT_IMPLEMENTATION
:
1936 if (c_parser_objc_diagnose_bad_element_prefix (parser
, specs
))
1940 warning_at (c_parser_peek_token (parser
)->location
,
1942 "prefix attributes are ignored for implementations");
1943 specs
->attrs
= NULL_TREE
;
1945 c_parser_objc_class_definition (parser
, NULL_TREE
);
1949 case RID_AT_PROTOCOL
:
1951 if (c_parser_objc_diagnose_bad_element_prefix (parser
, specs
))
1953 c_parser_objc_protocol_definition (parser
, specs
->attrs
);
1960 case RID_AT_PROPERTY
:
1963 c_parser_error (parser
, "unexpected attribute");
1964 specs
->attrs
= NULL
;
1971 else if (attribute_fallthrough_p (specs
->attrs
))
1972 warning_at (here
, OPT_Wattributes
,
1973 "%<fallthrough%> attribute not followed by %<;%>");
1975 pending_xref_error ();
1976 prefix_attrs
= specs
->attrs
;
1977 all_prefix_attrs
= prefix_attrs
;
1978 specs
->attrs
= NULL_TREE
;
1981 struct c_declarator
*declarator
;
1984 tree fnbody
= NULL_TREE
;
1985 /* Declaring either one or more declarators (in which case we
1986 should diagnose if there were no declaration specifiers) or a
1987 function definition (in which case the diagnostic for
1988 implicit int suffices). */
1989 declarator
= c_parser_declarator (parser
,
1990 specs
->typespec_kind
!= ctsk_none
,
1991 C_DTR_NORMAL
, &dummy
);
1992 if (declarator
== NULL
)
1994 if (omp_declare_simd_clauses
.exists ())
1995 c_finish_omp_declare_simd (parser
, NULL_TREE
, NULL_TREE
,
1996 omp_declare_simd_clauses
);
1997 if (oacc_routine_data
)
1998 c_finish_oacc_routine (oacc_routine_data
, NULL_TREE
, false);
1999 c_parser_skip_to_end_of_block_or_statement (parser
);
2002 if (auto_type_p
&& declarator
->kind
!= cdk_id
)
2005 "%<__auto_type%> requires a plain identifier"
2007 c_parser_skip_to_end_of_block_or_statement (parser
);
2010 if (c_parser_next_token_is (parser
, CPP_EQ
)
2011 || c_parser_next_token_is (parser
, CPP_COMMA
)
2012 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2013 || c_parser_next_token_is_keyword (parser
, RID_ASM
)
2014 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
)
2015 || c_parser_next_token_is_keyword (parser
, RID_IN
))
2017 tree asm_name
= NULL_TREE
;
2018 tree postfix_attrs
= NULL_TREE
;
2019 if (!diagnosed_no_specs
&& !specs
->declspecs_seen_p
)
2021 diagnosed_no_specs
= true;
2022 pedwarn (here
, 0, "data definition has no type or storage class");
2024 /* Having seen a data definition, there cannot now be a
2025 function definition. */
2027 if (c_parser_next_token_is_keyword (parser
, RID_ASM
))
2028 asm_name
= c_parser_simple_asm_expr (parser
);
2029 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2031 postfix_attrs
= c_parser_attributes (parser
);
2032 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
2034 /* This means there is an attribute specifier after
2035 the declarator in a function definition. Provide
2036 some more information for the user. */
2037 error_at (here
, "attributes should be specified before the "
2038 "declarator in a function definition");
2039 c_parser_skip_to_end_of_block_or_statement (parser
);
2043 if (c_parser_next_token_is (parser
, CPP_EQ
))
2047 location_t init_loc
;
2048 c_parser_consume_token (parser
);
2051 init_loc
= c_parser_peek_token (parser
)->location
;
2052 rich_location
richloc (line_table
, init_loc
);
2053 start_init (NULL_TREE
, asm_name
, global_bindings_p (), &richloc
);
2054 /* A parameter is initialized, which is invalid. Don't
2055 attempt to instrument the initializer. */
2056 int flag_sanitize_save
= flag_sanitize
;
2057 if (nested
&& !empty_ok
)
2059 init
= c_parser_expr_no_commas (parser
, NULL
);
2060 flag_sanitize
= flag_sanitize_save
;
2061 if (TREE_CODE (init
.value
) == COMPONENT_REF
2062 && DECL_C_BIT_FIELD (TREE_OPERAND (init
.value
, 1)))
2064 "%<__auto_type%> used with a bit-field"
2066 init
= convert_lvalue_to_rvalue (init_loc
, init
, true, true);
2067 tree init_type
= TREE_TYPE (init
.value
);
2068 /* As with typeof, remove all qualifiers from atomic types. */
2069 if (init_type
!= error_mark_node
&& TYPE_ATOMIC (init_type
))
2071 = c_build_qualified_type (init_type
, TYPE_UNQUALIFIED
);
2072 bool vm_type
= variably_modified_type_p (init_type
,
2075 init
.value
= save_expr (init
.value
);
2077 specs
->typespec_kind
= ctsk_typeof
;
2078 specs
->locations
[cdw_typedef
] = init_loc
;
2079 specs
->typedef_p
= true;
2080 specs
->type
= init_type
;
2083 bool maybe_const
= true;
2084 tree type_expr
= c_fully_fold (init
.value
, false,
2086 specs
->expr_const_operands
&= maybe_const
;
2088 specs
->expr
= build2 (COMPOUND_EXPR
,
2089 TREE_TYPE (type_expr
),
2090 specs
->expr
, type_expr
);
2092 specs
->expr
= type_expr
;
2094 d
= start_decl (declarator
, specs
, true,
2095 chainon (postfix_attrs
, all_prefix_attrs
));
2097 d
= error_mark_node
;
2098 if (omp_declare_simd_clauses
.exists ())
2099 c_finish_omp_declare_simd (parser
, d
, NULL_TREE
,
2100 omp_declare_simd_clauses
);
2104 /* The declaration of the variable is in effect while
2105 its initializer is parsed. */
2106 d
= start_decl (declarator
, specs
, true,
2107 chainon (postfix_attrs
, all_prefix_attrs
));
2109 d
= error_mark_node
;
2110 if (omp_declare_simd_clauses
.exists ())
2111 c_finish_omp_declare_simd (parser
, d
, NULL_TREE
,
2112 omp_declare_simd_clauses
);
2113 init_loc
= c_parser_peek_token (parser
)->location
;
2114 rich_location
richloc (line_table
, init_loc
);
2115 start_init (d
, asm_name
, global_bindings_p (), &richloc
);
2116 /* A parameter is initialized, which is invalid. Don't
2117 attempt to instrument the initializer. */
2118 int flag_sanitize_save
= flag_sanitize
;
2119 if (TREE_CODE (d
) == PARM_DECL
)
2121 init
= c_parser_initializer (parser
);
2122 flag_sanitize
= flag_sanitize_save
;
2125 if (oacc_routine_data
)
2126 c_finish_oacc_routine (oacc_routine_data
, d
, false);
2127 if (d
!= error_mark_node
)
2129 maybe_warn_string_init (init_loc
, TREE_TYPE (d
), init
);
2130 finish_decl (d
, init_loc
, init
.value
,
2131 init
.original_type
, asm_name
);
2139 "%<__auto_type%> requires an initialized "
2140 "data declaration");
2141 c_parser_skip_to_end_of_block_or_statement (parser
);
2144 tree d
= start_decl (declarator
, specs
, false,
2145 chainon (postfix_attrs
,
2147 if (d
&& TREE_CODE (d
) == FUNCTION_DECL
)
2148 if (declarator
->kind
== cdk_function
)
2149 if (DECL_ARGUMENTS (d
) == NULL_TREE
)
2150 DECL_ARGUMENTS (d
) = declarator
->u
.arg_info
->parms
;
2151 if (omp_declare_simd_clauses
.exists ())
2153 tree parms
= NULL_TREE
;
2154 if (d
&& TREE_CODE (d
) == FUNCTION_DECL
)
2156 struct c_declarator
*ce
= declarator
;
2158 if (ce
->kind
== cdk_function
)
2160 parms
= ce
->u
.arg_info
->parms
;
2164 ce
= ce
->declarator
;
2167 temp_store_parm_decls (d
, parms
);
2168 c_finish_omp_declare_simd (parser
, d
, parms
,
2169 omp_declare_simd_clauses
);
2171 temp_pop_parm_decls ();
2173 if (oacc_routine_data
)
2174 c_finish_oacc_routine (oacc_routine_data
, d
, false);
2176 finish_decl (d
, UNKNOWN_LOCATION
, NULL_TREE
,
2177 NULL_TREE
, asm_name
);
2179 if (c_parser_next_token_is_keyword (parser
, RID_IN
))
2182 *objc_foreach_object_declaration
= d
;
2184 *objc_foreach_object_declaration
= error_mark_node
;
2187 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2192 "%<__auto_type%> may only be used with"
2193 " a single declarator");
2194 c_parser_skip_to_end_of_block_or_statement (parser
);
2197 c_parser_consume_token (parser
);
2198 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2199 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
2202 all_prefix_attrs
= prefix_attrs
;
2205 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2207 c_parser_consume_token (parser
);
2210 else if (c_parser_next_token_is_keyword (parser
, RID_IN
))
2212 /* This can only happen in Objective-C: we found the
2213 'in' that terminates the declaration inside an
2214 Objective-C foreach statement. Do not consume the
2215 token, so that the caller can use it to determine
2216 that this indeed is a foreach context. */
2221 c_parser_error (parser
, "expected %<,%> or %<;%>");
2222 c_parser_skip_to_end_of_block_or_statement (parser
);
2226 else if (auto_type_p
)
2229 "%<__auto_type%> requires an initialized data declaration");
2230 c_parser_skip_to_end_of_block_or_statement (parser
);
2235 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, "
2236 "%<asm%> or %<__attribute__%>");
2237 c_parser_skip_to_end_of_block_or_statement (parser
);
2240 /* Function definition (nested or otherwise). */
2243 pedwarn (here
, OPT_Wpedantic
, "ISO C forbids nested functions");
2244 c_push_function_context ();
2246 if (!start_function (specs
, declarator
, all_prefix_attrs
))
2248 /* At this point we've consumed:
2249 declaration-specifiers declarator
2250 and the next token isn't CPP_EQ, CPP_COMMA, CPP_SEMICOLON,
2251 RID_ASM, RID_ATTRIBUTE, or RID_IN,
2253 declaration-specifiers declarator
2254 aren't grokkable as a function definition, so we have
2256 gcc_assert (!c_parser_next_token_is (parser
, CPP_SEMICOLON
));
2257 if (c_parser_next_token_starts_declspecs (parser
))
2260 declaration-specifiers declarator decl-specs
2261 then assume we have a missing semicolon, which would
2263 declaration-specifiers declarator decl-specs
2266 <~~~~~~~~~ declaration ~~~~~~~~~~>
2267 Use c_parser_require to get an error with a fix-it hint. */
2268 c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>");
2269 parser
->error
= false;
2273 /* This can appear in many cases looking nothing like a
2274 function definition, so we don't give a more specific
2275 error suggesting there was one. */
2276 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
2277 "or %<__attribute__%>");
2280 c_pop_function_context ();
2284 if (DECL_DECLARED_INLINE_P (current_function_decl
))
2285 tv
= TV_PARSE_INLINE
;
2288 auto_timevar
at (g_timer
, tv
);
2290 /* Parse old-style parameter declarations. ??? Attributes are
2291 not allowed to start declaration specifiers here because of a
2292 syntax conflict between a function declaration with attribute
2293 suffix and a function definition with an attribute prefix on
2294 first old-style parameter declaration. Following the old
2295 parser, they are not accepted on subsequent old-style
2296 parameter declarations either. However, there is no
2297 ambiguity after the first declaration, nor indeed on the
2298 first as long as we don't allow postfix attributes after a
2299 declarator with a nonempty identifier list in a definition;
2300 and postfix attributes have never been accepted here in
2301 function definitions either. */
2302 while (c_parser_next_token_is_not (parser
, CPP_EOF
)
2303 && c_parser_next_token_is_not (parser
, CPP_OPEN_BRACE
))
2304 c_parser_declaration_or_fndef (parser
, false, false, false,
2305 true, false, NULL
, vNULL
);
2306 store_parm_decls ();
2307 if (omp_declare_simd_clauses
.exists ())
2308 c_finish_omp_declare_simd (parser
, current_function_decl
, NULL_TREE
,
2309 omp_declare_simd_clauses
);
2310 if (oacc_routine_data
)
2311 c_finish_oacc_routine (oacc_routine_data
, current_function_decl
, true);
2312 DECL_STRUCT_FUNCTION (current_function_decl
)->function_start_locus
2313 = c_parser_peek_token (parser
)->location
;
2315 /* If the definition was marked with __GIMPLE then parse the
2316 function body as GIMPLE. */
2317 if (specs
->gimple_p
)
2319 cfun
->pass_startwith
= specs
->gimple_or_rtl_pass
;
2320 bool saved
= in_late_binary_op
;
2321 in_late_binary_op
= true;
2322 c_parser_parse_gimple_body (parser
);
2323 in_late_binary_op
= saved
;
2325 /* Similarly, if it was marked with __RTL, use the RTL parser now,
2326 consuming the function body. */
2327 else if (specs
->rtl_p
)
2329 c_parser_parse_rtl_body (parser
, specs
->gimple_or_rtl_pass
);
2331 /* Normally, store_parm_decls sets next_is_function_body,
2332 anticipating a function body. We need a push_scope/pop_scope
2333 pair to flush out this state, or subsequent function parsing
2342 fnbody
= c_parser_compound_statement (parser
);
2343 tree fndecl
= current_function_decl
;
2346 tree decl
= current_function_decl
;
2347 /* Mark nested functions as needing static-chain initially.
2348 lower_nested_functions will recompute it but the
2349 DECL_STATIC_CHAIN flag is also used before that happens,
2350 by initializer_constant_valid_p. See gcc.dg/nested-fn-2.c. */
2351 DECL_STATIC_CHAIN (decl
) = 1;
2354 c_pop_function_context ();
2355 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
));
2363 /* Get rid of the empty stmt list for GIMPLE. */
2364 if (specs
->gimple_p
)
2365 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
2371 /* Parse an asm-definition (asm() outside a function body). This is a
2379 c_parser_asm_definition (c_parser
*parser
)
2381 tree asm_str
= c_parser_simple_asm_expr (parser
);
2383 symtab
->finalize_toplevel_asm (asm_str
);
2384 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
2387 /* Parse a static assertion (C11 6.7.10).
2389 static_assert-declaration:
2390 static_assert-declaration-no-semi ;
2394 c_parser_static_assert_declaration (c_parser
*parser
)
2396 c_parser_static_assert_declaration_no_semi (parser
);
2398 || !c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
2399 c_parser_skip_to_end_of_block_or_statement (parser
);
2402 /* Parse a static assertion (C11 6.7.10), without the trailing
2405 static_assert-declaration-no-semi:
2406 _Static_assert ( constant-expression , string-literal )
2410 c_parser_static_assert_declaration_no_semi (c_parser
*parser
)
2412 location_t assert_loc
, value_loc
;
2416 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_STATIC_ASSERT
));
2417 assert_loc
= c_parser_peek_token (parser
)->location
;
2419 pedwarn_c99 (assert_loc
, OPT_Wpedantic
,
2420 "ISO C99 does not support %<_Static_assert%>");
2422 pedwarn_c99 (assert_loc
, OPT_Wpedantic
,
2423 "ISO C90 does not support %<_Static_assert%>");
2424 c_parser_consume_token (parser
);
2425 matching_parens parens
;
2426 if (!parens
.require_open (parser
))
2428 location_t value_tok_loc
= c_parser_peek_token (parser
)->location
;
2429 value
= c_parser_expr_no_commas (parser
, NULL
).value
;
2430 value_loc
= EXPR_LOC_OR_LOC (value
, value_tok_loc
);
2431 parser
->lex_untranslated_string
= true;
2432 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
2434 parser
->lex_untranslated_string
= false;
2437 switch (c_parser_peek_token (parser
)->type
)
2443 case CPP_UTF8STRING
:
2444 string
= c_parser_peek_token (parser
)->value
;
2445 c_parser_consume_token (parser
);
2446 parser
->lex_untranslated_string
= false;
2449 c_parser_error (parser
, "expected string literal");
2450 parser
->lex_untranslated_string
= false;
2453 parens
.require_close (parser
);
2455 if (!INTEGRAL_TYPE_P (TREE_TYPE (value
)))
2457 error_at (value_loc
, "expression in static assertion is not an integer");
2460 if (TREE_CODE (value
) != INTEGER_CST
)
2462 value
= c_fully_fold (value
, false, NULL
);
2463 /* Strip no-op conversions. */
2464 STRIP_TYPE_NOPS (value
);
2465 if (TREE_CODE (value
) == INTEGER_CST
)
2466 pedwarn (value_loc
, OPT_Wpedantic
, "expression in static assertion "
2467 "is not an integer constant expression");
2469 if (TREE_CODE (value
) != INTEGER_CST
)
2471 error_at (value_loc
, "expression in static assertion is not constant");
2474 constant_expression_warning (value
);
2475 if (integer_zerop (value
))
2476 error_at (assert_loc
, "static assertion failed: %E", string
);
2479 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
2480 6.7, C11 6.7), adding them to SPECS (which may already include some).
2481 Storage class specifiers are accepted iff SCSPEC_OK; type
2482 specifiers are accepted iff TYPESPEC_OK; alignment specifiers are
2483 accepted iff ALIGNSPEC_OK; attributes are accepted at the start
2484 iff START_ATTR_OK; __auto_type is accepted iff AUTO_TYPE_OK.
2486 declaration-specifiers:
2487 storage-class-specifier declaration-specifiers[opt]
2488 type-specifier declaration-specifiers[opt]
2489 type-qualifier declaration-specifiers[opt]
2490 function-specifier declaration-specifiers[opt]
2491 alignment-specifier declaration-specifiers[opt]
2493 Function specifiers (inline) are from C99, and are currently
2494 handled as storage class specifiers, as is __thread. Alignment
2495 specifiers are from C11.
2497 C90 6.5.1, C99 6.7.1, C11 6.7.1:
2498 storage-class-specifier:
2506 (_Thread_local is new in C11.)
2508 C99 6.7.4, C11 6.7.4:
2513 (_Noreturn is new in C11.)
2515 C90 6.5.2, C99 6.7.2, C11 6.7.2:
2528 [_Imaginary removed in C99 TC2]
2529 struct-or-union-specifier
2532 atomic-type-specifier
2534 (_Bool and _Complex are new in C99.)
2535 (atomic-type-specifier is new in C11.)
2537 C90 6.5.3, C99 6.7.3, C11 6.7.3:
2543 address-space-qualifier
2546 (restrict is new in C99.)
2547 (_Atomic is new in C11.)
2551 declaration-specifiers:
2552 attributes declaration-specifiers[opt]
2558 identifier recognized by the target
2560 storage-class-specifier:
2574 (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
2575 http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
2577 atomic-type-specifier
2578 _Atomic ( type-name )
2583 class-name objc-protocol-refs[opt]
2584 typedef-name objc-protocol-refs
2589 c_parser_declspecs (c_parser
*parser
, struct c_declspecs
*specs
,
2590 bool scspec_ok
, bool typespec_ok
, bool start_attr_ok
,
2591 bool alignspec_ok
, bool auto_type_ok
,
2592 enum c_lookahead_kind la
)
2594 bool attrs_ok
= start_attr_ok
;
2595 bool seen_type
= specs
->typespec_kind
!= ctsk_none
;
2598 gcc_assert (la
== cla_prefer_id
);
2600 while (c_parser_next_token_is (parser
, CPP_NAME
)
2601 || c_parser_next_token_is (parser
, CPP_KEYWORD
)
2602 || (c_dialect_objc () && c_parser_next_token_is (parser
, CPP_LESS
)))
2604 struct c_typespec t
;
2607 location_t loc
= c_parser_peek_token (parser
)->location
;
2609 /* If we cannot accept a type, exit if the next token must start
2610 one. Also, if we already have seen a tagged definition,
2611 a typename would be an error anyway and likely the user
2612 has simply forgotten a semicolon, so we exit. */
2613 if ((!typespec_ok
|| specs
->typespec_kind
== ctsk_tagdef
)
2614 && c_parser_next_tokens_start_typename (parser
, la
)
2615 && !c_parser_next_token_is_qualifier (parser
)
2616 && !c_parser_next_token_is_keyword (parser
, RID_ALIGNAS
))
2619 if (c_parser_next_token_is (parser
, CPP_NAME
))
2621 c_token
*name_token
= c_parser_peek_token (parser
);
2622 tree value
= name_token
->value
;
2623 c_id_kind kind
= name_token
->id_kind
;
2625 if (kind
== C_ID_ADDRSPACE
)
2628 = name_token
->keyword
- RID_FIRST_ADDR_SPACE
;
2629 declspecs_add_addrspace (name_token
->location
, specs
, as
);
2630 c_parser_consume_token (parser
);
2635 gcc_assert (!c_parser_next_token_is_qualifier (parser
));
2637 /* If we cannot accept a type, and the next token must start one,
2638 exit. Do the same if we already have seen a tagged definition,
2639 since it would be an error anyway and likely the user has simply
2640 forgotten a semicolon. */
2641 if (seen_type
|| !c_parser_next_tokens_start_typename (parser
, la
))
2644 /* Now at an unknown typename (C_ID_ID), a C_ID_TYPENAME or
2645 a C_ID_CLASSNAME. */
2646 c_parser_consume_token (parser
);
2649 if (kind
== C_ID_ID
)
2651 error_at (loc
, "unknown type name %qE", value
);
2652 t
.kind
= ctsk_typedef
;
2653 t
.spec
= error_mark_node
;
2655 else if (kind
== C_ID_TYPENAME
2656 && (!c_dialect_objc ()
2657 || c_parser_next_token_is_not (parser
, CPP_LESS
)))
2659 t
.kind
= ctsk_typedef
;
2660 /* For a typedef name, record the meaning, not the name.
2661 In case of 'foo foo, bar;'. */
2662 t
.spec
= lookup_name (value
);
2666 tree proto
= NULL_TREE
;
2667 gcc_assert (c_dialect_objc ());
2669 if (c_parser_next_token_is (parser
, CPP_LESS
))
2670 proto
= c_parser_objc_protocol_refs (parser
);
2671 t
.spec
= objc_get_protocol_qualified_type (value
, proto
);
2674 t
.expr_const_operands
= true;
2675 declspecs_add_type (name_token
->location
, specs
, t
);
2678 if (c_parser_next_token_is (parser
, CPP_LESS
))
2680 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
2681 nisse@lysator.liu.se. */
2683 gcc_assert (c_dialect_objc ());
2684 if (!typespec_ok
|| seen_type
)
2686 proto
= c_parser_objc_protocol_refs (parser
);
2688 t
.spec
= objc_get_protocol_qualified_type (NULL_TREE
, proto
);
2690 t
.expr_const_operands
= true;
2691 declspecs_add_type (loc
, specs
, t
);
2694 gcc_assert (c_parser_next_token_is (parser
, CPP_KEYWORD
));
2695 switch (c_parser_peek_token (parser
)->keyword
)
2708 /* TODO: Distinguish between function specifiers (inline, noreturn)
2709 and storage class specifiers, either here or in
2710 declspecs_add_scspec. */
2711 declspecs_add_scspec (loc
, specs
,
2712 c_parser_peek_token (parser
)->value
);
2713 c_parser_consume_token (parser
);
2745 if (c_dialect_objc ())
2746 parser
->objc_need_raw_identifier
= true;
2747 t
.kind
= ctsk_resword
;
2748 t
.spec
= c_parser_peek_token (parser
)->value
;
2750 t
.expr_const_operands
= true;
2751 declspecs_add_type (loc
, specs
, t
);
2752 c_parser_consume_token (parser
);
2759 t
= c_parser_enum_specifier (parser
);
2760 invoke_plugin_callbacks (PLUGIN_FINISH_TYPE
, t
.spec
);
2761 declspecs_add_type (loc
, specs
, t
);
2769 t
= c_parser_struct_or_union_specifier (parser
);
2770 invoke_plugin_callbacks (PLUGIN_FINISH_TYPE
, t
.spec
);
2771 declspecs_add_type (loc
, specs
, t
);
2774 /* ??? The old parser rejected typeof after other type
2775 specifiers, but is a syntax error the best way of
2777 if (!typespec_ok
|| seen_type
)
2781 t
= c_parser_typeof_specifier (parser
);
2782 declspecs_add_type (loc
, specs
, t
);
2785 /* C parser handling of Objective-C constructs needs
2786 checking for correct lvalue-to-rvalue conversions, and
2787 the code in build_modify_expr handling various
2788 Objective-C cases, and that in build_unary_op handling
2789 Objective-C cases for increment / decrement, also needs
2790 updating; uses of TYPE_MAIN_VARIANT in objc_compare_types
2791 and objc_types_are_equivalent may also need updates. */
2792 if (c_dialect_objc ())
2793 sorry ("%<_Atomic%> in Objective-C");
2795 pedwarn_c99 (loc
, OPT_Wpedantic
,
2796 "ISO C99 does not support the %<_Atomic%> qualifier");
2798 pedwarn_c99 (loc
, OPT_Wpedantic
,
2799 "ISO C90 does not support the %<_Atomic%> qualifier");
2802 value
= c_parser_peek_token (parser
)->value
;
2803 c_parser_consume_token (parser
);
2804 if (typespec_ok
&& c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
2806 /* _Atomic ( type-name ). */
2808 c_parser_consume_token (parser
);
2809 struct c_type_name
*type
= c_parser_type_name (parser
);
2810 t
.kind
= ctsk_typeof
;
2811 t
.spec
= error_mark_node
;
2813 t
.expr_const_operands
= true;
2815 t
.spec
= groktypename (type
, &t
.expr
,
2816 &t
.expr_const_operands
);
2817 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2819 if (t
.spec
!= error_mark_node
)
2821 if (TREE_CODE (t
.spec
) == ARRAY_TYPE
)
2822 error_at (loc
, "%<_Atomic%>-qualified array type");
2823 else if (TREE_CODE (t
.spec
) == FUNCTION_TYPE
)
2824 error_at (loc
, "%<_Atomic%>-qualified function type");
2825 else if (TYPE_QUALS (t
.spec
) != TYPE_UNQUALIFIED
)
2826 error_at (loc
, "%<_Atomic%> applied to a qualified type");
2828 t
.spec
= c_build_qualified_type (t
.spec
, TYPE_QUAL_ATOMIC
);
2830 declspecs_add_type (loc
, specs
, t
);
2833 declspecs_add_qual (loc
, specs
, value
);
2839 declspecs_add_qual (loc
, specs
, c_parser_peek_token (parser
)->value
);
2840 c_parser_consume_token (parser
);
2845 attrs
= c_parser_attributes (parser
);
2846 declspecs_add_attrs (loc
, specs
, attrs
);
2851 align
= c_parser_alignas_specifier (parser
);
2852 declspecs_add_alignas (loc
, specs
, align
);
2856 error_at (loc
, "%<__GIMPLE%> only valid with -fgimple");
2857 c_parser_consume_token (parser
);
2858 specs
->gimple_p
= true;
2859 specs
->locations
[cdw_gimple
] = loc
;
2860 specs
->gimple_or_rtl_pass
= c_parser_gimple_or_rtl_pass_list (parser
);
2863 c_parser_consume_token (parser
);
2864 specs
->rtl_p
= true;
2865 specs
->locations
[cdw_rtl
] = loc
;
2866 specs
->gimple_or_rtl_pass
= c_parser_gimple_or_rtl_pass_list (parser
);
2875 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2, C11 6.7.2.2).
2878 enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
2879 enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
2880 enum attributes[opt] identifier
2882 The form with trailing comma is new in C99. The forms with
2883 attributes are GNU extensions. In GNU C, we accept any expression
2884 without commas in the syntax (assignment expressions, not just
2885 conditional expressions); assignment expressions will be diagnosed
2890 enumerator-list , enumerator
2893 enumeration-constant
2894 enumeration-constant = constant-expression
2899 enumeration-constant attributes[opt]
2900 enumeration-constant attributes[opt] = constant-expression
2904 static struct c_typespec
2905 c_parser_enum_specifier (c_parser
*parser
)
2907 struct c_typespec ret
;
2909 tree ident
= NULL_TREE
;
2910 location_t enum_loc
;
2911 location_t ident_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
2912 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ENUM
));
2913 c_parser_consume_token (parser
);
2914 attrs
= c_parser_attributes (parser
);
2915 enum_loc
= c_parser_peek_token (parser
)->location
;
2916 /* Set the location in case we create a decl now. */
2917 c_parser_set_source_position_from_token (c_parser_peek_token (parser
));
2918 if (c_parser_next_token_is (parser
, CPP_NAME
))
2920 ident
= c_parser_peek_token (parser
)->value
;
2921 ident_loc
= c_parser_peek_token (parser
)->location
;
2922 enum_loc
= ident_loc
;
2923 c_parser_consume_token (parser
);
2925 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
2927 /* Parse an enum definition. */
2928 struct c_enum_contents the_enum
;
2931 /* We chain the enumerators in reverse order, then put them in
2932 forward order at the end. */
2934 timevar_push (TV_PARSE_ENUM
);
2935 type
= start_enum (enum_loc
, &the_enum
, ident
);
2937 c_parser_consume_token (parser
);
2945 location_t comma_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
2946 location_t decl_loc
, value_loc
;
2947 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
2949 /* Give a nicer error for "enum {}". */
2950 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
)
2953 error_at (c_parser_peek_token (parser
)->location
,
2954 "empty enum is invalid");
2955 parser
->error
= true;
2958 c_parser_error (parser
, "expected identifier");
2959 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
2960 values
= error_mark_node
;
2963 token
= c_parser_peek_token (parser
);
2964 enum_id
= token
->value
;
2965 /* Set the location in case we create a decl now. */
2966 c_parser_set_source_position_from_token (token
);
2967 decl_loc
= value_loc
= token
->location
;
2968 c_parser_consume_token (parser
);
2969 /* Parse any specified attributes. */
2970 tree enum_attrs
= c_parser_attributes (parser
);
2971 if (c_parser_next_token_is (parser
, CPP_EQ
))
2973 c_parser_consume_token (parser
);
2974 value_loc
= c_parser_peek_token (parser
)->location
;
2975 enum_value
= c_parser_expr_no_commas (parser
, NULL
).value
;
2978 enum_value
= NULL_TREE
;
2979 enum_decl
= build_enumerator (decl_loc
, value_loc
,
2980 &the_enum
, enum_id
, enum_value
);
2982 decl_attributes (&TREE_PURPOSE (enum_decl
), enum_attrs
, 0);
2983 TREE_CHAIN (enum_decl
) = values
;
2986 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2988 comma_loc
= c_parser_peek_token (parser
)->location
;
2990 c_parser_consume_token (parser
);
2992 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2995 pedwarn_c90 (comma_loc
, OPT_Wpedantic
,
2996 "comma at end of enumerator list");
2997 c_parser_consume_token (parser
);
3002 c_parser_error (parser
, "expected %<,%> or %<}%>");
3003 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
3004 values
= error_mark_node
;
3008 postfix_attrs
= c_parser_attributes (parser
);
3009 ret
.spec
= finish_enum (type
, nreverse (values
),
3010 chainon (attrs
, postfix_attrs
));
3011 ret
.kind
= ctsk_tagdef
;
3012 ret
.expr
= NULL_TREE
;
3013 ret
.expr_const_operands
= true;
3014 timevar_pop (TV_PARSE_ENUM
);
3019 c_parser_error (parser
, "expected %<{%>");
3020 ret
.spec
= error_mark_node
;
3021 ret
.kind
= ctsk_tagref
;
3022 ret
.expr
= NULL_TREE
;
3023 ret
.expr_const_operands
= true;
3026 ret
= parser_xref_tag (ident_loc
, ENUMERAL_TYPE
, ident
);
3027 /* In ISO C, enumerated types can be referred to only if already
3029 if (pedantic
&& !COMPLETE_TYPE_P (ret
.spec
))
3032 pedwarn (enum_loc
, OPT_Wpedantic
,
3033 "ISO C forbids forward references to %<enum%> types");
3038 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1, C11 6.7.2.1).
3040 struct-or-union-specifier:
3041 struct-or-union attributes[opt] identifier[opt]
3042 { struct-contents } attributes[opt]
3043 struct-or-union attributes[opt] identifier
3046 struct-declaration-list
3048 struct-declaration-list:
3049 struct-declaration ;
3050 struct-declaration-list struct-declaration ;
3057 struct-declaration-list struct-declaration
3059 struct-declaration-list:
3060 struct-declaration-list ;
3063 (Note that in the syntax here, unlike that in ISO C, the semicolons
3064 are included here rather than in struct-declaration, in order to
3065 describe the syntax with extra semicolons and missing semicolon at
3070 struct-declaration-list:
3071 @defs ( class-name )
3073 (Note this does not include a trailing semicolon, but can be
3074 followed by further declarations, and gets a pedwarn-if-pedantic
3075 when followed by a semicolon.) */
3077 static struct c_typespec
3078 c_parser_struct_or_union_specifier (c_parser
*parser
)
3080 struct c_typespec ret
;
3082 tree ident
= NULL_TREE
;
3083 location_t struct_loc
;
3084 location_t ident_loc
= UNKNOWN_LOCATION
;
3085 enum tree_code code
;
3086 switch (c_parser_peek_token (parser
)->keyword
)
3097 struct_loc
= c_parser_peek_token (parser
)->location
;
3098 c_parser_consume_token (parser
);
3099 attrs
= c_parser_attributes (parser
);
3101 /* Set the location in case we create a decl now. */
3102 c_parser_set_source_position_from_token (c_parser_peek_token (parser
));
3104 if (c_parser_next_token_is (parser
, CPP_NAME
))
3106 ident
= c_parser_peek_token (parser
)->value
;
3107 ident_loc
= c_parser_peek_token (parser
)->location
;
3108 struct_loc
= ident_loc
;
3109 c_parser_consume_token (parser
);
3111 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
3113 /* Parse a struct or union definition. Start the scope of the
3114 tag before parsing components. */
3115 struct c_struct_parse_info
*struct_info
;
3116 tree type
= start_struct (struct_loc
, code
, ident
, &struct_info
);
3118 /* We chain the components in reverse order, then put them in
3119 forward order at the end. Each struct-declaration may
3120 declare multiple components (comma-separated), so we must use
3121 chainon to join them, although when parsing each
3122 struct-declaration we can use TREE_CHAIN directly.
3124 The theory behind all this is that there will be more
3125 semicolon separated fields than comma separated fields, and
3126 so we'll be minimizing the number of node traversals required
3129 timevar_push (TV_PARSE_STRUCT
);
3130 contents
= NULL_TREE
;
3131 c_parser_consume_token (parser
);
3132 /* Handle the Objective-C @defs construct,
3133 e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
3134 if (c_parser_next_token_is_keyword (parser
, RID_AT_DEFS
))
3137 gcc_assert (c_dialect_objc ());
3138 c_parser_consume_token (parser
);
3139 matching_parens parens
;
3140 if (!parens
.require_open (parser
))
3142 if (c_parser_next_token_is (parser
, CPP_NAME
)
3143 && c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
)
3145 name
= c_parser_peek_token (parser
)->value
;
3146 c_parser_consume_token (parser
);
3150 c_parser_error (parser
, "expected class name");
3151 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
3154 parens
.skip_until_found_close (parser
);
3155 contents
= nreverse (objc_get_class_ivars (name
));
3158 /* Parse the struct-declarations and semicolons. Problems with
3159 semicolons are diagnosed here; empty structures are diagnosed
3164 /* Parse any stray semicolon. */
3165 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3167 location_t semicolon_loc
3168 = c_parser_peek_token (parser
)->location
;
3169 gcc_rich_location
richloc (semicolon_loc
);
3170 richloc
.add_fixit_remove ();
3171 pedwarn (&richloc
, OPT_Wpedantic
,
3172 "extra semicolon in struct or union specified");
3173 c_parser_consume_token (parser
);
3176 /* Stop if at the end of the struct or union contents. */
3177 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3179 c_parser_consume_token (parser
);
3182 /* Accept #pragmas at struct scope. */
3183 if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
3185 c_parser_pragma (parser
, pragma_struct
, NULL
);
3188 /* Parse some comma-separated declarations, but not the
3189 trailing semicolon if any. */
3190 decls
= c_parser_struct_declaration (parser
);
3191 contents
= chainon (decls
, contents
);
3192 /* If no semicolon follows, either we have a parse error or
3193 are at the end of the struct or union and should
3195 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3196 c_parser_consume_token (parser
);
3199 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3200 pedwarn (c_parser_peek_token (parser
)->location
, 0,
3201 "no semicolon at end of struct or union");
3202 else if (parser
->error
3203 || !c_parser_next_token_starts_declspecs (parser
))
3205 c_parser_error (parser
, "expected %<;%>");
3206 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
3210 /* If we come here, we have already emitted an error
3211 for an expected `;', identifier or `(', and we also
3212 recovered already. Go on with the next field. */
3215 postfix_attrs
= c_parser_attributes (parser
);
3216 ret
.spec
= finish_struct (struct_loc
, type
, nreverse (contents
),
3217 chainon (attrs
, postfix_attrs
), struct_info
);
3218 ret
.kind
= ctsk_tagdef
;
3219 ret
.expr
= NULL_TREE
;
3220 ret
.expr_const_operands
= true;
3221 timevar_pop (TV_PARSE_STRUCT
);
3226 c_parser_error (parser
, "expected %<{%>");
3227 ret
.spec
= error_mark_node
;
3228 ret
.kind
= ctsk_tagref
;
3229 ret
.expr
= NULL_TREE
;
3230 ret
.expr_const_operands
= true;
3233 ret
= parser_xref_tag (ident_loc
, code
, ident
);
3237 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1, C11 6.7.2.1),
3238 *without* the trailing semicolon.
3241 specifier-qualifier-list struct-declarator-list
3242 static_assert-declaration-no-semi
3244 specifier-qualifier-list:
3245 type-specifier specifier-qualifier-list[opt]
3246 type-qualifier specifier-qualifier-list[opt]
3247 alignment-specifier specifier-qualifier-list[opt]
3248 attributes specifier-qualifier-list[opt]
3250 struct-declarator-list:
3252 struct-declarator-list , attributes[opt] struct-declarator
3255 declarator attributes[opt]
3256 declarator[opt] : constant-expression attributes[opt]
3261 __extension__ struct-declaration
3262 specifier-qualifier-list
3264 Unlike the ISO C syntax, semicolons are handled elsewhere. The use
3265 of attributes where shown is a GNU extension. In GNU C, we accept
3266 any expression without commas in the syntax (assignment
3267 expressions, not just conditional expressions); assignment
3268 expressions will be diagnosed as non-constant. */
3271 c_parser_struct_declaration (c_parser
*parser
)
3273 struct c_declspecs
*specs
;
3275 tree all_prefix_attrs
;
3277 location_t decl_loc
;
3278 if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
3282 ext
= disable_extension_diagnostics ();
3283 c_parser_consume_token (parser
);
3284 decl
= c_parser_struct_declaration (parser
);
3285 restore_extension_diagnostics (ext
);
3288 if (c_parser_next_token_is_keyword (parser
, RID_STATIC_ASSERT
))
3290 c_parser_static_assert_declaration_no_semi (parser
);
3293 specs
= build_null_declspecs ();
3294 decl_loc
= c_parser_peek_token (parser
)->location
;
3295 /* Strictly by the standard, we shouldn't allow _Alignas here,
3296 but it appears to have been intended to allow it there, so
3297 we're keeping it as it is until WG14 reaches a conclusion
3299 <http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1731.pdf> */
3300 c_parser_declspecs (parser
, specs
, false, true, true,
3301 true, false, cla_nonabstract_decl
);
3304 if (!specs
->declspecs_seen_p
)
3306 c_parser_error (parser
, "expected specifier-qualifier-list");
3309 finish_declspecs (specs
);
3310 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
3311 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3314 if (specs
->typespec_kind
== ctsk_none
)
3316 pedwarn (decl_loc
, OPT_Wpedantic
,
3317 "ISO C forbids member declarations with no members");
3318 shadow_tag_warned (specs
, pedantic
);
3323 /* Support for unnamed structs or unions as members of
3324 structs or unions (which is [a] useful and [b] supports
3328 ret
= grokfield (c_parser_peek_token (parser
)->location
,
3329 build_id_declarator (NULL_TREE
), specs
,
3332 decl_attributes (&ret
, attrs
, 0);
3337 /* Provide better error recovery. Note that a type name here is valid,
3338 and will be treated as a field name. */
3339 if (specs
->typespec_kind
== ctsk_tagdef
3340 && TREE_CODE (specs
->type
) != ENUMERAL_TYPE
3341 && c_parser_next_token_starts_declspecs (parser
)
3342 && !c_parser_next_token_is (parser
, CPP_NAME
))
3344 c_parser_error (parser
, "expected %<;%>, identifier or %<(%>");
3345 parser
->error
= false;
3349 pending_xref_error ();
3350 prefix_attrs
= specs
->attrs
;
3351 all_prefix_attrs
= prefix_attrs
;
3352 specs
->attrs
= NULL_TREE
;
3356 /* Declaring one or more declarators or un-named bit-fields. */
3357 struct c_declarator
*declarator
;
3359 if (c_parser_next_token_is (parser
, CPP_COLON
))
3360 declarator
= build_id_declarator (NULL_TREE
);
3362 declarator
= c_parser_declarator (parser
,
3363 specs
->typespec_kind
!= ctsk_none
,
3364 C_DTR_NORMAL
, &dummy
);
3365 if (declarator
== NULL
)
3367 c_parser_skip_to_end_of_block_or_statement (parser
);
3370 if (c_parser_next_token_is (parser
, CPP_COLON
)
3371 || c_parser_next_token_is (parser
, CPP_COMMA
)
3372 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
3373 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
)
3374 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
3376 tree postfix_attrs
= NULL_TREE
;
3377 tree width
= NULL_TREE
;
3379 if (c_parser_next_token_is (parser
, CPP_COLON
))
3381 c_parser_consume_token (parser
);
3382 width
= c_parser_expr_no_commas (parser
, NULL
).value
;
3384 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
3385 postfix_attrs
= c_parser_attributes (parser
);
3386 d
= grokfield (c_parser_peek_token (parser
)->location
,
3387 declarator
, specs
, width
, &all_prefix_attrs
);
3388 decl_attributes (&d
, chainon (postfix_attrs
,
3389 all_prefix_attrs
), 0);
3390 DECL_CHAIN (d
) = decls
;
3392 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
3393 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
3396 all_prefix_attrs
= prefix_attrs
;
3397 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3398 c_parser_consume_token (parser
);
3399 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
3400 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3402 /* Semicolon consumed in caller. */
3407 c_parser_error (parser
, "expected %<,%>, %<;%> or %<}%>");
3413 c_parser_error (parser
,
3414 "expected %<:%>, %<,%>, %<;%>, %<}%> or "
3415 "%<__attribute__%>");
3422 /* Parse a typeof specifier (a GNU extension).
3425 typeof ( expression )
3426 typeof ( type-name )
3429 static struct c_typespec
3430 c_parser_typeof_specifier (c_parser
*parser
)
3432 struct c_typespec ret
;
3433 ret
.kind
= ctsk_typeof
;
3434 ret
.spec
= error_mark_node
;
3435 ret
.expr
= NULL_TREE
;
3436 ret
.expr_const_operands
= true;
3437 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_TYPEOF
));
3438 c_parser_consume_token (parser
);
3439 c_inhibit_evaluation_warnings
++;
3441 matching_parens parens
;
3442 if (!parens
.require_open (parser
))
3444 c_inhibit_evaluation_warnings
--;
3448 if (c_parser_next_tokens_start_typename (parser
, cla_prefer_id
))
3450 struct c_type_name
*type
= c_parser_type_name (parser
);
3451 c_inhibit_evaluation_warnings
--;
3455 ret
.spec
= groktypename (type
, &ret
.expr
, &ret
.expr_const_operands
);
3456 pop_maybe_used (variably_modified_type_p (ret
.spec
, NULL_TREE
));
3462 location_t here
= c_parser_peek_token (parser
)->location
;
3463 struct c_expr expr
= c_parser_expression (parser
);
3464 c_inhibit_evaluation_warnings
--;
3466 if (TREE_CODE (expr
.value
) == COMPONENT_REF
3467 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
3468 error_at (here
, "%<typeof%> applied to a bit-field");
3469 mark_exp_read (expr
.value
);
3470 ret
.spec
= TREE_TYPE (expr
.value
);
3471 was_vm
= variably_modified_type_p (ret
.spec
, NULL_TREE
);
3472 /* This is returned with the type so that when the type is
3473 evaluated, this can be evaluated. */
3475 ret
.expr
= c_fully_fold (expr
.value
, false, &ret
.expr_const_operands
);
3476 pop_maybe_used (was_vm
);
3477 /* For use in macros such as those in <stdatomic.h>, remove all
3478 qualifiers from atomic types. (const can be an issue for more macros
3479 using typeof than just the <stdatomic.h> ones.) */
3480 if (ret
.spec
!= error_mark_node
&& TYPE_ATOMIC (ret
.spec
))
3481 ret
.spec
= c_build_qualified_type (ret
.spec
, TYPE_UNQUALIFIED
);
3483 parens
.skip_until_found_close (parser
);
3487 /* Parse an alignment-specifier.
3491 alignment-specifier:
3492 _Alignas ( type-name )
3493 _Alignas ( constant-expression )
3497 c_parser_alignas_specifier (c_parser
* parser
)
3499 tree ret
= error_mark_node
;
3500 location_t loc
= c_parser_peek_token (parser
)->location
;
3501 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ALIGNAS
));
3502 c_parser_consume_token (parser
);
3504 pedwarn_c99 (loc
, OPT_Wpedantic
,
3505 "ISO C99 does not support %<_Alignas%>");
3507 pedwarn_c99 (loc
, OPT_Wpedantic
,
3508 "ISO C90 does not support %<_Alignas%>");
3509 matching_parens parens
;
3510 if (!parens
.require_open (parser
))
3512 if (c_parser_next_tokens_start_typename (parser
, cla_prefer_id
))
3514 struct c_type_name
*type
= c_parser_type_name (parser
);
3516 ret
= c_sizeof_or_alignof_type (loc
, groktypename (type
, NULL
, NULL
),
3520 ret
= c_parser_expr_no_commas (parser
, NULL
).value
;
3521 parens
.skip_until_found_close (parser
);
3525 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
3526 6.5.5, C99 6.7.5, 6.7.6, C11 6.7.6, 6.7.7). If TYPE_SEEN_P then
3527 a typedef name may be redeclared; otherwise it may not. KIND
3528 indicates which kind of declarator is wanted. Returns a valid
3529 declarator except in the case of a syntax error in which case NULL is
3530 returned. *SEEN_ID is set to true if an identifier being declared is
3531 seen; this is used to diagnose bad forms of abstract array declarators
3532 and to determine whether an identifier list is syntactically permitted.
3535 pointer[opt] direct-declarator
3539 ( attributes[opt] declarator )
3540 direct-declarator array-declarator
3541 direct-declarator ( parameter-type-list )
3542 direct-declarator ( identifier-list[opt] )
3545 * type-qualifier-list[opt]
3546 * type-qualifier-list[opt] pointer
3548 type-qualifier-list:
3551 type-qualifier-list type-qualifier
3552 type-qualifier-list attributes
3555 [ type-qualifier-list[opt] assignment-expression[opt] ]
3556 [ static type-qualifier-list[opt] assignment-expression ]
3557 [ type-qualifier-list static assignment-expression ]
3558 [ type-qualifier-list[opt] * ]
3560 parameter-type-list:
3562 parameter-list , ...
3565 parameter-declaration
3566 parameter-list , parameter-declaration
3568 parameter-declaration:
3569 declaration-specifiers declarator attributes[opt]
3570 declaration-specifiers abstract-declarator[opt] attributes[opt]
3574 identifier-list , identifier
3576 abstract-declarator:
3578 pointer[opt] direct-abstract-declarator
3580 direct-abstract-declarator:
3581 ( attributes[opt] abstract-declarator )
3582 direct-abstract-declarator[opt] array-declarator
3583 direct-abstract-declarator[opt] ( parameter-type-list[opt] )
3588 direct-declarator ( parameter-forward-declarations
3589 parameter-type-list[opt] )
3591 direct-abstract-declarator:
3592 direct-abstract-declarator[opt] ( parameter-forward-declarations
3593 parameter-type-list[opt] )
3595 parameter-forward-declarations:
3597 parameter-forward-declarations parameter-list ;
3599 The uses of attributes shown above are GNU extensions.
3601 Some forms of array declarator are not included in C99 in the
3602 syntax for abstract declarators; these are disallowed elsewhere.
3603 This may be a defect (DR#289).
3605 This function also accepts an omitted abstract declarator as being
3606 an abstract declarator, although not part of the formal syntax. */
3608 struct c_declarator
*
3609 c_parser_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
3612 /* Parse any initial pointer part. */
3613 if (c_parser_next_token_is (parser
, CPP_MULT
))
3615 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
3616 struct c_declarator
*inner
;
3617 c_parser_consume_token (parser
);
3618 c_parser_declspecs (parser
, quals_attrs
, false, false, true,
3619 false, false, cla_prefer_id
);
3620 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
3624 return make_pointer_declarator (quals_attrs
, inner
);
3626 /* Now we have a direct declarator, direct abstract declarator or
3627 nothing (which counts as a direct abstract declarator here). */
3628 return c_parser_direct_declarator (parser
, type_seen_p
, kind
, seen_id
);
3631 /* Parse a direct declarator or direct abstract declarator; arguments
3632 as c_parser_declarator. */
3634 static struct c_declarator
*
3635 c_parser_direct_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
3638 /* The direct declarator must start with an identifier (possibly
3639 omitted) or a parenthesized declarator (possibly abstract). In
3640 an ordinary declarator, initial parentheses must start a
3641 parenthesized declarator. In an abstract declarator or parameter
3642 declarator, they could start a parenthesized declarator or a
3643 parameter list. To tell which, the open parenthesis and any
3644 following attributes must be read. If a declaration specifier
3645 follows, then it is a parameter list; if the specifier is a
3646 typedef name, there might be an ambiguity about redeclaring it,
3647 which is resolved in the direction of treating it as a typedef
3648 name. If a close parenthesis follows, it is also an empty
3649 parameter list, as the syntax does not permit empty abstract
3650 declarators. Otherwise, it is a parenthesized declarator (in
3651 which case the analysis may be repeated inside it, recursively).
3653 ??? There is an ambiguity in a parameter declaration "int
3654 (__attribute__((foo)) x)", where x is not a typedef name: it
3655 could be an abstract declarator for a function, or declare x with
3656 parentheses. The proper resolution of this ambiguity needs
3657 documenting. At present we follow an accident of the old
3658 parser's implementation, whereby the first parameter must have
3659 some declaration specifiers other than just attributes. Thus as
3660 a parameter declaration it is treated as a parenthesized
3661 parameter named x, and as an abstract declarator it is
3664 ??? Also following the old parser, attributes inside an empty
3665 parameter list are ignored, making it a list not yielding a
3666 prototype, rather than giving an error or making it have one
3667 parameter with implicit type int.
3669 ??? Also following the old parser, typedef names may be
3670 redeclared in declarators, but not Objective-C class names. */
3672 if (kind
!= C_DTR_ABSTRACT
3673 && c_parser_next_token_is (parser
, CPP_NAME
)
3675 && (c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
3676 || c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
))
3677 || c_parser_peek_token (parser
)->id_kind
== C_ID_ID
))
3679 struct c_declarator
*inner
3680 = build_id_declarator (c_parser_peek_token (parser
)->value
);
3682 inner
->id_loc
= c_parser_peek_token (parser
)->location
;
3683 c_parser_consume_token (parser
);
3684 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
3687 if (kind
!= C_DTR_NORMAL
3688 && c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
3690 struct c_declarator
*inner
= build_id_declarator (NULL_TREE
);
3691 inner
->id_loc
= c_parser_peek_token (parser
)->location
;
3692 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
3695 /* Either we are at the end of an abstract declarator, or we have
3698 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
3701 struct c_declarator
*inner
;
3702 c_parser_consume_token (parser
);
3703 attrs
= c_parser_attributes (parser
);
3704 if (kind
!= C_DTR_NORMAL
3705 && (c_parser_next_token_starts_declspecs (parser
)
3706 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
)))
3708 struct c_arg_info
*args
3709 = c_parser_parms_declarator (parser
, kind
== C_DTR_NORMAL
,
3716 = build_function_declarator (args
,
3717 build_id_declarator (NULL_TREE
));
3718 return c_parser_direct_declarator_inner (parser
, *seen_id
,
3722 /* A parenthesized declarator. */
3723 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
3724 if (inner
!= NULL
&& attrs
!= NULL
)
3725 inner
= build_attrs_declarator (attrs
, inner
);
3726 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3728 c_parser_consume_token (parser
);
3732 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
3736 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3743 if (kind
== C_DTR_NORMAL
)
3745 c_parser_error (parser
, "expected identifier or %<(%>");
3749 return build_id_declarator (NULL_TREE
);
3753 /* Parse part of a direct declarator or direct abstract declarator,
3754 given that some (in INNER) has already been parsed; ID_PRESENT is
3755 true if an identifier is present, false for an abstract
3758 static struct c_declarator
*
3759 c_parser_direct_declarator_inner (c_parser
*parser
, bool id_present
,
3760 struct c_declarator
*inner
)
3762 /* Parse a sequence of array declarators and parameter lists. */
3763 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
3765 location_t brace_loc
= c_parser_peek_token (parser
)->location
;
3766 struct c_declarator
*declarator
;
3767 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
3770 struct c_expr dimen
;
3771 dimen
.value
= NULL_TREE
;
3772 dimen
.original_code
= ERROR_MARK
;
3773 dimen
.original_type
= NULL_TREE
;
3774 c_parser_consume_token (parser
);
3775 c_parser_declspecs (parser
, quals_attrs
, false, false, true,
3776 false, false, cla_prefer_id
);
3777 static_seen
= c_parser_next_token_is_keyword (parser
, RID_STATIC
);
3779 c_parser_consume_token (parser
);
3780 if (static_seen
&& !quals_attrs
->declspecs_seen_p
)
3781 c_parser_declspecs (parser
, quals_attrs
, false, false, true,
3782 false, false, cla_prefer_id
);
3783 if (!quals_attrs
->declspecs_seen_p
)
3785 /* If "static" is present, there must be an array dimension.
3786 Otherwise, there may be a dimension, "*", or no
3791 dimen
= c_parser_expr_no_commas (parser
, NULL
);
3795 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3797 dimen
.value
= NULL_TREE
;
3800 else if (c_parser_next_token_is (parser
, CPP_MULT
))
3802 if (c_parser_peek_2nd_token (parser
)->type
== CPP_CLOSE_SQUARE
)
3804 dimen
.value
= NULL_TREE
;
3806 c_parser_consume_token (parser
);
3811 dimen
= c_parser_expr_no_commas (parser
, NULL
);
3817 dimen
= c_parser_expr_no_commas (parser
, NULL
);
3820 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3821 c_parser_consume_token (parser
);
3824 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3829 dimen
= convert_lvalue_to_rvalue (brace_loc
, dimen
, true, true);
3830 declarator
= build_array_declarator (brace_loc
, dimen
.value
, quals_attrs
,
3831 static_seen
, star_seen
);
3832 if (declarator
== NULL
)
3834 inner
= set_array_declarator_inner (declarator
, inner
);
3835 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
3837 else if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
3840 struct c_arg_info
*args
;
3841 c_parser_consume_token (parser
);
3842 attrs
= c_parser_attributes (parser
);
3843 args
= c_parser_parms_declarator (parser
, id_present
, attrs
);
3848 inner
= build_function_declarator (args
, inner
);
3849 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
3855 /* Parse a parameter list or identifier list, including the closing
3856 parenthesis but not the opening one. ATTRS are the attributes at
3857 the start of the list. ID_LIST_OK is true if an identifier list is
3858 acceptable; such a list must not have attributes at the start. */
3860 static struct c_arg_info
*
3861 c_parser_parms_declarator (c_parser
*parser
, bool id_list_ok
, tree attrs
)
3864 declare_parm_level ();
3865 /* If the list starts with an identifier, it is an identifier list.
3866 Otherwise, it is either a prototype list or an empty list. */
3869 && c_parser_next_token_is (parser
, CPP_NAME
)
3870 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
3872 /* Look ahead to detect typos in type names. */
3873 && c_parser_peek_2nd_token (parser
)->type
!= CPP_NAME
3874 && c_parser_peek_2nd_token (parser
)->type
!= CPP_MULT
3875 && c_parser_peek_2nd_token (parser
)->type
!= CPP_OPEN_PAREN
3876 && c_parser_peek_2nd_token (parser
)->type
!= CPP_OPEN_SQUARE
3877 && c_parser_peek_2nd_token (parser
)->type
!= CPP_KEYWORD
)
3879 tree list
= NULL_TREE
, *nextp
= &list
;
3880 while (c_parser_next_token_is (parser
, CPP_NAME
)
3881 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
3883 *nextp
= build_tree_list (NULL_TREE
,
3884 c_parser_peek_token (parser
)->value
);
3885 nextp
= & TREE_CHAIN (*nextp
);
3886 c_parser_consume_token (parser
);
3887 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
3889 c_parser_consume_token (parser
);
3890 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3892 c_parser_error (parser
, "expected identifier");
3896 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3898 struct c_arg_info
*ret
= build_arg_info ();
3900 c_parser_consume_token (parser
);
3906 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3914 struct c_arg_info
*ret
= c_parser_parms_list_declarator (parser
, attrs
,
3921 /* Parse a parameter list (possibly empty), including the closing
3922 parenthesis but not the opening one. ATTRS are the attributes at
3923 the start of the list. EXPR is NULL or an expression that needs to
3924 be evaluated for the side effects of array size expressions in the
3927 static struct c_arg_info
*
3928 c_parser_parms_list_declarator (c_parser
*parser
, tree attrs
, tree expr
)
3930 bool bad_parm
= false;
3932 /* ??? Following the old parser, forward parameter declarations may
3933 use abstract declarators, and if no real parameter declarations
3934 follow the forward declarations then this is not diagnosed. Also
3935 note as above that attributes are ignored as the only contents of
3936 the parentheses, or as the only contents after forward
3938 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3940 struct c_arg_info
*ret
= build_arg_info ();
3941 c_parser_consume_token (parser
);
3944 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3946 struct c_arg_info
*ret
= build_arg_info ();
3948 if (flag_allow_parameterless_variadic_functions
)
3950 /* F (...) is allowed. */
3951 ret
->types
= NULL_TREE
;
3955 /* Suppress -Wold-style-definition for this case. */
3956 ret
->types
= error_mark_node
;
3957 error_at (c_parser_peek_token (parser
)->location
,
3958 "ISO C requires a named argument before %<...%>");
3960 c_parser_consume_token (parser
);
3961 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3963 c_parser_consume_token (parser
);
3968 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3973 /* Nonempty list of parameters, either terminated with semicolon
3974 (forward declarations; recurse) or with close parenthesis (normal
3975 function) or with ", ... )" (variadic function). */
3978 /* Parse a parameter. */
3979 struct c_parm
*parm
= c_parser_parameter_declaration (parser
, attrs
);
3984 push_parm_decl (parm
, &expr
);
3985 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3988 c_parser_consume_token (parser
);
3989 mark_forward_parm_decls ();
3990 new_attrs
= c_parser_attributes (parser
);
3991 return c_parser_parms_list_declarator (parser
, new_attrs
, expr
);
3993 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3995 c_parser_consume_token (parser
);
3999 return get_parm_info (false, expr
);
4001 if (!c_parser_require (parser
, CPP_COMMA
,
4002 "expected %<;%>, %<,%> or %<)%>",
4003 UNKNOWN_LOCATION
, false))
4005 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4008 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
4010 c_parser_consume_token (parser
);
4011 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4013 c_parser_consume_token (parser
);
4017 return get_parm_info (true, expr
);
4021 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4029 /* Parse a parameter declaration. ATTRS are the attributes at the
4030 start of the declaration if it is the first parameter. */
4032 static struct c_parm
*
4033 c_parser_parameter_declaration (c_parser
*parser
, tree attrs
)
4035 struct c_declspecs
*specs
;
4036 struct c_declarator
*declarator
;
4038 tree postfix_attrs
= NULL_TREE
;
4041 /* Accept #pragmas between parameter declarations. */
4042 while (c_parser_next_token_is (parser
, CPP_PRAGMA
))
4043 c_parser_pragma (parser
, pragma_param
, NULL
);
4045 if (!c_parser_next_token_starts_declspecs (parser
))
4047 c_token
*token
= c_parser_peek_token (parser
);
4050 c_parser_set_source_position_from_token (token
);
4051 if (c_parser_next_tokens_start_typename (parser
, cla_prefer_type
))
4053 auto_diagnostic_group d
;
4054 name_hint hint
= lookup_name_fuzzy (token
->value
,
4055 FUZZY_LOOKUP_TYPENAME
,
4059 gcc_rich_location
richloc (token
->location
);
4060 richloc
.add_fixit_replace (hint
.suggestion ());
4062 "unknown type name %qE; did you mean %qs?",
4063 token
->value
, hint
.suggestion ());
4066 error_at (token
->location
, "unknown type name %qE", token
->value
);
4067 parser
->error
= true;
4069 /* ??? In some Objective-C cases '...' isn't applicable so there
4070 should be a different message. */
4072 c_parser_error (parser
,
4073 "expected declaration specifiers or %<...%>");
4074 c_parser_skip_to_end_of_parameter (parser
);
4078 location_t start_loc
= c_parser_peek_token (parser
)->location
;
4080 specs
= build_null_declspecs ();
4083 declspecs_add_attrs (input_location
, specs
, attrs
);
4086 c_parser_declspecs (parser
, specs
, true, true, true, true, false,
4087 cla_nonabstract_decl
);
4088 finish_declspecs (specs
);
4089 pending_xref_error ();
4090 prefix_attrs
= specs
->attrs
;
4091 specs
->attrs
= NULL_TREE
;
4092 declarator
= c_parser_declarator (parser
,
4093 specs
->typespec_kind
!= ctsk_none
,
4094 C_DTR_PARM
, &dummy
);
4095 if (declarator
== NULL
)
4097 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
4100 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
4101 postfix_attrs
= c_parser_attributes (parser
);
4103 /* Generate a location for the parameter, ranging from the start of the
4104 initial token to the end of the final token.
4106 If we have a identifier, then use it for the caret location, e.g.
4108 extern int callee (int one, int (*two)(int, int), float three);
4109 ~~~~~~^~~~~~~~~~~~~~
4111 otherwise, reuse the start location for the caret location e.g.:
4113 extern int callee (int one, int (*)(int, int), float three);
4116 location_t end_loc
= parser
->last_token_location
;
4118 /* Find any cdk_id declarator; determine if we have an identifier. */
4119 c_declarator
*id_declarator
= declarator
;
4120 while (id_declarator
&& id_declarator
->kind
!= cdk_id
)
4121 id_declarator
= id_declarator
->declarator
;
4122 location_t caret_loc
= (id_declarator
->u
.id
4123 ? id_declarator
->id_loc
4125 location_t param_loc
= make_location (caret_loc
, start_loc
, end_loc
);
4127 return build_c_parm (specs
, chainon (postfix_attrs
, prefix_attrs
),
4128 declarator
, param_loc
);
4131 /* Parse a string literal in an asm expression. It should not be
4132 translated, and wide string literals are an error although
4133 permitted by the syntax. This is a GNU extension.
4138 ??? At present, following the old parser, the caller needs to have
4139 set lex_untranslated_string to 1. It would be better to follow the
4140 C++ parser rather than using this kludge. */
4143 c_parser_asm_string_literal (c_parser
*parser
)
4146 int save_flag
= warn_overlength_strings
;
4147 warn_overlength_strings
= 0;
4148 if (c_parser_next_token_is (parser
, CPP_STRING
))
4150 str
= c_parser_peek_token (parser
)->value
;
4151 c_parser_consume_token (parser
);
4153 else if (c_parser_next_token_is (parser
, CPP_WSTRING
))
4155 error_at (c_parser_peek_token (parser
)->location
,
4156 "wide string literal in %<asm%>");
4157 str
= build_string (1, "");
4158 c_parser_consume_token (parser
);
4162 c_parser_error (parser
, "expected string literal");
4165 warn_overlength_strings
= save_flag
;
4169 /* Parse a simple asm expression. This is used in restricted
4170 contexts, where a full expression with inputs and outputs does not
4171 make sense. This is a GNU extension.
4174 asm ( asm-string-literal )
4178 c_parser_simple_asm_expr (c_parser
*parser
)
4181 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
4182 /* ??? Follow the C++ parser rather than using the
4183 lex_untranslated_string kludge. */
4184 parser
->lex_untranslated_string
= true;
4185 c_parser_consume_token (parser
);
4186 matching_parens parens
;
4187 if (!parens
.require_open (parser
))
4189 parser
->lex_untranslated_string
= false;
4192 str
= c_parser_asm_string_literal (parser
);
4193 parser
->lex_untranslated_string
= false;
4194 if (!parens
.require_close (parser
))
4196 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4203 c_parser_attribute_any_word (c_parser
*parser
)
4205 tree attr_name
= NULL_TREE
;
4207 if (c_parser_next_token_is (parser
, CPP_KEYWORD
))
4209 /* ??? See comment above about what keywords are accepted here. */
4211 switch (c_parser_peek_token (parser
)->keyword
)
4242 case RID_TRANSACTION_ATOMIC
:
4243 case RID_TRANSACTION_CANCEL
:
4259 /* Accept __attribute__((__const)) as __attribute__((const)) etc. */
4260 attr_name
= ridpointers
[(int) c_parser_peek_token (parser
)->keyword
];
4262 else if (c_parser_next_token_is (parser
, CPP_NAME
))
4263 attr_name
= c_parser_peek_token (parser
)->value
;
4268 /* Parse (possibly empty) attributes. This is a GNU extension.
4272 attributes attribute
4275 __attribute__ ( ( attribute-list ) )
4279 attribute_list , attrib
4284 any-word ( identifier )
4285 any-word ( identifier , nonempty-expr-list )
4286 any-word ( expr-list )
4288 where the "identifier" must not be declared as a type, and
4289 "any-word" may be any identifier (including one declared as a
4290 type), a reserved word storage class specifier, type specifier or
4291 type qualifier. ??? This still leaves out most reserved keywords
4292 (following the old parser), shouldn't we include them, and why not
4293 allow identifiers declared as types to start the arguments? */
4296 c_parser_attributes (c_parser
*parser
)
4298 tree attrs
= NULL_TREE
;
4299 while (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
4301 /* ??? Follow the C++ parser rather than using the
4302 lex_untranslated_string kludge. */
4303 parser
->lex_untranslated_string
= true;
4304 /* Consume the `__attribute__' keyword. */
4305 c_parser_consume_token (parser
);
4306 /* Look for the two `(' tokens. */
4307 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4309 parser
->lex_untranslated_string
= false;
4312 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4314 parser
->lex_untranslated_string
= false;
4315 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4318 /* Parse the attribute list. */
4319 while (c_parser_next_token_is (parser
, CPP_COMMA
)
4320 || c_parser_next_token_is (parser
, CPP_NAME
)
4321 || c_parser_next_token_is (parser
, CPP_KEYWORD
))
4323 tree attr
, attr_name
, attr_args
;
4324 vec
<tree
, va_gc
> *expr_list
;
4325 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4327 c_parser_consume_token (parser
);
4331 attr_name
= c_parser_attribute_any_word (parser
);
4332 if (attr_name
== NULL
)
4334 attr_name
= canonicalize_attr_name (attr_name
);
4335 c_parser_consume_token (parser
);
4336 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
4338 attr
= build_tree_list (attr_name
, NULL_TREE
);
4339 /* Add this attribute to the list. */
4340 attrs
= chainon (attrs
, attr
);
4341 /* If the next token isn't a comma, we're done. */
4342 if (!c_parser_next_token_is (parser
, CPP_COMMA
))
4346 c_parser_consume_token (parser
);
4347 /* Parse the attribute contents. If they start with an
4348 identifier which is followed by a comma or close
4349 parenthesis, then the arguments start with that
4350 identifier; otherwise they are an expression list.
4351 In objective-c the identifier may be a classname. */
4352 if (c_parser_next_token_is (parser
, CPP_NAME
)
4353 && (c_parser_peek_token (parser
)->id_kind
== C_ID_ID
4354 || (c_dialect_objc ()
4355 && c_parser_peek_token (parser
)->id_kind
4357 && ((c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
)
4358 || (c_parser_peek_2nd_token (parser
)->type
4359 == CPP_CLOSE_PAREN
))
4360 && (attribute_takes_identifier_p (attr_name
)
4361 || (c_dialect_objc ()
4362 && c_parser_peek_token (parser
)->id_kind
4363 == C_ID_CLASSNAME
)))
4365 tree arg1
= c_parser_peek_token (parser
)->value
;
4366 c_parser_consume_token (parser
);
4367 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4368 attr_args
= build_tree_list (NULL_TREE
, arg1
);
4372 c_parser_consume_token (parser
);
4373 expr_list
= c_parser_expr_list (parser
, false, true,
4374 NULL
, NULL
, NULL
, NULL
);
4375 tree_list
= build_tree_list_vec (expr_list
);
4376 attr_args
= tree_cons (NULL_TREE
, arg1
, tree_list
);
4377 release_tree_vector (expr_list
);
4382 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4383 attr_args
= NULL_TREE
;
4386 expr_list
= c_parser_expr_list (parser
, false, true,
4387 NULL
, NULL
, NULL
, NULL
);
4388 attr_args
= build_tree_list_vec (expr_list
);
4389 release_tree_vector (expr_list
);
4393 attr
= build_tree_list (attr_name
, attr_args
);
4394 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4395 c_parser_consume_token (parser
);
4398 parser
->lex_untranslated_string
= false;
4399 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4403 /* Add this attribute to the list. */
4404 attrs
= chainon (attrs
, attr
);
4405 /* If the next token isn't a comma, we're done. */
4406 if (!c_parser_next_token_is (parser
, CPP_COMMA
))
4409 /* Look for the two `)' tokens. */
4410 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4411 c_parser_consume_token (parser
);
4414 parser
->lex_untranslated_string
= false;
4415 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4419 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4420 c_parser_consume_token (parser
);
4423 parser
->lex_untranslated_string
= false;
4424 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4428 parser
->lex_untranslated_string
= false;
4434 /* Parse a type name (C90 6.5.5, C99 6.7.6, C11 6.7.7). ALIGNAS_OK
4435 says whether alignment specifiers are OK (only in cases that might
4436 be the type name of a compound literal).
4439 specifier-qualifier-list abstract-declarator[opt]
4442 struct c_type_name
*
4443 c_parser_type_name (c_parser
*parser
, bool alignas_ok
)
4445 struct c_declspecs
*specs
= build_null_declspecs ();
4446 struct c_declarator
*declarator
;
4447 struct c_type_name
*ret
;
4449 c_parser_declspecs (parser
, specs
, false, true, true, alignas_ok
, false,
4451 if (!specs
->declspecs_seen_p
)
4453 c_parser_error (parser
, "expected specifier-qualifier-list");
4456 if (specs
->type
!= error_mark_node
)
4458 pending_xref_error ();
4459 finish_declspecs (specs
);
4461 declarator
= c_parser_declarator (parser
,
4462 specs
->typespec_kind
!= ctsk_none
,
4463 C_DTR_ABSTRACT
, &dummy
);
4464 if (declarator
== NULL
)
4466 ret
= XOBNEW (&parser_obstack
, struct c_type_name
);
4468 ret
->declarator
= declarator
;
4472 /* Parse an initializer (C90 6.5.7, C99 6.7.8, C11 6.7.9).
4475 assignment-expression
4476 { initializer-list }
4477 { initializer-list , }
4480 designation[opt] initializer
4481 initializer-list , designation[opt] initializer
4488 designator-list designator
4495 [ constant-expression ]
4507 [ constant-expression ... constant-expression ]
4509 Any expression without commas is accepted in the syntax for the
4510 constant-expressions, with non-constant expressions rejected later.
4512 This function is only used for top-level initializers; for nested
4513 ones, see c_parser_initval. */
4515 static struct c_expr
4516 c_parser_initializer (c_parser
*parser
)
4518 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4519 return c_parser_braced_init (parser
, NULL_TREE
, false, NULL
);
4523 location_t loc
= c_parser_peek_token (parser
)->location
;
4524 ret
= c_parser_expr_no_commas (parser
, NULL
);
4525 if (TREE_CODE (ret
.value
) != STRING_CST
4526 && TREE_CODE (ret
.value
) != COMPOUND_LITERAL_EXPR
)
4527 ret
= convert_lvalue_to_rvalue (loc
, ret
, true, true);
4532 /* The location of the last comma within the current initializer list,
4533 or UNKNOWN_LOCATION if not within one. */
4535 location_t last_init_list_comma
;
4537 /* Parse a braced initializer list. TYPE is the type specified for a
4538 compound literal, and NULL_TREE for other initializers and for
4539 nested braced lists. NESTED_P is true for nested braced lists,
4540 false for the list of a compound literal or the list that is the
4541 top-level initializer in a declaration. */
4543 static struct c_expr
4544 c_parser_braced_init (c_parser
*parser
, tree type
, bool nested_p
,
4545 struct obstack
*outer_obstack
)
4548 struct obstack braced_init_obstack
;
4549 location_t brace_loc
= c_parser_peek_token (parser
)->location
;
4550 gcc_obstack_init (&braced_init_obstack
);
4551 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
4552 matching_braces braces
;
4553 braces
.consume_open (parser
);
4556 finish_implicit_inits (brace_loc
, outer_obstack
);
4557 push_init_level (brace_loc
, 0, &braced_init_obstack
);
4560 really_start_incremental_init (type
);
4561 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
4563 pedwarn (brace_loc
, OPT_Wpedantic
, "ISO C forbids empty initializer braces");
4567 /* Parse a non-empty initializer list, possibly with a trailing
4571 c_parser_initelt (parser
, &braced_init_obstack
);
4574 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4576 last_init_list_comma
= c_parser_peek_token (parser
)->location
;
4577 c_parser_consume_token (parser
);
4581 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
4585 c_token
*next_tok
= c_parser_peek_token (parser
);
4586 if (next_tok
->type
!= CPP_CLOSE_BRACE
)
4589 ret
.original_code
= ERROR_MARK
;
4590 ret
.original_type
= NULL
;
4591 braces
.skip_until_found_close (parser
);
4592 pop_init_level (brace_loc
, 0, &braced_init_obstack
, last_init_list_comma
);
4593 obstack_free (&braced_init_obstack
, NULL
);
4596 location_t close_loc
= next_tok
->location
;
4597 c_parser_consume_token (parser
);
4598 ret
= pop_init_level (brace_loc
, 0, &braced_init_obstack
, close_loc
);
4599 obstack_free (&braced_init_obstack
, NULL
);
4600 set_c_expr_source_range (&ret
, brace_loc
, close_loc
);
4604 /* Parse a nested initializer, including designators. */
4607 c_parser_initelt (c_parser
*parser
, struct obstack
* braced_init_obstack
)
4609 /* Parse any designator or designator list. A single array
4610 designator may have the subsequent "=" omitted in GNU C, but a
4611 longer list or a structure member designator may not. */
4612 if (c_parser_next_token_is (parser
, CPP_NAME
)
4613 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
4615 /* Old-style structure member designator. */
4616 set_init_label (c_parser_peek_token (parser
)->location
,
4617 c_parser_peek_token (parser
)->value
,
4618 c_parser_peek_token (parser
)->location
,
4619 braced_init_obstack
);
4620 /* Use the colon as the error location. */
4621 pedwarn (c_parser_peek_2nd_token (parser
)->location
, OPT_Wpedantic
,
4622 "obsolete use of designated initializer with %<:%>");
4623 c_parser_consume_token (parser
);
4624 c_parser_consume_token (parser
);
4628 /* des_seen is 0 if there have been no designators, 1 if there
4629 has been a single array designator and 2 otherwise. */
4631 /* Location of a designator. */
4632 location_t des_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
4633 while (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
)
4634 || c_parser_next_token_is (parser
, CPP_DOT
))
4636 int des_prev
= des_seen
;
4638 des_loc
= c_parser_peek_token (parser
)->location
;
4641 if (c_parser_next_token_is (parser
, CPP_DOT
))
4644 c_parser_consume_token (parser
);
4645 if (c_parser_next_token_is (parser
, CPP_NAME
))
4647 set_init_label (des_loc
, c_parser_peek_token (parser
)->value
,
4648 c_parser_peek_token (parser
)->location
,
4649 braced_init_obstack
);
4650 c_parser_consume_token (parser
);
4656 init
.original_code
= ERROR_MARK
;
4657 init
.original_type
= NULL
;
4658 c_parser_error (parser
, "expected identifier");
4659 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
4660 process_init_element (input_location
, init
, false,
4661 braced_init_obstack
);
4668 location_t ellipsis_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
4669 location_t array_index_loc
= UNKNOWN_LOCATION
;
4670 /* ??? Following the old parser, [ objc-receiver
4671 objc-message-args ] is accepted as an initializer,
4672 being distinguished from a designator by what follows
4673 the first assignment expression inside the square
4674 brackets, but after a first array designator a
4675 subsequent square bracket is for Objective-C taken to
4676 start an expression, using the obsolete form of
4677 designated initializer without '=', rather than
4678 possibly being a second level of designation: in LALR
4679 terms, the '[' is shifted rather than reducing
4680 designator to designator-list. */
4681 if (des_prev
== 1 && c_dialect_objc ())
4683 des_seen
= des_prev
;
4686 if (des_prev
== 0 && c_dialect_objc ())
4688 /* This might be an array designator or an
4689 Objective-C message expression. If the former,
4690 continue parsing here; if the latter, parse the
4691 remainder of the initializer given the starting
4692 primary-expression. ??? It might make sense to
4693 distinguish when des_prev == 1 as well; see
4694 previous comment. */
4696 struct c_expr mexpr
;
4697 c_parser_consume_token (parser
);
4698 if (c_parser_peek_token (parser
)->type
== CPP_NAME
4699 && ((c_parser_peek_token (parser
)->id_kind
4701 || (c_parser_peek_token (parser
)->id_kind
4702 == C_ID_CLASSNAME
)))
4704 /* Type name receiver. */
4705 tree id
= c_parser_peek_token (parser
)->value
;
4706 c_parser_consume_token (parser
);
4707 rec
= objc_get_class_reference (id
);
4708 goto parse_message_args
;
4710 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
4711 mark_exp_read (first
);
4712 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
)
4713 || c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
4714 goto array_desig_after_first
;
4715 /* Expression receiver. So far only one part
4716 without commas has been parsed; there might be
4717 more of the expression. */
4719 while (c_parser_next_token_is (parser
, CPP_COMMA
))
4722 location_t comma_loc
, exp_loc
;
4723 comma_loc
= c_parser_peek_token (parser
)->location
;
4724 c_parser_consume_token (parser
);
4725 exp_loc
= c_parser_peek_token (parser
)->location
;
4726 next
= c_parser_expr_no_commas (parser
, NULL
);
4727 next
= convert_lvalue_to_rvalue (exp_loc
, next
,
4729 rec
= build_compound_expr (comma_loc
, rec
, next
.value
);
4732 /* Now parse the objc-message-args. */
4733 args
= c_parser_objc_message_args (parser
);
4734 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4737 = objc_build_message_expr (rec
, args
);
4738 mexpr
.original_code
= ERROR_MARK
;
4739 mexpr
.original_type
= NULL
;
4740 /* Now parse and process the remainder of the
4741 initializer, starting with this message
4742 expression as a primary-expression. */
4743 c_parser_initval (parser
, &mexpr
, braced_init_obstack
);
4746 c_parser_consume_token (parser
);
4747 array_index_loc
= c_parser_peek_token (parser
)->location
;
4748 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
4749 mark_exp_read (first
);
4750 array_desig_after_first
:
4751 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
4753 ellipsis_loc
= c_parser_peek_token (parser
)->location
;
4754 c_parser_consume_token (parser
);
4755 second
= c_parser_expr_no_commas (parser
, NULL
).value
;
4756 mark_exp_read (second
);
4760 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
4762 c_parser_consume_token (parser
);
4763 set_init_index (array_index_loc
, first
, second
,
4764 braced_init_obstack
);
4766 pedwarn (ellipsis_loc
, OPT_Wpedantic
,
4767 "ISO C forbids specifying range of elements to initialize");
4770 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4776 if (c_parser_next_token_is (parser
, CPP_EQ
))
4778 pedwarn_c90 (des_loc
, OPT_Wpedantic
,
4779 "ISO C90 forbids specifying subobject "
4781 c_parser_consume_token (parser
);
4786 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
4787 "obsolete use of designated initializer without %<=%>");
4792 init
.original_code
= ERROR_MARK
;
4793 init
.original_type
= NULL
;
4794 c_parser_error (parser
, "expected %<=%>");
4795 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
4796 process_init_element (input_location
, init
, false,
4797 braced_init_obstack
);
4803 c_parser_initval (parser
, NULL
, braced_init_obstack
);
4806 /* Parse a nested initializer; as c_parser_initializer but parses
4807 initializers within braced lists, after any designators have been
4808 applied. If AFTER is not NULL then it is an Objective-C message
4809 expression which is the primary-expression starting the
4813 c_parser_initval (c_parser
*parser
, struct c_expr
*after
,
4814 struct obstack
* braced_init_obstack
)
4817 gcc_assert (!after
|| c_dialect_objc ());
4818 location_t loc
= c_parser_peek_token (parser
)->location
;
4820 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
) && !after
)
4821 init
= c_parser_braced_init (parser
, NULL_TREE
, true,
4822 braced_init_obstack
);
4825 init
= c_parser_expr_no_commas (parser
, after
);
4826 if (init
.value
!= NULL_TREE
4827 && TREE_CODE (init
.value
) != STRING_CST
4828 && TREE_CODE (init
.value
) != COMPOUND_LITERAL_EXPR
)
4829 init
= convert_lvalue_to_rvalue (loc
, init
, true, true);
4831 process_init_element (loc
, init
, false, braced_init_obstack
);
4834 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
4835 C99 6.8.2, C11 6.8.2).
4838 { block-item-list[opt] }
4839 { label-declarations block-item-list }
4843 block-item-list block-item
4855 { label-declarations block-item-list }
4858 __extension__ nested-declaration
4859 nested-function-definition
4863 label-declarations label-declaration
4866 __label__ identifier-list ;
4868 Allowing the mixing of declarations and code is new in C99. The
4869 GNU syntax also permits (not shown above) labels at the end of
4870 compound statements, which yield an error. We don't allow labels
4871 on declarations; this might seem like a natural extension, but
4872 there would be a conflict between attributes on the label and
4873 prefix attributes on the declaration. ??? The syntax follows the
4874 old parser in requiring something after label declarations.
4875 Although they are erroneous if the labels declared aren't defined,
4876 is it useful for the syntax to be this way?
4897 cancellation-point-directive */
4900 c_parser_compound_statement (c_parser
*parser
)
4903 location_t brace_loc
;
4904 brace_loc
= c_parser_peek_token (parser
)->location
;
4905 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
4907 /* Ensure a scope is entered and left anyway to avoid confusion
4908 if we have just prepared to enter a function body. */
4909 stmt
= c_begin_compound_stmt (true);
4910 c_end_compound_stmt (brace_loc
, stmt
, true);
4911 return error_mark_node
;
4913 stmt
= c_begin_compound_stmt (true);
4914 c_parser_compound_statement_nostart (parser
);
4916 return c_end_compound_stmt (brace_loc
, stmt
, true);
4919 /* Parse a compound statement except for the opening brace. This is
4920 used for parsing both compound statements and statement expressions
4921 (which follow different paths to handling the opening). */
4924 c_parser_compound_statement_nostart (c_parser
*parser
)
4926 bool last_stmt
= false;
4927 bool last_label
= false;
4928 bool save_valid_for_pragma
= valid_location_for_stdc_pragma_p ();
4929 location_t label_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
4930 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
4932 add_debug_begin_stmt (c_parser_peek_token (parser
)->location
);
4933 c_parser_consume_token (parser
);
4936 mark_valid_location_for_stdc_pragma (true);
4937 if (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
4939 /* Read zero or more forward-declarations for labels that nested
4940 functions can jump to. */
4941 mark_valid_location_for_stdc_pragma (false);
4942 while (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
4944 label_loc
= c_parser_peek_token (parser
)->location
;
4945 c_parser_consume_token (parser
);
4946 /* Any identifiers, including those declared as type names,
4951 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
4953 c_parser_error (parser
, "expected identifier");
4957 = declare_label (c_parser_peek_token (parser
)->value
);
4958 C_DECLARED_LABEL_FLAG (label
) = 1;
4959 add_stmt (build_stmt (label_loc
, DECL_EXPR
, label
));
4960 c_parser_consume_token (parser
);
4961 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4962 c_parser_consume_token (parser
);
4966 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4968 pedwarn (label_loc
, OPT_Wpedantic
, "ISO C forbids label declarations");
4970 /* We must now have at least one statement, label or declaration. */
4971 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
4973 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
4974 c_parser_error (parser
, "expected declaration or statement");
4975 c_parser_consume_token (parser
);
4978 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
4980 location_t loc
= c_parser_peek_token (parser
)->location
;
4981 loc
= expansion_point_location_if_in_system_header (loc
);
4982 if (c_parser_next_token_is_keyword (parser
, RID_CASE
)
4983 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
4984 || (c_parser_next_token_is (parser
, CPP_NAME
)
4985 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
4987 if (c_parser_next_token_is_keyword (parser
, RID_CASE
))
4988 label_loc
= c_parser_peek_2nd_token (parser
)->location
;
4990 label_loc
= c_parser_peek_token (parser
)->location
;
4993 mark_valid_location_for_stdc_pragma (false);
4994 c_parser_label (parser
);
4996 else if (!last_label
4997 && c_parser_next_tokens_start_declaration (parser
))
5000 mark_valid_location_for_stdc_pragma (false);
5001 bool fallthru_attr_p
= false;
5002 c_parser_declaration_or_fndef (parser
, true, true, true, true,
5003 true, NULL
, vNULL
, NULL
,
5005 if (last_stmt
&& !fallthru_attr_p
)
5006 pedwarn_c90 (loc
, OPT_Wdeclaration_after_statement
,
5007 "ISO C90 forbids mixed declarations and code");
5008 last_stmt
= fallthru_attr_p
;
5010 else if (!last_label
5011 && c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
5013 /* __extension__ can start a declaration, but is also an
5014 unary operator that can start an expression. Consume all
5015 but the last of a possible series of __extension__ to
5017 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
5018 && (c_parser_peek_2nd_token (parser
)->keyword
5020 c_parser_consume_token (parser
);
5021 if (c_token_starts_declaration (c_parser_peek_2nd_token (parser
)))
5024 ext
= disable_extension_diagnostics ();
5025 c_parser_consume_token (parser
);
5027 mark_valid_location_for_stdc_pragma (false);
5028 c_parser_declaration_or_fndef (parser
, true, true, true, true,
5030 /* Following the old parser, __extension__ does not
5031 disable this diagnostic. */
5032 restore_extension_diagnostics (ext
);
5034 pedwarn_c90 (loc
, OPT_Wdeclaration_after_statement
,
5035 "ISO C90 forbids mixed declarations and code");
5041 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
5043 /* External pragmas, and some omp pragmas, are not associated
5044 with regular c code, and so are not to be considered statements
5045 syntactically. This ensures that the user doesn't put them
5046 places that would turn into syntax errors if the directive
5048 if (c_parser_pragma (parser
,
5049 last_label
? pragma_stmt
: pragma_compound
,
5051 last_label
= false, last_stmt
= true;
5053 else if (c_parser_next_token_is (parser
, CPP_EOF
))
5055 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
5056 c_parser_error (parser
, "expected declaration or statement");
5059 else if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
5061 if (parser
->in_if_block
)
5063 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
5064 error_at (loc
, "expected %<}%> before %<else%>");
5069 error_at (loc
, "%<else%> without a previous %<if%>");
5070 c_parser_consume_token (parser
);
5079 mark_valid_location_for_stdc_pragma (false);
5080 c_parser_statement_after_labels (parser
, NULL
);
5083 parser
->error
= false;
5086 error_at (label_loc
, "label at end of compound statement");
5087 c_parser_consume_token (parser
);
5088 /* Restore the value we started with. */
5089 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
5092 /* Parse all consecutive labels. */
5095 c_parser_all_labels (c_parser
*parser
)
5097 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
5098 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
5099 || (c_parser_next_token_is (parser
, CPP_NAME
)
5100 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
5101 c_parser_label (parser
);
5104 /* Parse a label (C90 6.6.1, C99 6.8.1, C11 6.8.1).
5107 identifier : attributes[opt]
5108 case constant-expression :
5114 case constant-expression ... constant-expression :
5116 The use of attributes on labels is a GNU extension. The syntax in
5117 GNU C accepts any expressions without commas, non-constant
5118 expressions being rejected later. */
5121 c_parser_label (c_parser
*parser
)
5123 location_t loc1
= c_parser_peek_token (parser
)->location
;
5124 tree label
= NULL_TREE
;
5126 /* Remember whether this case or a user-defined label is allowed to fall
5128 bool fallthrough_p
= c_parser_peek_token (parser
)->flags
& PREV_FALLTHROUGH
;
5130 if (c_parser_next_token_is_keyword (parser
, RID_CASE
))
5133 c_parser_consume_token (parser
);
5134 exp1
= c_parser_expr_no_commas (parser
, NULL
).value
;
5135 if (c_parser_next_token_is (parser
, CPP_COLON
))
5137 c_parser_consume_token (parser
);
5138 label
= do_case (loc1
, exp1
, NULL_TREE
);
5140 else if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
5142 c_parser_consume_token (parser
);
5143 exp2
= c_parser_expr_no_commas (parser
, NULL
).value
;
5144 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
5145 label
= do_case (loc1
, exp1
, exp2
);
5148 c_parser_error (parser
, "expected %<:%> or %<...%>");
5150 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
5152 c_parser_consume_token (parser
);
5153 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
5154 label
= do_case (loc1
, NULL_TREE
, NULL_TREE
);
5158 tree name
= c_parser_peek_token (parser
)->value
;
5161 location_t loc2
= c_parser_peek_token (parser
)->location
;
5162 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
5163 c_parser_consume_token (parser
);
5164 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
5165 c_parser_consume_token (parser
);
5166 attrs
= c_parser_attributes (parser
);
5167 tlab
= define_label (loc2
, name
);
5170 decl_attributes (&tlab
, attrs
, 0);
5171 label
= add_stmt (build_stmt (loc1
, LABEL_EXPR
, tlab
));
5176 if (TREE_CODE (label
) == LABEL_EXPR
)
5177 FALLTHROUGH_LABEL_P (LABEL_EXPR_LABEL (label
)) = fallthrough_p
;
5179 FALLTHROUGH_LABEL_P (CASE_LABEL (label
)) = fallthrough_p
;
5181 /* Allow '__attribute__((fallthrough));'. */
5182 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
5184 location_t loc
= c_parser_peek_token (parser
)->location
;
5185 tree attrs
= c_parser_attributes (parser
);
5186 if (attribute_fallthrough_p (attrs
))
5188 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5190 tree fn
= build_call_expr_internal_loc (loc
,
5196 warning_at (loc
, OPT_Wattributes
, "%<fallthrough%> attribute "
5197 "not followed by %<;%>");
5199 else if (attrs
!= NULL_TREE
)
5200 warning_at (loc
, OPT_Wattributes
, "only attribute %<fallthrough%>"
5201 " can be applied to a null statement");
5203 if (c_parser_next_tokens_start_declaration (parser
))
5205 error_at (c_parser_peek_token (parser
)->location
,
5206 "a label can only be part of a statement and "
5207 "a declaration is not a statement");
5208 c_parser_declaration_or_fndef (parser
, /*fndef_ok*/ false,
5209 /*static_assert_ok*/ true,
5210 /*empty_ok*/ true, /*nested*/ true,
5211 /*start_attr_ok*/ true, NULL
,
5217 /* Parse a statement (C90 6.6, C99 6.8, C11 6.8).
5222 expression-statement
5230 expression-statement:
5233 selection-statement:
5237 iteration-statement:
5246 return expression[opt] ;
5256 expression-statement:
5262 objc-throw-statement
5263 objc-try-catch-statement
5264 objc-synchronized-statement
5266 objc-throw-statement:
5282 parallel-directive structured-block
5285 kernels-directive structured-block
5288 data-directive structured-block
5291 loop-directive structured-block
5305 parallel-for-construct
5306 parallel-for-simd-construct
5307 parallel-sections-construct
5314 parallel-directive structured-block
5317 for-directive iteration-statement
5320 simd-directive iteration-statements
5323 for-simd-directive iteration-statements
5326 sections-directive section-scope
5329 single-directive structured-block
5331 parallel-for-construct:
5332 parallel-for-directive iteration-statement
5334 parallel-for-simd-construct:
5335 parallel-for-simd-directive iteration-statement
5337 parallel-sections-construct:
5338 parallel-sections-directive section-scope
5341 master-directive structured-block
5344 critical-directive structured-block
5347 atomic-directive expression-statement
5350 ordered-directive structured-block
5352 Transactional Memory:
5355 transaction-statement
5356 transaction-cancel-statement
5358 IF_P is used to track whether there's a (possibly labeled) if statement
5359 which is not enclosed in braces and has an else clause. This is used to
5360 implement -Wparentheses. */
5363 c_parser_statement (c_parser
*parser
, bool *if_p
, location_t
*loc_after_labels
)
5365 c_parser_all_labels (parser
);
5366 if (loc_after_labels
)
5367 *loc_after_labels
= c_parser_peek_token (parser
)->location
;
5368 c_parser_statement_after_labels (parser
, if_p
, NULL
);
5371 /* Parse a statement, other than a labeled statement. CHAIN is a vector
5372 of if-else-if conditions.
5374 IF_P is used to track whether there's a (possibly labeled) if statement
5375 which is not enclosed in braces and has an else clause. This is used to
5376 implement -Wparentheses. */
5379 c_parser_statement_after_labels (c_parser
*parser
, bool *if_p
,
5382 location_t loc
= c_parser_peek_token (parser
)->location
;
5383 tree stmt
= NULL_TREE
;
5384 bool in_if_block
= parser
->in_if_block
;
5385 parser
->in_if_block
= false;
5389 if (c_parser_peek_token (parser
)->type
!= CPP_OPEN_BRACE
)
5390 add_debug_begin_stmt (loc
);
5392 switch (c_parser_peek_token (parser
)->type
)
5394 case CPP_OPEN_BRACE
:
5395 add_stmt (c_parser_compound_statement (parser
));
5398 switch (c_parser_peek_token (parser
)->keyword
)
5401 c_parser_if_statement (parser
, if_p
, chain
);
5404 c_parser_switch_statement (parser
, if_p
);
5407 c_parser_while_statement (parser
, false, 0, if_p
);
5410 c_parser_do_statement (parser
, 0, false);
5413 c_parser_for_statement (parser
, false, 0, if_p
);
5416 c_parser_consume_token (parser
);
5417 if (c_parser_next_token_is (parser
, CPP_NAME
))
5419 stmt
= c_finish_goto_label (loc
,
5420 c_parser_peek_token (parser
)->value
);
5421 c_parser_consume_token (parser
);
5423 else if (c_parser_next_token_is (parser
, CPP_MULT
))
5427 c_parser_consume_token (parser
);
5428 val
= c_parser_expression (parser
);
5429 val
= convert_lvalue_to_rvalue (loc
, val
, false, true);
5430 stmt
= c_finish_goto_ptr (loc
, val
.value
);
5433 c_parser_error (parser
, "expected identifier or %<*%>");
5434 goto expect_semicolon
;
5436 c_parser_consume_token (parser
);
5437 stmt
= c_finish_bc_stmt (loc
, &c_cont_label
, false);
5438 goto expect_semicolon
;
5440 c_parser_consume_token (parser
);
5441 stmt
= c_finish_bc_stmt (loc
, &c_break_label
, true);
5442 goto expect_semicolon
;
5444 c_parser_consume_token (parser
);
5445 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5447 stmt
= c_finish_return (loc
, NULL_TREE
, NULL_TREE
);
5448 c_parser_consume_token (parser
);
5452 location_t xloc
= c_parser_peek_token (parser
)->location
;
5453 struct c_expr expr
= c_parser_expression_conv (parser
);
5454 mark_exp_read (expr
.value
);
5455 stmt
= c_finish_return (EXPR_LOC_OR_LOC (expr
.value
, xloc
),
5456 expr
.value
, expr
.original_type
);
5457 goto expect_semicolon
;
5461 stmt
= c_parser_asm_statement (parser
);
5463 case RID_TRANSACTION_ATOMIC
:
5464 case RID_TRANSACTION_RELAXED
:
5465 stmt
= c_parser_transaction (parser
,
5466 c_parser_peek_token (parser
)->keyword
);
5468 case RID_TRANSACTION_CANCEL
:
5469 stmt
= c_parser_transaction_cancel (parser
);
5470 goto expect_semicolon
;
5472 gcc_assert (c_dialect_objc ());
5473 c_parser_consume_token (parser
);
5474 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5476 stmt
= objc_build_throw_stmt (loc
, NULL_TREE
);
5477 c_parser_consume_token (parser
);
5481 struct c_expr expr
= c_parser_expression (parser
);
5482 expr
= convert_lvalue_to_rvalue (loc
, expr
, false, false);
5483 expr
.value
= c_fully_fold (expr
.value
, false, NULL
);
5484 stmt
= objc_build_throw_stmt (loc
, expr
.value
);
5485 goto expect_semicolon
;
5489 gcc_assert (c_dialect_objc ());
5490 c_parser_objc_try_catch_finally_statement (parser
);
5492 case RID_AT_SYNCHRONIZED
:
5493 gcc_assert (c_dialect_objc ());
5494 c_parser_objc_synchronized_statement (parser
);
5498 /* Allow '__attribute__((fallthrough));'. */
5499 tree attrs
= c_parser_attributes (parser
);
5500 if (attribute_fallthrough_p (attrs
))
5502 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5504 tree fn
= build_call_expr_internal_loc (loc
,
5509 c_parser_consume_token (parser
);
5512 warning_at (loc
, OPT_Wattributes
,
5513 "%<fallthrough%> attribute not followed "
5516 else if (attrs
!= NULL_TREE
)
5517 warning_at (loc
, OPT_Wattributes
, "only attribute %<fallthrough%>"
5518 " can be applied to a null statement");
5526 c_parser_consume_token (parser
);
5528 case CPP_CLOSE_PAREN
:
5529 case CPP_CLOSE_SQUARE
:
5530 /* Avoid infinite loop in error recovery:
5531 c_parser_skip_until_found stops at a closing nesting
5532 delimiter without consuming it, but here we need to consume
5533 it to proceed further. */
5534 c_parser_error (parser
, "expected statement");
5535 c_parser_consume_token (parser
);
5538 c_parser_pragma (parser
, pragma_stmt
, if_p
);
5542 stmt
= c_finish_expr_stmt (loc
, c_parser_expression_conv (parser
).value
);
5544 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5547 /* Two cases cannot and do not have line numbers associated: If stmt
5548 is degenerate, such as "2;", then stmt is an INTEGER_CST, which
5549 cannot hold line numbers. But that's OK because the statement
5550 will either be changed to a MODIFY_EXPR during gimplification of
5551 the statement expr, or discarded. If stmt was compound, but
5552 without new variables, we will have skipped the creation of a
5553 BIND and will have a bare STATEMENT_LIST. But that's OK because
5554 (recursively) all of the component statements should already have
5555 line numbers assigned. ??? Can we discard no-op statements
5557 if (EXPR_LOCATION (stmt
) == UNKNOWN_LOCATION
)
5558 protected_set_expr_location (stmt
, loc
);
5560 parser
->in_if_block
= in_if_block
;
5563 /* Parse the condition from an if, do, while or for statements. */
5566 c_parser_condition (c_parser
*parser
)
5568 location_t loc
= c_parser_peek_token (parser
)->location
;
5570 cond
= c_parser_expression_conv (parser
).value
;
5571 cond
= c_objc_common_truthvalue_conversion (loc
, cond
);
5572 cond
= c_fully_fold (cond
, false, NULL
);
5573 if (warn_sequence_point
)
5574 verify_sequence_points (cond
);
5578 /* Parse a parenthesized condition from an if, do or while statement.
5584 c_parser_paren_condition (c_parser
*parser
)
5587 matching_parens parens
;
5588 if (!parens
.require_open (parser
))
5589 return error_mark_node
;
5590 cond
= c_parser_condition (parser
);
5591 parens
.skip_until_found_close (parser
);
5595 /* Parse a statement which is a block in C99.
5597 IF_P is used to track whether there's a (possibly labeled) if statement
5598 which is not enclosed in braces and has an else clause. This is used to
5599 implement -Wparentheses. */
5602 c_parser_c99_block_statement (c_parser
*parser
, bool *if_p
,
5603 location_t
*loc_after_labels
)
5605 tree block
= c_begin_compound_stmt (flag_isoc99
);
5606 location_t loc
= c_parser_peek_token (parser
)->location
;
5607 c_parser_statement (parser
, if_p
, loc_after_labels
);
5608 return c_end_compound_stmt (loc
, block
, flag_isoc99
);
5611 /* Parse the body of an if statement. This is just parsing a
5612 statement but (a) it is a block in C99, (b) we track whether the
5613 body is an if statement for the sake of -Wparentheses warnings, (c)
5614 we handle an empty body specially for the sake of -Wempty-body
5615 warnings, and (d) we call parser_compound_statement directly
5616 because c_parser_statement_after_labels resets
5617 parser->in_if_block.
5619 IF_P is used to track whether there's a (possibly labeled) if statement
5620 which is not enclosed in braces and has an else clause. This is used to
5621 implement -Wparentheses. */
5624 c_parser_if_body (c_parser
*parser
, bool *if_p
,
5625 const token_indent_info
&if_tinfo
)
5627 tree block
= c_begin_compound_stmt (flag_isoc99
);
5628 location_t body_loc
= c_parser_peek_token (parser
)->location
;
5629 location_t body_loc_after_labels
= UNKNOWN_LOCATION
;
5630 token_indent_info body_tinfo
5631 = get_token_indent_info (c_parser_peek_token (parser
));
5633 c_parser_all_labels (parser
);
5634 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5636 location_t loc
= c_parser_peek_token (parser
)->location
;
5637 add_stmt (build_empty_stmt (loc
));
5638 c_parser_consume_token (parser
);
5639 if (!c_parser_next_token_is_keyword (parser
, RID_ELSE
))
5640 warning_at (loc
, OPT_Wempty_body
,
5641 "suggest braces around empty body in an %<if%> statement");
5643 else if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5644 add_stmt (c_parser_compound_statement (parser
));
5647 body_loc_after_labels
= c_parser_peek_token (parser
)->location
;
5648 c_parser_statement_after_labels (parser
, if_p
);
5651 token_indent_info next_tinfo
5652 = get_token_indent_info (c_parser_peek_token (parser
));
5653 warn_for_misleading_indentation (if_tinfo
, body_tinfo
, next_tinfo
);
5654 if (body_loc_after_labels
!= UNKNOWN_LOCATION
5655 && next_tinfo
.type
!= CPP_SEMICOLON
)
5656 warn_for_multistatement_macros (body_loc_after_labels
, next_tinfo
.location
,
5657 if_tinfo
.location
, RID_IF
);
5659 return c_end_compound_stmt (body_loc
, block
, flag_isoc99
);
5662 /* Parse the else body of an if statement. This is just parsing a
5663 statement but (a) it is a block in C99, (b) we handle an empty body
5664 specially for the sake of -Wempty-body warnings. CHAIN is a vector
5665 of if-else-if conditions. */
5668 c_parser_else_body (c_parser
*parser
, const token_indent_info
&else_tinfo
,
5671 location_t body_loc
= c_parser_peek_token (parser
)->location
;
5672 tree block
= c_begin_compound_stmt (flag_isoc99
);
5673 token_indent_info body_tinfo
5674 = get_token_indent_info (c_parser_peek_token (parser
));
5675 location_t body_loc_after_labels
= UNKNOWN_LOCATION
;
5677 c_parser_all_labels (parser
);
5678 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5680 location_t loc
= c_parser_peek_token (parser
)->location
;
5683 "suggest braces around empty body in an %<else%> statement");
5684 add_stmt (build_empty_stmt (loc
));
5685 c_parser_consume_token (parser
);
5689 if (!c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5690 body_loc_after_labels
= c_parser_peek_token (parser
)->location
;
5691 c_parser_statement_after_labels (parser
, NULL
, chain
);
5694 token_indent_info next_tinfo
5695 = get_token_indent_info (c_parser_peek_token (parser
));
5696 warn_for_misleading_indentation (else_tinfo
, body_tinfo
, next_tinfo
);
5697 if (body_loc_after_labels
!= UNKNOWN_LOCATION
5698 && next_tinfo
.type
!= CPP_SEMICOLON
)
5699 warn_for_multistatement_macros (body_loc_after_labels
, next_tinfo
.location
,
5700 else_tinfo
.location
, RID_ELSE
);
5702 return c_end_compound_stmt (body_loc
, block
, flag_isoc99
);
5705 /* We might need to reclassify any previously-lexed identifier, e.g.
5706 when we've left a for loop with an if-statement without else in the
5707 body - we might have used a wrong scope for the token. See PR67784. */
5710 c_parser_maybe_reclassify_token (c_parser
*parser
)
5712 if (c_parser_next_token_is (parser
, CPP_NAME
))
5714 c_token
*token
= c_parser_peek_token (parser
);
5716 if (token
->id_kind
!= C_ID_CLASSNAME
)
5718 tree decl
= lookup_name (token
->value
);
5720 token
->id_kind
= C_ID_ID
;
5723 if (TREE_CODE (decl
) == TYPE_DECL
)
5724 token
->id_kind
= C_ID_TYPENAME
;
5726 else if (c_dialect_objc ())
5728 tree objc_interface_decl
= objc_is_class_name (token
->value
);
5729 /* Objective-C class names are in the same namespace as
5730 variables and typedefs, and hence are shadowed by local
5732 if (objc_interface_decl
)
5734 token
->value
= objc_interface_decl
;
5735 token
->id_kind
= C_ID_CLASSNAME
;
5742 /* Parse an if statement (C90 6.6.4, C99 6.8.4, C11 6.8.4).
5745 if ( expression ) statement
5746 if ( expression ) statement else statement
5748 CHAIN is a vector of if-else-if conditions.
5749 IF_P is used to track whether there's a (possibly labeled) if statement
5750 which is not enclosed in braces and has an else clause. This is used to
5751 implement -Wparentheses. */
5754 c_parser_if_statement (c_parser
*parser
, bool *if_p
, vec
<tree
> *chain
)
5759 bool nested_if
= false;
5760 tree first_body
, second_body
;
5763 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_IF
));
5764 token_indent_info if_tinfo
5765 = get_token_indent_info (c_parser_peek_token (parser
));
5766 c_parser_consume_token (parser
);
5767 block
= c_begin_compound_stmt (flag_isoc99
);
5768 loc
= c_parser_peek_token (parser
)->location
;
5769 cond
= c_parser_paren_condition (parser
);
5770 in_if_block
= parser
->in_if_block
;
5771 parser
->in_if_block
= true;
5772 first_body
= c_parser_if_body (parser
, &nested_if
, if_tinfo
);
5773 parser
->in_if_block
= in_if_block
;
5775 if (warn_duplicated_cond
)
5776 warn_duplicated_cond_add_or_warn (EXPR_LOCATION (cond
), cond
, &chain
);
5778 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
5780 token_indent_info else_tinfo
5781 = get_token_indent_info (c_parser_peek_token (parser
));
5782 c_parser_consume_token (parser
);
5783 if (warn_duplicated_cond
)
5785 if (c_parser_next_token_is_keyword (parser
, RID_IF
)
5788 /* We've got "if (COND) else if (COND2)". Start the
5789 condition chain and add COND as the first element. */
5790 chain
= new vec
<tree
> ();
5791 if (!CONSTANT_CLASS_P (cond
) && !TREE_SIDE_EFFECTS (cond
))
5792 chain
->safe_push (cond
);
5794 else if (!c_parser_next_token_is_keyword (parser
, RID_IF
))
5796 /* This is if-else without subsequent if. Zap the condition
5797 chain; we would have already warned at this point. */
5802 second_body
= c_parser_else_body (parser
, else_tinfo
, chain
);
5803 /* Set IF_P to true to indicate that this if statement has an
5804 else clause. This may trigger the Wparentheses warning
5805 below when we get back up to the parent if statement. */
5811 second_body
= NULL_TREE
;
5813 /* Diagnose an ambiguous else if if-then-else is nested inside
5816 warning_at (loc
, OPT_Wdangling_else
,
5817 "suggest explicit braces to avoid ambiguous %<else%>");
5819 if (warn_duplicated_cond
)
5821 /* This if statement does not have an else clause. We don't
5822 need the condition chain anymore. */
5827 c_finish_if_stmt (loc
, cond
, first_body
, second_body
);
5828 add_stmt (c_end_compound_stmt (loc
, block
, flag_isoc99
));
5830 c_parser_maybe_reclassify_token (parser
);
5833 /* Parse a switch statement (C90 6.6.4, C99 6.8.4, C11 6.8.4).
5836 switch (expression) statement
5840 c_parser_switch_statement (c_parser
*parser
, bool *if_p
)
5843 tree block
, expr
, body
, save_break
;
5844 location_t switch_loc
= c_parser_peek_token (parser
)->location
;
5845 location_t switch_cond_loc
;
5846 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SWITCH
));
5847 c_parser_consume_token (parser
);
5848 block
= c_begin_compound_stmt (flag_isoc99
);
5849 bool explicit_cast_p
= false;
5850 matching_parens parens
;
5851 if (parens
.require_open (parser
))
5853 switch_cond_loc
= c_parser_peek_token (parser
)->location
;
5854 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
5855 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
5856 explicit_cast_p
= true;
5857 ce
= c_parser_expression (parser
);
5858 ce
= convert_lvalue_to_rvalue (switch_cond_loc
, ce
, true, false);
5860 /* ??? expr has no valid location? */
5861 parens
.skip_until_found_close (parser
);
5865 switch_cond_loc
= UNKNOWN_LOCATION
;
5866 expr
= error_mark_node
;
5867 ce
.original_type
= error_mark_node
;
5869 c_start_case (switch_loc
, switch_cond_loc
, expr
, explicit_cast_p
);
5870 save_break
= c_break_label
;
5871 c_break_label
= NULL_TREE
;
5872 location_t loc_after_labels
;
5873 bool open_brace_p
= c_parser_peek_token (parser
)->type
== CPP_OPEN_BRACE
;
5874 body
= c_parser_c99_block_statement (parser
, if_p
, &loc_after_labels
);
5875 location_t next_loc
= c_parser_peek_token (parser
)->location
;
5876 if (!open_brace_p
&& c_parser_peek_token (parser
)->type
!= CPP_SEMICOLON
)
5877 warn_for_multistatement_macros (loc_after_labels
, next_loc
, switch_loc
,
5881 location_t here
= c_parser_peek_token (parser
)->location
;
5882 tree t
= build1 (LABEL_EXPR
, void_type_node
, c_break_label
);
5883 SET_EXPR_LOCATION (t
, here
);
5884 SWITCH_BREAK_LABEL_P (c_break_label
) = 1;
5885 append_to_statement_list_force (t
, &body
);
5887 c_finish_case (body
, ce
.original_type
);
5888 c_break_label
= save_break
;
5889 add_stmt (c_end_compound_stmt (switch_loc
, block
, flag_isoc99
));
5890 c_parser_maybe_reclassify_token (parser
);
5893 /* Parse a while statement (C90 6.6.5, C99 6.8.5, C11 6.8.5).
5896 while (expression) statement
5898 IF_P is used to track whether there's a (possibly labeled) if statement
5899 which is not enclosed in braces and has an else clause. This is used to
5900 implement -Wparentheses. */
5903 c_parser_while_statement (c_parser
*parser
, bool ivdep
, unsigned short unroll
,
5906 tree block
, cond
, body
, save_break
, save_cont
;
5908 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_WHILE
));
5909 token_indent_info while_tinfo
5910 = get_token_indent_info (c_parser_peek_token (parser
));
5911 c_parser_consume_token (parser
);
5912 block
= c_begin_compound_stmt (flag_isoc99
);
5913 loc
= c_parser_peek_token (parser
)->location
;
5914 cond
= c_parser_paren_condition (parser
);
5915 if (ivdep
&& cond
!= error_mark_node
)
5916 cond
= build3 (ANNOTATE_EXPR
, TREE_TYPE (cond
), cond
,
5917 build_int_cst (integer_type_node
,
5918 annot_expr_ivdep_kind
),
5920 if (unroll
&& cond
!= error_mark_node
)
5921 cond
= build3 (ANNOTATE_EXPR
, TREE_TYPE (cond
), cond
,
5922 build_int_cst (integer_type_node
,
5923 annot_expr_unroll_kind
),
5924 build_int_cst (integer_type_node
, unroll
));
5925 save_break
= c_break_label
;
5926 c_break_label
= NULL_TREE
;
5927 save_cont
= c_cont_label
;
5928 c_cont_label
= NULL_TREE
;
5930 token_indent_info body_tinfo
5931 = get_token_indent_info (c_parser_peek_token (parser
));
5933 location_t loc_after_labels
;
5934 bool open_brace
= c_parser_next_token_is (parser
, CPP_OPEN_BRACE
);
5935 body
= c_parser_c99_block_statement (parser
, if_p
, &loc_after_labels
);
5936 c_finish_loop (loc
, cond
, NULL
, body
, c_break_label
, c_cont_label
, true);
5937 add_stmt (c_end_compound_stmt (loc
, block
, flag_isoc99
));
5938 c_parser_maybe_reclassify_token (parser
);
5940 token_indent_info next_tinfo
5941 = get_token_indent_info (c_parser_peek_token (parser
));
5942 warn_for_misleading_indentation (while_tinfo
, body_tinfo
, next_tinfo
);
5944 if (next_tinfo
.type
!= CPP_SEMICOLON
&& !open_brace
)
5945 warn_for_multistatement_macros (loc_after_labels
, next_tinfo
.location
,
5946 while_tinfo
.location
, RID_WHILE
);
5948 c_break_label
= save_break
;
5949 c_cont_label
= save_cont
;
5952 /* Parse a do statement (C90 6.6.5, C99 6.8.5, C11 6.8.5).
5955 do statement while ( expression ) ;
5959 c_parser_do_statement (c_parser
*parser
, bool ivdep
, unsigned short unroll
)
5961 tree block
, cond
, body
, save_break
, save_cont
, new_break
, new_cont
;
5963 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_DO
));
5964 c_parser_consume_token (parser
);
5965 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5966 warning_at (c_parser_peek_token (parser
)->location
,
5968 "suggest braces around empty body in %<do%> statement");
5969 block
= c_begin_compound_stmt (flag_isoc99
);
5970 loc
= c_parser_peek_token (parser
)->location
;
5971 save_break
= c_break_label
;
5972 c_break_label
= NULL_TREE
;
5973 save_cont
= c_cont_label
;
5974 c_cont_label
= NULL_TREE
;
5975 body
= c_parser_c99_block_statement (parser
, NULL
);
5976 c_parser_require_keyword (parser
, RID_WHILE
, "expected %<while%>");
5977 new_break
= c_break_label
;
5978 c_break_label
= save_break
;
5979 new_cont
= c_cont_label
;
5980 c_cont_label
= save_cont
;
5981 cond
= c_parser_paren_condition (parser
);
5982 if (ivdep
&& cond
!= error_mark_node
)
5983 cond
= build3 (ANNOTATE_EXPR
, TREE_TYPE (cond
), cond
,
5984 build_int_cst (integer_type_node
,
5985 annot_expr_ivdep_kind
),
5987 if (unroll
&& cond
!= error_mark_node
)
5988 cond
= build3 (ANNOTATE_EXPR
, TREE_TYPE (cond
), cond
,
5989 build_int_cst (integer_type_node
,
5990 annot_expr_unroll_kind
),
5991 build_int_cst (integer_type_node
, unroll
));
5992 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
5993 c_parser_skip_to_end_of_block_or_statement (parser
);
5994 c_finish_loop (loc
, cond
, NULL
, body
, new_break
, new_cont
, false);
5995 add_stmt (c_end_compound_stmt (loc
, block
, flag_isoc99
));
5998 /* Parse a for statement (C90 6.6.5, C99 6.8.5, C11 6.8.5).
6001 for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
6002 for ( nested-declaration expression[opt] ; expression[opt] ) statement
6004 The form with a declaration is new in C99.
6006 ??? In accordance with the old parser, the declaration may be a
6007 nested function, which is then rejected in check_for_loop_decls,
6008 but does it make any sense for this to be included in the grammar?
6009 Note in particular that the nested function does not include a
6010 trailing ';', whereas the "declaration" production includes one.
6011 Also, can we reject bad declarations earlier and cheaper than
6012 check_for_loop_decls?
6014 In Objective-C, there are two additional variants:
6017 for ( expression in expresssion ) statement
6018 for ( declaration in expression ) statement
6020 This is inconsistent with C, because the second variant is allowed
6021 even if c99 is not enabled.
6023 The rest of the comment documents these Objective-C foreach-statement.
6025 Here is the canonical example of the first variant:
6026 for (object in array) { do something with object }
6027 we call the first expression ("object") the "object_expression" and
6028 the second expression ("array") the "collection_expression".
6029 object_expression must be an lvalue of type "id" (a generic Objective-C
6030 object) because the loop works by assigning to object_expression the
6031 various objects from the collection_expression. collection_expression
6032 must evaluate to something of type "id" which responds to the method
6033 countByEnumeratingWithState:objects:count:.
6035 The canonical example of the second variant is:
6036 for (id object in array) { do something with object }
6037 which is completely equivalent to
6040 for (object in array) { do something with object }
6042 Note that initizializing 'object' in some way (eg, "for ((object =
6043 xxx) in array) { do something with object }") is possibly
6044 technically valid, but completely pointless as 'object' will be
6045 assigned to something else as soon as the loop starts. We should
6046 most likely reject it (TODO).
6048 The beginning of the Objective-C foreach-statement looks exactly
6049 like the beginning of the for-statement, and we can tell it is a
6050 foreach-statement only because the initial declaration or
6051 expression is terminated by 'in' instead of ';'.
6053 IF_P is used to track whether there's a (possibly labeled) if statement
6054 which is not enclosed in braces and has an else clause. This is used to
6055 implement -Wparentheses. */
6058 c_parser_for_statement (c_parser
*parser
, bool ivdep
, unsigned short unroll
,
6061 tree block
, cond
, incr
, save_break
, save_cont
, body
;
6062 /* The following are only used when parsing an ObjC foreach statement. */
6063 tree object_expression
;
6064 /* Silence the bogus uninitialized warning. */
6065 tree collection_expression
= NULL
;
6066 location_t loc
= c_parser_peek_token (parser
)->location
;
6067 location_t for_loc
= c_parser_peek_token (parser
)->location
;
6068 bool is_foreach_statement
= false;
6069 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_FOR
));
6070 token_indent_info for_tinfo
6071 = get_token_indent_info (c_parser_peek_token (parser
));
6072 c_parser_consume_token (parser
);
6073 /* Open a compound statement in Objective-C as well, just in case this is
6074 as foreach expression. */
6075 block
= c_begin_compound_stmt (flag_isoc99
|| c_dialect_objc ());
6076 cond
= error_mark_node
;
6077 incr
= error_mark_node
;
6078 matching_parens parens
;
6079 if (parens
.require_open (parser
))
6081 /* Parse the initialization declaration or expression. */
6082 object_expression
= error_mark_node
;
6083 parser
->objc_could_be_foreach_context
= c_dialect_objc ();
6084 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
6086 parser
->objc_could_be_foreach_context
= false;
6087 c_parser_consume_token (parser
);
6088 c_finish_expr_stmt (loc
, NULL_TREE
);
6090 else if (c_parser_next_tokens_start_declaration (parser
))
6092 c_parser_declaration_or_fndef (parser
, true, true, true, true, true,
6093 &object_expression
, vNULL
);
6094 parser
->objc_could_be_foreach_context
= false;
6096 if (c_parser_next_token_is_keyword (parser
, RID_IN
))
6098 c_parser_consume_token (parser
);
6099 is_foreach_statement
= true;
6100 if (check_for_loop_decls (for_loc
, true) == NULL_TREE
)
6101 c_parser_error (parser
, "multiple iterating variables in fast enumeration");
6104 check_for_loop_decls (for_loc
, flag_isoc99
);
6106 else if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
6108 /* __extension__ can start a declaration, but is also an
6109 unary operator that can start an expression. Consume all
6110 but the last of a possible series of __extension__ to
6112 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
6113 && (c_parser_peek_2nd_token (parser
)->keyword
6115 c_parser_consume_token (parser
);
6116 if (c_token_starts_declaration (c_parser_peek_2nd_token (parser
)))
6119 ext
= disable_extension_diagnostics ();
6120 c_parser_consume_token (parser
);
6121 c_parser_declaration_or_fndef (parser
, true, true, true, true,
6122 true, &object_expression
, vNULL
);
6123 parser
->objc_could_be_foreach_context
= false;
6125 restore_extension_diagnostics (ext
);
6126 if (c_parser_next_token_is_keyword (parser
, RID_IN
))
6128 c_parser_consume_token (parser
);
6129 is_foreach_statement
= true;
6130 if (check_for_loop_decls (for_loc
, true) == NULL_TREE
)
6131 c_parser_error (parser
, "multiple iterating variables in fast enumeration");
6134 check_for_loop_decls (for_loc
, flag_isoc99
);
6144 tree init_expression
;
6145 ce
= c_parser_expression (parser
);
6146 init_expression
= ce
.value
;
6147 parser
->objc_could_be_foreach_context
= false;
6148 if (c_parser_next_token_is_keyword (parser
, RID_IN
))
6150 c_parser_consume_token (parser
);
6151 is_foreach_statement
= true;
6152 if (! lvalue_p (init_expression
))
6153 c_parser_error (parser
, "invalid iterating variable in fast enumeration");
6154 object_expression
= c_fully_fold (init_expression
, false, NULL
);
6158 ce
= convert_lvalue_to_rvalue (loc
, ce
, true, false);
6159 init_expression
= ce
.value
;
6160 c_finish_expr_stmt (loc
, init_expression
);
6161 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6165 /* Parse the loop condition. In the case of a foreach
6166 statement, there is no loop condition. */
6167 gcc_assert (!parser
->objc_could_be_foreach_context
);
6168 if (!is_foreach_statement
)
6170 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
6174 c_parser_error (parser
, "missing loop condition in loop with "
6175 "%<GCC ivdep%> pragma");
6176 cond
= error_mark_node
;
6180 c_parser_error (parser
, "missing loop condition in loop with "
6181 "%<GCC unroll%> pragma");
6182 cond
= error_mark_node
;
6186 c_parser_consume_token (parser
);
6192 cond
= c_parser_condition (parser
);
6193 c_parser_skip_until_found (parser
, CPP_SEMICOLON
,
6196 if (ivdep
&& cond
!= error_mark_node
)
6197 cond
= build3 (ANNOTATE_EXPR
, TREE_TYPE (cond
), cond
,
6198 build_int_cst (integer_type_node
,
6199 annot_expr_ivdep_kind
),
6201 if (unroll
&& cond
!= error_mark_node
)
6202 cond
= build3 (ANNOTATE_EXPR
, TREE_TYPE (cond
), cond
,
6203 build_int_cst (integer_type_node
,
6204 annot_expr_unroll_kind
),
6205 build_int_cst (integer_type_node
, unroll
));
6207 /* Parse the increment expression (the third expression in a
6208 for-statement). In the case of a foreach-statement, this is
6209 the expression that follows the 'in'. */
6210 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
6212 if (is_foreach_statement
)
6214 c_parser_error (parser
, "missing collection in fast enumeration");
6215 collection_expression
= error_mark_node
;
6218 incr
= c_process_expr_stmt (loc
, NULL_TREE
);
6222 if (is_foreach_statement
)
6223 collection_expression
= c_fully_fold (c_parser_expression (parser
).value
,
6227 struct c_expr ce
= c_parser_expression (parser
);
6228 ce
= convert_lvalue_to_rvalue (loc
, ce
, true, false);
6229 incr
= c_process_expr_stmt (loc
, ce
.value
);
6232 parens
.skip_until_found_close (parser
);
6234 save_break
= c_break_label
;
6235 c_break_label
= NULL_TREE
;
6236 save_cont
= c_cont_label
;
6237 c_cont_label
= NULL_TREE
;
6239 token_indent_info body_tinfo
6240 = get_token_indent_info (c_parser_peek_token (parser
));
6242 location_t loc_after_labels
;
6243 bool open_brace
= c_parser_next_token_is (parser
, CPP_OPEN_BRACE
);
6244 body
= c_parser_c99_block_statement (parser
, if_p
, &loc_after_labels
);
6246 if (is_foreach_statement
)
6247 objc_finish_foreach_loop (loc
, object_expression
, collection_expression
, body
, c_break_label
, c_cont_label
);
6249 c_finish_loop (loc
, cond
, incr
, body
, c_break_label
, c_cont_label
, true);
6250 add_stmt (c_end_compound_stmt (loc
, block
, flag_isoc99
|| c_dialect_objc ()));
6251 c_parser_maybe_reclassify_token (parser
);
6253 token_indent_info next_tinfo
6254 = get_token_indent_info (c_parser_peek_token (parser
));
6255 warn_for_misleading_indentation (for_tinfo
, body_tinfo
, next_tinfo
);
6257 if (next_tinfo
.type
!= CPP_SEMICOLON
&& !open_brace
)
6258 warn_for_multistatement_macros (loc_after_labels
, next_tinfo
.location
,
6259 for_tinfo
.location
, RID_FOR
);
6261 c_break_label
= save_break
;
6262 c_cont_label
= save_cont
;
6265 /* Parse an asm statement, a GNU extension. This is a full-blown asm
6266 statement with inputs, outputs, clobbers, and volatile tag
6270 asm type-qualifier[opt] ( asm-argument ) ;
6271 asm type-qualifier[opt] goto ( asm-goto-argument ) ;
6275 asm-string-literal : asm-operands[opt]
6276 asm-string-literal : asm-operands[opt] : asm-operands[opt]
6277 asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers[opt]
6280 asm-string-literal : : asm-operands[opt] : asm-clobbers[opt] \
6283 Qualifiers other than volatile are accepted in the syntax but
6287 c_parser_asm_statement (c_parser
*parser
)
6289 tree quals
, str
, outputs
, inputs
, clobbers
, labels
, ret
;
6290 bool simple
, is_goto
;
6291 location_t asm_loc
= c_parser_peek_token (parser
)->location
;
6292 int section
, nsections
;
6294 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
6295 c_parser_consume_token (parser
);
6296 if (c_parser_next_token_is_keyword (parser
, RID_VOLATILE
))
6298 quals
= c_parser_peek_token (parser
)->value
;
6299 c_parser_consume_token (parser
);
6301 else if (c_parser_next_token_is_keyword (parser
, RID_CONST
)
6302 || c_parser_next_token_is_keyword (parser
, RID_RESTRICT
))
6304 warning_at (c_parser_peek_token (parser
)->location
,
6306 "%E qualifier ignored on asm",
6307 c_parser_peek_token (parser
)->value
);
6309 c_parser_consume_token (parser
);
6315 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
6317 c_parser_consume_token (parser
);
6321 /* ??? Follow the C++ parser rather than using the
6322 lex_untranslated_string kludge. */
6323 parser
->lex_untranslated_string
= true;
6326 matching_parens parens
;
6327 if (!parens
.require_open (parser
))
6330 str
= c_parser_asm_string_literal (parser
);
6331 if (str
== NULL_TREE
)
6332 goto error_close_paren
;
6335 outputs
= NULL_TREE
;
6337 clobbers
= NULL_TREE
;
6340 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
) && !is_goto
)
6343 /* Parse each colon-delimited section of operands. */
6344 nsections
= 3 + is_goto
;
6345 for (section
= 0; section
< nsections
; ++section
)
6347 if (!c_parser_require (parser
, CPP_COLON
,
6349 ? G_("expected %<:%>")
6350 : G_("expected %<:%> or %<)%>"),
6351 UNKNOWN_LOCATION
, is_goto
))
6352 goto error_close_paren
;
6354 /* Once past any colon, we're no longer a simple asm. */
6357 if ((!c_parser_next_token_is (parser
, CPP_COLON
)
6358 && !c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
6363 /* For asm goto, we don't allow output operands, but reserve
6364 the slot for a future extension that does allow them. */
6366 outputs
= c_parser_asm_operands (parser
);
6369 inputs
= c_parser_asm_operands (parser
);
6372 clobbers
= c_parser_asm_clobbers (parser
);
6375 labels
= c_parser_asm_goto_operands (parser
);
6381 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
) && !is_goto
)
6386 if (!parens
.require_close (parser
))
6388 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6392 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
6393 c_parser_skip_to_end_of_block_or_statement (parser
);
6395 ret
= build_asm_stmt (quals
, build_asm_expr (asm_loc
, str
, outputs
, inputs
,
6396 clobbers
, labels
, simple
));
6399 parser
->lex_untranslated_string
= false;
6403 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6407 /* Parse asm operands, a GNU extension.
6411 asm-operands , asm-operand
6414 asm-string-literal ( expression )
6415 [ identifier ] asm-string-literal ( expression )
6419 c_parser_asm_operands (c_parser
*parser
)
6421 tree list
= NULL_TREE
;
6426 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
6428 c_parser_consume_token (parser
);
6429 if (c_parser_next_token_is (parser
, CPP_NAME
))
6431 tree id
= c_parser_peek_token (parser
)->value
;
6432 c_parser_consume_token (parser
);
6433 name
= build_string (IDENTIFIER_LENGTH (id
),
6434 IDENTIFIER_POINTER (id
));
6438 c_parser_error (parser
, "expected identifier");
6439 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
6442 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
6447 str
= c_parser_asm_string_literal (parser
);
6448 if (str
== NULL_TREE
)
6450 parser
->lex_untranslated_string
= false;
6451 matching_parens parens
;
6452 if (!parens
.require_open (parser
))
6454 parser
->lex_untranslated_string
= true;
6457 expr
= c_parser_expression (parser
);
6458 mark_exp_read (expr
.value
);
6459 parser
->lex_untranslated_string
= true;
6460 if (!parens
.require_close (parser
))
6462 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6465 list
= chainon (list
, build_tree_list (build_tree_list (name
, str
),
6467 if (c_parser_next_token_is (parser
, CPP_COMMA
))
6468 c_parser_consume_token (parser
);
6475 /* Parse asm clobbers, a GNU extension.
6479 asm-clobbers , asm-string-literal
6483 c_parser_asm_clobbers (c_parser
*parser
)
6485 tree list
= NULL_TREE
;
6488 tree str
= c_parser_asm_string_literal (parser
);
6490 list
= tree_cons (NULL_TREE
, str
, list
);
6493 if (c_parser_next_token_is (parser
, CPP_COMMA
))
6494 c_parser_consume_token (parser
);
6501 /* Parse asm goto labels, a GNU extension.
6505 asm-goto-operands , identifier
6509 c_parser_asm_goto_operands (c_parser
*parser
)
6511 tree list
= NULL_TREE
;
6516 if (c_parser_next_token_is (parser
, CPP_NAME
))
6518 c_token
*tok
= c_parser_peek_token (parser
);
6520 label
= lookup_label_for_goto (tok
->location
, name
);
6521 c_parser_consume_token (parser
);
6522 TREE_USED (label
) = 1;
6526 c_parser_error (parser
, "expected identifier");
6530 name
= build_string (IDENTIFIER_LENGTH (name
),
6531 IDENTIFIER_POINTER (name
));
6532 list
= tree_cons (name
, label
, list
);
6533 if (c_parser_next_token_is (parser
, CPP_COMMA
))
6534 c_parser_consume_token (parser
);
6536 return nreverse (list
);
6540 /* Parse an expression other than a compound expression; that is, an
6541 assignment expression (C90 6.3.16, C99 6.5.16, C11 6.5.16). If
6542 AFTER is not NULL then it is an Objective-C message expression which
6543 is the primary-expression starting the expression as an initializer.
6545 assignment-expression:
6546 conditional-expression
6547 unary-expression assignment-operator assignment-expression
6549 assignment-operator: one of
6550 = *= /= %= += -= <<= >>= &= ^= |=
6552 In GNU C we accept any conditional expression on the LHS and
6553 diagnose the invalid lvalue rather than producing a syntax
6556 static struct c_expr
6557 c_parser_expr_no_commas (c_parser
*parser
, struct c_expr
*after
,
6558 tree omp_atomic_lhs
)
6560 struct c_expr lhs
, rhs
, ret
;
6561 enum tree_code code
;
6562 location_t op_location
, exp_location
;
6563 gcc_assert (!after
|| c_dialect_objc ());
6564 lhs
= c_parser_conditional_expression (parser
, after
, omp_atomic_lhs
);
6565 op_location
= c_parser_peek_token (parser
)->location
;
6566 switch (c_parser_peek_token (parser
)->type
)
6575 code
= TRUNC_DIV_EXPR
;
6578 code
= TRUNC_MOD_EXPR
;
6593 code
= BIT_AND_EXPR
;
6596 code
= BIT_XOR_EXPR
;
6599 code
= BIT_IOR_EXPR
;
6604 c_parser_consume_token (parser
);
6605 exp_location
= c_parser_peek_token (parser
)->location
;
6606 rhs
= c_parser_expr_no_commas (parser
, NULL
);
6607 rhs
= convert_lvalue_to_rvalue (exp_location
, rhs
, true, true);
6609 ret
.value
= build_modify_expr (op_location
, lhs
.value
, lhs
.original_type
,
6610 code
, exp_location
, rhs
.value
,
6612 set_c_expr_source_range (&ret
, lhs
.get_start (), rhs
.get_finish ());
6613 if (code
== NOP_EXPR
)
6614 ret
.original_code
= MODIFY_EXPR
;
6617 TREE_NO_WARNING (ret
.value
) = 1;
6618 ret
.original_code
= ERROR_MARK
;
6620 ret
.original_type
= NULL
;
6624 /* Parse a conditional expression (C90 6.3.15, C99 6.5.15, C11 6.5.15). If
6625 AFTER is not NULL then it is an Objective-C message expression which is
6626 the primary-expression starting the expression as an initializer.
6628 conditional-expression:
6629 logical-OR-expression
6630 logical-OR-expression ? expression : conditional-expression
6634 conditional-expression:
6635 logical-OR-expression ? : conditional-expression
6638 static struct c_expr
6639 c_parser_conditional_expression (c_parser
*parser
, struct c_expr
*after
,
6640 tree omp_atomic_lhs
)
6642 struct c_expr cond
, exp1
, exp2
, ret
;
6643 location_t start
, cond_loc
, colon_loc
;
6645 gcc_assert (!after
|| c_dialect_objc ());
6647 cond
= c_parser_binary_expression (parser
, after
, omp_atomic_lhs
);
6649 if (c_parser_next_token_is_not (parser
, CPP_QUERY
))
6651 if (cond
.value
!= error_mark_node
)
6652 start
= cond
.get_start ();
6654 start
= UNKNOWN_LOCATION
;
6655 cond_loc
= c_parser_peek_token (parser
)->location
;
6656 cond
= convert_lvalue_to_rvalue (cond_loc
, cond
, true, true);
6657 c_parser_consume_token (parser
);
6658 if (c_parser_next_token_is (parser
, CPP_COLON
))
6660 tree eptype
= NULL_TREE
;
6662 location_t middle_loc
= c_parser_peek_token (parser
)->location
;
6663 pedwarn (middle_loc
, OPT_Wpedantic
,
6664 "ISO C forbids omitting the middle term of a ?: expression");
6665 if (TREE_CODE (cond
.value
) == EXCESS_PRECISION_EXPR
)
6667 eptype
= TREE_TYPE (cond
.value
);
6668 cond
.value
= TREE_OPERAND (cond
.value
, 0);
6670 tree e
= cond
.value
;
6671 while (TREE_CODE (e
) == COMPOUND_EXPR
)
6672 e
= TREE_OPERAND (e
, 1);
6673 warn_for_omitted_condop (middle_loc
, e
);
6674 /* Make sure first operand is calculated only once. */
6675 exp1
.value
= save_expr (default_conversion (cond
.value
));
6677 exp1
.value
= build1 (EXCESS_PRECISION_EXPR
, eptype
, exp1
.value
);
6678 exp1
.original_type
= NULL
;
6679 exp1
.src_range
= cond
.src_range
;
6680 cond
.value
= c_objc_common_truthvalue_conversion (cond_loc
, exp1
.value
);
6681 c_inhibit_evaluation_warnings
+= cond
.value
== truthvalue_true_node
;
6686 = c_objc_common_truthvalue_conversion
6687 (cond_loc
, default_conversion (cond
.value
));
6688 c_inhibit_evaluation_warnings
+= cond
.value
== truthvalue_false_node
;
6689 exp1
= c_parser_expression_conv (parser
);
6690 mark_exp_read (exp1
.value
);
6691 c_inhibit_evaluation_warnings
+=
6692 ((cond
.value
== truthvalue_true_node
)
6693 - (cond
.value
== truthvalue_false_node
));
6696 colon_loc
= c_parser_peek_token (parser
)->location
;
6697 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6699 c_inhibit_evaluation_warnings
-= cond
.value
== truthvalue_true_node
;
6701 ret
.original_code
= ERROR_MARK
;
6702 ret
.original_type
= NULL
;
6706 location_t exp2_loc
= c_parser_peek_token (parser
)->location
;
6707 exp2
= c_parser_conditional_expression (parser
, NULL
, NULL_TREE
);
6708 exp2
= convert_lvalue_to_rvalue (exp2_loc
, exp2
, true, true);
6710 c_inhibit_evaluation_warnings
-= cond
.value
== truthvalue_true_node
;
6711 location_t loc1
= make_location (exp1
.get_start (), exp1
.src_range
);
6712 location_t loc2
= make_location (exp2
.get_start (), exp2
.src_range
);
6713 ret
.value
= build_conditional_expr (colon_loc
, cond
.value
,
6714 cond
.original_code
== C_MAYBE_CONST_EXPR
,
6715 exp1
.value
, exp1
.original_type
, loc1
,
6716 exp2
.value
, exp2
.original_type
, loc2
);
6717 ret
.original_code
= ERROR_MARK
;
6718 if (exp1
.value
== error_mark_node
|| exp2
.value
== error_mark_node
)
6719 ret
.original_type
= NULL
;
6724 /* If both sides are enum type, the default conversion will have
6725 made the type of the result be an integer type. We want to
6726 remember the enum types we started with. */
6727 t1
= exp1
.original_type
? exp1
.original_type
: TREE_TYPE (exp1
.value
);
6728 t2
= exp2
.original_type
? exp2
.original_type
: TREE_TYPE (exp2
.value
);
6729 ret
.original_type
= ((t1
!= error_mark_node
6730 && t2
!= error_mark_node
6731 && (TYPE_MAIN_VARIANT (t1
)
6732 == TYPE_MAIN_VARIANT (t2
)))
6736 set_c_expr_source_range (&ret
, start
, exp2
.get_finish ());
6740 /* Parse a binary expression; that is, a logical-OR-expression (C90
6741 6.3.5-6.3.14, C99 6.5.5-6.5.14, C11 6.5.5-6.5.14). If AFTER is not
6742 NULL then it is an Objective-C message expression which is the
6743 primary-expression starting the expression as an initializer.
6745 OMP_ATOMIC_LHS is NULL, unless parsing OpenMP #pragma omp atomic,
6746 when it should be the unfolded lhs. In a valid OpenMP source,
6747 one of the operands of the toplevel binary expression must be equal
6748 to it. In that case, just return a build2 created binary operation
6749 rather than result of parser_build_binary_op.
6751 multiplicative-expression:
6753 multiplicative-expression * cast-expression
6754 multiplicative-expression / cast-expression
6755 multiplicative-expression % cast-expression
6757 additive-expression:
6758 multiplicative-expression
6759 additive-expression + multiplicative-expression
6760 additive-expression - multiplicative-expression
6764 shift-expression << additive-expression
6765 shift-expression >> additive-expression
6767 relational-expression:
6769 relational-expression < shift-expression
6770 relational-expression > shift-expression
6771 relational-expression <= shift-expression
6772 relational-expression >= shift-expression
6774 equality-expression:
6775 relational-expression
6776 equality-expression == relational-expression
6777 equality-expression != relational-expression
6781 AND-expression & equality-expression
6783 exclusive-OR-expression:
6785 exclusive-OR-expression ^ AND-expression
6787 inclusive-OR-expression:
6788 exclusive-OR-expression
6789 inclusive-OR-expression | exclusive-OR-expression
6791 logical-AND-expression:
6792 inclusive-OR-expression
6793 logical-AND-expression && inclusive-OR-expression
6795 logical-OR-expression:
6796 logical-AND-expression
6797 logical-OR-expression || logical-AND-expression
6800 static struct c_expr
6801 c_parser_binary_expression (c_parser
*parser
, struct c_expr
*after
,
6802 tree omp_atomic_lhs
)
6804 /* A binary expression is parsed using operator-precedence parsing,
6805 with the operands being cast expressions. All the binary
6806 operators are left-associative. Thus a binary expression is of
6809 E0 op1 E1 op2 E2 ...
6811 which we represent on a stack. On the stack, the precedence
6812 levels are strictly increasing. When a new operator is
6813 encountered of higher precedence than that at the top of the
6814 stack, it is pushed; its LHS is the top expression, and its RHS
6815 is everything parsed until it is popped. When a new operator is
6816 encountered with precedence less than or equal to that at the top
6817 of the stack, triples E[i-1] op[i] E[i] are popped and replaced
6818 by the result of the operation until the operator at the top of
6819 the stack has lower precedence than the new operator or there is
6820 only one element on the stack; then the top expression is the LHS
6821 of the new operator. In the case of logical AND and OR
6822 expressions, we also need to adjust c_inhibit_evaluation_warnings
6823 as appropriate when the operators are pushed and popped. */
6826 /* The expression at this stack level. */
6828 /* The precedence of the operator on its left, PREC_NONE at the
6829 bottom of the stack. */
6830 enum c_parser_prec prec
;
6831 /* The operation on its left. */
6833 /* The source location of this operation. */
6835 /* The sizeof argument if expr.original_code == SIZEOF_EXPR. */
6839 /* Location of the binary operator. */
6840 location_t binary_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
6843 switch (stack[sp].op) \
6845 case TRUTH_ANDIF_EXPR: \
6846 c_inhibit_evaluation_warnings -= (stack[sp - 1].expr.value \
6847 == truthvalue_false_node); \
6849 case TRUTH_ORIF_EXPR: \
6850 c_inhibit_evaluation_warnings -= (stack[sp - 1].expr.value \
6851 == truthvalue_true_node); \
6853 case TRUNC_DIV_EXPR: \
6854 if (stack[sp - 1].expr.original_code == SIZEOF_EXPR \
6855 && stack[sp].expr.original_code == SIZEOF_EXPR) \
6857 tree type0 = stack[sp - 1].sizeof_arg; \
6858 tree type1 = stack[sp].sizeof_arg; \
6859 tree first_arg = type0; \
6860 if (!TYPE_P (type0)) \
6861 type0 = TREE_TYPE (type0); \
6862 if (!TYPE_P (type1)) \
6863 type1 = TREE_TYPE (type1); \
6864 if (POINTER_TYPE_P (type0) \
6865 && comptypes (TREE_TYPE (type0), type1) \
6866 && !(TREE_CODE (first_arg) == PARM_DECL \
6867 && C_ARRAY_PARAMETER (first_arg) \
6868 && warn_sizeof_array_argument)) \
6870 auto_diagnostic_group d; \
6871 if (warning_at (stack[sp].loc, OPT_Wsizeof_pointer_div, \
6872 "division %<sizeof (%T) / sizeof (%T)%> " \
6873 "does not compute the number of array " \
6876 if (DECL_P (first_arg)) \
6877 inform (DECL_SOURCE_LOCATION (first_arg), \
6878 "first %<sizeof%> operand was declared here"); \
6885 stack[sp - 1].expr \
6886 = convert_lvalue_to_rvalue (stack[sp - 1].loc, \
6887 stack[sp - 1].expr, true, true); \
6889 = convert_lvalue_to_rvalue (stack[sp].loc, \
6890 stack[sp].expr, true, true); \
6891 if (__builtin_expect (omp_atomic_lhs != NULL_TREE, 0) && sp == 1 \
6892 && c_parser_peek_token (parser)->type == CPP_SEMICOLON \
6893 && ((1 << stack[sp].prec) \
6894 & ((1 << PREC_BITOR) | (1 << PREC_BITXOR) | (1 << PREC_BITAND) \
6895 | (1 << PREC_SHIFT) | (1 << PREC_ADD) | (1 << PREC_MULT))) \
6896 && stack[sp].op != TRUNC_MOD_EXPR \
6897 && stack[0].expr.value != error_mark_node \
6898 && stack[1].expr.value != error_mark_node \
6899 && (c_tree_equal (stack[0].expr.value, omp_atomic_lhs) \
6900 || c_tree_equal (stack[1].expr.value, omp_atomic_lhs))) \
6901 stack[0].expr.value \
6902 = build2 (stack[1].op, TREE_TYPE (stack[0].expr.value), \
6903 stack[0].expr.value, stack[1].expr.value); \
6905 stack[sp - 1].expr = parser_build_binary_op (stack[sp].loc, \
6907 stack[sp - 1].expr, \
6911 gcc_assert (!after
|| c_dialect_objc ());
6912 stack
[0].loc
= c_parser_peek_token (parser
)->location
;
6913 stack
[0].expr
= c_parser_cast_expression (parser
, after
);
6914 stack
[0].prec
= PREC_NONE
;
6915 stack
[0].sizeof_arg
= c_last_sizeof_arg
;
6919 enum c_parser_prec oprec
;
6920 enum tree_code ocode
;
6921 source_range src_range
;
6924 switch (c_parser_peek_token (parser
)->type
)
6932 ocode
= TRUNC_DIV_EXPR
;
6936 ocode
= TRUNC_MOD_EXPR
;
6948 ocode
= LSHIFT_EXPR
;
6952 ocode
= RSHIFT_EXPR
;
6966 case CPP_GREATER_EQ
:
6979 oprec
= PREC_BITAND
;
6980 ocode
= BIT_AND_EXPR
;
6983 oprec
= PREC_BITXOR
;
6984 ocode
= BIT_XOR_EXPR
;
6988 ocode
= BIT_IOR_EXPR
;
6991 oprec
= PREC_LOGAND
;
6992 ocode
= TRUTH_ANDIF_EXPR
;
6996 ocode
= TRUTH_ORIF_EXPR
;
6999 /* Not a binary operator, so end of the binary
7003 binary_loc
= c_parser_peek_token (parser
)->location
;
7004 while (oprec
<= stack
[sp
].prec
)
7006 c_parser_consume_token (parser
);
7009 case TRUTH_ANDIF_EXPR
:
7010 src_range
= stack
[sp
].expr
.src_range
;
7012 = convert_lvalue_to_rvalue (stack
[sp
].loc
,
7013 stack
[sp
].expr
, true, true);
7014 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
7015 (stack
[sp
].loc
, default_conversion (stack
[sp
].expr
.value
));
7016 c_inhibit_evaluation_warnings
+= (stack
[sp
].expr
.value
7017 == truthvalue_false_node
);
7018 set_c_expr_source_range (&stack
[sp
].expr
, src_range
);
7020 case TRUTH_ORIF_EXPR
:
7021 src_range
= stack
[sp
].expr
.src_range
;
7023 = convert_lvalue_to_rvalue (stack
[sp
].loc
,
7024 stack
[sp
].expr
, true, true);
7025 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
7026 (stack
[sp
].loc
, default_conversion (stack
[sp
].expr
.value
));
7027 c_inhibit_evaluation_warnings
+= (stack
[sp
].expr
.value
7028 == truthvalue_true_node
);
7029 set_c_expr_source_range (&stack
[sp
].expr
, src_range
);
7035 stack
[sp
].loc
= binary_loc
;
7036 stack
[sp
].expr
= c_parser_cast_expression (parser
, NULL
);
7037 stack
[sp
].prec
= oprec
;
7038 stack
[sp
].op
= ocode
;
7039 stack
[sp
].sizeof_arg
= c_last_sizeof_arg
;
7044 return stack
[0].expr
;
7048 /* Parse a cast expression (C90 6.3.4, C99 6.5.4, C11 6.5.4). If AFTER
7049 is not NULL then it is an Objective-C message expression which is the
7050 primary-expression starting the expression as an initializer.
7054 ( type-name ) unary-expression
7057 static struct c_expr
7058 c_parser_cast_expression (c_parser
*parser
, struct c_expr
*after
)
7060 location_t cast_loc
= c_parser_peek_token (parser
)->location
;
7061 gcc_assert (!after
|| c_dialect_objc ());
7063 return c_parser_postfix_expression_after_primary (parser
,
7065 /* If the expression begins with a parenthesized type name, it may
7066 be either a cast or a compound literal; we need to see whether
7067 the next character is '{' to tell the difference. If not, it is
7068 an unary expression. Full detection of unknown typenames here
7069 would require a 3-token lookahead. */
7070 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
7071 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
7073 struct c_type_name
*type_name
;
7076 matching_parens parens
;
7077 parens
.consume_open (parser
);
7078 type_name
= c_parser_type_name (parser
, true);
7079 parens
.skip_until_found_close (parser
);
7080 if (type_name
== NULL
)
7083 ret
.original_code
= ERROR_MARK
;
7084 ret
.original_type
= NULL
;
7088 /* Save casted types in the function's used types hash table. */
7089 used_types_insert (type_name
->specs
->type
);
7091 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
7092 return c_parser_postfix_expression_after_paren_type (parser
, type_name
,
7094 if (type_name
->specs
->alignas_p
)
7095 error_at (type_name
->specs
->locations
[cdw_alignas
],
7096 "alignment specified for type name in cast");
7098 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
7099 expr
= c_parser_cast_expression (parser
, NULL
);
7100 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, true, true);
7102 ret
.value
= c_cast_expr (cast_loc
, type_name
, expr
.value
);
7103 if (ret
.value
&& expr
.value
)
7104 set_c_expr_source_range (&ret
, cast_loc
, expr
.get_finish ());
7105 ret
.original_code
= ERROR_MARK
;
7106 ret
.original_type
= NULL
;
7110 return c_parser_unary_expression (parser
);
7113 /* Parse an unary expression (C90 6.3.3, C99 6.5.3, C11 6.5.3).
7119 unary-operator cast-expression
7120 sizeof unary-expression
7121 sizeof ( type-name )
7123 unary-operator: one of
7129 __alignof__ unary-expression
7130 __alignof__ ( type-name )
7133 (C11 permits _Alignof with type names only.)
7135 unary-operator: one of
7136 __extension__ __real__ __imag__
7138 Transactional Memory:
7141 transaction-expression
7143 In addition, the GNU syntax treats ++ and -- as unary operators, so
7144 they may be applied to cast expressions with errors for non-lvalues
7147 static struct c_expr
7148 c_parser_unary_expression (c_parser
*parser
)
7151 struct c_expr ret
, op
;
7152 location_t op_loc
= c_parser_peek_token (parser
)->location
;
7155 ret
.original_code
= ERROR_MARK
;
7156 ret
.original_type
= NULL
;
7157 switch (c_parser_peek_token (parser
)->type
)
7160 c_parser_consume_token (parser
);
7161 exp_loc
= c_parser_peek_token (parser
)->location
;
7162 op
= c_parser_cast_expression (parser
, NULL
);
7164 op
= default_function_array_read_conversion (exp_loc
, op
);
7165 return parser_build_unary_op (op_loc
, PREINCREMENT_EXPR
, op
);
7166 case CPP_MINUS_MINUS
:
7167 c_parser_consume_token (parser
);
7168 exp_loc
= c_parser_peek_token (parser
)->location
;
7169 op
= c_parser_cast_expression (parser
, NULL
);
7171 op
= default_function_array_read_conversion (exp_loc
, op
);
7172 return parser_build_unary_op (op_loc
, PREDECREMENT_EXPR
, op
);
7174 c_parser_consume_token (parser
);
7175 op
= c_parser_cast_expression (parser
, NULL
);
7176 mark_exp_read (op
.value
);
7177 return parser_build_unary_op (op_loc
, ADDR_EXPR
, op
);
7180 c_parser_consume_token (parser
);
7181 exp_loc
= c_parser_peek_token (parser
)->location
;
7182 op
= c_parser_cast_expression (parser
, NULL
);
7183 finish
= op
.get_finish ();
7184 op
= convert_lvalue_to_rvalue (exp_loc
, op
, true, true);
7185 location_t combined_loc
= make_location (op_loc
, op_loc
, finish
);
7186 ret
.value
= build_indirect_ref (combined_loc
, op
.value
, RO_UNARY_STAR
);
7187 ret
.src_range
.m_start
= op_loc
;
7188 ret
.src_range
.m_finish
= finish
;
7192 if (!c_dialect_objc () && !in_system_header_at (input_location
))
7195 "traditional C rejects the unary plus operator");
7196 c_parser_consume_token (parser
);
7197 exp_loc
= c_parser_peek_token (parser
)->location
;
7198 op
= c_parser_cast_expression (parser
, NULL
);
7199 op
= convert_lvalue_to_rvalue (exp_loc
, op
, true, true);
7200 return parser_build_unary_op (op_loc
, CONVERT_EXPR
, op
);
7202 c_parser_consume_token (parser
);
7203 exp_loc
= c_parser_peek_token (parser
)->location
;
7204 op
= c_parser_cast_expression (parser
, NULL
);
7205 op
= convert_lvalue_to_rvalue (exp_loc
, op
, true, true);
7206 return parser_build_unary_op (op_loc
, NEGATE_EXPR
, op
);
7208 c_parser_consume_token (parser
);
7209 exp_loc
= c_parser_peek_token (parser
)->location
;
7210 op
= c_parser_cast_expression (parser
, NULL
);
7211 op
= convert_lvalue_to_rvalue (exp_loc
, op
, true, true);
7212 return parser_build_unary_op (op_loc
, BIT_NOT_EXPR
, op
);
7214 c_parser_consume_token (parser
);
7215 exp_loc
= c_parser_peek_token (parser
)->location
;
7216 op
= c_parser_cast_expression (parser
, NULL
);
7217 op
= convert_lvalue_to_rvalue (exp_loc
, op
, true, true);
7218 return parser_build_unary_op (op_loc
, TRUTH_NOT_EXPR
, op
);
7220 /* Refer to the address of a label as a pointer. */
7221 c_parser_consume_token (parser
);
7222 if (c_parser_next_token_is (parser
, CPP_NAME
))
7224 ret
.value
= finish_label_address_expr
7225 (c_parser_peek_token (parser
)->value
, op_loc
);
7226 set_c_expr_source_range (&ret
, op_loc
,
7227 c_parser_peek_token (parser
)->get_finish ());
7228 c_parser_consume_token (parser
);
7232 c_parser_error (parser
, "expected identifier");
7237 switch (c_parser_peek_token (parser
)->keyword
)
7240 return c_parser_sizeof_expression (parser
);
7242 return c_parser_alignof_expression (parser
);
7244 c_parser_consume_token (parser
);
7245 ext
= disable_extension_diagnostics ();
7246 ret
= c_parser_cast_expression (parser
, NULL
);
7247 restore_extension_diagnostics (ext
);
7250 c_parser_consume_token (parser
);
7251 exp_loc
= c_parser_peek_token (parser
)->location
;
7252 op
= c_parser_cast_expression (parser
, NULL
);
7253 op
= default_function_array_conversion (exp_loc
, op
);
7254 return parser_build_unary_op (op_loc
, REALPART_EXPR
, op
);
7256 c_parser_consume_token (parser
);
7257 exp_loc
= c_parser_peek_token (parser
)->location
;
7258 op
= c_parser_cast_expression (parser
, NULL
);
7259 op
= default_function_array_conversion (exp_loc
, op
);
7260 return parser_build_unary_op (op_loc
, IMAGPART_EXPR
, op
);
7261 case RID_TRANSACTION_ATOMIC
:
7262 case RID_TRANSACTION_RELAXED
:
7263 return c_parser_transaction_expression (parser
,
7264 c_parser_peek_token (parser
)->keyword
);
7266 return c_parser_postfix_expression (parser
);
7269 return c_parser_postfix_expression (parser
);
7273 /* Parse a sizeof expression. */
7275 static struct c_expr
7276 c_parser_sizeof_expression (c_parser
*parser
)
7279 struct c_expr result
;
7280 location_t expr_loc
;
7281 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SIZEOF
));
7284 location_t finish
= UNKNOWN_LOCATION
;
7286 start
= c_parser_peek_token (parser
)->location
;
7288 c_parser_consume_token (parser
);
7289 c_inhibit_evaluation_warnings
++;
7291 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
7292 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
7294 /* Either sizeof ( type-name ) or sizeof unary-expression
7295 starting with a compound literal. */
7296 struct c_type_name
*type_name
;
7297 matching_parens parens
;
7298 parens
.consume_open (parser
);
7299 expr_loc
= c_parser_peek_token (parser
)->location
;
7300 type_name
= c_parser_type_name (parser
, true);
7301 parens
.skip_until_found_close (parser
);
7302 finish
= parser
->tokens_buf
[0].location
;
7303 if (type_name
== NULL
)
7306 c_inhibit_evaluation_warnings
--;
7309 ret
.original_code
= ERROR_MARK
;
7310 ret
.original_type
= NULL
;
7313 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
7315 expr
= c_parser_postfix_expression_after_paren_type (parser
,
7318 finish
= expr
.get_finish ();
7321 /* sizeof ( type-name ). */
7322 if (type_name
->specs
->alignas_p
)
7323 error_at (type_name
->specs
->locations
[cdw_alignas
],
7324 "alignment specified for type name in %<sizeof%>");
7325 c_inhibit_evaluation_warnings
--;
7327 result
= c_expr_sizeof_type (expr_loc
, type_name
);
7331 expr_loc
= c_parser_peek_token (parser
)->location
;
7332 expr
= c_parser_unary_expression (parser
);
7333 finish
= expr
.get_finish ();
7335 c_inhibit_evaluation_warnings
--;
7337 mark_exp_read (expr
.value
);
7338 if (TREE_CODE (expr
.value
) == COMPONENT_REF
7339 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
7340 error_at (expr_loc
, "%<sizeof%> applied to a bit-field");
7341 result
= c_expr_sizeof_expr (expr_loc
, expr
);
7343 if (finish
!= UNKNOWN_LOCATION
)
7344 set_c_expr_source_range (&result
, start
, finish
);
7348 /* Parse an alignof expression. */
7350 static struct c_expr
7351 c_parser_alignof_expression (c_parser
*parser
)
7354 location_t start_loc
= c_parser_peek_token (parser
)->location
;
7356 tree alignof_spelling
= c_parser_peek_token (parser
)->value
;
7357 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ALIGNOF
));
7358 bool is_c11_alignof
= strcmp (IDENTIFIER_POINTER (alignof_spelling
),
7360 /* A diagnostic is not required for the use of this identifier in
7361 the implementation namespace; only diagnose it for the C11
7362 spelling because of existing code using the other spellings. */
7366 pedwarn_c99 (start_loc
, OPT_Wpedantic
, "ISO C99 does not support %qE",
7369 pedwarn_c99 (start_loc
, OPT_Wpedantic
, "ISO C90 does not support %qE",
7372 c_parser_consume_token (parser
);
7373 c_inhibit_evaluation_warnings
++;
7375 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
7376 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
7378 /* Either __alignof__ ( type-name ) or __alignof__
7379 unary-expression starting with a compound literal. */
7381 struct c_type_name
*type_name
;
7383 matching_parens parens
;
7384 parens
.consume_open (parser
);
7385 loc
= c_parser_peek_token (parser
)->location
;
7386 type_name
= c_parser_type_name (parser
, true);
7387 end_loc
= c_parser_peek_token (parser
)->location
;
7388 parens
.skip_until_found_close (parser
);
7389 if (type_name
== NULL
)
7392 c_inhibit_evaluation_warnings
--;
7395 ret
.original_code
= ERROR_MARK
;
7396 ret
.original_type
= NULL
;
7399 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
7401 expr
= c_parser_postfix_expression_after_paren_type (parser
,
7406 /* alignof ( type-name ). */
7407 if (type_name
->specs
->alignas_p
)
7408 error_at (type_name
->specs
->locations
[cdw_alignas
],
7409 "alignment specified for type name in %qE",
7411 c_inhibit_evaluation_warnings
--;
7413 ret
.value
= c_sizeof_or_alignof_type (loc
, groktypename (type_name
,
7415 false, is_c11_alignof
, 1);
7416 ret
.original_code
= ERROR_MARK
;
7417 ret
.original_type
= NULL
;
7418 set_c_expr_source_range (&ret
, start_loc
, end_loc
);
7424 expr
= c_parser_unary_expression (parser
);
7425 end_loc
= expr
.src_range
.m_finish
;
7427 mark_exp_read (expr
.value
);
7428 c_inhibit_evaluation_warnings
--;
7432 OPT_Wpedantic
, "ISO C does not allow %<%E (expression)%>",
7434 ret
.value
= c_alignof_expr (start_loc
, expr
.value
);
7435 ret
.original_code
= ERROR_MARK
;
7436 ret
.original_type
= NULL
;
7437 set_c_expr_source_range (&ret
, start_loc
, end_loc
);
7442 /* Helper function to read arguments of builtins which are interfaces
7443 for the middle-end nodes like COMPLEX_EXPR, VEC_PERM_EXPR and
7444 others. The name of the builtin is passed using BNAME parameter.
7445 Function returns true if there were no errors while parsing and
7446 stores the arguments in CEXPR_LIST. If it returns true,
7447 *OUT_CLOSE_PAREN_LOC is written to with the location of the closing
7450 c_parser_get_builtin_args (c_parser
*parser
, const char *bname
,
7451 vec
<c_expr_t
, va_gc
> **ret_cexpr_list
,
7453 location_t
*out_close_paren_loc
)
7455 location_t loc
= c_parser_peek_token (parser
)->location
;
7456 vec
<c_expr_t
, va_gc
> *cexpr_list
;
7458 bool saved_force_folding_builtin_constant_p
;
7460 *ret_cexpr_list
= NULL
;
7461 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
7463 error_at (loc
, "cannot take address of %qs", bname
);
7467 c_parser_consume_token (parser
);
7469 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
7471 *out_close_paren_loc
= c_parser_peek_token (parser
)->location
;
7472 c_parser_consume_token (parser
);
7476 saved_force_folding_builtin_constant_p
7477 = force_folding_builtin_constant_p
;
7478 force_folding_builtin_constant_p
|= choose_expr_p
;
7479 expr
= c_parser_expr_no_commas (parser
, NULL
);
7480 force_folding_builtin_constant_p
7481 = saved_force_folding_builtin_constant_p
;
7482 vec_alloc (cexpr_list
, 1);
7483 vec_safe_push (cexpr_list
, expr
);
7484 while (c_parser_next_token_is (parser
, CPP_COMMA
))
7486 c_parser_consume_token (parser
);
7487 expr
= c_parser_expr_no_commas (parser
, NULL
);
7488 vec_safe_push (cexpr_list
, expr
);
7491 *out_close_paren_loc
= c_parser_peek_token (parser
)->location
;
7492 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
7495 *ret_cexpr_list
= cexpr_list
;
7499 /* This represents a single generic-association. */
7501 struct c_generic_association
7503 /* The location of the starting token of the type. */
7504 location_t type_location
;
7505 /* The association's type, or NULL_TREE for 'default'. */
7507 /* The association's expression. */
7508 struct c_expr expression
;
7511 /* Parse a generic-selection. (C11 6.5.1.1).
7514 _Generic ( assignment-expression , generic-assoc-list )
7518 generic-assoc-list , generic-association
7520 generic-association:
7521 type-name : assignment-expression
7522 default : assignment-expression
7525 static struct c_expr
7526 c_parser_generic_selection (c_parser
*parser
)
7528 struct c_expr selector
, error_expr
;
7530 struct c_generic_association matched_assoc
;
7531 bool match_found
= false;
7532 location_t generic_loc
, selector_loc
;
7534 error_expr
.original_code
= ERROR_MARK
;
7535 error_expr
.original_type
= NULL
;
7536 error_expr
.set_error ();
7537 matched_assoc
.type_location
= UNKNOWN_LOCATION
;
7538 matched_assoc
.type
= NULL_TREE
;
7539 matched_assoc
.expression
= error_expr
;
7541 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_GENERIC
));
7542 generic_loc
= c_parser_peek_token (parser
)->location
;
7543 c_parser_consume_token (parser
);
7545 pedwarn_c99 (generic_loc
, OPT_Wpedantic
,
7546 "ISO C99 does not support %<_Generic%>");
7548 pedwarn_c99 (generic_loc
, OPT_Wpedantic
,
7549 "ISO C90 does not support %<_Generic%>");
7551 matching_parens parens
;
7552 if (!parens
.require_open (parser
))
7555 c_inhibit_evaluation_warnings
++;
7556 selector_loc
= c_parser_peek_token (parser
)->location
;
7557 selector
= c_parser_expr_no_commas (parser
, NULL
);
7558 selector
= default_function_array_conversion (selector_loc
, selector
);
7559 c_inhibit_evaluation_warnings
--;
7561 if (selector
.value
== error_mark_node
)
7563 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
7566 selector_type
= TREE_TYPE (selector
.value
);
7567 /* In ISO C terms, rvalues (including the controlling expression of
7568 _Generic) do not have qualified types. */
7569 if (TREE_CODE (selector_type
) != ARRAY_TYPE
)
7570 selector_type
= TYPE_MAIN_VARIANT (selector_type
);
7571 /* In ISO C terms, _Noreturn is not part of the type of expressions
7572 such as &abort, but in GCC it is represented internally as a type
7574 if (FUNCTION_POINTER_TYPE_P (selector_type
)
7575 && TYPE_QUALS (TREE_TYPE (selector_type
)) != TYPE_UNQUALIFIED
)
7577 = build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (selector_type
)));
7579 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
7581 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
7585 auto_vec
<c_generic_association
> associations
;
7588 struct c_generic_association assoc
, *iter
;
7590 c_token
*token
= c_parser_peek_token (parser
);
7592 assoc
.type_location
= token
->location
;
7593 if (token
->type
== CPP_KEYWORD
&& token
->keyword
== RID_DEFAULT
)
7595 c_parser_consume_token (parser
);
7596 assoc
.type
= NULL_TREE
;
7600 struct c_type_name
*type_name
;
7602 type_name
= c_parser_type_name (parser
);
7603 if (type_name
== NULL
)
7605 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
7608 assoc
.type
= groktypename (type_name
, NULL
, NULL
);
7609 if (assoc
.type
== error_mark_node
)
7611 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
7615 if (TREE_CODE (assoc
.type
) == FUNCTION_TYPE
)
7616 error_at (assoc
.type_location
,
7617 "%<_Generic%> association has function type");
7618 else if (!COMPLETE_TYPE_P (assoc
.type
))
7619 error_at (assoc
.type_location
,
7620 "%<_Generic%> association has incomplete type");
7622 if (variably_modified_type_p (assoc
.type
, NULL_TREE
))
7623 error_at (assoc
.type_location
,
7624 "%<_Generic%> association has "
7625 "variable length type");
7628 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
7630 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
7634 assoc
.expression
= c_parser_expr_no_commas (parser
, NULL
);
7635 if (assoc
.expression
.value
== error_mark_node
)
7637 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
7641 for (ix
= 0; associations
.iterate (ix
, &iter
); ++ix
)
7643 if (assoc
.type
== NULL_TREE
)
7645 if (iter
->type
== NULL_TREE
)
7647 error_at (assoc
.type_location
,
7648 "duplicate %<default%> case in %<_Generic%>");
7649 inform (iter
->type_location
, "original %<default%> is here");
7652 else if (iter
->type
!= NULL_TREE
)
7654 if (comptypes (assoc
.type
, iter
->type
))
7656 error_at (assoc
.type_location
,
7657 "%<_Generic%> specifies two compatible types");
7658 inform (iter
->type_location
, "compatible type is here");
7663 if (assoc
.type
== NULL_TREE
)
7667 matched_assoc
= assoc
;
7671 else if (comptypes (assoc
.type
, selector_type
))
7673 if (!match_found
|| matched_assoc
.type
== NULL_TREE
)
7675 matched_assoc
= assoc
;
7680 error_at (assoc
.type_location
,
7681 "%<_Generic%> selector matches multiple associations");
7682 inform (matched_assoc
.type_location
,
7683 "other match is here");
7687 associations
.safe_push (assoc
);
7689 if (c_parser_peek_token (parser
)->type
!= CPP_COMMA
)
7691 c_parser_consume_token (parser
);
7694 if (!parens
.require_close (parser
))
7696 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
7702 error_at (selector_loc
, "%<_Generic%> selector of type %qT is not "
7703 "compatible with any association",
7708 return matched_assoc
.expression
;
7711 /* Check the validity of a function pointer argument *EXPR (argument
7712 position POS) to __builtin_tgmath. Return the number of function
7713 arguments if possibly valid; return 0 having reported an error if
7717 check_tgmath_function (c_expr
*expr
, unsigned int pos
)
7719 tree type
= TREE_TYPE (expr
->value
);
7720 if (!FUNCTION_POINTER_TYPE_P (type
))
7722 error_at (expr
->get_location (),
7723 "argument %u of %<__builtin_tgmath%> is not a function pointer",
7727 type
= TREE_TYPE (type
);
7728 if (!prototype_p (type
))
7730 error_at (expr
->get_location (),
7731 "argument %u of %<__builtin_tgmath%> is unprototyped", pos
);
7734 if (stdarg_p (type
))
7736 error_at (expr
->get_location (),
7737 "argument %u of %<__builtin_tgmath%> has variable arguments",
7741 unsigned int nargs
= 0;
7742 function_args_iterator iter
;
7744 FOREACH_FUNCTION_ARGS (type
, t
, iter
)
7746 if (t
== void_type_node
)
7752 error_at (expr
->get_location (),
7753 "argument %u of %<__builtin_tgmath%> has no arguments", pos
);
7759 /* Ways in which a parameter or return value of a type-generic macro
7760 may vary between the different functions the macro may call. */
7761 enum tgmath_parm_kind
7763 tgmath_fixed
, tgmath_real
, tgmath_complex
7766 /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2,
7767 C11 6.5.1-6.5.2). Compound literals aren't handled here; callers have to
7768 call c_parser_postfix_expression_after_paren_type on encountering them.
7772 postfix-expression [ expression ]
7773 postfix-expression ( argument-expression-list[opt] )
7774 postfix-expression . identifier
7775 postfix-expression -> identifier
7776 postfix-expression ++
7777 postfix-expression --
7778 ( type-name ) { initializer-list }
7779 ( type-name ) { initializer-list , }
7781 argument-expression-list:
7783 argument-expression-list , argument-expression
7796 (treated as a keyword in GNU C)
7799 ( compound-statement )
7800 __builtin_va_arg ( assignment-expression , type-name )
7801 __builtin_offsetof ( type-name , offsetof-member-designator )
7802 __builtin_choose_expr ( assignment-expression ,
7803 assignment-expression ,
7804 assignment-expression )
7805 __builtin_types_compatible_p ( type-name , type-name )
7806 __builtin_tgmath ( expr-list )
7807 __builtin_complex ( assignment-expression , assignment-expression )
7808 __builtin_shuffle ( assignment-expression , assignment-expression )
7809 __builtin_shuffle ( assignment-expression ,
7810 assignment-expression ,
7811 assignment-expression, )
7813 offsetof-member-designator:
7815 offsetof-member-designator . identifier
7816 offsetof-member-designator [ expression ]
7821 [ objc-receiver objc-message-args ]
7822 @selector ( objc-selector-arg )
7823 @protocol ( identifier )
7824 @encode ( type-name )
7826 Classname . identifier
7829 static struct c_expr
7830 c_parser_postfix_expression (c_parser
*parser
)
7832 struct c_expr expr
, e1
;
7833 struct c_type_name
*t1
, *t2
;
7834 location_t loc
= c_parser_peek_token (parser
)->location
;
7835 source_range tok_range
= c_parser_peek_token (parser
)->get_range ();
7836 expr
.original_code
= ERROR_MARK
;
7837 expr
.original_type
= NULL
;
7838 switch (c_parser_peek_token (parser
)->type
)
7841 expr
.value
= c_parser_peek_token (parser
)->value
;
7842 set_c_expr_source_range (&expr
, tok_range
);
7843 loc
= c_parser_peek_token (parser
)->location
;
7844 c_parser_consume_token (parser
);
7845 if (TREE_CODE (expr
.value
) == FIXED_CST
7846 && !targetm
.fixed_point_supported_p ())
7848 error_at (loc
, "fixed-point types not supported for this target");
7856 expr
.value
= c_parser_peek_token (parser
)->value
;
7857 /* For the purpose of warning when a pointer is compared with
7858 a zero character constant. */
7859 expr
.original_type
= char_type_node
;
7860 set_c_expr_source_range (&expr
, tok_range
);
7861 c_parser_consume_token (parser
);
7867 case CPP_UTF8STRING
:
7868 expr
.value
= c_parser_peek_token (parser
)->value
;
7869 set_c_expr_source_range (&expr
, tok_range
);
7870 expr
.original_code
= STRING_CST
;
7871 c_parser_consume_token (parser
);
7873 case CPP_OBJC_STRING
:
7874 gcc_assert (c_dialect_objc ());
7876 = objc_build_string_object (c_parser_peek_token (parser
)->value
);
7877 set_c_expr_source_range (&expr
, tok_range
);
7878 c_parser_consume_token (parser
);
7881 switch (c_parser_peek_token (parser
)->id_kind
)
7885 tree id
= c_parser_peek_token (parser
)->value
;
7886 c_parser_consume_token (parser
);
7887 expr
.value
= build_external_ref (loc
, id
,
7888 (c_parser_peek_token (parser
)->type
7890 &expr
.original_type
);
7891 set_c_expr_source_range (&expr
, tok_range
);
7894 case C_ID_CLASSNAME
:
7896 /* Here we parse the Objective-C 2.0 Class.name dot
7898 tree class_name
= c_parser_peek_token (parser
)->value
;
7900 c_parser_consume_token (parser
);
7901 gcc_assert (c_dialect_objc ());
7902 if (!c_parser_require (parser
, CPP_DOT
, "expected %<.%>"))
7907 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
7909 c_parser_error (parser
, "expected identifier");
7913 c_token
*component_tok
= c_parser_peek_token (parser
);
7914 component
= component_tok
->value
;
7915 location_t end_loc
= component_tok
->get_finish ();
7916 c_parser_consume_token (parser
);
7917 expr
.value
= objc_build_class_component_ref (class_name
,
7919 set_c_expr_source_range (&expr
, loc
, end_loc
);
7923 c_parser_error (parser
, "expected expression");
7928 case CPP_OPEN_PAREN
:
7929 /* A parenthesized expression, statement expression or compound
7931 if (c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_BRACE
)
7933 /* A statement expression. */
7935 location_t brace_loc
;
7936 c_parser_consume_token (parser
);
7937 brace_loc
= c_parser_peek_token (parser
)->location
;
7938 c_parser_consume_token (parser
);
7939 /* If we've not yet started the current function's statement list,
7940 or we're in the parameter scope of an old-style function
7941 declaration, statement expressions are not allowed. */
7942 if (!building_stmt_list_p () || old_style_parameter_scope ())
7944 error_at (loc
, "braced-group within expression allowed "
7945 "only inside a function");
7946 parser
->error
= true;
7947 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
7948 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
7952 stmt
= c_begin_stmt_expr ();
7953 c_parser_compound_statement_nostart (parser
);
7954 location_t close_loc
= c_parser_peek_token (parser
)->location
;
7955 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
7957 pedwarn (loc
, OPT_Wpedantic
,
7958 "ISO C forbids braced-groups within expressions");
7959 expr
.value
= c_finish_stmt_expr (brace_loc
, stmt
);
7960 set_c_expr_source_range (&expr
, loc
, close_loc
);
7961 mark_exp_read (expr
.value
);
7965 /* A parenthesized expression. */
7966 location_t loc_open_paren
= c_parser_peek_token (parser
)->location
;
7967 c_parser_consume_token (parser
);
7968 expr
= c_parser_expression (parser
);
7969 if (TREE_CODE (expr
.value
) == MODIFY_EXPR
)
7970 TREE_NO_WARNING (expr
.value
) = 1;
7971 if (expr
.original_code
!= C_MAYBE_CONST_EXPR
7972 && expr
.original_code
!= SIZEOF_EXPR
)
7973 expr
.original_code
= ERROR_MARK
;
7974 /* Don't change EXPR.ORIGINAL_TYPE. */
7975 location_t loc_close_paren
= c_parser_peek_token (parser
)->location
;
7976 set_c_expr_source_range (&expr
, loc_open_paren
, loc_close_paren
);
7977 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
7978 "expected %<)%>", loc_open_paren
);
7982 switch (c_parser_peek_token (parser
)->keyword
)
7984 case RID_FUNCTION_NAME
:
7985 pedwarn (loc
, OPT_Wpedantic
, "ISO C does not support "
7986 "%<__FUNCTION__%> predefined identifier");
7987 expr
.value
= fname_decl (loc
,
7988 c_parser_peek_token (parser
)->keyword
,
7989 c_parser_peek_token (parser
)->value
);
7990 set_c_expr_source_range (&expr
, loc
, loc
);
7991 c_parser_consume_token (parser
);
7993 case RID_PRETTY_FUNCTION_NAME
:
7994 pedwarn (loc
, OPT_Wpedantic
, "ISO C does not support "
7995 "%<__PRETTY_FUNCTION__%> predefined identifier");
7996 expr
.value
= fname_decl (loc
,
7997 c_parser_peek_token (parser
)->keyword
,
7998 c_parser_peek_token (parser
)->value
);
7999 set_c_expr_source_range (&expr
, loc
, loc
);
8000 c_parser_consume_token (parser
);
8002 case RID_C99_FUNCTION_NAME
:
8003 pedwarn_c90 (loc
, OPT_Wpedantic
, "ISO C90 does not support "
8004 "%<__func__%> predefined identifier");
8005 expr
.value
= fname_decl (loc
,
8006 c_parser_peek_token (parser
)->keyword
,
8007 c_parser_peek_token (parser
)->value
);
8008 set_c_expr_source_range (&expr
, loc
, loc
);
8009 c_parser_consume_token (parser
);
8013 location_t start_loc
= loc
;
8014 c_parser_consume_token (parser
);
8015 matching_parens parens
;
8016 if (!parens
.require_open (parser
))
8021 e1
= c_parser_expr_no_commas (parser
, NULL
);
8022 mark_exp_read (e1
.value
);
8023 e1
.value
= c_fully_fold (e1
.value
, false, NULL
);
8024 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
8026 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
8030 loc
= c_parser_peek_token (parser
)->location
;
8031 t1
= c_parser_type_name (parser
);
8032 location_t end_loc
= c_parser_peek_token (parser
)->get_finish ();
8033 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
8041 tree type_expr
= NULL_TREE
;
8042 expr
.value
= c_build_va_arg (start_loc
, e1
.value
, loc
,
8043 groktypename (t1
, &type_expr
, NULL
));
8046 expr
.value
= build2 (C_MAYBE_CONST_EXPR
,
8047 TREE_TYPE (expr
.value
), type_expr
,
8049 C_MAYBE_CONST_EXPR_NON_CONST (expr
.value
) = true;
8051 set_c_expr_source_range (&expr
, start_loc
, end_loc
);
8057 c_parser_consume_token (parser
);
8058 matching_parens parens
;
8059 if (!parens
.require_open (parser
))
8064 t1
= c_parser_type_name (parser
);
8066 parser
->error
= true;
8067 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
8068 gcc_assert (parser
->error
);
8071 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
8075 tree type
= groktypename (t1
, NULL
, NULL
);
8077 if (type
== error_mark_node
)
8078 offsetof_ref
= error_mark_node
;
8081 offsetof_ref
= build1 (INDIRECT_REF
, type
, null_pointer_node
);
8082 SET_EXPR_LOCATION (offsetof_ref
, loc
);
8084 /* Parse the second argument to __builtin_offsetof. We
8085 must have one identifier, and beyond that we want to
8086 accept sub structure and sub array references. */
8087 if (c_parser_next_token_is (parser
, CPP_NAME
))
8089 c_token
*comp_tok
= c_parser_peek_token (parser
);
8090 offsetof_ref
= build_component_ref
8091 (loc
, offsetof_ref
, comp_tok
->value
, comp_tok
->location
);
8092 c_parser_consume_token (parser
);
8093 while (c_parser_next_token_is (parser
, CPP_DOT
)
8094 || c_parser_next_token_is (parser
,
8096 || c_parser_next_token_is (parser
,
8099 if (c_parser_next_token_is (parser
, CPP_DEREF
))
8101 loc
= c_parser_peek_token (parser
)->location
;
8102 offsetof_ref
= build_array_ref (loc
,
8107 else if (c_parser_next_token_is (parser
, CPP_DOT
))
8110 c_parser_consume_token (parser
);
8111 if (c_parser_next_token_is_not (parser
,
8114 c_parser_error (parser
, "expected identifier");
8117 c_token
*comp_tok
= c_parser_peek_token (parser
);
8118 offsetof_ref
= build_component_ref
8119 (loc
, offsetof_ref
, comp_tok
->value
,
8120 comp_tok
->location
);
8121 c_parser_consume_token (parser
);
8127 loc
= c_parser_peek_token (parser
)->location
;
8128 c_parser_consume_token (parser
);
8129 ce
= c_parser_expression (parser
);
8130 ce
= convert_lvalue_to_rvalue (loc
, ce
, false, false);
8132 idx
= c_fully_fold (idx
, false, NULL
);
8133 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
8135 offsetof_ref
= build_array_ref (loc
, offsetof_ref
, idx
);
8140 c_parser_error (parser
, "expected identifier");
8141 location_t end_loc
= c_parser_peek_token (parser
)->get_finish ();
8142 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
8144 expr
.value
= fold_offsetof (offsetof_ref
);
8145 set_c_expr_source_range (&expr
, loc
, end_loc
);
8148 case RID_CHOOSE_EXPR
:
8150 vec
<c_expr_t
, va_gc
> *cexpr_list
;
8151 c_expr_t
*e1_p
, *e2_p
, *e3_p
;
8153 location_t close_paren_loc
;
8155 c_parser_consume_token (parser
);
8156 if (!c_parser_get_builtin_args (parser
,
8157 "__builtin_choose_expr",
8165 if (vec_safe_length (cexpr_list
) != 3)
8167 error_at (loc
, "wrong number of arguments to "
8168 "%<__builtin_choose_expr%>");
8173 e1_p
= &(*cexpr_list
)[0];
8174 e2_p
= &(*cexpr_list
)[1];
8175 e3_p
= &(*cexpr_list
)[2];
8178 mark_exp_read (e2_p
->value
);
8179 mark_exp_read (e3_p
->value
);
8180 if (TREE_CODE (c
) != INTEGER_CST
8181 || !INTEGRAL_TYPE_P (TREE_TYPE (c
)))
8183 "first argument to %<__builtin_choose_expr%> not"
8185 constant_expression_warning (c
);
8186 expr
= integer_zerop (c
) ? *e3_p
: *e2_p
;
8187 set_c_expr_source_range (&expr
, loc
, close_paren_loc
);
8190 case RID_TYPES_COMPATIBLE_P
:
8192 c_parser_consume_token (parser
);
8193 matching_parens parens
;
8194 if (!parens
.require_open (parser
))
8199 t1
= c_parser_type_name (parser
);
8205 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
8207 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
8211 t2
= c_parser_type_name (parser
);
8217 location_t close_paren_loc
= c_parser_peek_token (parser
)->location
;
8218 parens
.skip_until_found_close (parser
);
8220 e1
= groktypename (t1
, NULL
, NULL
);
8221 e2
= groktypename (t2
, NULL
, NULL
);
8222 if (e1
== error_mark_node
|| e2
== error_mark_node
)
8228 e1
= TYPE_MAIN_VARIANT (e1
);
8229 e2
= TYPE_MAIN_VARIANT (e2
);
8232 = comptypes (e1
, e2
) ? integer_one_node
: integer_zero_node
;
8233 set_c_expr_source_range (&expr
, loc
, close_paren_loc
);
8236 case RID_BUILTIN_TGMATH
:
8238 vec
<c_expr_t
, va_gc
> *cexpr_list
;
8239 location_t close_paren_loc
;
8241 c_parser_consume_token (parser
);
8242 if (!c_parser_get_builtin_args (parser
,
8251 if (vec_safe_length (cexpr_list
) < 3)
8253 error_at (loc
, "too few arguments to %<__builtin_tgmath%>");
8260 FOR_EACH_VEC_ELT (*cexpr_list
, i
, p
)
8261 *p
= convert_lvalue_to_rvalue (loc
, *p
, true, true);
8262 unsigned int nargs
= check_tgmath_function (&(*cexpr_list
)[0], 1);
8268 if (vec_safe_length (cexpr_list
) < nargs
)
8270 error_at (loc
, "too few arguments to %<__builtin_tgmath%>");
8274 unsigned int num_functions
= vec_safe_length (cexpr_list
) - nargs
;
8275 if (num_functions
< 2)
8277 error_at (loc
, "too few arguments to %<__builtin_tgmath%>");
8282 /* The first NUM_FUNCTIONS expressions are the function
8283 pointers. The remaining NARGS expressions are the
8284 arguments that are to be passed to one of those
8285 functions, chosen following <tgmath.h> rules. */
8286 for (unsigned int j
= 1; j
< num_functions
; j
++)
8288 unsigned int this_nargs
8289 = check_tgmath_function (&(*cexpr_list
)[j
], j
+ 1);
8290 if (this_nargs
== 0)
8295 if (this_nargs
!= nargs
)
8297 error_at ((*cexpr_list
)[j
].get_location (),
8298 "argument %u of %<__builtin_tgmath%> has "
8299 "wrong number of arguments", j
+ 1);
8305 /* The functions all have the same number of arguments.
8306 Determine whether arguments and return types vary in
8307 ways permitted for <tgmath.h> functions. */
8308 /* The first entry in each of these vectors is for the
8309 return type, subsequent entries for parameter
8311 auto_vec
<enum tgmath_parm_kind
> parm_kind (nargs
+ 1);
8312 auto_vec
<tree
> parm_first (nargs
+ 1);
8313 auto_vec
<bool> parm_complex (nargs
+ 1);
8314 auto_vec
<bool> parm_varies (nargs
+ 1);
8315 tree first_type
= TREE_TYPE (TREE_TYPE ((*cexpr_list
)[0].value
));
8316 tree first_ret
= TYPE_MAIN_VARIANT (TREE_TYPE (first_type
));
8317 parm_first
.quick_push (first_ret
);
8318 parm_complex
.quick_push (TREE_CODE (first_ret
) == COMPLEX_TYPE
);
8319 parm_varies
.quick_push (false);
8320 function_args_iterator iter
;
8322 unsigned int argpos
;
8323 FOREACH_FUNCTION_ARGS (first_type
, t
, iter
)
8325 if (t
== void_type_node
)
8327 parm_first
.quick_push (TYPE_MAIN_VARIANT (t
));
8328 parm_complex
.quick_push (TREE_CODE (t
) == COMPLEX_TYPE
);
8329 parm_varies
.quick_push (false);
8331 for (unsigned int j
= 1; j
< num_functions
; j
++)
8333 tree type
= TREE_TYPE (TREE_TYPE ((*cexpr_list
)[j
].value
));
8334 tree ret
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
8335 if (ret
!= parm_first
[0])
8337 parm_varies
[0] = true;
8338 if (!SCALAR_FLOAT_TYPE_P (parm_first
[0])
8339 && !COMPLEX_FLOAT_TYPE_P (parm_first
[0]))
8341 error_at ((*cexpr_list
)[0].get_location (),
8342 "invalid type-generic return type for "
8343 "argument %u of %<__builtin_tgmath%>",
8348 if (!SCALAR_FLOAT_TYPE_P (ret
)
8349 && !COMPLEX_FLOAT_TYPE_P (ret
))
8351 error_at ((*cexpr_list
)[j
].get_location (),
8352 "invalid type-generic return type for "
8353 "argument %u of %<__builtin_tgmath%>",
8359 if (TREE_CODE (ret
) == COMPLEX_TYPE
)
8360 parm_complex
[0] = true;
8362 FOREACH_FUNCTION_ARGS (type
, t
, iter
)
8364 if (t
== void_type_node
)
8366 t
= TYPE_MAIN_VARIANT (t
);
8367 if (t
!= parm_first
[argpos
])
8369 parm_varies
[argpos
] = true;
8370 if (!SCALAR_FLOAT_TYPE_P (parm_first
[argpos
])
8371 && !COMPLEX_FLOAT_TYPE_P (parm_first
[argpos
]))
8373 error_at ((*cexpr_list
)[0].get_location (),
8374 "invalid type-generic type for "
8375 "argument %u of argument %u of "
8376 "%<__builtin_tgmath%>", argpos
, 1);
8380 if (!SCALAR_FLOAT_TYPE_P (t
)
8381 && !COMPLEX_FLOAT_TYPE_P (t
))
8383 error_at ((*cexpr_list
)[j
].get_location (),
8384 "invalid type-generic type for "
8385 "argument %u of argument %u of "
8386 "%<__builtin_tgmath%>", argpos
, j
+ 1);
8391 if (TREE_CODE (t
) == COMPLEX_TYPE
)
8392 parm_complex
[argpos
] = true;
8396 enum tgmath_parm_kind max_variation
= tgmath_fixed
;
8397 for (unsigned int j
= 0; j
<= nargs
; j
++)
8399 enum tgmath_parm_kind this_kind
;
8402 if (parm_complex
[j
])
8403 max_variation
= this_kind
= tgmath_complex
;
8406 this_kind
= tgmath_real
;
8407 if (max_variation
!= tgmath_complex
)
8408 max_variation
= tgmath_real
;
8412 this_kind
= tgmath_fixed
;
8413 parm_kind
.quick_push (this_kind
);
8415 if (max_variation
== tgmath_fixed
)
8417 error_at (loc
, "function arguments of %<__builtin_tgmath%> "
8418 "all have the same type");
8423 /* Identify a parameter (not the return type) that varies,
8424 including with complex types if any variation includes
8425 complex types; there must be at least one such
8427 unsigned int tgarg
= 0;
8428 for (unsigned int j
= 1; j
<= nargs
; j
++)
8429 if (parm_kind
[j
] == max_variation
)
8436 error_at (loc
, "function arguments of %<__builtin_tgmath%> "
8437 "lack type-generic parameter");
8442 /* Determine the type of the relevant parameter for each
8444 auto_vec
<tree
> tg_type (num_functions
);
8445 for (unsigned int j
= 0; j
< num_functions
; j
++)
8447 tree type
= TREE_TYPE (TREE_TYPE ((*cexpr_list
)[j
].value
));
8449 FOREACH_FUNCTION_ARGS (type
, t
, iter
)
8451 if (argpos
== tgarg
)
8453 tg_type
.quick_push (TYPE_MAIN_VARIANT (t
));
8460 /* Verify that the corresponding types are different for
8461 all the listed functions. Also determine whether all
8462 the types are complex, whether all the types are
8463 standard or binary, and whether all the types are
8465 bool all_complex
= true;
8466 bool all_binary
= true;
8467 bool all_decimal
= true;
8468 hash_set
<tree
> tg_types
;
8469 FOR_EACH_VEC_ELT (tg_type
, i
, t
)
8471 if (TREE_CODE (t
) == COMPLEX_TYPE
)
8472 all_decimal
= false;
8475 all_complex
= false;
8476 if (DECIMAL_FLOAT_TYPE_P (t
))
8479 all_decimal
= false;
8481 if (tg_types
.add (t
))
8483 error_at ((*cexpr_list
)[i
].get_location (),
8484 "duplicate type-generic parameter type for "
8485 "function argument %u of %<__builtin_tgmath%>",
8492 /* Verify that other parameters and the return type whose
8493 types vary have their types varying in the correct
8495 for (unsigned int j
= 0; j
< num_functions
; j
++)
8497 tree exp_type
= tg_type
[j
];
8498 tree exp_real_type
= exp_type
;
8499 if (TREE_CODE (exp_type
) == COMPLEX_TYPE
)
8500 exp_real_type
= TREE_TYPE (exp_type
);
8501 tree type
= TREE_TYPE (TREE_TYPE ((*cexpr_list
)[j
].value
));
8502 tree ret
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
8503 if ((parm_kind
[0] == tgmath_complex
&& ret
!= exp_type
)
8504 || (parm_kind
[0] == tgmath_real
&& ret
!= exp_real_type
))
8506 error_at ((*cexpr_list
)[j
].get_location (),
8507 "bad return type for function argument %u "
8508 "of %<__builtin_tgmath%>", j
+ 1);
8513 FOREACH_FUNCTION_ARGS (type
, t
, iter
)
8515 if (t
== void_type_node
)
8517 t
= TYPE_MAIN_VARIANT (t
);
8518 if ((parm_kind
[argpos
] == tgmath_complex
8520 || (parm_kind
[argpos
] == tgmath_real
8521 && t
!= exp_real_type
))
8523 error_at ((*cexpr_list
)[j
].get_location (),
8524 "bad type for argument %u of "
8525 "function argument %u of "
8526 "%<__builtin_tgmath%>", argpos
, j
+ 1);
8534 /* The functions listed are a valid set of functions for a
8535 <tgmath.h> macro to select between. Identify the
8536 matching function, if any. First, the argument types
8537 must be combined following <tgmath.h> rules. Integer
8538 types are treated as _Decimal64 if any type-generic
8539 argument is decimal, or if the only alternatives for
8540 type-generic arguments are of decimal types, and are
8541 otherwise treated as double (or _Complex double for
8542 complex integer types, or _Float64 or _Complex _Float64
8543 if all the return types are the same _FloatN or
8544 _FloatNx type). After that adjustment, types are
8545 combined following the usual arithmetic conversions.
8546 If the function only accepts complex arguments, a
8547 complex type is produced. */
8548 bool arg_complex
= all_complex
;
8549 bool arg_binary
= all_binary
;
8550 bool arg_int_decimal
= all_decimal
;
8551 for (unsigned int j
= 1; j
<= nargs
; j
++)
8553 if (parm_kind
[j
] == tgmath_fixed
)
8555 c_expr_t
*ce
= &(*cexpr_list
)[num_functions
+ j
- 1];
8556 tree type
= TREE_TYPE (ce
->value
);
8557 if (!INTEGRAL_TYPE_P (type
)
8558 && !SCALAR_FLOAT_TYPE_P (type
)
8559 && TREE_CODE (type
) != COMPLEX_TYPE
)
8561 error_at (ce
->get_location (),
8562 "invalid type of argument %u of type-generic "
8567 if (DECIMAL_FLOAT_TYPE_P (type
))
8569 arg_int_decimal
= true;
8572 error_at (ce
->get_location (),
8573 "decimal floating-point argument %u to "
8574 "complex-only type-generic function", j
);
8578 else if (all_binary
)
8580 error_at (ce
->get_location (),
8581 "decimal floating-point argument %u to "
8582 "binary-only type-generic function", j
);
8586 else if (arg_complex
)
8588 error_at (ce
->get_location (),
8589 "both complex and decimal floating-point "
8590 "arguments to type-generic function");
8594 else if (arg_binary
)
8596 error_at (ce
->get_location (),
8597 "both binary and decimal floating-point "
8598 "arguments to type-generic function");
8603 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
8606 if (COMPLEX_FLOAT_TYPE_P (type
))
8610 error_at (ce
->get_location (),
8611 "complex argument %u to "
8612 "decimal-only type-generic function", j
);
8616 else if (arg_int_decimal
)
8618 error_at (ce
->get_location (),
8619 "both complex and decimal floating-point "
8620 "arguments to type-generic function");
8625 else if (SCALAR_FLOAT_TYPE_P (type
))
8630 error_at (ce
->get_location (),
8631 "binary argument %u to "
8632 "decimal-only type-generic function", j
);
8636 else if (arg_int_decimal
)
8638 error_at (ce
->get_location (),
8639 "both binary and decimal floating-point "
8640 "arguments to type-generic function");
8646 /* For a macro rounding its result to a narrower type, map
8647 integer types to _Float64 not double if the return type
8648 is a _FloatN or _FloatNx type. */
8649 bool arg_int_float64
= false;
8650 if (parm_kind
[0] == tgmath_fixed
8651 && SCALAR_FLOAT_TYPE_P (parm_first
[0])
8652 && float64_type_node
!= NULL_TREE
)
8653 for (unsigned int j
= 0; j
< NUM_FLOATN_NX_TYPES
; j
++)
8654 if (parm_first
[0] == FLOATN_TYPE_NODE (j
))
8656 arg_int_float64
= true;
8659 tree arg_real
= NULL_TREE
;
8660 for (unsigned int j
= 1; j
<= nargs
; j
++)
8662 if (parm_kind
[j
] == tgmath_fixed
)
8664 c_expr_t
*ce
= &(*cexpr_list
)[num_functions
+ j
- 1];
8665 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (ce
->value
));
8666 if (TREE_CODE (type
) == COMPLEX_TYPE
)
8667 type
= TREE_TYPE (type
);
8668 if (INTEGRAL_TYPE_P (type
))
8669 type
= (arg_int_decimal
8670 ? dfloat64_type_node
8673 : double_type_node
);
8674 if (arg_real
== NULL_TREE
)
8677 arg_real
= common_type (arg_real
, type
);
8678 if (arg_real
== error_mark_node
)
8684 tree arg_type
= (arg_complex
8685 ? build_complex_type (arg_real
)
8688 /* Look for a function to call with type-generic parameter
8690 c_expr_t
*fn
= NULL
;
8691 for (unsigned int j
= 0; j
< num_functions
; j
++)
8693 if (tg_type
[j
] == arg_type
)
8695 fn
= &(*cexpr_list
)[j
];
8700 && parm_kind
[0] == tgmath_fixed
8701 && SCALAR_FLOAT_TYPE_P (parm_first
[0]))
8703 /* Presume this is a macro that rounds its result to a
8704 narrower type, and look for the first function with
8705 at least the range and precision of the argument
8707 for (unsigned int j
= 0; j
< num_functions
; j
++)
8710 != (TREE_CODE (tg_type
[j
]) == COMPLEX_TYPE
))
8712 tree real_tg_type
= (arg_complex
8713 ? TREE_TYPE (tg_type
[j
])
8715 if (DECIMAL_FLOAT_TYPE_P (arg_real
)
8716 != DECIMAL_FLOAT_TYPE_P (real_tg_type
))
8718 scalar_float_mode arg_mode
8719 = SCALAR_FLOAT_TYPE_MODE (arg_real
);
8720 scalar_float_mode tg_mode
8721 = SCALAR_FLOAT_TYPE_MODE (real_tg_type
);
8722 const real_format
*arg_fmt
= REAL_MODE_FORMAT (arg_mode
);
8723 const real_format
*tg_fmt
= REAL_MODE_FORMAT (tg_mode
);
8724 if (arg_fmt
->b
== tg_fmt
->b
8725 && arg_fmt
->p
<= tg_fmt
->p
8726 && arg_fmt
->emax
<= tg_fmt
->emax
8727 && (arg_fmt
->emin
- arg_fmt
->p
8728 >= tg_fmt
->emin
- tg_fmt
->p
))
8730 fn
= &(*cexpr_list
)[j
];
8737 error_at (loc
, "no matching function for type-generic call");
8742 /* Construct a call to FN. */
8743 vec
<tree
, va_gc
> *args
;
8744 vec_alloc (args
, nargs
);
8745 vec
<tree
, va_gc
> *origtypes
;
8746 vec_alloc (origtypes
, nargs
);
8747 auto_vec
<location_t
> arg_loc (nargs
);
8748 for (unsigned int j
= 0; j
< nargs
; j
++)
8750 c_expr_t
*ce
= &(*cexpr_list
)[num_functions
+ j
];
8751 args
->quick_push (ce
->value
);
8752 arg_loc
.quick_push (ce
->get_location ());
8753 origtypes
->quick_push (ce
->original_type
);
8755 expr
.value
= c_build_function_call_vec (loc
, arg_loc
, fn
->value
,
8757 set_c_expr_source_range (&expr
, loc
, close_paren_loc
);
8760 case RID_BUILTIN_CALL_WITH_STATIC_CHAIN
:
8762 vec
<c_expr_t
, va_gc
> *cexpr_list
;
8765 location_t close_paren_loc
;
8767 c_parser_consume_token (parser
);
8768 if (!c_parser_get_builtin_args (parser
,
8769 "__builtin_call_with_static_chain",
8776 if (vec_safe_length (cexpr_list
) != 2)
8778 error_at (loc
, "wrong number of arguments to "
8779 "%<__builtin_call_with_static_chain%>");
8784 expr
= (*cexpr_list
)[0];
8785 e2_p
= &(*cexpr_list
)[1];
8786 *e2_p
= convert_lvalue_to_rvalue (loc
, *e2_p
, true, true);
8787 chain_value
= e2_p
->value
;
8788 mark_exp_read (chain_value
);
8790 if (TREE_CODE (expr
.value
) != CALL_EXPR
)
8791 error_at (loc
, "first argument to "
8792 "%<__builtin_call_with_static_chain%> "
8793 "must be a call expression");
8794 else if (TREE_CODE (TREE_TYPE (chain_value
)) != POINTER_TYPE
)
8795 error_at (loc
, "second argument to "
8796 "%<__builtin_call_with_static_chain%> "
8797 "must be a pointer type");
8799 CALL_EXPR_STATIC_CHAIN (expr
.value
) = chain_value
;
8800 set_c_expr_source_range (&expr
, loc
, close_paren_loc
);
8803 case RID_BUILTIN_COMPLEX
:
8805 vec
<c_expr_t
, va_gc
> *cexpr_list
;
8806 c_expr_t
*e1_p
, *e2_p
;
8807 location_t close_paren_loc
;
8809 c_parser_consume_token (parser
);
8810 if (!c_parser_get_builtin_args (parser
,
8811 "__builtin_complex",
8819 if (vec_safe_length (cexpr_list
) != 2)
8821 error_at (loc
, "wrong number of arguments to "
8822 "%<__builtin_complex%>");
8827 e1_p
= &(*cexpr_list
)[0];
8828 e2_p
= &(*cexpr_list
)[1];
8830 *e1_p
= convert_lvalue_to_rvalue (loc
, *e1_p
, true, true);
8831 if (TREE_CODE (e1_p
->value
) == EXCESS_PRECISION_EXPR
)
8832 e1_p
->value
= convert (TREE_TYPE (e1_p
->value
),
8833 TREE_OPERAND (e1_p
->value
, 0));
8834 *e2_p
= convert_lvalue_to_rvalue (loc
, *e2_p
, true, true);
8835 if (TREE_CODE (e2_p
->value
) == EXCESS_PRECISION_EXPR
)
8836 e2_p
->value
= convert (TREE_TYPE (e2_p
->value
),
8837 TREE_OPERAND (e2_p
->value
, 0));
8838 if (!SCALAR_FLOAT_TYPE_P (TREE_TYPE (e1_p
->value
))
8839 || DECIMAL_FLOAT_TYPE_P (TREE_TYPE (e1_p
->value
))
8840 || !SCALAR_FLOAT_TYPE_P (TREE_TYPE (e2_p
->value
))
8841 || DECIMAL_FLOAT_TYPE_P (TREE_TYPE (e2_p
->value
)))
8843 error_at (loc
, "%<__builtin_complex%> operand "
8844 "not of real binary floating-point type");
8848 if (TYPE_MAIN_VARIANT (TREE_TYPE (e1_p
->value
))
8849 != TYPE_MAIN_VARIANT (TREE_TYPE (e2_p
->value
)))
8852 "%<__builtin_complex%> operands of different types");
8856 pedwarn_c90 (loc
, OPT_Wpedantic
,
8857 "ISO C90 does not support complex types");
8858 expr
.value
= build2_loc (loc
, COMPLEX_EXPR
,
8861 (TREE_TYPE (e1_p
->value
))),
8862 e1_p
->value
, e2_p
->value
);
8863 set_c_expr_source_range (&expr
, loc
, close_paren_loc
);
8866 case RID_BUILTIN_SHUFFLE
:
8868 vec
<c_expr_t
, va_gc
> *cexpr_list
;
8871 location_t close_paren_loc
;
8873 c_parser_consume_token (parser
);
8874 if (!c_parser_get_builtin_args (parser
,
8875 "__builtin_shuffle",
8883 FOR_EACH_VEC_SAFE_ELT (cexpr_list
, i
, p
)
8884 *p
= convert_lvalue_to_rvalue (loc
, *p
, true, true);
8886 if (vec_safe_length (cexpr_list
) == 2)
8888 c_build_vec_perm_expr
8889 (loc
, (*cexpr_list
)[0].value
,
8890 NULL_TREE
, (*cexpr_list
)[1].value
);
8892 else if (vec_safe_length (cexpr_list
) == 3)
8894 c_build_vec_perm_expr
8895 (loc
, (*cexpr_list
)[0].value
,
8896 (*cexpr_list
)[1].value
,
8897 (*cexpr_list
)[2].value
);
8900 error_at (loc
, "wrong number of arguments to "
8901 "%<__builtin_shuffle%>");
8904 set_c_expr_source_range (&expr
, loc
, close_paren_loc
);
8907 case RID_AT_SELECTOR
:
8909 gcc_assert (c_dialect_objc ());
8910 c_parser_consume_token (parser
);
8911 matching_parens parens
;
8912 if (!parens
.require_open (parser
))
8917 tree sel
= c_parser_objc_selector_arg (parser
);
8918 location_t close_loc
= c_parser_peek_token (parser
)->location
;
8919 parens
.skip_until_found_close (parser
);
8920 expr
.value
= objc_build_selector_expr (loc
, sel
);
8921 set_c_expr_source_range (&expr
, loc
, close_loc
);
8924 case RID_AT_PROTOCOL
:
8926 gcc_assert (c_dialect_objc ());
8927 c_parser_consume_token (parser
);
8928 matching_parens parens
;
8929 if (!parens
.require_open (parser
))
8934 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
8936 c_parser_error (parser
, "expected identifier");
8937 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
8941 tree id
= c_parser_peek_token (parser
)->value
;
8942 c_parser_consume_token (parser
);
8943 location_t close_loc
= c_parser_peek_token (parser
)->location
;
8944 parens
.skip_until_found_close (parser
);
8945 expr
.value
= objc_build_protocol_expr (id
);
8946 set_c_expr_source_range (&expr
, loc
, close_loc
);
8951 /* Extension to support C-structures in the archiver. */
8952 gcc_assert (c_dialect_objc ());
8953 c_parser_consume_token (parser
);
8954 matching_parens parens
;
8955 if (!parens
.require_open (parser
))
8960 t1
= c_parser_type_name (parser
);
8964 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
8967 location_t close_loc
= c_parser_peek_token (parser
)->location
;
8968 parens
.skip_until_found_close (parser
);
8969 tree type
= groktypename (t1
, NULL
, NULL
);
8970 expr
.value
= objc_build_encode_expr (type
);
8971 set_c_expr_source_range (&expr
, loc
, close_loc
);
8975 expr
= c_parser_generic_selection (parser
);
8978 c_parser_error (parser
, "expected expression");
8983 case CPP_OPEN_SQUARE
:
8984 if (c_dialect_objc ())
8986 tree receiver
, args
;
8987 c_parser_consume_token (parser
);
8988 receiver
= c_parser_objc_receiver (parser
);
8989 args
= c_parser_objc_message_args (parser
);
8990 location_t close_loc
= c_parser_peek_token (parser
)->location
;
8991 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
8993 expr
.value
= objc_build_message_expr (receiver
, args
);
8994 set_c_expr_source_range (&expr
, loc
, close_loc
);
8997 /* Else fall through to report error. */
9000 c_parser_error (parser
, "expected expression");
9005 return c_parser_postfix_expression_after_primary
9006 (parser
, EXPR_LOC_OR_LOC (expr
.value
, loc
), expr
);
9009 /* Parse a postfix expression after a parenthesized type name: the
9010 brace-enclosed initializer of a compound literal, possibly followed
9011 by some postfix operators. This is separate because it is not
9012 possible to tell until after the type name whether a cast
9013 expression has a cast or a compound literal, or whether the operand
9014 of sizeof is a parenthesized type name or starts with a compound
9015 literal. TYPE_LOC is the location where TYPE_NAME starts--the
9016 location of the first token after the parentheses around the type
9019 static struct c_expr
9020 c_parser_postfix_expression_after_paren_type (c_parser
*parser
,
9021 struct c_type_name
*type_name
,
9022 location_t type_loc
)
9028 location_t start_loc
;
9029 tree type_expr
= NULL_TREE
;
9030 bool type_expr_const
= true;
9031 check_compound_literal_type (type_loc
, type_name
);
9032 rich_location
richloc (line_table
, type_loc
);
9033 start_init (NULL_TREE
, NULL
, 0, &richloc
);
9034 type
= groktypename (type_name
, &type_expr
, &type_expr_const
);
9035 start_loc
= c_parser_peek_token (parser
)->location
;
9036 if (type
!= error_mark_node
&& C_TYPE_VARIABLE_SIZE (type
))
9038 error_at (type_loc
, "compound literal has variable size");
9039 type
= error_mark_node
;
9041 init
= c_parser_braced_init (parser
, type
, false, NULL
);
9043 maybe_warn_string_init (type_loc
, type
, init
);
9045 if (type
!= error_mark_node
9046 && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type
))
9047 && current_function_decl
)
9049 error ("compound literal qualified by address-space qualifier");
9050 type
= error_mark_node
;
9053 pedwarn_c90 (start_loc
, OPT_Wpedantic
, "ISO C90 forbids compound literals");
9054 non_const
= ((init
.value
&& TREE_CODE (init
.value
) == CONSTRUCTOR
)
9055 ? CONSTRUCTOR_NON_CONST (init
.value
)
9056 : init
.original_code
== C_MAYBE_CONST_EXPR
);
9057 non_const
|= !type_expr_const
;
9058 unsigned int alignas_align
= 0;
9059 if (type
!= error_mark_node
9060 && type_name
->specs
->align_log
!= -1)
9062 alignas_align
= 1U << type_name
->specs
->align_log
;
9063 if (alignas_align
< min_align_of_type (type
))
9065 error_at (type_name
->specs
->locations
[cdw_alignas
],
9066 "%<_Alignas%> specifiers cannot reduce "
9067 "alignment of compound literal");
9071 expr
.value
= build_compound_literal (start_loc
, type
, init
.value
, non_const
,
9073 set_c_expr_source_range (&expr
, init
.src_range
);
9074 expr
.original_code
= ERROR_MARK
;
9075 expr
.original_type
= NULL
;
9076 if (type
!= error_mark_node
9077 && expr
.value
!= error_mark_node
9080 if (TREE_CODE (expr
.value
) == C_MAYBE_CONST_EXPR
)
9082 gcc_assert (C_MAYBE_CONST_EXPR_PRE (expr
.value
) == NULL_TREE
);
9083 C_MAYBE_CONST_EXPR_PRE (expr
.value
) = type_expr
;
9087 gcc_assert (!non_const
);
9088 expr
.value
= build2 (C_MAYBE_CONST_EXPR
, type
,
9089 type_expr
, expr
.value
);
9092 return c_parser_postfix_expression_after_primary (parser
, start_loc
, expr
);
9095 /* Callback function for sizeof_pointer_memaccess_warning to compare
9099 sizeof_ptr_memacc_comptypes (tree type1
, tree type2
)
9101 return comptypes (type1
, type2
) == 1;
9104 /* Parse a postfix expression after the initial primary or compound
9105 literal; that is, parse a series of postfix operators.
9107 EXPR_LOC is the location of the primary expression. */
9109 static struct c_expr
9110 c_parser_postfix_expression_after_primary (c_parser
*parser
,
9111 location_t expr_loc
,
9114 struct c_expr orig_expr
;
9116 location_t sizeof_arg_loc
[3], comp_loc
;
9118 unsigned int literal_zero_mask
;
9120 vec
<tree
, va_gc
> *exprlist
;
9121 vec
<tree
, va_gc
> *origtypes
= NULL
;
9122 vec
<location_t
> arg_loc
= vNULL
;
9128 location_t op_loc
= c_parser_peek_token (parser
)->location
;
9129 switch (c_parser_peek_token (parser
)->type
)
9131 case CPP_OPEN_SQUARE
:
9132 /* Array reference. */
9133 c_parser_consume_token (parser
);
9134 idx
= c_parser_expression (parser
).value
;
9135 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
9137 start
= expr
.get_start ();
9138 finish
= parser
->tokens_buf
[0].location
;
9139 expr
.value
= build_array_ref (op_loc
, expr
.value
, idx
);
9140 set_c_expr_source_range (&expr
, start
, finish
);
9141 expr
.original_code
= ERROR_MARK
;
9142 expr
.original_type
= NULL
;
9144 case CPP_OPEN_PAREN
:
9145 /* Function call. */
9146 c_parser_consume_token (parser
);
9147 for (i
= 0; i
< 3; i
++)
9149 sizeof_arg
[i
] = NULL_TREE
;
9150 sizeof_arg_loc
[i
] = UNKNOWN_LOCATION
;
9152 literal_zero_mask
= 0;
9153 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
9156 exprlist
= c_parser_expr_list (parser
, true, false, &origtypes
,
9157 sizeof_arg_loc
, sizeof_arg
,
9158 &arg_loc
, &literal_zero_mask
);
9159 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
9162 mark_exp_read (expr
.value
);
9163 if (warn_sizeof_pointer_memaccess
)
9164 sizeof_pointer_memaccess_warning (sizeof_arg_loc
,
9165 expr
.value
, exprlist
,
9167 sizeof_ptr_memacc_comptypes
);
9168 if (TREE_CODE (expr
.value
) == FUNCTION_DECL
9169 && fndecl_built_in_p (expr
.value
, BUILT_IN_MEMSET
)
9170 && vec_safe_length (exprlist
) == 3)
9172 tree arg0
= (*exprlist
)[0];
9173 tree arg2
= (*exprlist
)[2];
9174 warn_for_memset (expr_loc
, arg0
, arg2
, literal_zero_mask
);
9177 start
= expr
.get_start ();
9178 finish
= parser
->tokens_buf
[0].get_finish ();
9180 = c_build_function_call_vec (expr_loc
, arg_loc
, expr
.value
,
9181 exprlist
, origtypes
);
9182 set_c_expr_source_range (&expr
, start
, finish
);
9184 expr
.original_code
= ERROR_MARK
;
9185 if (TREE_CODE (expr
.value
) == INTEGER_CST
9186 && TREE_CODE (orig_expr
.value
) == FUNCTION_DECL
9187 && fndecl_built_in_p (orig_expr
.value
, BUILT_IN_CONSTANT_P
))
9188 expr
.original_code
= C_MAYBE_CONST_EXPR
;
9189 expr
.original_type
= NULL
;
9192 release_tree_vector (exprlist
);
9193 release_tree_vector (origtypes
);
9198 /* Structure element reference. */
9199 c_parser_consume_token (parser
);
9200 expr
= default_function_array_conversion (expr_loc
, expr
);
9201 if (c_parser_next_token_is (parser
, CPP_NAME
))
9203 c_token
*comp_tok
= c_parser_peek_token (parser
);
9204 ident
= comp_tok
->value
;
9205 comp_loc
= comp_tok
->location
;
9209 c_parser_error (parser
, "expected identifier");
9211 expr
.original_code
= ERROR_MARK
;
9212 expr
.original_type
= NULL
;
9215 start
= expr
.get_start ();
9216 finish
= c_parser_peek_token (parser
)->get_finish ();
9217 c_parser_consume_token (parser
);
9218 expr
.value
= build_component_ref (op_loc
, expr
.value
, ident
,
9220 set_c_expr_source_range (&expr
, start
, finish
);
9221 expr
.original_code
= ERROR_MARK
;
9222 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
9223 expr
.original_type
= NULL
;
9226 /* Remember the original type of a bitfield. */
9227 tree field
= TREE_OPERAND (expr
.value
, 1);
9228 if (TREE_CODE (field
) != FIELD_DECL
)
9229 expr
.original_type
= NULL
;
9231 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
9235 /* Structure element reference. */
9236 c_parser_consume_token (parser
);
9237 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, true, false);
9238 if (c_parser_next_token_is (parser
, CPP_NAME
))
9240 c_token
*comp_tok
= c_parser_peek_token (parser
);
9241 ident
= comp_tok
->value
;
9242 comp_loc
= comp_tok
->location
;
9246 c_parser_error (parser
, "expected identifier");
9248 expr
.original_code
= ERROR_MARK
;
9249 expr
.original_type
= NULL
;
9252 start
= expr
.get_start ();
9253 finish
= c_parser_peek_token (parser
)->get_finish ();
9254 c_parser_consume_token (parser
);
9255 expr
.value
= build_component_ref (op_loc
,
9256 build_indirect_ref (op_loc
,
9260 set_c_expr_source_range (&expr
, start
, finish
);
9261 expr
.original_code
= ERROR_MARK
;
9262 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
9263 expr
.original_type
= NULL
;
9266 /* Remember the original type of a bitfield. */
9267 tree field
= TREE_OPERAND (expr
.value
, 1);
9268 if (TREE_CODE (field
) != FIELD_DECL
)
9269 expr
.original_type
= NULL
;
9271 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
9275 /* Postincrement. */
9276 start
= expr
.get_start ();
9277 finish
= c_parser_peek_token (parser
)->get_finish ();
9278 c_parser_consume_token (parser
);
9279 expr
= default_function_array_read_conversion (expr_loc
, expr
);
9280 expr
.value
= build_unary_op (op_loc
, POSTINCREMENT_EXPR
,
9282 set_c_expr_source_range (&expr
, start
, finish
);
9283 expr
.original_code
= ERROR_MARK
;
9284 expr
.original_type
= NULL
;
9286 case CPP_MINUS_MINUS
:
9287 /* Postdecrement. */
9288 start
= expr
.get_start ();
9289 finish
= c_parser_peek_token (parser
)->get_finish ();
9290 c_parser_consume_token (parser
);
9291 expr
= default_function_array_read_conversion (expr_loc
, expr
);
9292 expr
.value
= build_unary_op (op_loc
, POSTDECREMENT_EXPR
,
9294 set_c_expr_source_range (&expr
, start
, finish
);
9295 expr
.original_code
= ERROR_MARK
;
9296 expr
.original_type
= NULL
;
9304 /* Parse an expression (C90 6.3.17, C99 6.5.17, C11 6.5.17).
9307 assignment-expression
9308 expression , assignment-expression
9311 static struct c_expr
9312 c_parser_expression (c_parser
*parser
)
9314 location_t tloc
= c_parser_peek_token (parser
)->location
;
9316 expr
= c_parser_expr_no_commas (parser
, NULL
);
9317 if (c_parser_next_token_is (parser
, CPP_COMMA
))
9318 expr
= convert_lvalue_to_rvalue (tloc
, expr
, true, false);
9319 while (c_parser_next_token_is (parser
, CPP_COMMA
))
9323 location_t loc
= c_parser_peek_token (parser
)->location
;
9324 location_t expr_loc
;
9325 c_parser_consume_token (parser
);
9326 expr_loc
= c_parser_peek_token (parser
)->location
;
9327 lhsval
= expr
.value
;
9328 while (TREE_CODE (lhsval
) == COMPOUND_EXPR
)
9329 lhsval
= TREE_OPERAND (lhsval
, 1);
9330 if (DECL_P (lhsval
) || handled_component_p (lhsval
))
9331 mark_exp_read (lhsval
);
9332 next
= c_parser_expr_no_commas (parser
, NULL
);
9333 next
= convert_lvalue_to_rvalue (expr_loc
, next
, true, false);
9334 expr
.value
= build_compound_expr (loc
, expr
.value
, next
.value
);
9335 expr
.original_code
= COMPOUND_EXPR
;
9336 expr
.original_type
= next
.original_type
;
9341 /* Parse an expression and convert functions or arrays to pointers and
9342 lvalues to rvalues. */
9344 static struct c_expr
9345 c_parser_expression_conv (c_parser
*parser
)
9348 location_t loc
= c_parser_peek_token (parser
)->location
;
9349 expr
= c_parser_expression (parser
);
9350 expr
= convert_lvalue_to_rvalue (loc
, expr
, true, false);
9354 /* Helper function of c_parser_expr_list. Check if IDXth (0 based)
9355 argument is a literal zero alone and if so, set it in literal_zero_mask. */
9358 c_parser_check_literal_zero (c_parser
*parser
, unsigned *literal_zero_mask
,
9361 if (idx
>= HOST_BITS_PER_INT
)
9364 c_token
*tok
= c_parser_peek_token (parser
);
9372 /* If a parameter is literal zero alone, remember it
9373 for -Wmemset-transposed-args warning. */
9374 if (integer_zerop (tok
->value
)
9375 && !TREE_OVERFLOW (tok
->value
)
9376 && (c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
9377 || c_parser_peek_2nd_token (parser
)->type
== CPP_CLOSE_PAREN
))
9378 *literal_zero_mask
|= 1U << idx
;
9384 /* Parse a non-empty list of expressions. If CONVERT_P, convert
9385 functions and arrays to pointers and lvalues to rvalues. If
9386 FOLD_P, fold the expressions. If LOCATIONS is non-NULL, save the
9387 locations of function arguments into this vector.
9390 assignment-expression
9391 nonempty-expr-list , assignment-expression
9394 static vec
<tree
, va_gc
> *
9395 c_parser_expr_list (c_parser
*parser
, bool convert_p
, bool fold_p
,
9396 vec
<tree
, va_gc
> **p_orig_types
,
9397 location_t
*sizeof_arg_loc
, tree
*sizeof_arg
,
9398 vec
<location_t
> *locations
,
9399 unsigned int *literal_zero_mask
)
9401 vec
<tree
, va_gc
> *ret
;
9402 vec
<tree
, va_gc
> *orig_types
;
9404 unsigned int idx
= 0;
9406 ret
= make_tree_vector ();
9407 if (p_orig_types
== NULL
)
9410 orig_types
= make_tree_vector ();
9412 if (literal_zero_mask
)
9413 c_parser_check_literal_zero (parser
, literal_zero_mask
, 0);
9414 expr
= c_parser_expr_no_commas (parser
, NULL
);
9416 expr
= convert_lvalue_to_rvalue (expr
.get_location (), expr
, true, true);
9418 expr
.value
= c_fully_fold (expr
.value
, false, NULL
);
9419 ret
->quick_push (expr
.value
);
9421 orig_types
->quick_push (expr
.original_type
);
9423 locations
->safe_push (expr
.get_location ());
9424 if (sizeof_arg
!= NULL
9425 && expr
.original_code
== SIZEOF_EXPR
)
9427 sizeof_arg
[0] = c_last_sizeof_arg
;
9428 sizeof_arg_loc
[0] = c_last_sizeof_loc
;
9430 while (c_parser_next_token_is (parser
, CPP_COMMA
))
9432 c_parser_consume_token (parser
);
9433 if (literal_zero_mask
)
9434 c_parser_check_literal_zero (parser
, literal_zero_mask
, idx
+ 1);
9435 expr
= c_parser_expr_no_commas (parser
, NULL
);
9437 expr
= convert_lvalue_to_rvalue (expr
.get_location (), expr
, true,
9440 expr
.value
= c_fully_fold (expr
.value
, false, NULL
);
9441 vec_safe_push (ret
, expr
.value
);
9443 vec_safe_push (orig_types
, expr
.original_type
);
9445 locations
->safe_push (expr
.get_location ());
9447 && sizeof_arg
!= NULL
9448 && expr
.original_code
== SIZEOF_EXPR
)
9450 sizeof_arg
[idx
] = c_last_sizeof_arg
;
9451 sizeof_arg_loc
[idx
] = c_last_sizeof_loc
;
9455 *p_orig_types
= orig_types
;
9459 /* Parse Objective-C-specific constructs. */
9461 /* Parse an objc-class-definition.
9463 objc-class-definition:
9464 @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
9465 objc-class-instance-variables[opt] objc-methodprotolist @end
9466 @implementation identifier objc-superclass[opt]
9467 objc-class-instance-variables[opt]
9468 @interface identifier ( identifier ) objc-protocol-refs[opt]
9469 objc-methodprotolist @end
9470 @interface identifier ( ) objc-protocol-refs[opt]
9471 objc-methodprotolist @end
9472 @implementation identifier ( identifier )
9477 "@interface identifier (" must start "@interface identifier (
9478 identifier ) ...": objc-methodprotolist in the first production may
9479 not start with a parenthesized identifier as a declarator of a data
9480 definition with no declaration specifiers if the objc-superclass,
9481 objc-protocol-refs and objc-class-instance-variables are omitted. */
9484 c_parser_objc_class_definition (c_parser
*parser
, tree attributes
)
9489 if (c_parser_next_token_is_keyword (parser
, RID_AT_INTERFACE
))
9491 else if (c_parser_next_token_is_keyword (parser
, RID_AT_IMPLEMENTATION
))
9496 c_parser_consume_token (parser
);
9497 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
9499 c_parser_error (parser
, "expected identifier");
9502 id1
= c_parser_peek_token (parser
)->value
;
9503 c_parser_consume_token (parser
);
9504 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
9506 /* We have a category or class extension. */
9508 tree proto
= NULL_TREE
;
9509 matching_parens parens
;
9510 parens
.consume_open (parser
);
9511 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
9513 if (iface_p
&& c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
9515 /* We have a class extension. */
9520 c_parser_error (parser
, "expected identifier or %<)%>");
9521 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
9527 id2
= c_parser_peek_token (parser
)->value
;
9528 c_parser_consume_token (parser
);
9530 parens
.skip_until_found_close (parser
);
9533 objc_start_category_implementation (id1
, id2
);
9536 if (c_parser_next_token_is (parser
, CPP_LESS
))
9537 proto
= c_parser_objc_protocol_refs (parser
);
9538 objc_start_category_interface (id1
, id2
, proto
, attributes
);
9539 c_parser_objc_methodprotolist (parser
);
9540 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
9541 objc_finish_interface ();
9544 if (c_parser_next_token_is (parser
, CPP_COLON
))
9546 c_parser_consume_token (parser
);
9547 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
9549 c_parser_error (parser
, "expected identifier");
9552 superclass
= c_parser_peek_token (parser
)->value
;
9553 c_parser_consume_token (parser
);
9556 superclass
= NULL_TREE
;
9559 tree proto
= NULL_TREE
;
9560 if (c_parser_next_token_is (parser
, CPP_LESS
))
9561 proto
= c_parser_objc_protocol_refs (parser
);
9562 objc_start_class_interface (id1
, superclass
, proto
, attributes
);
9565 objc_start_class_implementation (id1
, superclass
);
9566 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
9567 c_parser_objc_class_instance_variables (parser
);
9570 objc_continue_interface ();
9571 c_parser_objc_methodprotolist (parser
);
9572 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
9573 objc_finish_interface ();
9577 objc_continue_implementation ();
9582 /* Parse objc-class-instance-variables.
9584 objc-class-instance-variables:
9585 { objc-instance-variable-decl-list[opt] }
9587 objc-instance-variable-decl-list:
9588 objc-visibility-spec
9589 objc-instance-variable-decl ;
9591 objc-instance-variable-decl-list objc-visibility-spec
9592 objc-instance-variable-decl-list objc-instance-variable-decl ;
9593 objc-instance-variable-decl-list ;
9595 objc-visibility-spec:
9600 objc-instance-variable-decl:
9605 c_parser_objc_class_instance_variables (c_parser
*parser
)
9607 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
9608 c_parser_consume_token (parser
);
9609 while (c_parser_next_token_is_not (parser
, CPP_EOF
))
9612 /* Parse any stray semicolon. */
9613 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
9615 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
9617 c_parser_consume_token (parser
);
9620 /* Stop if at the end of the instance variables. */
9621 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
9623 c_parser_consume_token (parser
);
9626 /* Parse any objc-visibility-spec. */
9627 if (c_parser_next_token_is_keyword (parser
, RID_AT_PRIVATE
))
9629 c_parser_consume_token (parser
);
9630 objc_set_visibility (OBJC_IVAR_VIS_PRIVATE
);
9633 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PROTECTED
))
9635 c_parser_consume_token (parser
);
9636 objc_set_visibility (OBJC_IVAR_VIS_PROTECTED
);
9639 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PUBLIC
))
9641 c_parser_consume_token (parser
);
9642 objc_set_visibility (OBJC_IVAR_VIS_PUBLIC
);
9645 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PACKAGE
))
9647 c_parser_consume_token (parser
);
9648 objc_set_visibility (OBJC_IVAR_VIS_PACKAGE
);
9651 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
9653 c_parser_pragma (parser
, pragma_external
, NULL
);
9657 /* Parse some comma-separated declarations. */
9658 decls
= c_parser_struct_declaration (parser
);
9661 /* There is a syntax error. We want to skip the offending
9662 tokens up to the next ';' (included) or '}'
9665 /* First, skip manually a ')' or ']'. This is because they
9666 reduce the nesting level, so c_parser_skip_until_found()
9667 wouldn't be able to skip past them. */
9668 c_token
*token
= c_parser_peek_token (parser
);
9669 if (token
->type
== CPP_CLOSE_PAREN
|| token
->type
== CPP_CLOSE_SQUARE
)
9670 c_parser_consume_token (parser
);
9672 /* Then, do the standard skipping. */
9673 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
9675 /* We hopefully recovered. Start normal parsing again. */
9676 parser
->error
= false;
9681 /* Comma-separated instance variables are chained together
9682 in reverse order; add them one by one. */
9683 tree ivar
= nreverse (decls
);
9684 for (; ivar
; ivar
= DECL_CHAIN (ivar
))
9685 objc_add_instance_variable (copy_node (ivar
));
9687 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
9691 /* Parse an objc-class-declaration.
9693 objc-class-declaration:
9694 @class identifier-list ;
9698 c_parser_objc_class_declaration (c_parser
*parser
)
9700 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_CLASS
));
9701 c_parser_consume_token (parser
);
9702 /* Any identifiers, including those declared as type names, are OK
9707 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
9709 c_parser_error (parser
, "expected identifier");
9710 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
9711 parser
->error
= false;
9714 id
= c_parser_peek_token (parser
)->value
;
9715 objc_declare_class (id
);
9716 c_parser_consume_token (parser
);
9717 if (c_parser_next_token_is (parser
, CPP_COMMA
))
9718 c_parser_consume_token (parser
);
9722 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
9725 /* Parse an objc-alias-declaration.
9727 objc-alias-declaration:
9728 @compatibility_alias identifier identifier ;
9732 c_parser_objc_alias_declaration (c_parser
*parser
)
9735 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_ALIAS
));
9736 c_parser_consume_token (parser
);
9737 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
9739 c_parser_error (parser
, "expected identifier");
9740 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
9743 id1
= c_parser_peek_token (parser
)->value
;
9744 c_parser_consume_token (parser
);
9745 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
9747 c_parser_error (parser
, "expected identifier");
9748 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
9751 id2
= c_parser_peek_token (parser
)->value
;
9752 c_parser_consume_token (parser
);
9753 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
9754 objc_declare_alias (id1
, id2
);
9757 /* Parse an objc-protocol-definition.
9759 objc-protocol-definition:
9760 @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
9761 @protocol identifier-list ;
9763 "@protocol identifier ;" should be resolved as "@protocol
9764 identifier-list ;": objc-methodprotolist may not start with a
9765 semicolon in the first alternative if objc-protocol-refs are
9769 c_parser_objc_protocol_definition (c_parser
*parser
, tree attributes
)
9771 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_PROTOCOL
));
9773 c_parser_consume_token (parser
);
9774 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
9776 c_parser_error (parser
, "expected identifier");
9779 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
9780 || c_parser_peek_2nd_token (parser
)->type
== CPP_SEMICOLON
)
9782 /* Any identifiers, including those declared as type names, are
9787 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
9789 c_parser_error (parser
, "expected identifier");
9792 id
= c_parser_peek_token (parser
)->value
;
9793 objc_declare_protocol (id
, attributes
);
9794 c_parser_consume_token (parser
);
9795 if (c_parser_next_token_is (parser
, CPP_COMMA
))
9796 c_parser_consume_token (parser
);
9800 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
9804 tree id
= c_parser_peek_token (parser
)->value
;
9805 tree proto
= NULL_TREE
;
9806 c_parser_consume_token (parser
);
9807 if (c_parser_next_token_is (parser
, CPP_LESS
))
9808 proto
= c_parser_objc_protocol_refs (parser
);
9809 parser
->objc_pq_context
= true;
9810 objc_start_protocol (id
, proto
, attributes
);
9811 c_parser_objc_methodprotolist (parser
);
9812 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
9813 parser
->objc_pq_context
= false;
9814 objc_finish_interface ();
9818 /* Parse an objc-method-type.
9824 Return true if it is a class method (+) and false if it is
9825 an instance method (-).
9828 c_parser_objc_method_type (c_parser
*parser
)
9830 switch (c_parser_peek_token (parser
)->type
)
9833 c_parser_consume_token (parser
);
9836 c_parser_consume_token (parser
);
9843 /* Parse an objc-method-definition.
9845 objc-method-definition:
9846 objc-method-type objc-method-decl ;[opt] compound-statement
9850 c_parser_objc_method_definition (c_parser
*parser
)
9852 bool is_class_method
= c_parser_objc_method_type (parser
);
9853 tree decl
, attributes
= NULL_TREE
, expr
= NULL_TREE
;
9854 parser
->objc_pq_context
= true;
9855 decl
= c_parser_objc_method_decl (parser
, is_class_method
, &attributes
,
9857 if (decl
== error_mark_node
)
9858 return; /* Bail here. */
9860 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
9862 c_parser_consume_token (parser
);
9863 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
9864 "extra semicolon in method definition specified");
9867 if (!c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
9869 c_parser_error (parser
, "expected %<{%>");
9873 parser
->objc_pq_context
= false;
9874 if (objc_start_method_definition (is_class_method
, decl
, attributes
, expr
))
9876 add_stmt (c_parser_compound_statement (parser
));
9877 objc_finish_method_definition (current_function_decl
);
9881 /* This code is executed when we find a method definition
9882 outside of an @implementation context (or invalid for other
9883 reasons). Parse the method (to keep going) but do not emit
9886 c_parser_compound_statement (parser
);
9890 /* Parse an objc-methodprotolist.
9892 objc-methodprotolist:
9894 objc-methodprotolist objc-methodproto
9895 objc-methodprotolist declaration
9896 objc-methodprotolist ;
9900 The declaration is a data definition, which may be missing
9901 declaration specifiers under the same rules and diagnostics as
9902 other data definitions outside functions, and the stray semicolon
9903 is diagnosed the same way as a stray semicolon outside a
9907 c_parser_objc_methodprotolist (c_parser
*parser
)
9911 /* The list is terminated by @end. */
9912 switch (c_parser_peek_token (parser
)->type
)
9915 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
9916 "ISO C does not allow extra %<;%> outside of a function");
9917 c_parser_consume_token (parser
);
9921 c_parser_objc_methodproto (parser
);
9924 c_parser_pragma (parser
, pragma_external
, NULL
);
9929 if (c_parser_next_token_is_keyword (parser
, RID_AT_END
))
9931 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PROPERTY
))
9932 c_parser_objc_at_property_declaration (parser
);
9933 else if (c_parser_next_token_is_keyword (parser
, RID_AT_OPTIONAL
))
9935 objc_set_method_opt (true);
9936 c_parser_consume_token (parser
);
9938 else if (c_parser_next_token_is_keyword (parser
, RID_AT_REQUIRED
))
9940 objc_set_method_opt (false);
9941 c_parser_consume_token (parser
);
9944 c_parser_declaration_or_fndef (parser
, false, false, true,
9945 false, true, NULL
, vNULL
);
9951 /* Parse an objc-methodproto.
9954 objc-method-type objc-method-decl ;
9958 c_parser_objc_methodproto (c_parser
*parser
)
9960 bool is_class_method
= c_parser_objc_method_type (parser
);
9961 tree decl
, attributes
= NULL_TREE
;
9963 /* Remember protocol qualifiers in prototypes. */
9964 parser
->objc_pq_context
= true;
9965 decl
= c_parser_objc_method_decl (parser
, is_class_method
, &attributes
,
9967 /* Forget protocol qualifiers now. */
9968 parser
->objc_pq_context
= false;
9970 /* Do not allow the presence of attributes to hide an erroneous
9971 method implementation in the interface section. */
9972 if (!c_parser_next_token_is (parser
, CPP_SEMICOLON
))
9974 c_parser_error (parser
, "expected %<;%>");
9978 if (decl
!= error_mark_node
)
9979 objc_add_method_declaration (is_class_method
, decl
, attributes
);
9981 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
9984 /* If we are at a position that method attributes may be present, check that
9985 there are not any parsed already (a syntax error) and then collect any
9986 specified at the current location. Finally, if new attributes were present,
9987 check that the next token is legal ( ';' for decls and '{' for defs). */
9990 c_parser_objc_maybe_method_attributes (c_parser
* parser
, tree
* attributes
)
9995 c_parser_error (parser
,
9996 "method attributes must be specified at the end only");
9997 *attributes
= NULL_TREE
;
10001 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
10002 *attributes
= c_parser_attributes (parser
);
10004 /* If there were no attributes here, just report any earlier error. */
10005 if (*attributes
== NULL_TREE
|| bad
)
10008 /* If the attributes are followed by a ; or {, then just report any earlier
10010 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
10011 || c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
10014 /* We've got attributes, but not at the end. */
10015 c_parser_error (parser
,
10016 "expected %<;%> or %<{%> after method attribute definition");
10020 /* Parse an objc-method-decl.
10023 ( objc-type-name ) objc-selector
10025 ( objc-type-name ) objc-keyword-selector objc-optparmlist
10026 objc-keyword-selector objc-optparmlist
10029 objc-keyword-selector:
10031 objc-keyword-selector objc-keyword-decl
10034 objc-selector : ( objc-type-name ) identifier
10035 objc-selector : identifier
10036 : ( objc-type-name ) identifier
10040 objc-optparms objc-optellipsis
10044 objc-opt-parms , parameter-declaration
10052 c_parser_objc_method_decl (c_parser
*parser
, bool is_class_method
,
10053 tree
*attributes
, tree
*expr
)
10055 tree type
= NULL_TREE
;
10057 tree parms
= NULL_TREE
;
10058 bool ellipsis
= false;
10059 bool attr_err
= false;
10061 *attributes
= NULL_TREE
;
10062 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
10064 matching_parens parens
;
10065 parens
.consume_open (parser
);
10066 type
= c_parser_objc_type_name (parser
);
10067 parens
.skip_until_found_close (parser
);
10069 sel
= c_parser_objc_selector (parser
);
10070 /* If there is no selector, or a colon follows, we have an
10071 objc-keyword-selector. If there is a selector, and a colon does
10072 not follow, that selector ends the objc-method-decl. */
10073 if (!sel
|| c_parser_next_token_is (parser
, CPP_COLON
))
10076 tree list
= NULL_TREE
;
10079 tree atype
= NULL_TREE
, id
, keyworddecl
;
10080 tree param_attr
= NULL_TREE
;
10081 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
10083 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
10085 c_parser_consume_token (parser
);
10086 atype
= c_parser_objc_type_name (parser
);
10087 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
10090 /* New ObjC allows attributes on method parameters. */
10091 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
10092 param_attr
= c_parser_attributes (parser
);
10093 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
10095 c_parser_error (parser
, "expected identifier");
10096 return error_mark_node
;
10098 id
= c_parser_peek_token (parser
)->value
;
10099 c_parser_consume_token (parser
);
10100 keyworddecl
= objc_build_keyword_decl (tsel
, atype
, id
, param_attr
);
10101 list
= chainon (list
, keyworddecl
);
10102 tsel
= c_parser_objc_selector (parser
);
10103 if (!tsel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
10107 attr_err
|= c_parser_objc_maybe_method_attributes (parser
, attributes
) ;
10109 /* Parse the optional parameter list. Optional Objective-C
10110 method parameters follow the C syntax, and may include '...'
10111 to denote a variable number of arguments. */
10112 parms
= make_node (TREE_LIST
);
10113 while (c_parser_next_token_is (parser
, CPP_COMMA
))
10115 struct c_parm
*parm
;
10116 c_parser_consume_token (parser
);
10117 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
10120 c_parser_consume_token (parser
);
10121 attr_err
|= c_parser_objc_maybe_method_attributes
10122 (parser
, attributes
) ;
10125 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
10128 parms
= chainon (parms
,
10129 build_tree_list (NULL_TREE
, grokparm (parm
, expr
)));
10134 attr_err
|= c_parser_objc_maybe_method_attributes (parser
, attributes
) ;
10138 c_parser_error (parser
, "objective-c method declaration is expected");
10139 return error_mark_node
;
10143 return error_mark_node
;
10145 return objc_build_method_signature (is_class_method
, type
, sel
, parms
, ellipsis
);
10148 /* Parse an objc-type-name.
10151 objc-type-qualifiers[opt] type-name
10152 objc-type-qualifiers[opt]
10154 objc-type-qualifiers:
10155 objc-type-qualifier
10156 objc-type-qualifiers objc-type-qualifier
10158 objc-type-qualifier: one of
10159 in out inout bycopy byref oneway
10163 c_parser_objc_type_name (c_parser
*parser
)
10165 tree quals
= NULL_TREE
;
10166 struct c_type_name
*type_name
= NULL
;
10167 tree type
= NULL_TREE
;
10170 c_token
*token
= c_parser_peek_token (parser
);
10171 if (token
->type
== CPP_KEYWORD
10172 && (token
->keyword
== RID_IN
10173 || token
->keyword
== RID_OUT
10174 || token
->keyword
== RID_INOUT
10175 || token
->keyword
== RID_BYCOPY
10176 || token
->keyword
== RID_BYREF
10177 || token
->keyword
== RID_ONEWAY
))
10179 quals
= chainon (build_tree_list (NULL_TREE
, token
->value
), quals
);
10180 c_parser_consume_token (parser
);
10185 if (c_parser_next_tokens_start_typename (parser
, cla_prefer_type
))
10186 type_name
= c_parser_type_name (parser
);
10188 type
= groktypename (type_name
, NULL
, NULL
);
10190 /* If the type is unknown, and error has already been produced and
10191 we need to recover from the error. In that case, use NULL_TREE
10192 for the type, as if no type had been specified; this will use the
10193 default type ('id') which is good for error recovery. */
10194 if (type
== error_mark_node
)
10197 return build_tree_list (quals
, type
);
10200 /* Parse objc-protocol-refs.
10202 objc-protocol-refs:
10203 < identifier-list >
10207 c_parser_objc_protocol_refs (c_parser
*parser
)
10209 tree list
= NULL_TREE
;
10210 gcc_assert (c_parser_next_token_is (parser
, CPP_LESS
));
10211 c_parser_consume_token (parser
);
10212 /* Any identifiers, including those declared as type names, are OK
10217 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
10219 c_parser_error (parser
, "expected identifier");
10222 id
= c_parser_peek_token (parser
)->value
;
10223 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
10224 c_parser_consume_token (parser
);
10225 if (c_parser_next_token_is (parser
, CPP_COMMA
))
10226 c_parser_consume_token (parser
);
10230 c_parser_require (parser
, CPP_GREATER
, "expected %<>%>");
10234 /* Parse an objc-try-catch-finally-statement.
10236 objc-try-catch-finally-statement:
10237 @try compound-statement objc-catch-list[opt]
10238 @try compound-statement objc-catch-list[opt] @finally compound-statement
10241 @catch ( objc-catch-parameter-declaration ) compound-statement
10242 objc-catch-list @catch ( objc-catch-parameter-declaration ) compound-statement
10244 objc-catch-parameter-declaration:
10245 parameter-declaration
10248 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
10250 PS: This function is identical to cp_parser_objc_try_catch_finally_statement
10251 for C++. Keep them in sync. */
10254 c_parser_objc_try_catch_finally_statement (c_parser
*parser
)
10256 location_t location
;
10259 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_TRY
));
10260 c_parser_consume_token (parser
);
10261 location
= c_parser_peek_token (parser
)->location
;
10262 objc_maybe_warn_exceptions (location
);
10263 stmt
= c_parser_compound_statement (parser
);
10264 objc_begin_try_stmt (location
, stmt
);
10266 while (c_parser_next_token_is_keyword (parser
, RID_AT_CATCH
))
10268 struct c_parm
*parm
;
10269 tree parameter_declaration
= error_mark_node
;
10270 bool seen_open_paren
= false;
10272 c_parser_consume_token (parser
);
10273 matching_parens parens
;
10274 if (!parens
.require_open (parser
))
10275 seen_open_paren
= true;
10276 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
10278 /* We have "@catch (...)" (where the '...' are literally
10279 what is in the code). Skip the '...'.
10280 parameter_declaration is set to NULL_TREE, and
10281 objc_being_catch_clauses() knows that that means
10283 c_parser_consume_token (parser
);
10284 parameter_declaration
= NULL_TREE
;
10288 /* We have "@catch (NSException *exception)" or something
10289 like that. Parse the parameter declaration. */
10290 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
10292 parameter_declaration
= error_mark_node
;
10294 parameter_declaration
= grokparm (parm
, NULL
);
10296 if (seen_open_paren
)
10297 parens
.require_close (parser
);
10300 /* If there was no open parenthesis, we are recovering from
10301 an error, and we are trying to figure out what mistake
10302 the user has made. */
10304 /* If there is an immediate closing parenthesis, the user
10305 probably forgot the opening one (ie, they typed "@catch
10306 NSException *e)". Parse the closing parenthesis and keep
10308 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
10309 c_parser_consume_token (parser
);
10311 /* If these is no immediate closing parenthesis, the user
10312 probably doesn't know that parenthesis are required at
10313 all (ie, they typed "@catch NSException *e"). So, just
10314 forget about the closing parenthesis and keep going. */
10316 objc_begin_catch_clause (parameter_declaration
);
10317 if (c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
10318 c_parser_compound_statement_nostart (parser
);
10319 objc_finish_catch_clause ();
10321 if (c_parser_next_token_is_keyword (parser
, RID_AT_FINALLY
))
10323 c_parser_consume_token (parser
);
10324 location
= c_parser_peek_token (parser
)->location
;
10325 stmt
= c_parser_compound_statement (parser
);
10326 objc_build_finally_clause (location
, stmt
);
10328 objc_finish_try_stmt ();
10331 /* Parse an objc-synchronized-statement.
10333 objc-synchronized-statement:
10334 @synchronized ( expression ) compound-statement
10338 c_parser_objc_synchronized_statement (c_parser
*parser
)
10342 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_SYNCHRONIZED
));
10343 c_parser_consume_token (parser
);
10344 loc
= c_parser_peek_token (parser
)->location
;
10345 objc_maybe_warn_exceptions (loc
);
10346 matching_parens parens
;
10347 if (parens
.require_open (parser
))
10349 struct c_expr ce
= c_parser_expression (parser
);
10350 ce
= convert_lvalue_to_rvalue (loc
, ce
, false, false);
10352 expr
= c_fully_fold (expr
, false, NULL
);
10353 parens
.skip_until_found_close (parser
);
10356 expr
= error_mark_node
;
10357 stmt
= c_parser_compound_statement (parser
);
10358 objc_build_synchronized (loc
, expr
, stmt
);
10361 /* Parse an objc-selector; return NULL_TREE without an error if the
10362 next token is not an objc-selector.
10367 enum struct union if else while do for switch case default
10368 break continue return goto asm sizeof typeof __alignof
10369 unsigned long const short volatile signed restrict _Complex
10370 in out inout bycopy byref oneway int char float double void _Bool
10373 ??? Why this selection of keywords but not, for example, storage
10374 class specifiers? */
10377 c_parser_objc_selector (c_parser
*parser
)
10379 c_token
*token
= c_parser_peek_token (parser
);
10380 tree value
= token
->value
;
10381 if (token
->type
== CPP_NAME
)
10383 c_parser_consume_token (parser
);
10386 if (token
->type
!= CPP_KEYWORD
)
10388 switch (token
->keyword
)
10427 CASE_RID_FLOATN_NX
:
10431 case RID_AUTO_TYPE
:
10436 c_parser_consume_token (parser
);
10443 /* Parse an objc-selector-arg.
10447 objc-keywordname-list
10449 objc-keywordname-list:
10451 objc-keywordname-list objc-keywordname
10459 c_parser_objc_selector_arg (c_parser
*parser
)
10461 tree sel
= c_parser_objc_selector (parser
);
10462 tree list
= NULL_TREE
;
10463 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
10467 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
10469 list
= chainon (list
, build_tree_list (sel
, NULL_TREE
));
10470 sel
= c_parser_objc_selector (parser
);
10471 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
10477 /* Parse an objc-receiver.
10486 c_parser_objc_receiver (c_parser
*parser
)
10488 location_t loc
= c_parser_peek_token (parser
)->location
;
10490 if (c_parser_peek_token (parser
)->type
== CPP_NAME
10491 && (c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
10492 || c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
))
10494 tree id
= c_parser_peek_token (parser
)->value
;
10495 c_parser_consume_token (parser
);
10496 return objc_get_class_reference (id
);
10498 struct c_expr ce
= c_parser_expression (parser
);
10499 ce
= convert_lvalue_to_rvalue (loc
, ce
, false, false);
10500 return c_fully_fold (ce
.value
, false, NULL
);
10503 /* Parse objc-message-args.
10507 objc-keywordarg-list
10509 objc-keywordarg-list:
10511 objc-keywordarg-list objc-keywordarg
10514 objc-selector : objc-keywordexpr
10519 c_parser_objc_message_args (c_parser
*parser
)
10521 tree sel
= c_parser_objc_selector (parser
);
10522 tree list
= NULL_TREE
;
10523 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
10528 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
10529 return error_mark_node
;
10530 keywordexpr
= c_parser_objc_keywordexpr (parser
);
10531 list
= chainon (list
, build_tree_list (sel
, keywordexpr
));
10532 sel
= c_parser_objc_selector (parser
);
10533 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
10539 /* Parse an objc-keywordexpr.
10546 c_parser_objc_keywordexpr (c_parser
*parser
)
10549 vec
<tree
, va_gc
> *expr_list
= c_parser_expr_list (parser
, true, true,
10550 NULL
, NULL
, NULL
, NULL
);
10551 if (vec_safe_length (expr_list
) == 1)
10553 /* Just return the expression, remove a level of
10555 ret
= (*expr_list
)[0];
10559 /* We have a comma expression, we will collapse later. */
10560 ret
= build_tree_list_vec (expr_list
);
10562 release_tree_vector (expr_list
);
10566 /* A check, needed in several places, that ObjC interface, implementation or
10567 method definitions are not prefixed by incorrect items. */
10569 c_parser_objc_diagnose_bad_element_prefix (c_parser
*parser
,
10570 struct c_declspecs
*specs
)
10572 if (!specs
->declspecs_seen_p
|| specs
->non_sc_seen_p
10573 || specs
->typespec_kind
!= ctsk_none
)
10575 c_parser_error (parser
,
10576 "no type or storage class may be specified here,");
10577 c_parser_skip_to_end_of_block_or_statement (parser
);
10583 /* Parse an Objective-C @property declaration. The syntax is:
10585 objc-property-declaration:
10586 '@property' objc-property-attributes[opt] struct-declaration ;
10588 objc-property-attributes:
10589 '(' objc-property-attribute-list ')'
10591 objc-property-attribute-list:
10592 objc-property-attribute
10593 objc-property-attribute-list, objc-property-attribute
10595 objc-property-attribute
10596 'getter' = identifier
10597 'setter' = identifier
10606 @property NSString *name;
10607 @property (readonly) id object;
10608 @property (retain, nonatomic, getter=getTheName) id name;
10609 @property int a, b, c;
10611 PS: This function is identical to cp_parser_objc_at_propery_declaration
10612 for C++. Keep them in sync. */
10614 c_parser_objc_at_property_declaration (c_parser
*parser
)
10616 /* The following variables hold the attributes of the properties as
10617 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
10618 seen. When we see an attribute, we set them to 'true' (if they
10619 are boolean properties) or to the identifier (if they have an
10620 argument, ie, for getter and setter). Note that here we only
10621 parse the list of attributes, check the syntax and accumulate the
10622 attributes that we find. objc_add_property_declaration() will
10623 then process the information. */
10624 bool property_assign
= false;
10625 bool property_copy
= false;
10626 tree property_getter_ident
= NULL_TREE
;
10627 bool property_nonatomic
= false;
10628 bool property_readonly
= false;
10629 bool property_readwrite
= false;
10630 bool property_retain
= false;
10631 tree property_setter_ident
= NULL_TREE
;
10633 /* 'properties' is the list of properties that we read. Usually a
10634 single one, but maybe more (eg, in "@property int a, b, c;" there
10639 loc
= c_parser_peek_token (parser
)->location
;
10640 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_PROPERTY
));
10642 c_parser_consume_token (parser
); /* Eat '@property'. */
10644 /* Parse the optional attribute list... */
10645 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
10647 matching_parens parens
;
10650 parens
.consume_open (parser
);
10652 /* Property attribute keywords are valid now. */
10653 parser
->objc_property_attr_context
= true;
10657 bool syntax_error
= false;
10658 c_token
*token
= c_parser_peek_token (parser
);
10661 if (token
->type
!= CPP_KEYWORD
)
10663 if (token
->type
== CPP_CLOSE_PAREN
)
10664 c_parser_error (parser
, "expected identifier");
10667 c_parser_consume_token (parser
);
10668 c_parser_error (parser
, "unknown property attribute");
10672 keyword
= token
->keyword
;
10673 c_parser_consume_token (parser
);
10676 case RID_ASSIGN
: property_assign
= true; break;
10677 case RID_COPY
: property_copy
= true; break;
10678 case RID_NONATOMIC
: property_nonatomic
= true; break;
10679 case RID_READONLY
: property_readonly
= true; break;
10680 case RID_READWRITE
: property_readwrite
= true; break;
10681 case RID_RETAIN
: property_retain
= true; break;
10685 if (c_parser_next_token_is_not (parser
, CPP_EQ
))
10687 if (keyword
== RID_GETTER
)
10688 c_parser_error (parser
,
10689 "missing %<=%> (after %<getter%> attribute)");
10691 c_parser_error (parser
,
10692 "missing %<=%> (after %<setter%> attribute)");
10693 syntax_error
= true;
10696 c_parser_consume_token (parser
); /* eat the = */
10697 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
10699 c_parser_error (parser
, "expected identifier");
10700 syntax_error
= true;
10703 if (keyword
== RID_SETTER
)
10705 if (property_setter_ident
!= NULL_TREE
)
10706 c_parser_error (parser
, "the %<setter%> attribute may only be specified once");
10708 property_setter_ident
= c_parser_peek_token (parser
)->value
;
10709 c_parser_consume_token (parser
);
10710 if (c_parser_next_token_is_not (parser
, CPP_COLON
))
10711 c_parser_error (parser
, "setter name must terminate with %<:%>");
10713 c_parser_consume_token (parser
);
10717 if (property_getter_ident
!= NULL_TREE
)
10718 c_parser_error (parser
, "the %<getter%> attribute may only be specified once");
10720 property_getter_ident
= c_parser_peek_token (parser
)->value
;
10721 c_parser_consume_token (parser
);
10725 c_parser_error (parser
, "unknown property attribute");
10726 syntax_error
= true;
10733 if (c_parser_next_token_is (parser
, CPP_COMMA
))
10734 c_parser_consume_token (parser
);
10738 parser
->objc_property_attr_context
= false;
10739 parens
.skip_until_found_close (parser
);
10741 /* ... and the property declaration(s). */
10742 properties
= c_parser_struct_declaration (parser
);
10744 if (properties
== error_mark_node
)
10746 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
10747 parser
->error
= false;
10751 if (properties
== NULL_TREE
)
10752 c_parser_error (parser
, "expected identifier");
10755 /* Comma-separated properties are chained together in
10756 reverse order; add them one by one. */
10757 properties
= nreverse (properties
);
10759 for (; properties
; properties
= TREE_CHAIN (properties
))
10760 objc_add_property_declaration (loc
, copy_node (properties
),
10761 property_readonly
, property_readwrite
,
10762 property_assign
, property_retain
,
10763 property_copy
, property_nonatomic
,
10764 property_getter_ident
, property_setter_ident
);
10767 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
10768 parser
->error
= false;
10771 /* Parse an Objective-C @synthesize declaration. The syntax is:
10773 objc-synthesize-declaration:
10774 @synthesize objc-synthesize-identifier-list ;
10776 objc-synthesize-identifier-list:
10777 objc-synthesize-identifier
10778 objc-synthesize-identifier-list, objc-synthesize-identifier
10780 objc-synthesize-identifier
10782 identifier = identifier
10785 @synthesize MyProperty;
10786 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
10788 PS: This function is identical to cp_parser_objc_at_synthesize_declaration
10789 for C++. Keep them in sync.
10792 c_parser_objc_at_synthesize_declaration (c_parser
*parser
)
10794 tree list
= NULL_TREE
;
10796 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_SYNTHESIZE
));
10797 loc
= c_parser_peek_token (parser
)->location
;
10799 c_parser_consume_token (parser
);
10802 tree property
, ivar
;
10803 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
10805 c_parser_error (parser
, "expected identifier");
10806 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
10807 /* Once we find the semicolon, we can resume normal parsing.
10808 We have to reset parser->error manually because
10809 c_parser_skip_until_found() won't reset it for us if the
10810 next token is precisely a semicolon. */
10811 parser
->error
= false;
10814 property
= c_parser_peek_token (parser
)->value
;
10815 c_parser_consume_token (parser
);
10816 if (c_parser_next_token_is (parser
, CPP_EQ
))
10818 c_parser_consume_token (parser
);
10819 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
10821 c_parser_error (parser
, "expected identifier");
10822 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
10823 parser
->error
= false;
10826 ivar
= c_parser_peek_token (parser
)->value
;
10827 c_parser_consume_token (parser
);
10831 list
= chainon (list
, build_tree_list (ivar
, property
));
10832 if (c_parser_next_token_is (parser
, CPP_COMMA
))
10833 c_parser_consume_token (parser
);
10837 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
10838 objc_add_synthesize_declaration (loc
, list
);
10841 /* Parse an Objective-C @dynamic declaration. The syntax is:
10843 objc-dynamic-declaration:
10844 @dynamic identifier-list ;
10847 @dynamic MyProperty;
10848 @dynamic MyProperty, AnotherProperty;
10850 PS: This function is identical to cp_parser_objc_at_dynamic_declaration
10851 for C++. Keep them in sync.
10854 c_parser_objc_at_dynamic_declaration (c_parser
*parser
)
10856 tree list
= NULL_TREE
;
10858 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_DYNAMIC
));
10859 loc
= c_parser_peek_token (parser
)->location
;
10861 c_parser_consume_token (parser
);
10865 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
10867 c_parser_error (parser
, "expected identifier");
10868 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
10869 parser
->error
= false;
10872 property
= c_parser_peek_token (parser
)->value
;
10873 list
= chainon (list
, build_tree_list (NULL_TREE
, property
));
10874 c_parser_consume_token (parser
);
10875 if (c_parser_next_token_is (parser
, CPP_COMMA
))
10876 c_parser_consume_token (parser
);
10880 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
10881 objc_add_dynamic_declaration (loc
, list
);
10885 /* Parse a pragma GCC ivdep. */
10888 c_parse_pragma_ivdep (c_parser
*parser
)
10890 c_parser_consume_pragma (parser
);
10891 c_parser_skip_to_pragma_eol (parser
);
10895 /* Parse a pragma GCC unroll. */
10897 static unsigned short
10898 c_parser_pragma_unroll (c_parser
*parser
)
10900 unsigned short unroll
;
10901 c_parser_consume_pragma (parser
);
10902 location_t location
= c_parser_peek_token (parser
)->location
;
10903 tree expr
= c_parser_expr_no_commas (parser
, NULL
).value
;
10904 mark_exp_read (expr
);
10905 expr
= c_fully_fold (expr
, false, NULL
);
10906 HOST_WIDE_INT lunroll
= 0;
10907 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr
))
10908 || TREE_CODE (expr
) != INTEGER_CST
10909 || (lunroll
= tree_to_shwi (expr
)) < 0
10910 || lunroll
>= USHRT_MAX
)
10912 error_at (location
, "%<#pragma GCC unroll%> requires an"
10913 " assignment-expression that evaluates to a non-negative"
10914 " integral constant less than %u", USHRT_MAX
);
10919 unroll
= (unsigned short)lunroll
;
10924 c_parser_skip_to_pragma_eol (parser
);
10928 /* Handle pragmas. Some OpenMP pragmas are associated with, and therefore
10929 should be considered, statements. ALLOW_STMT is true if we're within
10930 the context of a function and such pragmas are to be allowed. Returns
10931 true if we actually parsed such a pragma. */
10934 c_parser_pragma (c_parser
*parser
, enum pragma_context context
, bool *if_p
)
10937 const char *construct
= NULL
;
10939 id
= c_parser_peek_token (parser
)->pragma_kind
;
10940 gcc_assert (id
!= PRAGMA_NONE
);
10944 case PRAGMA_OACC_DECLARE
:
10945 c_parser_oacc_declare (parser
);
10948 case PRAGMA_OACC_ENTER_DATA
:
10949 if (context
!= pragma_compound
)
10951 construct
= "acc enter data";
10953 if (context
== pragma_stmt
)
10955 error_at (c_parser_peek_token (parser
)->location
,
10956 "%<#pragma %s%> may only be used in compound "
10957 "statements", construct
);
10958 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
10963 c_parser_oacc_enter_exit_data (parser
, true);
10966 case PRAGMA_OACC_EXIT_DATA
:
10967 if (context
!= pragma_compound
)
10969 construct
= "acc exit data";
10972 c_parser_oacc_enter_exit_data (parser
, false);
10975 case PRAGMA_OACC_ROUTINE
:
10976 if (context
!= pragma_external
)
10978 error_at (c_parser_peek_token (parser
)->location
,
10979 "%<#pragma acc routine%> must be at file scope");
10980 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
10983 c_parser_oacc_routine (parser
, context
);
10986 case PRAGMA_OACC_UPDATE
:
10987 if (context
!= pragma_compound
)
10989 construct
= "acc update";
10992 c_parser_oacc_update (parser
);
10995 case PRAGMA_OMP_BARRIER
:
10996 if (context
!= pragma_compound
)
10998 construct
= "omp barrier";
11001 c_parser_omp_barrier (parser
);
11004 case PRAGMA_OMP_FLUSH
:
11005 if (context
!= pragma_compound
)
11007 construct
= "omp flush";
11010 c_parser_omp_flush (parser
);
11013 case PRAGMA_OMP_TASKWAIT
:
11014 if (context
!= pragma_compound
)
11016 construct
= "omp taskwait";
11019 c_parser_omp_taskwait (parser
);
11022 case PRAGMA_OMP_TASKYIELD
:
11023 if (context
!= pragma_compound
)
11025 construct
= "omp taskyield";
11028 c_parser_omp_taskyield (parser
);
11031 case PRAGMA_OMP_CANCEL
:
11032 if (context
!= pragma_compound
)
11034 construct
= "omp cancel";
11037 c_parser_omp_cancel (parser
);
11040 case PRAGMA_OMP_CANCELLATION_POINT
:
11041 c_parser_omp_cancellation_point (parser
, context
);
11044 case PRAGMA_OMP_THREADPRIVATE
:
11045 c_parser_omp_threadprivate (parser
);
11048 case PRAGMA_OMP_TARGET
:
11049 return c_parser_omp_target (parser
, context
, if_p
);
11051 case PRAGMA_OMP_END_DECLARE_TARGET
:
11052 c_parser_omp_end_declare_target (parser
);
11055 case PRAGMA_OMP_SECTION
:
11056 error_at (c_parser_peek_token (parser
)->location
,
11057 "%<#pragma omp section%> may only be used in "
11058 "%<#pragma omp sections%> construct");
11059 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
11062 case PRAGMA_OMP_DECLARE
:
11063 c_parser_omp_declare (parser
, context
);
11066 case PRAGMA_OMP_ORDERED
:
11067 return c_parser_omp_ordered (parser
, context
, if_p
);
11071 const bool ivdep
= c_parse_pragma_ivdep (parser
);
11072 unsigned short unroll
;
11073 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_UNROLL
)
11074 unroll
= c_parser_pragma_unroll (parser
);
11077 if (!c_parser_next_token_is_keyword (parser
, RID_FOR
)
11078 && !c_parser_next_token_is_keyword (parser
, RID_WHILE
)
11079 && !c_parser_next_token_is_keyword (parser
, RID_DO
))
11081 c_parser_error (parser
, "for, while or do statement expected");
11084 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
11085 c_parser_for_statement (parser
, ivdep
, unroll
, if_p
);
11086 else if (c_parser_next_token_is_keyword (parser
, RID_WHILE
))
11087 c_parser_while_statement (parser
, ivdep
, unroll
, if_p
);
11089 c_parser_do_statement (parser
, ivdep
, unroll
);
11093 case PRAGMA_UNROLL
:
11095 unsigned short unroll
= c_parser_pragma_unroll (parser
);
11097 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_IVDEP
)
11098 ivdep
= c_parse_pragma_ivdep (parser
);
11101 if (!c_parser_next_token_is_keyword (parser
, RID_FOR
)
11102 && !c_parser_next_token_is_keyword (parser
, RID_WHILE
)
11103 && !c_parser_next_token_is_keyword (parser
, RID_DO
))
11105 c_parser_error (parser
, "for, while or do statement expected");
11108 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
11109 c_parser_for_statement (parser
, ivdep
, unroll
, if_p
);
11110 else if (c_parser_next_token_is_keyword (parser
, RID_WHILE
))
11111 c_parser_while_statement (parser
, ivdep
, unroll
, if_p
);
11113 c_parser_do_statement (parser
, ivdep
, unroll
);
11117 case PRAGMA_GCC_PCH_PREPROCESS
:
11118 c_parser_error (parser
, "%<#pragma GCC pch_preprocess%> must be first");
11119 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
11122 case PRAGMA_OACC_WAIT
:
11123 if (context
!= pragma_compound
)
11125 construct
= "acc wait";
11128 /* FALL THROUGH. */
11131 if (id
< PRAGMA_FIRST_EXTERNAL
)
11133 if (context
!= pragma_stmt
&& context
!= pragma_compound
)
11136 c_parser_error (parser
, "expected declaration specifiers");
11137 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
11140 c_parser_omp_construct (parser
, if_p
);
11146 c_parser_consume_pragma (parser
);
11147 c_invoke_pragma_handler (id
);
11149 /* Skip to EOL, but suppress any error message. Those will have been
11150 generated by the handler routine through calling error, as opposed
11151 to calling c_parser_error. */
11152 parser
->error
= true;
11153 c_parser_skip_to_pragma_eol (parser
);
11158 /* The interface the pragma parsers have to the lexer. */
11161 pragma_lex (tree
*value
, location_t
*loc
)
11163 c_token
*tok
= c_parser_peek_token (the_parser
);
11164 enum cpp_ttype ret
= tok
->type
;
11166 *value
= tok
->value
;
11168 *loc
= tok
->location
;
11170 if (ret
== CPP_PRAGMA_EOL
|| ret
== CPP_EOF
)
11174 if (ret
== CPP_KEYWORD
)
11176 c_parser_consume_token (the_parser
);
11183 c_parser_pragma_pch_preprocess (c_parser
*parser
)
11187 c_parser_consume_pragma (parser
);
11188 if (c_parser_next_token_is (parser
, CPP_STRING
))
11190 name
= c_parser_peek_token (parser
)->value
;
11191 c_parser_consume_token (parser
);
11194 c_parser_error (parser
, "expected string literal");
11195 c_parser_skip_to_pragma_eol (parser
);
11198 c_common_pch_pragma (parse_in
, TREE_STRING_POINTER (name
));
11201 /* OpenACC and OpenMP parsing routines. */
11203 /* Returns name of the next clause.
11204 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
11205 the token is not consumed. Otherwise appropriate pragma_omp_clause is
11206 returned and the token is consumed. */
11208 static pragma_omp_clause
11209 c_parser_omp_clause_name (c_parser
*parser
)
11211 pragma_omp_clause result
= PRAGMA_OMP_CLAUSE_NONE
;
11213 if (c_parser_next_token_is_keyword (parser
, RID_AUTO
))
11214 result
= PRAGMA_OACC_CLAUSE_AUTO
;
11215 else if (c_parser_next_token_is_keyword (parser
, RID_IF
))
11216 result
= PRAGMA_OMP_CLAUSE_IF
;
11217 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
11218 result
= PRAGMA_OMP_CLAUSE_DEFAULT
;
11219 else if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
11220 result
= PRAGMA_OMP_CLAUSE_FOR
;
11221 else if (c_parser_next_token_is (parser
, CPP_NAME
))
11223 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
11228 if (!strcmp ("aligned", p
))
11229 result
= PRAGMA_OMP_CLAUSE_ALIGNED
;
11230 else if (!strcmp ("async", p
))
11231 result
= PRAGMA_OACC_CLAUSE_ASYNC
;
11234 if (!strcmp ("collapse", p
))
11235 result
= PRAGMA_OMP_CLAUSE_COLLAPSE
;
11236 else if (!strcmp ("copy", p
))
11237 result
= PRAGMA_OACC_CLAUSE_COPY
;
11238 else if (!strcmp ("copyin", p
))
11239 result
= PRAGMA_OMP_CLAUSE_COPYIN
;
11240 else if (!strcmp ("copyout", p
))
11241 result
= PRAGMA_OACC_CLAUSE_COPYOUT
;
11242 else if (!strcmp ("copyprivate", p
))
11243 result
= PRAGMA_OMP_CLAUSE_COPYPRIVATE
;
11244 else if (!strcmp ("create", p
))
11245 result
= PRAGMA_OACC_CLAUSE_CREATE
;
11248 if (!strcmp ("defaultmap", p
))
11249 result
= PRAGMA_OMP_CLAUSE_DEFAULTMAP
;
11250 else if (!strcmp ("delete", p
))
11251 result
= PRAGMA_OACC_CLAUSE_DELETE
;
11252 else if (!strcmp ("depend", p
))
11253 result
= PRAGMA_OMP_CLAUSE_DEPEND
;
11254 else if (!strcmp ("device", p
))
11255 result
= PRAGMA_OMP_CLAUSE_DEVICE
;
11256 else if (!strcmp ("deviceptr", p
))
11257 result
= PRAGMA_OACC_CLAUSE_DEVICEPTR
;
11258 else if (!strcmp ("device_resident", p
))
11259 result
= PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT
;
11260 else if (!strcmp ("dist_schedule", p
))
11261 result
= PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
;
11264 if (!strcmp ("final", p
))
11265 result
= PRAGMA_OMP_CLAUSE_FINAL
;
11266 else if (!strcmp ("finalize", p
))
11267 result
= PRAGMA_OACC_CLAUSE_FINALIZE
;
11268 else if (!strcmp ("firstprivate", p
))
11269 result
= PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
;
11270 else if (!strcmp ("from", p
))
11271 result
= PRAGMA_OMP_CLAUSE_FROM
;
11274 if (!strcmp ("gang", p
))
11275 result
= PRAGMA_OACC_CLAUSE_GANG
;
11276 else if (!strcmp ("grainsize", p
))
11277 result
= PRAGMA_OMP_CLAUSE_GRAINSIZE
;
11280 if (!strcmp ("hint", p
))
11281 result
= PRAGMA_OMP_CLAUSE_HINT
;
11282 else if (!strcmp ("host", p
))
11283 result
= PRAGMA_OACC_CLAUSE_HOST
;
11286 if (!strcmp ("if_present", p
))
11287 result
= PRAGMA_OACC_CLAUSE_IF_PRESENT
;
11288 else if (!strcmp ("inbranch", p
))
11289 result
= PRAGMA_OMP_CLAUSE_INBRANCH
;
11290 else if (!strcmp ("independent", p
))
11291 result
= PRAGMA_OACC_CLAUSE_INDEPENDENT
;
11292 else if (!strcmp ("is_device_ptr", p
))
11293 result
= PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR
;
11296 if (!strcmp ("lastprivate", p
))
11297 result
= PRAGMA_OMP_CLAUSE_LASTPRIVATE
;
11298 else if (!strcmp ("linear", p
))
11299 result
= PRAGMA_OMP_CLAUSE_LINEAR
;
11300 else if (!strcmp ("link", p
))
11301 result
= PRAGMA_OMP_CLAUSE_LINK
;
11304 if (!strcmp ("map", p
))
11305 result
= PRAGMA_OMP_CLAUSE_MAP
;
11306 else if (!strcmp ("mergeable", p
))
11307 result
= PRAGMA_OMP_CLAUSE_MERGEABLE
;
11310 if (!strcmp ("nogroup", p
))
11311 result
= PRAGMA_OMP_CLAUSE_NOGROUP
;
11312 else if (!strcmp ("notinbranch", p
))
11313 result
= PRAGMA_OMP_CLAUSE_NOTINBRANCH
;
11314 else if (!strcmp ("nowait", p
))
11315 result
= PRAGMA_OMP_CLAUSE_NOWAIT
;
11316 else if (!strcmp ("num_gangs", p
))
11317 result
= PRAGMA_OACC_CLAUSE_NUM_GANGS
;
11318 else if (!strcmp ("num_tasks", p
))
11319 result
= PRAGMA_OMP_CLAUSE_NUM_TASKS
;
11320 else if (!strcmp ("num_teams", p
))
11321 result
= PRAGMA_OMP_CLAUSE_NUM_TEAMS
;
11322 else if (!strcmp ("num_threads", p
))
11323 result
= PRAGMA_OMP_CLAUSE_NUM_THREADS
;
11324 else if (!strcmp ("num_workers", p
))
11325 result
= PRAGMA_OACC_CLAUSE_NUM_WORKERS
;
11328 if (!strcmp ("ordered", p
))
11329 result
= PRAGMA_OMP_CLAUSE_ORDERED
;
11332 if (!strcmp ("parallel", p
))
11333 result
= PRAGMA_OMP_CLAUSE_PARALLEL
;
11334 else if (!strcmp ("present", p
))
11335 result
= PRAGMA_OACC_CLAUSE_PRESENT
;
11336 /* As of OpenACC 2.5, these are now aliases of the non-present_or
11338 else if (!strcmp ("present_or_copy", p
)
11339 || !strcmp ("pcopy", p
))
11340 result
= PRAGMA_OACC_CLAUSE_COPY
;
11341 else if (!strcmp ("present_or_copyin", p
)
11342 || !strcmp ("pcopyin", p
))
11343 result
= PRAGMA_OACC_CLAUSE_COPYIN
;
11344 else if (!strcmp ("present_or_copyout", p
)
11345 || !strcmp ("pcopyout", p
))
11346 result
= PRAGMA_OACC_CLAUSE_COPYOUT
;
11347 else if (!strcmp ("present_or_create", p
)
11348 || !strcmp ("pcreate", p
))
11349 result
= PRAGMA_OACC_CLAUSE_CREATE
;
11350 else if (!strcmp ("priority", p
))
11351 result
= PRAGMA_OMP_CLAUSE_PRIORITY
;
11352 else if (!strcmp ("private", p
))
11353 result
= PRAGMA_OMP_CLAUSE_PRIVATE
;
11354 else if (!strcmp ("proc_bind", p
))
11355 result
= PRAGMA_OMP_CLAUSE_PROC_BIND
;
11358 if (!strcmp ("reduction", p
))
11359 result
= PRAGMA_OMP_CLAUSE_REDUCTION
;
11362 if (!strcmp ("safelen", p
))
11363 result
= PRAGMA_OMP_CLAUSE_SAFELEN
;
11364 else if (!strcmp ("schedule", p
))
11365 result
= PRAGMA_OMP_CLAUSE_SCHEDULE
;
11366 else if (!strcmp ("sections", p
))
11367 result
= PRAGMA_OMP_CLAUSE_SECTIONS
;
11368 else if (!strcmp ("self", p
)) /* "self" is a synonym for "host". */
11369 result
= PRAGMA_OACC_CLAUSE_HOST
;
11370 else if (!strcmp ("seq", p
))
11371 result
= PRAGMA_OACC_CLAUSE_SEQ
;
11372 else if (!strcmp ("shared", p
))
11373 result
= PRAGMA_OMP_CLAUSE_SHARED
;
11374 else if (!strcmp ("simd", p
))
11375 result
= PRAGMA_OMP_CLAUSE_SIMD
;
11376 else if (!strcmp ("simdlen", p
))
11377 result
= PRAGMA_OMP_CLAUSE_SIMDLEN
;
11380 if (!strcmp ("taskgroup", p
))
11381 result
= PRAGMA_OMP_CLAUSE_TASKGROUP
;
11382 else if (!strcmp ("thread_limit", p
))
11383 result
= PRAGMA_OMP_CLAUSE_THREAD_LIMIT
;
11384 else if (!strcmp ("threads", p
))
11385 result
= PRAGMA_OMP_CLAUSE_THREADS
;
11386 else if (!strcmp ("tile", p
))
11387 result
= PRAGMA_OACC_CLAUSE_TILE
;
11388 else if (!strcmp ("to", p
))
11389 result
= PRAGMA_OMP_CLAUSE_TO
;
11392 if (!strcmp ("uniform", p
))
11393 result
= PRAGMA_OMP_CLAUSE_UNIFORM
;
11394 else if (!strcmp ("untied", p
))
11395 result
= PRAGMA_OMP_CLAUSE_UNTIED
;
11396 else if (!strcmp ("use_device", p
))
11397 result
= PRAGMA_OACC_CLAUSE_USE_DEVICE
;
11398 else if (!strcmp ("use_device_ptr", p
))
11399 result
= PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR
;
11402 if (!strcmp ("vector", p
))
11403 result
= PRAGMA_OACC_CLAUSE_VECTOR
;
11404 else if (!strcmp ("vector_length", p
))
11405 result
= PRAGMA_OACC_CLAUSE_VECTOR_LENGTH
;
11408 if (!strcmp ("wait", p
))
11409 result
= PRAGMA_OACC_CLAUSE_WAIT
;
11410 else if (!strcmp ("worker", p
))
11411 result
= PRAGMA_OACC_CLAUSE_WORKER
;
11416 if (result
!= PRAGMA_OMP_CLAUSE_NONE
)
11417 c_parser_consume_token (parser
);
11422 /* Validate that a clause of the given type does not already exist. */
11425 check_no_duplicate_clause (tree clauses
, enum omp_clause_code code
,
11430 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
11431 if (OMP_CLAUSE_CODE (c
) == code
)
11433 location_t loc
= OMP_CLAUSE_LOCATION (c
);
11434 error_at (loc
, "too many %qs clauses", name
);
11440 Parse wait clause or wait directive parameters. */
11443 c_parser_oacc_wait_list (c_parser
*parser
, location_t clause_loc
, tree list
)
11445 vec
<tree
, va_gc
> *args
;
11448 matching_parens parens
;
11449 if (!parens
.require_open (parser
))
11452 args
= c_parser_expr_list (parser
, false, true, NULL
, NULL
, NULL
, NULL
);
11454 if (args
->length () == 0)
11456 c_parser_error (parser
, "expected integer expression before ')'");
11457 release_tree_vector (args
);
11461 args_tree
= build_tree_list_vec (args
);
11463 for (t
= args_tree
; t
; t
= TREE_CHAIN (t
))
11465 tree targ
= TREE_VALUE (t
);
11467 if (targ
!= error_mark_node
)
11469 if (!INTEGRAL_TYPE_P (TREE_TYPE (targ
)))
11471 c_parser_error (parser
, "expression must be integral");
11472 targ
= error_mark_node
;
11476 tree c
= build_omp_clause (clause_loc
, OMP_CLAUSE_WAIT
);
11478 OMP_CLAUSE_DECL (c
) = targ
;
11479 OMP_CLAUSE_CHAIN (c
) = list
;
11485 release_tree_vector (args
);
11486 parens
.require_close (parser
);
11490 /* OpenACC 2.0, OpenMP 2.5:
11493 variable-list , identifier
11495 If KIND is nonzero, create the appropriate node and install the
11496 decl in OMP_CLAUSE_DECL and add the node to the head of the list.
11497 If KIND is nonzero, CLAUSE_LOC is the location of the clause.
11499 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
11500 return the list created. */
11503 c_parser_omp_variable_list (c_parser
*parser
,
11504 location_t clause_loc
,
11505 enum omp_clause_code kind
, tree list
)
11507 if (c_parser_next_token_is_not (parser
, CPP_NAME
)
11508 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
11509 c_parser_error (parser
, "expected identifier");
11511 while (c_parser_next_token_is (parser
, CPP_NAME
)
11512 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
11514 tree t
= lookup_name (c_parser_peek_token (parser
)->value
);
11516 if (t
== NULL_TREE
)
11518 undeclared_variable (c_parser_peek_token (parser
)->location
,
11519 c_parser_peek_token (parser
)->value
);
11520 t
= error_mark_node
;
11523 c_parser_consume_token (parser
);
11525 if (t
== error_mark_node
)
11527 else if (kind
!= 0)
11531 case OMP_CLAUSE__CACHE_
:
11532 /* The OpenACC cache directive explicitly only allows "array
11533 elements or subarrays". */
11534 if (c_parser_peek_token (parser
)->type
!= CPP_OPEN_SQUARE
)
11536 c_parser_error (parser
, "expected %<[%>");
11537 t
= error_mark_node
;
11541 case OMP_CLAUSE_MAP
:
11542 case OMP_CLAUSE_FROM
:
11543 case OMP_CLAUSE_TO
:
11544 while (c_parser_next_token_is (parser
, CPP_DOT
))
11546 location_t op_loc
= c_parser_peek_token (parser
)->location
;
11547 c_parser_consume_token (parser
);
11548 if (!c_parser_next_token_is (parser
, CPP_NAME
))
11550 c_parser_error (parser
, "expected identifier");
11551 t
= error_mark_node
;
11555 c_token
*comp_tok
= c_parser_peek_token (parser
);
11556 tree ident
= comp_tok
->value
;
11557 location_t comp_loc
= comp_tok
->location
;
11558 c_parser_consume_token (parser
);
11559 t
= build_component_ref (op_loc
, t
, ident
, comp_loc
);
11562 case OMP_CLAUSE_DEPEND
:
11563 case OMP_CLAUSE_REDUCTION
:
11564 while (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
11566 tree low_bound
= NULL_TREE
, length
= NULL_TREE
;
11568 c_parser_consume_token (parser
);
11569 if (!c_parser_next_token_is (parser
, CPP_COLON
))
11571 location_t expr_loc
11572 = c_parser_peek_token (parser
)->location
;
11573 c_expr expr
= c_parser_expression (parser
);
11574 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
,
11576 low_bound
= expr
.value
;
11578 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
11579 length
= integer_one_node
;
11582 /* Look for `:'. */
11583 if (!c_parser_require (parser
, CPP_COLON
,
11586 t
= error_mark_node
;
11589 if (!c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
11591 location_t expr_loc
11592 = c_parser_peek_token (parser
)->location
;
11593 c_expr expr
= c_parser_expression (parser
);
11594 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
,
11596 length
= expr
.value
;
11599 /* Look for the closing `]'. */
11600 if (!c_parser_require (parser
, CPP_CLOSE_SQUARE
,
11603 t
= error_mark_node
;
11607 t
= tree_cons (low_bound
, length
, t
);
11614 if (t
!= error_mark_node
)
11616 tree u
= build_omp_clause (clause_loc
, kind
);
11617 OMP_CLAUSE_DECL (u
) = t
;
11618 OMP_CLAUSE_CHAIN (u
) = list
;
11623 list
= tree_cons (t
, NULL_TREE
, list
);
11625 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
11628 c_parser_consume_token (parser
);
11634 /* Similarly, but expect leading and trailing parenthesis. This is a very
11635 common case for OpenACC and OpenMP clauses. */
11638 c_parser_omp_var_list_parens (c_parser
*parser
, enum omp_clause_code kind
,
11641 /* The clauses location. */
11642 location_t loc
= c_parser_peek_token (parser
)->location
;
11644 matching_parens parens
;
11645 if (parens
.require_open (parser
))
11647 list
= c_parser_omp_variable_list (parser
, loc
, kind
, list
);
11648 parens
.skip_until_found_close (parser
);
11654 copy ( variable-list )
11655 copyin ( variable-list )
11656 copyout ( variable-list )
11657 create ( variable-list )
11658 delete ( variable-list )
11659 present ( variable-list ) */
11662 c_parser_oacc_data_clause (c_parser
*parser
, pragma_omp_clause c_kind
,
11665 enum gomp_map_kind kind
;
11668 case PRAGMA_OACC_CLAUSE_COPY
:
11669 kind
= GOMP_MAP_TOFROM
;
11671 case PRAGMA_OACC_CLAUSE_COPYIN
:
11672 kind
= GOMP_MAP_TO
;
11674 case PRAGMA_OACC_CLAUSE_COPYOUT
:
11675 kind
= GOMP_MAP_FROM
;
11677 case PRAGMA_OACC_CLAUSE_CREATE
:
11678 kind
= GOMP_MAP_ALLOC
;
11680 case PRAGMA_OACC_CLAUSE_DELETE
:
11681 kind
= GOMP_MAP_RELEASE
;
11683 case PRAGMA_OACC_CLAUSE_DEVICE
:
11684 kind
= GOMP_MAP_FORCE_TO
;
11686 case PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT
:
11687 kind
= GOMP_MAP_DEVICE_RESIDENT
;
11689 case PRAGMA_OACC_CLAUSE_HOST
:
11690 kind
= GOMP_MAP_FORCE_FROM
;
11692 case PRAGMA_OACC_CLAUSE_LINK
:
11693 kind
= GOMP_MAP_LINK
;
11695 case PRAGMA_OACC_CLAUSE_PRESENT
:
11696 kind
= GOMP_MAP_FORCE_PRESENT
;
11699 gcc_unreachable ();
11702 nl
= c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_MAP
, list
);
11704 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
11705 OMP_CLAUSE_SET_MAP_KIND (c
, kind
);
11711 deviceptr ( variable-list ) */
11714 c_parser_oacc_data_clause_deviceptr (c_parser
*parser
, tree list
)
11716 location_t loc
= c_parser_peek_token (parser
)->location
;
11719 /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
11720 c_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
11721 variable-list must only allow for pointer variables. */
11722 vars
= c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_ERROR
, NULL
);
11723 for (t
= vars
; t
&& t
; t
= TREE_CHAIN (t
))
11725 tree v
= TREE_PURPOSE (t
);
11727 /* FIXME diagnostics: Ideally we should keep individual
11728 locations for all the variables in the var list to make the
11729 following errors more precise. Perhaps
11730 c_parser_omp_var_list_parens() should construct a list of
11731 locations to go along with the var list. */
11733 if (!VAR_P (v
) && TREE_CODE (v
) != PARM_DECL
)
11734 error_at (loc
, "%qD is not a variable", v
);
11735 else if (TREE_TYPE (v
) == error_mark_node
)
11737 else if (!POINTER_TYPE_P (TREE_TYPE (v
)))
11738 error_at (loc
, "%qD is not a pointer variable", v
);
11740 tree u
= build_omp_clause (loc
, OMP_CLAUSE_MAP
);
11741 OMP_CLAUSE_SET_MAP_KIND (u
, GOMP_MAP_FORCE_DEVICEPTR
);
11742 OMP_CLAUSE_DECL (u
) = v
;
11743 OMP_CLAUSE_CHAIN (u
) = list
;
11750 /* OpenACC 2.0, OpenMP 3.0:
11751 collapse ( constant-expression ) */
11754 c_parser_omp_clause_collapse (c_parser
*parser
, tree list
)
11756 tree c
, num
= error_mark_node
;
11760 check_no_duplicate_clause (list
, OMP_CLAUSE_COLLAPSE
, "collapse");
11761 check_no_duplicate_clause (list
, OMP_CLAUSE_TILE
, "tile");
11763 loc
= c_parser_peek_token (parser
)->location
;
11764 matching_parens parens
;
11765 if (parens
.require_open (parser
))
11767 num
= c_parser_expr_no_commas (parser
, NULL
).value
;
11768 parens
.skip_until_found_close (parser
);
11770 if (num
== error_mark_node
)
11772 mark_exp_read (num
);
11773 num
= c_fully_fold (num
, false, NULL
);
11774 if (!INTEGRAL_TYPE_P (TREE_TYPE (num
))
11775 || !tree_fits_shwi_p (num
)
11776 || (n
= tree_to_shwi (num
)) <= 0
11780 "collapse argument needs positive constant integer expression");
11783 c
= build_omp_clause (loc
, OMP_CLAUSE_COLLAPSE
);
11784 OMP_CLAUSE_COLLAPSE_EXPR (c
) = num
;
11785 OMP_CLAUSE_CHAIN (c
) = list
;
11790 copyin ( variable-list ) */
11793 c_parser_omp_clause_copyin (c_parser
*parser
, tree list
)
11795 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYIN
, list
);
11799 copyprivate ( variable-list ) */
11802 c_parser_omp_clause_copyprivate (c_parser
*parser
, tree list
)
11804 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYPRIVATE
, list
);
11808 default ( none | shared )
11811 default ( none | present ) */
11814 c_parser_omp_clause_default (c_parser
*parser
, tree list
, bool is_oacc
)
11816 enum omp_clause_default_kind kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
11817 location_t loc
= c_parser_peek_token (parser
)->location
;
11820 matching_parens parens
;
11821 if (!parens
.require_open (parser
))
11823 if (c_parser_next_token_is (parser
, CPP_NAME
))
11825 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
11830 if (strcmp ("none", p
) != 0)
11832 kind
= OMP_CLAUSE_DEFAULT_NONE
;
11836 if (strcmp ("present", p
) != 0 || !is_oacc
)
11838 kind
= OMP_CLAUSE_DEFAULT_PRESENT
;
11842 if (strcmp ("shared", p
) != 0 || is_oacc
)
11844 kind
= OMP_CLAUSE_DEFAULT_SHARED
;
11851 c_parser_consume_token (parser
);
11857 c_parser_error (parser
, "expected %<none%> or %<present%>");
11859 c_parser_error (parser
, "expected %<none%> or %<shared%>");
11861 parens
.skip_until_found_close (parser
);
11863 if (kind
== OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
11866 check_no_duplicate_clause (list
, OMP_CLAUSE_DEFAULT
, "default");
11867 c
= build_omp_clause (loc
, OMP_CLAUSE_DEFAULT
);
11868 OMP_CLAUSE_CHAIN (c
) = list
;
11869 OMP_CLAUSE_DEFAULT_KIND (c
) = kind
;
11875 firstprivate ( variable-list ) */
11878 c_parser_omp_clause_firstprivate (c_parser
*parser
, tree list
)
11880 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_FIRSTPRIVATE
, list
);
11884 final ( expression ) */
11887 c_parser_omp_clause_final (c_parser
*parser
, tree list
)
11889 location_t loc
= c_parser_peek_token (parser
)->location
;
11890 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
11892 tree t
= c_parser_paren_condition (parser
);
11895 check_no_duplicate_clause (list
, OMP_CLAUSE_FINAL
, "final");
11897 c
= build_omp_clause (loc
, OMP_CLAUSE_FINAL
);
11898 OMP_CLAUSE_FINAL_EXPR (c
) = t
;
11899 OMP_CLAUSE_CHAIN (c
) = list
;
11903 c_parser_error (parser
, "expected %<(%>");
11908 /* OpenACC, OpenMP 2.5:
11912 if ( directive-name-modifier : expression )
11914 directive-name-modifier:
11915 parallel | task | taskloop | target data | target | target update
11916 | target enter data | target exit data */
11919 c_parser_omp_clause_if (c_parser
*parser
, tree list
, bool is_omp
)
11921 location_t location
= c_parser_peek_token (parser
)->location
;
11922 enum tree_code if_modifier
= ERROR_MARK
;
11924 matching_parens parens
;
11925 if (!parens
.require_open (parser
))
11928 if (is_omp
&& c_parser_next_token_is (parser
, CPP_NAME
))
11930 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
11932 if (strcmp (p
, "parallel") == 0)
11933 if_modifier
= OMP_PARALLEL
;
11934 else if (strcmp (p
, "task") == 0)
11935 if_modifier
= OMP_TASK
;
11936 else if (strcmp (p
, "taskloop") == 0)
11937 if_modifier
= OMP_TASKLOOP
;
11938 else if (strcmp (p
, "target") == 0)
11940 if_modifier
= OMP_TARGET
;
11941 if (c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
)
11943 p
= IDENTIFIER_POINTER (c_parser_peek_2nd_token (parser
)->value
);
11944 if (strcmp ("data", p
) == 0)
11945 if_modifier
= OMP_TARGET_DATA
;
11946 else if (strcmp ("update", p
) == 0)
11947 if_modifier
= OMP_TARGET_UPDATE
;
11948 else if (strcmp ("enter", p
) == 0)
11949 if_modifier
= OMP_TARGET_ENTER_DATA
;
11950 else if (strcmp ("exit", p
) == 0)
11951 if_modifier
= OMP_TARGET_EXIT_DATA
;
11952 if (if_modifier
!= OMP_TARGET
)
11955 c_parser_consume_token (parser
);
11959 location_t loc
= c_parser_peek_2nd_token (parser
)->location
;
11960 error_at (loc
, "expected %<data%>, %<update%>, %<enter%> "
11962 if_modifier
= ERROR_MARK
;
11964 if (if_modifier
== OMP_TARGET_ENTER_DATA
11965 || if_modifier
== OMP_TARGET_EXIT_DATA
)
11967 if (c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
)
11969 p
= IDENTIFIER_POINTER
11970 (c_parser_peek_2nd_token (parser
)->value
);
11971 if (strcmp ("data", p
) == 0)
11975 c_parser_consume_token (parser
);
11979 = c_parser_peek_2nd_token (parser
)->location
;
11980 error_at (loc
, "expected %<data%>");
11981 if_modifier
= ERROR_MARK
;
11986 if (if_modifier
!= ERROR_MARK
)
11988 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
11990 c_parser_consume_token (parser
);
11991 c_parser_consume_token (parser
);
11997 location_t loc
= c_parser_peek_2nd_token (parser
)->location
;
11998 error_at (loc
, "expected %<:%>");
12000 if_modifier
= ERROR_MARK
;
12005 tree t
= c_parser_condition (parser
), c
;
12006 parens
.skip_until_found_close (parser
);
12008 for (c
= list
; c
; c
= OMP_CLAUSE_CHAIN (c
))
12009 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IF
)
12011 if (if_modifier
!= ERROR_MARK
12012 && OMP_CLAUSE_IF_MODIFIER (c
) == if_modifier
)
12014 const char *p
= NULL
;
12015 switch (if_modifier
)
12017 case OMP_PARALLEL
: p
= "parallel"; break;
12018 case OMP_TASK
: p
= "task"; break;
12019 case OMP_TASKLOOP
: p
= "taskloop"; break;
12020 case OMP_TARGET_DATA
: p
= "target data"; break;
12021 case OMP_TARGET
: p
= "target"; break;
12022 case OMP_TARGET_UPDATE
: p
= "target update"; break;
12023 case OMP_TARGET_ENTER_DATA
: p
= "enter data"; break;
12024 case OMP_TARGET_EXIT_DATA
: p
= "exit data"; break;
12025 default: gcc_unreachable ();
12027 error_at (location
, "too many %<if%> clauses with %qs modifier",
12031 else if (OMP_CLAUSE_IF_MODIFIER (c
) == if_modifier
)
12034 error_at (location
, "too many %<if%> clauses");
12036 error_at (location
, "too many %<if%> clauses without modifier");
12039 else if (if_modifier
== ERROR_MARK
12040 || OMP_CLAUSE_IF_MODIFIER (c
) == ERROR_MARK
)
12042 error_at (location
, "if any %<if%> clause has modifier, then all "
12043 "%<if%> clauses have to use modifier");
12048 c
= build_omp_clause (location
, OMP_CLAUSE_IF
);
12049 OMP_CLAUSE_IF_MODIFIER (c
) = if_modifier
;
12050 OMP_CLAUSE_IF_EXPR (c
) = t
;
12051 OMP_CLAUSE_CHAIN (c
) = list
;
12056 lastprivate ( variable-list ) */
12059 c_parser_omp_clause_lastprivate (c_parser
*parser
, tree list
)
12061 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_LASTPRIVATE
, list
);
12068 c_parser_omp_clause_mergeable (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
12072 /* FIXME: Should we allow duplicates? */
12073 check_no_duplicate_clause (list
, OMP_CLAUSE_MERGEABLE
, "mergeable");
12075 c
= build_omp_clause (c_parser_peek_token (parser
)->location
,
12076 OMP_CLAUSE_MERGEABLE
);
12077 OMP_CLAUSE_CHAIN (c
) = list
;
12086 c_parser_omp_clause_nowait (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
12089 location_t loc
= c_parser_peek_token (parser
)->location
;
12091 check_no_duplicate_clause (list
, OMP_CLAUSE_NOWAIT
, "nowait");
12093 c
= build_omp_clause (loc
, OMP_CLAUSE_NOWAIT
);
12094 OMP_CLAUSE_CHAIN (c
) = list
;
12099 num_threads ( expression ) */
12102 c_parser_omp_clause_num_threads (c_parser
*parser
, tree list
)
12104 location_t num_threads_loc
= c_parser_peek_token (parser
)->location
;
12105 matching_parens parens
;
12106 if (parens
.require_open (parser
))
12108 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
12109 c_expr expr
= c_parser_expression (parser
);
12110 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
12111 tree c
, t
= expr
.value
;
12112 t
= c_fully_fold (t
, false, NULL
);
12114 parens
.skip_until_found_close (parser
);
12116 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
12118 c_parser_error (parser
, "expected integer expression");
12122 /* Attempt to statically determine when the number isn't positive. */
12123 c
= fold_build2_loc (expr_loc
, LE_EXPR
, boolean_type_node
, t
,
12124 build_int_cst (TREE_TYPE (t
), 0));
12125 protected_set_expr_location (c
, expr_loc
);
12126 if (c
== boolean_true_node
)
12128 warning_at (expr_loc
, 0,
12129 "%<num_threads%> value must be positive");
12130 t
= integer_one_node
;
12133 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_THREADS
, "num_threads");
12135 c
= build_omp_clause (num_threads_loc
, OMP_CLAUSE_NUM_THREADS
);
12136 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
12137 OMP_CLAUSE_CHAIN (c
) = list
;
12145 num_tasks ( expression ) */
12148 c_parser_omp_clause_num_tasks (c_parser
*parser
, tree list
)
12150 location_t num_tasks_loc
= c_parser_peek_token (parser
)->location
;
12151 matching_parens parens
;
12152 if (parens
.require_open (parser
))
12154 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
12155 c_expr expr
= c_parser_expression (parser
);
12156 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
12157 tree c
, t
= expr
.value
;
12158 t
= c_fully_fold (t
, false, NULL
);
12160 parens
.skip_until_found_close (parser
);
12162 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
12164 c_parser_error (parser
, "expected integer expression");
12168 /* Attempt to statically determine when the number isn't positive. */
12169 c
= fold_build2_loc (expr_loc
, LE_EXPR
, boolean_type_node
, t
,
12170 build_int_cst (TREE_TYPE (t
), 0));
12171 if (CAN_HAVE_LOCATION_P (c
))
12172 SET_EXPR_LOCATION (c
, expr_loc
);
12173 if (c
== boolean_true_node
)
12175 warning_at (expr_loc
, 0, "%<num_tasks%> value must be positive");
12176 t
= integer_one_node
;
12179 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_TASKS
, "num_tasks");
12181 c
= build_omp_clause (num_tasks_loc
, OMP_CLAUSE_NUM_TASKS
);
12182 OMP_CLAUSE_NUM_TASKS_EXPR (c
) = t
;
12183 OMP_CLAUSE_CHAIN (c
) = list
;
12191 grainsize ( expression ) */
12194 c_parser_omp_clause_grainsize (c_parser
*parser
, tree list
)
12196 location_t grainsize_loc
= c_parser_peek_token (parser
)->location
;
12197 matching_parens parens
;
12198 if (parens
.require_open (parser
))
12200 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
12201 c_expr expr
= c_parser_expression (parser
);
12202 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
12203 tree c
, t
= expr
.value
;
12204 t
= c_fully_fold (t
, false, NULL
);
12206 parens
.skip_until_found_close (parser
);
12208 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
12210 c_parser_error (parser
, "expected integer expression");
12214 /* Attempt to statically determine when the number isn't positive. */
12215 c
= fold_build2_loc (expr_loc
, LE_EXPR
, boolean_type_node
, t
,
12216 build_int_cst (TREE_TYPE (t
), 0));
12217 if (CAN_HAVE_LOCATION_P (c
))
12218 SET_EXPR_LOCATION (c
, expr_loc
);
12219 if (c
== boolean_true_node
)
12221 warning_at (expr_loc
, 0, "%<grainsize%> value must be positive");
12222 t
= integer_one_node
;
12225 check_no_duplicate_clause (list
, OMP_CLAUSE_GRAINSIZE
, "grainsize");
12227 c
= build_omp_clause (grainsize_loc
, OMP_CLAUSE_GRAINSIZE
);
12228 OMP_CLAUSE_GRAINSIZE_EXPR (c
) = t
;
12229 OMP_CLAUSE_CHAIN (c
) = list
;
12237 priority ( expression ) */
12240 c_parser_omp_clause_priority (c_parser
*parser
, tree list
)
12242 location_t priority_loc
= c_parser_peek_token (parser
)->location
;
12243 matching_parens parens
;
12244 if (parens
.require_open (parser
))
12246 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
12247 c_expr expr
= c_parser_expression (parser
);
12248 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
12249 tree c
, t
= expr
.value
;
12250 t
= c_fully_fold (t
, false, NULL
);
12252 parens
.skip_until_found_close (parser
);
12254 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
12256 c_parser_error (parser
, "expected integer expression");
12260 /* Attempt to statically determine when the number isn't
12262 c
= fold_build2_loc (expr_loc
, LT_EXPR
, boolean_type_node
, t
,
12263 build_int_cst (TREE_TYPE (t
), 0));
12264 if (CAN_HAVE_LOCATION_P (c
))
12265 SET_EXPR_LOCATION (c
, expr_loc
);
12266 if (c
== boolean_true_node
)
12268 warning_at (expr_loc
, 0, "%<priority%> value must be non-negative");
12269 t
= integer_one_node
;
12272 check_no_duplicate_clause (list
, OMP_CLAUSE_PRIORITY
, "priority");
12274 c
= build_omp_clause (priority_loc
, OMP_CLAUSE_PRIORITY
);
12275 OMP_CLAUSE_PRIORITY_EXPR (c
) = t
;
12276 OMP_CLAUSE_CHAIN (c
) = list
;
12284 hint ( expression ) */
12287 c_parser_omp_clause_hint (c_parser
*parser
, tree list
)
12289 location_t hint_loc
= c_parser_peek_token (parser
)->location
;
12290 matching_parens parens
;
12291 if (parens
.require_open (parser
))
12293 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
12294 c_expr expr
= c_parser_expression (parser
);
12295 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
12296 tree c
, t
= expr
.value
;
12297 t
= c_fully_fold (t
, false, NULL
);
12299 parens
.skip_until_found_close (parser
);
12301 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
12303 c_parser_error (parser
, "expected integer expression");
12307 check_no_duplicate_clause (list
, OMP_CLAUSE_HINT
, "hint");
12309 c
= build_omp_clause (hint_loc
, OMP_CLAUSE_HINT
);
12310 OMP_CLAUSE_HINT_EXPR (c
) = t
;
12311 OMP_CLAUSE_CHAIN (c
) = list
;
12319 defaultmap ( tofrom : scalar ) */
12322 c_parser_omp_clause_defaultmap (c_parser
*parser
, tree list
)
12324 location_t loc
= c_parser_peek_token (parser
)->location
;
12328 matching_parens parens
;
12329 if (!parens
.require_open (parser
))
12331 if (!c_parser_next_token_is (parser
, CPP_NAME
))
12333 c_parser_error (parser
, "expected %<tofrom%>");
12336 p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
12337 if (strcmp (p
, "tofrom") != 0)
12339 c_parser_error (parser
, "expected %<tofrom%>");
12342 c_parser_consume_token (parser
);
12343 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
12345 if (!c_parser_next_token_is (parser
, CPP_NAME
))
12347 c_parser_error (parser
, "expected %<scalar%>");
12350 p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
12351 if (strcmp (p
, "scalar") != 0)
12353 c_parser_error (parser
, "expected %<scalar%>");
12356 c_parser_consume_token (parser
);
12357 parens
.skip_until_found_close (parser
);
12358 check_no_duplicate_clause (list
, OMP_CLAUSE_DEFAULTMAP
, "defaultmap");
12359 c
= build_omp_clause (loc
, OMP_CLAUSE_DEFAULTMAP
);
12360 OMP_CLAUSE_CHAIN (c
) = list
;
12364 parens
.skip_until_found_close (parser
);
12369 use_device ( variable-list )
12372 use_device_ptr ( variable-list ) */
12375 c_parser_omp_clause_use_device_ptr (c_parser
*parser
, tree list
)
12377 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_USE_DEVICE_PTR
,
12382 is_device_ptr ( variable-list ) */
12385 c_parser_omp_clause_is_device_ptr (c_parser
*parser
, tree list
)
12387 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_IS_DEVICE_PTR
, list
);
12391 num_gangs ( expression )
12392 num_workers ( expression )
12393 vector_length ( expression ) */
12396 c_parser_oacc_single_int_clause (c_parser
*parser
, omp_clause_code code
,
12399 location_t loc
= c_parser_peek_token (parser
)->location
;
12401 matching_parens parens
;
12402 if (!parens
.require_open (parser
))
12405 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
12406 c_expr expr
= c_parser_expression (parser
);
12407 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
12408 tree c
, t
= expr
.value
;
12409 t
= c_fully_fold (t
, false, NULL
);
12411 parens
.skip_until_found_close (parser
);
12413 if (t
== error_mark_node
)
12415 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
12417 error_at (expr_loc
, "%qs expression must be integral",
12418 omp_clause_code_name
[code
]);
12422 /* Attempt to statically determine when the number isn't positive. */
12423 c
= fold_build2_loc (expr_loc
, LE_EXPR
, boolean_type_node
, t
,
12424 build_int_cst (TREE_TYPE (t
), 0));
12425 protected_set_expr_location (c
, expr_loc
);
12426 if (c
== boolean_true_node
)
12428 warning_at (expr_loc
, 0,
12429 "%qs value must be positive",
12430 omp_clause_code_name
[code
]);
12431 t
= integer_one_node
;
12434 check_no_duplicate_clause (list
, code
, omp_clause_code_name
[code
]);
12436 c
= build_omp_clause (loc
, code
);
12437 OMP_CLAUSE_OPERAND (c
, 0) = t
;
12438 OMP_CLAUSE_CHAIN (c
) = list
;
12444 gang [( gang-arg-list )]
12445 worker [( [num:] int-expr )]
12446 vector [( [length:] int-expr )]
12448 where gang-arg is one of:
12453 and size-expr may be:
12460 c_parser_oacc_shape_clause (c_parser
*parser
, omp_clause_code kind
,
12461 const char *str
, tree list
)
12463 const char *id
= "num";
12464 tree ops
[2] = { NULL_TREE
, NULL_TREE
}, c
;
12465 location_t loc
= c_parser_peek_token (parser
)->location
;
12467 if (kind
== OMP_CLAUSE_VECTOR
)
12470 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
12472 c_parser_consume_token (parser
);
12476 c_token
*next
= c_parser_peek_token (parser
);
12479 /* Gang static argument. */
12480 if (kind
== OMP_CLAUSE_GANG
12481 && c_parser_next_token_is_keyword (parser
, RID_STATIC
))
12483 c_parser_consume_token (parser
);
12485 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
12486 goto cleanup_error
;
12489 if (ops
[idx
] != NULL_TREE
)
12491 c_parser_error (parser
, "too many %<static%> arguments");
12492 goto cleanup_error
;
12495 /* Check for the '*' argument. */
12496 if (c_parser_next_token_is (parser
, CPP_MULT
)
12497 && (c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
12498 || c_parser_peek_2nd_token (parser
)->type
12499 == CPP_CLOSE_PAREN
))
12501 c_parser_consume_token (parser
);
12502 ops
[idx
] = integer_minus_one_node
;
12504 if (c_parser_next_token_is (parser
, CPP_COMMA
))
12506 c_parser_consume_token (parser
);
12513 /* Worker num: argument and vector length: arguments. */
12514 else if (c_parser_next_token_is (parser
, CPP_NAME
)
12515 && strcmp (id
, IDENTIFIER_POINTER (next
->value
)) == 0
12516 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
12518 c_parser_consume_token (parser
); /* id */
12519 c_parser_consume_token (parser
); /* ':' */
12522 /* Now collect the actual argument. */
12523 if (ops
[idx
] != NULL_TREE
)
12525 c_parser_error (parser
, "unexpected argument");
12526 goto cleanup_error
;
12529 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
12530 c_expr cexpr
= c_parser_expr_no_commas (parser
, NULL
);
12531 cexpr
= convert_lvalue_to_rvalue (expr_loc
, cexpr
, false, true);
12532 tree expr
= cexpr
.value
;
12533 if (expr
== error_mark_node
)
12534 goto cleanup_error
;
12536 expr
= c_fully_fold (expr
, false, NULL
);
12538 /* Attempt to statically determine when the number isn't a
12539 positive integer. */
12541 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
12543 c_parser_error (parser
, "expected integer expression");
12547 tree c
= fold_build2_loc (expr_loc
, LE_EXPR
, boolean_type_node
, expr
,
12548 build_int_cst (TREE_TYPE (expr
), 0));
12549 if (c
== boolean_true_node
)
12551 warning_at (loc
, 0,
12552 "%qs value must be positive", str
);
12553 expr
= integer_one_node
;
12558 if (kind
== OMP_CLAUSE_GANG
12559 && c_parser_next_token_is (parser
, CPP_COMMA
))
12561 c_parser_consume_token (parser
);
12568 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
12569 goto cleanup_error
;
12572 check_no_duplicate_clause (list
, kind
, str
);
12574 c
= build_omp_clause (loc
, kind
);
12577 OMP_CLAUSE_OPERAND (c
, 1) = ops
[1];
12579 OMP_CLAUSE_OPERAND (c
, 0) = ops
[0];
12580 OMP_CLAUSE_CHAIN (c
) = list
;
12585 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
12597 c_parser_oacc_simple_clause (c_parser
*parser
, enum omp_clause_code code
,
12600 check_no_duplicate_clause (list
, code
, omp_clause_code_name
[code
]);
12602 tree c
= build_omp_clause (c_parser_peek_token (parser
)->location
, code
);
12603 OMP_CLAUSE_CHAIN (c
) = list
;
12609 async [( int-expr )] */
12612 c_parser_oacc_clause_async (c_parser
*parser
, tree list
)
12615 location_t loc
= c_parser_peek_token (parser
)->location
;
12617 t
= build_int_cst (integer_type_node
, GOMP_ASYNC_NOVAL
);
12619 if (c_parser_peek_token (parser
)->type
== CPP_OPEN_PAREN
)
12621 c_parser_consume_token (parser
);
12623 t
= c_parser_expression (parser
).value
;
12624 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
12625 c_parser_error (parser
, "expected integer expression");
12626 else if (t
== error_mark_node
12627 || !c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
12631 t
= c_fully_fold (t
, false, NULL
);
12633 check_no_duplicate_clause (list
, OMP_CLAUSE_ASYNC
, "async");
12635 c
= build_omp_clause (loc
, OMP_CLAUSE_ASYNC
);
12636 OMP_CLAUSE_ASYNC_EXPR (c
) = t
;
12637 OMP_CLAUSE_CHAIN (c
) = list
;
12644 tile ( size-expr-list ) */
12647 c_parser_oacc_clause_tile (c_parser
*parser
, tree list
)
12649 tree c
, expr
= error_mark_node
;
12651 tree tile
= NULL_TREE
;
12653 check_no_duplicate_clause (list
, OMP_CLAUSE_TILE
, "tile");
12654 check_no_duplicate_clause (list
, OMP_CLAUSE_COLLAPSE
, "collapse");
12656 loc
= c_parser_peek_token (parser
)->location
;
12657 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
12662 if (tile
&& !c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
12665 if (c_parser_next_token_is (parser
, CPP_MULT
)
12666 && (c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
12667 || c_parser_peek_2nd_token (parser
)->type
== CPP_CLOSE_PAREN
))
12669 c_parser_consume_token (parser
);
12670 expr
= integer_zero_node
;
12674 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
12675 c_expr cexpr
= c_parser_expr_no_commas (parser
, NULL
);
12676 cexpr
= convert_lvalue_to_rvalue (expr_loc
, cexpr
, false, true);
12677 expr
= cexpr
.value
;
12679 if (expr
== error_mark_node
)
12681 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
12686 expr
= c_fully_fold (expr
, false, NULL
);
12688 if (!INTEGRAL_TYPE_P (TREE_TYPE (expr
))
12689 || !tree_fits_shwi_p (expr
)
12690 || tree_to_shwi (expr
) <= 0)
12692 error_at (expr_loc
, "%<tile%> argument needs positive"
12693 " integral constant");
12694 expr
= integer_zero_node
;
12698 tile
= tree_cons (NULL_TREE
, expr
, tile
);
12700 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
));
12702 /* Consume the trailing ')'. */
12703 c_parser_consume_token (parser
);
12705 c
= build_omp_clause (loc
, OMP_CLAUSE_TILE
);
12706 tile
= nreverse (tile
);
12707 OMP_CLAUSE_TILE_LIST (c
) = tile
;
12708 OMP_CLAUSE_CHAIN (c
) = list
;
12713 wait ( int-expr-list ) */
12716 c_parser_oacc_clause_wait (c_parser
*parser
, tree list
)
12718 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
12720 if (c_parser_peek_token (parser
)->type
== CPP_OPEN_PAREN
)
12721 list
= c_parser_oacc_wait_list (parser
, clause_loc
, list
);
12730 ordered ( constant-expression ) */
12733 c_parser_omp_clause_ordered (c_parser
*parser
, tree list
)
12735 check_no_duplicate_clause (list
, OMP_CLAUSE_ORDERED
, "ordered");
12737 tree c
, num
= NULL_TREE
;
12739 location_t loc
= c_parser_peek_token (parser
)->location
;
12740 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
12742 matching_parens parens
;
12743 parens
.consume_open (parser
);
12744 num
= c_parser_expr_no_commas (parser
, NULL
).value
;
12745 parens
.skip_until_found_close (parser
);
12747 if (num
== error_mark_node
)
12751 mark_exp_read (num
);
12752 num
= c_fully_fold (num
, false, NULL
);
12753 if (!INTEGRAL_TYPE_P (TREE_TYPE (num
))
12754 || !tree_fits_shwi_p (num
)
12755 || (n
= tree_to_shwi (num
)) <= 0
12758 error_at (loc
, "ordered argument needs positive "
12759 "constant integer expression");
12763 c
= build_omp_clause (loc
, OMP_CLAUSE_ORDERED
);
12764 OMP_CLAUSE_ORDERED_EXPR (c
) = num
;
12765 OMP_CLAUSE_CHAIN (c
) = list
;
12770 private ( variable-list ) */
12773 c_parser_omp_clause_private (c_parser
*parser
, tree list
)
12775 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_PRIVATE
, list
);
12779 reduction ( reduction-operator : variable-list )
12781 reduction-operator:
12782 One of: + * - & ^ | && ||
12786 reduction-operator:
12787 One of: + * - & ^ | && || max min
12791 reduction-operator:
12792 One of: + * - & ^ | && ||
12796 c_parser_omp_clause_reduction (c_parser
*parser
, tree list
)
12798 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
12799 matching_parens parens
;
12800 if (parens
.require_open (parser
))
12802 enum tree_code code
= ERROR_MARK
;
12803 tree reduc_id
= NULL_TREE
;
12805 switch (c_parser_peek_token (parser
)->type
)
12817 code
= BIT_AND_EXPR
;
12820 code
= BIT_XOR_EXPR
;
12823 code
= BIT_IOR_EXPR
;
12826 code
= TRUTH_ANDIF_EXPR
;
12829 code
= TRUTH_ORIF_EXPR
;
12834 = IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
12835 if (strcmp (p
, "min") == 0)
12840 if (strcmp (p
, "max") == 0)
12845 reduc_id
= c_parser_peek_token (parser
)->value
;
12849 c_parser_error (parser
,
12850 "expected %<+%>, %<*%>, %<-%>, %<&%>, "
12851 "%<^%>, %<|%>, %<&&%>, %<||%> or identifier");
12852 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
12855 c_parser_consume_token (parser
);
12856 reduc_id
= c_omp_reduction_id (code
, reduc_id
);
12857 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
12861 nl
= c_parser_omp_variable_list (parser
, clause_loc
,
12862 OMP_CLAUSE_REDUCTION
, list
);
12863 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
12865 tree d
= OMP_CLAUSE_DECL (c
), type
;
12866 if (TREE_CODE (d
) != TREE_LIST
)
12867 type
= TREE_TYPE (d
);
12872 for (t
= d
; TREE_CODE (t
) == TREE_LIST
; t
= TREE_CHAIN (t
))
12874 type
= TREE_TYPE (t
);
12877 if (TREE_CODE (type
) != POINTER_TYPE
12878 && TREE_CODE (type
) != ARRAY_TYPE
)
12880 type
= TREE_TYPE (type
);
12884 while (TREE_CODE (type
) == ARRAY_TYPE
)
12885 type
= TREE_TYPE (type
);
12886 OMP_CLAUSE_REDUCTION_CODE (c
) = code
;
12887 if (code
== ERROR_MARK
12888 || !(INTEGRAL_TYPE_P (type
)
12889 || TREE_CODE (type
) == REAL_TYPE
12890 || TREE_CODE (type
) == COMPLEX_TYPE
))
12891 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
)
12892 = c_omp_reduction_lookup (reduc_id
,
12893 TYPE_MAIN_VARIANT (type
));
12898 parens
.skip_until_found_close (parser
);
12904 schedule ( schedule-kind )
12905 schedule ( schedule-kind , expression )
12908 static | dynamic | guided | runtime | auto
12911 schedule ( schedule-modifier : schedule-kind )
12912 schedule ( schedule-modifier [ , schedule-modifier ] : schedule-kind , expression )
12920 c_parser_omp_clause_schedule (c_parser
*parser
, tree list
)
12923 location_t loc
= c_parser_peek_token (parser
)->location
;
12924 int modifiers
= 0, nmodifiers
= 0;
12926 matching_parens parens
;
12927 if (!parens
.require_open (parser
))
12930 c
= build_omp_clause (loc
, OMP_CLAUSE_SCHEDULE
);
12932 while (c_parser_next_token_is (parser
, CPP_NAME
))
12934 tree kind
= c_parser_peek_token (parser
)->value
;
12935 const char *p
= IDENTIFIER_POINTER (kind
);
12936 if (strcmp ("simd", p
) == 0)
12937 OMP_CLAUSE_SCHEDULE_SIMD (c
) = 1;
12938 else if (strcmp ("monotonic", p
) == 0)
12939 modifiers
|= OMP_CLAUSE_SCHEDULE_MONOTONIC
;
12940 else if (strcmp ("nonmonotonic", p
) == 0)
12941 modifiers
|= OMP_CLAUSE_SCHEDULE_NONMONOTONIC
;
12944 c_parser_consume_token (parser
);
12945 if (nmodifiers
++ == 0
12946 && c_parser_next_token_is (parser
, CPP_COMMA
))
12947 c_parser_consume_token (parser
);
12950 c_parser_require (parser
, CPP_COLON
, "expected %<:%>");
12955 if ((modifiers
& (OMP_CLAUSE_SCHEDULE_MONOTONIC
12956 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
12957 == (OMP_CLAUSE_SCHEDULE_MONOTONIC
12958 | OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
12960 error_at (loc
, "both %<monotonic%> and %<nonmonotonic%> modifiers "
12965 if (c_parser_next_token_is (parser
, CPP_NAME
))
12967 tree kind
= c_parser_peek_token (parser
)->value
;
12968 const char *p
= IDENTIFIER_POINTER (kind
);
12973 if (strcmp ("dynamic", p
) != 0)
12975 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_DYNAMIC
;
12979 if (strcmp ("guided", p
) != 0)
12981 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_GUIDED
;
12985 if (strcmp ("runtime", p
) != 0)
12987 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_RUNTIME
;
12994 else if (c_parser_next_token_is_keyword (parser
, RID_STATIC
))
12995 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_STATIC
;
12996 else if (c_parser_next_token_is_keyword (parser
, RID_AUTO
))
12997 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_AUTO
;
13001 c_parser_consume_token (parser
);
13002 if (c_parser_next_token_is (parser
, CPP_COMMA
))
13005 c_parser_consume_token (parser
);
13007 here
= c_parser_peek_token (parser
)->location
;
13008 c_expr expr
= c_parser_expr_no_commas (parser
, NULL
);
13009 expr
= convert_lvalue_to_rvalue (here
, expr
, false, true);
13011 t
= c_fully_fold (t
, false, NULL
);
13013 if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_RUNTIME
)
13014 error_at (here
, "schedule %<runtime%> does not take "
13015 "a %<chunk_size%> parameter");
13016 else if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_AUTO
)
13018 "schedule %<auto%> does not take "
13019 "a %<chunk_size%> parameter");
13020 else if (TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
)
13022 /* Attempt to statically determine when the number isn't
13024 tree s
= fold_build2_loc (loc
, LE_EXPR
, boolean_type_node
, t
,
13025 build_int_cst (TREE_TYPE (t
), 0));
13026 protected_set_expr_location (s
, loc
);
13027 if (s
== boolean_true_node
)
13029 warning_at (loc
, 0,
13030 "chunk size value must be positive");
13031 t
= integer_one_node
;
13033 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
13036 c_parser_error (parser
, "expected integer expression");
13038 parens
.skip_until_found_close (parser
);
13041 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
13042 "expected %<,%> or %<)%>");
13044 OMP_CLAUSE_SCHEDULE_KIND (c
)
13045 = (enum omp_clause_schedule_kind
)
13046 (OMP_CLAUSE_SCHEDULE_KIND (c
) | modifiers
);
13048 check_no_duplicate_clause (list
, OMP_CLAUSE_SCHEDULE
, "schedule");
13049 OMP_CLAUSE_CHAIN (c
) = list
;
13053 c_parser_error (parser
, "invalid schedule kind");
13054 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
13059 shared ( variable-list ) */
13062 c_parser_omp_clause_shared (c_parser
*parser
, tree list
)
13064 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_SHARED
, list
);
13071 c_parser_omp_clause_untied (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
13075 /* FIXME: Should we allow duplicates? */
13076 check_no_duplicate_clause (list
, OMP_CLAUSE_UNTIED
, "untied");
13078 c
= build_omp_clause (c_parser_peek_token (parser
)->location
,
13079 OMP_CLAUSE_UNTIED
);
13080 OMP_CLAUSE_CHAIN (c
) = list
;
13090 c_parser_omp_clause_branch (c_parser
*parser ATTRIBUTE_UNUSED
,
13091 enum omp_clause_code code
, tree list
)
13093 check_no_duplicate_clause (list
, code
, omp_clause_code_name
[code
]);
13095 tree c
= build_omp_clause (c_parser_peek_token (parser
)->location
, code
);
13096 OMP_CLAUSE_CHAIN (c
) = list
;
13108 c_parser_omp_clause_cancelkind (c_parser
*parser ATTRIBUTE_UNUSED
,
13109 enum omp_clause_code code
, tree list
)
13111 tree c
= build_omp_clause (c_parser_peek_token (parser
)->location
, code
);
13112 OMP_CLAUSE_CHAIN (c
) = list
;
13121 c_parser_omp_clause_nogroup (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
13123 check_no_duplicate_clause (list
, OMP_CLAUSE_NOGROUP
, "nogroup");
13124 tree c
= build_omp_clause (c_parser_peek_token (parser
)->location
,
13125 OMP_CLAUSE_NOGROUP
);
13126 OMP_CLAUSE_CHAIN (c
) = list
;
13135 c_parser_omp_clause_orderedkind (c_parser
*parser ATTRIBUTE_UNUSED
,
13136 enum omp_clause_code code
, tree list
)
13138 check_no_duplicate_clause (list
, code
, omp_clause_code_name
[code
]);
13139 tree c
= build_omp_clause (c_parser_peek_token (parser
)->location
, code
);
13140 OMP_CLAUSE_CHAIN (c
) = list
;
13145 num_teams ( expression ) */
13148 c_parser_omp_clause_num_teams (c_parser
*parser
, tree list
)
13150 location_t num_teams_loc
= c_parser_peek_token (parser
)->location
;
13151 matching_parens parens
;
13152 if (parens
.require_open (parser
))
13154 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
13155 c_expr expr
= c_parser_expression (parser
);
13156 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
13157 tree c
, t
= expr
.value
;
13158 t
= c_fully_fold (t
, false, NULL
);
13160 parens
.skip_until_found_close (parser
);
13162 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
13164 c_parser_error (parser
, "expected integer expression");
13168 /* Attempt to statically determine when the number isn't positive. */
13169 c
= fold_build2_loc (expr_loc
, LE_EXPR
, boolean_type_node
, t
,
13170 build_int_cst (TREE_TYPE (t
), 0));
13171 protected_set_expr_location (c
, expr_loc
);
13172 if (c
== boolean_true_node
)
13174 warning_at (expr_loc
, 0, "%<num_teams%> value must be positive");
13175 t
= integer_one_node
;
13178 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_TEAMS
, "num_teams");
13180 c
= build_omp_clause (num_teams_loc
, OMP_CLAUSE_NUM_TEAMS
);
13181 OMP_CLAUSE_NUM_TEAMS_EXPR (c
) = t
;
13182 OMP_CLAUSE_CHAIN (c
) = list
;
13190 thread_limit ( expression ) */
13193 c_parser_omp_clause_thread_limit (c_parser
*parser
, tree list
)
13195 location_t num_thread_limit_loc
= c_parser_peek_token (parser
)->location
;
13196 matching_parens parens
;
13197 if (parens
.require_open (parser
))
13199 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
13200 c_expr expr
= c_parser_expression (parser
);
13201 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
13202 tree c
, t
= expr
.value
;
13203 t
= c_fully_fold (t
, false, NULL
);
13205 parens
.skip_until_found_close (parser
);
13207 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
13209 c_parser_error (parser
, "expected integer expression");
13213 /* Attempt to statically determine when the number isn't positive. */
13214 c
= fold_build2_loc (expr_loc
, LE_EXPR
, boolean_type_node
, t
,
13215 build_int_cst (TREE_TYPE (t
), 0));
13216 protected_set_expr_location (c
, expr_loc
);
13217 if (c
== boolean_true_node
)
13219 warning_at (expr_loc
, 0, "%<thread_limit%> value must be positive");
13220 t
= integer_one_node
;
13223 check_no_duplicate_clause (list
, OMP_CLAUSE_THREAD_LIMIT
,
13226 c
= build_omp_clause (num_thread_limit_loc
, OMP_CLAUSE_THREAD_LIMIT
);
13227 OMP_CLAUSE_THREAD_LIMIT_EXPR (c
) = t
;
13228 OMP_CLAUSE_CHAIN (c
) = list
;
13236 aligned ( variable-list )
13237 aligned ( variable-list : constant-expression ) */
13240 c_parser_omp_clause_aligned (c_parser
*parser
, tree list
)
13242 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
13245 matching_parens parens
;
13246 if (!parens
.require_open (parser
))
13249 nl
= c_parser_omp_variable_list (parser
, clause_loc
,
13250 OMP_CLAUSE_ALIGNED
, list
);
13252 if (c_parser_next_token_is (parser
, CPP_COLON
))
13254 c_parser_consume_token (parser
);
13255 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
13256 c_expr expr
= c_parser_expr_no_commas (parser
, NULL
);
13257 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
13258 tree alignment
= expr
.value
;
13259 alignment
= c_fully_fold (alignment
, false, NULL
);
13260 if (TREE_CODE (alignment
) != INTEGER_CST
13261 || !INTEGRAL_TYPE_P (TREE_TYPE (alignment
))
13262 || tree_int_cst_sgn (alignment
) != 1)
13264 error_at (clause_loc
, "%<aligned%> clause alignment expression must "
13265 "be positive constant integer expression");
13266 alignment
= NULL_TREE
;
13269 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
13270 OMP_CLAUSE_ALIGNED_ALIGNMENT (c
) = alignment
;
13273 parens
.skip_until_found_close (parser
);
13278 linear ( variable-list )
13279 linear ( variable-list : expression )
13282 linear ( modifier ( variable-list ) )
13283 linear ( modifier ( variable-list ) : expression ) */
13286 c_parser_omp_clause_linear (c_parser
*parser
, tree list
)
13288 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
13290 enum omp_clause_linear_kind kind
= OMP_CLAUSE_LINEAR_DEFAULT
;
13292 matching_parens parens
;
13293 if (!parens
.require_open (parser
))
13296 if (c_parser_next_token_is (parser
, CPP_NAME
))
13298 c_token
*tok
= c_parser_peek_token (parser
);
13299 const char *p
= IDENTIFIER_POINTER (tok
->value
);
13300 if (strcmp ("val", p
) == 0)
13301 kind
= OMP_CLAUSE_LINEAR_VAL
;
13302 if (c_parser_peek_2nd_token (parser
)->type
!= CPP_OPEN_PAREN
)
13303 kind
= OMP_CLAUSE_LINEAR_DEFAULT
;
13304 if (kind
!= OMP_CLAUSE_LINEAR_DEFAULT
)
13306 c_parser_consume_token (parser
);
13307 c_parser_consume_token (parser
);
13311 nl
= c_parser_omp_variable_list (parser
, clause_loc
,
13312 OMP_CLAUSE_LINEAR
, list
);
13314 if (kind
!= OMP_CLAUSE_LINEAR_DEFAULT
)
13315 parens
.skip_until_found_close (parser
);
13317 if (c_parser_next_token_is (parser
, CPP_COLON
))
13319 c_parser_consume_token (parser
);
13320 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
13321 c_expr expr
= c_parser_expression (parser
);
13322 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
13324 step
= c_fully_fold (step
, false, NULL
);
13325 if (!INTEGRAL_TYPE_P (TREE_TYPE (step
)))
13327 error_at (clause_loc
, "%<linear%> clause step expression must "
13329 step
= integer_one_node
;
13334 step
= integer_one_node
;
13336 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
13338 OMP_CLAUSE_LINEAR_STEP (c
) = step
;
13339 OMP_CLAUSE_LINEAR_KIND (c
) = kind
;
13342 parens
.skip_until_found_close (parser
);
13347 safelen ( constant-expression ) */
13350 c_parser_omp_clause_safelen (c_parser
*parser
, tree list
)
13352 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
13355 matching_parens parens
;
13356 if (!parens
.require_open (parser
))
13359 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
13360 c_expr expr
= c_parser_expr_no_commas (parser
, NULL
);
13361 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
13363 t
= c_fully_fold (t
, false, NULL
);
13364 if (TREE_CODE (t
) != INTEGER_CST
13365 || !INTEGRAL_TYPE_P (TREE_TYPE (t
))
13366 || tree_int_cst_sgn (t
) != 1)
13368 error_at (clause_loc
, "%<safelen%> clause expression must "
13369 "be positive constant integer expression");
13373 parens
.skip_until_found_close (parser
);
13374 if (t
== NULL_TREE
|| t
== error_mark_node
)
13377 check_no_duplicate_clause (list
, OMP_CLAUSE_SAFELEN
, "safelen");
13379 c
= build_omp_clause (clause_loc
, OMP_CLAUSE_SAFELEN
);
13380 OMP_CLAUSE_SAFELEN_EXPR (c
) = t
;
13381 OMP_CLAUSE_CHAIN (c
) = list
;
13386 simdlen ( constant-expression ) */
13389 c_parser_omp_clause_simdlen (c_parser
*parser
, tree list
)
13391 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
13394 matching_parens parens
;
13395 if (!parens
.require_open (parser
))
13398 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
13399 c_expr expr
= c_parser_expr_no_commas (parser
, NULL
);
13400 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
13402 t
= c_fully_fold (t
, false, NULL
);
13403 if (TREE_CODE (t
) != INTEGER_CST
13404 || !INTEGRAL_TYPE_P (TREE_TYPE (t
))
13405 || tree_int_cst_sgn (t
) != 1)
13407 error_at (clause_loc
, "%<simdlen%> clause expression must "
13408 "be positive constant integer expression");
13412 parens
.skip_until_found_close (parser
);
13413 if (t
== NULL_TREE
|| t
== error_mark_node
)
13416 check_no_duplicate_clause (list
, OMP_CLAUSE_SIMDLEN
, "simdlen");
13418 c
= build_omp_clause (clause_loc
, OMP_CLAUSE_SIMDLEN
);
13419 OMP_CLAUSE_SIMDLEN_EXPR (c
) = t
;
13420 OMP_CLAUSE_CHAIN (c
) = list
;
13426 identifier [+/- integer]
13427 vec , identifier [+/- integer]
13431 c_parser_omp_clause_depend_sink (c_parser
*parser
, location_t clause_loc
,
13435 if (c_parser_next_token_is_not (parser
, CPP_NAME
)
13436 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
13438 c_parser_error (parser
, "expected identifier");
13442 while (c_parser_next_token_is (parser
, CPP_NAME
)
13443 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
13445 tree t
= lookup_name (c_parser_peek_token (parser
)->value
);
13446 tree addend
= NULL
;
13448 if (t
== NULL_TREE
)
13450 undeclared_variable (c_parser_peek_token (parser
)->location
,
13451 c_parser_peek_token (parser
)->value
);
13452 t
= error_mark_node
;
13455 c_parser_consume_token (parser
);
13458 if (c_parser_next_token_is (parser
, CPP_MINUS
))
13460 else if (!c_parser_next_token_is (parser
, CPP_PLUS
))
13462 addend
= integer_zero_node
;
13464 goto add_to_vector
;
13466 c_parser_consume_token (parser
);
13468 if (c_parser_next_token_is_not (parser
, CPP_NUMBER
))
13470 c_parser_error (parser
, "expected integer");
13474 addend
= c_parser_peek_token (parser
)->value
;
13475 if (TREE_CODE (addend
) != INTEGER_CST
)
13477 c_parser_error (parser
, "expected integer");
13480 c_parser_consume_token (parser
);
13483 if (t
!= error_mark_node
)
13485 vec
= tree_cons (addend
, t
, vec
);
13487 OMP_CLAUSE_DEPEND_SINK_NEGATIVE (vec
) = 1;
13490 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
13493 c_parser_consume_token (parser
);
13496 if (vec
== NULL_TREE
)
13499 tree u
= build_omp_clause (clause_loc
, OMP_CLAUSE_DEPEND
);
13500 OMP_CLAUSE_DEPEND_KIND (u
) = OMP_CLAUSE_DEPEND_SINK
;
13501 OMP_CLAUSE_DECL (u
) = nreverse (vec
);
13502 OMP_CLAUSE_CHAIN (u
) = list
;
13507 depend ( depend-kind: variable-list )
13515 depend ( sink : vec ) */
13518 c_parser_omp_clause_depend (c_parser
*parser
, tree list
)
13520 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
13521 enum omp_clause_depend_kind kind
= OMP_CLAUSE_DEPEND_INOUT
;
13524 matching_parens parens
;
13525 if (!parens
.require_open (parser
))
13528 if (c_parser_next_token_is (parser
, CPP_NAME
))
13530 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
13531 if (strcmp ("in", p
) == 0)
13532 kind
= OMP_CLAUSE_DEPEND_IN
;
13533 else if (strcmp ("inout", p
) == 0)
13534 kind
= OMP_CLAUSE_DEPEND_INOUT
;
13535 else if (strcmp ("out", p
) == 0)
13536 kind
= OMP_CLAUSE_DEPEND_OUT
;
13537 else if (strcmp ("source", p
) == 0)
13538 kind
= OMP_CLAUSE_DEPEND_SOURCE
;
13539 else if (strcmp ("sink", p
) == 0)
13540 kind
= OMP_CLAUSE_DEPEND_SINK
;
13547 c_parser_consume_token (parser
);
13549 if (kind
== OMP_CLAUSE_DEPEND_SOURCE
)
13551 c
= build_omp_clause (clause_loc
, OMP_CLAUSE_DEPEND
);
13552 OMP_CLAUSE_DEPEND_KIND (c
) = kind
;
13553 OMP_CLAUSE_DECL (c
) = NULL_TREE
;
13554 OMP_CLAUSE_CHAIN (c
) = list
;
13555 parens
.skip_until_found_close (parser
);
13559 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
13562 if (kind
== OMP_CLAUSE_DEPEND_SINK
)
13563 nl
= c_parser_omp_clause_depend_sink (parser
, clause_loc
, list
);
13566 nl
= c_parser_omp_variable_list (parser
, clause_loc
,
13567 OMP_CLAUSE_DEPEND
, list
);
13569 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
13570 OMP_CLAUSE_DEPEND_KIND (c
) = kind
;
13573 parens
.skip_until_found_close (parser
);
13577 c_parser_error (parser
, "invalid depend kind");
13579 parens
.skip_until_found_close (parser
);
13584 map ( map-kind: variable-list )
13585 map ( variable-list )
13588 alloc | to | from | tofrom
13592 alloc | to | from | tofrom | release | delete
13594 map ( always [,] map-kind: variable-list ) */
13597 c_parser_omp_clause_map (c_parser
*parser
, tree list
)
13599 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
13600 enum gomp_map_kind kind
= GOMP_MAP_TOFROM
;
13602 enum c_id_kind always_id_kind
= C_ID_NONE
;
13603 location_t always_loc
= UNKNOWN_LOCATION
;
13604 tree always_id
= NULL_TREE
;
13607 matching_parens parens
;
13608 if (!parens
.require_open (parser
))
13611 if (c_parser_next_token_is (parser
, CPP_NAME
))
13613 c_token
*tok
= c_parser_peek_token (parser
);
13614 const char *p
= IDENTIFIER_POINTER (tok
->value
);
13615 always_id_kind
= tok
->id_kind
;
13616 always_loc
= tok
->location
;
13617 always_id
= tok
->value
;
13618 if (strcmp ("always", p
) == 0)
13620 c_token
*sectok
= c_parser_peek_2nd_token (parser
);
13621 if (sectok
->type
== CPP_COMMA
)
13623 c_parser_consume_token (parser
);
13624 c_parser_consume_token (parser
);
13627 else if (sectok
->type
== CPP_NAME
)
13629 p
= IDENTIFIER_POINTER (sectok
->value
);
13630 if (strcmp ("alloc", p
) == 0
13631 || strcmp ("to", p
) == 0
13632 || strcmp ("from", p
) == 0
13633 || strcmp ("tofrom", p
) == 0
13634 || strcmp ("release", p
) == 0
13635 || strcmp ("delete", p
) == 0)
13637 c_parser_consume_token (parser
);
13644 if (c_parser_next_token_is (parser
, CPP_NAME
)
13645 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
13647 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
13648 if (strcmp ("alloc", p
) == 0)
13649 kind
= GOMP_MAP_ALLOC
;
13650 else if (strcmp ("to", p
) == 0)
13651 kind
= always
? GOMP_MAP_ALWAYS_TO
: GOMP_MAP_TO
;
13652 else if (strcmp ("from", p
) == 0)
13653 kind
= always
? GOMP_MAP_ALWAYS_FROM
: GOMP_MAP_FROM
;
13654 else if (strcmp ("tofrom", p
) == 0)
13655 kind
= always
? GOMP_MAP_ALWAYS_TOFROM
: GOMP_MAP_TOFROM
;
13656 else if (strcmp ("release", p
) == 0)
13657 kind
= GOMP_MAP_RELEASE
;
13658 else if (strcmp ("delete", p
) == 0)
13659 kind
= GOMP_MAP_DELETE
;
13662 c_parser_error (parser
, "invalid map kind");
13663 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
13667 c_parser_consume_token (parser
);
13668 c_parser_consume_token (parser
);
13672 if (always_id_kind
!= C_ID_ID
)
13674 c_parser_error (parser
, "expected identifier");
13675 parens
.skip_until_found_close (parser
);
13679 tree t
= lookup_name (always_id
);
13680 if (t
== NULL_TREE
)
13682 undeclared_variable (always_loc
, always_id
);
13683 t
= error_mark_node
;
13685 if (t
!= error_mark_node
)
13687 tree u
= build_omp_clause (clause_loc
, OMP_CLAUSE_MAP
);
13688 OMP_CLAUSE_DECL (u
) = t
;
13689 OMP_CLAUSE_CHAIN (u
) = list
;
13690 OMP_CLAUSE_SET_MAP_KIND (u
, kind
);
13695 parens
.skip_until_found_close (parser
);
13700 nl
= c_parser_omp_variable_list (parser
, clause_loc
, OMP_CLAUSE_MAP
, list
);
13702 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
13703 OMP_CLAUSE_SET_MAP_KIND (c
, kind
);
13705 parens
.skip_until_found_close (parser
);
13710 device ( expression ) */
13713 c_parser_omp_clause_device (c_parser
*parser
, tree list
)
13715 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
13716 matching_parens parens
;
13717 if (parens
.require_open (parser
))
13719 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
13720 c_expr expr
= c_parser_expr_no_commas (parser
, NULL
);
13721 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
13722 tree c
, t
= expr
.value
;
13723 t
= c_fully_fold (t
, false, NULL
);
13725 parens
.skip_until_found_close (parser
);
13727 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
13729 c_parser_error (parser
, "expected integer expression");
13733 check_no_duplicate_clause (list
, OMP_CLAUSE_DEVICE
, "device");
13735 c
= build_omp_clause (clause_loc
, OMP_CLAUSE_DEVICE
);
13736 OMP_CLAUSE_DEVICE_ID (c
) = t
;
13737 OMP_CLAUSE_CHAIN (c
) = list
;
13745 dist_schedule ( static )
13746 dist_schedule ( static , expression ) */
13749 c_parser_omp_clause_dist_schedule (c_parser
*parser
, tree list
)
13751 tree c
, t
= NULL_TREE
;
13752 location_t loc
= c_parser_peek_token (parser
)->location
;
13754 matching_parens parens
;
13755 if (!parens
.require_open (parser
))
13758 if (!c_parser_next_token_is_keyword (parser
, RID_STATIC
))
13760 c_parser_error (parser
, "invalid dist_schedule kind");
13761 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
13766 c_parser_consume_token (parser
);
13767 if (c_parser_next_token_is (parser
, CPP_COMMA
))
13769 c_parser_consume_token (parser
);
13771 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
13772 c_expr expr
= c_parser_expr_no_commas (parser
, NULL
);
13773 expr
= convert_lvalue_to_rvalue (expr_loc
, expr
, false, true);
13775 t
= c_fully_fold (t
, false, NULL
);
13776 parens
.skip_until_found_close (parser
);
13779 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
13780 "expected %<,%> or %<)%>");
13782 check_no_duplicate_clause (list
, OMP_CLAUSE_SCHEDULE
, "schedule");
13783 if (t
== error_mark_node
)
13786 c
= build_omp_clause (loc
, OMP_CLAUSE_DIST_SCHEDULE
);
13787 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c
) = t
;
13788 OMP_CLAUSE_CHAIN (c
) = list
;
13793 proc_bind ( proc-bind-kind )
13796 master | close | spread */
13799 c_parser_omp_clause_proc_bind (c_parser
*parser
, tree list
)
13801 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
13802 enum omp_clause_proc_bind_kind kind
;
13805 matching_parens parens
;
13806 if (!parens
.require_open (parser
))
13809 if (c_parser_next_token_is (parser
, CPP_NAME
))
13811 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
13812 if (strcmp ("master", p
) == 0)
13813 kind
= OMP_CLAUSE_PROC_BIND_MASTER
;
13814 else if (strcmp ("close", p
) == 0)
13815 kind
= OMP_CLAUSE_PROC_BIND_CLOSE
;
13816 else if (strcmp ("spread", p
) == 0)
13817 kind
= OMP_CLAUSE_PROC_BIND_SPREAD
;
13824 c_parser_consume_token (parser
);
13825 parens
.skip_until_found_close (parser
);
13826 c
= build_omp_clause (clause_loc
, OMP_CLAUSE_PROC_BIND
);
13827 OMP_CLAUSE_PROC_BIND_KIND (c
) = kind
;
13828 OMP_CLAUSE_CHAIN (c
) = list
;
13832 c_parser_error (parser
, "invalid proc_bind kind");
13833 parens
.skip_until_found_close (parser
);
13838 to ( variable-list ) */
13841 c_parser_omp_clause_to (c_parser
*parser
, tree list
)
13843 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_TO
, list
);
13847 from ( variable-list ) */
13850 c_parser_omp_clause_from (c_parser
*parser
, tree list
)
13852 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_FROM
, list
);
13856 uniform ( variable-list ) */
13859 c_parser_omp_clause_uniform (c_parser
*parser
, tree list
)
13861 /* The clauses location. */
13862 location_t loc
= c_parser_peek_token (parser
)->location
;
13864 matching_parens parens
;
13865 if (parens
.require_open (parser
))
13867 list
= c_parser_omp_variable_list (parser
, loc
, OMP_CLAUSE_UNIFORM
,
13869 parens
.skip_until_found_close (parser
);
13874 /* Parse all OpenACC clauses. The set clauses allowed by the directive
13875 is a bitmask in MASK. Return the list of clauses found. */
13878 c_parser_oacc_all_clauses (c_parser
*parser
, omp_clause_mask mask
,
13879 const char *where
, bool finish_p
= true)
13881 tree clauses
= NULL
;
13884 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
13887 pragma_omp_clause c_kind
;
13888 const char *c_name
;
13889 tree prev
= clauses
;
13891 if (!first
&& c_parser_next_token_is (parser
, CPP_COMMA
))
13892 c_parser_consume_token (parser
);
13894 here
= c_parser_peek_token (parser
)->location
;
13895 c_kind
= c_parser_omp_clause_name (parser
);
13899 case PRAGMA_OACC_CLAUSE_ASYNC
:
13900 clauses
= c_parser_oacc_clause_async (parser
, clauses
);
13903 case PRAGMA_OACC_CLAUSE_AUTO
:
13904 clauses
= c_parser_oacc_simple_clause (parser
, OMP_CLAUSE_AUTO
,
13908 case PRAGMA_OACC_CLAUSE_COLLAPSE
:
13909 clauses
= c_parser_omp_clause_collapse (parser
, clauses
);
13910 c_name
= "collapse";
13912 case PRAGMA_OACC_CLAUSE_COPY
:
13913 clauses
= c_parser_oacc_data_clause (parser
, c_kind
, clauses
);
13916 case PRAGMA_OACC_CLAUSE_COPYIN
:
13917 clauses
= c_parser_oacc_data_clause (parser
, c_kind
, clauses
);
13920 case PRAGMA_OACC_CLAUSE_COPYOUT
:
13921 clauses
= c_parser_oacc_data_clause (parser
, c_kind
, clauses
);
13922 c_name
= "copyout";
13924 case PRAGMA_OACC_CLAUSE_CREATE
:
13925 clauses
= c_parser_oacc_data_clause (parser
, c_kind
, clauses
);
13928 case PRAGMA_OACC_CLAUSE_DELETE
:
13929 clauses
= c_parser_oacc_data_clause (parser
, c_kind
, clauses
);
13932 case PRAGMA_OMP_CLAUSE_DEFAULT
:
13933 clauses
= c_parser_omp_clause_default (parser
, clauses
, true);
13934 c_name
= "default";
13936 case PRAGMA_OACC_CLAUSE_DEVICE
:
13937 clauses
= c_parser_oacc_data_clause (parser
, c_kind
, clauses
);
13940 case PRAGMA_OACC_CLAUSE_DEVICEPTR
:
13941 clauses
= c_parser_oacc_data_clause_deviceptr (parser
, clauses
);
13942 c_name
= "deviceptr";
13944 case PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT
:
13945 clauses
= c_parser_oacc_data_clause (parser
, c_kind
, clauses
);
13946 c_name
= "device_resident";
13948 case PRAGMA_OACC_CLAUSE_FINALIZE
:
13949 clauses
= c_parser_oacc_simple_clause (parser
, OMP_CLAUSE_FINALIZE
,
13951 c_name
= "finalize";
13953 case PRAGMA_OACC_CLAUSE_FIRSTPRIVATE
:
13954 clauses
= c_parser_omp_clause_firstprivate (parser
, clauses
);
13955 c_name
= "firstprivate";
13957 case PRAGMA_OACC_CLAUSE_GANG
:
13959 clauses
= c_parser_oacc_shape_clause (parser
, OMP_CLAUSE_GANG
,
13962 case PRAGMA_OACC_CLAUSE_HOST
:
13963 clauses
= c_parser_oacc_data_clause (parser
, c_kind
, clauses
);
13966 case PRAGMA_OACC_CLAUSE_IF
:
13967 clauses
= c_parser_omp_clause_if (parser
, clauses
, false);
13970 case PRAGMA_OACC_CLAUSE_IF_PRESENT
:
13971 clauses
= c_parser_oacc_simple_clause (parser
, OMP_CLAUSE_IF_PRESENT
,
13973 c_name
= "if_present";
13975 case PRAGMA_OACC_CLAUSE_INDEPENDENT
:
13976 clauses
= c_parser_oacc_simple_clause (parser
, OMP_CLAUSE_INDEPENDENT
,
13978 c_name
= "independent";
13980 case PRAGMA_OACC_CLAUSE_LINK
:
13981 clauses
= c_parser_oacc_data_clause (parser
, c_kind
, clauses
);
13984 case PRAGMA_OACC_CLAUSE_NUM_GANGS
:
13985 clauses
= c_parser_oacc_single_int_clause (parser
,
13986 OMP_CLAUSE_NUM_GANGS
,
13988 c_name
= "num_gangs";
13990 case PRAGMA_OACC_CLAUSE_NUM_WORKERS
:
13991 clauses
= c_parser_oacc_single_int_clause (parser
,
13992 OMP_CLAUSE_NUM_WORKERS
,
13994 c_name
= "num_workers";
13996 case PRAGMA_OACC_CLAUSE_PRESENT
:
13997 clauses
= c_parser_oacc_data_clause (parser
, c_kind
, clauses
);
13998 c_name
= "present";
14000 case PRAGMA_OACC_CLAUSE_PRIVATE
:
14001 clauses
= c_parser_omp_clause_private (parser
, clauses
);
14002 c_name
= "private";
14004 case PRAGMA_OACC_CLAUSE_REDUCTION
:
14005 clauses
= c_parser_omp_clause_reduction (parser
, clauses
);
14006 c_name
= "reduction";
14008 case PRAGMA_OACC_CLAUSE_SEQ
:
14009 clauses
= c_parser_oacc_simple_clause (parser
, OMP_CLAUSE_SEQ
,
14013 case PRAGMA_OACC_CLAUSE_TILE
:
14014 clauses
= c_parser_oacc_clause_tile (parser
, clauses
);
14017 case PRAGMA_OACC_CLAUSE_USE_DEVICE
:
14018 clauses
= c_parser_omp_clause_use_device_ptr (parser
, clauses
);
14019 c_name
= "use_device";
14021 case PRAGMA_OACC_CLAUSE_VECTOR
:
14023 clauses
= c_parser_oacc_shape_clause (parser
, OMP_CLAUSE_VECTOR
,
14026 case PRAGMA_OACC_CLAUSE_VECTOR_LENGTH
:
14027 clauses
= c_parser_oacc_single_int_clause (parser
,
14028 OMP_CLAUSE_VECTOR_LENGTH
,
14030 c_name
= "vector_length";
14032 case PRAGMA_OACC_CLAUSE_WAIT
:
14033 clauses
= c_parser_oacc_clause_wait (parser
, clauses
);
14036 case PRAGMA_OACC_CLAUSE_WORKER
:
14038 clauses
= c_parser_oacc_shape_clause (parser
, OMP_CLAUSE_WORKER
,
14042 c_parser_error (parser
, "expected %<#pragma acc%> clause");
14048 if (((mask
>> c_kind
) & 1) == 0)
14050 /* Remove the invalid clause(s) from the list to avoid
14051 confusing the rest of the compiler. */
14053 error_at (here
, "%qs is not valid for %qs", c_name
, where
);
14058 c_parser_skip_to_pragma_eol (parser
);
14061 return c_finish_omp_clauses (clauses
, C_ORT_ACC
);
14066 /* Parse all OpenMP clauses. The set clauses allowed by the directive
14067 is a bitmask in MASK. Return the list of clauses found. */
14070 c_parser_omp_all_clauses (c_parser
*parser
, omp_clause_mask mask
,
14071 const char *where
, bool finish_p
= true)
14073 tree clauses
= NULL
;
14076 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
14079 pragma_omp_clause c_kind
;
14080 const char *c_name
;
14081 tree prev
= clauses
;
14083 if (!first
&& c_parser_next_token_is (parser
, CPP_COMMA
))
14084 c_parser_consume_token (parser
);
14086 here
= c_parser_peek_token (parser
)->location
;
14087 c_kind
= c_parser_omp_clause_name (parser
);
14091 case PRAGMA_OMP_CLAUSE_COLLAPSE
:
14092 clauses
= c_parser_omp_clause_collapse (parser
, clauses
);
14093 c_name
= "collapse";
14095 case PRAGMA_OMP_CLAUSE_COPYIN
:
14096 clauses
= c_parser_omp_clause_copyin (parser
, clauses
);
14099 case PRAGMA_OMP_CLAUSE_COPYPRIVATE
:
14100 clauses
= c_parser_omp_clause_copyprivate (parser
, clauses
);
14101 c_name
= "copyprivate";
14103 case PRAGMA_OMP_CLAUSE_DEFAULT
:
14104 clauses
= c_parser_omp_clause_default (parser
, clauses
, false);
14105 c_name
= "default";
14107 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
:
14108 clauses
= c_parser_omp_clause_firstprivate (parser
, clauses
);
14109 c_name
= "firstprivate";
14111 case PRAGMA_OMP_CLAUSE_FINAL
:
14112 clauses
= c_parser_omp_clause_final (parser
, clauses
);
14115 case PRAGMA_OMP_CLAUSE_GRAINSIZE
:
14116 clauses
= c_parser_omp_clause_grainsize (parser
, clauses
);
14117 c_name
= "grainsize";
14119 case PRAGMA_OMP_CLAUSE_HINT
:
14120 clauses
= c_parser_omp_clause_hint (parser
, clauses
);
14123 case PRAGMA_OMP_CLAUSE_DEFAULTMAP
:
14124 clauses
= c_parser_omp_clause_defaultmap (parser
, clauses
);
14125 c_name
= "defaultmap";
14127 case PRAGMA_OMP_CLAUSE_IF
:
14128 clauses
= c_parser_omp_clause_if (parser
, clauses
, true);
14131 case PRAGMA_OMP_CLAUSE_LASTPRIVATE
:
14132 clauses
= c_parser_omp_clause_lastprivate (parser
, clauses
);
14133 c_name
= "lastprivate";
14135 case PRAGMA_OMP_CLAUSE_MERGEABLE
:
14136 clauses
= c_parser_omp_clause_mergeable (parser
, clauses
);
14137 c_name
= "mergeable";
14139 case PRAGMA_OMP_CLAUSE_NOWAIT
:
14140 clauses
= c_parser_omp_clause_nowait (parser
, clauses
);
14143 case PRAGMA_OMP_CLAUSE_NUM_TASKS
:
14144 clauses
= c_parser_omp_clause_num_tasks (parser
, clauses
);
14145 c_name
= "num_tasks";
14147 case PRAGMA_OMP_CLAUSE_NUM_THREADS
:
14148 clauses
= c_parser_omp_clause_num_threads (parser
, clauses
);
14149 c_name
= "num_threads";
14151 case PRAGMA_OMP_CLAUSE_ORDERED
:
14152 clauses
= c_parser_omp_clause_ordered (parser
, clauses
);
14153 c_name
= "ordered";
14155 case PRAGMA_OMP_CLAUSE_PRIORITY
:
14156 clauses
= c_parser_omp_clause_priority (parser
, clauses
);
14157 c_name
= "priority";
14159 case PRAGMA_OMP_CLAUSE_PRIVATE
:
14160 clauses
= c_parser_omp_clause_private (parser
, clauses
);
14161 c_name
= "private";
14163 case PRAGMA_OMP_CLAUSE_REDUCTION
:
14164 clauses
= c_parser_omp_clause_reduction (parser
, clauses
);
14165 c_name
= "reduction";
14167 case PRAGMA_OMP_CLAUSE_SCHEDULE
:
14168 clauses
= c_parser_omp_clause_schedule (parser
, clauses
);
14169 c_name
= "schedule";
14171 case PRAGMA_OMP_CLAUSE_SHARED
:
14172 clauses
= c_parser_omp_clause_shared (parser
, clauses
);
14175 case PRAGMA_OMP_CLAUSE_UNTIED
:
14176 clauses
= c_parser_omp_clause_untied (parser
, clauses
);
14179 case PRAGMA_OMP_CLAUSE_INBRANCH
:
14180 clauses
= c_parser_omp_clause_branch (parser
, OMP_CLAUSE_INBRANCH
,
14182 c_name
= "inbranch";
14184 case PRAGMA_OMP_CLAUSE_NOTINBRANCH
:
14185 clauses
= c_parser_omp_clause_branch (parser
, OMP_CLAUSE_NOTINBRANCH
,
14187 c_name
= "notinbranch";
14189 case PRAGMA_OMP_CLAUSE_PARALLEL
:
14191 = c_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_PARALLEL
,
14193 c_name
= "parallel";
14197 error_at (here
, "%qs must be the first clause of %qs",
14202 case PRAGMA_OMP_CLAUSE_FOR
:
14204 = c_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_FOR
,
14208 goto clause_not_first
;
14210 case PRAGMA_OMP_CLAUSE_SECTIONS
:
14212 = c_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_SECTIONS
,
14214 c_name
= "sections";
14216 goto clause_not_first
;
14218 case PRAGMA_OMP_CLAUSE_TASKGROUP
:
14220 = c_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_TASKGROUP
,
14222 c_name
= "taskgroup";
14224 goto clause_not_first
;
14226 case PRAGMA_OMP_CLAUSE_LINK
:
14228 = c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_LINK
, clauses
);
14231 case PRAGMA_OMP_CLAUSE_TO
:
14232 if ((mask
& (OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_LINK
)) != 0)
14234 = c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_TO_DECLARE
,
14237 clauses
= c_parser_omp_clause_to (parser
, clauses
);
14240 case PRAGMA_OMP_CLAUSE_FROM
:
14241 clauses
= c_parser_omp_clause_from (parser
, clauses
);
14244 case PRAGMA_OMP_CLAUSE_UNIFORM
:
14245 clauses
= c_parser_omp_clause_uniform (parser
, clauses
);
14246 c_name
= "uniform";
14248 case PRAGMA_OMP_CLAUSE_NUM_TEAMS
:
14249 clauses
= c_parser_omp_clause_num_teams (parser
, clauses
);
14250 c_name
= "num_teams";
14252 case PRAGMA_OMP_CLAUSE_THREAD_LIMIT
:
14253 clauses
= c_parser_omp_clause_thread_limit (parser
, clauses
);
14254 c_name
= "thread_limit";
14256 case PRAGMA_OMP_CLAUSE_ALIGNED
:
14257 clauses
= c_parser_omp_clause_aligned (parser
, clauses
);
14258 c_name
= "aligned";
14260 case PRAGMA_OMP_CLAUSE_LINEAR
:
14261 clauses
= c_parser_omp_clause_linear (parser
, clauses
);
14264 case PRAGMA_OMP_CLAUSE_DEPEND
:
14265 clauses
= c_parser_omp_clause_depend (parser
, clauses
);
14268 case PRAGMA_OMP_CLAUSE_MAP
:
14269 clauses
= c_parser_omp_clause_map (parser
, clauses
);
14272 case PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR
:
14273 clauses
= c_parser_omp_clause_use_device_ptr (parser
, clauses
);
14274 c_name
= "use_device_ptr";
14276 case PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR
:
14277 clauses
= c_parser_omp_clause_is_device_ptr (parser
, clauses
);
14278 c_name
= "is_device_ptr";
14280 case PRAGMA_OMP_CLAUSE_DEVICE
:
14281 clauses
= c_parser_omp_clause_device (parser
, clauses
);
14284 case PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
:
14285 clauses
= c_parser_omp_clause_dist_schedule (parser
, clauses
);
14286 c_name
= "dist_schedule";
14288 case PRAGMA_OMP_CLAUSE_PROC_BIND
:
14289 clauses
= c_parser_omp_clause_proc_bind (parser
, clauses
);
14290 c_name
= "proc_bind";
14292 case PRAGMA_OMP_CLAUSE_SAFELEN
:
14293 clauses
= c_parser_omp_clause_safelen (parser
, clauses
);
14294 c_name
= "safelen";
14296 case PRAGMA_OMP_CLAUSE_SIMDLEN
:
14297 clauses
= c_parser_omp_clause_simdlen (parser
, clauses
);
14298 c_name
= "simdlen";
14300 case PRAGMA_OMP_CLAUSE_NOGROUP
:
14301 clauses
= c_parser_omp_clause_nogroup (parser
, clauses
);
14302 c_name
= "nogroup";
14304 case PRAGMA_OMP_CLAUSE_THREADS
:
14306 = c_parser_omp_clause_orderedkind (parser
, OMP_CLAUSE_THREADS
,
14308 c_name
= "threads";
14310 case PRAGMA_OMP_CLAUSE_SIMD
:
14312 = c_parser_omp_clause_orderedkind (parser
, OMP_CLAUSE_SIMD
,
14317 c_parser_error (parser
, "expected %<#pragma omp%> clause");
14323 if (((mask
>> c_kind
) & 1) == 0)
14325 /* Remove the invalid clause(s) from the list to avoid
14326 confusing the rest of the compiler. */
14328 error_at (here
, "%qs is not valid for %qs", c_name
, where
);
14333 c_parser_skip_to_pragma_eol (parser
);
14337 if ((mask
& (OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_UNIFORM
)) != 0)
14338 return c_finish_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
);
14339 return c_finish_omp_clauses (clauses
, C_ORT_OMP
);
14345 /* OpenACC 2.0, OpenMP 2.5:
14349 In practice, we're also interested in adding the statement to an
14350 outer node. So it is convenient if we work around the fact that
14351 c_parser_statement calls add_stmt. */
14354 c_parser_omp_structured_block (c_parser
*parser
, bool *if_p
)
14356 tree stmt
= push_stmt_list ();
14357 c_parser_statement (parser
, if_p
);
14358 return pop_stmt_list (stmt
);
14362 # pragma acc cache (variable-list) new-line
14364 LOC is the location of the #pragma token.
14368 c_parser_oacc_cache (location_t loc
, c_parser
*parser
)
14370 tree stmt
, clauses
;
14372 clauses
= c_parser_omp_var_list_parens (parser
, OMP_CLAUSE__CACHE_
, NULL
);
14373 clauses
= c_finish_omp_clauses (clauses
, C_ORT_ACC
);
14375 c_parser_skip_to_pragma_eol (parser
);
14377 stmt
= make_node (OACC_CACHE
);
14378 TREE_TYPE (stmt
) = void_type_node
;
14379 OACC_CACHE_CLAUSES (stmt
) = clauses
;
14380 SET_EXPR_LOCATION (stmt
, loc
);
14387 # pragma acc data oacc-data-clause[optseq] new-line
14390 LOC is the location of the #pragma token.
14393 #define OACC_DATA_CLAUSE_MASK \
14394 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
14395 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
14396 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
14397 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
14398 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
14399 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
14400 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT))
14403 c_parser_oacc_data (location_t loc
, c_parser
*parser
, bool *if_p
)
14405 tree stmt
, clauses
, block
;
14407 clauses
= c_parser_oacc_all_clauses (parser
, OACC_DATA_CLAUSE_MASK
,
14408 "#pragma acc data");
14410 block
= c_begin_omp_parallel ();
14411 add_stmt (c_parser_omp_structured_block (parser
, if_p
));
14413 stmt
= c_finish_oacc_data (loc
, clauses
, block
);
14419 # pragma acc declare oacc-data-clause[optseq] new-line
14422 #define OACC_DECLARE_CLAUSE_MASK \
14423 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
14424 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
14425 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
14426 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
14427 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
14428 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT) \
14429 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_LINK) \
14430 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT))
14433 c_parser_oacc_declare (c_parser
*parser
)
14435 location_t pragma_loc
= c_parser_peek_token (parser
)->location
;
14436 tree clauses
, stmt
, t
, decl
;
14438 bool error
= false;
14440 c_parser_consume_pragma (parser
);
14442 clauses
= c_parser_oacc_all_clauses (parser
, OACC_DECLARE_CLAUSE_MASK
,
14443 "#pragma acc declare");
14446 error_at (pragma_loc
,
14447 "no valid clauses specified in %<#pragma acc declare%>");
14451 for (t
= clauses
; t
; t
= OMP_CLAUSE_CHAIN (t
))
14453 location_t loc
= OMP_CLAUSE_LOCATION (t
);
14454 decl
= OMP_CLAUSE_DECL (t
);
14455 if (!DECL_P (decl
))
14457 error_at (loc
, "array section in %<#pragma acc declare%>");
14462 switch (OMP_CLAUSE_MAP_KIND (t
))
14464 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
14465 case GOMP_MAP_ALLOC
:
14467 case GOMP_MAP_FORCE_DEVICEPTR
:
14468 case GOMP_MAP_DEVICE_RESIDENT
:
14471 case GOMP_MAP_LINK
:
14472 if (!global_bindings_p ()
14473 && (TREE_STATIC (decl
)
14474 || !DECL_EXTERNAL (decl
)))
14477 "%qD must be a global variable in "
14478 "%<#pragma acc declare link%>",
14486 if (global_bindings_p ())
14488 error_at (loc
, "invalid OpenACC clause at file scope");
14492 if (DECL_EXTERNAL (decl
))
14495 "invalid use of %<extern%> variable %qD "
14496 "in %<#pragma acc declare%>", decl
);
14500 else if (TREE_PUBLIC (decl
))
14503 "invalid use of %<global%> variable %qD "
14504 "in %<#pragma acc declare%>", decl
);
14511 if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl
))
14512 || lookup_attribute ("omp declare target link",
14513 DECL_ATTRIBUTES (decl
)))
14515 error_at (loc
, "variable %qD used more than once with "
14516 "%<#pragma acc declare%>", decl
);
14525 if (OMP_CLAUSE_MAP_KIND (t
) == GOMP_MAP_LINK
)
14526 id
= get_identifier ("omp declare target link");
14528 id
= get_identifier ("omp declare target");
14530 DECL_ATTRIBUTES (decl
)
14531 = tree_cons (id
, NULL_TREE
, DECL_ATTRIBUTES (decl
));
14533 if (global_bindings_p ())
14535 symtab_node
*node
= symtab_node::get (decl
);
14538 node
->offloadable
= 1;
14539 if (ENABLE_OFFLOADING
)
14541 g
->have_offload
= true;
14542 if (is_a
<varpool_node
*> (node
))
14543 vec_safe_push (offload_vars
, decl
);
14550 if (error
|| global_bindings_p ())
14553 stmt
= make_node (OACC_DECLARE
);
14554 TREE_TYPE (stmt
) = void_type_node
;
14555 OACC_DECLARE_CLAUSES (stmt
) = clauses
;
14556 SET_EXPR_LOCATION (stmt
, pragma_loc
);
14564 # pragma acc enter data oacc-enter-data-clause[optseq] new-line
14568 # pragma acc exit data oacc-exit-data-clause[optseq] new-line
14571 LOC is the location of the #pragma token.
14574 #define OACC_ENTER_DATA_CLAUSE_MASK \
14575 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
14576 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
14577 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
14578 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
14579 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
14581 #define OACC_EXIT_DATA_CLAUSE_MASK \
14582 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
14583 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
14584 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
14585 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
14586 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FINALIZE) \
14587 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
14590 c_parser_oacc_enter_exit_data (c_parser
*parser
, bool enter
)
14592 location_t loc
= c_parser_peek_token (parser
)->location
;
14593 tree clauses
, stmt
;
14594 const char *p
= "";
14596 c_parser_consume_pragma (parser
);
14598 if (c_parser_next_token_is (parser
, CPP_NAME
))
14600 p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
14601 c_parser_consume_token (parser
);
14604 if (strcmp (p
, "data") != 0)
14606 error_at (loc
, "expected %<data%> after %<#pragma acc %s%>",
14607 enter
? "enter" : "exit");
14608 parser
->error
= true;
14609 c_parser_skip_to_pragma_eol (parser
);
14614 clauses
= c_parser_oacc_all_clauses (parser
, OACC_ENTER_DATA_CLAUSE_MASK
,
14615 "#pragma acc enter data");
14617 clauses
= c_parser_oacc_all_clauses (parser
, OACC_EXIT_DATA_CLAUSE_MASK
,
14618 "#pragma acc exit data");
14620 if (omp_find_clause (clauses
, OMP_CLAUSE_MAP
) == NULL_TREE
)
14622 error_at (loc
, "%<#pragma acc %s data%> has no data movement clause",
14623 enter
? "enter" : "exit");
14627 stmt
= enter
? make_node (OACC_ENTER_DATA
) : make_node (OACC_EXIT_DATA
);
14628 TREE_TYPE (stmt
) = void_type_node
;
14629 OMP_STANDALONE_CLAUSES (stmt
) = clauses
;
14630 SET_EXPR_LOCATION (stmt
, loc
);
14636 # pragma acc host_data oacc-data-clause[optseq] new-line
14640 #define OACC_HOST_DATA_CLAUSE_MASK \
14641 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_USE_DEVICE) )
14644 c_parser_oacc_host_data (location_t loc
, c_parser
*parser
, bool *if_p
)
14646 tree stmt
, clauses
, block
;
14648 clauses
= c_parser_oacc_all_clauses (parser
, OACC_HOST_DATA_CLAUSE_MASK
,
14649 "#pragma acc host_data");
14651 block
= c_begin_omp_parallel ();
14652 add_stmt (c_parser_omp_structured_block (parser
, if_p
));
14653 stmt
= c_finish_oacc_host_data (loc
, clauses
, block
);
14660 # pragma acc loop oacc-loop-clause[optseq] new-line
14663 LOC is the location of the #pragma token.
14666 #define OACC_LOOP_CLAUSE_MASK \
14667 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
14668 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
14669 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
14670 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
14671 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
14672 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
14673 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_AUTO) \
14674 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_INDEPENDENT) \
14675 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
14676 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_TILE) )
14678 c_parser_oacc_loop (location_t loc
, c_parser
*parser
, char *p_name
,
14679 omp_clause_mask mask
, tree
*cclauses
, bool *if_p
)
14681 bool is_parallel
= ((mask
>> PRAGMA_OACC_CLAUSE_REDUCTION
) & 1) == 1;
14683 strcat (p_name
, " loop");
14684 mask
|= OACC_LOOP_CLAUSE_MASK
;
14686 tree clauses
= c_parser_oacc_all_clauses (parser
, mask
, p_name
,
14690 clauses
= c_oacc_split_loop_clauses (clauses
, cclauses
, is_parallel
);
14692 *cclauses
= c_finish_omp_clauses (*cclauses
, C_ORT_ACC
);
14694 clauses
= c_finish_omp_clauses (clauses
, C_ORT_ACC
);
14697 tree block
= c_begin_compound_stmt (true);
14698 tree stmt
= c_parser_omp_for_loop (loc
, parser
, OACC_LOOP
, clauses
, NULL
,
14700 block
= c_end_compound_stmt (loc
, block
, true);
14707 # pragma acc kernels oacc-kernels-clause[optseq] new-line
14712 # pragma acc parallel oacc-parallel-clause[optseq] new-line
14715 LOC is the location of the #pragma token.
14718 #define OACC_KERNELS_CLAUSE_MASK \
14719 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
14720 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
14721 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
14722 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
14723 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
14724 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
14725 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
14726 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
14727 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
14728 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
14729 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
14730 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
14731 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
14733 #define OACC_PARALLEL_CLAUSE_MASK \
14734 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
14735 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
14736 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
14737 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
14738 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
14739 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
14740 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
14741 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
14742 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
14743 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
14744 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
14745 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
14746 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
14747 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
14748 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
14749 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
14752 c_parser_oacc_kernels_parallel (location_t loc
, c_parser
*parser
,
14753 enum pragma_kind p_kind
, char *p_name
,
14756 omp_clause_mask mask
;
14757 enum tree_code code
;
14760 case PRAGMA_OACC_KERNELS
:
14761 strcat (p_name
, " kernels");
14762 mask
= OACC_KERNELS_CLAUSE_MASK
;
14763 code
= OACC_KERNELS
;
14765 case PRAGMA_OACC_PARALLEL
:
14766 strcat (p_name
, " parallel");
14767 mask
= OACC_PARALLEL_CLAUSE_MASK
;
14768 code
= OACC_PARALLEL
;
14771 gcc_unreachable ();
14774 if (c_parser_next_token_is (parser
, CPP_NAME
))
14776 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
14777 if (strcmp (p
, "loop") == 0)
14779 c_parser_consume_token (parser
);
14780 tree block
= c_begin_omp_parallel ();
14782 c_parser_oacc_loop (loc
, parser
, p_name
, mask
, &clauses
, if_p
);
14783 return c_finish_omp_construct (loc
, code
, block
, clauses
);
14787 tree clauses
= c_parser_oacc_all_clauses (parser
, mask
, p_name
);
14789 tree block
= c_begin_omp_parallel ();
14790 add_stmt (c_parser_omp_structured_block (parser
, if_p
));
14792 return c_finish_omp_construct (loc
, code
, block
, clauses
);
14796 # pragma acc routine oacc-routine-clause[optseq] new-line
14797 function-definition
14799 # pragma acc routine ( name ) oacc-routine-clause[optseq] new-line
14802 #define OACC_ROUTINE_CLAUSE_MASK \
14803 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
14804 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
14805 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
14806 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) )
14808 /* Parse an OpenACC routine directive. For named directives, we apply
14809 immediately to the named function. For unnamed ones we then parse
14810 a declaration or definition, which must be for a function. */
14813 c_parser_oacc_routine (c_parser
*parser
, enum pragma_context context
)
14815 gcc_checking_assert (context
== pragma_external
);
14817 oacc_routine_data data
;
14818 data
.error_seen
= false;
14819 data
.fndecl_seen
= false;
14820 data
.clauses
= NULL_TREE
;
14821 data
.loc
= c_parser_peek_token (parser
)->location
;
14823 c_parser_consume_pragma (parser
);
14825 /* Look for optional '( name )'. */
14826 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
14828 c_parser_consume_token (parser
); /* '(' */
14830 tree decl
= NULL_TREE
;
14831 c_token
*name_token
= c_parser_peek_token (parser
);
14832 location_t name_loc
= name_token
->location
;
14833 if (name_token
->type
== CPP_NAME
14834 && (name_token
->id_kind
== C_ID_ID
14835 || name_token
->id_kind
== C_ID_TYPENAME
))
14837 decl
= lookup_name (name_token
->value
);
14839 error_at (name_loc
,
14840 "%qE has not been declared", name_token
->value
);
14841 c_parser_consume_token (parser
);
14844 c_parser_error (parser
, "expected function name");
14847 || !c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
14849 c_parser_skip_to_pragma_eol (parser
, false);
14854 = c_parser_oacc_all_clauses (parser
, OACC_ROUTINE_CLAUSE_MASK
,
14855 "#pragma acc routine");
14857 if (TREE_CODE (decl
) != FUNCTION_DECL
)
14859 error_at (name_loc
, "%qD does not refer to a function", decl
);
14863 c_finish_oacc_routine (&data
, decl
, false);
14865 else /* No optional '( name )'. */
14868 = c_parser_oacc_all_clauses (parser
, OACC_ROUTINE_CLAUSE_MASK
,
14869 "#pragma acc routine");
14871 /* Emit a helpful diagnostic if there's another pragma following this
14872 one. Also don't allow a static assertion declaration, as in the
14873 following we'll just parse a *single* "declaration or function
14874 definition", and the static assertion counts an one. */
14875 if (c_parser_next_token_is (parser
, CPP_PRAGMA
)
14876 || c_parser_next_token_is_keyword (parser
, RID_STATIC_ASSERT
))
14878 error_at (data
.loc
,
14879 "%<#pragma acc routine%> not immediately followed by"
14880 " function declaration or definition");
14881 /* ..., and then just keep going. */
14885 /* We only have to consider the pragma_external case here. */
14886 if (c_parser_next_token_is (parser
, CPP_KEYWORD
)
14887 && c_parser_peek_token (parser
)->keyword
== RID_EXTENSION
)
14889 int ext
= disable_extension_diagnostics ();
14891 c_parser_consume_token (parser
);
14892 while (c_parser_next_token_is (parser
, CPP_KEYWORD
)
14893 && c_parser_peek_token (parser
)->keyword
== RID_EXTENSION
);
14894 c_parser_declaration_or_fndef (parser
, true, true, true, false, true,
14895 NULL
, vNULL
, &data
);
14896 restore_extension_diagnostics (ext
);
14899 c_parser_declaration_or_fndef (parser
, true, true, true, false, true,
14900 NULL
, vNULL
, &data
);
14904 /* Finalize an OpenACC routine pragma, applying it to FNDECL.
14905 IS_DEFN is true if we're applying it to the definition. */
14908 c_finish_oacc_routine (struct oacc_routine_data
*data
, tree fndecl
,
14911 /* Keep going if we're in error reporting mode. */
14912 if (data
->error_seen
14913 || fndecl
== error_mark_node
)
14916 if (data
->fndecl_seen
)
14918 error_at (data
->loc
,
14919 "%<#pragma acc routine%> not immediately followed by"
14920 " a single function declaration or definition");
14921 data
->error_seen
= true;
14924 if (fndecl
== NULL_TREE
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14926 error_at (data
->loc
,
14927 "%<#pragma acc routine%> not immediately followed by"
14928 " function declaration or definition");
14929 data
->error_seen
= true;
14933 if (oacc_get_fn_attrib (fndecl
))
14935 error_at (data
->loc
,
14936 "%<#pragma acc routine%> already applied to %qD", fndecl
);
14937 data
->error_seen
= true;
14941 if (TREE_USED (fndecl
) || (!is_defn
&& DECL_SAVED_TREE (fndecl
)))
14943 error_at (data
->loc
,
14945 ? G_("%<#pragma acc routine%> must be applied before use")
14946 : G_("%<#pragma acc routine%> must be applied before "
14948 data
->error_seen
= true;
14952 /* Process the routine's dimension clauses. */
14953 tree dims
= oacc_build_routine_dims (data
->clauses
);
14954 oacc_replace_fn_attrib (fndecl
, dims
);
14956 /* Add an "omp declare target" attribute. */
14957 DECL_ATTRIBUTES (fndecl
)
14958 = tree_cons (get_identifier ("omp declare target"),
14959 NULL_TREE
, DECL_ATTRIBUTES (fndecl
));
14961 /* Remember that we've used this "#pragma acc routine". */
14962 data
->fndecl_seen
= true;
14966 # pragma acc update oacc-update-clause[optseq] new-line
14969 #define OACC_UPDATE_CLAUSE_MASK \
14970 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
14971 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
14972 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
14973 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
14974 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) \
14975 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
14978 c_parser_oacc_update (c_parser
*parser
)
14980 location_t loc
= c_parser_peek_token (parser
)->location
;
14982 c_parser_consume_pragma (parser
);
14984 tree clauses
= c_parser_oacc_all_clauses (parser
, OACC_UPDATE_CLAUSE_MASK
,
14985 "#pragma acc update");
14986 if (omp_find_clause (clauses
, OMP_CLAUSE_MAP
) == NULL_TREE
)
14989 "%<#pragma acc update%> must contain at least one "
14990 "%<device%> or %<host%> or %<self%> clause");
14997 tree stmt
= make_node (OACC_UPDATE
);
14998 TREE_TYPE (stmt
) = void_type_node
;
14999 OACC_UPDATE_CLAUSES (stmt
) = clauses
;
15000 SET_EXPR_LOCATION (stmt
, loc
);
15005 # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
15007 LOC is the location of the #pragma token.
15010 #define OACC_WAIT_CLAUSE_MASK \
15011 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) )
15014 c_parser_oacc_wait (location_t loc
, c_parser
*parser
, char *p_name
)
15016 tree clauses
, list
= NULL_TREE
, stmt
= NULL_TREE
;
15018 if (c_parser_peek_token (parser
)->type
== CPP_OPEN_PAREN
)
15019 list
= c_parser_oacc_wait_list (parser
, loc
, list
);
15021 strcpy (p_name
, " wait");
15022 clauses
= c_parser_oacc_all_clauses (parser
, OACC_WAIT_CLAUSE_MASK
, p_name
);
15023 stmt
= c_finish_oacc_wait (loc
, list
, clauses
);
15030 # pragma omp atomic new-line
15034 x binop= expr | x++ | ++x | x-- | --x
15036 +, *, -, /, &, ^, |, <<, >>
15038 where x is an lvalue expression with scalar type.
15041 # pragma omp atomic new-line
15044 # pragma omp atomic read new-line
15047 # pragma omp atomic write new-line
15050 # pragma omp atomic update new-line
15053 # pragma omp atomic capture new-line
15056 # pragma omp atomic capture new-line
15064 expression-stmt | x = x binop expr
15066 v = expression-stmt
15068 { v = x; update-stmt; } | { update-stmt; v = x; }
15072 expression-stmt | x = x binop expr | x = expr binop x
15076 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
15078 where x and v are lvalue expressions with scalar type.
15080 LOC is the location of the #pragma token. */
15083 c_parser_omp_atomic (location_t loc
, c_parser
*parser
)
15085 tree lhs
= NULL_TREE
, rhs
= NULL_TREE
, v
= NULL_TREE
;
15086 tree lhs1
= NULL_TREE
, rhs1
= NULL_TREE
;
15087 tree stmt
, orig_lhs
, unfolded_lhs
= NULL_TREE
, unfolded_lhs1
= NULL_TREE
;
15088 enum tree_code code
= OMP_ATOMIC
, opcode
= NOP_EXPR
;
15089 struct c_expr expr
;
15091 bool structured_block
= false;
15092 bool swapped
= false;
15093 bool seq_cst
= false;
15096 if (c_parser_next_token_is (parser
, CPP_NAME
))
15098 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
15099 if (!strcmp (p
, "seq_cst"))
15102 c_parser_consume_token (parser
);
15103 if (c_parser_next_token_is (parser
, CPP_COMMA
)
15104 && c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
)
15105 c_parser_consume_token (parser
);
15108 if (c_parser_next_token_is (parser
, CPP_NAME
))
15110 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
15112 if (!strcmp (p
, "read"))
15113 code
= OMP_ATOMIC_READ
;
15114 else if (!strcmp (p
, "write"))
15116 else if (!strcmp (p
, "update"))
15118 else if (!strcmp (p
, "capture"))
15119 code
= OMP_ATOMIC_CAPTURE_NEW
;
15123 c_parser_consume_token (parser
);
15127 if (c_parser_next_token_is (parser
, CPP_COMMA
)
15128 && c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
)
15129 c_parser_consume_token (parser
);
15131 if (c_parser_next_token_is (parser
, CPP_NAME
))
15134 = IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
15135 if (!strcmp (p
, "seq_cst"))
15138 c_parser_consume_token (parser
);
15142 c_parser_skip_to_pragma_eol (parser
);
15146 case OMP_ATOMIC_READ
:
15147 case NOP_EXPR
: /* atomic write */
15148 v
= c_parser_cast_expression (parser
, NULL
).value
;
15149 non_lvalue_p
= !lvalue_p (v
);
15150 v
= c_fully_fold (v
, false, NULL
, true);
15151 if (v
== error_mark_node
)
15154 v
= non_lvalue (v
);
15155 loc
= c_parser_peek_token (parser
)->location
;
15156 if (!c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
15158 if (code
== NOP_EXPR
)
15160 lhs
= c_parser_expression (parser
).value
;
15161 lhs
= c_fully_fold (lhs
, false, NULL
);
15162 if (lhs
== error_mark_node
)
15167 lhs
= c_parser_cast_expression (parser
, NULL
).value
;
15168 non_lvalue_p
= !lvalue_p (lhs
);
15169 lhs
= c_fully_fold (lhs
, false, NULL
, true);
15170 if (lhs
== error_mark_node
)
15173 lhs
= non_lvalue (lhs
);
15175 if (code
== NOP_EXPR
)
15177 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
15185 case OMP_ATOMIC_CAPTURE_NEW
:
15186 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
15188 c_parser_consume_token (parser
);
15189 structured_block
= true;
15193 v
= c_parser_cast_expression (parser
, NULL
).value
;
15194 non_lvalue_p
= !lvalue_p (v
);
15195 v
= c_fully_fold (v
, false, NULL
, true);
15196 if (v
== error_mark_node
)
15199 v
= non_lvalue (v
);
15200 if (!c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
15208 /* For structured_block case we don't know yet whether
15209 old or new x should be captured. */
15211 eloc
= c_parser_peek_token (parser
)->location
;
15212 expr
= c_parser_cast_expression (parser
, NULL
);
15214 expr
= default_function_array_conversion (eloc
, expr
);
15215 unfolded_lhs
= expr
.value
;
15216 lhs
= c_fully_fold (lhs
, false, NULL
, true);
15218 switch (TREE_CODE (lhs
))
15222 c_parser_skip_to_end_of_block_or_statement (parser
);
15223 if (structured_block
)
15225 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
15226 c_parser_consume_token (parser
);
15227 else if (code
== OMP_ATOMIC_CAPTURE_NEW
)
15229 c_parser_skip_to_end_of_block_or_statement (parser
);
15230 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
15231 c_parser_consume_token (parser
);
15236 case POSTINCREMENT_EXPR
:
15237 if (code
== OMP_ATOMIC_CAPTURE_NEW
&& !structured_block
)
15238 code
= OMP_ATOMIC_CAPTURE_OLD
;
15240 case PREINCREMENT_EXPR
:
15241 lhs
= TREE_OPERAND (lhs
, 0);
15242 unfolded_lhs
= NULL_TREE
;
15243 opcode
= PLUS_EXPR
;
15244 rhs
= integer_one_node
;
15247 case POSTDECREMENT_EXPR
:
15248 if (code
== OMP_ATOMIC_CAPTURE_NEW
&& !structured_block
)
15249 code
= OMP_ATOMIC_CAPTURE_OLD
;
15251 case PREDECREMENT_EXPR
:
15252 lhs
= TREE_OPERAND (lhs
, 0);
15253 unfolded_lhs
= NULL_TREE
;
15254 opcode
= MINUS_EXPR
;
15255 rhs
= integer_one_node
;
15258 case COMPOUND_EXPR
:
15259 if (TREE_CODE (TREE_OPERAND (lhs
, 0)) == SAVE_EXPR
15260 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == COMPOUND_EXPR
15261 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (lhs
, 1), 0)) == MODIFY_EXPR
15262 && TREE_OPERAND (TREE_OPERAND (lhs
, 1), 1) == TREE_OPERAND (lhs
, 0)
15263 && TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND
15264 (TREE_OPERAND (lhs
, 1), 0), 0)))
15266 /* Undo effects of boolean_increment for post {in,de}crement. */
15267 lhs
= TREE_OPERAND (TREE_OPERAND (lhs
, 1), 0);
15270 if (TREE_CODE (lhs
) == MODIFY_EXPR
15271 && TREE_CODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) == BOOLEAN_TYPE
)
15273 /* Undo effects of boolean_increment. */
15274 if (integer_onep (TREE_OPERAND (lhs
, 1)))
15276 /* This is pre or post increment. */
15277 rhs
= TREE_OPERAND (lhs
, 1);
15278 lhs
= TREE_OPERAND (lhs
, 0);
15279 unfolded_lhs
= NULL_TREE
;
15281 if (code
== OMP_ATOMIC_CAPTURE_NEW
15282 && !structured_block
15283 && TREE_CODE (orig_lhs
) == COMPOUND_EXPR
)
15284 code
= OMP_ATOMIC_CAPTURE_OLD
;
15287 if (TREE_CODE (TREE_OPERAND (lhs
, 1)) == TRUTH_NOT_EXPR
15288 && TREE_OPERAND (lhs
, 0)
15289 == TREE_OPERAND (TREE_OPERAND (lhs
, 1), 0))
15291 /* This is pre or post decrement. */
15292 rhs
= TREE_OPERAND (lhs
, 1);
15293 lhs
= TREE_OPERAND (lhs
, 0);
15294 unfolded_lhs
= NULL_TREE
;
15296 if (code
== OMP_ATOMIC_CAPTURE_NEW
15297 && !structured_block
15298 && TREE_CODE (orig_lhs
) == COMPOUND_EXPR
)
15299 code
= OMP_ATOMIC_CAPTURE_OLD
;
15305 if (!lvalue_p (unfolded_lhs
))
15306 lhs
= non_lvalue (lhs
);
15307 switch (c_parser_peek_token (parser
)->type
)
15310 opcode
= MULT_EXPR
;
15313 opcode
= TRUNC_DIV_EXPR
;
15316 opcode
= PLUS_EXPR
;
15319 opcode
= MINUS_EXPR
;
15321 case CPP_LSHIFT_EQ
:
15322 opcode
= LSHIFT_EXPR
;
15324 case CPP_RSHIFT_EQ
:
15325 opcode
= RSHIFT_EXPR
;
15328 opcode
= BIT_AND_EXPR
;
15331 opcode
= BIT_IOR_EXPR
;
15334 opcode
= BIT_XOR_EXPR
;
15337 c_parser_consume_token (parser
);
15338 eloc
= c_parser_peek_token (parser
)->location
;
15339 expr
= c_parser_expr_no_commas (parser
, NULL
, unfolded_lhs
);
15341 switch (TREE_CODE (rhs1
))
15344 case TRUNC_DIV_EXPR
:
15353 if (c_tree_equal (TREE_OPERAND (rhs1
, 0), unfolded_lhs
))
15355 opcode
= TREE_CODE (rhs1
);
15356 rhs
= c_fully_fold (TREE_OPERAND (rhs1
, 1), false, NULL
,
15358 rhs1
= c_fully_fold (TREE_OPERAND (rhs1
, 0), false, NULL
,
15362 if (c_tree_equal (TREE_OPERAND (rhs1
, 1), unfolded_lhs
))
15364 opcode
= TREE_CODE (rhs1
);
15365 rhs
= c_fully_fold (TREE_OPERAND (rhs1
, 0), false, NULL
,
15367 rhs1
= c_fully_fold (TREE_OPERAND (rhs1
, 1), false, NULL
,
15369 swapped
= !commutative_tree_code (opcode
);
15378 if (c_parser_peek_token (parser
)->type
== CPP_SEMICOLON
)
15380 if (structured_block
&& code
== OMP_ATOMIC_CAPTURE_NEW
)
15382 code
= OMP_ATOMIC_CAPTURE_OLD
;
15385 expr
= default_function_array_read_conversion (eloc
, expr
);
15386 unfolded_lhs1
= expr
.value
;
15387 lhs1
= c_fully_fold (unfolded_lhs1
, false, NULL
, true);
15389 c_parser_consume_token (parser
);
15392 if (structured_block
)
15395 expr
= default_function_array_read_conversion (eloc
, expr
);
15396 rhs
= c_fully_fold (expr
.value
, false, NULL
, true);
15401 c_parser_error (parser
, "invalid form of %<#pragma omp atomic%>");
15404 c_parser_error (parser
,
15405 "invalid operator for %<#pragma omp atomic%>");
15409 /* Arrange to pass the location of the assignment operator to
15410 c_finish_omp_atomic. */
15411 loc
= c_parser_peek_token (parser
)->location
;
15412 c_parser_consume_token (parser
);
15413 eloc
= c_parser_peek_token (parser
)->location
;
15414 expr
= c_parser_expression (parser
);
15415 expr
= default_function_array_read_conversion (eloc
, expr
);
15417 rhs
= c_fully_fold (rhs
, false, NULL
, true);
15421 if (structured_block
&& code
== OMP_ATOMIC_CAPTURE_NEW
)
15423 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
15425 v
= c_parser_cast_expression (parser
, NULL
).value
;
15426 non_lvalue_p
= !lvalue_p (v
);
15427 v
= c_fully_fold (v
, false, NULL
, true);
15428 if (v
== error_mark_node
)
15431 v
= non_lvalue (v
);
15432 if (!c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
15434 eloc
= c_parser_peek_token (parser
)->location
;
15435 expr
= c_parser_cast_expression (parser
, NULL
);
15437 expr
= default_function_array_read_conversion (eloc
, expr
);
15438 unfolded_lhs1
= expr
.value
;
15439 lhs1
= c_fully_fold (lhs1
, false, NULL
, true);
15440 if (lhs1
== error_mark_node
)
15442 if (!lvalue_p (unfolded_lhs1
))
15443 lhs1
= non_lvalue (lhs1
);
15445 if (structured_block
)
15447 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
15448 c_parser_require (parser
, CPP_CLOSE_BRACE
, "expected %<}%>");
15451 if (unfolded_lhs
&& unfolded_lhs1
15452 && !c_tree_equal (unfolded_lhs
, unfolded_lhs1
))
15454 error ("%<#pragma omp atomic capture%> uses two different "
15455 "expressions for memory");
15456 stmt
= error_mark_node
;
15459 stmt
= c_finish_omp_atomic (loc
, code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
15461 if (stmt
!= error_mark_node
)
15464 if (!structured_block
)
15465 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
15470 # pragma omp barrier new-line
15474 c_parser_omp_barrier (c_parser
*parser
)
15476 location_t loc
= c_parser_peek_token (parser
)->location
;
15477 c_parser_consume_pragma (parser
);
15478 c_parser_skip_to_pragma_eol (parser
);
15480 c_finish_omp_barrier (loc
);
15484 # pragma omp critical [(name)] new-line
15488 # pragma omp critical [(name) [hint(expression)]] new-line
15490 LOC is the location of the #pragma itself. */
15492 #define OMP_CRITICAL_CLAUSE_MASK \
15493 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HINT) )
15496 c_parser_omp_critical (location_t loc
, c_parser
*parser
, bool *if_p
)
15498 tree stmt
, name
= NULL_TREE
, clauses
= NULL_TREE
;
15500 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
15502 c_parser_consume_token (parser
);
15503 if (c_parser_next_token_is (parser
, CPP_NAME
))
15505 name
= c_parser_peek_token (parser
)->value
;
15506 c_parser_consume_token (parser
);
15507 c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
15510 c_parser_error (parser
, "expected identifier");
15512 clauses
= c_parser_omp_all_clauses (parser
,
15513 OMP_CRITICAL_CLAUSE_MASK
,
15514 "#pragma omp critical");
15518 if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
15519 c_parser_error (parser
, "expected %<(%> or end of line");
15520 c_parser_skip_to_pragma_eol (parser
);
15523 stmt
= c_parser_omp_structured_block (parser
, if_p
);
15524 return c_finish_omp_critical (loc
, stmt
, name
, clauses
);
15528 # pragma omp flush flush-vars[opt] new-line
15531 ( variable-list ) */
15534 c_parser_omp_flush (c_parser
*parser
)
15536 location_t loc
= c_parser_peek_token (parser
)->location
;
15537 c_parser_consume_pragma (parser
);
15538 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
15539 c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_ERROR
, NULL
);
15540 else if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
15541 c_parser_error (parser
, "expected %<(%> or end of line");
15542 c_parser_skip_to_pragma_eol (parser
);
15544 c_finish_omp_flush (loc
);
15547 /* Parse the restricted form of loop statements allowed by OpenACC and OpenMP.
15548 The real trick here is to determine the loop control variable early
15549 so that we can push a new decl if necessary to make it private.
15550 LOC is the location of the "acc" or "omp" in "#pragma acc" or "#pragma omp",
15554 c_parser_omp_for_loop (location_t loc
, c_parser
*parser
, enum tree_code code
,
15555 tree clauses
, tree
*cclauses
, bool *if_p
)
15557 tree decl
, cond
, incr
, save_break
, save_cont
, body
, init
, stmt
, cl
;
15558 tree declv
, condv
, incrv
, initv
, ret
= NULL_TREE
;
15559 tree pre_body
= NULL_TREE
, this_pre_body
;
15560 tree ordered_cl
= NULL_TREE
;
15561 bool fail
= false, open_brace_parsed
= false;
15562 int i
, collapse
= 1, ordered
= 0, count
, nbraces
= 0;
15563 location_t for_loc
;
15564 bool tiling
= false;
15565 vec
<tree
, va_gc
> *for_block
= make_tree_vector ();
15567 for (cl
= clauses
; cl
; cl
= OMP_CLAUSE_CHAIN (cl
))
15568 if (OMP_CLAUSE_CODE (cl
) == OMP_CLAUSE_COLLAPSE
)
15569 collapse
= tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (cl
));
15570 else if (OMP_CLAUSE_CODE (cl
) == OMP_CLAUSE_TILE
)
15573 collapse
= list_length (OMP_CLAUSE_TILE_LIST (cl
));
15575 else if (OMP_CLAUSE_CODE (cl
) == OMP_CLAUSE_ORDERED
15576 && OMP_CLAUSE_ORDERED_EXPR (cl
))
15579 ordered
= tree_to_shwi (OMP_CLAUSE_ORDERED_EXPR (cl
));
15582 if (ordered
&& ordered
< collapse
)
15584 error_at (OMP_CLAUSE_LOCATION (ordered_cl
),
15585 "%<ordered%> clause parameter is less than %<collapse%>");
15586 OMP_CLAUSE_ORDERED_EXPR (ordered_cl
)
15587 = build_int_cst (NULL_TREE
, collapse
);
15588 ordered
= collapse
;
15592 for (tree
*pc
= &clauses
; *pc
; )
15593 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LINEAR
)
15595 error_at (OMP_CLAUSE_LOCATION (*pc
),
15596 "%<linear%> clause may not be specified together "
15597 "with %<ordered%> clause with a parameter");
15598 *pc
= OMP_CLAUSE_CHAIN (*pc
);
15601 pc
= &OMP_CLAUSE_CHAIN (*pc
);
15604 gcc_assert (tiling
|| (collapse
>= 1 && ordered
>= 0));
15605 count
= ordered
? ordered
: collapse
;
15607 declv
= make_tree_vec (count
);
15608 initv
= make_tree_vec (count
);
15609 condv
= make_tree_vec (count
);
15610 incrv
= make_tree_vec (count
);
15612 if (!c_parser_next_token_is_keyword (parser
, RID_FOR
))
15614 c_parser_error (parser
, "for statement expected");
15617 for_loc
= c_parser_peek_token (parser
)->location
;
15618 c_parser_consume_token (parser
);
15620 for (i
= 0; i
< count
; i
++)
15622 int bracecount
= 0;
15624 matching_parens parens
;
15625 if (!parens
.require_open (parser
))
15628 /* Parse the initialization declaration or expression. */
15629 if (c_parser_next_tokens_start_declaration (parser
))
15632 vec_safe_push (for_block
, c_begin_compound_stmt (true));
15633 this_pre_body
= push_stmt_list ();
15634 c_parser_declaration_or_fndef (parser
, true, true, true, true, true,
15638 this_pre_body
= pop_stmt_list (this_pre_body
);
15642 pre_body
= push_stmt_list ();
15644 add_stmt (this_pre_body
);
15645 pre_body
= pop_stmt_list (pre_body
);
15648 pre_body
= this_pre_body
;
15650 decl
= check_for_loop_decls (for_loc
, flag_isoc99
);
15653 if (DECL_INITIAL (decl
) == error_mark_node
)
15654 decl
= error_mark_node
;
15657 else if (c_parser_next_token_is (parser
, CPP_NAME
)
15658 && c_parser_peek_2nd_token (parser
)->type
== CPP_EQ
)
15660 struct c_expr decl_exp
;
15661 struct c_expr init_exp
;
15662 location_t init_loc
;
15664 decl_exp
= c_parser_postfix_expression (parser
);
15665 decl
= decl_exp
.value
;
15667 c_parser_require (parser
, CPP_EQ
, "expected %<=%>");
15669 init_loc
= c_parser_peek_token (parser
)->location
;
15670 init_exp
= c_parser_expr_no_commas (parser
, NULL
);
15671 init_exp
= default_function_array_read_conversion (init_loc
,
15673 init
= build_modify_expr (init_loc
, decl
, decl_exp
.original_type
,
15674 NOP_EXPR
, init_loc
, init_exp
.value
,
15675 init_exp
.original_type
);
15676 init
= c_process_expr_stmt (init_loc
, init
);
15678 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
15683 c_parser_error (parser
,
15684 "expected iteration declaration or initialization");
15685 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
15691 /* Parse the loop condition. */
15693 if (c_parser_next_token_is_not (parser
, CPP_SEMICOLON
))
15695 location_t cond_loc
= c_parser_peek_token (parser
)->location
;
15696 struct c_expr cond_expr
15697 = c_parser_binary_expression (parser
, NULL
, NULL_TREE
);
15699 cond
= cond_expr
.value
;
15700 cond
= c_objc_common_truthvalue_conversion (cond_loc
, cond
);
15701 if (COMPARISON_CLASS_P (cond
))
15703 tree op0
= TREE_OPERAND (cond
, 0), op1
= TREE_OPERAND (cond
, 1);
15704 op0
= c_fully_fold (op0
, false, NULL
);
15705 op1
= c_fully_fold (op1
, false, NULL
);
15706 TREE_OPERAND (cond
, 0) = op0
;
15707 TREE_OPERAND (cond
, 1) = op1
;
15709 switch (cond_expr
.original_code
)
15717 /* Can't be cond = error_mark_node, because we want to preserve
15718 the location until c_finish_omp_for. */
15719 cond
= build1 (NOP_EXPR
, boolean_type_node
, error_mark_node
);
15722 protected_set_expr_location (cond
, cond_loc
);
15724 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
15726 /* Parse the increment expression. */
15728 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
))
15730 location_t incr_loc
= c_parser_peek_token (parser
)->location
;
15732 incr
= c_process_expr_stmt (incr_loc
,
15733 c_parser_expression (parser
).value
);
15735 parens
.skip_until_found_close (parser
);
15737 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
15741 TREE_VEC_ELT (declv
, i
) = decl
;
15742 TREE_VEC_ELT (initv
, i
) = init
;
15743 TREE_VEC_ELT (condv
, i
) = cond
;
15744 TREE_VEC_ELT (incrv
, i
) = incr
;
15748 if (i
== count
- 1)
15751 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
15752 in between the collapsed for loops to be still considered perfectly
15753 nested. Hopefully the final version clarifies this.
15754 For now handle (multiple) {'s and empty statements. */
15757 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
15759 c_parser_consume_token (parser
);
15762 else if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
15764 c_parser_consume_token (parser
);
15767 else if (bracecount
15768 && c_parser_next_token_is (parser
, CPP_SEMICOLON
))
15769 c_parser_consume_token (parser
);
15772 c_parser_error (parser
, "not enough perfectly nested loops");
15775 open_brace_parsed
= true;
15785 nbraces
+= bracecount
;
15791 save_break
= c_break_label
;
15792 c_break_label
= size_one_node
;
15793 save_cont
= c_cont_label
;
15794 c_cont_label
= NULL_TREE
;
15795 body
= push_stmt_list ();
15797 if (open_brace_parsed
)
15799 location_t here
= c_parser_peek_token (parser
)->location
;
15800 stmt
= c_begin_compound_stmt (true);
15801 c_parser_compound_statement_nostart (parser
);
15802 add_stmt (c_end_compound_stmt (here
, stmt
, true));
15805 add_stmt (c_parser_c99_block_statement (parser
, if_p
));
15808 tree t
= build1 (LABEL_EXPR
, void_type_node
, c_cont_label
);
15809 SET_EXPR_LOCATION (t
, loc
);
15813 body
= pop_stmt_list (body
);
15814 c_break_label
= save_break
;
15815 c_cont_label
= save_cont
;
15819 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
15821 c_parser_consume_token (parser
);
15824 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
15825 c_parser_consume_token (parser
);
15828 c_parser_error (parser
, "collapsed loops not perfectly nested");
15831 location_t here
= c_parser_peek_token (parser
)->location
;
15832 stmt
= c_begin_compound_stmt (true);
15834 c_parser_compound_statement_nostart (parser
);
15835 body
= c_end_compound_stmt (here
, stmt
, true);
15842 /* Only bother calling c_finish_omp_for if we haven't already generated
15843 an error from the initialization parsing. */
15846 stmt
= c_finish_omp_for (loc
, code
, declv
, NULL
, initv
, condv
,
15847 incrv
, body
, pre_body
);
15849 /* Check for iterators appearing in lb, b or incr expressions. */
15850 if (stmt
&& !c_omp_check_loop_iv (stmt
, declv
, NULL
))
15857 if (cclauses
!= NULL
15858 && cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
] != NULL
)
15861 for (c
= &cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
]; *c
; )
15862 if (OMP_CLAUSE_CODE (*c
) != OMP_CLAUSE_FIRSTPRIVATE
15863 && OMP_CLAUSE_CODE (*c
) != OMP_CLAUSE_LASTPRIVATE
)
15864 c
= &OMP_CLAUSE_CHAIN (*c
);
15867 for (i
= 0; i
< count
; i
++)
15868 if (TREE_VEC_ELT (declv
, i
) == OMP_CLAUSE_DECL (*c
))
15871 c
= &OMP_CLAUSE_CHAIN (*c
);
15872 else if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_FIRSTPRIVATE
)
15875 "iteration variable %qD should not be firstprivate",
15876 OMP_CLAUSE_DECL (*c
));
15877 *c
= OMP_CLAUSE_CHAIN (*c
);
15881 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
15883 *c
= OMP_CLAUSE_CHAIN (*c
);
15884 if (code
== OMP_SIMD
)
15886 OMP_CLAUSE_CHAIN (l
)
15887 = cclauses
[C_OMP_CLAUSE_SPLIT_FOR
];
15888 cclauses
[C_OMP_CLAUSE_SPLIT_FOR
] = l
;
15892 OMP_CLAUSE_CHAIN (l
) = clauses
;
15898 OMP_FOR_CLAUSES (stmt
) = clauses
;
15903 while (!for_block
->is_empty ())
15905 /* FIXME diagnostics: LOC below should be the actual location of
15906 this particular for block. We need to build a list of
15907 locations to go along with FOR_BLOCK. */
15908 stmt
= c_end_compound_stmt (loc
, for_block
->pop (), true);
15911 release_tree_vector (for_block
);
15915 /* Helper function for OpenMP parsing, split clauses and call
15916 finish_omp_clauses on each of the set of clauses afterwards. */
15919 omp_split_clauses (location_t loc
, enum tree_code code
,
15920 omp_clause_mask mask
, tree clauses
, tree
*cclauses
)
15923 c_omp_split_clauses (loc
, code
, mask
, clauses
, cclauses
);
15924 for (i
= 0; i
< C_OMP_CLAUSE_SPLIT_COUNT
; i
++)
15926 cclauses
[i
] = c_finish_omp_clauses (cclauses
[i
], C_ORT_OMP
);
15930 #pragma omp simd simd-clause[optseq] new-line
15933 LOC is the location of the #pragma token.
15936 #define OMP_SIMD_CLAUSE_MASK \
15937 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
15938 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
15939 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
15940 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
15941 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
15942 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
15943 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
15944 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
15947 c_parser_omp_simd (location_t loc
, c_parser
*parser
,
15948 char *p_name
, omp_clause_mask mask
, tree
*cclauses
,
15951 tree block
, clauses
, ret
;
15953 strcat (p_name
, " simd");
15954 mask
|= OMP_SIMD_CLAUSE_MASK
;
15956 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
15959 omp_split_clauses (loc
, OMP_SIMD
, mask
, clauses
, cclauses
);
15960 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_SIMD
];
15961 tree c
= omp_find_clause (cclauses
[C_OMP_CLAUSE_SPLIT_FOR
],
15962 OMP_CLAUSE_ORDERED
);
15963 if (c
&& OMP_CLAUSE_ORDERED_EXPR (c
))
15965 error_at (OMP_CLAUSE_LOCATION (c
),
15966 "%<ordered%> clause with parameter may not be specified "
15967 "on %qs construct", p_name
);
15968 OMP_CLAUSE_ORDERED_EXPR (c
) = NULL_TREE
;
15972 block
= c_begin_compound_stmt (true);
15973 ret
= c_parser_omp_for_loop (loc
, parser
, OMP_SIMD
, clauses
, cclauses
, if_p
);
15974 block
= c_end_compound_stmt (loc
, block
, true);
15981 #pragma omp for for-clause[optseq] new-line
15985 #pragma omp for simd for-simd-clause[optseq] new-line
15988 LOC is the location of the #pragma token.
15991 #define OMP_FOR_CLAUSE_MASK \
15992 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
15993 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
15994 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
15995 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
15996 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
15997 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
15998 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
15999 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
16000 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
16003 c_parser_omp_for (location_t loc
, c_parser
*parser
,
16004 char *p_name
, omp_clause_mask mask
, tree
*cclauses
,
16007 tree block
, clauses
, ret
;
16009 strcat (p_name
, " for");
16010 mask
|= OMP_FOR_CLAUSE_MASK
;
16011 /* parallel for{, simd} disallows nowait clause, but for
16012 target {teams distribute ,}parallel for{, simd} it should be accepted. */
16013 if (cclauses
&& (mask
& (OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_MAP
)) == 0)
16014 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_NOWAIT
);
16015 /* Composite distribute parallel for{, simd} disallows ordered clause. */
16016 if ((mask
& (OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
)) != 0)
16017 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_ORDERED
);
16019 if (c_parser_next_token_is (parser
, CPP_NAME
))
16021 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
16023 if (strcmp (p
, "simd") == 0)
16025 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
16026 if (cclauses
== NULL
)
16027 cclauses
= cclauses_buf
;
16029 c_parser_consume_token (parser
);
16030 if (!flag_openmp
) /* flag_openmp_simd */
16031 return c_parser_omp_simd (loc
, parser
, p_name
, mask
, cclauses
,
16033 block
= c_begin_compound_stmt (true);
16034 ret
= c_parser_omp_simd (loc
, parser
, p_name
, mask
, cclauses
, if_p
);
16035 block
= c_end_compound_stmt (loc
, block
, true);
16036 if (ret
== NULL_TREE
)
16038 ret
= make_node (OMP_FOR
);
16039 TREE_TYPE (ret
) = void_type_node
;
16040 OMP_FOR_BODY (ret
) = block
;
16041 OMP_FOR_CLAUSES (ret
) = cclauses
[C_OMP_CLAUSE_SPLIT_FOR
];
16042 SET_EXPR_LOCATION (ret
, loc
);
16047 if (!flag_openmp
) /* flag_openmp_simd */
16049 c_parser_skip_to_pragma_eol (parser
, false);
16053 /* Composite distribute parallel for disallows linear clause. */
16054 if ((mask
& (OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
)) != 0)
16055 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_LINEAR
);
16057 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
16060 omp_split_clauses (loc
, OMP_FOR
, mask
, clauses
, cclauses
);
16061 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_FOR
];
16064 block
= c_begin_compound_stmt (true);
16065 ret
= c_parser_omp_for_loop (loc
, parser
, OMP_FOR
, clauses
, cclauses
, if_p
);
16066 block
= c_end_compound_stmt (loc
, block
, true);
16073 # pragma omp master new-line
16076 LOC is the location of the #pragma token.
16080 c_parser_omp_master (location_t loc
, c_parser
*parser
, bool *if_p
)
16082 c_parser_skip_to_pragma_eol (parser
);
16083 return c_finish_omp_master (loc
, c_parser_omp_structured_block (parser
,
16088 # pragma omp ordered new-line
16092 # pragma omp ordered ordered-clauses new-line
16095 # pragma omp ordered depend-clauses new-line */
16097 #define OMP_ORDERED_CLAUSE_MASK \
16098 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREADS) \
16099 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMD))
16101 #define OMP_ORDERED_DEPEND_CLAUSE_MASK \
16102 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND)
16105 c_parser_omp_ordered (c_parser
*parser
, enum pragma_context context
,
16108 location_t loc
= c_parser_peek_token (parser
)->location
;
16109 c_parser_consume_pragma (parser
);
16111 if (context
!= pragma_stmt
&& context
!= pragma_compound
)
16113 c_parser_error (parser
, "expected declaration specifiers");
16114 c_parser_skip_to_pragma_eol (parser
, false);
16118 if (c_parser_next_token_is (parser
, CPP_NAME
))
16120 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
16122 if (!strcmp ("depend", p
))
16124 if (!flag_openmp
) /* flag_openmp_simd */
16126 c_parser_skip_to_pragma_eol (parser
, false);
16129 if (context
== pragma_stmt
)
16132 "%<#pragma omp ordered%> with %<depend%> clause may "
16133 "only be used in compound statements");
16134 c_parser_skip_to_pragma_eol (parser
, false);
16139 = c_parser_omp_all_clauses (parser
,
16140 OMP_ORDERED_DEPEND_CLAUSE_MASK
,
16141 "#pragma omp ordered");
16142 c_finish_omp_ordered (loc
, clauses
, NULL_TREE
);
16147 tree clauses
= c_parser_omp_all_clauses (parser
, OMP_ORDERED_CLAUSE_MASK
,
16148 "#pragma omp ordered");
16150 if (!flag_openmp
/* flag_openmp_simd */
16151 && omp_find_clause (clauses
, OMP_CLAUSE_SIMD
) == NULL_TREE
)
16154 c_finish_omp_ordered (loc
, clauses
,
16155 c_parser_omp_structured_block (parser
, if_p
));
16162 { section-sequence }
16165 section-directive[opt] structured-block
16166 section-sequence section-directive structured-block
16168 SECTIONS_LOC is the location of the #pragma omp sections. */
16171 c_parser_omp_sections_scope (location_t sections_loc
, c_parser
*parser
)
16173 tree stmt
, substmt
;
16174 bool error_suppress
= false;
16177 loc
= c_parser_peek_token (parser
)->location
;
16178 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
16180 /* Avoid skipping until the end of the block. */
16181 parser
->error
= false;
16185 stmt
= push_stmt_list ();
16187 if (c_parser_peek_token (parser
)->pragma_kind
!= PRAGMA_OMP_SECTION
)
16189 substmt
= c_parser_omp_structured_block (parser
, NULL
);
16190 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
16191 SET_EXPR_LOCATION (substmt
, loc
);
16192 add_stmt (substmt
);
16197 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
16199 if (c_parser_next_token_is (parser
, CPP_EOF
))
16202 loc
= c_parser_peek_token (parser
)->location
;
16203 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_OMP_SECTION
)
16205 c_parser_consume_pragma (parser
);
16206 c_parser_skip_to_pragma_eol (parser
);
16207 error_suppress
= false;
16209 else if (!error_suppress
)
16211 error_at (loc
, "expected %<#pragma omp section%> or %<}%>");
16212 error_suppress
= true;
16215 substmt
= c_parser_omp_structured_block (parser
, NULL
);
16216 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
16217 SET_EXPR_LOCATION (substmt
, loc
);
16218 add_stmt (substmt
);
16220 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
16221 "expected %<#pragma omp section%> or %<}%>");
16223 substmt
= pop_stmt_list (stmt
);
16225 stmt
= make_node (OMP_SECTIONS
);
16226 SET_EXPR_LOCATION (stmt
, sections_loc
);
16227 TREE_TYPE (stmt
) = void_type_node
;
16228 OMP_SECTIONS_BODY (stmt
) = substmt
;
16230 return add_stmt (stmt
);
16234 # pragma omp sections sections-clause[optseq] newline
16237 LOC is the location of the #pragma token.
16240 #define OMP_SECTIONS_CLAUSE_MASK \
16241 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
16242 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
16243 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
16244 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
16245 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
16248 c_parser_omp_sections (location_t loc
, c_parser
*parser
,
16249 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
16251 tree block
, clauses
, ret
;
16253 strcat (p_name
, " sections");
16254 mask
|= OMP_SECTIONS_CLAUSE_MASK
;
16256 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_NOWAIT
);
16258 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
16261 omp_split_clauses (loc
, OMP_SECTIONS
, mask
, clauses
, cclauses
);
16262 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_SECTIONS
];
16265 block
= c_begin_compound_stmt (true);
16266 ret
= c_parser_omp_sections_scope (loc
, parser
);
16268 OMP_SECTIONS_CLAUSES (ret
) = clauses
;
16269 block
= c_end_compound_stmt (loc
, block
, true);
16276 # pragma omp parallel parallel-clause[optseq] new-line
16278 # pragma omp parallel for parallel-for-clause[optseq] new-line
16280 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
16284 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
16287 LOC is the location of the #pragma token.
16290 #define OMP_PARALLEL_CLAUSE_MASK \
16291 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
16292 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
16293 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
16294 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
16295 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
16296 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
16297 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
16298 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
16299 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
16302 c_parser_omp_parallel (location_t loc
, c_parser
*parser
,
16303 char *p_name
, omp_clause_mask mask
, tree
*cclauses
,
16306 tree stmt
, clauses
, block
;
16308 strcat (p_name
, " parallel");
16309 mask
|= OMP_PARALLEL_CLAUSE_MASK
;
16310 /* #pragma omp target parallel{, for, for simd} disallow copyin clause. */
16311 if ((mask
& (OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_MAP
)) != 0
16312 && (mask
& (OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
)) == 0)
16313 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_COPYIN
);
16315 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
16317 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
16318 if (cclauses
== NULL
)
16319 cclauses
= cclauses_buf
;
16321 c_parser_consume_token (parser
);
16322 if (!flag_openmp
) /* flag_openmp_simd */
16323 return c_parser_omp_for (loc
, parser
, p_name
, mask
, cclauses
, if_p
);
16324 block
= c_begin_omp_parallel ();
16325 tree ret
= c_parser_omp_for (loc
, parser
, p_name
, mask
, cclauses
, if_p
);
16327 = c_finish_omp_parallel (loc
, cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
],
16329 if (ret
== NULL_TREE
)
16331 OMP_PARALLEL_COMBINED (stmt
) = 1;
16334 /* When combined with distribute, parallel has to be followed by for.
16335 #pragma omp target parallel is allowed though. */
16337 && (mask
& (OMP_CLAUSE_MASK_1
16338 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
)) != 0)
16340 error_at (loc
, "expected %<for%> after %qs", p_name
);
16341 c_parser_skip_to_pragma_eol (parser
);
16344 else if (!flag_openmp
) /* flag_openmp_simd */
16346 c_parser_skip_to_pragma_eol (parser
, false);
16349 else if (cclauses
== NULL
&& c_parser_next_token_is (parser
, CPP_NAME
))
16351 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
16352 if (strcmp (p
, "sections") == 0)
16354 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
16355 if (cclauses
== NULL
)
16356 cclauses
= cclauses_buf
;
16358 c_parser_consume_token (parser
);
16359 block
= c_begin_omp_parallel ();
16360 c_parser_omp_sections (loc
, parser
, p_name
, mask
, cclauses
);
16361 stmt
= c_finish_omp_parallel (loc
,
16362 cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
],
16364 OMP_PARALLEL_COMBINED (stmt
) = 1;
16369 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
16372 omp_split_clauses (loc
, OMP_PARALLEL
, mask
, clauses
, cclauses
);
16373 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
];
16376 block
= c_begin_omp_parallel ();
16377 c_parser_statement (parser
, if_p
);
16378 stmt
= c_finish_omp_parallel (loc
, clauses
, block
);
16384 # pragma omp single single-clause[optseq] new-line
16387 LOC is the location of the #pragma.
16390 #define OMP_SINGLE_CLAUSE_MASK \
16391 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
16392 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
16393 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
16394 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
16397 c_parser_omp_single (location_t loc
, c_parser
*parser
, bool *if_p
)
16399 tree stmt
= make_node (OMP_SINGLE
);
16400 SET_EXPR_LOCATION (stmt
, loc
);
16401 TREE_TYPE (stmt
) = void_type_node
;
16403 OMP_SINGLE_CLAUSES (stmt
)
16404 = c_parser_omp_all_clauses (parser
, OMP_SINGLE_CLAUSE_MASK
,
16405 "#pragma omp single");
16406 OMP_SINGLE_BODY (stmt
) = c_parser_omp_structured_block (parser
, if_p
);
16408 return add_stmt (stmt
);
16412 # pragma omp task task-clause[optseq] new-line
16414 LOC is the location of the #pragma.
16417 #define OMP_TASK_CLAUSE_MASK \
16418 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
16419 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
16420 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
16421 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
16422 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
16423 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
16424 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
16425 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
16426 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
16427 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY))
16430 c_parser_omp_task (location_t loc
, c_parser
*parser
, bool *if_p
)
16432 tree clauses
, block
;
16434 clauses
= c_parser_omp_all_clauses (parser
, OMP_TASK_CLAUSE_MASK
,
16435 "#pragma omp task");
16437 block
= c_begin_omp_task ();
16438 c_parser_statement (parser
, if_p
);
16439 return c_finish_omp_task (loc
, clauses
, block
);
16443 # pragma omp taskwait new-line
16447 c_parser_omp_taskwait (c_parser
*parser
)
16449 location_t loc
= c_parser_peek_token (parser
)->location
;
16450 c_parser_consume_pragma (parser
);
16451 c_parser_skip_to_pragma_eol (parser
);
16453 c_finish_omp_taskwait (loc
);
16457 # pragma omp taskyield new-line
16461 c_parser_omp_taskyield (c_parser
*parser
)
16463 location_t loc
= c_parser_peek_token (parser
)->location
;
16464 c_parser_consume_pragma (parser
);
16465 c_parser_skip_to_pragma_eol (parser
);
16467 c_finish_omp_taskyield (loc
);
16471 # pragma omp taskgroup new-line
16475 c_parser_omp_taskgroup (c_parser
*parser
, bool *if_p
)
16477 location_t loc
= c_parser_peek_token (parser
)->location
;
16478 c_parser_skip_to_pragma_eol (parser
);
16479 return c_finish_omp_taskgroup (loc
, c_parser_omp_structured_block (parser
,
16484 # pragma omp cancel cancel-clause[optseq] new-line
16486 LOC is the location of the #pragma.
16489 #define OMP_CANCEL_CLAUSE_MASK \
16490 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
16491 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
16492 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
16493 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
16494 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
16497 c_parser_omp_cancel (c_parser
*parser
)
16499 location_t loc
= c_parser_peek_token (parser
)->location
;
16501 c_parser_consume_pragma (parser
);
16502 tree clauses
= c_parser_omp_all_clauses (parser
, OMP_CANCEL_CLAUSE_MASK
,
16503 "#pragma omp cancel");
16505 c_finish_omp_cancel (loc
, clauses
);
16509 # pragma omp cancellation point cancelpt-clause[optseq] new-line
16511 LOC is the location of the #pragma.
16514 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
16515 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
16516 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
16517 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
16518 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
16521 c_parser_omp_cancellation_point (c_parser
*parser
, enum pragma_context context
)
16523 location_t loc
= c_parser_peek_token (parser
)->location
;
16525 bool point_seen
= false;
16527 c_parser_consume_pragma (parser
);
16528 if (c_parser_next_token_is (parser
, CPP_NAME
))
16530 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
16531 if (strcmp (p
, "point") == 0)
16533 c_parser_consume_token (parser
);
16539 c_parser_error (parser
, "expected %<point%>");
16540 c_parser_skip_to_pragma_eol (parser
);
16544 if (context
!= pragma_compound
)
16546 if (context
== pragma_stmt
)
16548 "%<#pragma %s%> may only be used in compound statements",
16549 "omp cancellation point");
16551 c_parser_error (parser
, "expected declaration specifiers");
16552 c_parser_skip_to_pragma_eol (parser
, false);
16557 = c_parser_omp_all_clauses (parser
, OMP_CANCELLATION_POINT_CLAUSE_MASK
,
16558 "#pragma omp cancellation point");
16560 c_finish_omp_cancellation_point (loc
, clauses
);
16564 #pragma omp distribute distribute-clause[optseq] new-line
16567 #define OMP_DISTRIBUTE_CLAUSE_MASK \
16568 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
16569 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
16570 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
16571 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
16572 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
16575 c_parser_omp_distribute (location_t loc
, c_parser
*parser
,
16576 char *p_name
, omp_clause_mask mask
, tree
*cclauses
,
16579 tree clauses
, block
, ret
;
16581 strcat (p_name
, " distribute");
16582 mask
|= OMP_DISTRIBUTE_CLAUSE_MASK
;
16584 if (c_parser_next_token_is (parser
, CPP_NAME
))
16586 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
16588 bool parallel
= false;
16590 if (strcmp (p
, "simd") == 0)
16593 parallel
= strcmp (p
, "parallel") == 0;
16594 if (parallel
|| simd
)
16596 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
16597 if (cclauses
== NULL
)
16598 cclauses
= cclauses_buf
;
16599 c_parser_consume_token (parser
);
16600 if (!flag_openmp
) /* flag_openmp_simd */
16603 return c_parser_omp_simd (loc
, parser
, p_name
, mask
, cclauses
,
16606 return c_parser_omp_parallel (loc
, parser
, p_name
, mask
,
16609 block
= c_begin_compound_stmt (true);
16611 ret
= c_parser_omp_simd (loc
, parser
, p_name
, mask
, cclauses
,
16614 ret
= c_parser_omp_parallel (loc
, parser
, p_name
, mask
, cclauses
,
16616 block
= c_end_compound_stmt (loc
, block
, true);
16619 ret
= make_node (OMP_DISTRIBUTE
);
16620 TREE_TYPE (ret
) = void_type_node
;
16621 OMP_FOR_BODY (ret
) = block
;
16622 OMP_FOR_CLAUSES (ret
) = cclauses
[C_OMP_CLAUSE_SPLIT_DISTRIBUTE
];
16623 SET_EXPR_LOCATION (ret
, loc
);
16628 if (!flag_openmp
) /* flag_openmp_simd */
16630 c_parser_skip_to_pragma_eol (parser
, false);
16634 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
16637 omp_split_clauses (loc
, OMP_DISTRIBUTE
, mask
, clauses
, cclauses
);
16638 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_DISTRIBUTE
];
16641 block
= c_begin_compound_stmt (true);
16642 ret
= c_parser_omp_for_loop (loc
, parser
, OMP_DISTRIBUTE
, clauses
, NULL
,
16644 block
= c_end_compound_stmt (loc
, block
, true);
16651 # pragma omp teams teams-clause[optseq] new-line
16652 structured-block */
16654 #define OMP_TEAMS_CLAUSE_MASK \
16655 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
16656 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
16657 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
16658 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
16659 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
16660 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
16661 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
16664 c_parser_omp_teams (location_t loc
, c_parser
*parser
,
16665 char *p_name
, omp_clause_mask mask
, tree
*cclauses
,
16668 tree clauses
, block
, ret
;
16670 strcat (p_name
, " teams");
16671 mask
|= OMP_TEAMS_CLAUSE_MASK
;
16673 if (c_parser_next_token_is (parser
, CPP_NAME
))
16675 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
16676 if (strcmp (p
, "distribute") == 0)
16678 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
16679 if (cclauses
== NULL
)
16680 cclauses
= cclauses_buf
;
16682 c_parser_consume_token (parser
);
16683 if (!flag_openmp
) /* flag_openmp_simd */
16684 return c_parser_omp_distribute (loc
, parser
, p_name
, mask
,
16686 block
= c_begin_compound_stmt (true);
16687 ret
= c_parser_omp_distribute (loc
, parser
, p_name
, mask
, cclauses
,
16689 block
= c_end_compound_stmt (loc
, block
, true);
16692 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_TEAMS
];
16693 ret
= make_node (OMP_TEAMS
);
16694 TREE_TYPE (ret
) = void_type_node
;
16695 OMP_TEAMS_CLAUSES (ret
) = clauses
;
16696 OMP_TEAMS_BODY (ret
) = block
;
16697 OMP_TEAMS_COMBINED (ret
) = 1;
16698 return add_stmt (ret
);
16701 if (!flag_openmp
) /* flag_openmp_simd */
16703 c_parser_skip_to_pragma_eol (parser
, false);
16707 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
16710 omp_split_clauses (loc
, OMP_TEAMS
, mask
, clauses
, cclauses
);
16711 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_TEAMS
];
16714 tree stmt
= make_node (OMP_TEAMS
);
16715 TREE_TYPE (stmt
) = void_type_node
;
16716 OMP_TEAMS_CLAUSES (stmt
) = clauses
;
16717 OMP_TEAMS_BODY (stmt
) = c_parser_omp_structured_block (parser
, if_p
);
16719 return add_stmt (stmt
);
16723 # pragma omp target data target-data-clause[optseq] new-line
16724 structured-block */
16726 #define OMP_TARGET_DATA_CLAUSE_MASK \
16727 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
16728 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
16729 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
16730 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR))
16733 c_parser_omp_target_data (location_t loc
, c_parser
*parser
, bool *if_p
)
16736 = c_parser_omp_all_clauses (parser
, OMP_TARGET_DATA_CLAUSE_MASK
,
16737 "#pragma omp target data");
16739 for (tree
*pc
= &clauses
; *pc
;)
16741 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_MAP
)
16742 switch (OMP_CLAUSE_MAP_KIND (*pc
))
16745 case GOMP_MAP_ALWAYS_TO
:
16746 case GOMP_MAP_FROM
:
16747 case GOMP_MAP_ALWAYS_FROM
:
16748 case GOMP_MAP_TOFROM
:
16749 case GOMP_MAP_ALWAYS_TOFROM
:
16750 case GOMP_MAP_ALLOC
:
16753 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
16754 case GOMP_MAP_ALWAYS_POINTER
:
16758 error_at (OMP_CLAUSE_LOCATION (*pc
),
16759 "%<#pragma omp target data%> with map-type other "
16760 "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
16761 "on %<map%> clause");
16762 *pc
= OMP_CLAUSE_CHAIN (*pc
);
16765 pc
= &OMP_CLAUSE_CHAIN (*pc
);
16772 "%<#pragma omp target data%> must contain at least "
16773 "one %<map%> clause");
16777 tree stmt
= make_node (OMP_TARGET_DATA
);
16778 TREE_TYPE (stmt
) = void_type_node
;
16779 OMP_TARGET_DATA_CLAUSES (stmt
) = clauses
;
16780 keep_next_level ();
16781 tree block
= c_begin_compound_stmt (true);
16782 add_stmt (c_parser_omp_structured_block (parser
, if_p
));
16783 OMP_TARGET_DATA_BODY (stmt
) = c_end_compound_stmt (loc
, block
, true);
16785 SET_EXPR_LOCATION (stmt
, loc
);
16786 return add_stmt (stmt
);
16790 # pragma omp target update target-update-clause[optseq] new-line */
16792 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
16793 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
16794 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
16795 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
16796 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
16797 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
16798 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
16801 c_parser_omp_target_update (location_t loc
, c_parser
*parser
,
16802 enum pragma_context context
)
16804 if (context
== pragma_stmt
)
16806 error_at (loc
, "%<#pragma %s%> may only be used in compound statements",
16807 "omp target update");
16808 c_parser_skip_to_pragma_eol (parser
, false);
16813 = c_parser_omp_all_clauses (parser
, OMP_TARGET_UPDATE_CLAUSE_MASK
,
16814 "#pragma omp target update");
16815 if (omp_find_clause (clauses
, OMP_CLAUSE_TO
) == NULL_TREE
16816 && omp_find_clause (clauses
, OMP_CLAUSE_FROM
) == NULL_TREE
)
16819 "%<#pragma omp target update%> must contain at least one "
16820 "%<from%> or %<to%> clauses");
16824 tree stmt
= make_node (OMP_TARGET_UPDATE
);
16825 TREE_TYPE (stmt
) = void_type_node
;
16826 OMP_TARGET_UPDATE_CLAUSES (stmt
) = clauses
;
16827 SET_EXPR_LOCATION (stmt
, loc
);
16833 # pragma omp target enter data target-data-clause[optseq] new-line */
16835 #define OMP_TARGET_ENTER_DATA_CLAUSE_MASK \
16836 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
16837 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
16838 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
16839 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
16840 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
16843 c_parser_omp_target_enter_data (location_t loc
, c_parser
*parser
,
16844 enum pragma_context context
)
16846 bool data_seen
= false;
16847 if (c_parser_next_token_is (parser
, CPP_NAME
))
16849 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
16850 if (strcmp (p
, "data") == 0)
16852 c_parser_consume_token (parser
);
16858 c_parser_error (parser
, "expected %<data%>");
16859 c_parser_skip_to_pragma_eol (parser
);
16863 if (context
== pragma_stmt
)
16865 error_at (loc
, "%<#pragma %s%> may only be used in compound statements",
16866 "omp target enter data");
16867 c_parser_skip_to_pragma_eol (parser
, false);
16872 = c_parser_omp_all_clauses (parser
, OMP_TARGET_ENTER_DATA_CLAUSE_MASK
,
16873 "#pragma omp target enter data");
16875 for (tree
*pc
= &clauses
; *pc
;)
16877 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_MAP
)
16878 switch (OMP_CLAUSE_MAP_KIND (*pc
))
16881 case GOMP_MAP_ALWAYS_TO
:
16882 case GOMP_MAP_ALLOC
:
16885 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
16886 case GOMP_MAP_ALWAYS_POINTER
:
16890 error_at (OMP_CLAUSE_LOCATION (*pc
),
16891 "%<#pragma omp target enter data%> with map-type other "
16892 "than %<to%> or %<alloc%> on %<map%> clause");
16893 *pc
= OMP_CLAUSE_CHAIN (*pc
);
16896 pc
= &OMP_CLAUSE_CHAIN (*pc
);
16903 "%<#pragma omp target enter data%> must contain at least "
16904 "one %<map%> clause");
16908 tree stmt
= make_node (OMP_TARGET_ENTER_DATA
);
16909 TREE_TYPE (stmt
) = void_type_node
;
16910 OMP_TARGET_ENTER_DATA_CLAUSES (stmt
) = clauses
;
16911 SET_EXPR_LOCATION (stmt
, loc
);
16917 # pragma omp target exit data target-data-clause[optseq] new-line */
16919 #define OMP_TARGET_EXIT_DATA_CLAUSE_MASK \
16920 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
16921 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
16922 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
16923 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
16924 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
16927 c_parser_omp_target_exit_data (location_t loc
, c_parser
*parser
,
16928 enum pragma_context context
)
16930 bool data_seen
= false;
16931 if (c_parser_next_token_is (parser
, CPP_NAME
))
16933 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
16934 if (strcmp (p
, "data") == 0)
16936 c_parser_consume_token (parser
);
16942 c_parser_error (parser
, "expected %<data%>");
16943 c_parser_skip_to_pragma_eol (parser
);
16947 if (context
== pragma_stmt
)
16949 error_at (loc
, "%<#pragma %s%> may only be used in compound statements",
16950 "omp target exit data");
16951 c_parser_skip_to_pragma_eol (parser
, false);
16956 = c_parser_omp_all_clauses (parser
, OMP_TARGET_EXIT_DATA_CLAUSE_MASK
,
16957 "#pragma omp target exit data");
16960 for (tree
*pc
= &clauses
; *pc
;)
16962 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_MAP
)
16963 switch (OMP_CLAUSE_MAP_KIND (*pc
))
16965 case GOMP_MAP_FROM
:
16966 case GOMP_MAP_ALWAYS_FROM
:
16967 case GOMP_MAP_RELEASE
:
16968 case GOMP_MAP_DELETE
:
16971 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
16972 case GOMP_MAP_ALWAYS_POINTER
:
16976 error_at (OMP_CLAUSE_LOCATION (*pc
),
16977 "%<#pragma omp target exit data%> with map-type other "
16978 "than %<from%>, %<release%> or %<delete%> on %<map%>"
16980 *pc
= OMP_CLAUSE_CHAIN (*pc
);
16983 pc
= &OMP_CLAUSE_CHAIN (*pc
);
16990 "%<#pragma omp target exit data%> must contain at least one "
16995 tree stmt
= make_node (OMP_TARGET_EXIT_DATA
);
16996 TREE_TYPE (stmt
) = void_type_node
;
16997 OMP_TARGET_EXIT_DATA_CLAUSES (stmt
) = clauses
;
16998 SET_EXPR_LOCATION (stmt
, loc
);
17004 # pragma omp target target-clause[optseq] new-line
17005 structured-block */
17007 #define OMP_TARGET_CLAUSE_MASK \
17008 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
17009 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
17010 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
17011 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
17012 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
17013 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
17014 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
17015 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULTMAP) \
17016 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR))
17019 c_parser_omp_target (c_parser
*parser
, enum pragma_context context
, bool *if_p
)
17021 location_t loc
= c_parser_peek_token (parser
)->location
;
17022 c_parser_consume_pragma (parser
);
17023 tree
*pc
= NULL
, stmt
, block
;
17025 if (context
!= pragma_stmt
&& context
!= pragma_compound
)
17027 c_parser_error (parser
, "expected declaration specifiers");
17028 c_parser_skip_to_pragma_eol (parser
);
17032 if (c_parser_next_token_is (parser
, CPP_NAME
))
17034 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
17035 enum tree_code ccode
= ERROR_MARK
;
17037 if (strcmp (p
, "teams") == 0)
17039 else if (strcmp (p
, "parallel") == 0)
17040 ccode
= OMP_PARALLEL
;
17041 else if (strcmp (p
, "simd") == 0)
17043 if (ccode
!= ERROR_MARK
)
17045 tree cclauses
[C_OMP_CLAUSE_SPLIT_COUNT
];
17046 char p_name
[sizeof ("#pragma omp target teams distribute "
17047 "parallel for simd")];
17049 c_parser_consume_token (parser
);
17050 strcpy (p_name
, "#pragma omp target");
17051 if (!flag_openmp
) /* flag_openmp_simd */
17057 stmt
= c_parser_omp_teams (loc
, parser
, p_name
,
17058 OMP_TARGET_CLAUSE_MASK
,
17062 stmt
= c_parser_omp_parallel (loc
, parser
, p_name
,
17063 OMP_TARGET_CLAUSE_MASK
,
17067 stmt
= c_parser_omp_simd (loc
, parser
, p_name
,
17068 OMP_TARGET_CLAUSE_MASK
,
17072 gcc_unreachable ();
17074 return stmt
!= NULL_TREE
;
17076 keep_next_level ();
17077 tree block
= c_begin_compound_stmt (true), ret
;
17081 ret
= c_parser_omp_teams (loc
, parser
, p_name
,
17082 OMP_TARGET_CLAUSE_MASK
, cclauses
,
17086 ret
= c_parser_omp_parallel (loc
, parser
, p_name
,
17087 OMP_TARGET_CLAUSE_MASK
, cclauses
,
17091 ret
= c_parser_omp_simd (loc
, parser
, p_name
,
17092 OMP_TARGET_CLAUSE_MASK
, cclauses
,
17096 gcc_unreachable ();
17098 block
= c_end_compound_stmt (loc
, block
, true);
17099 if (ret
== NULL_TREE
)
17101 if (ccode
== OMP_TEAMS
)
17103 /* For combined target teams, ensure the num_teams and
17104 thread_limit clause expressions are evaluated on the host,
17105 before entering the target construct. */
17107 for (c
= cclauses
[C_OMP_CLAUSE_SPLIT_TEAMS
];
17108 c
; c
= OMP_CLAUSE_CHAIN (c
))
17109 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
17110 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
17111 && TREE_CODE (OMP_CLAUSE_OPERAND (c
, 0)) != INTEGER_CST
)
17113 tree expr
= OMP_CLAUSE_OPERAND (c
, 0);
17114 tree tmp
= create_tmp_var_raw (TREE_TYPE (expr
));
17115 expr
= build4 (TARGET_EXPR
, TREE_TYPE (expr
), tmp
,
17116 expr
, NULL_TREE
, NULL_TREE
);
17118 OMP_CLAUSE_OPERAND (c
, 0) = expr
;
17119 tree tc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
17120 OMP_CLAUSE_FIRSTPRIVATE
);
17121 OMP_CLAUSE_DECL (tc
) = tmp
;
17122 OMP_CLAUSE_CHAIN (tc
)
17123 = cclauses
[C_OMP_CLAUSE_SPLIT_TARGET
];
17124 cclauses
[C_OMP_CLAUSE_SPLIT_TARGET
] = tc
;
17127 tree stmt
= make_node (OMP_TARGET
);
17128 TREE_TYPE (stmt
) = void_type_node
;
17129 OMP_TARGET_CLAUSES (stmt
) = cclauses
[C_OMP_CLAUSE_SPLIT_TARGET
];
17130 OMP_TARGET_BODY (stmt
) = block
;
17131 OMP_TARGET_COMBINED (stmt
) = 1;
17133 pc
= &OMP_TARGET_CLAUSES (stmt
);
17134 goto check_clauses
;
17136 else if (!flag_openmp
) /* flag_openmp_simd */
17138 c_parser_skip_to_pragma_eol (parser
, false);
17141 else if (strcmp (p
, "data") == 0)
17143 c_parser_consume_token (parser
);
17144 c_parser_omp_target_data (loc
, parser
, if_p
);
17147 else if (strcmp (p
, "enter") == 0)
17149 c_parser_consume_token (parser
);
17150 c_parser_omp_target_enter_data (loc
, parser
, context
);
17153 else if (strcmp (p
, "exit") == 0)
17155 c_parser_consume_token (parser
);
17156 c_parser_omp_target_exit_data (loc
, parser
, context
);
17159 else if (strcmp (p
, "update") == 0)
17161 c_parser_consume_token (parser
);
17162 return c_parser_omp_target_update (loc
, parser
, context
);
17165 if (!flag_openmp
) /* flag_openmp_simd */
17167 c_parser_skip_to_pragma_eol (parser
, false);
17171 stmt
= make_node (OMP_TARGET
);
17172 TREE_TYPE (stmt
) = void_type_node
;
17174 OMP_TARGET_CLAUSES (stmt
)
17175 = c_parser_omp_all_clauses (parser
, OMP_TARGET_CLAUSE_MASK
,
17176 "#pragma omp target");
17177 pc
= &OMP_TARGET_CLAUSES (stmt
);
17178 keep_next_level ();
17179 block
= c_begin_compound_stmt (true);
17180 add_stmt (c_parser_omp_structured_block (parser
, if_p
));
17181 OMP_TARGET_BODY (stmt
) = c_end_compound_stmt (loc
, block
, true);
17183 SET_EXPR_LOCATION (stmt
, loc
);
17189 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_MAP
)
17190 switch (OMP_CLAUSE_MAP_KIND (*pc
))
17193 case GOMP_MAP_ALWAYS_TO
:
17194 case GOMP_MAP_FROM
:
17195 case GOMP_MAP_ALWAYS_FROM
:
17196 case GOMP_MAP_TOFROM
:
17197 case GOMP_MAP_ALWAYS_TOFROM
:
17198 case GOMP_MAP_ALLOC
:
17199 case GOMP_MAP_FIRSTPRIVATE_POINTER
:
17200 case GOMP_MAP_ALWAYS_POINTER
:
17203 error_at (OMP_CLAUSE_LOCATION (*pc
),
17204 "%<#pragma omp target%> with map-type other "
17205 "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
17206 "on %<map%> clause");
17207 *pc
= OMP_CLAUSE_CHAIN (*pc
);
17210 pc
= &OMP_CLAUSE_CHAIN (*pc
);
17216 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
17218 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
17219 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
17220 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
17221 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
17222 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
17223 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
17224 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
17227 c_parser_omp_declare_simd (c_parser
*parser
, enum pragma_context context
)
17229 auto_vec
<c_token
> clauses
;
17230 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
17232 c_token
*token
= c_parser_peek_token (parser
);
17233 if (token
->type
== CPP_EOF
)
17235 c_parser_skip_to_pragma_eol (parser
);
17238 clauses
.safe_push (*token
);
17239 c_parser_consume_token (parser
);
17241 clauses
.safe_push (*c_parser_peek_token (parser
));
17242 c_parser_skip_to_pragma_eol (parser
);
17244 while (c_parser_next_token_is (parser
, CPP_PRAGMA
))
17246 if (c_parser_peek_token (parser
)->pragma_kind
17247 != PRAGMA_OMP_DECLARE
17248 || c_parser_peek_2nd_token (parser
)->type
!= CPP_NAME
17249 || strcmp (IDENTIFIER_POINTER
17250 (c_parser_peek_2nd_token (parser
)->value
),
17253 c_parser_error (parser
,
17254 "%<#pragma omp declare simd%> must be followed by "
17255 "function declaration or definition or another "
17256 "%<#pragma omp declare simd%>");
17259 c_parser_consume_pragma (parser
);
17260 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
17262 c_token
*token
= c_parser_peek_token (parser
);
17263 if (token
->type
== CPP_EOF
)
17265 c_parser_skip_to_pragma_eol (parser
);
17268 clauses
.safe_push (*token
);
17269 c_parser_consume_token (parser
);
17271 clauses
.safe_push (*c_parser_peek_token (parser
));
17272 c_parser_skip_to_pragma_eol (parser
);
17275 /* Make sure nothing tries to read past the end of the tokens. */
17277 memset (&eof_token
, 0, sizeof (eof_token
));
17278 eof_token
.type
= CPP_EOF
;
17279 clauses
.safe_push (eof_token
);
17280 clauses
.safe_push (eof_token
);
17284 case pragma_external
:
17285 if (c_parser_next_token_is (parser
, CPP_KEYWORD
)
17286 && c_parser_peek_token (parser
)->keyword
== RID_EXTENSION
)
17288 int ext
= disable_extension_diagnostics ();
17290 c_parser_consume_token (parser
);
17291 while (c_parser_next_token_is (parser
, CPP_KEYWORD
)
17292 && c_parser_peek_token (parser
)->keyword
== RID_EXTENSION
);
17293 c_parser_declaration_or_fndef (parser
, true, true, true, false, true,
17295 restore_extension_diagnostics (ext
);
17298 c_parser_declaration_or_fndef (parser
, true, true, true, false, true,
17301 case pragma_struct
:
17304 c_parser_error (parser
, "%<#pragma omp declare simd%> must be followed by "
17305 "function declaration or definition");
17307 case pragma_compound
:
17308 if (c_parser_next_token_is (parser
, CPP_KEYWORD
)
17309 && c_parser_peek_token (parser
)->keyword
== RID_EXTENSION
)
17311 int ext
= disable_extension_diagnostics ();
17313 c_parser_consume_token (parser
);
17314 while (c_parser_next_token_is (parser
, CPP_KEYWORD
)
17315 && c_parser_peek_token (parser
)->keyword
== RID_EXTENSION
);
17316 if (c_parser_next_tokens_start_declaration (parser
))
17318 c_parser_declaration_or_fndef (parser
, true, true, true, true,
17319 true, NULL
, clauses
);
17320 restore_extension_diagnostics (ext
);
17323 restore_extension_diagnostics (ext
);
17325 else if (c_parser_next_tokens_start_declaration (parser
))
17327 c_parser_declaration_or_fndef (parser
, true, true, true, true, true,
17331 c_parser_error (parser
, "%<#pragma omp declare simd%> must be followed by "
17332 "function declaration or definition");
17335 gcc_unreachable ();
17339 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
17340 and put that into "omp declare simd" attribute. */
17343 c_finish_omp_declare_simd (c_parser
*parser
, tree fndecl
, tree parms
,
17344 vec
<c_token
> clauses
)
17346 /* Normally first token is CPP_NAME "simd". CPP_EOF there indicates
17347 error has been reported and CPP_PRAGMA that c_finish_omp_declare_simd
17348 has already processed the tokens. */
17349 if (clauses
.exists () && clauses
[0].type
== CPP_EOF
)
17351 if (fndecl
== NULL_TREE
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
17353 error ("%<#pragma omp declare simd%> not immediately followed by "
17354 "a function declaration or definition");
17355 clauses
[0].type
= CPP_EOF
;
17358 if (clauses
.exists () && clauses
[0].type
!= CPP_NAME
)
17360 error_at (DECL_SOURCE_LOCATION (fndecl
),
17361 "%<#pragma omp declare simd%> not immediately followed by "
17362 "a single function declaration or definition");
17363 clauses
[0].type
= CPP_EOF
;
17367 if (parms
== NULL_TREE
)
17368 parms
= DECL_ARGUMENTS (fndecl
);
17370 unsigned int tokens_avail
= parser
->tokens_avail
;
17371 gcc_assert (parser
->tokens
== &parser
->tokens_buf
[0]);
17374 parser
->tokens
= clauses
.address ();
17375 parser
->tokens_avail
= clauses
.length ();
17377 /* c_parser_omp_declare_simd pushed 2 extra CPP_EOF tokens at the end. */
17378 while (parser
->tokens_avail
> 3)
17380 c_token
*token
= c_parser_peek_token (parser
);
17381 gcc_assert (token
->type
== CPP_NAME
17382 && strcmp (IDENTIFIER_POINTER (token
->value
), "simd") == 0);
17383 c_parser_consume_token (parser
);
17384 parser
->in_pragma
= true;
17386 tree c
= NULL_TREE
;
17387 c
= c_parser_omp_all_clauses (parser
, OMP_DECLARE_SIMD_CLAUSE_MASK
,
17388 "#pragma omp declare simd");
17389 c
= c_omp_declare_simd_clauses_to_numbers (parms
, c
);
17390 if (c
!= NULL_TREE
)
17391 c
= tree_cons (NULL_TREE
, c
, NULL_TREE
);
17392 c
= build_tree_list (get_identifier ("omp declare simd"), c
);
17393 TREE_CHAIN (c
) = DECL_ATTRIBUTES (fndecl
);
17394 DECL_ATTRIBUTES (fndecl
) = c
;
17397 parser
->tokens
= &parser
->tokens_buf
[0];
17398 parser
->tokens_avail
= tokens_avail
;
17399 if (clauses
.exists ())
17400 clauses
[0].type
= CPP_PRAGMA
;
17405 # pragma omp declare target new-line
17406 declarations and definitions
17407 # pragma omp end declare target new-line
17410 # pragma omp declare target ( extended-list ) new-line
17412 # pragma omp declare target declare-target-clauses[seq] new-line */
17414 #define OMP_DECLARE_TARGET_CLAUSE_MASK \
17415 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
17416 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK))
17419 c_parser_omp_declare_target (c_parser
*parser
)
17421 location_t loc
= c_parser_peek_token (parser
)->location
;
17422 tree clauses
= NULL_TREE
;
17423 if (c_parser_next_token_is (parser
, CPP_NAME
))
17424 clauses
= c_parser_omp_all_clauses (parser
, OMP_DECLARE_TARGET_CLAUSE_MASK
,
17425 "#pragma omp declare target");
17426 else if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
17428 clauses
= c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_TO_DECLARE
,
17430 clauses
= c_finish_omp_clauses (clauses
, C_ORT_OMP
);
17431 c_parser_skip_to_pragma_eol (parser
);
17435 c_parser_skip_to_pragma_eol (parser
);
17436 current_omp_declare_target_attribute
++;
17439 if (current_omp_declare_target_attribute
)
17440 error_at (loc
, "%<#pragma omp declare target%> with clauses in between "
17441 "%<#pragma omp declare target%> without clauses and "
17442 "%<#pragma omp end declare target%>");
17443 for (tree c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
17445 tree t
= OMP_CLAUSE_DECL (c
), id
;
17446 tree at1
= lookup_attribute ("omp declare target", DECL_ATTRIBUTES (t
));
17447 tree at2
= lookup_attribute ("omp declare target link",
17448 DECL_ATTRIBUTES (t
));
17449 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINK
)
17451 id
= get_identifier ("omp declare target link");
17452 std::swap (at1
, at2
);
17455 id
= get_identifier ("omp declare target");
17458 error_at (OMP_CLAUSE_LOCATION (c
),
17459 "%qD specified both in declare target %<link%> and %<to%>"
17465 DECL_ATTRIBUTES (t
) = tree_cons (id
, NULL_TREE
, DECL_ATTRIBUTES (t
));
17466 if (TREE_CODE (t
) != FUNCTION_DECL
&& !is_global_var (t
))
17469 symtab_node
*node
= symtab_node::get (t
);
17472 node
->offloadable
= 1;
17473 if (ENABLE_OFFLOADING
)
17475 g
->have_offload
= true;
17476 if (is_a
<varpool_node
*> (node
))
17477 vec_safe_push (offload_vars
, t
);
17485 c_parser_omp_end_declare_target (c_parser
*parser
)
17487 location_t loc
= c_parser_peek_token (parser
)->location
;
17488 c_parser_consume_pragma (parser
);
17489 if (c_parser_next_token_is (parser
, CPP_NAME
)
17490 && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
),
17493 c_parser_consume_token (parser
);
17494 if (c_parser_next_token_is (parser
, CPP_NAME
)
17495 && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
),
17497 c_parser_consume_token (parser
);
17500 c_parser_error (parser
, "expected %<target%>");
17501 c_parser_skip_to_pragma_eol (parser
);
17507 c_parser_error (parser
, "expected %<declare%>");
17508 c_parser_skip_to_pragma_eol (parser
);
17511 c_parser_skip_to_pragma_eol (parser
);
17512 if (!current_omp_declare_target_attribute
)
17513 error_at (loc
, "%<#pragma omp end declare target%> without corresponding "
17514 "%<#pragma omp declare target%>");
17516 current_omp_declare_target_attribute
--;
17521 #pragma omp declare reduction (reduction-id : typename-list : expression) \
17522 initializer-clause[opt] new-line
17524 initializer-clause:
17525 initializer (omp_priv = initializer)
17526 initializer (function-name (argument-list)) */
17529 c_parser_omp_declare_reduction (c_parser
*parser
, enum pragma_context context
)
17531 unsigned int tokens_avail
= 0, i
;
17532 vec
<tree
> types
= vNULL
;
17533 vec
<c_token
> clauses
= vNULL
;
17534 enum tree_code reduc_code
= ERROR_MARK
;
17535 tree reduc_id
= NULL_TREE
;
17537 location_t rloc
= c_parser_peek_token (parser
)->location
;
17539 if (context
== pragma_struct
|| context
== pragma_param
)
17541 error ("%<#pragma omp declare reduction%> not at file or block scope");
17545 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
17548 switch (c_parser_peek_token (parser
)->type
)
17551 reduc_code
= PLUS_EXPR
;
17554 reduc_code
= MULT_EXPR
;
17557 reduc_code
= MINUS_EXPR
;
17560 reduc_code
= BIT_AND_EXPR
;
17563 reduc_code
= BIT_XOR_EXPR
;
17566 reduc_code
= BIT_IOR_EXPR
;
17569 reduc_code
= TRUTH_ANDIF_EXPR
;
17572 reduc_code
= TRUTH_ORIF_EXPR
;
17576 p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
17577 if (strcmp (p
, "min") == 0)
17579 reduc_code
= MIN_EXPR
;
17582 if (strcmp (p
, "max") == 0)
17584 reduc_code
= MAX_EXPR
;
17587 reduc_id
= c_parser_peek_token (parser
)->value
;
17590 c_parser_error (parser
,
17591 "expected %<+%>, %<*%>, %<-%>, %<&%>, "
17592 "%<^%>, %<|%>, %<&&%>, %<||%> or identifier");
17596 tree orig_reduc_id
, reduc_decl
;
17597 orig_reduc_id
= reduc_id
;
17598 reduc_id
= c_omp_reduction_id (reduc_code
, reduc_id
);
17599 reduc_decl
= c_omp_reduction_decl (reduc_id
);
17600 c_parser_consume_token (parser
);
17602 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
17607 location_t loc
= c_parser_peek_token (parser
)->location
;
17608 struct c_type_name
*ctype
= c_parser_type_name (parser
);
17611 type
= groktypename (ctype
, NULL
, NULL
);
17612 if (type
== error_mark_node
)
17614 else if ((INTEGRAL_TYPE_P (type
)
17615 || TREE_CODE (type
) == REAL_TYPE
17616 || TREE_CODE (type
) == COMPLEX_TYPE
)
17617 && orig_reduc_id
== NULL_TREE
)
17618 error_at (loc
, "predeclared arithmetic type in "
17619 "%<#pragma omp declare reduction%>");
17620 else if (TREE_CODE (type
) == FUNCTION_TYPE
17621 || TREE_CODE (type
) == ARRAY_TYPE
)
17622 error_at (loc
, "function or array type in "
17623 "%<#pragma omp declare reduction%>");
17624 else if (TYPE_ATOMIC (type
))
17625 error_at (loc
, "%<_Atomic%> qualified type in "
17626 "%<#pragma omp declare reduction%>");
17627 else if (TYPE_QUALS_NO_ADDR_SPACE (type
))
17628 error_at (loc
, "const, volatile or restrict qualified type in "
17629 "%<#pragma omp declare reduction%>");
17633 for (t
= DECL_INITIAL (reduc_decl
); t
; t
= TREE_CHAIN (t
))
17634 if (comptypes (TREE_PURPOSE (t
), type
))
17636 error_at (loc
, "redeclaration of %qs "
17637 "%<#pragma omp declare reduction%> for "
17639 IDENTIFIER_POINTER (reduc_id
)
17640 + sizeof ("omp declare reduction ") - 1,
17643 = DECL_SOURCE_LOCATION (TREE_VEC_ELT (TREE_VALUE (t
),
17645 error_at (ploc
, "previous %<#pragma omp declare "
17649 if (t
== NULL_TREE
)
17650 types
.safe_push (type
);
17652 if (c_parser_next_token_is (parser
, CPP_COMMA
))
17653 c_parser_consume_token (parser
);
17661 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>")
17662 || types
.is_empty ())
17665 clauses
.release ();
17669 c_token
*token
= c_parser_peek_token (parser
);
17670 if (token
->type
== CPP_EOF
|| token
->type
== CPP_PRAGMA_EOL
)
17672 c_parser_consume_token (parser
);
17674 c_parser_skip_to_pragma_eol (parser
);
17678 if (types
.length () > 1)
17680 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
17682 c_token
*token
= c_parser_peek_token (parser
);
17683 if (token
->type
== CPP_EOF
)
17685 clauses
.safe_push (*token
);
17686 c_parser_consume_token (parser
);
17688 clauses
.safe_push (*c_parser_peek_token (parser
));
17689 c_parser_skip_to_pragma_eol (parser
);
17691 /* Make sure nothing tries to read past the end of the tokens. */
17693 memset (&eof_token
, 0, sizeof (eof_token
));
17694 eof_token
.type
= CPP_EOF
;
17695 clauses
.safe_push (eof_token
);
17696 clauses
.safe_push (eof_token
);
17699 int errs
= errorcount
;
17700 FOR_EACH_VEC_ELT (types
, i
, type
)
17702 tokens_avail
= parser
->tokens_avail
;
17703 gcc_assert (parser
->tokens
== &parser
->tokens_buf
[0]);
17704 if (!clauses
.is_empty ())
17706 parser
->tokens
= clauses
.address ();
17707 parser
->tokens_avail
= clauses
.length ();
17708 parser
->in_pragma
= true;
17711 bool nested
= current_function_decl
!= NULL_TREE
;
17713 c_push_function_context ();
17714 tree fndecl
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
17715 reduc_id
, default_function_type
);
17716 current_function_decl
= fndecl
;
17717 allocate_struct_function (fndecl
, true);
17719 tree stmt
= push_stmt_list ();
17720 /* Intentionally BUILTINS_LOCATION, so that -Wshadow doesn't
17721 warn about these. */
17722 tree omp_out
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
17723 get_identifier ("omp_out"), type
);
17724 DECL_ARTIFICIAL (omp_out
) = 1;
17725 DECL_CONTEXT (omp_out
) = fndecl
;
17726 pushdecl (omp_out
);
17727 tree omp_in
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
17728 get_identifier ("omp_in"), type
);
17729 DECL_ARTIFICIAL (omp_in
) = 1;
17730 DECL_CONTEXT (omp_in
) = fndecl
;
17732 struct c_expr combiner
= c_parser_expression (parser
);
17733 struct c_expr initializer
;
17734 tree omp_priv
= NULL_TREE
, omp_orig
= NULL_TREE
;
17736 initializer
.set_error ();
17737 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
17739 else if (c_parser_next_token_is (parser
, CPP_NAME
)
17740 && strcmp (IDENTIFIER_POINTER
17741 (c_parser_peek_token (parser
)->value
),
17742 "initializer") == 0)
17744 c_parser_consume_token (parser
);
17747 omp_priv
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
17748 get_identifier ("omp_priv"), type
);
17749 DECL_ARTIFICIAL (omp_priv
) = 1;
17750 DECL_INITIAL (omp_priv
) = error_mark_node
;
17751 DECL_CONTEXT (omp_priv
) = fndecl
;
17752 pushdecl (omp_priv
);
17753 omp_orig
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
17754 get_identifier ("omp_orig"), type
);
17755 DECL_ARTIFICIAL (omp_orig
) = 1;
17756 DECL_CONTEXT (omp_orig
) = fndecl
;
17757 pushdecl (omp_orig
);
17758 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
17760 else if (!c_parser_next_token_is (parser
, CPP_NAME
))
17762 c_parser_error (parser
, "expected %<omp_priv%> or "
17766 else if (strcmp (IDENTIFIER_POINTER
17767 (c_parser_peek_token (parser
)->value
),
17770 if (c_parser_peek_2nd_token (parser
)->type
!= CPP_OPEN_PAREN
17771 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
17773 c_parser_error (parser
, "expected function-name %<(%>");
17777 initializer
= c_parser_postfix_expression (parser
);
17778 if (initializer
.value
17779 && TREE_CODE (initializer
.value
) == CALL_EXPR
)
17782 tree c
= initializer
.value
;
17783 for (j
= 0; j
< call_expr_nargs (c
); j
++)
17785 tree a
= CALL_EXPR_ARG (c
, j
);
17787 if (TREE_CODE (a
) == ADDR_EXPR
17788 && TREE_OPERAND (a
, 0) == omp_priv
)
17791 if (j
== call_expr_nargs (c
))
17792 error ("one of the initializer call arguments should be "
17798 c_parser_consume_token (parser
);
17799 if (!c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
17803 tree st
= push_stmt_list ();
17804 location_t loc
= c_parser_peek_token (parser
)->location
;
17805 rich_location
richloc (line_table
, loc
);
17806 start_init (omp_priv
, NULL_TREE
, 0, &richloc
);
17807 struct c_expr init
= c_parser_initializer (parser
);
17809 finish_decl (omp_priv
, loc
, init
.value
,
17810 init
.original_type
, NULL_TREE
);
17811 pop_stmt_list (st
);
17815 && !c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
17821 c_parser_skip_to_pragma_eol (parser
);
17823 tree t
= tree_cons (type
, make_tree_vec (omp_priv
? 6 : 3),
17824 DECL_INITIAL (reduc_decl
));
17825 DECL_INITIAL (reduc_decl
) = t
;
17826 DECL_SOURCE_LOCATION (omp_out
) = rloc
;
17827 TREE_VEC_ELT (TREE_VALUE (t
), 0) = omp_out
;
17828 TREE_VEC_ELT (TREE_VALUE (t
), 1) = omp_in
;
17829 TREE_VEC_ELT (TREE_VALUE (t
), 2) = combiner
.value
;
17830 walk_tree (&combiner
.value
, c_check_omp_declare_reduction_r
,
17831 &TREE_VEC_ELT (TREE_VALUE (t
), 0), NULL
);
17834 DECL_SOURCE_LOCATION (omp_priv
) = rloc
;
17835 TREE_VEC_ELT (TREE_VALUE (t
), 3) = omp_priv
;
17836 TREE_VEC_ELT (TREE_VALUE (t
), 4) = omp_orig
;
17837 TREE_VEC_ELT (TREE_VALUE (t
), 5) = initializer
.value
;
17838 walk_tree (&initializer
.value
, c_check_omp_declare_reduction_r
,
17839 &TREE_VEC_ELT (TREE_VALUE (t
), 3), NULL
);
17840 walk_tree (&DECL_INITIAL (omp_priv
),
17841 c_check_omp_declare_reduction_r
,
17842 &TREE_VEC_ELT (TREE_VALUE (t
), 3), NULL
);
17846 pop_stmt_list (stmt
);
17848 if (cfun
->language
!= NULL
)
17850 ggc_free (cfun
->language
);
17851 cfun
->language
= NULL
;
17854 current_function_decl
= NULL_TREE
;
17856 c_pop_function_context ();
17858 if (!clauses
.is_empty ())
17860 parser
->tokens
= &parser
->tokens_buf
[0];
17861 parser
->tokens_avail
= tokens_avail
;
17865 if (errs
!= errorcount
)
17869 clauses
.release ();
17875 #pragma omp declare simd declare-simd-clauses[optseq] new-line
17876 #pragma omp declare reduction (reduction-id : typename-list : expression) \
17877 initializer-clause[opt] new-line
17878 #pragma omp declare target new-line */
17881 c_parser_omp_declare (c_parser
*parser
, enum pragma_context context
)
17883 c_parser_consume_pragma (parser
);
17884 if (c_parser_next_token_is (parser
, CPP_NAME
))
17886 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
17887 if (strcmp (p
, "simd") == 0)
17889 /* c_parser_consume_token (parser); done in
17890 c_parser_omp_declare_simd. */
17891 c_parser_omp_declare_simd (parser
, context
);
17894 if (strcmp (p
, "reduction") == 0)
17896 c_parser_consume_token (parser
);
17897 c_parser_omp_declare_reduction (parser
, context
);
17900 if (!flag_openmp
) /* flag_openmp_simd */
17902 c_parser_skip_to_pragma_eol (parser
, false);
17905 if (strcmp (p
, "target") == 0)
17907 c_parser_consume_token (parser
);
17908 c_parser_omp_declare_target (parser
);
17913 c_parser_error (parser
, "expected %<simd%> or %<reduction%> "
17915 c_parser_skip_to_pragma_eol (parser
);
17919 #pragma omp taskloop taskloop-clause[optseq] new-line
17922 #pragma omp taskloop simd taskloop-simd-clause[optseq] new-line
17925 #define OMP_TASKLOOP_CLAUSE_MASK \
17926 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
17927 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
17928 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
17929 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
17930 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
17931 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_GRAINSIZE) \
17932 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TASKS) \
17933 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
17934 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
17935 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
17936 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
17937 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
17938 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP) \
17939 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY))
17942 c_parser_omp_taskloop (location_t loc
, c_parser
*parser
,
17943 char *p_name
, omp_clause_mask mask
, tree
*cclauses
,
17946 tree clauses
, block
, ret
;
17948 strcat (p_name
, " taskloop");
17949 mask
|= OMP_TASKLOOP_CLAUSE_MASK
;
17951 if (c_parser_next_token_is (parser
, CPP_NAME
))
17953 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
17955 if (strcmp (p
, "simd") == 0)
17957 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
17958 if (cclauses
== NULL
)
17959 cclauses
= cclauses_buf
;
17960 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_REDUCTION
);
17961 c_parser_consume_token (parser
);
17962 if (!flag_openmp
) /* flag_openmp_simd */
17963 return c_parser_omp_simd (loc
, parser
, p_name
, mask
, cclauses
,
17965 block
= c_begin_compound_stmt (true);
17966 ret
= c_parser_omp_simd (loc
, parser
, p_name
, mask
, cclauses
, if_p
);
17967 block
= c_end_compound_stmt (loc
, block
, true);
17970 ret
= make_node (OMP_TASKLOOP
);
17971 TREE_TYPE (ret
) = void_type_node
;
17972 OMP_FOR_BODY (ret
) = block
;
17973 OMP_FOR_CLAUSES (ret
) = cclauses
[C_OMP_CLAUSE_SPLIT_TASKLOOP
];
17974 SET_EXPR_LOCATION (ret
, loc
);
17979 if (!flag_openmp
) /* flag_openmp_simd */
17981 c_parser_skip_to_pragma_eol (parser
, false);
17985 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
17988 omp_split_clauses (loc
, OMP_TASKLOOP
, mask
, clauses
, cclauses
);
17989 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_TASKLOOP
];
17992 block
= c_begin_compound_stmt (true);
17993 ret
= c_parser_omp_for_loop (loc
, parser
, OMP_TASKLOOP
, clauses
, NULL
, if_p
);
17994 block
= c_end_compound_stmt (loc
, block
, true);
18000 /* Main entry point to parsing most OpenMP pragmas. */
18003 c_parser_omp_construct (c_parser
*parser
, bool *if_p
)
18005 enum pragma_kind p_kind
;
18008 char p_name
[sizeof "#pragma omp teams distribute parallel for simd"];
18009 omp_clause_mask
mask (0);
18011 loc
= c_parser_peek_token (parser
)->location
;
18012 p_kind
= c_parser_peek_token (parser
)->pragma_kind
;
18013 c_parser_consume_pragma (parser
);
18017 case PRAGMA_OACC_ATOMIC
:
18018 c_parser_omp_atomic (loc
, parser
);
18020 case PRAGMA_OACC_CACHE
:
18021 strcpy (p_name
, "#pragma acc");
18022 stmt
= c_parser_oacc_cache (loc
, parser
);
18024 case PRAGMA_OACC_DATA
:
18025 stmt
= c_parser_oacc_data (loc
, parser
, if_p
);
18027 case PRAGMA_OACC_HOST_DATA
:
18028 stmt
= c_parser_oacc_host_data (loc
, parser
, if_p
);
18030 case PRAGMA_OACC_KERNELS
:
18031 case PRAGMA_OACC_PARALLEL
:
18032 strcpy (p_name
, "#pragma acc");
18033 stmt
= c_parser_oacc_kernels_parallel (loc
, parser
, p_kind
, p_name
,
18036 case PRAGMA_OACC_LOOP
:
18037 strcpy (p_name
, "#pragma acc");
18038 stmt
= c_parser_oacc_loop (loc
, parser
, p_name
, mask
, NULL
, if_p
);
18040 case PRAGMA_OACC_WAIT
:
18041 strcpy (p_name
, "#pragma wait");
18042 stmt
= c_parser_oacc_wait (loc
, parser
, p_name
);
18044 case PRAGMA_OMP_ATOMIC
:
18045 c_parser_omp_atomic (loc
, parser
);
18047 case PRAGMA_OMP_CRITICAL
:
18048 stmt
= c_parser_omp_critical (loc
, parser
, if_p
);
18050 case PRAGMA_OMP_DISTRIBUTE
:
18051 strcpy (p_name
, "#pragma omp");
18052 stmt
= c_parser_omp_distribute (loc
, parser
, p_name
, mask
, NULL
, if_p
);
18054 case PRAGMA_OMP_FOR
:
18055 strcpy (p_name
, "#pragma omp");
18056 stmt
= c_parser_omp_for (loc
, parser
, p_name
, mask
, NULL
, if_p
);
18058 case PRAGMA_OMP_MASTER
:
18059 stmt
= c_parser_omp_master (loc
, parser
, if_p
);
18061 case PRAGMA_OMP_PARALLEL
:
18062 strcpy (p_name
, "#pragma omp");
18063 stmt
= c_parser_omp_parallel (loc
, parser
, p_name
, mask
, NULL
, if_p
);
18065 case PRAGMA_OMP_SECTIONS
:
18066 strcpy (p_name
, "#pragma omp");
18067 stmt
= c_parser_omp_sections (loc
, parser
, p_name
, mask
, NULL
);
18069 case PRAGMA_OMP_SIMD
:
18070 strcpy (p_name
, "#pragma omp");
18071 stmt
= c_parser_omp_simd (loc
, parser
, p_name
, mask
, NULL
, if_p
);
18073 case PRAGMA_OMP_SINGLE
:
18074 stmt
= c_parser_omp_single (loc
, parser
, if_p
);
18076 case PRAGMA_OMP_TASK
:
18077 stmt
= c_parser_omp_task (loc
, parser
, if_p
);
18079 case PRAGMA_OMP_TASKGROUP
:
18080 stmt
= c_parser_omp_taskgroup (parser
, if_p
);
18082 case PRAGMA_OMP_TASKLOOP
:
18083 strcpy (p_name
, "#pragma omp");
18084 stmt
= c_parser_omp_taskloop (loc
, parser
, p_name
, mask
, NULL
, if_p
);
18086 case PRAGMA_OMP_TEAMS
:
18087 strcpy (p_name
, "#pragma omp");
18088 stmt
= c_parser_omp_teams (loc
, parser
, p_name
, mask
, NULL
, if_p
);
18091 gcc_unreachable ();
18095 gcc_assert (EXPR_LOCATION (stmt
) != UNKNOWN_LOCATION
);
18100 # pragma omp threadprivate (variable-list) */
18103 c_parser_omp_threadprivate (c_parser
*parser
)
18108 c_parser_consume_pragma (parser
);
18109 loc
= c_parser_peek_token (parser
)->location
;
18110 vars
= c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_ERROR
, NULL
);
18112 /* Mark every variable in VARS to be assigned thread local storage. */
18113 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
18115 tree v
= TREE_PURPOSE (t
);
18117 /* FIXME diagnostics: Ideally we should keep individual
18118 locations for all the variables in the var list to make the
18119 following errors more precise. Perhaps
18120 c_parser_omp_var_list_parens() should construct a list of
18121 locations to go along with the var list. */
18123 /* If V had already been marked threadprivate, it doesn't matter
18124 whether it had been used prior to this point. */
18126 error_at (loc
, "%qD is not a variable", v
);
18127 else if (TREE_USED (v
) && !C_DECL_THREADPRIVATE_P (v
))
18128 error_at (loc
, "%qE declared %<threadprivate%> after first use", v
);
18129 else if (! is_global_var (v
))
18130 error_at (loc
, "automatic variable %qE cannot be %<threadprivate%>", v
);
18131 else if (TREE_TYPE (v
) == error_mark_node
)
18133 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
18134 error_at (loc
, "%<threadprivate%> %qE has incomplete type", v
);
18137 if (! DECL_THREAD_LOCAL_P (v
))
18139 set_decl_tls_model (v
, decl_default_tls_model (v
));
18140 /* If rtl has been already set for this var, call
18141 make_decl_rtl once again, so that encode_section_info
18142 has a chance to look at the new decl flags. */
18143 if (DECL_RTL_SET_P (v
))
18146 C_DECL_THREADPRIVATE_P (v
) = 1;
18150 c_parser_skip_to_pragma_eol (parser
);
18153 /* Parse a transaction attribute (GCC Extension).
18155 transaction-attribute:
18159 The transactional memory language description is written for C++,
18160 and uses the C++0x attribute syntax. For compatibility, allow the
18161 bracket style for transactions in C as well. */
18164 c_parser_transaction_attributes (c_parser
*parser
)
18166 tree attr_name
, attr
= NULL
;
18168 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
18169 return c_parser_attributes (parser
);
18171 if (!c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
18173 c_parser_consume_token (parser
);
18174 if (!c_parser_require (parser
, CPP_OPEN_SQUARE
, "expected %<[%>"))
18177 attr_name
= c_parser_attribute_any_word (parser
);
18180 c_parser_consume_token (parser
);
18181 attr
= build_tree_list (attr_name
, NULL_TREE
);
18184 c_parser_error (parser
, "expected identifier");
18186 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, "expected %<]%>");
18188 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, "expected %<]%>");
18192 /* Parse a __transaction_atomic or __transaction_relaxed statement
18195 transaction-statement:
18196 __transaction_atomic transaction-attribute[opt] compound-statement
18197 __transaction_relaxed compound-statement
18199 Note that the only valid attribute is: "outer".
18203 c_parser_transaction (c_parser
*parser
, enum rid keyword
)
18205 unsigned int old_in
= parser
->in_transaction
;
18206 unsigned int this_in
= 1, new_in
;
18207 location_t loc
= c_parser_peek_token (parser
)->location
;
18210 gcc_assert ((keyword
== RID_TRANSACTION_ATOMIC
18211 || keyword
== RID_TRANSACTION_RELAXED
)
18212 && c_parser_next_token_is_keyword (parser
, keyword
));
18213 c_parser_consume_token (parser
);
18215 if (keyword
== RID_TRANSACTION_RELAXED
)
18216 this_in
|= TM_STMT_ATTR_RELAXED
;
18219 attrs
= c_parser_transaction_attributes (parser
);
18221 this_in
|= parse_tm_stmt_attr (attrs
, TM_STMT_ATTR_OUTER
);
18224 /* Keep track if we're in the lexical scope of an outer transaction. */
18225 new_in
= this_in
| (old_in
& TM_STMT_ATTR_OUTER
);
18227 parser
->in_transaction
= new_in
;
18228 stmt
= c_parser_compound_statement (parser
);
18229 parser
->in_transaction
= old_in
;
18232 stmt
= c_finish_transaction (loc
, stmt
, this_in
);
18234 error_at (loc
, (keyword
== RID_TRANSACTION_ATOMIC
?
18235 "%<__transaction_atomic%> without transactional memory support enabled"
18236 : "%<__transaction_relaxed %> "
18237 "without transactional memory support enabled"));
18242 /* Parse a __transaction_atomic or __transaction_relaxed expression
18245 transaction-expression:
18246 __transaction_atomic ( expression )
18247 __transaction_relaxed ( expression )
18250 static struct c_expr
18251 c_parser_transaction_expression (c_parser
*parser
, enum rid keyword
)
18254 unsigned int old_in
= parser
->in_transaction
;
18255 unsigned int this_in
= 1;
18256 location_t loc
= c_parser_peek_token (parser
)->location
;
18259 gcc_assert ((keyword
== RID_TRANSACTION_ATOMIC
18260 || keyword
== RID_TRANSACTION_RELAXED
)
18261 && c_parser_next_token_is_keyword (parser
, keyword
));
18262 c_parser_consume_token (parser
);
18264 if (keyword
== RID_TRANSACTION_RELAXED
)
18265 this_in
|= TM_STMT_ATTR_RELAXED
;
18268 attrs
= c_parser_transaction_attributes (parser
);
18270 this_in
|= parse_tm_stmt_attr (attrs
, 0);
18273 parser
->in_transaction
= this_in
;
18274 matching_parens parens
;
18275 if (parens
.require_open (parser
))
18277 tree expr
= c_parser_expression (parser
).value
;
18278 ret
.original_type
= TREE_TYPE (expr
);
18279 ret
.value
= build1 (TRANSACTION_EXPR
, ret
.original_type
, expr
);
18280 if (this_in
& TM_STMT_ATTR_RELAXED
)
18281 TRANSACTION_EXPR_RELAXED (ret
.value
) = 1;
18282 SET_EXPR_LOCATION (ret
.value
, loc
);
18283 ret
.original_code
= TRANSACTION_EXPR
;
18284 if (!parens
.require_close (parser
))
18286 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
18294 ret
.original_code
= ERROR_MARK
;
18295 ret
.original_type
= NULL
;
18297 parser
->in_transaction
= old_in
;
18300 error_at (loc
, (keyword
== RID_TRANSACTION_ATOMIC
?
18301 "%<__transaction_atomic%> without transactional memory support enabled"
18302 : "%<__transaction_relaxed %> "
18303 "without transactional memory support enabled"));
18305 set_c_expr_source_range (&ret
, loc
, loc
);
18310 /* Parse a __transaction_cancel statement (GCC Extension).
18312 transaction-cancel-statement:
18313 __transaction_cancel transaction-attribute[opt] ;
18315 Note that the only valid attribute is "outer".
18319 c_parser_transaction_cancel (c_parser
*parser
)
18321 location_t loc
= c_parser_peek_token (parser
)->location
;
18323 bool is_outer
= false;
18325 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_TRANSACTION_CANCEL
));
18326 c_parser_consume_token (parser
);
18328 attrs
= c_parser_transaction_attributes (parser
);
18330 is_outer
= (parse_tm_stmt_attr (attrs
, TM_STMT_ATTR_OUTER
) != 0);
18334 error_at (loc
, "%<__transaction_cancel%> without "
18335 "transactional memory support enabled");
18338 else if (parser
->in_transaction
& TM_STMT_ATTR_RELAXED
)
18340 error_at (loc
, "%<__transaction_cancel%> within a "
18341 "%<__transaction_relaxed%>");
18346 if ((parser
->in_transaction
& TM_STMT_ATTR_OUTER
) == 0
18347 && !is_tm_may_cancel_outer (current_function_decl
))
18349 error_at (loc
, "outer %<__transaction_cancel%> not "
18350 "within outer %<__transaction_atomic%>");
18351 error_at (loc
, " or a %<transaction_may_cancel_outer%> function");
18355 else if (parser
->in_transaction
== 0)
18357 error_at (loc
, "%<__transaction_cancel%> not within "
18358 "%<__transaction_atomic%>");
18362 return add_stmt (build_tm_abort_call (loc
, is_outer
));
18365 return build1 (NOP_EXPR
, void_type_node
, error_mark_node
);
18368 /* Parse a single source file. */
18371 c_parse_file (void)
18373 /* Use local storage to begin. If the first token is a pragma, parse it.
18374 If it is #pragma GCC pch_preprocess, then this will load a PCH file
18375 which will cause garbage collection. */
18378 memset (&tparser
, 0, sizeof tparser
);
18379 tparser
.tokens
= &tparser
.tokens_buf
[0];
18380 the_parser
= &tparser
;
18382 if (c_parser_peek_token (&tparser
)->pragma_kind
== PRAGMA_GCC_PCH_PREPROCESS
)
18383 c_parser_pragma_pch_preprocess (&tparser
);
18385 the_parser
= ggc_alloc
<c_parser
> ();
18386 *the_parser
= tparser
;
18387 if (tparser
.tokens
== &tparser
.tokens_buf
[0])
18388 the_parser
->tokens
= &the_parser
->tokens_buf
[0];
18390 /* Initialize EH, if we've been told to do so. */
18391 if (flag_exceptions
)
18392 using_eh_for_cleanups ();
18394 c_parser_translation_unit (the_parser
);
18398 /* Parse the body of a function declaration marked with "__RTL".
18400 The RTL parser works on the level of characters read from a
18401 FILE *, whereas c_parser works at the level of tokens.
18402 Square this circle by consuming all of the tokens up to and
18403 including the closing brace, recording the start/end of the RTL
18404 fragment, and reopening the file and re-reading the relevant
18405 lines within the RTL parser.
18407 This requires the opening and closing braces of the C function
18408 to be on separate lines from the RTL they wrap.
18410 Take ownership of START_WITH_PASS, if non-NULL. */
18413 c_parser_parse_rtl_body (c_parser
*parser
, char *start_with_pass
)
18415 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
18417 free (start_with_pass
);
18421 location_t start_loc
= c_parser_peek_token (parser
)->location
;
18423 /* Consume all tokens, up to the closing brace, handling
18424 matching pairs of braces in the rtl dump. */
18425 int num_open_braces
= 1;
18428 switch (c_parser_peek_token (parser
)->type
)
18430 case CPP_OPEN_BRACE
:
18433 case CPP_CLOSE_BRACE
:
18434 if (--num_open_braces
== 0)
18435 goto found_closing_brace
;
18438 error_at (start_loc
, "no closing brace");
18439 free (start_with_pass
);
18444 c_parser_consume_token (parser
);
18447 found_closing_brace
:
18448 /* At the closing brace; record its location. */
18449 location_t end_loc
= c_parser_peek_token (parser
)->location
;
18451 /* Consume the closing brace. */
18452 c_parser_consume_token (parser
);
18454 /* Invoke the RTL parser. */
18455 if (!read_rtl_function_body_from_file_range (start_loc
, end_loc
))
18457 free (start_with_pass
);
18461 /* If a pass name was provided for START_WITH_PASS, run the backend
18462 accordingly now, on the cfun created above, transferring
18463 ownership of START_WITH_PASS. */
18464 if (start_with_pass
)
18465 run_rtl_passes (start_with_pass
);
18468 #include "gt-c-c-parser.h"