2 Copyright (C) 2016-2019 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"
69 /* GIMPLE parser state. */
74 gimple_parser (c_parser
*p
) : parser (p
), edges(), current_bb(NULL
) {}
75 /* c_parser is not visible here, use composition and fake inheritance
76 via a conversion operator. */
77 operator c_parser
*() { return parser
; }
80 /* CFG build state. */
81 class gimple_parser_edge
87 profile_probability probability
;
89 auto_vec
<gimple_parser_edge
> edges
;
90 basic_block current_bb
;
92 void push_edge (int, int, int, profile_probability
);
96 gimple_parser::push_edge (int src
, int dest
, int flags
,
97 profile_probability prob
)
103 e
.probability
= prob
;
108 /* Gimple parsing functions. */
109 static bool c_parser_gimple_compound_statement (gimple_parser
&, gimple_seq
*);
110 static void c_parser_gimple_label (gimple_parser
&, gimple_seq
*);
111 static void c_parser_gimple_statement (gimple_parser
&, gimple_seq
*);
112 static struct c_expr
c_parser_gimple_binary_expression (gimple_parser
&);
113 static struct c_expr
c_parser_gimple_unary_expression (gimple_parser
&);
114 static struct c_expr
c_parser_gimple_postfix_expression (gimple_parser
&);
115 static struct c_expr c_parser_gimple_postfix_expression_after_primary
116 (gimple_parser
&, location_t
, struct c_expr
);
117 static void c_parser_gimple_declaration (gimple_parser
&);
118 static void c_parser_gimple_goto_stmt (gimple_parser
&, location_t
,
120 static void c_parser_gimple_try_stmt (gimple_parser
&, gimple_seq
*);
121 static void c_parser_gimple_if_stmt (gimple_parser
&, gimple_seq
*);
122 static void c_parser_gimple_switch_stmt (gimple_parser
&, gimple_seq
*);
123 static void c_parser_gimple_return_stmt (gimple_parser
&, gimple_seq
*);
124 static void c_finish_gimple_return (location_t
, tree
);
125 static tree
c_parser_gimple_paren_condition (gimple_parser
&);
126 static void c_parser_gimple_expr_list (gimple_parser
&, vec
<tree
> *);
129 /* See if VAL is an identifier matching __BB<num> and return <num>
133 c_parser_gimple_parse_bb_spec (tree val
, int *index
)
135 if (strncmp (IDENTIFIER_POINTER (val
), "__BB", 4) != 0)
137 for (const char *p
= IDENTIFIER_POINTER (val
) + 4; *p
; ++p
)
140 *index
= atoi (IDENTIFIER_POINTER (val
) + 4);
144 /* See if VAL is an identifier matching __BB<num> and return <num>
145 in *INDEX. Return true if so and parse also FREQUENCY of
150 c_parser_gimple_parse_bb_spec_edge_probability (tree val
,
151 gimple_parser
&parser
,
153 profile_probability
*probablity
)
155 bool return_p
= c_parser_gimple_parse_bb_spec (val
, index
);
158 *probablity
= 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 *probablity
= 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
, false);
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);
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 if (VECTOR_TYPE_P (TREE_TYPE (parent
))
1276 || TREE_CODE (TREE_TYPE (parent
)) == COMPLEX_TYPE
)
1277 DECL_GIMPLE_REG_P (parent
) = 1;
1278 name
= make_ssa_name_fn (cfun
, parent
,
1279 gimple_build_nop (), version
);
1286 /* Parse a gimple call to an internal function.
1288 gimple-call-internal:
1289 . identifier ( gimple-argument-expression-list[opt] ) */
1291 static struct c_expr
1292 c_parser_gimple_call_internal (gimple_parser
&parser
)
1297 gcc_assert (c_parser_next_token_is (parser
, CPP_DOT
));
1298 c_parser_consume_token (parser
);
1299 location_t loc
= c_parser_peek_token (parser
)->location
;
1300 if (!c_parser_next_token_is (parser
, CPP_NAME
)
1301 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
1303 c_parser_error (parser
, "expecting internal function name");
1306 tree id
= c_parser_peek_token (parser
)->value
;
1307 internal_fn ifn
= lookup_internal_fn (IDENTIFIER_POINTER (id
));
1308 c_parser_consume_token (parser
);
1309 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1311 auto_vec
<tree
> exprlist
;
1312 if (!c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
1313 c_parser_gimple_expr_list (parser
, &exprlist
);
1314 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
1315 if (ifn
== IFN_LAST
)
1316 error_at (loc
, "unknown internal function %qE", id
);
1319 expr
.value
= build_call_expr_internal_loc_array
1320 (loc
, ifn
, void_type_node
, exprlist
.length (),
1321 exprlist
.address ());
1322 expr
.original_code
= ERROR_MARK
;
1323 expr
.original_type
= NULL
;
1329 /* Parse '<' type [',' alignment] '>' and return a type on success
1330 and NULL_TREE on error. */
1333 c_parser_gimple_typespec (gimple_parser
&parser
)
1335 struct c_type_name
*type_name
= NULL
;
1336 tree alignment
= NULL_TREE
;
1337 if (c_parser_require (parser
, CPP_LESS
, "expected %<<%>"))
1339 type_name
= c_parser_type_name (parser
);
1340 /* Optional alignment. */
1341 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1343 c_parser_consume_token (parser
);
1345 = c_parser_gimple_postfix_expression (parser
).value
;
1347 c_parser_skip_until_found (parser
,
1348 CPP_GREATER
, "expected %<>%>");
1353 tree type
= groktypename (type_name
, &tem
, NULL
);
1355 type
= build_aligned_type (type
, tree_to_uhwi (alignment
));
1359 /* Parse gimple postfix expression.
1361 gimple-postfix-expression:
1362 gimple-primary-expression
1363 gimple-primary-expression [ gimple-primary-expression ]
1364 gimple-primary-expression ( gimple-argument-expression-list[opt] )
1365 gimple-postfix-expression . identifier
1366 gimple-postfix-expression -> identifier
1368 gimple-argument-expression-list:
1369 gimple-unary-expression
1370 gimple-argument-expression-list , gimple-unary-expression
1372 gimple-primary-expression:
1377 gimple-call-internal
1381 static struct c_expr
1382 c_parser_gimple_postfix_expression (gimple_parser
&parser
)
1384 location_t loc
= c_parser_peek_token (parser
)->location
;
1385 source_range tok_range
= c_parser_peek_token (parser
)->get_range ();
1388 switch (c_parser_peek_token (parser
)->type
)
1391 expr
.value
= c_parser_peek_token (parser
)->value
;
1392 set_c_expr_source_range (&expr
, tok_range
);
1393 loc
= c_parser_peek_token (parser
)->location
;
1394 c_parser_consume_token (parser
);
1400 expr
.value
= c_parser_peek_token (parser
)->value
;
1401 set_c_expr_source_range (&expr
, tok_range
);
1402 c_parser_consume_token (parser
);
1408 case CPP_UTF8STRING
:
1409 expr
= c_parser_string_literal (parser
, false, true);
1412 expr
= c_parser_gimple_call_internal (parser
);
1415 if (c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
1417 tree id
= c_parser_peek_token (parser
)->value
;
1418 if (strcmp (IDENTIFIER_POINTER (id
), "__MEM") == 0)
1420 /* __MEM '<' type-name [ ',' number ] '>'
1421 '(' [ '(' type-name ')' ] unary-expression
1422 [ '+' number ] ')' */
1423 location_t loc
= c_parser_peek_token (parser
)->location
;
1424 c_parser_consume_token (parser
);
1425 tree type
= c_parser_gimple_typespec (parser
);
1427 ptr
.value
= error_mark_node
;
1428 tree alias_off
= NULL_TREE
;
1429 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1431 tree alias_type
= NULL_TREE
;
1432 /* Optional alias-type cast. */
1433 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
1435 c_parser_consume_token (parser
);
1436 struct c_type_name
*alias_type_name
1437 = c_parser_type_name (parser
);
1438 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1440 if (alias_type_name
)
1443 alias_type
= groktypename (alias_type_name
,
1447 ptr
= c_parser_gimple_unary_expression (parser
);
1448 if (ptr
.value
== error_mark_node
1449 || ! POINTER_TYPE_P (TREE_TYPE (ptr
.value
)))
1451 if (ptr
.value
!= error_mark_node
)
1452 error_at (ptr
.get_start (),
1453 "invalid type of %<__MEM%> operand");
1454 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1459 alias_type
= TREE_TYPE (ptr
.value
);
1460 /* Optional constant offset. */
1461 if (c_parser_next_token_is (parser
, CPP_PLUS
))
1463 c_parser_consume_token (parser
);
1465 = c_parser_gimple_postfix_expression (parser
).value
;
1466 alias_off
= fold_convert (alias_type
, alias_off
);
1469 alias_off
= build_int_cst (alias_type
, 0);
1470 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1473 if (! type
|| c_parser_error (parser
))
1475 c_parser_set_error (parser
, false);
1478 expr
.value
= build2_loc (loc
, MEM_REF
,
1479 type
, ptr
.value
, alias_off
);
1482 else if (strcmp (IDENTIFIER_POINTER (id
), "__VIEW_CONVERT") == 0)
1484 /* __VIEW_CONVERT '<' type-name [ ',' number ] '>'
1485 '(' postfix-expression ')' */
1486 location_t loc
= c_parser_peek_token (parser
)->location
;
1487 c_parser_consume_token (parser
);
1488 tree type
= c_parser_gimple_typespec (parser
);
1489 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1491 c_expr op
= c_parser_gimple_postfix_expression (parser
);
1492 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1494 if (type
&& op
.value
!= error_mark_node
)
1495 expr
.value
= build1_loc (loc
, VIEW_CONVERT_EXPR
,
1500 else if (strcmp (IDENTIFIER_POINTER (id
), "__BIT_FIELD_REF") == 0)
1502 /* __BIT_FIELD_REF '<' type-name [ ',' number ] '>'
1503 '(' postfix-expression, integer, integer ')' */
1504 location_t loc
= c_parser_peek_token (parser
)->location
;
1505 c_parser_consume_token (parser
);
1506 tree type
= c_parser_gimple_typespec (parser
);
1507 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1509 c_expr op0
= c_parser_gimple_postfix_expression (parser
);
1510 c_parser_skip_until_found (parser
, CPP_COMMA
,
1512 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1513 if (TREE_CODE (op1
.value
) != INTEGER_CST
1514 || !int_fits_type_p (op1
.value
, bitsizetype
))
1515 c_parser_error (parser
, "expected constant size");
1516 c_parser_skip_until_found (parser
, CPP_COMMA
,
1518 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1519 if (TREE_CODE (op2
.value
) != INTEGER_CST
1520 || !int_fits_type_p (op2
.value
, bitsizetype
))
1521 c_parser_error (parser
, "expected constant offset");
1522 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1525 && op0
.value
!= error_mark_node
1526 && TREE_CODE (op1
.value
) == INTEGER_CST
1527 && TREE_CODE (op2
.value
) == INTEGER_CST
)
1528 expr
.value
= build3_loc (loc
, BIT_FIELD_REF
, type
,
1530 fold_convert (bitsizetype
,
1532 fold_convert (bitsizetype
,
1537 else if (strcmp (IDENTIFIER_POINTER (id
), "_Literal") == 0)
1539 /* _Literal '(' type-name ')' ( [ '-' ] constant | constructor ) */
1540 c_parser_consume_token (parser
);
1541 tree type
= NULL_TREE
;
1542 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1544 struct c_type_name
*type_name
= c_parser_type_name (parser
);
1547 type
= groktypename (type_name
, &tem
, NULL
);
1548 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1553 c_parser_error (parser
, "invalid _Literal");
1556 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1558 c_parser_consume_token (parser
);
1559 if (!AGGREGATE_TYPE_P (type
)
1560 && !VECTOR_TYPE_P (type
))
1562 c_parser_error (parser
, "invalid type for _Literal with "
1564 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
1568 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1569 bool constant_p
= true;
1570 if (VECTOR_TYPE_P (type
)
1571 && !c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1573 vec_alloc (v
, TYPE_VECTOR_SUBPARTS (type
).to_constant ());
1577 = c_parser_gimple_postfix_expression (parser
).value
;
1579 || val
== error_mark_node
1580 || (! CONSTANT_CLASS_P (val
)
1581 && ! SSA_VAR_P (val
)))
1583 c_parser_error (parser
, "invalid _Literal");
1586 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, val
);
1587 if (! CONSTANT_CLASS_P (val
))
1589 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1590 c_parser_consume_token (parser
);
1596 if (c_parser_require (parser
, CPP_CLOSE_BRACE
,
1599 if (v
&& constant_p
)
1600 expr
.value
= build_vector_from_ctor (type
, v
);
1602 expr
.value
= build_constructor (type
, v
);
1606 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
1614 if ((neg_p
= c_parser_next_token_is (parser
, CPP_MINUS
)))
1615 c_parser_consume_token (parser
);
1616 if ((addr_p
= c_parser_next_token_is (parser
, CPP_AND
)))
1617 c_parser_consume_token (parser
);
1618 tree val
= c_parser_gimple_postfix_expression (parser
).value
;
1620 || val
== error_mark_node
1621 || (!CONSTANT_CLASS_P (val
)
1623 && (TREE_CODE (val
) == STRING_CST
1626 c_parser_error (parser
, "invalid _Literal");
1630 val
= build1 (ADDR_EXPR
, type
, val
);
1633 val
= const_unop (NEGATE_EXPR
, TREE_TYPE (val
), val
);
1636 c_parser_error (parser
, "invalid _Literal");
1640 expr
.value
= fold_convert (type
, val
);
1646 unsigned version
, ver_offset
;
1647 if (! lookup_name (id
)
1648 && c_parser_parse_ssa_name_id (id
, &version
, &ver_offset
))
1650 c_parser_consume_token (parser
);
1651 expr
.value
= c_parser_parse_ssa_name (parser
, id
, NULL_TREE
,
1652 version
, ver_offset
);
1653 if (expr
.value
== error_mark_node
)
1655 set_c_expr_source_range (&expr
, tok_range
);
1656 /* For default definition SSA names. */
1657 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
1658 && c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
1661 (c_parser_peek_2nd_token (parser
)->value
)) == 0
1662 && c_parser_peek_nth_token (parser
, 3)->type
== CPP_CLOSE_PAREN
)
1664 c_parser_consume_token (parser
);
1665 c_parser_consume_token (parser
);
1666 c_parser_consume_token (parser
);
1667 if (! SSA_NAME_IS_DEFAULT_DEF (expr
.value
))
1669 if (!SSA_NAME_VAR (expr
.value
))
1671 error_at (loc
, "anonymous SSA name cannot have"
1672 " default definition");
1673 expr
.value
= error_mark_node
;
1676 set_ssa_default_def (cfun
, SSA_NAME_VAR (expr
.value
),
1678 SSA_NAME_DEF_STMT (expr
.value
) = gimple_build_nop ();
1684 c_parser_consume_token (parser
);
1686 = build_external_ref (loc
, id
,
1687 (c_parser_peek_token (parser
)->type
1688 == CPP_OPEN_PAREN
), &expr
.original_type
);
1689 set_c_expr_source_range (&expr
, tok_range
);
1695 c_parser_error (parser
, "expected expression");
1701 c_parser_error (parser
, "expected expression");
1705 return c_parser_gimple_postfix_expression_after_primary
1706 (parser
, EXPR_LOC_OR_LOC (expr
.value
, loc
), expr
);
1709 /* Parse a gimple postfix expression after the initial primary or compound
1712 static struct c_expr
1713 c_parser_gimple_postfix_expression_after_primary (gimple_parser
&parser
,
1714 location_t expr_loc
,
1720 location_t comp_loc
;
1724 location_t op_loc
= c_parser_peek_token (parser
)->location
;
1725 switch (c_parser_peek_token (parser
)->type
)
1727 case CPP_OPEN_SQUARE
:
1729 c_parser_consume_token (parser
);
1730 tree idx
= c_parser_gimple_unary_expression (parser
).value
;
1732 if (! c_parser_require (parser
, CPP_CLOSE_SQUARE
, "expected %<]%>"))
1734 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
1738 start
= expr
.get_start ();
1739 finish
= c_parser_tokens_buf (parser
, 0)->location
;
1740 expr
.value
= build_array_ref (op_loc
, expr
.value
, idx
);
1741 set_c_expr_source_range (&expr
, start
, finish
);
1743 expr
.original_code
= ERROR_MARK
;
1744 expr
.original_type
= NULL
;
1747 case CPP_OPEN_PAREN
:
1749 /* Function call. */
1750 c_parser_consume_token (parser
);
1751 auto_vec
<tree
> exprlist
;
1752 if (! c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
1753 c_parser_gimple_expr_list (parser
, &exprlist
);
1754 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1756 expr
.value
= build_call_array_loc
1757 (expr_loc
, TREE_TYPE (TREE_TYPE (expr
.value
)),
1758 expr
.value
, exprlist
.length (), exprlist
.address ());
1759 expr
.original_code
= ERROR_MARK
;
1760 expr
.original_type
= NULL
;
1765 /* Structure element reference. */
1766 c_parser_consume_token (parser
);
1767 if (c_parser_next_token_is (parser
, CPP_NAME
))
1769 c_token
*comp_tok
= c_parser_peek_token (parser
);
1770 ident
= comp_tok
->value
;
1771 comp_loc
= comp_tok
->location
;
1775 c_parser_error (parser
, "expected identifier");
1777 expr
.original_code
= ERROR_MARK
;
1778 expr
.original_type
= NULL
;
1781 start
= expr
.get_start ();
1782 finish
= c_parser_peek_token (parser
)->get_finish ();
1783 c_parser_consume_token (parser
);
1784 expr
.value
= build_component_ref (op_loc
, expr
.value
, ident
,
1786 set_c_expr_source_range (&expr
, start
, finish
);
1787 expr
.original_code
= ERROR_MARK
;
1788 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1789 expr
.original_type
= NULL
;
1792 /* Remember the original type of a bitfield. */
1793 tree field
= TREE_OPERAND (expr
.value
, 1);
1794 if (TREE_CODE (field
) != FIELD_DECL
)
1795 expr
.original_type
= NULL
;
1797 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1803 /* Structure element reference. */
1804 c_parser_consume_token (parser
);
1805 if (c_parser_next_token_is (parser
, CPP_NAME
))
1807 c_token
*comp_tok
= c_parser_peek_token (parser
);
1808 ident
= comp_tok
->value
;
1809 comp_loc
= comp_tok
->location
;
1813 c_parser_error (parser
, "expected identifier");
1815 expr
.original_code
= ERROR_MARK
;
1816 expr
.original_type
= NULL
;
1819 start
= expr
.get_start ();
1820 finish
= c_parser_peek_token (parser
)->get_finish ();
1821 c_parser_consume_token (parser
);
1822 expr
.value
= build_component_ref (op_loc
,
1823 build_simple_mem_ref_loc
1824 (op_loc
, expr
.value
),
1826 set_c_expr_source_range (&expr
, start
, finish
);
1827 expr
.original_code
= ERROR_MARK
;
1828 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1829 expr
.original_type
= NULL
;
1832 /* Remember the original type of a bitfield. */
1833 tree field
= TREE_OPERAND (expr
.value
, 1);
1834 if (TREE_CODE (field
) != FIELD_DECL
)
1835 expr
.original_type
= NULL
;
1837 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1847 /* Parse expression list.
1850 gimple-unary-expression
1851 gimple-expr-list , gimple-unary-expression
1856 c_parser_gimple_expr_list (gimple_parser
&parser
, vec
<tree
> *ret
)
1860 expr
= c_parser_gimple_unary_expression (parser
);
1861 ret
->safe_push (expr
.value
);
1862 while (c_parser_next_token_is (parser
, CPP_COMMA
))
1864 c_parser_consume_token (parser
);
1865 expr
= c_parser_gimple_unary_expression (parser
);
1866 ret
->safe_push (expr
.value
);
1870 /* Parse gimple label.
1874 case constant-expression :
1880 c_parser_gimple_label (gimple_parser
&parser
, gimple_seq
*seq
)
1882 tree name
= c_parser_peek_token (parser
)->value
;
1883 location_t loc1
= c_parser_peek_token (parser
)->location
;
1884 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
1885 c_parser_consume_token (parser
);
1886 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
1887 c_parser_consume_token (parser
);
1888 tree label
= define_label (loc1
, name
);
1889 gimple_seq_add_stmt_without_update (seq
, gimple_build_label (label
));
1893 /* Parse gimple/RTL pass list.
1895 gimple-or-rtl-pass-list:
1896 startwith("pass-name")[,{cfg,ssa}]
1900 c_parser_gimple_or_rtl_pass_list (c_parser
*parser
, c_declspecs
*specs
)
1904 /* Accept __GIMPLE/__RTL. */
1905 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
1907 c_parser_consume_token (parser
);
1909 specs
->entry_bb_count
= profile_count::uninitialized ();
1910 while (c_parser_next_token_is (parser
, CPP_NAME
))
1912 profile_quality quality
;
1913 const char *op
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
1914 c_parser_consume_token (parser
);
1915 if (! strcmp (op
, "startwith"))
1917 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1919 if (c_parser_next_token_is_not (parser
, CPP_STRING
))
1921 error_at (c_parser_peek_token (parser
)->location
,
1922 "expected pass name");
1925 pass
= xstrdup (TREE_STRING_POINTER
1926 (c_parser_string_literal (parser
, false,
1928 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<(%>"))
1931 else if (parse_profile_quality (op
, &quality
))
1934 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1937 if (!c_parser_next_token_is (parser
, CPP_NUMBER
)
1938 || (TREE_CODE (q
= c_parser_peek_token (parser
)->value
)
1941 c_parser_error (parser
, "expected count value");
1945 specs
->entry_bb_count
1946 = profile_count::from_gcov_type (TREE_INT_CST_LOW (q
), quality
);
1947 c_parser_consume_token (parser
);
1948 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1951 else if (specs
->declspec_il
!= cdil_gimple
)
1952 /* Allow only one IL specifier and none on RTL. */
1954 else if (! strcmp (op
, "cfg"))
1955 specs
->declspec_il
= cdil_gimple_cfg
;
1956 else if (! strcmp (op
, "ssa"))
1957 specs
->declspec_il
= cdil_gimple_ssa
;
1960 error_at (c_parser_peek_token (parser
)->location
,
1961 "invalid operation");
1964 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1965 c_parser_consume_token (parser
);
1968 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1971 specs
->gimple_or_rtl_pass
= pass
;
1974 /* Parse gimple local declaration.
1976 declaration-specifiers:
1977 storage-class-specifier declaration-specifiers[opt]
1978 type-specifier declaration-specifiers[opt]
1979 type-qualifier declaration-specifiers[opt]
1980 function-specifier declaration-specifiers[opt]
1981 alignment-specifier declaration-specifiers[opt]
1983 storage-class-specifier:
2007 address-space-qualifier
2013 c_parser_gimple_declaration (gimple_parser
&parser
)
2015 struct c_declarator
*declarator
;
2016 struct c_declspecs
*specs
= build_null_declspecs ();
2017 c_parser_declspecs (parser
, specs
, true, true, true,
2018 true, true, cla_nonabstract_decl
);
2019 finish_declspecs (specs
);
2021 /* Provide better error recovery. Note that a type name here is usually
2022 better diagnosed as a redeclaration. */
2023 if (c_parser_next_token_starts_declspecs (parser
)
2024 && ! c_parser_next_token_is (parser
, CPP_NAME
))
2026 c_parser_error (parser
, "expected %<;%>");
2027 c_parser_set_error (parser
, false);
2032 declarator
= c_parser_declarator (parser
,
2033 specs
->typespec_kind
!= ctsk_none
,
2034 C_DTR_NORMAL
, &dummy
);
2036 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2038 /* Handle SSA name decls specially, they do not go into the identifier
2039 table but we simply build the SSA name for later lookup. */
2040 unsigned version
, ver_offset
;
2041 if (declarator
->kind
== cdk_id
2042 && is_gimple_reg_type (specs
->type
)
2043 && c_parser_parse_ssa_name_id (declarator
->u
.id
,
2044 &version
, &ver_offset
)
2045 /* The following restricts it to unnamed anonymous SSA names
2046 which fails parsing of named ones in dumps (we could
2047 decide to not dump their name for -gimple). */
2049 c_parser_parse_ssa_name (parser
, declarator
->u
.id
, specs
->type
,
2050 version
, ver_offset
);
2053 tree postfix_attrs
= NULL_TREE
;
2054 tree all_prefix_attrs
= specs
->attrs
;
2055 specs
->attrs
= NULL
;
2056 tree decl
= start_decl (declarator
, specs
, false,
2057 chainon (postfix_attrs
, all_prefix_attrs
));
2059 finish_decl (decl
, UNKNOWN_LOCATION
, NULL_TREE
, NULL_TREE
,
2065 c_parser_error (parser
, "expected %<;%>");
2070 /* Parse gimple goto statement. */
2073 c_parser_gimple_goto_stmt (gimple_parser
&parser
,
2074 location_t loc
, tree label
, gimple_seq
*seq
)
2076 if (cfun
->curr_properties
& PROP_cfg
)
2079 profile_probability prob
;
2080 if (c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2081 &dest_index
, &prob
))
2083 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2084 EDGE_FALLTHRU
, prob
);
2088 tree decl
= lookup_label_for_goto (loc
, label
);
2089 gimple_seq_add_stmt_without_update (seq
, gimple_build_goto (decl
));
2092 /* Parse a parenthesized condition.
2094 ( gimple-binary-expression ) */
2097 c_parser_gimple_paren_condition (gimple_parser
&parser
)
2099 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2100 return error_mark_node
;
2101 tree cond
= c_parser_gimple_binary_expression (parser
).value
;
2102 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2103 return error_mark_node
;
2107 /* Parse gimple try statement.
2110 try { ... } finally { ... }
2111 try { ... } finally { ... } else { ... }
2113 This could support try/catch as well, but it's not implemented yet.
2117 c_parser_gimple_try_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2119 gimple_seq tryseq
= NULL
;
2120 c_parser_consume_token (parser
);
2121 c_parser_gimple_compound_statement (parser
, &tryseq
);
2123 if ((c_parser_next_token_is (parser
, CPP_KEYWORD
)
2124 && c_parser_peek_token (parser
)->keyword
== RID_AT_FINALLY
)
2125 || (c_parser_next_token_is (parser
, CPP_NAME
)
2126 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
2127 && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
),
2130 gimple_seq finseq
= NULL
;
2131 c_parser_consume_token (parser
);
2132 c_parser_gimple_compound_statement (parser
, &finseq
);
2134 if (c_parser_next_token_is (parser
, CPP_KEYWORD
)
2135 && c_parser_peek_token (parser
)->keyword
== RID_ELSE
)
2137 gimple_seq elsseq
= NULL
;
2138 c_parser_consume_token (parser
);
2139 c_parser_gimple_compound_statement (parser
, &elsseq
);
2141 geh_else
*stmt
= gimple_build_eh_else (finseq
, elsseq
);
2143 gimple_seq_add_stmt_without_update (&finseq
, stmt
);
2146 gtry
*stmt
= gimple_build_try (tryseq
, finseq
, GIMPLE_TRY_FINALLY
);
2147 gimple_seq_add_stmt_without_update (seq
, stmt
);
2149 else if (c_parser_next_token_is (parser
, CPP_KEYWORD
)
2150 && c_parser_peek_token (parser
)->keyword
== RID_AT_CATCH
)
2151 c_parser_error (parser
, "%<catch%> is not supported");
2153 c_parser_error (parser
, "expected %<finally%> or %<catch%>");
2156 /* Parse gimple if-else statement.
2159 if ( gimple-binary-expression ) gimple-goto-statement
2160 if ( gimple-binary-expression ) gimple-goto-statement \
2161 else gimple-goto-statement
2165 c_parser_gimple_if_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2167 tree t_label
= NULL_TREE
, f_label
= NULL_TREE
, label
;
2169 c_parser_consume_token (parser
);
2170 tree cond
= c_parser_gimple_paren_condition (parser
);
2172 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
2174 loc
= c_parser_peek_token (parser
)->location
;
2175 c_parser_consume_token (parser
);
2176 if (! c_parser_next_token_is (parser
, CPP_NAME
))
2178 c_parser_error (parser
, "expected label");
2181 label
= c_parser_peek_token (parser
)->value
;
2182 c_parser_consume_token (parser
);
2184 profile_probability prob
;
2185 if ((cfun
->curr_properties
& PROP_cfg
)
2186 && c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2187 &dest_index
, &prob
))
2188 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2189 EDGE_TRUE_VALUE
, prob
);
2191 t_label
= lookup_label_for_goto (loc
, label
);
2192 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
2197 c_parser_error (parser
, "expected goto expression");
2201 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
2202 c_parser_consume_token (parser
);
2205 c_parser_error (parser
, "expected else statement");
2209 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
2211 loc
= c_parser_peek_token (parser
)->location
;
2212 c_parser_consume_token (parser
);
2213 if (! c_parser_next_token_is (parser
, CPP_NAME
))
2215 c_parser_error (parser
, "expected label");
2218 label
= c_parser_peek_token (parser
)->value
;
2219 c_parser_consume_token (parser
);
2221 profile_probability prob
;
2222 if ((cfun
->curr_properties
& PROP_cfg
)
2223 && c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2224 &dest_index
, &prob
))
2225 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2226 EDGE_FALSE_VALUE
, prob
);
2228 f_label
= lookup_label_for_goto (loc
, label
);
2229 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
2234 c_parser_error (parser
, "expected goto expression");
2238 if (cond
!= error_mark_node
)
2239 gimple_seq_add_stmt_without_update (seq
, gimple_build_cond_from_tree (cond
, t_label
,
2243 /* Parse gimple switch-statement.
2245 gimple-switch-statement:
2246 switch (gimple-postfix-expression) gimple-case-statement
2248 gimple-case-statement:
2249 gimple-case-statement
2250 gimple-label-statement : gimple-goto-statment
2254 c_parser_gimple_switch_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2257 tree case_label
, label
;
2258 auto_vec
<tree
> labels
;
2259 tree default_label
= NULL_TREE
;
2260 c_parser_consume_token (parser
);
2262 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2264 cond_expr
= c_parser_gimple_postfix_expression (parser
);
2265 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2268 if (! c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
2271 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
2273 if (c_parser_next_token_is (parser
, CPP_EOF
))
2275 c_parser_error (parser
, "expected statement");
2279 switch (c_parser_peek_token (parser
)->keyword
)
2284 location_t loc
= c_parser_peek_token (parser
)->location
;
2285 c_parser_consume_token (parser
);
2287 if (c_parser_next_token_is (parser
, CPP_NAME
)
2288 || c_parser_peek_token (parser
)->type
== CPP_NUMBER
)
2289 exp1
= c_parser_gimple_postfix_expression (parser
);
2292 c_parser_error (parser
, "expected expression");
2296 if (c_parser_next_token_is (parser
, CPP_COLON
))
2298 c_parser_consume_token (parser
);
2299 if (c_parser_next_token_is (parser
, CPP_NAME
))
2301 label
= c_parser_peek_token (parser
)->value
;
2302 c_parser_consume_token (parser
);
2303 tree decl
= lookup_label_for_goto (loc
, label
);
2304 case_label
= build_case_label (exp1
.value
, NULL_TREE
,
2306 labels
.safe_push (case_label
);
2307 if (! c_parser_require (parser
, CPP_SEMICOLON
,
2311 else if (! c_parser_require (parser
, CPP_NAME
,
2315 else if (! c_parser_require (parser
, CPP_SEMICOLON
,
2322 location_t loc
= c_parser_peek_token (parser
)->location
;
2323 c_parser_consume_token (parser
);
2324 if (c_parser_next_token_is (parser
, CPP_COLON
))
2326 c_parser_consume_token (parser
);
2327 if (c_parser_next_token_is (parser
, CPP_NAME
))
2329 label
= c_parser_peek_token (parser
)->value
;
2330 c_parser_consume_token (parser
);
2331 tree decl
= lookup_label_for_goto (loc
, label
);
2332 default_label
= build_case_label (NULL_TREE
, NULL_TREE
,
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
,
2348 c_parser_error (parser
, "expected case label");
2353 if (! c_parser_require (parser
, CPP_CLOSE_BRACE
, "expected %<}%>"))
2356 if (cond_expr
.value
!= error_mark_node
)
2358 gswitch
*s
= gimple_build_switch (cond_expr
.value
, default_label
, labels
);
2359 gimple_seq_add_stmt_without_update (seq
, s
);
2363 /* Parse gimple return statement. */
2366 c_parser_gimple_return_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2368 location_t loc
= c_parser_peek_token (parser
)->location
;
2370 c_parser_consume_token (parser
);
2371 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2373 c_finish_gimple_return (loc
, NULL_TREE
);
2374 ret
= gimple_build_return (NULL
);
2375 gimple_seq_add_stmt_without_update (seq
, ret
);
2379 location_t xloc
= c_parser_peek_token (parser
)->location
;
2380 c_expr expr
= c_parser_gimple_unary_expression (parser
);
2381 if (expr
.value
!= error_mark_node
)
2383 c_finish_gimple_return (xloc
, expr
.value
);
2384 ret
= gimple_build_return (expr
.value
);
2385 gimple_seq_add_stmt_without_update (seq
, ret
);
2390 /* Support function for c_parser_gimple_return_stmt. */
2393 c_finish_gimple_return (location_t loc
, tree retval
)
2395 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
2397 /* Use the expansion point to handle cases such as returning NULL
2398 in a function returning void. */
2399 location_t xloc
= expansion_point_location_if_in_system_header (loc
);
2401 if (TREE_THIS_VOLATILE (current_function_decl
))
2402 warning_at (xloc
, 0,
2403 "function declared %<noreturn%> has a %<return%> statement");
2406 current_function_returns_null
= 1;
2407 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
2409 current_function_returns_null
= 1;
2410 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
2413 (xloc
, "%<return%> with a value, in function returning void");
2414 inform (DECL_SOURCE_LOCATION (current_function_decl
),
2418 else if (TREE_CODE (valtype
) != TREE_CODE (TREE_TYPE (retval
)))
2421 (xloc
, "invalid conversion in return statement");
2422 inform (DECL_SOURCE_LOCATION (current_function_decl
),