2 Copyright (C) 2016-2020 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
27 #include "stringpool.h"
30 #include "stor-layout.h"
32 #include "trans-mem.h"
33 #include "c-family/c-pragma.h"
35 #include "c-family/c-objc.h"
38 #include "gomp-constants.h"
39 #include "c-family/c-indentation.h"
40 #include "gimple-expr.h"
42 #include "gcc-rich-location.h"
45 #include "tree-pass.h"
46 #include "tree-pretty-print.h"
48 #include "basic-block.h"
50 #include "gimple-pretty-print.h"
52 #include "pass_manager.h"
53 #include "tree-ssanames.h"
54 #include "gimple-ssa.h"
56 #include "internal-fn.h"
61 #include "gimple-iterator.h"
63 #include "tree-phinodes.h"
64 #include "tree-into-ssa.h"
68 /* GIMPLE parser state. */
73 gimple_parser (c_parser
*p
) : parser (p
), edges(), current_bb(NULL
) {}
74 /* c_parser is not visible here, use composition and fake inheritance
75 via a conversion operator. */
76 operator c_parser
*() { return parser
; }
79 /* CFG build state. */
80 class gimple_parser_edge
86 profile_probability probability
;
88 auto_vec
<gimple_parser_edge
> edges
;
89 basic_block current_bb
;
91 void push_edge (int, int, int, profile_probability
);
95 gimple_parser::push_edge (int src
, int dest
, int flags
,
96 profile_probability prob
)
102 e
.probability
= prob
;
107 /* Gimple parsing functions. */
108 static bool c_parser_gimple_compound_statement (gimple_parser
&, gimple_seq
*);
109 static void c_parser_gimple_label (gimple_parser
&, gimple_seq
*);
110 static void c_parser_gimple_statement (gimple_parser
&, gimple_seq
*);
111 static struct c_expr
c_parser_gimple_binary_expression (gimple_parser
&);
112 static struct c_expr
c_parser_gimple_unary_expression (gimple_parser
&);
113 static struct c_expr
c_parser_gimple_postfix_expression (gimple_parser
&);
114 static struct c_expr c_parser_gimple_postfix_expression_after_primary
115 (gimple_parser
&, location_t
, struct c_expr
);
116 static void c_parser_gimple_declaration (gimple_parser
&);
117 static void c_parser_gimple_goto_stmt (gimple_parser
&, location_t
,
119 static void c_parser_gimple_try_stmt (gimple_parser
&, gimple_seq
*);
120 static void c_parser_gimple_if_stmt (gimple_parser
&, gimple_seq
*);
121 static void c_parser_gimple_switch_stmt (gimple_parser
&, gimple_seq
*);
122 static void c_parser_gimple_return_stmt (gimple_parser
&, gimple_seq
*);
123 static void c_finish_gimple_return (location_t
, tree
);
124 static tree
c_parser_gimple_paren_condition (gimple_parser
&);
125 static void c_parser_gimple_expr_list (gimple_parser
&, vec
<tree
> *);
128 /* See if VAL is an identifier matching __BB<num> and return <num>
132 c_parser_gimple_parse_bb_spec (tree val
, int *index
)
134 if (strncmp (IDENTIFIER_POINTER (val
), "__BB", 4) != 0)
136 for (const char *p
= IDENTIFIER_POINTER (val
) + 4; *p
; ++p
)
139 *index
= atoi (IDENTIFIER_POINTER (val
) + 4);
143 /* See if VAL is an identifier matching __BB<num> and return <num>
144 in *INDEX. Return true if so and parse also FREQUENCY of
149 c_parser_gimple_parse_bb_spec_edge_probability (tree val
,
150 gimple_parser
&parser
,
152 profile_probability
*probablity
)
154 bool return_p
= c_parser_gimple_parse_bb_spec (val
, index
);
157 *probablity
= profile_probability::uninitialized ();
158 /* Parse frequency if provided. */
159 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
162 c_parser_consume_token (parser
);
163 if (!c_parser_next_token_is (parser
, CPP_NAME
))
165 c_parser_error (parser
, "expected frequency quality");
169 profile_quality quality
;
171 = IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
172 if (!parse_profile_quality (v
, &quality
))
174 c_parser_error (parser
, "unknown profile quality");
178 c_parser_consume_token (parser
);
179 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
182 if (!c_parser_next_token_is (parser
, CPP_NUMBER
)
183 || (TREE_CODE (f
= c_parser_peek_token (parser
)->value
)
186 c_parser_error (parser
, "expected frequency value");
190 unsigned int value
= TREE_INT_CST_LOW (f
);
191 *probablity
= profile_probability (value
, quality
);
193 c_parser_consume_token (parser
);
194 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
197 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
208 /* Parse the body of a function declaration marked with "__GIMPLE". */
211 c_parser_parse_gimple_body (c_parser
*cparser
, char *gimple_pass
,
212 enum c_declspec_il cdil
,
213 profile_count entry_bb_count
)
215 gimple_parser
parser (cparser
);
216 gimple_seq seq
= NULL
;
217 gimple_seq body
= NULL
;
218 tree stmt
= push_stmt_list ();
220 location_t loc1
= c_parser_peek_token (parser
)->location
;
222 cfun
->pass_startwith
= gimple_pass
;
223 init_tree_ssa (cfun
);
225 if (cdil
== cdil_gimple
)
226 /* While we have SSA names in the IL we do not have a CFG built yet
227 and PHIs are represented using a PHI internal function. We do
228 have lowered control flow and exception handling (well, we do not
229 have parser support for EH yet). But as we still have BINDs
230 we have to go through lowering again. */
231 cfun
->curr_properties
= PROP_gimple_any
;
234 /* We have at least cdil_gimple_cfg. */
235 gimple_register_cfg_hooks ();
236 init_empty_tree_cfg ();
237 parser
.current_bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
238 /* Initialize the bare loop structure - we are going to only
239 mark headers and leave the rest to fixup. */
240 set_loops_for_fn (cfun
, ggc_cleared_alloc
<struct loops
> ());
241 init_loops_structure (cfun
, loops_for_fn (cfun
), 1);
242 loops_state_set (cfun
, LOOPS_NEED_FIXUP
|LOOPS_MAY_HAVE_MULTIPLE_LATCHES
);
243 cfun
->curr_properties
244 |= PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_loops
;
245 if (cdil
== cdil_gimple_ssa
)
247 init_ssa_operands (cfun
);
248 cfun
->curr_properties
|= PROP_ssa
;
252 if (! c_parser_gimple_compound_statement (parser
, &seq
)
253 && cdil
== cdil_gimple
)
255 gimple
*ret
= gimple_build_return (NULL
);
256 gimple_seq_add_stmt_without_update (&seq
, ret
);
259 tree block
= pop_scope ();
260 stmt
= pop_stmt_list (stmt
);
261 stmt
= c_build_bind_expr (loc1
, block
, stmt
);
263 block
= DECL_INITIAL (current_function_decl
);
264 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
265 BLOCK_CHAIN (block
) = NULL_TREE
;
266 TREE_ASM_WRITTEN (block
) = 1;
268 if (cdil
== cdil_gimple
)
270 gbind
*bind_stmt
= gimple_build_bind (BIND_EXPR_VARS (stmt
), NULL
,
271 BIND_EXPR_BLOCK (stmt
));
272 gimple_bind_set_body (bind_stmt
, seq
);
273 gimple_seq_add_stmt_without_update (&body
, bind_stmt
);
274 gimple_set_body (current_function_decl
, body
);
278 /* Control-flow and binds are lowered, record local decls. */
279 for (tree var
= BIND_EXPR_VARS (stmt
); var
; var
= DECL_CHAIN (var
))
281 && !DECL_EXTERNAL (var
))
282 add_local_decl (cfun
, var
);
283 /* We have a CFG. Build the edges. */
284 for (unsigned i
= 0; i
< parser
.edges
.length (); ++i
)
286 edge e
= make_edge (BASIC_BLOCK_FOR_FN (cfun
, parser
.edges
[i
].src
),
287 BASIC_BLOCK_FOR_FN (cfun
, parser
.edges
[i
].dest
),
288 parser
.edges
[i
].flags
);
289 e
->probability
= parser
.edges
[i
].probability
;
291 /* Add edges for case labels. */
293 FOR_EACH_BB_FN (bb
, cfun
)
294 if (EDGE_COUNT (bb
->succs
) == 0)
296 gimple
*last
= last_stmt (bb
);
297 if (gswitch
*sw
= safe_dyn_cast
<gswitch
*> (last
))
298 for (unsigned i
= 0; i
< gimple_switch_num_labels (sw
); ++i
)
300 basic_block label_bb
= gimple_switch_label_bb (cfun
, sw
, i
);
301 make_edge (bb
, label_bb
, 0);
304 /* Need those for loop fixup. */
305 calculate_dominance_info (CDI_DOMINATORS
);
306 /* With SSA lower PHIs parsed as internal function calls and
308 if (cdil
== cdil_gimple_ssa
)
310 /* Create PHI nodes, they are parsed into __PHI internal calls. */
311 FOR_EACH_BB_FN (bb
, cfun
)
312 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
315 gimple
*stmt
= gsi_stmt (gsi
);
316 if (!gimple_call_internal_p (stmt
, IFN_PHI
))
319 gphi
*phi
= create_phi_node (gimple_call_lhs (stmt
), bb
);
320 for (unsigned i
= 0; i
< gimple_call_num_args (stmt
); i
+= 2)
322 int srcidx
= TREE_INT_CST_LOW (gimple_call_arg (stmt
, i
));
323 edge e
= find_edge (BASIC_BLOCK_FOR_FN (cfun
, srcidx
), bb
);
325 c_parser_error (parser
, "edge not found");
327 add_phi_arg (phi
, gimple_call_arg (stmt
, i
+ 1), e
,
330 gsi_remove (&gsi
, false);
332 /* Fill SSA name gaps, putting them on the freelist. */
333 for (unsigned i
= 1; i
< num_ssa_names
; ++i
)
336 tree name
= make_ssa_name_fn (cfun
, integer_type_node
, NULL
, i
);
337 release_ssa_name_fn (cfun
, name
);
339 /* No explicit virtual operands (yet). */
340 bitmap_obstack_initialize (NULL
);
341 update_ssa (TODO_update_ssa_only_virtuals
);
342 bitmap_obstack_release (NULL
);
343 /* ??? By flushing the freelist after virtual operand SSA rewrite
344 we keep the gaps available for re-use like needed for the
345 PR89595 testcase but then usually virtual operands would have
346 taken most of them. The fix is obviously to make virtual
347 operands explicit in the SSA IL. */
348 flush_ssaname_freelist ();
350 fix_loop_structure (NULL
);
353 if (cfun
->curr_properties
& PROP_cfg
)
355 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= entry_bb_count
;
356 gcov_type t
= param_gimple_fe_computed_hot_bb_threshold
;
357 set_hot_bb_threshold (t
);
358 update_max_bb_count ();
359 cgraph_node::get_create (cfun
->decl
);
360 cgraph_edge::rebuild_edges ();
362 dump_function (TDI_gimple
, current_function_decl
);
365 /* Parse a compound statement in gimple function body.
369 gimple-declaration-statement
371 gimple-switch-statement
372 gimple-labeled-statement
373 gimple-expression-statement
374 gimple-goto-statement
376 gimple-return-statement
380 c_parser_gimple_compound_statement (gimple_parser
&parser
, gimple_seq
*seq
)
382 bool return_p
= false;
384 if (! c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
387 /* A compund statement starts with optional declarations. */
388 while (c_parser_next_tokens_start_declaration (parser
))
390 c_parser_gimple_declaration (parser
);
391 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
395 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
397 if (c_parser_error (parser
))
399 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
402 else if (c_parser_next_token_is (parser
, CPP_EOF
))
404 c_parser_error (parser
, "expected declaration or statement");
408 switch (c_parser_peek_token (parser
)->type
)
411 switch (c_parser_peek_token (parser
)->keyword
)
414 c_parser_gimple_try_stmt (parser
, seq
);
417 c_parser_gimple_if_stmt (parser
, seq
);
420 c_parser_gimple_switch_stmt (parser
, seq
);
424 location_t loc
= c_parser_peek_token (parser
)->location
;
425 c_parser_consume_token (parser
);
426 if (c_parser_next_token_is (parser
, CPP_NAME
))
428 tree label
= c_parser_peek_token (parser
)->value
;
429 c_parser_consume_token (parser
);
430 c_parser_gimple_goto_stmt (parser
, loc
, label
, seq
);
431 if (! c_parser_require (parser
, CPP_SEMICOLON
,
439 c_parser_gimple_return_stmt (parser
, seq
);
440 if (! c_parser_require (parser
, CPP_SEMICOLON
,
443 if (cfun
->curr_properties
& PROP_cfg
)
444 parser
.push_edge (parser
.current_bb
->index
, EXIT_BLOCK
, 0,
445 profile_probability::uninitialized ());
452 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
454 c_parser_gimple_label (parser
, seq
);
457 if (c_parser_next_token_is (parser
, CPP_NAME
)
458 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
459 && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
),
462 c_parser_gimple_try_stmt (parser
, seq
);
465 /* Basic block specification.
467 if ((cfun
->curr_properties
& PROP_cfg
)
468 && !strcmp (IDENTIFIER_POINTER
469 (c_parser_peek_token (parser
)->value
), "__BB"))
471 c_parser_consume_token (parser
);
472 if (! c_parser_require (parser
, CPP_OPEN_PAREN
,
475 if (c_parser_next_token_is_not (parser
, CPP_NUMBER
))
477 c_parser_error (parser
, "expected block index");
480 tree tnum
= c_parser_peek_token (parser
)->value
;
481 if (TREE_CODE (tnum
) != INTEGER_CST
)
483 c_parser_error (parser
, "expected block index");
486 int index
= TREE_INT_CST_LOW (tnum
);
487 if (index
< NUM_FIXED_BLOCKS
488 || (index
< last_basic_block_for_fn (cfun
)
489 && BASIC_BLOCK_FOR_FN (cfun
, index
) != NULL
))
491 c_parser_error (parser
, "invalid block index");
494 int is_loop_header_of
= -1;
495 profile_count bb_count
= profile_count::uninitialized ();
496 c_parser_consume_token (parser
);
497 while (c_parser_next_token_is (parser
, CPP_COMMA
))
499 c_parser_consume_token (parser
);
500 if (! c_parser_next_token_is (parser
, CPP_NAME
))
502 c_parser_error (parser
, "expected block specifier");
505 /* loop_header (NUM) */
506 if (!strcmp (IDENTIFIER_POINTER
507 (c_parser_peek_token (parser
)->value
),
510 c_parser_consume_token (parser
);
511 if (! c_parser_require (parser
, CPP_OPEN_PAREN
,
515 if (! c_parser_next_token_is (parser
, CPP_NUMBER
)
516 || TREE_CODE (loop_num
517 = c_parser_peek_token (parser
)->value
)
520 c_parser_error (parser
, "expected loop number");
523 c_parser_consume_token (parser
);
524 is_loop_header_of
= TREE_INT_CST_LOW (loop_num
);
525 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
,
529 /* Parse profile: quality(value) */
533 profile_quality quality
;
534 tree v
= c_parser_peek_token (parser
)->value
;
535 if (!parse_profile_quality (IDENTIFIER_POINTER (v
),
538 c_parser_error (parser
, "unknown block specifier");
542 c_parser_consume_token (parser
);
543 if (!c_parser_require (parser
, CPP_OPEN_PAREN
,
547 if (!c_parser_next_token_is (parser
, CPP_NUMBER
)
548 || (TREE_CODE (q
= c_parser_peek_token (parser
)->value
)
551 c_parser_error (parser
, "expected count value");
556 = profile_count::from_gcov_type (TREE_INT_CST_LOW (q
),
558 c_parser_consume_token (parser
);
559 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
,
564 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
,
566 || ! c_parser_require (parser
, CPP_COLON
,
570 /* Put stmts parsed in the current block. */
571 if (!gimple_seq_empty_p (*seq
))
573 if (!parser
.current_bb
)
574 c_parser_error (parser
, "stmts without block");
577 gimple_stmt_iterator gsi
578 = gsi_start_bb (parser
.current_bb
);
579 gsi_insert_seq_after (&gsi
, *seq
, GSI_CONTINUE_LINKING
);
584 /* Build an empty block with specified index, linking them
586 basic_block bb
= alloc_block ();
588 link_block (bb
, (parser
.current_bb
? parser
.current_bb
589 : ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
590 if (basic_block_info_for_fn (cfun
)->length () <= (size_t)index
)
591 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
),
593 SET_BASIC_BLOCK_FOR_FN (cfun
, index
, bb
);
594 if (last_basic_block_for_fn (cfun
) <= index
)
595 last_basic_block_for_fn (cfun
) = index
+ 1;
596 n_basic_blocks_for_fn (cfun
)++;
597 if (parser
.current_bb
->index
== ENTRY_BLOCK
)
598 parser
.push_edge (ENTRY_BLOCK
, bb
->index
, EDGE_FALLTHRU
,
599 profile_probability::always ());
601 /* We leave the proper setting to fixup. */
602 class loop
*loop_father
= loops_for_fn (cfun
)->tree_root
;
603 /* If the new block is a loop header, allocate a loop
604 struct. Fixup will take care of proper placement within
606 if (is_loop_header_of
!= -1)
608 if (number_of_loops (cfun
) > (unsigned)is_loop_header_of
609 && get_loop (cfun
, is_loop_header_of
) != NULL
)
611 c_parser_error (parser
, "duplicate loop header");
615 class loop
*loop
= alloc_loop ();
616 loop
->num
= is_loop_header_of
;
618 vec_safe_grow_cleared (loops_for_fn (cfun
)->larray
,
619 is_loop_header_of
+ 1);
620 (*loops_for_fn (cfun
)->larray
)[is_loop_header_of
] = loop
;
621 flow_loop_tree_node_add (loops_for_fn (cfun
)->tree_root
,
624 loop_father
= get_loop (cfun
, is_loop_header_of
);
626 bb
->loop_father
= loop_father
;
627 bb
->count
= bb_count
;
629 /* Stmts now go to the new block. */
630 parser
.current_bb
= bb
;
638 location_t loc
= c_parser_peek_token (parser
)->location
;
639 c_parser_consume_token (parser
);
640 gimple
*nop
= gimple_build_nop ();
641 gimple_set_location (nop
, loc
);
642 gimple_seq_add_stmt_without_update (seq
, nop
);
648 c_parser_gimple_statement (parser
, seq
);
649 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
650 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
653 c_parser_consume_token (parser
);
655 /* Put stmts parsed in the current block. */
656 if ((cfun
->curr_properties
& PROP_cfg
)
657 && !gimple_seq_empty_p (*seq
))
659 if (!parser
.current_bb
)
660 c_parser_error (parser
, "stmts without block");
663 gimple_stmt_iterator gsi
= gsi_start_bb (parser
.current_bb
);
664 gsi_insert_seq_after (&gsi
, *seq
, GSI_CONTINUE_LINKING
);
672 /* Parse a gimple statement.
675 gimple-call-expression
676 gimple-assign-statement
679 gimple-assign-statement:
680 gimple-unary-expression = gimple-assign-rhs
683 gimple-cast-expression
684 gimple-unary-expression
685 gimple-binary-expression
686 gimple-call-expression
688 gimple-phi-statement:
689 identifier = __PHI ( label : gimple_primary-expression, ... )
692 gimple-primary-expression ( argument-list )
694 gimple-cast-expression:
695 ( type-name ) gimple-primary-expression
700 c_parser_gimple_statement (gimple_parser
&parser
, gimple_seq
*seq
)
702 struct c_expr lhs
, rhs
;
703 gimple
*assign
= NULL
;
705 tree arg
= NULL_TREE
;
706 auto_vec
<tree
> vargs
;
708 lhs
= c_parser_gimple_unary_expression (parser
);
709 loc
= EXPR_LOCATION (lhs
.value
);
712 /* GIMPLE call statement without LHS. */
713 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
714 && TREE_CODE (lhs
.value
) == CALL_EXPR
)
717 call
= gimple_build_call_from_tree (lhs
.value
, NULL
);
718 gimple_seq_add_stmt_without_update (seq
, call
);
719 gimple_set_location (call
, loc
);
723 /* All following cases are statements with LHS. */
724 if (! c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
727 /* Cast expression. */
728 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
729 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
731 c_parser_consume_token (parser
);
732 struct c_type_name
*type_name
= c_parser_type_name (parser
);
733 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
734 if (type_name
== NULL
)
736 /* ??? The actual type used in the cast expression is ignored as
737 in GIMPLE it is encoded by the type of the LHS. */
738 rhs
= c_parser_gimple_postfix_expression (parser
);
739 if (lhs
.value
!= error_mark_node
740 && rhs
.value
!= error_mark_node
)
742 enum tree_code code
= NOP_EXPR
;
743 if (FLOAT_TYPE_P (TREE_TYPE (lhs
.value
))
744 && ! FLOAT_TYPE_P (TREE_TYPE (rhs
.value
)))
746 else if (! FLOAT_TYPE_P (TREE_TYPE (lhs
.value
))
747 && FLOAT_TYPE_P (TREE_TYPE (rhs
.value
)))
748 code
= FIX_TRUNC_EXPR
;
749 assign
= gimple_build_assign (lhs
.value
, code
, rhs
.value
);
750 gimple_seq_add_stmt_without_update (seq
, assign
);
751 gimple_set_location (assign
, loc
);
756 /* Unary expression. */
757 switch (c_parser_peek_token (parser
)->type
)
761 tree id
= c_parser_peek_token (parser
)->value
;
762 if (strcmp (IDENTIFIER_POINTER (id
), "__ABS") == 0
763 || strcmp (IDENTIFIER_POINTER (id
), "__ABSU") == 0
764 || strcmp (IDENTIFIER_POINTER (id
), "__MIN") == 0
765 || strcmp (IDENTIFIER_POINTER (id
), "__MAX") == 0
766 || strcmp (IDENTIFIER_POINTER (id
), "__BIT_INSERT") == 0
767 || strcmp (IDENTIFIER_POINTER (id
), "__VEC_PERM") == 0)
768 goto build_unary_expr
;
772 if (c_parser_peek_token (parser
)->keyword
!= RID_REALPART
773 && c_parser_peek_token (parser
)->keyword
!= RID_IMAGPART
)
781 case CPP_MULT
: /* pointer deref */
783 rhs
= c_parser_gimple_unary_expression (parser
);
784 if (rhs
.value
!= error_mark_node
)
786 assign
= gimple_build_assign (lhs
.value
, rhs
.value
);
787 gimple_set_location (assign
, loc
);
788 gimple_seq_add_stmt_without_update (seq
, assign
);
795 /* GIMPLE PHI statement. */
796 if (c_parser_next_token_is_keyword (parser
, RID_PHI
))
798 c_parser_consume_token (parser
);
800 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
803 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
804 c_parser_consume_token (parser
);
806 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
))
808 if (c_parser_next_token_is (parser
, CPP_NAME
)
809 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
811 arg
= c_parser_peek_token (parser
)->value
;
812 c_parser_consume_token (parser
);
813 if (c_parser_next_token_is (parser
, CPP_COLON
))
814 c_parser_consume_token (parser
);
816 if (!c_parser_gimple_parse_bb_spec (arg
, &src_index
))
817 c_parser_error (parser
, "invalid source block specification");
818 vargs
.safe_push (size_int (src_index
));
820 else if (c_parser_next_token_is (parser
, CPP_COMMA
))
821 c_parser_consume_token (parser
);
824 arg
= c_parser_gimple_unary_expression (parser
).value
;
825 vargs
.safe_push (arg
);
829 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
832 /* Build internal function for PHI. */
833 gcall
*call_stmt
= gimple_build_call_internal_vec (IFN_PHI
, vargs
);
834 gimple_call_set_lhs (call_stmt
, lhs
.value
);
835 gimple_set_location (call_stmt
, UNKNOWN_LOCATION
);
836 gimple_seq_add_stmt_without_update (seq
, call_stmt
);
840 /* GIMPLE call with lhs. */
841 if (c_parser_next_token_is (parser
, CPP_DOT
)
842 || (c_parser_next_token_is (parser
, CPP_NAME
)
843 && c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_PAREN
844 && lookup_name (c_parser_peek_token (parser
)->value
)))
846 rhs
= c_parser_gimple_unary_expression (parser
);
847 if (rhs
.value
!= error_mark_node
)
849 gimple
*call
= gimple_build_call_from_tree (rhs
.value
, NULL
);
850 gimple_call_set_lhs (call
, lhs
.value
);
851 gimple_seq_add_stmt_without_update (seq
, call
);
852 gimple_set_location (call
, loc
);
857 rhs
= c_parser_gimple_binary_expression (parser
);
858 if (lhs
.value
!= error_mark_node
859 && rhs
.value
!= error_mark_node
)
861 /* If we parsed a comparison and the next token is a '?' then
862 parse a conditional expression. */
863 if (COMPARISON_CLASS_P (rhs
.value
)
864 && c_parser_next_token_is (parser
, CPP_QUERY
))
866 struct c_expr trueval
, falseval
;
867 c_parser_consume_token (parser
);
868 trueval
= c_parser_gimple_postfix_expression (parser
);
869 falseval
.set_error ();
870 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
871 falseval
= c_parser_gimple_postfix_expression (parser
);
872 if (trueval
.value
== error_mark_node
873 || falseval
.value
== error_mark_node
)
875 rhs
.value
= build3_loc (loc
, COND_EXPR
, TREE_TYPE (trueval
.value
),
876 rhs
.value
, trueval
.value
, falseval
.value
);
878 assign
= gimple_build_assign (lhs
.value
, rhs
.value
);
879 gimple_seq_add_stmt_without_update (seq
, assign
);
880 gimple_set_location (assign
, loc
);
885 /* Parse gimple binary expr.
887 gimple-binary-expression:
888 gimple-unary-expression * gimple-unary-expression
889 gimple-unary-expression __MULT_HIGHPART gimple-unary-expression
890 gimple-unary-expression / 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
909 c_parser_gimple_binary_expression (gimple_parser
&parser
)
911 /* Location of the binary operator. */
912 struct c_expr ret
, lhs
, rhs
;
913 enum tree_code code
= ERROR_MARK
;
915 lhs
= c_parser_gimple_postfix_expression (parser
);
916 if (c_parser_error (parser
))
918 tree ret_type
= TREE_TYPE (lhs
.value
);
919 switch (c_parser_peek_token (parser
)->type
)
925 code
= TRUNC_DIV_EXPR
;
928 code
= TRUNC_MOD_EXPR
;
931 if (POINTER_TYPE_P (TREE_TYPE (lhs
.value
)))
932 code
= POINTER_PLUS_EXPR
;
947 ret_type
= boolean_type_node
;
951 ret_type
= boolean_type_node
;
955 ret_type
= boolean_type_node
;
959 ret_type
= boolean_type_node
;
963 ret_type
= boolean_type_node
;
967 ret_type
= boolean_type_node
;
979 c_parser_error (parser
, "%<&&%> not valid in GIMPLE");
982 c_parser_error (parser
, "%<||%> not valid in GIMPLE");
986 tree id
= c_parser_peek_token (parser
)->value
;
987 if (strcmp (IDENTIFIER_POINTER (id
), "__MULT_HIGHPART") == 0)
989 code
= MULT_HIGHPART_EXPR
;
995 /* Not a binary expression. */
998 location_t ret_loc
= c_parser_peek_token (parser
)->location
;
999 c_parser_consume_token (parser
);
1000 rhs
= c_parser_gimple_postfix_expression (parser
);
1001 if (lhs
.value
!= error_mark_node
&& rhs
.value
!= error_mark_node
)
1002 ret
.value
= build2_loc (ret_loc
, code
, ret_type
, lhs
.value
, rhs
.value
);
1006 /* Parse a gimple parentized binary expression. */
1009 c_parser_gimple_parentized_binary_expression (gimple_parser
&parser
,
1016 c_parser_consume_token (parser
);
1017 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1019 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1020 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
1022 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1023 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1026 if (op1
.value
!= error_mark_node
&& op2
.value
!= error_mark_node
)
1027 ret
.value
= build2_loc (op_loc
,
1028 code
, TREE_TYPE (op1
.value
), op1
.value
, op2
.value
);
1032 /* Parse a gimple parentized binary expression. */
1035 c_parser_gimple_parentized_ternary_expression (gimple_parser
&parser
,
1042 c_parser_consume_token (parser
);
1043 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1045 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1046 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
1048 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1049 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<)%>"))
1051 c_expr op3
= c_parser_gimple_postfix_expression (parser
);
1052 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1055 if (op1
.value
!= error_mark_node
1056 && op2
.value
!= error_mark_node
1057 && op3
.value
!= error_mark_node
)
1058 ret
.value
= build3_loc (op_loc
,
1059 code
, TREE_TYPE (op1
.value
),
1060 op1
.value
, op2
.value
, op3
.value
);
1064 /* Parse gimple unary expression.
1066 gimple-unary-expression:
1067 gimple-postfix-expression
1068 unary-operator gimple-postfix-expression
1070 unary-operator: one of
1075 c_parser_gimple_unary_expression (gimple_parser
&parser
)
1077 struct c_expr ret
, op
;
1078 location_t op_loc
= c_parser_peek_token (parser
)->location
;
1081 switch (c_parser_peek_token (parser
)->type
)
1084 c_parser_consume_token (parser
);
1085 op
= c_parser_gimple_postfix_expression (parser
);
1086 mark_exp_read (op
.value
);
1087 return parser_build_unary_op (op_loc
, ADDR_EXPR
, op
);
1090 c_parser_consume_token (parser
);
1091 op
= c_parser_gimple_postfix_expression (parser
);
1092 if (op
.value
== error_mark_node
)
1094 if (! POINTER_TYPE_P (TREE_TYPE (op
.value
)))
1096 error_at (op_loc
, "expected pointer as argument of unary %<*%>");
1099 finish
= op
.get_finish ();
1100 location_t combined_loc
= make_location (op_loc
, op_loc
, finish
);
1101 ret
.value
= build_simple_mem_ref_loc (combined_loc
, op
.value
);
1102 TREE_SIDE_EFFECTS (ret
.value
)
1103 = TREE_THIS_VOLATILE (ret
.value
)
1104 = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op
.value
)));
1105 ret
.src_range
.m_start
= op_loc
;
1106 ret
.src_range
.m_finish
= finish
;
1110 c_parser_consume_token (parser
);
1111 op
= c_parser_gimple_postfix_expression (parser
);
1112 return parser_build_unary_op (op_loc
, CONVERT_EXPR
, op
);
1114 c_parser_consume_token (parser
);
1115 op
= c_parser_gimple_postfix_expression (parser
);
1116 return parser_build_unary_op (op_loc
, NEGATE_EXPR
, op
);
1118 c_parser_consume_token (parser
);
1119 op
= c_parser_gimple_postfix_expression (parser
);
1120 return parser_build_unary_op (op_loc
, BIT_NOT_EXPR
, op
);
1122 c_parser_error (parser
, "%<!%> not valid in GIMPLE");
1125 switch (c_parser_peek_token (parser
)->keyword
)
1128 c_parser_consume_token (parser
);
1129 op
= c_parser_gimple_postfix_expression (parser
);
1130 return parser_build_unary_op (op_loc
, REALPART_EXPR
, op
);
1132 c_parser_consume_token (parser
);
1133 op
= c_parser_gimple_postfix_expression (parser
);
1134 return parser_build_unary_op (op_loc
, IMAGPART_EXPR
, op
);
1136 return c_parser_gimple_postfix_expression (parser
);
1140 tree id
= c_parser_peek_token (parser
)->value
;
1141 if (strcmp (IDENTIFIER_POINTER (id
), "__ABS") == 0)
1143 c_parser_consume_token (parser
);
1144 op
= c_parser_gimple_postfix_expression (parser
);
1145 return parser_build_unary_op (op_loc
, ABS_EXPR
, op
);
1147 else if (strcmp (IDENTIFIER_POINTER (id
), "__ABSU") == 0)
1149 c_parser_consume_token (parser
);
1150 op
= c_parser_gimple_postfix_expression (parser
);
1151 return parser_build_unary_op (op_loc
, ABSU_EXPR
, op
);
1153 else if (strcmp (IDENTIFIER_POINTER (id
), "__MIN") == 0)
1154 return c_parser_gimple_parentized_binary_expression (parser
,
1157 else if (strcmp (IDENTIFIER_POINTER (id
), "__MAX") == 0)
1158 return c_parser_gimple_parentized_binary_expression (parser
,
1161 else if (strcmp (IDENTIFIER_POINTER (id
), "__VEC_PERM") == 0)
1162 return c_parser_gimple_parentized_ternary_expression
1163 (parser
, op_loc
, VEC_PERM_EXPR
);
1164 else if (strcmp (IDENTIFIER_POINTER (id
), "__BIT_INSERT") == 0)
1166 /* __BIT_INSERT '(' postfix-expression, postfix-expression,
1168 location_t loc
= c_parser_peek_token (parser
)->location
;
1169 c_parser_consume_token (parser
);
1170 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1172 c_expr op0
= c_parser_gimple_postfix_expression (parser
);
1173 c_parser_skip_until_found (parser
, CPP_COMMA
,
1175 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1176 c_parser_skip_until_found (parser
, CPP_COMMA
,
1178 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1179 if (TREE_CODE (op2
.value
) != INTEGER_CST
1180 || !int_fits_type_p (op2
.value
, bitsizetype
))
1181 c_parser_error (parser
, "expected constant offset");
1182 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1184 if (op0
.value
!= error_mark_node
1185 && op1
.value
!= error_mark_node
1186 && TREE_CODE (op2
.value
) == INTEGER_CST
)
1187 ret
.value
= build3_loc (loc
, BIT_INSERT_EXPR
,
1188 TREE_TYPE (op0
.value
),
1189 op0
.value
, op1
.value
,
1190 fold_convert (bitsizetype
,
1196 return c_parser_gimple_postfix_expression (parser
);
1199 return c_parser_gimple_postfix_expression (parser
);
1203 /* Decompose ID into base name (ID until ver_offset) and VERSION. Return
1204 true if ID matches a SSA name. */
1207 c_parser_parse_ssa_name_id (tree id
, unsigned *version
, unsigned *ver_offset
)
1209 const char *token
= IDENTIFIER_POINTER (id
);
1210 const char *var_version
= strrchr (token
, '_');
1214 *ver_offset
= var_version
- token
;
1215 for (const char *p
= var_version
+ 1; *p
; ++p
)
1218 *version
= atoi (var_version
+ 1);
1219 return *version
> 0;
1222 /* Get at the actual SSA name ID with VERSION starting at VER_OFFSET.
1223 TYPE is the type if the SSA name is being declared. */
1226 c_parser_parse_ssa_name (gimple_parser
&parser
,
1227 tree id
, tree type
, unsigned version
,
1228 unsigned ver_offset
)
1230 tree name
= NULL_TREE
;
1231 const char *token
= IDENTIFIER_POINTER (id
);
1233 if (ver_offset
== 0)
1235 /* Anonymous unnamed SSA name. */
1236 if (version
< num_ssa_names
)
1237 name
= ssa_name (version
);
1242 c_parser_error (parser
, "SSA name undeclared");
1243 return error_mark_node
;
1245 name
= make_ssa_name_fn (cfun
, type
, NULL
, version
);
1250 if (version
< num_ssa_names
)
1251 name
= ssa_name (version
);
1254 /* Separate var name from version. */
1255 char *var_name
= XNEWVEC (char, ver_offset
+ 1);
1256 memcpy (var_name
, token
, ver_offset
);
1257 var_name
[ver_offset
] = '\0';
1258 /* lookup for parent decl. */
1259 id
= get_identifier (var_name
);
1260 tree parent
= lookup_name (id
);
1261 XDELETEVEC (var_name
);
1262 if (! parent
|| parent
== error_mark_node
)
1264 c_parser_error (parser
, "base variable or SSA name undeclared");
1265 return error_mark_node
;
1267 if (!(VAR_P (parent
)
1268 || TREE_CODE (parent
) == PARM_DECL
1269 || TREE_CODE (parent
) == RESULT_DECL
))
1271 error ("invalid base %qE for SSA name", parent
);
1272 return error_mark_node
;
1274 if (VECTOR_TYPE_P (TREE_TYPE (parent
))
1275 || TREE_CODE (TREE_TYPE (parent
)) == COMPLEX_TYPE
)
1276 DECL_GIMPLE_REG_P (parent
) = 1;
1277 name
= make_ssa_name_fn (cfun
, parent
,
1278 gimple_build_nop (), version
);
1285 /* Parse a gimple call to an internal function.
1287 gimple-call-internal:
1288 . identifier ( gimple-argument-expression-list[opt] ) */
1290 static struct c_expr
1291 c_parser_gimple_call_internal (gimple_parser
&parser
)
1296 gcc_assert (c_parser_next_token_is (parser
, CPP_DOT
));
1297 c_parser_consume_token (parser
);
1298 location_t loc
= c_parser_peek_token (parser
)->location
;
1299 if (!c_parser_next_token_is (parser
, CPP_NAME
)
1300 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
1302 c_parser_error (parser
, "expecting internal function name");
1305 tree id
= c_parser_peek_token (parser
)->value
;
1306 internal_fn ifn
= lookup_internal_fn (IDENTIFIER_POINTER (id
));
1307 c_parser_consume_token (parser
);
1308 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1310 auto_vec
<tree
> exprlist
;
1311 if (!c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
1312 c_parser_gimple_expr_list (parser
, &exprlist
);
1313 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
1314 if (ifn
== IFN_LAST
)
1315 error_at (loc
, "unknown internal function %qE", id
);
1318 expr
.value
= build_call_expr_internal_loc_array
1319 (loc
, ifn
, void_type_node
, exprlist
.length (),
1320 exprlist
.address ());
1321 expr
.original_code
= ERROR_MARK
;
1322 expr
.original_type
= NULL
;
1328 /* Parse '<' type [',' alignment] '>' and return a type on success
1329 and NULL_TREE on error. */
1332 c_parser_gimple_typespec (gimple_parser
&parser
)
1334 struct c_type_name
*type_name
= NULL
;
1335 tree alignment
= NULL_TREE
;
1336 if (c_parser_require (parser
, CPP_LESS
, "expected %<<%>"))
1338 type_name
= c_parser_type_name (parser
);
1339 /* Optional alignment. */
1340 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1342 c_parser_consume_token (parser
);
1344 = c_parser_gimple_postfix_expression (parser
).value
;
1346 c_parser_skip_until_found (parser
,
1347 CPP_GREATER
, "expected %<>%>");
1352 tree type
= groktypename (type_name
, &tem
, NULL
);
1354 type
= build_aligned_type (type
, tree_to_uhwi (alignment
));
1358 /* Parse gimple postfix expression.
1360 gimple-postfix-expression:
1361 gimple-primary-expression
1362 gimple-primary-expression [ gimple-primary-expression ]
1363 gimple-primary-expression ( gimple-argument-expression-list[opt] )
1364 gimple-postfix-expression . identifier
1365 gimple-postfix-expression -> identifier
1367 gimple-argument-expression-list:
1368 gimple-unary-expression
1369 gimple-argument-expression-list , gimple-unary-expression
1371 gimple-primary-expression:
1376 gimple-call-internal
1380 static struct c_expr
1381 c_parser_gimple_postfix_expression (gimple_parser
&parser
)
1383 location_t loc
= c_parser_peek_token (parser
)->location
;
1384 source_range tok_range
= c_parser_peek_token (parser
)->get_range ();
1387 switch (c_parser_peek_token (parser
)->type
)
1390 expr
.value
= c_parser_peek_token (parser
)->value
;
1391 set_c_expr_source_range (&expr
, tok_range
);
1392 loc
= c_parser_peek_token (parser
)->location
;
1393 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, 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
.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
.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
),