2 Copyright (C) 2016-2022 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"
62 #include "gimple-iterator.h"
64 #include "tree-phinodes.h"
65 #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 (!startswith (IDENTIFIER_POINTER (val
), "__BB"))
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 if (number_of_loops (cfun
) <= (unsigned)is_loop_header_of
)
620 vec_safe_grow_cleared (loops_for_fn (cfun
)->larray
,
621 is_loop_header_of
+ 1, true);
622 (*loops_for_fn (cfun
)->larray
)[is_loop_header_of
] = loop
;
623 flow_loop_tree_node_add (loops_for_fn (cfun
)->tree_root
,
626 loop_father
= get_loop (cfun
, is_loop_header_of
);
628 bb
->loop_father
= loop_father
;
629 bb
->count
= bb_count
;
631 /* Stmts now go to the new block. */
632 parser
.current_bb
= bb
;
640 location_t loc
= c_parser_peek_token (parser
)->location
;
641 c_parser_consume_token (parser
);
642 gimple
*nop
= gimple_build_nop ();
643 gimple_set_location (nop
, loc
);
644 gimple_seq_add_stmt_without_update (seq
, nop
);
650 c_parser_gimple_statement (parser
, seq
);
651 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
652 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
655 c_parser_consume_token (parser
);
657 /* Put stmts parsed in the current block. */
658 if ((cfun
->curr_properties
& PROP_cfg
)
659 && !gimple_seq_empty_p (*seq
))
661 if (!parser
.current_bb
)
662 c_parser_error (parser
, "stmts without block");
665 gimple_stmt_iterator gsi
= gsi_start_bb (parser
.current_bb
);
666 gsi_insert_seq_after (&gsi
, *seq
, GSI_CONTINUE_LINKING
);
674 /* Parse a gimple statement.
677 gimple-call-expression
678 gimple-assign-statement
681 gimple-assign-statement:
682 gimple-unary-expression = gimple-assign-rhs
685 gimple-cast-expression
686 gimple-unary-expression
687 gimple-binary-expression
688 gimple-call-expression
690 gimple-phi-statement:
691 identifier = __PHI ( label : gimple_primary-expression, ... )
694 gimple-primary-expression ( argument-list )
696 gimple-cast-expression:
697 ( type-name ) gimple-primary-expression
702 c_parser_gimple_statement (gimple_parser
&parser
, gimple_seq
*seq
)
704 struct c_expr lhs
, rhs
;
705 gimple
*assign
= NULL
;
707 tree arg
= NULL_TREE
;
708 auto_vec
<tree
> vargs
;
710 lhs
= c_parser_gimple_unary_expression (parser
);
711 loc
= EXPR_LOCATION (lhs
.value
);
714 /* GIMPLE call statement without LHS. */
715 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
716 && TREE_CODE (lhs
.value
) == CALL_EXPR
)
719 call
= gimple_build_call_from_tree (lhs
.value
, NULL
);
720 gimple_seq_add_stmt_without_update (seq
, call
);
721 gimple_set_location (call
, loc
);
725 /* All following cases are statements with LHS. */
726 if (! c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
729 /* Cast expression. */
730 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
731 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
733 c_parser_consume_token (parser
);
734 struct c_type_name
*type_name
= c_parser_type_name (parser
);
735 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
736 if (type_name
== NULL
)
738 /* ??? The actual type used in the cast expression is ignored as
739 in GIMPLE it is encoded by the type of the LHS. */
740 rhs
= c_parser_gimple_postfix_expression (parser
);
741 if (lhs
.value
!= error_mark_node
742 && rhs
.value
!= error_mark_node
)
744 enum tree_code code
= NOP_EXPR
;
745 if (FLOAT_TYPE_P (TREE_TYPE (lhs
.value
))
746 && ! FLOAT_TYPE_P (TREE_TYPE (rhs
.value
)))
748 else if (! FLOAT_TYPE_P (TREE_TYPE (lhs
.value
))
749 && FLOAT_TYPE_P (TREE_TYPE (rhs
.value
)))
750 code
= FIX_TRUNC_EXPR
;
751 assign
= gimple_build_assign (lhs
.value
, code
, rhs
.value
);
752 gimple_seq_add_stmt_without_update (seq
, assign
);
753 gimple_set_location (assign
, loc
);
758 /* Unary expression. */
759 switch (c_parser_peek_token (parser
)->type
)
763 tree id
= c_parser_peek_token (parser
)->value
;
764 if (strcmp (IDENTIFIER_POINTER (id
), "__ABS") == 0
765 || strcmp (IDENTIFIER_POINTER (id
), "__ABSU") == 0
766 || strcmp (IDENTIFIER_POINTER (id
), "__MIN") == 0
767 || strcmp (IDENTIFIER_POINTER (id
), "__MAX") == 0
768 || strcmp (IDENTIFIER_POINTER (id
), "__BIT_INSERT") == 0
769 || strcmp (IDENTIFIER_POINTER (id
), "__VEC_PERM") == 0)
770 goto build_unary_expr
;
774 if (c_parser_peek_token (parser
)->keyword
!= RID_REALPART
775 && c_parser_peek_token (parser
)->keyword
!= RID_IMAGPART
)
783 case CPP_MULT
: /* pointer deref */
785 rhs
= c_parser_gimple_unary_expression (parser
);
786 if (rhs
.value
!= error_mark_node
)
788 assign
= gimple_build_assign (lhs
.value
, rhs
.value
);
789 gimple_set_location (assign
, loc
);
790 gimple_seq_add_stmt_without_update (seq
, assign
);
797 /* GIMPLE PHI statement. */
798 if (c_parser_next_token_is_keyword (parser
, RID_PHI
))
800 c_parser_consume_token (parser
);
802 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
805 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
806 c_parser_consume_token (parser
);
808 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
))
810 if (c_parser_next_token_is (parser
, CPP_NAME
)
811 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
813 arg
= c_parser_peek_token (parser
)->value
;
814 c_parser_consume_token (parser
);
815 if (c_parser_next_token_is (parser
, CPP_COLON
))
816 c_parser_consume_token (parser
);
818 if (!c_parser_gimple_parse_bb_spec (arg
, &src_index
))
819 c_parser_error (parser
, "invalid source block specification");
820 vargs
.safe_push (size_int (src_index
));
822 else if (c_parser_next_token_is (parser
, CPP_COMMA
))
823 c_parser_consume_token (parser
);
826 arg
= c_parser_gimple_unary_expression (parser
).value
;
827 vargs
.safe_push (arg
);
831 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
834 /* Build internal function for PHI. */
835 gcall
*call_stmt
= gimple_build_call_internal_vec (IFN_PHI
, vargs
);
836 gimple_call_set_lhs (call_stmt
, lhs
.value
);
837 gimple_set_location (call_stmt
, UNKNOWN_LOCATION
);
838 gimple_seq_add_stmt_without_update (seq
, call_stmt
);
842 /* GIMPLE call with lhs. */
843 if (c_parser_next_token_is (parser
, CPP_DOT
)
844 || (c_parser_next_token_is (parser
, CPP_NAME
)
845 && c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_PAREN
846 && lookup_name (c_parser_peek_token (parser
)->value
)))
848 rhs
= c_parser_gimple_unary_expression (parser
);
849 if (rhs
.value
!= error_mark_node
)
851 gimple
*call
= gimple_build_call_from_tree (rhs
.value
, NULL
);
852 gimple_call_set_lhs (call
, lhs
.value
);
853 gimple_seq_add_stmt_without_update (seq
, call
);
854 gimple_set_location (call
, loc
);
859 rhs
= c_parser_gimple_binary_expression (parser
);
860 if (lhs
.value
!= error_mark_node
861 && rhs
.value
!= error_mark_node
)
863 /* If we parsed a comparison and the next token is a '?' then
864 parse a conditional expression. */
865 if (COMPARISON_CLASS_P (rhs
.value
)
866 && c_parser_next_token_is (parser
, CPP_QUERY
))
868 struct c_expr trueval
, falseval
;
869 c_parser_consume_token (parser
);
870 trueval
= c_parser_gimple_postfix_expression (parser
);
871 falseval
.set_error ();
872 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
873 falseval
= c_parser_gimple_postfix_expression (parser
);
874 if (trueval
.value
== error_mark_node
875 || falseval
.value
== error_mark_node
)
877 rhs
.value
= build3_loc (loc
, COND_EXPR
, TREE_TYPE (trueval
.value
),
878 rhs
.value
, trueval
.value
, falseval
.value
);
880 if (get_gimple_rhs_class (TREE_CODE (rhs
.value
)) == GIMPLE_INVALID_RHS
)
882 c_parser_error (parser
, "unexpected RHS for assignment");
885 assign
= gimple_build_assign (lhs
.value
, rhs
.value
);
886 gimple_seq_add_stmt_without_update (seq
, assign
);
887 gimple_set_location (assign
, loc
);
892 /* Parse gimple binary expr.
894 gimple-binary-expression:
895 gimple-unary-expression * gimple-unary-expression
896 gimple-unary-expression __MULT_HIGHPART 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
906 gimple-unary-expression >= gimple-unary-expression
907 gimple-unary-expression == gimple-unary-expression
908 gimple-unary-expression != gimple-unary-expression
909 gimple-unary-expression & gimple-unary-expression
910 gimple-unary-expression ^ gimple-unary-expression
911 gimple-unary-expression | gimple-unary-expression
916 c_parser_gimple_binary_expression (gimple_parser
&parser
)
918 /* Location of the binary operator. */
919 struct c_expr ret
, lhs
, rhs
;
920 enum tree_code code
= ERROR_MARK
;
922 lhs
= c_parser_gimple_postfix_expression (parser
);
923 if (c_parser_error (parser
))
925 tree ret_type
= TREE_TYPE (lhs
.value
);
926 switch (c_parser_peek_token (parser
)->type
)
932 code
= TRUNC_DIV_EXPR
;
935 code
= TRUNC_MOD_EXPR
;
938 if (POINTER_TYPE_P (TREE_TYPE (lhs
.value
)))
939 code
= POINTER_PLUS_EXPR
;
954 ret_type
= boolean_type_node
;
958 ret_type
= boolean_type_node
;
962 ret_type
= boolean_type_node
;
966 ret_type
= boolean_type_node
;
970 ret_type
= boolean_type_node
;
974 ret_type
= boolean_type_node
;
986 c_parser_error (parser
, "%<&&%> not valid in GIMPLE");
989 c_parser_error (parser
, "%<||%> not valid in GIMPLE");
993 tree id
= c_parser_peek_token (parser
)->value
;
994 if (strcmp (IDENTIFIER_POINTER (id
), "__MULT_HIGHPART") == 0)
996 code
= MULT_HIGHPART_EXPR
;
1002 /* Not a binary expression. */
1005 location_t ret_loc
= c_parser_peek_token (parser
)->location
;
1006 c_parser_consume_token (parser
);
1007 rhs
= c_parser_gimple_postfix_expression (parser
);
1008 if (lhs
.value
!= error_mark_node
&& rhs
.value
!= error_mark_node
)
1009 ret
.value
= build2_loc (ret_loc
, code
, ret_type
, lhs
.value
, rhs
.value
);
1013 /* Parse a gimple parentized binary expression. */
1016 c_parser_gimple_parentized_binary_expression (gimple_parser
&parser
,
1023 c_parser_consume_token (parser
);
1024 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1026 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1027 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
1029 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1030 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1033 if (op1
.value
!= error_mark_node
&& op2
.value
!= error_mark_node
)
1034 ret
.value
= build2_loc (op_loc
,
1035 code
, TREE_TYPE (op1
.value
), op1
.value
, op2
.value
);
1039 /* Parse a gimple parentized binary expression. */
1042 c_parser_gimple_parentized_ternary_expression (gimple_parser
&parser
,
1049 c_parser_consume_token (parser
);
1050 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1052 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1053 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
1055 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1056 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<)%>"))
1058 c_expr op3
= c_parser_gimple_postfix_expression (parser
);
1059 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1062 if (op1
.value
!= error_mark_node
1063 && op2
.value
!= error_mark_node
1064 && op3
.value
!= error_mark_node
)
1065 ret
.value
= build3_loc (op_loc
,
1066 code
, TREE_TYPE (op1
.value
),
1067 op1
.value
, op2
.value
, op3
.value
);
1071 /* Parse gimple unary expression.
1073 gimple-unary-expression:
1074 gimple-postfix-expression
1075 unary-operator gimple-postfix-expression
1077 unary-operator: one of
1082 c_parser_gimple_unary_expression (gimple_parser
&parser
)
1084 struct c_expr ret
, op
;
1085 location_t op_loc
= c_parser_peek_token (parser
)->location
;
1088 switch (c_parser_peek_token (parser
)->type
)
1091 c_parser_consume_token (parser
);
1092 op
= c_parser_gimple_postfix_expression (parser
);
1093 mark_exp_read (op
.value
);
1094 return parser_build_unary_op (op_loc
, ADDR_EXPR
, op
);
1097 c_parser_consume_token (parser
);
1098 op
= c_parser_gimple_postfix_expression (parser
);
1099 if (op
.value
== error_mark_node
)
1101 if (! POINTER_TYPE_P (TREE_TYPE (op
.value
)))
1103 error_at (op_loc
, "expected pointer as argument of unary %<*%>");
1106 finish
= op
.get_finish ();
1107 location_t combined_loc
= make_location (op_loc
, op_loc
, finish
);
1108 ret
.value
= build_simple_mem_ref_loc (combined_loc
, op
.value
);
1109 TREE_SIDE_EFFECTS (ret
.value
)
1110 = TREE_THIS_VOLATILE (ret
.value
)
1111 = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op
.value
)));
1112 ret
.src_range
.m_start
= op_loc
;
1113 ret
.src_range
.m_finish
= finish
;
1117 c_parser_consume_token (parser
);
1118 op
= c_parser_gimple_postfix_expression (parser
);
1119 return parser_build_unary_op (op_loc
, CONVERT_EXPR
, op
);
1121 c_parser_consume_token (parser
);
1122 op
= c_parser_gimple_postfix_expression (parser
);
1123 return parser_build_unary_op (op_loc
, NEGATE_EXPR
, op
);
1125 c_parser_consume_token (parser
);
1126 op
= c_parser_gimple_postfix_expression (parser
);
1127 return parser_build_unary_op (op_loc
, BIT_NOT_EXPR
, op
);
1129 c_parser_error (parser
, "%<!%> not valid in GIMPLE");
1132 switch (c_parser_peek_token (parser
)->keyword
)
1135 c_parser_consume_token (parser
);
1136 op
= c_parser_gimple_postfix_expression (parser
);
1137 return parser_build_unary_op (op_loc
, REALPART_EXPR
, op
);
1139 c_parser_consume_token (parser
);
1140 op
= c_parser_gimple_postfix_expression (parser
);
1141 return parser_build_unary_op (op_loc
, IMAGPART_EXPR
, op
);
1143 return c_parser_gimple_postfix_expression (parser
);
1147 tree id
= c_parser_peek_token (parser
)->value
;
1148 if (strcmp (IDENTIFIER_POINTER (id
), "__ABS") == 0)
1150 c_parser_consume_token (parser
);
1151 op
= c_parser_gimple_postfix_expression (parser
);
1152 return parser_build_unary_op (op_loc
, ABS_EXPR
, op
);
1154 else if (strcmp (IDENTIFIER_POINTER (id
), "__ABSU") == 0)
1156 c_parser_consume_token (parser
);
1157 op
= c_parser_gimple_postfix_expression (parser
);
1158 return parser_build_unary_op (op_loc
, ABSU_EXPR
, op
);
1160 else if (strcmp (IDENTIFIER_POINTER (id
), "__MIN") == 0)
1161 return c_parser_gimple_parentized_binary_expression (parser
,
1164 else if (strcmp (IDENTIFIER_POINTER (id
), "__MAX") == 0)
1165 return c_parser_gimple_parentized_binary_expression (parser
,
1168 else if (strcmp (IDENTIFIER_POINTER (id
), "__VEC_PERM") == 0)
1169 return c_parser_gimple_parentized_ternary_expression
1170 (parser
, op_loc
, VEC_PERM_EXPR
);
1171 else if (strcmp (IDENTIFIER_POINTER (id
), "__BIT_INSERT") == 0)
1173 /* __BIT_INSERT '(' postfix-expression, postfix-expression,
1175 location_t loc
= c_parser_peek_token (parser
)->location
;
1176 c_parser_consume_token (parser
);
1177 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1179 c_expr op0
= c_parser_gimple_postfix_expression (parser
);
1180 c_parser_skip_until_found (parser
, CPP_COMMA
,
1182 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1183 c_parser_skip_until_found (parser
, CPP_COMMA
,
1185 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1186 if (TREE_CODE (op2
.value
) != INTEGER_CST
1187 || !int_fits_type_p (op2
.value
, bitsizetype
))
1188 c_parser_error (parser
, "expected constant offset");
1189 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1191 if (op0
.value
!= error_mark_node
1192 && op1
.value
!= error_mark_node
1193 && TREE_CODE (op2
.value
) == INTEGER_CST
)
1194 ret
.value
= build3_loc (loc
, BIT_INSERT_EXPR
,
1195 TREE_TYPE (op0
.value
),
1196 op0
.value
, op1
.value
,
1197 fold_convert (bitsizetype
,
1203 return c_parser_gimple_postfix_expression (parser
);
1206 return c_parser_gimple_postfix_expression (parser
);
1210 /* Decompose ID into base name (ID until ver_offset) and VERSION. Return
1211 true if ID matches a SSA name. */
1214 c_parser_parse_ssa_name_id (tree id
, unsigned *version
, unsigned *ver_offset
)
1216 const char *token
= IDENTIFIER_POINTER (id
);
1217 const char *var_version
= strrchr (token
, '_');
1221 *ver_offset
= var_version
- token
;
1222 for (const char *p
= var_version
+ 1; *p
; ++p
)
1225 *version
= atoi (var_version
+ 1);
1226 return *version
> 0;
1229 /* Get at the actual SSA name ID with VERSION starting at VER_OFFSET.
1230 TYPE is the type if the SSA name is being declared. */
1233 c_parser_parse_ssa_name (gimple_parser
&parser
,
1234 tree id
, tree type
, unsigned version
,
1235 unsigned ver_offset
)
1237 tree name
= NULL_TREE
;
1238 const char *token
= IDENTIFIER_POINTER (id
);
1240 if (ver_offset
== 0)
1242 /* Anonymous unnamed SSA name. */
1243 if (version
< num_ssa_names
)
1244 name
= ssa_name (version
);
1249 c_parser_error (parser
, "SSA name undeclared");
1250 return error_mark_node
;
1252 name
= make_ssa_name_fn (cfun
, type
, NULL
, version
);
1257 if (version
< num_ssa_names
)
1258 name
= ssa_name (version
);
1261 /* Separate var name from version. */
1262 char *var_name
= XNEWVEC (char, ver_offset
+ 1);
1263 memcpy (var_name
, token
, ver_offset
);
1264 var_name
[ver_offset
] = '\0';
1265 /* lookup for parent decl. */
1266 id
= get_identifier (var_name
);
1267 tree parent
= lookup_name (id
);
1268 XDELETEVEC (var_name
);
1269 if (! parent
|| parent
== error_mark_node
)
1271 c_parser_error (parser
, "base variable or SSA name undeclared");
1272 return error_mark_node
;
1274 if (!(VAR_P (parent
)
1275 || TREE_CODE (parent
) == PARM_DECL
1276 || TREE_CODE (parent
) == RESULT_DECL
))
1278 error ("invalid base %qE for SSA name", parent
);
1279 return error_mark_node
;
1281 name
= make_ssa_name_fn (cfun
, parent
,
1282 gimple_build_nop (), version
);
1289 /* Parse a gimple call to an internal function.
1291 gimple-call-internal:
1292 . identifier ( gimple-argument-expression-list[opt] ) */
1294 static struct c_expr
1295 c_parser_gimple_call_internal (gimple_parser
&parser
)
1300 gcc_assert (c_parser_next_token_is (parser
, CPP_DOT
));
1301 c_parser_consume_token (parser
);
1302 location_t loc
= c_parser_peek_token (parser
)->location
;
1303 if (!c_parser_next_token_is (parser
, CPP_NAME
)
1304 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
1306 c_parser_error (parser
, "expecting internal function name");
1309 tree id
= c_parser_peek_token (parser
)->value
;
1310 internal_fn ifn
= lookup_internal_fn (IDENTIFIER_POINTER (id
));
1311 c_parser_consume_token (parser
);
1312 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1314 auto_vec
<tree
> exprlist
;
1315 if (!c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
1316 c_parser_gimple_expr_list (parser
, &exprlist
);
1317 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
1318 if (ifn
== IFN_LAST
)
1319 error_at (loc
, "unknown internal function %qE", id
);
1322 expr
.value
= build_call_expr_internal_loc_array
1323 (loc
, ifn
, void_type_node
, exprlist
.length (),
1324 exprlist
.address ());
1325 expr
.original_code
= ERROR_MARK
;
1326 expr
.original_type
= NULL
;
1332 /* Parse '<' type [',' alignment] '>' and return a type on success
1333 and NULL_TREE on error. */
1336 c_parser_gimple_typespec (gimple_parser
&parser
)
1338 struct c_type_name
*type_name
= NULL
;
1339 tree alignment
= NULL_TREE
;
1340 if (c_parser_require (parser
, CPP_LESS
, "expected %<<%>"))
1342 type_name
= c_parser_type_name (parser
);
1343 /* Optional alignment. */
1344 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1346 c_parser_consume_token (parser
);
1348 = c_parser_gimple_postfix_expression (parser
).value
;
1350 c_parser_skip_until_found (parser
,
1351 CPP_GREATER
, "expected %<>%>");
1356 tree type
= groktypename (type_name
, &tem
, NULL
);
1358 type
= build_aligned_type (type
, tree_to_uhwi (alignment
));
1362 /* Parse gimple postfix expression.
1364 gimple-postfix-expression:
1365 gimple-primary-expression
1366 gimple-primary-expression [ gimple-primary-expression ]
1367 gimple-primary-expression ( gimple-argument-expression-list[opt] )
1368 gimple-postfix-expression . identifier
1369 gimple-postfix-expression -> identifier
1371 gimple-argument-expression-list:
1372 gimple-unary-expression
1373 gimple-argument-expression-list , gimple-unary-expression
1375 gimple-primary-expression:
1380 gimple-call-internal
1384 static struct c_expr
1385 c_parser_gimple_postfix_expression (gimple_parser
&parser
)
1387 location_t loc
= c_parser_peek_token (parser
)->location
;
1388 source_range tok_range
= c_parser_peek_token (parser
)->get_range ();
1391 switch (c_parser_peek_token (parser
)->type
)
1394 expr
.value
= c_parser_peek_token (parser
)->value
;
1395 set_c_expr_source_range (&expr
, tok_range
);
1396 loc
= c_parser_peek_token (parser
)->location
;
1397 c_parser_consume_token (parser
);
1404 expr
.value
= c_parser_peek_token (parser
)->value
;
1405 set_c_expr_source_range (&expr
, tok_range
);
1406 c_parser_consume_token (parser
);
1412 case CPP_UTF8STRING
:
1413 expr
= c_parser_string_literal (parser
, false, true);
1416 expr
= c_parser_gimple_call_internal (parser
);
1419 if (c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
1421 tree id
= c_parser_peek_token (parser
)->value
;
1422 if (strcmp (IDENTIFIER_POINTER (id
), "__MEM") == 0)
1424 /* __MEM '<' type-name [ ',' number ] '>'
1425 '(' [ '(' type-name ')' ] unary-expression
1426 [ '+' number ] ')' */
1427 location_t loc
= c_parser_peek_token (parser
)->location
;
1428 c_parser_consume_token (parser
);
1429 tree type
= c_parser_gimple_typespec (parser
);
1431 ptr
.value
= error_mark_node
;
1432 tree alias_off
= NULL_TREE
;
1433 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1435 tree alias_type
= NULL_TREE
;
1436 /* Optional alias-type cast. */
1437 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
1439 c_parser_consume_token (parser
);
1440 struct c_type_name
*alias_type_name
1441 = c_parser_type_name (parser
);
1442 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1444 if (alias_type_name
)
1447 alias_type
= groktypename (alias_type_name
,
1451 ptr
= c_parser_gimple_unary_expression (parser
);
1452 if (ptr
.value
== error_mark_node
1453 || ! POINTER_TYPE_P (TREE_TYPE (ptr
.value
)))
1455 if (ptr
.value
!= error_mark_node
)
1456 error_at (ptr
.get_start (),
1457 "invalid type of %<__MEM%> operand");
1458 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1463 alias_type
= TREE_TYPE (ptr
.value
);
1464 /* Optional constant offset. */
1465 if (c_parser_next_token_is (parser
, CPP_PLUS
))
1467 c_parser_consume_token (parser
);
1469 = c_parser_gimple_postfix_expression (parser
).value
;
1470 alias_off
= fold_convert (alias_type
, alias_off
);
1473 alias_off
= build_int_cst (alias_type
, 0);
1474 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1477 if (! type
|| c_parser_error (parser
))
1479 c_parser_set_error (parser
, false);
1482 expr
.value
= build2_loc (loc
, MEM_REF
,
1483 type
, ptr
.value
, alias_off
);
1486 else if (strcmp (IDENTIFIER_POINTER (id
), "__VIEW_CONVERT") == 0)
1488 /* __VIEW_CONVERT '<' type-name [ ',' number ] '>'
1489 '(' postfix-expression ')' */
1490 location_t loc
= c_parser_peek_token (parser
)->location
;
1491 c_parser_consume_token (parser
);
1492 tree type
= c_parser_gimple_typespec (parser
);
1493 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1495 c_expr op
= c_parser_gimple_postfix_expression (parser
);
1496 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1498 if (type
&& op
.value
!= error_mark_node
)
1499 expr
.value
= build1_loc (loc
, VIEW_CONVERT_EXPR
,
1504 else if (strcmp (IDENTIFIER_POINTER (id
), "__BIT_FIELD_REF") == 0)
1506 /* __BIT_FIELD_REF '<' type-name [ ',' number ] '>'
1507 '(' postfix-expression, integer, integer ')' */
1508 location_t loc
= c_parser_peek_token (parser
)->location
;
1509 c_parser_consume_token (parser
);
1510 tree type
= c_parser_gimple_typespec (parser
);
1511 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1513 c_expr op0
= c_parser_gimple_postfix_expression (parser
);
1514 c_parser_skip_until_found (parser
, CPP_COMMA
,
1516 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1517 if (TREE_CODE (op1
.value
) != INTEGER_CST
1518 || !int_fits_type_p (op1
.value
, bitsizetype
))
1519 c_parser_error (parser
, "expected constant size");
1520 c_parser_skip_until_found (parser
, CPP_COMMA
,
1522 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1523 if (TREE_CODE (op2
.value
) != INTEGER_CST
1524 || !int_fits_type_p (op2
.value
, bitsizetype
))
1525 c_parser_error (parser
, "expected constant offset");
1526 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1529 && op0
.value
!= error_mark_node
1530 && TREE_CODE (op1
.value
) == INTEGER_CST
1531 && TREE_CODE (op2
.value
) == INTEGER_CST
)
1532 expr
.value
= build3_loc (loc
, BIT_FIELD_REF
, type
,
1534 fold_convert (bitsizetype
,
1536 fold_convert (bitsizetype
,
1541 else if (strcmp (IDENTIFIER_POINTER (id
), "_Literal") == 0)
1543 /* _Literal '(' type-name ')' ( [ '-' ] constant | constructor ) */
1544 c_parser_consume_token (parser
);
1545 tree type
= NULL_TREE
;
1546 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1548 struct c_type_name
*type_name
= c_parser_type_name (parser
);
1551 type
= groktypename (type_name
, &tem
, NULL
);
1552 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1557 c_parser_error (parser
, "invalid _Literal");
1560 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1562 c_parser_consume_token (parser
);
1563 if (!AGGREGATE_TYPE_P (type
)
1564 && !VECTOR_TYPE_P (type
))
1566 c_parser_error (parser
, "invalid type for _Literal with "
1568 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
1572 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1573 bool constant_p
= true;
1574 if (VECTOR_TYPE_P (type
)
1575 && !c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1577 vec_alloc (v
, TYPE_VECTOR_SUBPARTS (type
).to_constant ());
1581 = c_parser_gimple_postfix_expression (parser
).value
;
1583 || val
== error_mark_node
1584 || (! CONSTANT_CLASS_P (val
)
1585 && ! SSA_VAR_P (val
)))
1587 c_parser_error (parser
, "invalid _Literal");
1590 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, val
);
1591 if (! CONSTANT_CLASS_P (val
))
1593 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1594 c_parser_consume_token (parser
);
1600 if (c_parser_require (parser
, CPP_CLOSE_BRACE
,
1603 if (v
&& constant_p
)
1604 expr
.value
= build_vector_from_ctor (type
, v
);
1606 expr
.value
= build_constructor (type
, v
);
1610 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
1618 if ((neg_p
= c_parser_next_token_is (parser
, CPP_MINUS
)))
1619 c_parser_consume_token (parser
);
1620 if ((addr_p
= c_parser_next_token_is (parser
, CPP_AND
)))
1621 c_parser_consume_token (parser
);
1622 tree val
= c_parser_gimple_postfix_expression (parser
).value
;
1624 || val
== error_mark_node
1625 || (!CONSTANT_CLASS_P (val
) && !addr_p
))
1627 c_parser_error (parser
, "invalid _Literal");
1632 val
= build1 (ADDR_EXPR
, type
, val
);
1633 if (!is_gimple_invariant_address (val
))
1635 c_parser_error (parser
, "invalid _Literal");
1641 val
= const_unop (NEGATE_EXPR
, TREE_TYPE (val
), val
);
1644 c_parser_error (parser
, "invalid _Literal");
1648 expr
.value
= fold_convert (type
, val
);
1654 unsigned version
, ver_offset
;
1655 if (! lookup_name (id
)
1656 && c_parser_parse_ssa_name_id (id
, &version
, &ver_offset
))
1658 c_parser_consume_token (parser
);
1659 expr
.value
= c_parser_parse_ssa_name (parser
, id
, NULL_TREE
,
1660 version
, ver_offset
);
1661 if (expr
.value
== error_mark_node
)
1663 set_c_expr_source_range (&expr
, tok_range
);
1664 /* For default definition SSA names. */
1665 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
1666 && c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
1669 (c_parser_peek_2nd_token (parser
)->value
)) == 0
1670 && c_parser_peek_nth_token (parser
, 3)->type
== CPP_CLOSE_PAREN
)
1672 c_parser_consume_token (parser
);
1673 c_parser_consume_token (parser
);
1674 c_parser_consume_token (parser
);
1675 if (! SSA_NAME_IS_DEFAULT_DEF (expr
.value
))
1677 if (!SSA_NAME_VAR (expr
.value
))
1679 error_at (loc
, "anonymous SSA name cannot have"
1680 " default definition");
1681 expr
.value
= error_mark_node
;
1684 set_ssa_default_def (cfun
, SSA_NAME_VAR (expr
.value
),
1686 SSA_NAME_DEF_STMT (expr
.value
) = gimple_build_nop ();
1692 c_parser_consume_token (parser
);
1694 = build_external_ref (loc
, id
,
1695 (c_parser_peek_token (parser
)->type
1696 == CPP_OPEN_PAREN
), &expr
.original_type
);
1697 set_c_expr_source_range (&expr
, tok_range
);
1703 c_parser_error (parser
, "expected expression");
1707 if (expr
.value
== error_mark_node
)
1709 return c_parser_gimple_postfix_expression_after_primary
1710 (parser
, EXPR_LOC_OR_LOC (expr
.value
, loc
), expr
);
1713 /* Parse a gimple postfix expression after the initial primary or compound
1716 static struct c_expr
1717 c_parser_gimple_postfix_expression_after_primary (gimple_parser
&parser
,
1718 location_t expr_loc
,
1724 location_t comp_loc
;
1728 location_t op_loc
= c_parser_peek_token (parser
)->location
;
1729 switch (c_parser_peek_token (parser
)->type
)
1731 case CPP_OPEN_SQUARE
:
1733 c_parser_consume_token (parser
);
1734 tree idx
= c_parser_gimple_unary_expression (parser
).value
;
1736 if (! c_parser_require (parser
, CPP_CLOSE_SQUARE
, "expected %<]%>"))
1738 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
1742 start
= expr
.get_start ();
1743 finish
= c_parser_tokens_buf (parser
, 0)->location
;
1744 expr
.value
= build_array_ref (op_loc
, expr
.value
, idx
);
1745 set_c_expr_source_range (&expr
, start
, finish
);
1747 expr
.original_code
= ERROR_MARK
;
1748 expr
.original_type
= NULL
;
1751 case CPP_OPEN_PAREN
:
1753 /* Function call. */
1754 c_parser_consume_token (parser
);
1755 auto_vec
<tree
> exprlist
;
1756 if (! c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
1757 c_parser_gimple_expr_list (parser
, &exprlist
);
1758 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1760 if (!FUNC_OR_METHOD_TYPE_P (TREE_TYPE (expr
.value
)))
1762 c_parser_error (parser
, "invalid call to non-function");
1766 expr
.value
= build_call_array_loc
1767 (expr_loc
, TREE_TYPE (TREE_TYPE (expr
.value
)),
1768 expr
.value
, exprlist
.length (), exprlist
.address ());
1769 expr
.original_code
= ERROR_MARK
;
1770 expr
.original_type
= NULL
;
1775 /* Structure element reference. */
1776 c_parser_consume_token (parser
);
1777 if (c_parser_next_token_is (parser
, CPP_NAME
))
1779 c_token
*comp_tok
= c_parser_peek_token (parser
);
1780 ident
= comp_tok
->value
;
1781 comp_loc
= comp_tok
->location
;
1785 c_parser_error (parser
, "expected identifier");
1787 expr
.original_code
= ERROR_MARK
;
1788 expr
.original_type
= NULL
;
1791 start
= expr
.get_start ();
1792 finish
= c_parser_peek_token (parser
)->get_finish ();
1793 c_parser_consume_token (parser
);
1794 expr
.value
= build_component_ref (op_loc
, expr
.value
, ident
,
1796 set_c_expr_source_range (&expr
, start
, finish
);
1797 expr
.original_code
= ERROR_MARK
;
1798 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1799 expr
.original_type
= NULL
;
1802 /* Remember the original type of a bitfield. */
1803 tree field
= TREE_OPERAND (expr
.value
, 1);
1804 if (TREE_CODE (field
) != FIELD_DECL
)
1805 expr
.original_type
= NULL
;
1807 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1813 /* Structure element reference. */
1814 if (!POINTER_TYPE_P (TREE_TYPE (expr
.value
)))
1816 c_parser_error (parser
, "dereference of non-pointer");
1818 expr
.original_code
= ERROR_MARK
;
1819 expr
.original_type
= NULL
;
1822 c_parser_consume_token (parser
);
1823 if (c_parser_next_token_is (parser
, CPP_NAME
))
1825 c_token
*comp_tok
= c_parser_peek_token (parser
);
1826 ident
= comp_tok
->value
;
1827 comp_loc
= comp_tok
->location
;
1831 c_parser_error (parser
, "expected identifier");
1833 expr
.original_code
= ERROR_MARK
;
1834 expr
.original_type
= NULL
;
1837 start
= expr
.get_start ();
1838 finish
= c_parser_peek_token (parser
)->get_finish ();
1839 c_parser_consume_token (parser
);
1840 expr
.value
= build_component_ref (op_loc
,
1841 build_simple_mem_ref_loc
1842 (op_loc
, expr
.value
),
1844 set_c_expr_source_range (&expr
, start
, finish
);
1845 expr
.original_code
= ERROR_MARK
;
1846 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1847 expr
.original_type
= NULL
;
1850 /* Remember the original type of a bitfield. */
1851 tree field
= TREE_OPERAND (expr
.value
, 1);
1852 if (TREE_CODE (field
) != FIELD_DECL
)
1853 expr
.original_type
= NULL
;
1855 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1865 /* Parse expression list.
1868 gimple-unary-expression
1869 gimple-expr-list , gimple-unary-expression
1874 c_parser_gimple_expr_list (gimple_parser
&parser
, vec
<tree
> *ret
)
1878 expr
= c_parser_gimple_unary_expression (parser
);
1879 ret
->safe_push (expr
.value
);
1880 while (c_parser_next_token_is (parser
, CPP_COMMA
))
1882 c_parser_consume_token (parser
);
1883 expr
= c_parser_gimple_unary_expression (parser
);
1884 ret
->safe_push (expr
.value
);
1888 /* Parse gimple label.
1892 case constant-expression :
1898 c_parser_gimple_label (gimple_parser
&parser
, gimple_seq
*seq
)
1900 tree name
= c_parser_peek_token (parser
)->value
;
1901 location_t loc1
= c_parser_peek_token (parser
)->location
;
1902 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
1903 c_parser_consume_token (parser
);
1904 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
1905 c_parser_consume_token (parser
);
1906 tree label
= define_label (loc1
, name
);
1908 gimple_seq_add_stmt_without_update (seq
, gimple_build_label (label
));
1912 /* Parse gimple/RTL pass list.
1914 gimple-or-rtl-pass-list:
1915 startwith("pass-name")[,{cfg,ssa}]
1919 c_parser_gimple_or_rtl_pass_list (c_parser
*parser
, c_declspecs
*specs
)
1923 /* Accept __GIMPLE/__RTL. */
1924 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
1926 c_parser_consume_token (parser
);
1928 specs
->entry_bb_count
= profile_count::uninitialized ();
1929 while (c_parser_next_token_is (parser
, CPP_NAME
))
1931 profile_quality quality
;
1932 const char *op
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
1933 c_parser_consume_token (parser
);
1934 if (! strcmp (op
, "startwith"))
1936 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1938 if (c_parser_next_token_is_not (parser
, CPP_STRING
))
1940 error_at (c_parser_peek_token (parser
)->location
,
1941 "expected pass name");
1944 pass
= xstrdup (TREE_STRING_POINTER
1945 (c_parser_string_literal (parser
, false,
1947 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<(%>"))
1950 else if (parse_profile_quality (op
, &quality
))
1953 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1956 if (!c_parser_next_token_is (parser
, CPP_NUMBER
)
1957 || (TREE_CODE (q
= c_parser_peek_token (parser
)->value
)
1960 c_parser_error (parser
, "expected count value");
1964 specs
->entry_bb_count
1965 = profile_count::from_gcov_type (TREE_INT_CST_LOW (q
), quality
);
1966 c_parser_consume_token (parser
);
1967 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1970 else if (specs
->declspec_il
!= cdil_gimple
)
1971 /* Allow only one IL specifier and none on RTL. */
1973 else if (! strcmp (op
, "cfg"))
1974 specs
->declspec_il
= cdil_gimple_cfg
;
1975 else if (! strcmp (op
, "ssa"))
1976 specs
->declspec_il
= cdil_gimple_ssa
;
1979 error_at (c_parser_peek_token (parser
)->location
,
1980 "invalid operation");
1983 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1984 c_parser_consume_token (parser
);
1987 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1990 specs
->gimple_or_rtl_pass
= pass
;
1993 /* Parse gimple local declaration.
1995 declaration-specifiers:
1996 storage-class-specifier declaration-specifiers[opt]
1997 type-specifier declaration-specifiers[opt]
1998 type-qualifier declaration-specifiers[opt]
1999 function-specifier declaration-specifiers[opt]
2000 alignment-specifier declaration-specifiers[opt]
2002 storage-class-specifier:
2026 address-space-qualifier
2032 c_parser_gimple_declaration (gimple_parser
&parser
)
2034 struct c_declarator
*declarator
;
2035 struct c_declspecs
*specs
= build_null_declspecs ();
2036 c_parser_declspecs (parser
, specs
, true, true, true,
2037 true, true, true, true, cla_nonabstract_decl
);
2038 finish_declspecs (specs
);
2040 /* Provide better error recovery. Note that a type name here is usually
2041 better diagnosed as a redeclaration. */
2042 if (c_parser_next_token_starts_declspecs (parser
)
2043 && ! c_parser_next_token_is (parser
, CPP_NAME
))
2045 c_parser_error (parser
, "expected %<;%>");
2046 c_parser_set_error (parser
, false);
2051 declarator
= c_parser_declarator (parser
,
2052 specs
->typespec_kind
!= ctsk_none
,
2053 C_DTR_NORMAL
, &dummy
);
2055 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2057 /* Handle SSA name decls specially, they do not go into the identifier
2058 table but we simply build the SSA name for later lookup. */
2059 unsigned version
, ver_offset
;
2060 if (declarator
->kind
== cdk_id
2061 && is_gimple_reg_type (specs
->type
)
2062 && c_parser_parse_ssa_name_id (declarator
->u
.id
.id
,
2063 &version
, &ver_offset
)
2064 /* The following restricts it to unnamed anonymous SSA names
2065 which fails parsing of named ones in dumps (we could
2066 decide to not dump their name for -gimple). */
2068 c_parser_parse_ssa_name (parser
, declarator
->u
.id
.id
, specs
->type
,
2069 version
, ver_offset
);
2072 tree postfix_attrs
= NULL_TREE
;
2073 tree all_prefix_attrs
= specs
->attrs
;
2074 specs
->attrs
= NULL
;
2075 tree decl
= start_decl (declarator
, specs
, false,
2076 chainon (postfix_attrs
, all_prefix_attrs
));
2078 finish_decl (decl
, UNKNOWN_LOCATION
, NULL_TREE
, NULL_TREE
,
2084 c_parser_error (parser
, "expected %<;%>");
2089 /* Parse gimple goto statement. */
2092 c_parser_gimple_goto_stmt (gimple_parser
&parser
,
2093 location_t loc
, tree label
, gimple_seq
*seq
)
2095 if (cfun
->curr_properties
& PROP_cfg
)
2098 profile_probability prob
;
2099 if (c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2100 &dest_index
, &prob
))
2102 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2103 EDGE_FALLTHRU
, prob
);
2107 tree decl
= lookup_label_for_goto (loc
, label
);
2108 gimple_seq_add_stmt_without_update (seq
, gimple_build_goto (decl
));
2111 /* Parse a parenthesized condition.
2113 ( gimple-binary-expression ) */
2116 c_parser_gimple_paren_condition (gimple_parser
&parser
)
2118 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2119 return error_mark_node
;
2120 tree cond
= c_parser_gimple_binary_expression (parser
).value
;
2121 if (cond
!= error_mark_node
2122 && ! COMPARISON_CLASS_P (cond
)
2123 && ! CONSTANT_CLASS_P (cond
)
2124 && ! SSA_VAR_P (cond
))
2126 c_parser_error (parser
, "comparison required");
2127 cond
= error_mark_node
;
2129 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2130 return error_mark_node
;
2134 /* Parse gimple try statement.
2137 try { ... } finally { ... }
2138 try { ... } finally { ... } else { ... }
2140 This could support try/catch as well, but it's not implemented yet.
2144 c_parser_gimple_try_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2146 gimple_seq tryseq
= NULL
;
2147 c_parser_consume_token (parser
);
2148 c_parser_gimple_compound_statement (parser
, &tryseq
);
2150 if ((c_parser_next_token_is (parser
, CPP_KEYWORD
)
2151 && c_parser_peek_token (parser
)->keyword
== RID_AT_FINALLY
)
2152 || (c_parser_next_token_is (parser
, CPP_NAME
)
2153 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
2154 && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
),
2157 gimple_seq finseq
= NULL
;
2158 c_parser_consume_token (parser
);
2159 c_parser_gimple_compound_statement (parser
, &finseq
);
2161 if (c_parser_next_token_is (parser
, CPP_KEYWORD
)
2162 && c_parser_peek_token (parser
)->keyword
== RID_ELSE
)
2164 gimple_seq elsseq
= NULL
;
2165 c_parser_consume_token (parser
);
2166 c_parser_gimple_compound_statement (parser
, &elsseq
);
2168 geh_else
*stmt
= gimple_build_eh_else (finseq
, elsseq
);
2170 gimple_seq_add_stmt_without_update (&finseq
, stmt
);
2173 gtry
*stmt
= gimple_build_try (tryseq
, finseq
, GIMPLE_TRY_FINALLY
);
2174 gimple_seq_add_stmt_without_update (seq
, stmt
);
2176 else if (c_parser_next_token_is (parser
, CPP_KEYWORD
)
2177 && c_parser_peek_token (parser
)->keyword
== RID_AT_CATCH
)
2178 c_parser_error (parser
, "%<catch%> is not supported");
2180 c_parser_error (parser
, "expected %<finally%> or %<catch%>");
2183 /* Parse gimple if-else statement.
2186 if ( gimple-binary-expression ) gimple-goto-statement
2187 if ( gimple-binary-expression ) gimple-goto-statement \
2188 else gimple-goto-statement
2192 c_parser_gimple_if_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2194 tree t_label
= NULL_TREE
, f_label
= NULL_TREE
, label
;
2196 c_parser_consume_token (parser
);
2197 tree cond
= c_parser_gimple_paren_condition (parser
);
2199 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
2201 loc
= c_parser_peek_token (parser
)->location
;
2202 c_parser_consume_token (parser
);
2203 if (! c_parser_next_token_is (parser
, CPP_NAME
))
2205 c_parser_error (parser
, "expected label");
2208 label
= c_parser_peek_token (parser
)->value
;
2209 c_parser_consume_token (parser
);
2211 profile_probability prob
;
2212 if ((cfun
->curr_properties
& PROP_cfg
)
2213 && c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2214 &dest_index
, &prob
))
2215 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2216 EDGE_TRUE_VALUE
, prob
);
2218 t_label
= lookup_label_for_goto (loc
, label
);
2219 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
2224 c_parser_error (parser
, "expected goto expression");
2228 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
2229 c_parser_consume_token (parser
);
2232 c_parser_error (parser
, "expected else statement");
2236 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
2238 loc
= c_parser_peek_token (parser
)->location
;
2239 c_parser_consume_token (parser
);
2240 if (! c_parser_next_token_is (parser
, CPP_NAME
))
2242 c_parser_error (parser
, "expected label");
2245 label
= c_parser_peek_token (parser
)->value
;
2246 c_parser_consume_token (parser
);
2248 profile_probability prob
;
2249 if ((cfun
->curr_properties
& PROP_cfg
)
2250 && c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2251 &dest_index
, &prob
))
2252 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2253 EDGE_FALSE_VALUE
, prob
);
2255 f_label
= lookup_label_for_goto (loc
, label
);
2256 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
2261 c_parser_error (parser
, "expected goto expression");
2265 if (cond
!= error_mark_node
)
2266 gimple_seq_add_stmt_without_update (seq
, gimple_build_cond_from_tree (cond
, t_label
,
2270 /* Parse gimple switch-statement.
2272 gimple-switch-statement:
2273 switch (gimple-postfix-expression) gimple-case-statement
2275 gimple-case-statement:
2276 gimple-case-statement
2277 gimple-label-statement : gimple-goto-statment
2281 c_parser_gimple_switch_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2284 tree case_label
, label
;
2285 auto_vec
<tree
> labels
;
2286 tree default_label
= NULL_TREE
;
2287 c_parser_consume_token (parser
);
2289 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2291 cond_expr
= c_parser_gimple_postfix_expression (parser
);
2292 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2295 if (! c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
2298 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
2300 if (c_parser_next_token_is (parser
, CPP_EOF
))
2302 c_parser_error (parser
, "expected statement");
2306 switch (c_parser_peek_token (parser
)->keyword
)
2311 location_t loc
= c_parser_peek_token (parser
)->location
;
2312 c_parser_consume_token (parser
);
2314 if (c_parser_next_token_is (parser
, CPP_NAME
)
2315 || c_parser_peek_token (parser
)->type
== CPP_NUMBER
)
2316 exp1
= c_parser_gimple_postfix_expression (parser
);
2319 c_parser_error (parser
, "expected expression");
2323 if (c_parser_next_token_is (parser
, CPP_COLON
))
2325 c_parser_consume_token (parser
);
2326 if (c_parser_next_token_is (parser
, CPP_NAME
))
2328 label
= c_parser_peek_token (parser
)->value
;
2329 c_parser_consume_token (parser
);
2330 tree decl
= lookup_label_for_goto (loc
, label
);
2331 case_label
= build_case_label (exp1
.value
, NULL_TREE
,
2333 labels
.safe_push (case_label
);
2334 if (! c_parser_require (parser
, CPP_SEMICOLON
,
2338 else if (! c_parser_require (parser
, CPP_NAME
,
2342 else if (! c_parser_require (parser
, CPP_SEMICOLON
,
2349 location_t loc
= c_parser_peek_token (parser
)->location
;
2350 c_parser_consume_token (parser
);
2351 if (c_parser_next_token_is (parser
, CPP_COLON
))
2353 c_parser_consume_token (parser
);
2354 if (c_parser_next_token_is (parser
, CPP_NAME
))
2356 label
= c_parser_peek_token (parser
)->value
;
2357 c_parser_consume_token (parser
);
2358 tree decl
= lookup_label_for_goto (loc
, label
);
2359 default_label
= build_case_label (NULL_TREE
, NULL_TREE
,
2361 if (! c_parser_require (parser
, CPP_SEMICOLON
,
2365 else if (! c_parser_require (parser
, CPP_NAME
,
2369 else if (! c_parser_require (parser
, CPP_SEMICOLON
,
2375 c_parser_error (parser
, "expected case label");
2380 if (! c_parser_require (parser
, CPP_CLOSE_BRACE
, "expected %<}%>"))
2383 if (cond_expr
.value
!= error_mark_node
)
2385 gswitch
*s
= gimple_build_switch (cond_expr
.value
, default_label
, labels
);
2386 gimple_seq_add_stmt_without_update (seq
, s
);
2390 /* Parse gimple return statement. */
2393 c_parser_gimple_return_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2395 location_t loc
= c_parser_peek_token (parser
)->location
;
2397 c_parser_consume_token (parser
);
2398 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2400 c_finish_gimple_return (loc
, NULL_TREE
);
2401 ret
= gimple_build_return (NULL
);
2402 gimple_seq_add_stmt_without_update (seq
, ret
);
2406 location_t xloc
= c_parser_peek_token (parser
)->location
;
2407 c_expr expr
= c_parser_gimple_unary_expression (parser
);
2408 if (expr
.value
!= error_mark_node
)
2410 c_finish_gimple_return (xloc
, expr
.value
);
2411 ret
= gimple_build_return (expr
.value
);
2412 gimple_seq_add_stmt_without_update (seq
, ret
);
2417 /* Support function for c_parser_gimple_return_stmt. */
2420 c_finish_gimple_return (location_t loc
, tree retval
)
2422 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
2424 /* Use the expansion point to handle cases such as returning NULL
2425 in a function returning void. */
2426 location_t xloc
= expansion_point_location_if_in_system_header (loc
);
2428 if (TREE_THIS_VOLATILE (current_function_decl
))
2429 warning_at (xloc
, 0,
2430 "function declared %<noreturn%> has a %<return%> statement");
2433 current_function_returns_null
= 1;
2434 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
2436 current_function_returns_null
= 1;
2437 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
2440 (xloc
, "%<return%> with a value, in function returning void");
2441 inform (DECL_SOURCE_LOCATION (current_function_decl
),
2445 else if (TREE_CODE (valtype
) != TREE_CODE (TREE_TYPE (retval
)))
2448 (xloc
, "invalid conversion in return statement");
2449 inform (DECL_SOURCE_LOCATION (current_function_decl
),