2 Copyright (C) 2016-2020 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
27 #include "stringpool.h"
30 #include "stor-layout.h"
32 #include "trans-mem.h"
33 #include "c-family/c-pragma.h"
35 #include "c-family/c-objc.h"
38 #include "gomp-constants.h"
39 #include "c-family/c-indentation.h"
40 #include "gimple-expr.h"
42 #include "gcc-rich-location.h"
45 #include "tree-pass.h"
46 #include "tree-pretty-print.h"
48 #include "basic-block.h"
50 #include "gimple-pretty-print.h"
52 #include "pass_manager.h"
53 #include "tree-ssanames.h"
54 #include "gimple-ssa.h"
56 #include "internal-fn.h"
61 #include "gimple-iterator.h"
63 #include "tree-phinodes.h"
64 #include "tree-into-ssa.h"
68 /* GIMPLE parser state. */
73 gimple_parser (c_parser
*p
) : parser (p
), edges(), current_bb(NULL
) {}
74 /* c_parser is not visible here, use composition and fake inheritance
75 via a conversion operator. */
76 operator c_parser
*() { return parser
; }
79 /* CFG build state. */
80 class gimple_parser_edge
86 profile_probability probability
;
88 auto_vec
<gimple_parser_edge
> edges
;
89 basic_block current_bb
;
91 void push_edge (int, int, int, profile_probability
);
95 gimple_parser::push_edge (int src
, int dest
, int flags
,
96 profile_probability prob
)
102 e
.probability
= prob
;
107 /* Gimple parsing functions. */
108 static bool c_parser_gimple_compound_statement (gimple_parser
&, gimple_seq
*);
109 static void c_parser_gimple_label (gimple_parser
&, gimple_seq
*);
110 static void c_parser_gimple_statement (gimple_parser
&, gimple_seq
*);
111 static struct c_expr
c_parser_gimple_binary_expression (gimple_parser
&);
112 static struct c_expr
c_parser_gimple_unary_expression (gimple_parser
&);
113 static struct c_expr
c_parser_gimple_postfix_expression (gimple_parser
&);
114 static struct c_expr c_parser_gimple_postfix_expression_after_primary
115 (gimple_parser
&, location_t
, struct c_expr
);
116 static void c_parser_gimple_declaration (gimple_parser
&);
117 static void c_parser_gimple_goto_stmt (gimple_parser
&, location_t
,
119 static void c_parser_gimple_try_stmt (gimple_parser
&, gimple_seq
*);
120 static void c_parser_gimple_if_stmt (gimple_parser
&, gimple_seq
*);
121 static void c_parser_gimple_switch_stmt (gimple_parser
&, gimple_seq
*);
122 static void c_parser_gimple_return_stmt (gimple_parser
&, gimple_seq
*);
123 static void c_finish_gimple_return (location_t
, tree
);
124 static tree
c_parser_gimple_paren_condition (gimple_parser
&);
125 static void c_parser_gimple_expr_list (gimple_parser
&, vec
<tree
> *);
128 /* See if VAL is an identifier matching __BB<num> and return <num>
132 c_parser_gimple_parse_bb_spec (tree val
, int *index
)
134 if (strncmp (IDENTIFIER_POINTER (val
), "__BB", 4) != 0)
136 for (const char *p
= IDENTIFIER_POINTER (val
) + 4; *p
; ++p
)
139 *index
= atoi (IDENTIFIER_POINTER (val
) + 4);
143 /* See if VAL is an identifier matching __BB<num> and return <num>
144 in *INDEX. Return true if so and parse also FREQUENCY of
149 c_parser_gimple_parse_bb_spec_edge_probability (tree val
,
150 gimple_parser
&parser
,
155 bool return_p
= c_parser_gimple_parse_bb_spec (val
, index
);
158 *probability
= profile_probability::uninitialized ();
159 /* Parse frequency if provided. */
160 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
163 c_parser_consume_token (parser
);
164 if (!c_parser_next_token_is (parser
, CPP_NAME
))
166 c_parser_error (parser
, "expected frequency quality");
170 profile_quality quality
;
172 = IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
173 if (!parse_profile_quality (v
, &quality
))
175 c_parser_error (parser
, "unknown profile quality");
179 c_parser_consume_token (parser
);
180 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
183 if (!c_parser_next_token_is (parser
, CPP_NUMBER
)
184 || (TREE_CODE (f
= c_parser_peek_token (parser
)->value
)
187 c_parser_error (parser
, "expected frequency value");
191 unsigned int value
= TREE_INT_CST_LOW (f
);
192 *probability
= profile_probability (value
, quality
);
194 c_parser_consume_token (parser
);
195 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
198 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
209 /* Parse the body of a function declaration marked with "__GIMPLE". */
212 c_parser_parse_gimple_body (c_parser
*cparser
, char *gimple_pass
,
213 enum c_declspec_il cdil
,
214 profile_count entry_bb_count
)
216 gimple_parser
parser (cparser
);
217 gimple_seq seq
= NULL
;
218 gimple_seq body
= NULL
;
219 tree stmt
= push_stmt_list ();
221 location_t loc1
= c_parser_peek_token (parser
)->location
;
223 cfun
->pass_startwith
= gimple_pass
;
224 init_tree_ssa (cfun
);
226 if (cdil
== cdil_gimple
)
227 /* While we have SSA names in the IL we do not have a CFG built yet
228 and PHIs are represented using a PHI internal function. We do
229 have lowered control flow and exception handling (well, we do not
230 have parser support for EH yet). But as we still have BINDs
231 we have to go through lowering again. */
232 cfun
->curr_properties
= PROP_gimple_any
;
235 /* We have at least cdil_gimple_cfg. */
236 gimple_register_cfg_hooks ();
237 init_empty_tree_cfg ();
238 parser
.current_bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
239 /* Initialize the bare loop structure - we are going to only
240 mark headers and leave the rest to fixup. */
241 set_loops_for_fn (cfun
, ggc_cleared_alloc
<struct loops
> ());
242 init_loops_structure (cfun
, loops_for_fn (cfun
), 1);
243 loops_state_set (cfun
, LOOPS_NEED_FIXUP
|LOOPS_MAY_HAVE_MULTIPLE_LATCHES
);
244 cfun
->curr_properties
245 |= PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_loops
;
246 if (cdil
== cdil_gimple_ssa
)
248 init_ssa_operands (cfun
);
249 cfun
->curr_properties
|= PROP_ssa
;
253 if (! c_parser_gimple_compound_statement (parser
, &seq
)
254 && cdil
== cdil_gimple
)
256 gimple
*ret
= gimple_build_return (NULL
);
257 gimple_seq_add_stmt_without_update (&seq
, ret
);
260 tree block
= pop_scope ();
261 stmt
= pop_stmt_list (stmt
);
262 stmt
= c_build_bind_expr (loc1
, block
, stmt
);
264 block
= DECL_INITIAL (current_function_decl
);
265 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
266 BLOCK_CHAIN (block
) = NULL_TREE
;
267 TREE_ASM_WRITTEN (block
) = 1;
269 if (cdil
== cdil_gimple
)
271 gbind
*bind_stmt
= gimple_build_bind (BIND_EXPR_VARS (stmt
), NULL
,
272 BIND_EXPR_BLOCK (stmt
));
273 gimple_bind_set_body (bind_stmt
, seq
);
274 gimple_seq_add_stmt_without_update (&body
, bind_stmt
);
275 gimple_set_body (current_function_decl
, body
);
279 /* Control-flow and binds are lowered, record local decls. */
280 for (tree var
= BIND_EXPR_VARS (stmt
); var
; var
= DECL_CHAIN (var
))
282 && !DECL_EXTERNAL (var
))
283 add_local_decl (cfun
, var
);
284 /* We have a CFG. Build the edges. */
285 for (unsigned i
= 0; i
< parser
.edges
.length (); ++i
)
287 edge e
= make_edge (BASIC_BLOCK_FOR_FN (cfun
, parser
.edges
[i
].src
),
288 BASIC_BLOCK_FOR_FN (cfun
, parser
.edges
[i
].dest
),
289 parser
.edges
[i
].flags
);
290 e
->probability
= parser
.edges
[i
].probability
;
292 /* Add edges for case labels. */
294 FOR_EACH_BB_FN (bb
, cfun
)
295 if (EDGE_COUNT (bb
->succs
) == 0)
297 gimple
*last
= last_stmt (bb
);
298 if (gswitch
*sw
= safe_dyn_cast
<gswitch
*> (last
))
299 for (unsigned i
= 0; i
< gimple_switch_num_labels (sw
); ++i
)
301 basic_block label_bb
= gimple_switch_label_bb (cfun
, sw
, i
);
302 make_edge (bb
, label_bb
, 0);
305 /* Need those for loop fixup. */
306 calculate_dominance_info (CDI_DOMINATORS
);
307 /* With SSA lower PHIs parsed as internal function calls and
309 if (cdil
== cdil_gimple_ssa
)
311 /* Create PHI nodes, they are parsed into __PHI internal calls. */
312 FOR_EACH_BB_FN (bb
, cfun
)
313 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
316 gimple
*stmt
= gsi_stmt (gsi
);
317 if (!gimple_call_internal_p (stmt
, IFN_PHI
))
320 gphi
*phi
= create_phi_node (gimple_call_lhs (stmt
), bb
);
321 for (unsigned i
= 0; i
< gimple_call_num_args (stmt
); i
+= 2)
323 int srcidx
= TREE_INT_CST_LOW (gimple_call_arg (stmt
, i
));
324 edge e
= find_edge (BASIC_BLOCK_FOR_FN (cfun
, srcidx
), bb
);
326 c_parser_error (parser
, "edge not found");
328 add_phi_arg (phi
, gimple_call_arg (stmt
, i
+ 1), e
,
331 gsi_remove (&gsi
, true);
333 /* Fill SSA name gaps, putting them on the freelist. */
334 for (unsigned i
= 1; i
< num_ssa_names
; ++i
)
337 tree name
= make_ssa_name_fn (cfun
, integer_type_node
, NULL
, i
);
338 release_ssa_name_fn (cfun
, name
);
340 /* No explicit virtual operands (yet). */
341 bitmap_obstack_initialize (NULL
);
342 update_ssa (TODO_update_ssa_only_virtuals
);
343 bitmap_obstack_release (NULL
);
344 /* ??? By flushing the freelist after virtual operand SSA rewrite
345 we keep the gaps available for re-use like needed for the
346 PR89595 testcase but then usually virtual operands would have
347 taken most of them. The fix is obviously to make virtual
348 operands explicit in the SSA IL. */
349 flush_ssaname_freelist ();
351 fix_loop_structure (NULL
);
354 if (cfun
->curr_properties
& PROP_cfg
)
356 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= entry_bb_count
;
357 gcov_type t
= param_gimple_fe_computed_hot_bb_threshold
;
358 set_hot_bb_threshold (t
);
359 update_max_bb_count ();
360 cgraph_node::get_create (cfun
->decl
);
361 cgraph_edge::rebuild_edges ();
363 dump_function (TDI_gimple
, current_function_decl
);
366 /* Parse a compound statement in gimple function body.
370 gimple-declaration-statement
372 gimple-switch-statement
373 gimple-labeled-statement
374 gimple-expression-statement
375 gimple-goto-statement
377 gimple-return-statement
381 c_parser_gimple_compound_statement (gimple_parser
&parser
, gimple_seq
*seq
)
383 bool return_p
= false;
385 if (! c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
388 /* A compund statement starts with optional declarations. */
389 while (c_parser_next_tokens_start_declaration (parser
))
391 c_parser_gimple_declaration (parser
);
392 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
396 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
398 if (c_parser_error (parser
))
400 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
403 else if (c_parser_next_token_is (parser
, CPP_EOF
))
405 c_parser_error (parser
, "expected declaration or statement");
409 switch (c_parser_peek_token (parser
)->type
)
412 switch (c_parser_peek_token (parser
)->keyword
)
415 c_parser_gimple_try_stmt (parser
, seq
);
418 c_parser_gimple_if_stmt (parser
, seq
);
421 c_parser_gimple_switch_stmt (parser
, seq
);
425 location_t loc
= c_parser_peek_token (parser
)->location
;
426 c_parser_consume_token (parser
);
427 if (c_parser_next_token_is (parser
, CPP_NAME
))
429 tree label
= c_parser_peek_token (parser
)->value
;
430 c_parser_consume_token (parser
);
431 c_parser_gimple_goto_stmt (parser
, loc
, label
, seq
);
432 if (! c_parser_require (parser
, CPP_SEMICOLON
,
440 c_parser_gimple_return_stmt (parser
, seq
);
441 if (! c_parser_require (parser
, CPP_SEMICOLON
,
444 if (cfun
->curr_properties
& PROP_cfg
)
445 parser
.push_edge (parser
.current_bb
->index
, EXIT_BLOCK
, 0,
446 profile_probability::uninitialized ());
453 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
455 c_parser_gimple_label (parser
, seq
);
458 if (c_parser_next_token_is (parser
, CPP_NAME
)
459 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
460 && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
),
463 c_parser_gimple_try_stmt (parser
, seq
);
466 /* Basic block specification.
468 if ((cfun
->curr_properties
& PROP_cfg
)
469 && !strcmp (IDENTIFIER_POINTER
470 (c_parser_peek_token (parser
)->value
), "__BB"))
472 c_parser_consume_token (parser
);
473 if (! c_parser_require (parser
, CPP_OPEN_PAREN
,
476 if (c_parser_next_token_is_not (parser
, CPP_NUMBER
))
478 c_parser_error (parser
, "expected block index");
481 tree tnum
= c_parser_peek_token (parser
)->value
;
482 if (TREE_CODE (tnum
) != INTEGER_CST
)
484 c_parser_error (parser
, "expected block index");
487 int index
= TREE_INT_CST_LOW (tnum
);
488 if (index
< NUM_FIXED_BLOCKS
489 || (index
< last_basic_block_for_fn (cfun
)
490 && BASIC_BLOCK_FOR_FN (cfun
, index
) != NULL
))
492 c_parser_error (parser
, "invalid block index");
495 int is_loop_header_of
= -1;
496 profile_count bb_count
= profile_count::uninitialized ();
497 c_parser_consume_token (parser
);
498 while (c_parser_next_token_is (parser
, CPP_COMMA
))
500 c_parser_consume_token (parser
);
501 if (! c_parser_next_token_is (parser
, CPP_NAME
))
503 c_parser_error (parser
, "expected block specifier");
506 /* loop_header (NUM) */
507 if (!strcmp (IDENTIFIER_POINTER
508 (c_parser_peek_token (parser
)->value
),
511 c_parser_consume_token (parser
);
512 if (! c_parser_require (parser
, CPP_OPEN_PAREN
,
516 if (! c_parser_next_token_is (parser
, CPP_NUMBER
)
517 || TREE_CODE (loop_num
518 = c_parser_peek_token (parser
)->value
)
521 c_parser_error (parser
, "expected loop number");
524 c_parser_consume_token (parser
);
525 is_loop_header_of
= TREE_INT_CST_LOW (loop_num
);
526 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
,
530 /* Parse profile: quality(value) */
534 profile_quality quality
;
535 tree v
= c_parser_peek_token (parser
)->value
;
536 if (!parse_profile_quality (IDENTIFIER_POINTER (v
),
539 c_parser_error (parser
, "unknown block specifier");
543 c_parser_consume_token (parser
);
544 if (!c_parser_require (parser
, CPP_OPEN_PAREN
,
548 if (!c_parser_next_token_is (parser
, CPP_NUMBER
)
549 || (TREE_CODE (q
= c_parser_peek_token (parser
)->value
)
552 c_parser_error (parser
, "expected count value");
557 = profile_count::from_gcov_type (TREE_INT_CST_LOW (q
),
559 c_parser_consume_token (parser
);
560 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
,
565 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
,
567 || ! c_parser_require (parser
, CPP_COLON
,
571 /* Put stmts parsed in the current block. */
572 if (!gimple_seq_empty_p (*seq
))
574 if (!parser
.current_bb
)
575 c_parser_error (parser
, "stmts without block");
578 gimple_stmt_iterator gsi
579 = gsi_start_bb (parser
.current_bb
);
580 gsi_insert_seq_after (&gsi
, *seq
, GSI_CONTINUE_LINKING
);
585 /* Build an empty block with specified index, linking them
587 basic_block bb
= alloc_block ();
589 link_block (bb
, (parser
.current_bb
? parser
.current_bb
590 : ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
591 if (basic_block_info_for_fn (cfun
)->length () <= (size_t)index
)
592 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
),
594 SET_BASIC_BLOCK_FOR_FN (cfun
, index
, bb
);
595 if (last_basic_block_for_fn (cfun
) <= index
)
596 last_basic_block_for_fn (cfun
) = index
+ 1;
597 n_basic_blocks_for_fn (cfun
)++;
598 if (parser
.current_bb
->index
== ENTRY_BLOCK
)
599 parser
.push_edge (ENTRY_BLOCK
, bb
->index
, EDGE_FALLTHRU
,
600 profile_probability::always ());
602 /* We leave the proper setting to fixup. */
603 class loop
*loop_father
= loops_for_fn (cfun
)->tree_root
;
604 /* If the new block is a loop header, allocate a loop
605 struct. Fixup will take care of proper placement within
607 if (is_loop_header_of
!= -1)
609 if (number_of_loops (cfun
) > (unsigned)is_loop_header_of
610 && get_loop (cfun
, is_loop_header_of
) != NULL
)
612 c_parser_error (parser
, "duplicate loop header");
616 class loop
*loop
= alloc_loop ();
617 loop
->num
= is_loop_header_of
;
619 vec_safe_grow_cleared (loops_for_fn (cfun
)->larray
,
620 is_loop_header_of
+ 1, true);
621 (*loops_for_fn (cfun
)->larray
)[is_loop_header_of
] = loop
;
622 flow_loop_tree_node_add (loops_for_fn (cfun
)->tree_root
,
625 loop_father
= get_loop (cfun
, is_loop_header_of
);
627 bb
->loop_father
= loop_father
;
628 bb
->count
= bb_count
;
630 /* Stmts now go to the new block. */
631 parser
.current_bb
= bb
;
639 location_t loc
= c_parser_peek_token (parser
)->location
;
640 c_parser_consume_token (parser
);
641 gimple
*nop
= gimple_build_nop ();
642 gimple_set_location (nop
, loc
);
643 gimple_seq_add_stmt_without_update (seq
, nop
);
649 c_parser_gimple_statement (parser
, seq
);
650 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
651 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
654 c_parser_consume_token (parser
);
656 /* Put stmts parsed in the current block. */
657 if ((cfun
->curr_properties
& PROP_cfg
)
658 && !gimple_seq_empty_p (*seq
))
660 if (!parser
.current_bb
)
661 c_parser_error (parser
, "stmts without block");
664 gimple_stmt_iterator gsi
= gsi_start_bb (parser
.current_bb
);
665 gsi_insert_seq_after (&gsi
, *seq
, GSI_CONTINUE_LINKING
);
673 /* Parse a gimple statement.
676 gimple-call-expression
677 gimple-assign-statement
680 gimple-assign-statement:
681 gimple-unary-expression = gimple-assign-rhs
684 gimple-cast-expression
685 gimple-unary-expression
686 gimple-binary-expression
687 gimple-call-expression
689 gimple-phi-statement:
690 identifier = __PHI ( label : gimple_primary-expression, ... )
693 gimple-primary-expression ( argument-list )
695 gimple-cast-expression:
696 ( type-name ) gimple-primary-expression
701 c_parser_gimple_statement (gimple_parser
&parser
, gimple_seq
*seq
)
703 struct c_expr lhs
, rhs
;
704 gimple
*assign
= NULL
;
706 tree arg
= NULL_TREE
;
707 auto_vec
<tree
> vargs
;
709 lhs
= c_parser_gimple_unary_expression (parser
);
710 loc
= EXPR_LOCATION (lhs
.value
);
713 /* GIMPLE call statement without LHS. */
714 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
715 && TREE_CODE (lhs
.value
) == CALL_EXPR
)
718 call
= gimple_build_call_from_tree (lhs
.value
, NULL
);
719 gimple_seq_add_stmt_without_update (seq
, call
);
720 gimple_set_location (call
, loc
);
724 /* All following cases are statements with LHS. */
725 if (! c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
728 /* Cast expression. */
729 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
730 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
732 c_parser_consume_token (parser
);
733 struct c_type_name
*type_name
= c_parser_type_name (parser
);
734 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
735 if (type_name
== NULL
)
737 /* ??? The actual type used in the cast expression is ignored as
738 in GIMPLE it is encoded by the type of the LHS. */
739 rhs
= c_parser_gimple_postfix_expression (parser
);
740 if (lhs
.value
!= error_mark_node
741 && rhs
.value
!= error_mark_node
)
743 enum tree_code code
= NOP_EXPR
;
744 if (FLOAT_TYPE_P (TREE_TYPE (lhs
.value
))
745 && ! FLOAT_TYPE_P (TREE_TYPE (rhs
.value
)))
747 else if (! FLOAT_TYPE_P (TREE_TYPE (lhs
.value
))
748 && FLOAT_TYPE_P (TREE_TYPE (rhs
.value
)))
749 code
= FIX_TRUNC_EXPR
;
750 assign
= gimple_build_assign (lhs
.value
, code
, rhs
.value
);
751 gimple_seq_add_stmt_without_update (seq
, assign
);
752 gimple_set_location (assign
, loc
);
757 /* Unary expression. */
758 switch (c_parser_peek_token (parser
)->type
)
762 tree id
= c_parser_peek_token (parser
)->value
;
763 if (strcmp (IDENTIFIER_POINTER (id
), "__ABS") == 0
764 || strcmp (IDENTIFIER_POINTER (id
), "__ABSU") == 0
765 || strcmp (IDENTIFIER_POINTER (id
), "__MIN") == 0
766 || strcmp (IDENTIFIER_POINTER (id
), "__MAX") == 0
767 || strcmp (IDENTIFIER_POINTER (id
), "__BIT_INSERT") == 0
768 || strcmp (IDENTIFIER_POINTER (id
), "__VEC_PERM") == 0)
769 goto build_unary_expr
;
773 if (c_parser_peek_token (parser
)->keyword
!= RID_REALPART
774 && c_parser_peek_token (parser
)->keyword
!= RID_IMAGPART
)
782 case CPP_MULT
: /* pointer deref */
784 rhs
= c_parser_gimple_unary_expression (parser
);
785 if (rhs
.value
!= error_mark_node
)
787 assign
= gimple_build_assign (lhs
.value
, rhs
.value
);
788 gimple_set_location (assign
, loc
);
789 gimple_seq_add_stmt_without_update (seq
, assign
);
796 /* GIMPLE PHI statement. */
797 if (c_parser_next_token_is_keyword (parser
, RID_PHI
))
799 c_parser_consume_token (parser
);
801 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
804 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
805 c_parser_consume_token (parser
);
807 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
))
809 if (c_parser_next_token_is (parser
, CPP_NAME
)
810 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
812 arg
= c_parser_peek_token (parser
)->value
;
813 c_parser_consume_token (parser
);
814 if (c_parser_next_token_is (parser
, CPP_COLON
))
815 c_parser_consume_token (parser
);
817 if (!c_parser_gimple_parse_bb_spec (arg
, &src_index
))
818 c_parser_error (parser
, "invalid source block specification");
819 vargs
.safe_push (size_int (src_index
));
821 else if (c_parser_next_token_is (parser
, CPP_COMMA
))
822 c_parser_consume_token (parser
);
825 arg
= c_parser_gimple_unary_expression (parser
).value
;
826 vargs
.safe_push (arg
);
830 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
833 /* Build internal function for PHI. */
834 gcall
*call_stmt
= gimple_build_call_internal_vec (IFN_PHI
, vargs
);
835 gimple_call_set_lhs (call_stmt
, lhs
.value
);
836 gimple_set_location (call_stmt
, UNKNOWN_LOCATION
);
837 gimple_seq_add_stmt_without_update (seq
, call_stmt
);
841 /* GIMPLE call with lhs. */
842 if (c_parser_next_token_is (parser
, CPP_DOT
)
843 || (c_parser_next_token_is (parser
, CPP_NAME
)
844 && c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_PAREN
845 && lookup_name (c_parser_peek_token (parser
)->value
)))
847 rhs
= c_parser_gimple_unary_expression (parser
);
848 if (rhs
.value
!= error_mark_node
)
850 gimple
*call
= gimple_build_call_from_tree (rhs
.value
, NULL
);
851 gimple_call_set_lhs (call
, lhs
.value
);
852 gimple_seq_add_stmt_without_update (seq
, call
);
853 gimple_set_location (call
, loc
);
858 rhs
= c_parser_gimple_binary_expression (parser
);
859 if (lhs
.value
!= error_mark_node
860 && rhs
.value
!= error_mark_node
)
862 /* If we parsed a comparison and the next token is a '?' then
863 parse a conditional expression. */
864 if (COMPARISON_CLASS_P (rhs
.value
)
865 && c_parser_next_token_is (parser
, CPP_QUERY
))
867 struct c_expr trueval
, falseval
;
868 c_parser_consume_token (parser
);
869 trueval
= c_parser_gimple_postfix_expression (parser
);
870 falseval
.set_error ();
871 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
872 falseval
= c_parser_gimple_postfix_expression (parser
);
873 if (trueval
.value
== error_mark_node
874 || falseval
.value
== error_mark_node
)
876 rhs
.value
= build3_loc (loc
, COND_EXPR
, TREE_TYPE (trueval
.value
),
877 rhs
.value
, trueval
.value
, falseval
.value
);
879 assign
= gimple_build_assign (lhs
.value
, rhs
.value
);
880 gimple_seq_add_stmt_without_update (seq
, assign
);
881 gimple_set_location (assign
, loc
);
886 /* Parse gimple binary expr.
888 gimple-binary-expression:
889 gimple-unary-expression * gimple-unary-expression
890 gimple-unary-expression __MULT_HIGHPART gimple-unary-expression
891 gimple-unary-expression / gimple-unary-expression
892 gimple-unary-expression % gimple-unary-expression
893 gimple-unary-expression + gimple-unary-expression
894 gimple-unary-expression - gimple-unary-expression
895 gimple-unary-expression << gimple-unary-expression
896 gimple-unary-expression >> gimple-unary-expression
897 gimple-unary-expression < gimple-unary-expression
898 gimple-unary-expression > gimple-unary-expression
899 gimple-unary-expression <= gimple-unary-expression
900 gimple-unary-expression >= gimple-unary-expression
901 gimple-unary-expression == gimple-unary-expression
902 gimple-unary-expression != gimple-unary-expression
903 gimple-unary-expression & gimple-unary-expression
904 gimple-unary-expression ^ gimple-unary-expression
905 gimple-unary-expression | gimple-unary-expression
910 c_parser_gimple_binary_expression (gimple_parser
&parser
)
912 /* Location of the binary operator. */
913 struct c_expr ret
, lhs
, rhs
;
914 enum tree_code code
= ERROR_MARK
;
916 lhs
= c_parser_gimple_postfix_expression (parser
);
917 if (c_parser_error (parser
))
919 tree ret_type
= TREE_TYPE (lhs
.value
);
920 switch (c_parser_peek_token (parser
)->type
)
926 code
= TRUNC_DIV_EXPR
;
929 code
= TRUNC_MOD_EXPR
;
932 if (POINTER_TYPE_P (TREE_TYPE (lhs
.value
)))
933 code
= POINTER_PLUS_EXPR
;
948 ret_type
= boolean_type_node
;
952 ret_type
= boolean_type_node
;
956 ret_type
= boolean_type_node
;
960 ret_type
= boolean_type_node
;
964 ret_type
= boolean_type_node
;
968 ret_type
= boolean_type_node
;
980 c_parser_error (parser
, "%<&&%> not valid in GIMPLE");
983 c_parser_error (parser
, "%<||%> not valid in GIMPLE");
987 tree id
= c_parser_peek_token (parser
)->value
;
988 if (strcmp (IDENTIFIER_POINTER (id
), "__MULT_HIGHPART") == 0)
990 code
= MULT_HIGHPART_EXPR
;
996 /* Not a binary expression. */
999 location_t ret_loc
= c_parser_peek_token (parser
)->location
;
1000 c_parser_consume_token (parser
);
1001 rhs
= c_parser_gimple_postfix_expression (parser
);
1002 if (lhs
.value
!= error_mark_node
&& rhs
.value
!= error_mark_node
)
1003 ret
.value
= build2_loc (ret_loc
, code
, ret_type
, lhs
.value
, rhs
.value
);
1007 /* Parse a gimple parentized binary expression. */
1010 c_parser_gimple_parentized_binary_expression (gimple_parser
&parser
,
1017 c_parser_consume_token (parser
);
1018 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1020 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1021 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
1023 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1024 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1027 if (op1
.value
!= error_mark_node
&& op2
.value
!= error_mark_node
)
1028 ret
.value
= build2_loc (op_loc
,
1029 code
, TREE_TYPE (op1
.value
), op1
.value
, op2
.value
);
1033 /* Parse a gimple parentized binary expression. */
1036 c_parser_gimple_parentized_ternary_expression (gimple_parser
&parser
,
1043 c_parser_consume_token (parser
);
1044 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1046 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1047 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
1049 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1050 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<)%>"))
1052 c_expr op3
= c_parser_gimple_postfix_expression (parser
);
1053 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1056 if (op1
.value
!= error_mark_node
1057 && op2
.value
!= error_mark_node
1058 && op3
.value
!= error_mark_node
)
1059 ret
.value
= build3_loc (op_loc
,
1060 code
, TREE_TYPE (op1
.value
),
1061 op1
.value
, op2
.value
, op3
.value
);
1065 /* Parse gimple unary expression.
1067 gimple-unary-expression:
1068 gimple-postfix-expression
1069 unary-operator gimple-postfix-expression
1071 unary-operator: one of
1076 c_parser_gimple_unary_expression (gimple_parser
&parser
)
1078 struct c_expr ret
, op
;
1079 location_t op_loc
= c_parser_peek_token (parser
)->location
;
1082 switch (c_parser_peek_token (parser
)->type
)
1085 c_parser_consume_token (parser
);
1086 op
= c_parser_gimple_postfix_expression (parser
);
1087 mark_exp_read (op
.value
);
1088 return parser_build_unary_op (op_loc
, ADDR_EXPR
, op
);
1091 c_parser_consume_token (parser
);
1092 op
= c_parser_gimple_postfix_expression (parser
);
1093 if (op
.value
== error_mark_node
)
1095 if (! POINTER_TYPE_P (TREE_TYPE (op
.value
)))
1097 error_at (op_loc
, "expected pointer as argument of unary %<*%>");
1100 finish
= op
.get_finish ();
1101 location_t combined_loc
= make_location (op_loc
, op_loc
, finish
);
1102 ret
.value
= build_simple_mem_ref_loc (combined_loc
, op
.value
);
1103 TREE_SIDE_EFFECTS (ret
.value
)
1104 = TREE_THIS_VOLATILE (ret
.value
)
1105 = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op
.value
)));
1106 ret
.src_range
.m_start
= op_loc
;
1107 ret
.src_range
.m_finish
= finish
;
1111 c_parser_consume_token (parser
);
1112 op
= c_parser_gimple_postfix_expression (parser
);
1113 return parser_build_unary_op (op_loc
, CONVERT_EXPR
, op
);
1115 c_parser_consume_token (parser
);
1116 op
= c_parser_gimple_postfix_expression (parser
);
1117 return parser_build_unary_op (op_loc
, NEGATE_EXPR
, op
);
1119 c_parser_consume_token (parser
);
1120 op
= c_parser_gimple_postfix_expression (parser
);
1121 return parser_build_unary_op (op_loc
, BIT_NOT_EXPR
, op
);
1123 c_parser_error (parser
, "%<!%> not valid in GIMPLE");
1126 switch (c_parser_peek_token (parser
)->keyword
)
1129 c_parser_consume_token (parser
);
1130 op
= c_parser_gimple_postfix_expression (parser
);
1131 return parser_build_unary_op (op_loc
, REALPART_EXPR
, op
);
1133 c_parser_consume_token (parser
);
1134 op
= c_parser_gimple_postfix_expression (parser
);
1135 return parser_build_unary_op (op_loc
, IMAGPART_EXPR
, op
);
1137 return c_parser_gimple_postfix_expression (parser
);
1141 tree id
= c_parser_peek_token (parser
)->value
;
1142 if (strcmp (IDENTIFIER_POINTER (id
), "__ABS") == 0)
1144 c_parser_consume_token (parser
);
1145 op
= c_parser_gimple_postfix_expression (parser
);
1146 return parser_build_unary_op (op_loc
, ABS_EXPR
, op
);
1148 else if (strcmp (IDENTIFIER_POINTER (id
), "__ABSU") == 0)
1150 c_parser_consume_token (parser
);
1151 op
= c_parser_gimple_postfix_expression (parser
);
1152 return parser_build_unary_op (op_loc
, ABSU_EXPR
, op
);
1154 else if (strcmp (IDENTIFIER_POINTER (id
), "__MIN") == 0)
1155 return c_parser_gimple_parentized_binary_expression (parser
,
1158 else if (strcmp (IDENTIFIER_POINTER (id
), "__MAX") == 0)
1159 return c_parser_gimple_parentized_binary_expression (parser
,
1162 else if (strcmp (IDENTIFIER_POINTER (id
), "__VEC_PERM") == 0)
1163 return c_parser_gimple_parentized_ternary_expression
1164 (parser
, op_loc
, VEC_PERM_EXPR
);
1165 else if (strcmp (IDENTIFIER_POINTER (id
), "__BIT_INSERT") == 0)
1167 /* __BIT_INSERT '(' postfix-expression, postfix-expression,
1169 location_t loc
= c_parser_peek_token (parser
)->location
;
1170 c_parser_consume_token (parser
);
1171 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1173 c_expr op0
= c_parser_gimple_postfix_expression (parser
);
1174 c_parser_skip_until_found (parser
, CPP_COMMA
,
1176 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1177 c_parser_skip_until_found (parser
, CPP_COMMA
,
1179 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1180 if (TREE_CODE (op2
.value
) != INTEGER_CST
1181 || !int_fits_type_p (op2
.value
, bitsizetype
))
1182 c_parser_error (parser
, "expected constant offset");
1183 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1185 if (op0
.value
!= error_mark_node
1186 && op1
.value
!= error_mark_node
1187 && TREE_CODE (op2
.value
) == INTEGER_CST
)
1188 ret
.value
= build3_loc (loc
, BIT_INSERT_EXPR
,
1189 TREE_TYPE (op0
.value
),
1190 op0
.value
, op1
.value
,
1191 fold_convert (bitsizetype
,
1197 return c_parser_gimple_postfix_expression (parser
);
1200 return c_parser_gimple_postfix_expression (parser
);
1204 /* Decompose ID into base name (ID until ver_offset) and VERSION. Return
1205 true if ID matches a SSA name. */
1208 c_parser_parse_ssa_name_id (tree id
, unsigned *version
, unsigned *ver_offset
)
1210 const char *token
= IDENTIFIER_POINTER (id
);
1211 const char *var_version
= strrchr (token
, '_');
1215 *ver_offset
= var_version
- token
;
1216 for (const char *p
= var_version
+ 1; *p
; ++p
)
1219 *version
= atoi (var_version
+ 1);
1220 return *version
> 0;
1223 /* Get at the actual SSA name ID with VERSION starting at VER_OFFSET.
1224 TYPE is the type if the SSA name is being declared. */
1227 c_parser_parse_ssa_name (gimple_parser
&parser
,
1228 tree id
, tree type
, unsigned version
,
1229 unsigned ver_offset
)
1231 tree name
= NULL_TREE
;
1232 const char *token
= IDENTIFIER_POINTER (id
);
1234 if (ver_offset
== 0)
1236 /* Anonymous unnamed SSA name. */
1237 if (version
< num_ssa_names
)
1238 name
= ssa_name (version
);
1243 c_parser_error (parser
, "SSA name undeclared");
1244 return error_mark_node
;
1246 name
= make_ssa_name_fn (cfun
, type
, NULL
, version
);
1251 if (version
< num_ssa_names
)
1252 name
= ssa_name (version
);
1255 /* Separate var name from version. */
1256 char *var_name
= XNEWVEC (char, ver_offset
+ 1);
1257 memcpy (var_name
, token
, ver_offset
);
1258 var_name
[ver_offset
] = '\0';
1259 /* lookup for parent decl. */
1260 id
= get_identifier (var_name
);
1261 tree parent
= lookup_name (id
);
1262 XDELETEVEC (var_name
);
1263 if (! parent
|| parent
== error_mark_node
)
1265 c_parser_error (parser
, "base variable or SSA name undeclared");
1266 return error_mark_node
;
1268 if (!(VAR_P (parent
)
1269 || TREE_CODE (parent
) == PARM_DECL
1270 || TREE_CODE (parent
) == RESULT_DECL
))
1272 error ("invalid base %qE for SSA name", parent
);
1273 return error_mark_node
;
1275 name
= make_ssa_name_fn (cfun
, parent
,
1276 gimple_build_nop (), version
);
1283 /* Parse a gimple call to an internal function.
1285 gimple-call-internal:
1286 . identifier ( gimple-argument-expression-list[opt] ) */
1288 static struct c_expr
1289 c_parser_gimple_call_internal (gimple_parser
&parser
)
1294 gcc_assert (c_parser_next_token_is (parser
, CPP_DOT
));
1295 c_parser_consume_token (parser
);
1296 location_t loc
= c_parser_peek_token (parser
)->location
;
1297 if (!c_parser_next_token_is (parser
, CPP_NAME
)
1298 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
1300 c_parser_error (parser
, "expecting internal function name");
1303 tree id
= c_parser_peek_token (parser
)->value
;
1304 internal_fn ifn
= lookup_internal_fn (IDENTIFIER_POINTER (id
));
1305 c_parser_consume_token (parser
);
1306 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1308 auto_vec
<tree
> exprlist
;
1309 if (!c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
1310 c_parser_gimple_expr_list (parser
, &exprlist
);
1311 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
1312 if (ifn
== IFN_LAST
)
1313 error_at (loc
, "unknown internal function %qE", id
);
1316 expr
.value
= build_call_expr_internal_loc_array
1317 (loc
, ifn
, void_type_node
, exprlist
.length (),
1318 exprlist
.address ());
1319 expr
.original_code
= ERROR_MARK
;
1320 expr
.original_type
= NULL
;
1326 /* Parse '<' type [',' alignment] '>' and return a type on success
1327 and NULL_TREE on error. */
1330 c_parser_gimple_typespec (gimple_parser
&parser
)
1332 struct c_type_name
*type_name
= NULL
;
1333 tree alignment
= NULL_TREE
;
1334 if (c_parser_require (parser
, CPP_LESS
, "expected %<<%>"))
1336 type_name
= c_parser_type_name (parser
);
1337 /* Optional alignment. */
1338 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1340 c_parser_consume_token (parser
);
1342 = c_parser_gimple_postfix_expression (parser
).value
;
1344 c_parser_skip_until_found (parser
,
1345 CPP_GREATER
, "expected %<>%>");
1350 tree type
= groktypename (type_name
, &tem
, NULL
);
1352 type
= build_aligned_type (type
, tree_to_uhwi (alignment
));
1356 /* Parse gimple postfix expression.
1358 gimple-postfix-expression:
1359 gimple-primary-expression
1360 gimple-primary-expression [ gimple-primary-expression ]
1361 gimple-primary-expression ( gimple-argument-expression-list[opt] )
1362 gimple-postfix-expression . identifier
1363 gimple-postfix-expression -> identifier
1365 gimple-argument-expression-list:
1366 gimple-unary-expression
1367 gimple-argument-expression-list , gimple-unary-expression
1369 gimple-primary-expression:
1374 gimple-call-internal
1378 static struct c_expr
1379 c_parser_gimple_postfix_expression (gimple_parser
&parser
)
1381 location_t loc
= c_parser_peek_token (parser
)->location
;
1382 source_range tok_range
= c_parser_peek_token (parser
)->get_range ();
1385 switch (c_parser_peek_token (parser
)->type
)
1388 expr
.value
= c_parser_peek_token (parser
)->value
;
1389 set_c_expr_source_range (&expr
, tok_range
);
1390 loc
= c_parser_peek_token (parser
)->location
;
1391 c_parser_consume_token (parser
);
1398 expr
.value
= c_parser_peek_token (parser
)->value
;
1399 set_c_expr_source_range (&expr
, tok_range
);
1400 c_parser_consume_token (parser
);
1406 case CPP_UTF8STRING
:
1407 expr
= c_parser_string_literal (parser
, false, true);
1410 expr
= c_parser_gimple_call_internal (parser
);
1413 if (c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
1415 tree id
= c_parser_peek_token (parser
)->value
;
1416 if (strcmp (IDENTIFIER_POINTER (id
), "__MEM") == 0)
1418 /* __MEM '<' type-name [ ',' number ] '>'
1419 '(' [ '(' type-name ')' ] unary-expression
1420 [ '+' number ] ')' */
1421 location_t loc
= c_parser_peek_token (parser
)->location
;
1422 c_parser_consume_token (parser
);
1423 tree type
= c_parser_gimple_typespec (parser
);
1425 ptr
.value
= error_mark_node
;
1426 tree alias_off
= NULL_TREE
;
1427 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1429 tree alias_type
= NULL_TREE
;
1430 /* Optional alias-type cast. */
1431 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
1433 c_parser_consume_token (parser
);
1434 struct c_type_name
*alias_type_name
1435 = c_parser_type_name (parser
);
1436 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1438 if (alias_type_name
)
1441 alias_type
= groktypename (alias_type_name
,
1445 ptr
= c_parser_gimple_unary_expression (parser
);
1446 if (ptr
.value
== error_mark_node
1447 || ! POINTER_TYPE_P (TREE_TYPE (ptr
.value
)))
1449 if (ptr
.value
!= error_mark_node
)
1450 error_at (ptr
.get_start (),
1451 "invalid type of %<__MEM%> operand");
1452 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1457 alias_type
= TREE_TYPE (ptr
.value
);
1458 /* Optional constant offset. */
1459 if (c_parser_next_token_is (parser
, CPP_PLUS
))
1461 c_parser_consume_token (parser
);
1463 = c_parser_gimple_postfix_expression (parser
).value
;
1464 alias_off
= fold_convert (alias_type
, alias_off
);
1467 alias_off
= build_int_cst (alias_type
, 0);
1468 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1471 if (! type
|| c_parser_error (parser
))
1473 c_parser_set_error (parser
, false);
1476 expr
.value
= build2_loc (loc
, MEM_REF
,
1477 type
, ptr
.value
, alias_off
);
1480 else if (strcmp (IDENTIFIER_POINTER (id
), "__VIEW_CONVERT") == 0)
1482 /* __VIEW_CONVERT '<' type-name [ ',' number ] '>'
1483 '(' postfix-expression ')' */
1484 location_t loc
= c_parser_peek_token (parser
)->location
;
1485 c_parser_consume_token (parser
);
1486 tree type
= c_parser_gimple_typespec (parser
);
1487 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1489 c_expr op
= c_parser_gimple_postfix_expression (parser
);
1490 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1492 if (type
&& op
.value
!= error_mark_node
)
1493 expr
.value
= build1_loc (loc
, VIEW_CONVERT_EXPR
,
1498 else if (strcmp (IDENTIFIER_POINTER (id
), "__BIT_FIELD_REF") == 0)
1500 /* __BIT_FIELD_REF '<' type-name [ ',' number ] '>'
1501 '(' postfix-expression, integer, integer ')' */
1502 location_t loc
= c_parser_peek_token (parser
)->location
;
1503 c_parser_consume_token (parser
);
1504 tree type
= c_parser_gimple_typespec (parser
);
1505 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1507 c_expr op0
= c_parser_gimple_postfix_expression (parser
);
1508 c_parser_skip_until_found (parser
, CPP_COMMA
,
1510 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1511 if (TREE_CODE (op1
.value
) != INTEGER_CST
1512 || !int_fits_type_p (op1
.value
, bitsizetype
))
1513 c_parser_error (parser
, "expected constant size");
1514 c_parser_skip_until_found (parser
, CPP_COMMA
,
1516 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1517 if (TREE_CODE (op2
.value
) != INTEGER_CST
1518 || !int_fits_type_p (op2
.value
, bitsizetype
))
1519 c_parser_error (parser
, "expected constant offset");
1520 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1523 && op0
.value
!= error_mark_node
1524 && TREE_CODE (op1
.value
) == INTEGER_CST
1525 && TREE_CODE (op2
.value
) == INTEGER_CST
)
1526 expr
.value
= build3_loc (loc
, BIT_FIELD_REF
, type
,
1528 fold_convert (bitsizetype
,
1530 fold_convert (bitsizetype
,
1535 else if (strcmp (IDENTIFIER_POINTER (id
), "_Literal") == 0)
1537 /* _Literal '(' type-name ')' ( [ '-' ] constant | constructor ) */
1538 c_parser_consume_token (parser
);
1539 tree type
= NULL_TREE
;
1540 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1542 struct c_type_name
*type_name
= c_parser_type_name (parser
);
1545 type
= groktypename (type_name
, &tem
, NULL
);
1546 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1551 c_parser_error (parser
, "invalid _Literal");
1554 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1556 c_parser_consume_token (parser
);
1557 if (!AGGREGATE_TYPE_P (type
)
1558 && !VECTOR_TYPE_P (type
))
1560 c_parser_error (parser
, "invalid type for _Literal with "
1562 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
1566 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1567 bool constant_p
= true;
1568 if (VECTOR_TYPE_P (type
)
1569 && !c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1571 vec_alloc (v
, TYPE_VECTOR_SUBPARTS (type
).to_constant ());
1575 = c_parser_gimple_postfix_expression (parser
).value
;
1577 || val
== error_mark_node
1578 || (! CONSTANT_CLASS_P (val
)
1579 && ! SSA_VAR_P (val
)))
1581 c_parser_error (parser
, "invalid _Literal");
1584 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, val
);
1585 if (! CONSTANT_CLASS_P (val
))
1587 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1588 c_parser_consume_token (parser
);
1594 if (c_parser_require (parser
, CPP_CLOSE_BRACE
,
1597 if (v
&& constant_p
)
1598 expr
.value
= build_vector_from_ctor (type
, v
);
1600 expr
.value
= build_constructor (type
, v
);
1604 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
1612 if ((neg_p
= c_parser_next_token_is (parser
, CPP_MINUS
)))
1613 c_parser_consume_token (parser
);
1614 if ((addr_p
= c_parser_next_token_is (parser
, CPP_AND
)))
1615 c_parser_consume_token (parser
);
1616 tree val
= c_parser_gimple_postfix_expression (parser
).value
;
1618 || val
== error_mark_node
1619 || (!CONSTANT_CLASS_P (val
)
1621 && (TREE_CODE (val
) == STRING_CST
1624 c_parser_error (parser
, "invalid _Literal");
1628 val
= build1 (ADDR_EXPR
, type
, val
);
1631 val
= const_unop (NEGATE_EXPR
, TREE_TYPE (val
), val
);
1634 c_parser_error (parser
, "invalid _Literal");
1638 expr
.value
= fold_convert (type
, val
);
1644 unsigned version
, ver_offset
;
1645 if (! lookup_name (id
)
1646 && c_parser_parse_ssa_name_id (id
, &version
, &ver_offset
))
1648 c_parser_consume_token (parser
);
1649 expr
.value
= c_parser_parse_ssa_name (parser
, id
, NULL_TREE
,
1650 version
, ver_offset
);
1651 if (expr
.value
== error_mark_node
)
1653 set_c_expr_source_range (&expr
, tok_range
);
1654 /* For default definition SSA names. */
1655 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
1656 && c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
1659 (c_parser_peek_2nd_token (parser
)->value
)) == 0
1660 && c_parser_peek_nth_token (parser
, 3)->type
== CPP_CLOSE_PAREN
)
1662 c_parser_consume_token (parser
);
1663 c_parser_consume_token (parser
);
1664 c_parser_consume_token (parser
);
1665 if (! SSA_NAME_IS_DEFAULT_DEF (expr
.value
))
1667 if (!SSA_NAME_VAR (expr
.value
))
1669 error_at (loc
, "anonymous SSA name cannot have"
1670 " default definition");
1671 expr
.value
= error_mark_node
;
1674 set_ssa_default_def (cfun
, SSA_NAME_VAR (expr
.value
),
1676 SSA_NAME_DEF_STMT (expr
.value
) = gimple_build_nop ();
1682 c_parser_consume_token (parser
);
1684 = build_external_ref (loc
, id
,
1685 (c_parser_peek_token (parser
)->type
1686 == CPP_OPEN_PAREN
), &expr
.original_type
);
1687 set_c_expr_source_range (&expr
, tok_range
);
1693 c_parser_error (parser
, "expected expression");
1699 c_parser_error (parser
, "expected expression");
1703 return c_parser_gimple_postfix_expression_after_primary
1704 (parser
, EXPR_LOC_OR_LOC (expr
.value
, loc
), expr
);
1707 /* Parse a gimple postfix expression after the initial primary or compound
1710 static struct c_expr
1711 c_parser_gimple_postfix_expression_after_primary (gimple_parser
&parser
,
1712 location_t expr_loc
,
1718 location_t comp_loc
;
1722 location_t op_loc
= c_parser_peek_token (parser
)->location
;
1723 switch (c_parser_peek_token (parser
)->type
)
1725 case CPP_OPEN_SQUARE
:
1727 c_parser_consume_token (parser
);
1728 tree idx
= c_parser_gimple_unary_expression (parser
).value
;
1730 if (! c_parser_require (parser
, CPP_CLOSE_SQUARE
, "expected %<]%>"))
1732 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
1736 start
= expr
.get_start ();
1737 finish
= c_parser_tokens_buf (parser
, 0)->location
;
1738 expr
.value
= build_array_ref (op_loc
, expr
.value
, idx
);
1739 set_c_expr_source_range (&expr
, start
, finish
);
1741 expr
.original_code
= ERROR_MARK
;
1742 expr
.original_type
= NULL
;
1745 case CPP_OPEN_PAREN
:
1747 /* Function call. */
1748 c_parser_consume_token (parser
);
1749 auto_vec
<tree
> exprlist
;
1750 if (! c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
1751 c_parser_gimple_expr_list (parser
, &exprlist
);
1752 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1754 expr
.value
= build_call_array_loc
1755 (expr_loc
, TREE_TYPE (TREE_TYPE (expr
.value
)),
1756 expr
.value
, exprlist
.length (), exprlist
.address ());
1757 expr
.original_code
= ERROR_MARK
;
1758 expr
.original_type
= NULL
;
1763 /* Structure element reference. */
1764 c_parser_consume_token (parser
);
1765 if (c_parser_next_token_is (parser
, CPP_NAME
))
1767 c_token
*comp_tok
= c_parser_peek_token (parser
);
1768 ident
= comp_tok
->value
;
1769 comp_loc
= comp_tok
->location
;
1773 c_parser_error (parser
, "expected identifier");
1775 expr
.original_code
= ERROR_MARK
;
1776 expr
.original_type
= NULL
;
1779 start
= expr
.get_start ();
1780 finish
= c_parser_peek_token (parser
)->get_finish ();
1781 c_parser_consume_token (parser
);
1782 expr
.value
= build_component_ref (op_loc
, expr
.value
, ident
,
1784 set_c_expr_source_range (&expr
, start
, finish
);
1785 expr
.original_code
= ERROR_MARK
;
1786 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1787 expr
.original_type
= NULL
;
1790 /* Remember the original type of a bitfield. */
1791 tree field
= TREE_OPERAND (expr
.value
, 1);
1792 if (TREE_CODE (field
) != FIELD_DECL
)
1793 expr
.original_type
= NULL
;
1795 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1801 /* Structure element reference. */
1802 c_parser_consume_token (parser
);
1803 if (c_parser_next_token_is (parser
, CPP_NAME
))
1805 c_token
*comp_tok
= c_parser_peek_token (parser
);
1806 ident
= comp_tok
->value
;
1807 comp_loc
= comp_tok
->location
;
1811 c_parser_error (parser
, "expected identifier");
1813 expr
.original_code
= ERROR_MARK
;
1814 expr
.original_type
= NULL
;
1817 start
= expr
.get_start ();
1818 finish
= c_parser_peek_token (parser
)->get_finish ();
1819 c_parser_consume_token (parser
);
1820 expr
.value
= build_component_ref (op_loc
,
1821 build_simple_mem_ref_loc
1822 (op_loc
, expr
.value
),
1824 set_c_expr_source_range (&expr
, start
, finish
);
1825 expr
.original_code
= ERROR_MARK
;
1826 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1827 expr
.original_type
= NULL
;
1830 /* Remember the original type of a bitfield. */
1831 tree field
= TREE_OPERAND (expr
.value
, 1);
1832 if (TREE_CODE (field
) != FIELD_DECL
)
1833 expr
.original_type
= NULL
;
1835 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1845 /* Parse expression list.
1848 gimple-unary-expression
1849 gimple-expr-list , gimple-unary-expression
1854 c_parser_gimple_expr_list (gimple_parser
&parser
, vec
<tree
> *ret
)
1858 expr
= c_parser_gimple_unary_expression (parser
);
1859 ret
->safe_push (expr
.value
);
1860 while (c_parser_next_token_is (parser
, CPP_COMMA
))
1862 c_parser_consume_token (parser
);
1863 expr
= c_parser_gimple_unary_expression (parser
);
1864 ret
->safe_push (expr
.value
);
1868 /* Parse gimple label.
1872 case constant-expression :
1878 c_parser_gimple_label (gimple_parser
&parser
, gimple_seq
*seq
)
1880 tree name
= c_parser_peek_token (parser
)->value
;
1881 location_t loc1
= c_parser_peek_token (parser
)->location
;
1882 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
1883 c_parser_consume_token (parser
);
1884 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
1885 c_parser_consume_token (parser
);
1886 tree label
= define_label (loc1
, name
);
1887 gimple_seq_add_stmt_without_update (seq
, gimple_build_label (label
));
1891 /* Parse gimple/RTL pass list.
1893 gimple-or-rtl-pass-list:
1894 startwith("pass-name")[,{cfg,ssa}]
1898 c_parser_gimple_or_rtl_pass_list (c_parser
*parser
, c_declspecs
*specs
)
1902 /* Accept __GIMPLE/__RTL. */
1903 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
1905 c_parser_consume_token (parser
);
1907 specs
->entry_bb_count
= profile_count::uninitialized ();
1908 while (c_parser_next_token_is (parser
, CPP_NAME
))
1910 profile_quality quality
;
1911 const char *op
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
1912 c_parser_consume_token (parser
);
1913 if (! strcmp (op
, "startwith"))
1915 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1917 if (c_parser_next_token_is_not (parser
, CPP_STRING
))
1919 error_at (c_parser_peek_token (parser
)->location
,
1920 "expected pass name");
1923 pass
= xstrdup (TREE_STRING_POINTER
1924 (c_parser_string_literal (parser
, false,
1926 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<(%>"))
1929 else if (parse_profile_quality (op
, &quality
))
1932 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1935 if (!c_parser_next_token_is (parser
, CPP_NUMBER
)
1936 || (TREE_CODE (q
= c_parser_peek_token (parser
)->value
)
1939 c_parser_error (parser
, "expected count value");
1943 specs
->entry_bb_count
1944 = profile_count::from_gcov_type (TREE_INT_CST_LOW (q
), quality
);
1945 c_parser_consume_token (parser
);
1946 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1949 else if (specs
->declspec_il
!= cdil_gimple
)
1950 /* Allow only one IL specifier and none on RTL. */
1952 else if (! strcmp (op
, "cfg"))
1953 specs
->declspec_il
= cdil_gimple_cfg
;
1954 else if (! strcmp (op
, "ssa"))
1955 specs
->declspec_il
= cdil_gimple_ssa
;
1958 error_at (c_parser_peek_token (parser
)->location
,
1959 "invalid operation");
1962 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1963 c_parser_consume_token (parser
);
1966 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1969 specs
->gimple_or_rtl_pass
= pass
;
1972 /* Parse gimple local declaration.
1974 declaration-specifiers:
1975 storage-class-specifier declaration-specifiers[opt]
1976 type-specifier declaration-specifiers[opt]
1977 type-qualifier declaration-specifiers[opt]
1978 function-specifier declaration-specifiers[opt]
1979 alignment-specifier declaration-specifiers[opt]
1981 storage-class-specifier:
2005 address-space-qualifier
2011 c_parser_gimple_declaration (gimple_parser
&parser
)
2013 struct c_declarator
*declarator
;
2014 struct c_declspecs
*specs
= build_null_declspecs ();
2015 c_parser_declspecs (parser
, specs
, true, true, true,
2016 true, true, true, true, cla_nonabstract_decl
);
2017 finish_declspecs (specs
);
2019 /* Provide better error recovery. Note that a type name here is usually
2020 better diagnosed as a redeclaration. */
2021 if (c_parser_next_token_starts_declspecs (parser
)
2022 && ! c_parser_next_token_is (parser
, CPP_NAME
))
2024 c_parser_error (parser
, "expected %<;%>");
2025 c_parser_set_error (parser
, false);
2030 declarator
= c_parser_declarator (parser
,
2031 specs
->typespec_kind
!= ctsk_none
,
2032 C_DTR_NORMAL
, &dummy
);
2034 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2036 /* Handle SSA name decls specially, they do not go into the identifier
2037 table but we simply build the SSA name for later lookup. */
2038 unsigned version
, ver_offset
;
2039 if (declarator
->kind
== cdk_id
2040 && is_gimple_reg_type (specs
->type
)
2041 && c_parser_parse_ssa_name_id (declarator
->u
.id
.id
,
2042 &version
, &ver_offset
)
2043 /* The following restricts it to unnamed anonymous SSA names
2044 which fails parsing of named ones in dumps (we could
2045 decide to not dump their name for -gimple). */
2047 c_parser_parse_ssa_name (parser
, declarator
->u
.id
.id
, specs
->type
,
2048 version
, ver_offset
);
2051 tree postfix_attrs
= NULL_TREE
;
2052 tree all_prefix_attrs
= specs
->attrs
;
2053 specs
->attrs
= NULL
;
2054 tree decl
= start_decl (declarator
, specs
, false,
2055 chainon (postfix_attrs
, all_prefix_attrs
));
2057 finish_decl (decl
, UNKNOWN_LOCATION
, NULL_TREE
, NULL_TREE
,
2063 c_parser_error (parser
, "expected %<;%>");
2068 /* Parse gimple goto statement. */
2071 c_parser_gimple_goto_stmt (gimple_parser
&parser
,
2072 location_t loc
, tree label
, gimple_seq
*seq
)
2074 if (cfun
->curr_properties
& PROP_cfg
)
2077 profile_probability prob
;
2078 if (c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2079 &dest_index
, &prob
))
2081 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2082 EDGE_FALLTHRU
, prob
);
2086 tree decl
= lookup_label_for_goto (loc
, label
);
2087 gimple_seq_add_stmt_without_update (seq
, gimple_build_goto (decl
));
2090 /* Parse a parenthesized condition.
2092 ( gimple-binary-expression ) */
2095 c_parser_gimple_paren_condition (gimple_parser
&parser
)
2097 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2098 return error_mark_node
;
2099 tree cond
= c_parser_gimple_binary_expression (parser
).value
;
2100 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2101 return error_mark_node
;
2105 /* Parse gimple try statement.
2108 try { ... } finally { ... }
2109 try { ... } finally { ... } else { ... }
2111 This could support try/catch as well, but it's not implemented yet.
2115 c_parser_gimple_try_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2117 gimple_seq tryseq
= NULL
;
2118 c_parser_consume_token (parser
);
2119 c_parser_gimple_compound_statement (parser
, &tryseq
);
2121 if ((c_parser_next_token_is (parser
, CPP_KEYWORD
)
2122 && c_parser_peek_token (parser
)->keyword
== RID_AT_FINALLY
)
2123 || (c_parser_next_token_is (parser
, CPP_NAME
)
2124 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
2125 && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
),
2128 gimple_seq finseq
= NULL
;
2129 c_parser_consume_token (parser
);
2130 c_parser_gimple_compound_statement (parser
, &finseq
);
2132 if (c_parser_next_token_is (parser
, CPP_KEYWORD
)
2133 && c_parser_peek_token (parser
)->keyword
== RID_ELSE
)
2135 gimple_seq elsseq
= NULL
;
2136 c_parser_consume_token (parser
);
2137 c_parser_gimple_compound_statement (parser
, &elsseq
);
2139 geh_else
*stmt
= gimple_build_eh_else (finseq
, elsseq
);
2141 gimple_seq_add_stmt_without_update (&finseq
, stmt
);
2144 gtry
*stmt
= gimple_build_try (tryseq
, finseq
, GIMPLE_TRY_FINALLY
);
2145 gimple_seq_add_stmt_without_update (seq
, stmt
);
2147 else if (c_parser_next_token_is (parser
, CPP_KEYWORD
)
2148 && c_parser_peek_token (parser
)->keyword
== RID_AT_CATCH
)
2149 c_parser_error (parser
, "%<catch%> is not supported");
2151 c_parser_error (parser
, "expected %<finally%> or %<catch%>");
2154 /* Parse gimple if-else statement.
2157 if ( gimple-binary-expression ) gimple-goto-statement
2158 if ( gimple-binary-expression ) gimple-goto-statement \
2159 else gimple-goto-statement
2163 c_parser_gimple_if_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2165 tree t_label
= NULL_TREE
, f_label
= NULL_TREE
, label
;
2167 c_parser_consume_token (parser
);
2168 tree cond
= c_parser_gimple_paren_condition (parser
);
2170 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
2172 loc
= c_parser_peek_token (parser
)->location
;
2173 c_parser_consume_token (parser
);
2174 if (! c_parser_next_token_is (parser
, CPP_NAME
))
2176 c_parser_error (parser
, "expected label");
2179 label
= c_parser_peek_token (parser
)->value
;
2180 c_parser_consume_token (parser
);
2182 profile_probability prob
;
2183 if ((cfun
->curr_properties
& PROP_cfg
)
2184 && c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2185 &dest_index
, &prob
))
2186 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2187 EDGE_TRUE_VALUE
, prob
);
2189 t_label
= lookup_label_for_goto (loc
, label
);
2190 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
2195 c_parser_error (parser
, "expected goto expression");
2199 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
2200 c_parser_consume_token (parser
);
2203 c_parser_error (parser
, "expected else statement");
2207 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
2209 loc
= c_parser_peek_token (parser
)->location
;
2210 c_parser_consume_token (parser
);
2211 if (! c_parser_next_token_is (parser
, CPP_NAME
))
2213 c_parser_error (parser
, "expected label");
2216 label
= c_parser_peek_token (parser
)->value
;
2217 c_parser_consume_token (parser
);
2219 profile_probability prob
;
2220 if ((cfun
->curr_properties
& PROP_cfg
)
2221 && c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2222 &dest_index
, &prob
))
2223 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2224 EDGE_FALSE_VALUE
, prob
);
2226 f_label
= lookup_label_for_goto (loc
, label
);
2227 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
2232 c_parser_error (parser
, "expected goto expression");
2236 if (cond
!= error_mark_node
)
2237 gimple_seq_add_stmt_without_update (seq
, gimple_build_cond_from_tree (cond
, t_label
,
2241 /* Parse gimple switch-statement.
2243 gimple-switch-statement:
2244 switch (gimple-postfix-expression) gimple-case-statement
2246 gimple-case-statement:
2247 gimple-case-statement
2248 gimple-label-statement : gimple-goto-statment
2252 c_parser_gimple_switch_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2255 tree case_label
, label
;
2256 auto_vec
<tree
> labels
;
2257 tree default_label
= NULL_TREE
;
2258 c_parser_consume_token (parser
);
2260 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2262 cond_expr
= c_parser_gimple_postfix_expression (parser
);
2263 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2266 if (! c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
2269 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
2271 if (c_parser_next_token_is (parser
, CPP_EOF
))
2273 c_parser_error (parser
, "expected statement");
2277 switch (c_parser_peek_token (parser
)->keyword
)
2282 location_t loc
= c_parser_peek_token (parser
)->location
;
2283 c_parser_consume_token (parser
);
2285 if (c_parser_next_token_is (parser
, CPP_NAME
)
2286 || c_parser_peek_token (parser
)->type
== CPP_NUMBER
)
2287 exp1
= c_parser_gimple_postfix_expression (parser
);
2290 c_parser_error (parser
, "expected expression");
2294 if (c_parser_next_token_is (parser
, CPP_COLON
))
2296 c_parser_consume_token (parser
);
2297 if (c_parser_next_token_is (parser
, CPP_NAME
))
2299 label
= c_parser_peek_token (parser
)->value
;
2300 c_parser_consume_token (parser
);
2301 tree decl
= lookup_label_for_goto (loc
, label
);
2302 case_label
= build_case_label (exp1
.value
, NULL_TREE
,
2304 labels
.safe_push (case_label
);
2305 if (! c_parser_require (parser
, CPP_SEMICOLON
,
2309 else if (! c_parser_require (parser
, CPP_NAME
,
2313 else if (! c_parser_require (parser
, CPP_SEMICOLON
,
2320 location_t loc
= c_parser_peek_token (parser
)->location
;
2321 c_parser_consume_token (parser
);
2322 if (c_parser_next_token_is (parser
, CPP_COLON
))
2324 c_parser_consume_token (parser
);
2325 if (c_parser_next_token_is (parser
, CPP_NAME
))
2327 label
= c_parser_peek_token (parser
)->value
;
2328 c_parser_consume_token (parser
);
2329 tree decl
= lookup_label_for_goto (loc
, label
);
2330 default_label
= build_case_label (NULL_TREE
, NULL_TREE
,
2332 if (! c_parser_require (parser
, CPP_SEMICOLON
,
2336 else if (! c_parser_require (parser
, CPP_NAME
,
2340 else if (! c_parser_require (parser
, CPP_SEMICOLON
,
2346 c_parser_error (parser
, "expected case label");
2351 if (! c_parser_require (parser
, CPP_CLOSE_BRACE
, "expected %<}%>"))
2354 if (cond_expr
.value
!= error_mark_node
)
2356 gswitch
*s
= gimple_build_switch (cond_expr
.value
, default_label
, labels
);
2357 gimple_seq_add_stmt_without_update (seq
, s
);
2361 /* Parse gimple return statement. */
2364 c_parser_gimple_return_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2366 location_t loc
= c_parser_peek_token (parser
)->location
;
2368 c_parser_consume_token (parser
);
2369 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2371 c_finish_gimple_return (loc
, NULL_TREE
);
2372 ret
= gimple_build_return (NULL
);
2373 gimple_seq_add_stmt_without_update (seq
, ret
);
2377 location_t xloc
= c_parser_peek_token (parser
)->location
;
2378 c_expr expr
= c_parser_gimple_unary_expression (parser
);
2379 if (expr
.value
!= error_mark_node
)
2381 c_finish_gimple_return (xloc
, expr
.value
);
2382 ret
= gimple_build_return (expr
.value
);
2383 gimple_seq_add_stmt_without_update (seq
, ret
);
2388 /* Support function for c_parser_gimple_return_stmt. */
2391 c_finish_gimple_return (location_t loc
, tree retval
)
2393 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
2395 /* Use the expansion point to handle cases such as returning NULL
2396 in a function returning void. */
2397 location_t xloc
= expansion_point_location_if_in_system_header (loc
);
2399 if (TREE_THIS_VOLATILE (current_function_decl
))
2400 warning_at (xloc
, 0,
2401 "function declared %<noreturn%> has a %<return%> statement");
2404 current_function_returns_null
= 1;
2405 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
2407 current_function_returns_null
= 1;
2408 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
2411 (xloc
, "%<return%> with a value, in function returning void");
2412 inform (DECL_SOURCE_LOCATION (current_function_decl
),
2416 else if (TREE_CODE (valtype
) != TREE_CODE (TREE_TYPE (retval
)))
2419 (xloc
, "invalid conversion in return statement");
2420 inform (DECL_SOURCE_LOCATION (current_function_decl
),