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. */
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 struct gimple_parser_edge
85 profile_probability probability
;
87 auto_vec
<gimple_parser_edge
> edges
;
88 basic_block current_bb
;
90 void push_edge (int, int, int, profile_probability
);
94 gimple_parser::push_edge (int src
, int dest
, int flags
,
95 profile_probability prob
)
101 e
.probability
= prob
;
106 /* Gimple parsing functions. */
107 static bool c_parser_gimple_compound_statement (gimple_parser
&, gimple_seq
*);
108 static void c_parser_gimple_label (gimple_parser
&, gimple_seq
*);
109 static void c_parser_gimple_statement (gimple_parser
&, gimple_seq
*);
110 static struct c_expr
c_parser_gimple_binary_expression (gimple_parser
&);
111 static struct c_expr
c_parser_gimple_unary_expression (gimple_parser
&);
112 static struct c_expr
c_parser_gimple_postfix_expression (gimple_parser
&);
113 static struct c_expr c_parser_gimple_postfix_expression_after_primary
114 (gimple_parser
&, location_t
, struct c_expr
);
115 static void c_parser_gimple_declaration (gimple_parser
&);
116 static void c_parser_gimple_goto_stmt (gimple_parser
&, location_t
,
118 static void c_parser_gimple_if_stmt (gimple_parser
&, gimple_seq
*);
119 static void c_parser_gimple_switch_stmt (gimple_parser
&, gimple_seq
*);
120 static void c_parser_gimple_return_stmt (gimple_parser
&, gimple_seq
*);
121 static void c_finish_gimple_return (location_t
, tree
);
122 static tree
c_parser_gimple_paren_condition (gimple_parser
&);
123 static void c_parser_gimple_expr_list (gimple_parser
&, vec
<tree
> *);
126 /* See if VAL is an identifier matching __BB<num> and return <num>
130 c_parser_gimple_parse_bb_spec (tree val
, int *index
)
132 if (strncmp (IDENTIFIER_POINTER (val
), "__BB", 4) != 0)
134 for (const char *p
= IDENTIFIER_POINTER (val
) + 4; *p
; ++p
)
137 *index
= atoi (IDENTIFIER_POINTER (val
) + 4);
141 /* See if VAL is an identifier matching __BB<num> and return <num>
142 in *INDEX. Return true if so and parse also FREQUENCY of
147 c_parser_gimple_parse_bb_spec_edge_probability (tree val
,
148 gimple_parser
&parser
,
150 profile_probability
*probablity
)
152 bool return_p
= c_parser_gimple_parse_bb_spec (val
, index
);
155 *probablity
= profile_probability::uninitialized ();
156 /* Parse frequency if provided. */
157 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
160 c_parser_consume_token (parser
);
161 if (!c_parser_next_token_is (parser
, CPP_NAME
))
163 c_parser_error (parser
, "expected frequency quality");
167 profile_quality quality
;
169 = IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
170 if (!parse_profile_quality (v
, &quality
))
172 c_parser_error (parser
, "unknown profile quality");
176 c_parser_consume_token (parser
);
177 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
180 if (!c_parser_next_token_is (parser
, CPP_NUMBER
)
181 || (TREE_CODE (f
= c_parser_peek_token (parser
)->value
)
184 c_parser_error (parser
, "expected frequency value");
188 unsigned int value
= TREE_INT_CST_LOW (f
);
189 *probablity
= profile_probability (value
, quality
);
191 c_parser_consume_token (parser
);
192 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
195 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
206 /* Parse the body of a function declaration marked with "__GIMPLE". */
209 c_parser_parse_gimple_body (c_parser
*cparser
, char *gimple_pass
,
210 enum c_declspec_il cdil
,
211 profile_count entry_bb_count
)
213 gimple_parser
parser (cparser
);
214 gimple_seq seq
= NULL
;
215 gimple_seq body
= NULL
;
216 tree stmt
= push_stmt_list ();
218 location_t loc1
= c_parser_peek_token (parser
)->location
;
220 cfun
->pass_startwith
= gimple_pass
;
221 init_tree_ssa (cfun
);
223 if (cdil
== cdil_gimple
)
224 /* While we have SSA names in the IL we do not have a CFG built yet
225 and PHIs are represented using a PHI internal function. We do
226 have lowered control flow and exception handling (well, we do not
227 have parser support for EH yet). But as we still have BINDs
228 we have to go through lowering again. */
229 cfun
->curr_properties
= PROP_gimple_any
;
232 /* We have at least cdil_gimple_cfg. */
233 gimple_register_cfg_hooks ();
234 init_empty_tree_cfg ();
235 /* Initialize the bare loop structure - we are going to only
236 mark headers and leave the rest to fixup. */
237 set_loops_for_fn (cfun
, ggc_cleared_alloc
<struct loops
> ());
238 init_loops_structure (cfun
, loops_for_fn (cfun
), 1);
239 loops_state_set (cfun
, LOOPS_NEED_FIXUP
|LOOPS_MAY_HAVE_MULTIPLE_LATCHES
);
240 cfun
->curr_properties
241 |= PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_loops
;
242 if (cdil
== cdil_gimple_ssa
)
244 init_ssa_operands (cfun
);
245 cfun
->curr_properties
|= PROP_ssa
;
249 if (! c_parser_gimple_compound_statement (parser
, &seq
)
250 && cdil
== cdil_gimple
)
252 gimple
*ret
= gimple_build_return (NULL
);
253 gimple_seq_add_stmt_without_update (&seq
, ret
);
256 tree block
= pop_scope ();
257 stmt
= pop_stmt_list (stmt
);
258 stmt
= c_build_bind_expr (loc1
, block
, stmt
);
260 block
= DECL_INITIAL (current_function_decl
);
261 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
262 BLOCK_CHAIN (block
) = NULL_TREE
;
263 TREE_ASM_WRITTEN (block
) = 1;
265 if (cdil
== cdil_gimple
)
267 gbind
*bind_stmt
= gimple_build_bind (BIND_EXPR_VARS (stmt
), NULL
,
268 BIND_EXPR_BLOCK (stmt
));
269 gimple_bind_set_body (bind_stmt
, seq
);
270 gimple_seq_add_stmt_without_update (&body
, bind_stmt
);
271 gimple_set_body (current_function_decl
, body
);
275 /* Control-flow and binds are lowered, record local decls. */
276 for (tree var
= BIND_EXPR_VARS (stmt
); var
; var
= DECL_CHAIN (var
))
278 && !DECL_EXTERNAL (var
))
279 add_local_decl (cfun
, var
);
280 /* We have a CFG. Build the edges. */
281 for (unsigned i
= 0; i
< parser
.edges
.length (); ++i
)
283 edge e
= make_edge (BASIC_BLOCK_FOR_FN (cfun
, parser
.edges
[i
].src
),
284 BASIC_BLOCK_FOR_FN (cfun
, parser
.edges
[i
].dest
),
285 parser
.edges
[i
].flags
);
286 e
->probability
= parser
.edges
[i
].probability
;
288 /* Add edges for case labels. */
290 FOR_EACH_BB_FN (bb
, cfun
)
291 if (EDGE_COUNT (bb
->succs
) == 0)
293 gimple
*last
= last_stmt (bb
);
294 if (gswitch
*sw
= safe_dyn_cast
<gswitch
*> (last
))
295 for (unsigned i
= 0; i
< gimple_switch_num_labels (sw
); ++i
)
297 basic_block label_bb
= gimple_switch_label_bb (cfun
, sw
, i
);
298 make_edge (bb
, label_bb
, 0);
301 /* Need those for loop fixup. */
302 calculate_dominance_info (CDI_DOMINATORS
);
303 /* With SSA lower PHIs parsed as internal function calls and
305 if (cdil
== cdil_gimple_ssa
)
307 /* Create PHI nodes, they are parsed into __PHI internal calls. */
308 FOR_EACH_BB_FN (bb
, cfun
)
309 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
312 gimple
*stmt
= gsi_stmt (gsi
);
313 if (!gimple_call_internal_p (stmt
, IFN_PHI
))
316 gphi
*phi
= create_phi_node (gimple_call_lhs (stmt
), bb
);
317 for (unsigned i
= 0; i
< gimple_call_num_args (stmt
); i
+= 2)
319 int srcidx
= TREE_INT_CST_LOW (gimple_call_arg (stmt
, i
));
320 edge e
= find_edge (BASIC_BLOCK_FOR_FN (cfun
, srcidx
), bb
);
322 c_parser_error (parser
, "edge not found");
324 add_phi_arg (phi
, gimple_call_arg (stmt
, i
+ 1), e
,
327 gsi_remove (&gsi
, false);
329 /* Fill SSA name gaps, putting them on the freelist. */
330 for (unsigned i
= 1; i
< num_ssa_names
; ++i
)
333 tree name
= make_ssa_name_fn (cfun
, integer_type_node
, NULL
, i
);
334 release_ssa_name_fn (cfun
, name
);
336 /* No explicit virtual operands (yet). */
337 bitmap_obstack_initialize (NULL
);
338 update_ssa (TODO_update_ssa_only_virtuals
);
339 bitmap_obstack_release (NULL
);
340 /* ??? By flushing the freelist after virtual operand SSA rewrite
341 we keep the gaps available for re-use like needed for the
342 PR89595 testcase but then usually virtual operands would have
343 taken most of them. The fix is obviously to make virtual
344 operands explicit in the SSA IL. */
345 flush_ssaname_freelist ();
347 fix_loop_structure (NULL
);
350 if (cfun
->curr_properties
& PROP_cfg
)
352 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= entry_bb_count
;
353 gcov_type t
= PARAM_VALUE (PARAM_GIMPLE_FE_COMPUTED_HOT_BB_THRESHOLD
);
354 set_hot_bb_threshold (t
);
355 update_max_bb_count ();
357 dump_function (TDI_gimple
, current_function_decl
);
360 /* Parse a compound statement in gimple function body.
364 gimple-declaration-statement
366 gimple-switch-statement
367 gimple-labeled-statement
368 gimple-expression-statement
369 gimple-goto-statement
371 gimple-return-statement
375 c_parser_gimple_compound_statement (gimple_parser
&parser
, gimple_seq
*seq
)
377 bool return_p
= false;
379 if (! c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
382 /* A compund statement starts with optional declarations. */
383 while (c_parser_next_tokens_start_declaration (parser
))
385 c_parser_gimple_declaration (parser
);
386 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
390 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
392 if (c_parser_error (parser
))
394 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
397 else if (c_parser_next_token_is (parser
, CPP_EOF
))
399 c_parser_error (parser
, "expected declaration or statement");
403 switch (c_parser_peek_token (parser
)->type
)
406 switch (c_parser_peek_token (parser
)->keyword
)
409 c_parser_gimple_if_stmt (parser
, seq
);
412 c_parser_gimple_switch_stmt (parser
, seq
);
416 location_t loc
= c_parser_peek_token (parser
)->location
;
417 c_parser_consume_token (parser
);
418 if (c_parser_next_token_is (parser
, CPP_NAME
))
420 tree label
= c_parser_peek_token (parser
)->value
;
421 c_parser_consume_token (parser
);
422 c_parser_gimple_goto_stmt (parser
, loc
, label
, seq
);
423 if (! c_parser_require (parser
, CPP_SEMICOLON
,
431 c_parser_gimple_return_stmt (parser
, seq
);
432 if (! c_parser_require (parser
, CPP_SEMICOLON
,
435 if (cfun
->curr_properties
& PROP_cfg
)
436 parser
.push_edge (parser
.current_bb
->index
, EXIT_BLOCK
, 0,
437 profile_probability::uninitialized ());
444 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
446 c_parser_gimple_label (parser
, seq
);
449 /* Basic block specification.
451 if ((cfun
->curr_properties
& PROP_cfg
)
452 && !strcmp (IDENTIFIER_POINTER
453 (c_parser_peek_token (parser
)->value
), "__BB"))
455 c_parser_consume_token (parser
);
456 if (! c_parser_require (parser
, CPP_OPEN_PAREN
,
459 if (c_parser_next_token_is_not (parser
, CPP_NUMBER
))
461 c_parser_error (parser
, "expected block index");
464 tree tnum
= c_parser_peek_token (parser
)->value
;
465 if (TREE_CODE (tnum
) != INTEGER_CST
)
467 c_parser_error (parser
, "expected block index");
470 int index
= TREE_INT_CST_LOW (tnum
);
471 if (index
< NUM_FIXED_BLOCKS
472 || (index
< last_basic_block_for_fn (cfun
)
473 && BASIC_BLOCK_FOR_FN (cfun
, index
) != NULL
))
475 c_parser_error (parser
, "invalid block index");
478 int is_loop_header_of
= -1;
479 profile_count bb_count
= profile_count::uninitialized ();
480 c_parser_consume_token (parser
);
481 while (c_parser_next_token_is (parser
, CPP_COMMA
))
483 c_parser_consume_token (parser
);
484 if (! c_parser_next_token_is (parser
, CPP_NAME
))
486 c_parser_error (parser
, "expected block specifier");
489 /* loop_header (NUM) */
490 if (!strcmp (IDENTIFIER_POINTER
491 (c_parser_peek_token (parser
)->value
),
494 c_parser_consume_token (parser
);
495 if (! c_parser_require (parser
, CPP_OPEN_PAREN
,
499 if (! c_parser_next_token_is (parser
, CPP_NUMBER
)
500 || TREE_CODE (loop_num
501 = c_parser_peek_token (parser
)->value
)
504 c_parser_error (parser
, "expected loop number");
507 c_parser_consume_token (parser
);
508 is_loop_header_of
= TREE_INT_CST_LOW (loop_num
);
509 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
,
513 /* Parse profile: quality(value) */
517 profile_quality quality
;
518 tree v
= c_parser_peek_token (parser
)->value
;
519 if (!parse_profile_quality (IDENTIFIER_POINTER (v
),
522 c_parser_error (parser
, "unknown block specifier");
526 c_parser_consume_token (parser
);
527 if (!c_parser_require (parser
, CPP_OPEN_PAREN
,
531 if (!c_parser_next_token_is (parser
, CPP_NUMBER
)
532 || (TREE_CODE (q
= c_parser_peek_token (parser
)->value
)
535 c_parser_error (parser
, "expected count value");
540 = profile_count::from_gcov_type (TREE_INT_CST_LOW (q
),
542 c_parser_consume_token (parser
);
543 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
,
548 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
,
550 || ! c_parser_require (parser
, CPP_COLON
,
554 /* Put stmts parsed in the current block. */
555 if (!gimple_seq_empty_p (*seq
))
557 if (!parser
.current_bb
)
558 c_parser_error (parser
, "stmts without block");
561 gimple_stmt_iterator gsi
562 = gsi_start_bb (parser
.current_bb
);
563 gsi_insert_seq_after (&gsi
, *seq
, GSI_CONTINUE_LINKING
);
568 /* Build an empty block with specified index, linking them
570 basic_block bb
= alloc_block ();
572 link_block (bb
, (parser
.current_bb
? parser
.current_bb
573 : ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
574 if (basic_block_info_for_fn (cfun
)->length () <= (size_t)index
)
575 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
),
577 SET_BASIC_BLOCK_FOR_FN (cfun
, index
, bb
);
578 if (last_basic_block_for_fn (cfun
) <= index
)
579 last_basic_block_for_fn (cfun
) = index
+ 1;
580 n_basic_blocks_for_fn (cfun
)++;
581 if (!parser
.current_bb
)
582 parser
.push_edge (ENTRY_BLOCK
, bb
->index
, EDGE_FALLTHRU
,
583 profile_probability::always ());
585 /* We leave the proper setting to fixup. */
586 struct loop
*loop_father
= loops_for_fn (cfun
)->tree_root
;
587 /* If the new block is a loop header, allocate a loop
588 struct. Fixup will take care of proper placement within
590 if (is_loop_header_of
!= -1)
592 if (number_of_loops (cfun
) > (unsigned)is_loop_header_of
593 && get_loop (cfun
, is_loop_header_of
) != NULL
)
595 c_parser_error (parser
, "duplicate loop header");
599 struct loop
*loop
= alloc_loop ();
600 loop
->num
= is_loop_header_of
;
602 vec_safe_grow_cleared (loops_for_fn (cfun
)->larray
,
603 is_loop_header_of
+ 1);
604 (*loops_for_fn (cfun
)->larray
)[is_loop_header_of
] = loop
;
605 flow_loop_tree_node_add (loops_for_fn (cfun
)->tree_root
,
608 loop_father
= get_loop (cfun
, is_loop_header_of
);
610 bb
->loop_father
= loop_father
;
611 bb
->count
= bb_count
;
613 /* Stmts now go to the new block. */
614 parser
.current_bb
= bb
;
622 location_t loc
= c_parser_peek_token (parser
)->location
;
623 c_parser_consume_token (parser
);
624 gimple
*nop
= gimple_build_nop ();
625 gimple_set_location (nop
, loc
);
626 gimple_seq_add_stmt_without_update (seq
, nop
);
632 c_parser_gimple_statement (parser
, seq
);
633 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
634 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
637 c_parser_consume_token (parser
);
639 /* Put stmts parsed in the current block. */
640 if ((cfun
->curr_properties
& PROP_cfg
)
641 && !gimple_seq_empty_p (*seq
))
643 if (!parser
.current_bb
)
644 c_parser_error (parser
, "stmts without block");
647 gimple_stmt_iterator gsi
= gsi_start_bb (parser
.current_bb
);
648 gsi_insert_seq_after (&gsi
, *seq
, GSI_CONTINUE_LINKING
);
656 /* Parse a gimple statement.
659 gimple-call-expression
660 gimple-assign-statement
663 gimple-assign-statement:
664 gimple-unary-expression = gimple-assign-rhs
667 gimple-cast-expression
668 gimple-unary-expression
669 gimple-binary-expression
670 gimple-call-expression
672 gimple-phi-statement:
673 identifier = __PHI ( label : gimple_primary-expression, ... )
676 gimple-primary-expression ( argument-list )
678 gimple-cast-expression:
679 ( type-name ) gimple-primary-expression
684 c_parser_gimple_statement (gimple_parser
&parser
, gimple_seq
*seq
)
686 struct c_expr lhs
, rhs
;
687 gimple
*assign
= NULL
;
689 tree arg
= NULL_TREE
;
690 auto_vec
<tree
> vargs
;
692 lhs
= c_parser_gimple_unary_expression (parser
);
693 loc
= EXPR_LOCATION (lhs
.value
);
696 /* GIMPLE call statement without LHS. */
697 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
698 && TREE_CODE (lhs
.value
) == CALL_EXPR
)
701 call
= gimple_build_call_from_tree (lhs
.value
, NULL
);
702 gimple_seq_add_stmt_without_update (seq
, call
);
703 gimple_set_location (call
, loc
);
707 /* All following cases are statements with LHS. */
708 if (! c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
711 /* Cast expression. */
712 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
713 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
715 c_parser_consume_token (parser
);
716 struct c_type_name
*type_name
= c_parser_type_name (parser
);
717 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
718 if (type_name
== NULL
)
720 /* ??? The actual type used in the cast expression is ignored as
721 in GIMPLE it is encoded by the type of the LHS. */
722 rhs
= c_parser_gimple_postfix_expression (parser
);
723 if (lhs
.value
!= error_mark_node
724 && rhs
.value
!= error_mark_node
)
726 enum tree_code code
= NOP_EXPR
;
727 if (FLOAT_TYPE_P (TREE_TYPE (lhs
.value
))
728 && ! FLOAT_TYPE_P (TREE_TYPE (rhs
.value
)))
730 else if (! FLOAT_TYPE_P (TREE_TYPE (lhs
.value
))
731 && FLOAT_TYPE_P (TREE_TYPE (rhs
.value
)))
732 code
= FIX_TRUNC_EXPR
;
733 assign
= gimple_build_assign (lhs
.value
, code
, rhs
.value
);
734 gimple_seq_add_stmt_without_update (seq
, assign
);
735 gimple_set_location (assign
, loc
);
740 /* Unary expression. */
741 switch (c_parser_peek_token (parser
)->type
)
745 tree id
= c_parser_peek_token (parser
)->value
;
746 if (strcmp (IDENTIFIER_POINTER (id
), "__ABS") == 0
747 || strcmp (IDENTIFIER_POINTER (id
), "__ABSU") == 0
748 || strcmp (IDENTIFIER_POINTER (id
), "__MIN") == 0
749 || strcmp (IDENTIFIER_POINTER (id
), "__MAX") == 0
750 || strcmp (IDENTIFIER_POINTER (id
), "__BIT_INSERT") == 0
751 || strcmp (IDENTIFIER_POINTER (id
), "__VEC_PERM") == 0)
752 goto build_unary_expr
;
756 if (c_parser_peek_token (parser
)->keyword
!= RID_REALPART
757 && c_parser_peek_token (parser
)->keyword
!= RID_IMAGPART
)
765 case CPP_MULT
: /* pointer deref */
767 rhs
= c_parser_gimple_unary_expression (parser
);
768 if (rhs
.value
!= error_mark_node
)
770 assign
= gimple_build_assign (lhs
.value
, rhs
.value
);
771 gimple_set_location (assign
, loc
);
772 gimple_seq_add_stmt_without_update (seq
, assign
);
779 /* GIMPLE PHI statement. */
780 if (c_parser_next_token_is_keyword (parser
, RID_PHI
))
782 c_parser_consume_token (parser
);
784 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
787 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
788 c_parser_consume_token (parser
);
790 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
))
792 if (c_parser_next_token_is (parser
, CPP_NAME
)
793 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
795 arg
= c_parser_peek_token (parser
)->value
;
796 c_parser_consume_token (parser
);
797 if (c_parser_next_token_is (parser
, CPP_COLON
))
798 c_parser_consume_token (parser
);
800 if (!c_parser_gimple_parse_bb_spec (arg
, &src_index
))
801 c_parser_error (parser
, "invalid source block specification");
802 vargs
.safe_push (size_int (src_index
));
804 else if (c_parser_next_token_is (parser
, CPP_COMMA
))
805 c_parser_consume_token (parser
);
808 arg
= c_parser_gimple_unary_expression (parser
).value
;
809 vargs
.safe_push (arg
);
813 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
816 /* Build internal function for PHI. */
817 gcall
*call_stmt
= gimple_build_call_internal_vec (IFN_PHI
, vargs
);
818 gimple_call_set_lhs (call_stmt
, lhs
.value
);
819 gimple_set_location (call_stmt
, UNKNOWN_LOCATION
);
820 gimple_seq_add_stmt_without_update (seq
, call_stmt
);
824 /* GIMPLE call with lhs. */
825 if (c_parser_next_token_is (parser
, CPP_DOT
)
826 || (c_parser_next_token_is (parser
, CPP_NAME
)
827 && c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_PAREN
828 && lookup_name (c_parser_peek_token (parser
)->value
)))
830 rhs
= c_parser_gimple_unary_expression (parser
);
831 if (rhs
.value
!= error_mark_node
)
833 gimple
*call
= gimple_build_call_from_tree (rhs
.value
, NULL
);
834 gimple_call_set_lhs (call
, lhs
.value
);
835 gimple_seq_add_stmt_without_update (seq
, call
);
836 gimple_set_location (call
, loc
);
841 rhs
= c_parser_gimple_binary_expression (parser
);
842 if (lhs
.value
!= error_mark_node
843 && rhs
.value
!= error_mark_node
)
845 /* If we parsed a comparison and the next token is a '?' then
846 parse a conditional expression. */
847 if (COMPARISON_CLASS_P (rhs
.value
)
848 && c_parser_next_token_is (parser
, CPP_QUERY
))
850 struct c_expr trueval
, falseval
;
851 c_parser_consume_token (parser
);
852 trueval
= c_parser_gimple_postfix_expression (parser
);
853 falseval
.set_error ();
854 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
855 falseval
= c_parser_gimple_postfix_expression (parser
);
856 if (trueval
.value
== error_mark_node
857 || falseval
.value
== error_mark_node
)
859 rhs
.value
= build3_loc (loc
, COND_EXPR
, TREE_TYPE (trueval
.value
),
860 rhs
.value
, trueval
.value
, falseval
.value
);
862 assign
= gimple_build_assign (lhs
.value
, rhs
.value
);
863 gimple_seq_add_stmt_without_update (seq
, assign
);
864 gimple_set_location (assign
, loc
);
869 /* Parse gimple binary expr.
871 gimple-binary-expression:
872 gimple-unary-expression * gimple-unary-expression
873 gimple-unary-expression __MULT_HIGHPART gimple-unary-expression
874 gimple-unary-expression / gimple-unary-expression
875 gimple-unary-expression % gimple-unary-expression
876 gimple-unary-expression + gimple-unary-expression
877 gimple-unary-expression - gimple-unary-expression
878 gimple-unary-expression << gimple-unary-expression
879 gimple-unary-expression >> gimple-unary-expression
880 gimple-unary-expression < gimple-unary-expression
881 gimple-unary-expression > gimple-unary-expression
882 gimple-unary-expression <= gimple-unary-expression
883 gimple-unary-expression >= gimple-unary-expression
884 gimple-unary-expression == gimple-unary-expression
885 gimple-unary-expression != gimple-unary-expression
886 gimple-unary-expression & gimple-unary-expression
887 gimple-unary-expression ^ gimple-unary-expression
888 gimple-unary-expression | gimple-unary-expression
893 c_parser_gimple_binary_expression (gimple_parser
&parser
)
895 /* Location of the binary operator. */
896 struct c_expr ret
, lhs
, rhs
;
897 enum tree_code code
= ERROR_MARK
;
899 lhs
= c_parser_gimple_postfix_expression (parser
);
900 if (c_parser_error (parser
))
902 tree ret_type
= TREE_TYPE (lhs
.value
);
903 switch (c_parser_peek_token (parser
)->type
)
909 code
= TRUNC_DIV_EXPR
;
912 code
= TRUNC_MOD_EXPR
;
915 if (POINTER_TYPE_P (TREE_TYPE (lhs
.value
)))
916 code
= POINTER_PLUS_EXPR
;
931 ret_type
= boolean_type_node
;
935 ret_type
= boolean_type_node
;
939 ret_type
= boolean_type_node
;
943 ret_type
= boolean_type_node
;
947 ret_type
= boolean_type_node
;
951 ret_type
= boolean_type_node
;
963 c_parser_error (parser
, "%<&&%> not valid in GIMPLE");
966 c_parser_error (parser
, "%<||%> not valid in GIMPLE");
970 tree id
= c_parser_peek_token (parser
)->value
;
971 if (strcmp (IDENTIFIER_POINTER (id
), "__MULT_HIGHPART") == 0)
973 code
= MULT_HIGHPART_EXPR
;
979 /* Not a binary expression. */
982 location_t ret_loc
= c_parser_peek_token (parser
)->location
;
983 c_parser_consume_token (parser
);
984 rhs
= c_parser_gimple_postfix_expression (parser
);
985 if (lhs
.value
!= error_mark_node
&& rhs
.value
!= error_mark_node
)
986 ret
.value
= build2_loc (ret_loc
, code
, ret_type
, lhs
.value
, rhs
.value
);
990 /* Parse a gimple parentized binary expression. */
993 c_parser_gimple_parentized_binary_expression (gimple_parser
&parser
,
1000 c_parser_consume_token (parser
);
1001 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1003 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1004 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
1006 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1007 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1010 if (op1
.value
!= error_mark_node
&& op2
.value
!= error_mark_node
)
1011 ret
.value
= build2_loc (op_loc
,
1012 code
, TREE_TYPE (op1
.value
), op1
.value
, op2
.value
);
1016 /* Parse a gimple parentized binary expression. */
1019 c_parser_gimple_parentized_ternary_expression (gimple_parser
&parser
,
1026 c_parser_consume_token (parser
);
1027 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1029 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1030 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
1032 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1033 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<)%>"))
1035 c_expr op3
= c_parser_gimple_postfix_expression (parser
);
1036 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1039 if (op1
.value
!= error_mark_node
1040 && op2
.value
!= error_mark_node
1041 && op3
.value
!= error_mark_node
)
1042 ret
.value
= build3_loc (op_loc
,
1043 code
, TREE_TYPE (op1
.value
),
1044 op1
.value
, op2
.value
, op3
.value
);
1048 /* Parse gimple unary expression.
1050 gimple-unary-expression:
1051 gimple-postfix-expression
1052 unary-operator gimple-postfix-expression
1054 unary-operator: one of
1059 c_parser_gimple_unary_expression (gimple_parser
&parser
)
1061 struct c_expr ret
, op
;
1062 location_t op_loc
= c_parser_peek_token (parser
)->location
;
1065 switch (c_parser_peek_token (parser
)->type
)
1068 c_parser_consume_token (parser
);
1069 op
= c_parser_gimple_postfix_expression (parser
);
1070 mark_exp_read (op
.value
);
1071 return parser_build_unary_op (op_loc
, ADDR_EXPR
, op
);
1074 c_parser_consume_token (parser
);
1075 op
= c_parser_gimple_postfix_expression (parser
);
1076 if (op
.value
== error_mark_node
)
1078 if (! POINTER_TYPE_P (TREE_TYPE (op
.value
)))
1080 error_at (op_loc
, "expected pointer as argument of unary %<*%>");
1083 finish
= op
.get_finish ();
1084 location_t combined_loc
= make_location (op_loc
, op_loc
, finish
);
1085 ret
.value
= build_simple_mem_ref_loc (combined_loc
, op
.value
);
1086 TREE_SIDE_EFFECTS (ret
.value
)
1087 = TREE_THIS_VOLATILE (ret
.value
)
1088 = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op
.value
)));
1089 ret
.src_range
.m_start
= op_loc
;
1090 ret
.src_range
.m_finish
= finish
;
1094 c_parser_consume_token (parser
);
1095 op
= c_parser_gimple_postfix_expression (parser
);
1096 return parser_build_unary_op (op_loc
, CONVERT_EXPR
, op
);
1098 c_parser_consume_token (parser
);
1099 op
= c_parser_gimple_postfix_expression (parser
);
1100 return parser_build_unary_op (op_loc
, NEGATE_EXPR
, op
);
1102 c_parser_consume_token (parser
);
1103 op
= c_parser_gimple_postfix_expression (parser
);
1104 return parser_build_unary_op (op_loc
, BIT_NOT_EXPR
, op
);
1106 c_parser_error (parser
, "%<!%> not valid in GIMPLE");
1109 switch (c_parser_peek_token (parser
)->keyword
)
1112 c_parser_consume_token (parser
);
1113 op
= c_parser_gimple_postfix_expression (parser
);
1114 return parser_build_unary_op (op_loc
, REALPART_EXPR
, op
);
1116 c_parser_consume_token (parser
);
1117 op
= c_parser_gimple_postfix_expression (parser
);
1118 return parser_build_unary_op (op_loc
, IMAGPART_EXPR
, op
);
1120 return c_parser_gimple_postfix_expression (parser
);
1124 tree id
= c_parser_peek_token (parser
)->value
;
1125 if (strcmp (IDENTIFIER_POINTER (id
), "__ABS") == 0)
1127 c_parser_consume_token (parser
);
1128 op
= c_parser_gimple_postfix_expression (parser
);
1129 return parser_build_unary_op (op_loc
, ABS_EXPR
, op
);
1131 else if (strcmp (IDENTIFIER_POINTER (id
), "__ABSU") == 0)
1133 c_parser_consume_token (parser
);
1134 op
= c_parser_gimple_postfix_expression (parser
);
1135 return parser_build_unary_op (op_loc
, ABSU_EXPR
, op
);
1137 else if (strcmp (IDENTIFIER_POINTER (id
), "__MIN") == 0)
1138 return c_parser_gimple_parentized_binary_expression (parser
,
1141 else if (strcmp (IDENTIFIER_POINTER (id
), "__MAX") == 0)
1142 return c_parser_gimple_parentized_binary_expression (parser
,
1145 else if (strcmp (IDENTIFIER_POINTER (id
), "__VEC_PERM") == 0)
1146 return c_parser_gimple_parentized_ternary_expression
1147 (parser
, op_loc
, VEC_PERM_EXPR
);
1148 else if (strcmp (IDENTIFIER_POINTER (id
), "__BIT_INSERT") == 0)
1150 /* __BIT_INSERT '(' postfix-expression, postfix-expression,
1152 location_t loc
= c_parser_peek_token (parser
)->location
;
1153 c_parser_consume_token (parser
);
1154 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1156 c_expr op0
= c_parser_gimple_postfix_expression (parser
);
1157 c_parser_skip_until_found (parser
, CPP_COMMA
,
1159 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1160 c_parser_skip_until_found (parser
, CPP_COMMA
,
1162 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1163 if (TREE_CODE (op2
.value
) != INTEGER_CST
1164 || !int_fits_type_p (op2
.value
, bitsizetype
))
1165 c_parser_error (parser
, "expected constant offset");
1166 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1168 if (op0
.value
!= error_mark_node
1169 && op1
.value
!= error_mark_node
1170 && TREE_CODE (op2
.value
) == INTEGER_CST
)
1171 ret
.value
= build3_loc (loc
, BIT_INSERT_EXPR
,
1172 TREE_TYPE (op0
.value
),
1173 op0
.value
, op1
.value
,
1174 fold_convert (bitsizetype
,
1180 return c_parser_gimple_postfix_expression (parser
);
1183 return c_parser_gimple_postfix_expression (parser
);
1187 /* Decompose ID into base name (ID until ver_offset) and VERSION. Return
1188 true if ID matches a SSA name. */
1191 c_parser_parse_ssa_name_id (tree id
, unsigned *version
, unsigned *ver_offset
)
1193 const char *token
= IDENTIFIER_POINTER (id
);
1194 const char *var_version
= strrchr (token
, '_');
1198 *ver_offset
= var_version
- token
;
1199 for (const char *p
= var_version
+ 1; *p
; ++p
)
1202 *version
= atoi (var_version
+ 1);
1203 return *version
> 0;
1206 /* Get at the actual SSA name ID with VERSION starting at VER_OFFSET.
1207 TYPE is the type if the SSA name is being declared. */
1210 c_parser_parse_ssa_name (gimple_parser
&parser
,
1211 tree id
, tree type
, unsigned version
,
1212 unsigned ver_offset
)
1214 tree name
= NULL_TREE
;
1215 const char *token
= IDENTIFIER_POINTER (id
);
1217 if (ver_offset
== 0)
1219 /* Anonymous unnamed SSA name. */
1220 if (version
< num_ssa_names
)
1221 name
= ssa_name (version
);
1226 c_parser_error (parser
, "SSA name undeclared");
1227 return error_mark_node
;
1229 name
= make_ssa_name_fn (cfun
, type
, NULL
, version
);
1234 if (version
< num_ssa_names
)
1235 name
= ssa_name (version
);
1238 /* Separate var name from version. */
1239 char *var_name
= XNEWVEC (char, ver_offset
+ 1);
1240 memcpy (var_name
, token
, ver_offset
);
1241 var_name
[ver_offset
] = '\0';
1242 /* lookup for parent decl. */
1243 id
= get_identifier (var_name
);
1244 tree parent
= lookup_name (id
);
1245 XDELETEVEC (var_name
);
1246 if (! parent
|| parent
== error_mark_node
)
1248 c_parser_error (parser
, "base variable or SSA name undeclared");
1249 return error_mark_node
;
1251 if (!(VAR_P (parent
)
1252 || TREE_CODE (parent
) == PARM_DECL
1253 || TREE_CODE (parent
) == RESULT_DECL
))
1255 error ("invalid base %qE for SSA name", parent
);
1256 return error_mark_node
;
1258 if (VECTOR_TYPE_P (TREE_TYPE (parent
))
1259 || TREE_CODE (TREE_TYPE (parent
)) == COMPLEX_TYPE
)
1260 DECL_GIMPLE_REG_P (parent
) = 1;
1261 name
= make_ssa_name_fn (cfun
, parent
,
1262 gimple_build_nop (), version
);
1269 /* Parse a gimple call to an internal function.
1271 gimple-call-internal:
1272 . identifier ( gimple-argument-expression-list[opt] ) */
1274 static struct c_expr
1275 c_parser_gimple_call_internal (gimple_parser
&parser
)
1280 gcc_assert (c_parser_next_token_is (parser
, CPP_DOT
));
1281 c_parser_consume_token (parser
);
1282 location_t loc
= c_parser_peek_token (parser
)->location
;
1283 if (!c_parser_next_token_is (parser
, CPP_NAME
)
1284 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
1286 c_parser_error (parser
, "expecting internal function name");
1289 tree id
= c_parser_peek_token (parser
)->value
;
1290 internal_fn ifn
= lookup_internal_fn (IDENTIFIER_POINTER (id
));
1291 c_parser_consume_token (parser
);
1292 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1294 auto_vec
<tree
> exprlist
;
1295 if (!c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
1296 c_parser_gimple_expr_list (parser
, &exprlist
);
1297 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
1298 if (ifn
== IFN_LAST
)
1299 error_at (loc
, "unknown internal function %qE", id
);
1302 expr
.value
= build_call_expr_internal_loc_array
1303 (loc
, ifn
, void_type_node
, exprlist
.length (),
1304 exprlist
.address ());
1305 expr
.original_code
= ERROR_MARK
;
1306 expr
.original_type
= NULL
;
1312 /* Parse '<' type [',' alignment] '>' and return a type on success
1313 and NULL_TREE on error. */
1316 c_parser_gimple_typespec (gimple_parser
&parser
)
1318 struct c_type_name
*type_name
= NULL
;
1319 tree alignment
= NULL_TREE
;
1320 if (c_parser_require (parser
, CPP_LESS
, "expected %<<%>"))
1322 type_name
= c_parser_type_name (parser
);
1323 /* Optional alignment. */
1324 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1326 c_parser_consume_token (parser
);
1328 = c_parser_gimple_postfix_expression (parser
).value
;
1330 c_parser_skip_until_found (parser
,
1331 CPP_GREATER
, "expected %<>%>");
1336 tree type
= groktypename (type_name
, &tem
, NULL
);
1338 type
= build_aligned_type (type
, tree_to_uhwi (alignment
));
1342 /* Parse gimple postfix expression.
1344 gimple-postfix-expression:
1345 gimple-primary-expression
1346 gimple-primary-expression [ gimple-primary-expression ]
1347 gimple-primary-expression ( gimple-argument-expression-list[opt] )
1348 gimple-postfix-expression . identifier
1349 gimple-postfix-expression -> identifier
1351 gimple-argument-expression-list:
1352 gimple-unary-expression
1353 gimple-argument-expression-list , gimple-unary-expression
1355 gimple-primary-expression:
1360 gimple-call-internal
1364 static struct c_expr
1365 c_parser_gimple_postfix_expression (gimple_parser
&parser
)
1367 location_t loc
= c_parser_peek_token (parser
)->location
;
1368 source_range tok_range
= c_parser_peek_token (parser
)->get_range ();
1371 switch (c_parser_peek_token (parser
)->type
)
1374 expr
.value
= c_parser_peek_token (parser
)->value
;
1375 set_c_expr_source_range (&expr
, tok_range
);
1376 loc
= c_parser_peek_token (parser
)->location
;
1377 c_parser_consume_token (parser
);
1383 expr
.value
= c_parser_peek_token (parser
)->value
;
1384 set_c_expr_source_range (&expr
, tok_range
);
1385 c_parser_consume_token (parser
);
1391 case CPP_UTF8STRING
:
1392 expr
.value
= c_parser_peek_token (parser
)->value
;
1393 set_c_expr_source_range (&expr
, tok_range
);
1394 expr
.original_code
= STRING_CST
;
1395 c_parser_consume_token (parser
);
1398 expr
= c_parser_gimple_call_internal (parser
);
1401 if (c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
1403 tree id
= c_parser_peek_token (parser
)->value
;
1404 if (strcmp (IDENTIFIER_POINTER (id
), "__MEM") == 0)
1406 /* __MEM '<' type-name [ ',' number ] '>'
1407 '(' [ '(' type-name ')' ] unary-expression
1408 [ '+' number ] ')' */
1409 location_t loc
= c_parser_peek_token (parser
)->location
;
1410 c_parser_consume_token (parser
);
1411 tree type
= c_parser_gimple_typespec (parser
);
1413 ptr
.value
= error_mark_node
;
1414 tree alias_off
= NULL_TREE
;
1415 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1417 tree alias_type
= NULL_TREE
;
1418 /* Optional alias-type cast. */
1419 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
1421 c_parser_consume_token (parser
);
1422 struct c_type_name
*alias_type_name
1423 = c_parser_type_name (parser
);
1424 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1426 if (alias_type_name
)
1429 alias_type
= groktypename (alias_type_name
,
1433 ptr
= c_parser_gimple_unary_expression (parser
);
1434 if (ptr
.value
== error_mark_node
1435 || ! POINTER_TYPE_P (TREE_TYPE (ptr
.value
)))
1437 if (ptr
.value
!= error_mark_node
)
1438 error_at (ptr
.get_start (),
1439 "invalid type of %<__MEM%> operand");
1440 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1445 alias_type
= TREE_TYPE (ptr
.value
);
1446 /* Optional constant offset. */
1447 if (c_parser_next_token_is (parser
, CPP_PLUS
))
1449 c_parser_consume_token (parser
);
1451 = c_parser_gimple_postfix_expression (parser
).value
;
1452 alias_off
= fold_convert (alias_type
, alias_off
);
1455 alias_off
= build_int_cst (alias_type
, 0);
1456 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1459 if (! type
|| c_parser_error (parser
))
1461 c_parser_set_error (parser
, false);
1464 expr
.value
= build2_loc (loc
, MEM_REF
,
1465 type
, ptr
.value
, alias_off
);
1468 else if (strcmp (IDENTIFIER_POINTER (id
), "__VIEW_CONVERT") == 0)
1470 /* __VIEW_CONVERT '<' type-name [ ',' number ] '>'
1471 '(' postfix-expression ')' */
1472 location_t loc
= c_parser_peek_token (parser
)->location
;
1473 c_parser_consume_token (parser
);
1474 tree type
= c_parser_gimple_typespec (parser
);
1475 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1477 c_expr op
= c_parser_gimple_postfix_expression (parser
);
1478 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1480 if (type
&& op
.value
!= error_mark_node
)
1481 expr
.value
= build1_loc (loc
, VIEW_CONVERT_EXPR
,
1486 else if (strcmp (IDENTIFIER_POINTER (id
), "__BIT_FIELD_REF") == 0)
1488 /* __BIT_FIELD_REF '<' type-name [ ',' number ] '>'
1489 '(' postfix-expression, integer, integer ')' */
1490 location_t loc
= c_parser_peek_token (parser
)->location
;
1491 c_parser_consume_token (parser
);
1492 tree type
= c_parser_gimple_typespec (parser
);
1493 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1495 c_expr op0
= c_parser_gimple_postfix_expression (parser
);
1496 c_parser_skip_until_found (parser
, CPP_COMMA
,
1498 c_expr op1
= c_parser_gimple_postfix_expression (parser
);
1499 if (TREE_CODE (op1
.value
) != INTEGER_CST
1500 || !int_fits_type_p (op1
.value
, bitsizetype
))
1501 c_parser_error (parser
, "expected constant size");
1502 c_parser_skip_until_found (parser
, CPP_COMMA
,
1504 c_expr op2
= c_parser_gimple_postfix_expression (parser
);
1505 if (TREE_CODE (op2
.value
) != INTEGER_CST
1506 || !int_fits_type_p (op2
.value
, bitsizetype
))
1507 c_parser_error (parser
, "expected constant offset");
1508 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1511 && op0
.value
!= error_mark_node
1512 && TREE_CODE (op1
.value
) == INTEGER_CST
1513 && TREE_CODE (op2
.value
) == INTEGER_CST
)
1514 expr
.value
= build3_loc (loc
, BIT_FIELD_REF
, type
,
1516 fold_convert (bitsizetype
,
1518 fold_convert (bitsizetype
,
1523 else if (strcmp (IDENTIFIER_POINTER (id
), "_Literal") == 0)
1525 /* _Literal '(' type-name ')' ( [ '-' ] constant | constructor ) */
1526 c_parser_consume_token (parser
);
1527 tree type
= NULL_TREE
;
1528 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1530 struct c_type_name
*type_name
= c_parser_type_name (parser
);
1533 type
= groktypename (type_name
, &tem
, NULL
);
1534 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1539 c_parser_error (parser
, "invalid _Literal");
1542 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1544 c_parser_consume_token (parser
);
1545 if (!AGGREGATE_TYPE_P (type
)
1546 && !VECTOR_TYPE_P (type
))
1548 c_parser_error (parser
, "invalid type for _Literal with "
1550 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
1554 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1555 bool constant_p
= true;
1556 if (VECTOR_TYPE_P (type
)
1557 && !c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1559 vec_alloc (v
, TYPE_VECTOR_SUBPARTS (type
).to_constant ());
1563 = c_parser_gimple_postfix_expression (parser
).value
;
1565 || val
== error_mark_node
1566 || (! CONSTANT_CLASS_P (val
)
1567 && ! SSA_VAR_P (val
)))
1569 c_parser_error (parser
, "invalid _Literal");
1572 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, val
);
1573 if (! CONSTANT_CLASS_P (val
))
1575 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1576 c_parser_consume_token (parser
);
1582 if (c_parser_require (parser
, CPP_CLOSE_BRACE
,
1585 if (v
&& constant_p
)
1586 expr
.value
= build_vector_from_ctor (type
, v
);
1588 expr
.value
= build_constructor (type
, v
);
1592 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
1600 if ((neg_p
= c_parser_next_token_is (parser
, CPP_MINUS
)))
1601 c_parser_consume_token (parser
);
1602 if ((addr_p
= c_parser_next_token_is (parser
, CPP_AND
)))
1603 c_parser_consume_token (parser
);
1604 tree val
= c_parser_gimple_postfix_expression (parser
).value
;
1606 || val
== error_mark_node
1607 || ! CONSTANT_CLASS_P (val
)
1608 || (addr_p
&& TREE_CODE (val
) != STRING_CST
))
1610 c_parser_error (parser
, "invalid _Literal");
1614 val
= build1 (ADDR_EXPR
, type
, val
);
1617 val
= const_unop (NEGATE_EXPR
, TREE_TYPE (val
), val
);
1620 c_parser_error (parser
, "invalid _Literal");
1624 expr
.value
= fold_convert (type
, val
);
1630 unsigned version
, ver_offset
;
1631 if (! lookup_name (id
)
1632 && c_parser_parse_ssa_name_id (id
, &version
, &ver_offset
))
1634 c_parser_consume_token (parser
);
1635 expr
.value
= c_parser_parse_ssa_name (parser
, id
, NULL_TREE
,
1636 version
, ver_offset
);
1637 if (expr
.value
== error_mark_node
)
1639 set_c_expr_source_range (&expr
, tok_range
);
1640 /* For default definition SSA names. */
1641 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
1642 && c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
1645 (c_parser_peek_2nd_token (parser
)->value
)) == 0
1646 && c_parser_peek_nth_token (parser
, 3)->type
== CPP_CLOSE_PAREN
)
1648 c_parser_consume_token (parser
);
1649 c_parser_consume_token (parser
);
1650 c_parser_consume_token (parser
);
1651 if (! SSA_NAME_IS_DEFAULT_DEF (expr
.value
))
1653 if (!SSA_NAME_VAR (expr
.value
))
1655 error_at (loc
, "anonymous SSA name cannot have"
1656 " default definition");
1657 expr
.value
= error_mark_node
;
1660 set_ssa_default_def (cfun
, SSA_NAME_VAR (expr
.value
),
1662 SSA_NAME_DEF_STMT (expr
.value
) = gimple_build_nop ();
1668 c_parser_consume_token (parser
);
1670 = build_external_ref (loc
, id
,
1671 (c_parser_peek_token (parser
)->type
1672 == CPP_OPEN_PAREN
), &expr
.original_type
);
1673 set_c_expr_source_range (&expr
, tok_range
);
1679 c_parser_error (parser
, "expected expression");
1685 c_parser_error (parser
, "expected expression");
1689 return c_parser_gimple_postfix_expression_after_primary
1690 (parser
, EXPR_LOC_OR_LOC (expr
.value
, loc
), expr
);
1693 /* Parse a gimple postfix expression after the initial primary or compound
1696 static struct c_expr
1697 c_parser_gimple_postfix_expression_after_primary (gimple_parser
&parser
,
1698 location_t expr_loc
,
1704 location_t comp_loc
;
1708 location_t op_loc
= c_parser_peek_token (parser
)->location
;
1709 switch (c_parser_peek_token (parser
)->type
)
1711 case CPP_OPEN_SQUARE
:
1713 c_parser_consume_token (parser
);
1714 tree idx
= c_parser_gimple_unary_expression (parser
).value
;
1716 if (! c_parser_require (parser
, CPP_CLOSE_SQUARE
, "expected %<]%>"))
1718 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
1722 start
= expr
.get_start ();
1723 finish
= c_parser_tokens_buf (parser
, 0)->location
;
1724 expr
.value
= build_array_ref (op_loc
, expr
.value
, idx
);
1725 set_c_expr_source_range (&expr
, start
, finish
);
1727 expr
.original_code
= ERROR_MARK
;
1728 expr
.original_type
= NULL
;
1731 case CPP_OPEN_PAREN
:
1733 /* Function call. */
1734 c_parser_consume_token (parser
);
1735 auto_vec
<tree
> exprlist
;
1736 if (! c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
1737 c_parser_gimple_expr_list (parser
, &exprlist
);
1738 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1740 expr
.value
= build_call_array_loc
1741 (expr_loc
, TREE_TYPE (TREE_TYPE (expr
.value
)),
1742 expr
.value
, exprlist
.length (), exprlist
.address ());
1743 expr
.original_code
= ERROR_MARK
;
1744 expr
.original_type
= NULL
;
1749 /* Structure element reference. */
1750 c_parser_consume_token (parser
);
1751 if (c_parser_next_token_is (parser
, CPP_NAME
))
1753 c_token
*comp_tok
= c_parser_peek_token (parser
);
1754 ident
= comp_tok
->value
;
1755 comp_loc
= comp_tok
->location
;
1759 c_parser_error (parser
, "expected identifier");
1761 expr
.original_code
= ERROR_MARK
;
1762 expr
.original_type
= NULL
;
1765 start
= expr
.get_start ();
1766 finish
= c_parser_peek_token (parser
)->get_finish ();
1767 c_parser_consume_token (parser
);
1768 expr
.value
= build_component_ref (op_loc
, expr
.value
, ident
,
1770 set_c_expr_source_range (&expr
, start
, finish
);
1771 expr
.original_code
= ERROR_MARK
;
1772 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1773 expr
.original_type
= NULL
;
1776 /* Remember the original type of a bitfield. */
1777 tree field
= TREE_OPERAND (expr
.value
, 1);
1778 if (TREE_CODE (field
) != FIELD_DECL
)
1779 expr
.original_type
= NULL
;
1781 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1787 /* Structure element reference. */
1788 c_parser_consume_token (parser
);
1789 if (c_parser_next_token_is (parser
, CPP_NAME
))
1791 c_token
*comp_tok
= c_parser_peek_token (parser
);
1792 ident
= comp_tok
->value
;
1793 comp_loc
= comp_tok
->location
;
1797 c_parser_error (parser
, "expected identifier");
1799 expr
.original_code
= ERROR_MARK
;
1800 expr
.original_type
= NULL
;
1803 start
= expr
.get_start ();
1804 finish
= c_parser_peek_token (parser
)->get_finish ();
1805 c_parser_consume_token (parser
);
1806 expr
.value
= build_component_ref (op_loc
,
1807 build_simple_mem_ref_loc
1808 (op_loc
, expr
.value
),
1810 set_c_expr_source_range (&expr
, start
, finish
);
1811 expr
.original_code
= ERROR_MARK
;
1812 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1813 expr
.original_type
= NULL
;
1816 /* Remember the original type of a bitfield. */
1817 tree field
= TREE_OPERAND (expr
.value
, 1);
1818 if (TREE_CODE (field
) != FIELD_DECL
)
1819 expr
.original_type
= NULL
;
1821 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1831 /* Parse expression list.
1834 gimple-unary-expression
1835 gimple-expr-list , gimple-unary-expression
1840 c_parser_gimple_expr_list (gimple_parser
&parser
, vec
<tree
> *ret
)
1844 expr
= c_parser_gimple_unary_expression (parser
);
1845 ret
->safe_push (expr
.value
);
1846 while (c_parser_next_token_is (parser
, CPP_COMMA
))
1848 c_parser_consume_token (parser
);
1849 expr
= c_parser_gimple_unary_expression (parser
);
1850 ret
->safe_push (expr
.value
);
1854 /* Parse gimple label.
1858 case constant-expression :
1864 c_parser_gimple_label (gimple_parser
&parser
, gimple_seq
*seq
)
1866 tree name
= c_parser_peek_token (parser
)->value
;
1867 location_t loc1
= c_parser_peek_token (parser
)->location
;
1868 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
1869 c_parser_consume_token (parser
);
1870 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
1871 c_parser_consume_token (parser
);
1872 tree label
= define_label (loc1
, name
);
1873 gimple_seq_add_stmt_without_update (seq
, gimple_build_label (label
));
1877 /* Parse gimple/RTL pass list.
1879 gimple-or-rtl-pass-list:
1880 startwith("pass-name")[,{cfg,ssa}]
1884 c_parser_gimple_or_rtl_pass_list (c_parser
*parser
, c_declspecs
*specs
)
1888 /* Accept __GIMPLE/__RTL. */
1889 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
1891 c_parser_consume_token (parser
);
1893 specs
->entry_bb_count
= profile_count::uninitialized ();
1894 while (c_parser_next_token_is (parser
, CPP_NAME
))
1896 profile_quality quality
;
1897 const char *op
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
1898 c_parser_consume_token (parser
);
1899 if (! strcmp (op
, "startwith"))
1901 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1903 if (c_parser_next_token_is_not (parser
, CPP_STRING
))
1905 error_at (c_parser_peek_token (parser
)->location
,
1906 "expected pass name");
1909 pass
= xstrdup (TREE_STRING_POINTER
1910 (c_parser_peek_token (parser
)->value
));
1911 c_parser_consume_token (parser
);
1912 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<(%>"))
1915 else if (parse_profile_quality (op
, &quality
))
1918 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1921 if (!c_parser_next_token_is (parser
, CPP_NUMBER
)
1922 || (TREE_CODE (q
= c_parser_peek_token (parser
)->value
)
1925 c_parser_error (parser
, "expected count value");
1929 specs
->entry_bb_count
1930 = profile_count::from_gcov_type (TREE_INT_CST_LOW (q
), quality
);
1931 c_parser_consume_token (parser
);
1932 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1935 else if (specs
->declspec_il
!= cdil_gimple
)
1936 /* Allow only one IL specifier and none on RTL. */
1938 else if (! strcmp (op
, "cfg"))
1939 specs
->declspec_il
= cdil_gimple_cfg
;
1940 else if (! strcmp (op
, "ssa"))
1941 specs
->declspec_il
= cdil_gimple_ssa
;
1944 error_at (c_parser_peek_token (parser
)->location
,
1945 "invalid operation");
1948 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1949 c_parser_consume_token (parser
);
1952 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1955 specs
->gimple_or_rtl_pass
= pass
;
1958 /* Parse gimple local declaration.
1960 declaration-specifiers:
1961 storage-class-specifier declaration-specifiers[opt]
1962 type-specifier declaration-specifiers[opt]
1963 type-qualifier declaration-specifiers[opt]
1964 function-specifier declaration-specifiers[opt]
1965 alignment-specifier declaration-specifiers[opt]
1967 storage-class-specifier:
1991 address-space-qualifier
1997 c_parser_gimple_declaration (gimple_parser
&parser
)
1999 struct c_declarator
*declarator
;
2000 struct c_declspecs
*specs
= build_null_declspecs ();
2001 c_parser_declspecs (parser
, specs
, true, true, true,
2002 true, true, cla_nonabstract_decl
);
2003 finish_declspecs (specs
);
2005 /* Provide better error recovery. Note that a type name here is usually
2006 better diagnosed as a redeclaration. */
2007 if (c_parser_next_token_starts_declspecs (parser
)
2008 && ! c_parser_next_token_is (parser
, CPP_NAME
))
2010 c_parser_error (parser
, "expected %<;%>");
2011 c_parser_set_error (parser
, false);
2016 declarator
= c_parser_declarator (parser
,
2017 specs
->typespec_kind
!= ctsk_none
,
2018 C_DTR_NORMAL
, &dummy
);
2020 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2022 /* Handle SSA name decls specially, they do not go into the identifier
2023 table but we simply build the SSA name for later lookup. */
2024 unsigned version
, ver_offset
;
2025 if (declarator
->kind
== cdk_id
2026 && is_gimple_reg_type (specs
->type
)
2027 && c_parser_parse_ssa_name_id (declarator
->u
.id
,
2028 &version
, &ver_offset
)
2029 /* The following restricts it to unnamed anonymous SSA names
2030 which fails parsing of named ones in dumps (we could
2031 decide to not dump their name for -gimple). */
2033 c_parser_parse_ssa_name (parser
, declarator
->u
.id
, specs
->type
,
2034 version
, ver_offset
);
2037 tree postfix_attrs
= NULL_TREE
;
2038 tree all_prefix_attrs
= specs
->attrs
;
2039 specs
->attrs
= NULL
;
2040 tree decl
= start_decl (declarator
, specs
, false,
2041 chainon (postfix_attrs
, all_prefix_attrs
));
2043 finish_decl (decl
, UNKNOWN_LOCATION
, NULL_TREE
, NULL_TREE
,
2049 c_parser_error (parser
, "expected %<;%>");
2054 /* Parse gimple goto statement. */
2057 c_parser_gimple_goto_stmt (gimple_parser
&parser
,
2058 location_t loc
, tree label
, gimple_seq
*seq
)
2060 if (cfun
->curr_properties
& PROP_cfg
)
2063 profile_probability prob
;
2064 if (c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2065 &dest_index
, &prob
))
2067 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2068 EDGE_FALLTHRU
, prob
);
2072 tree decl
= lookup_label_for_goto (loc
, label
);
2073 gimple_seq_add_stmt_without_update (seq
, gimple_build_goto (decl
));
2076 /* Parse a parenthesized condition.
2078 ( gimple-binary-expression ) */
2081 c_parser_gimple_paren_condition (gimple_parser
&parser
)
2083 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2084 return error_mark_node
;
2085 tree cond
= c_parser_gimple_binary_expression (parser
).value
;
2086 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2087 return error_mark_node
;
2091 /* Parse gimple if-else statement.
2094 if ( gimple-binary-expression ) gimple-goto-statement
2095 if ( gimple-binary-expression ) gimple-goto-statement \
2096 else gimple-goto-statement
2100 c_parser_gimple_if_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2102 tree t_label
= NULL_TREE
, f_label
= NULL_TREE
, label
;
2104 c_parser_consume_token (parser
);
2105 tree cond
= c_parser_gimple_paren_condition (parser
);
2107 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
2109 loc
= c_parser_peek_token (parser
)->location
;
2110 c_parser_consume_token (parser
);
2111 if (! c_parser_next_token_is (parser
, CPP_NAME
))
2113 c_parser_error (parser
, "expected label");
2116 label
= c_parser_peek_token (parser
)->value
;
2117 c_parser_consume_token (parser
);
2119 profile_probability prob
;
2120 if ((cfun
->curr_properties
& PROP_cfg
)
2121 && c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2122 &dest_index
, &prob
))
2123 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2124 EDGE_TRUE_VALUE
, prob
);
2126 t_label
= lookup_label_for_goto (loc
, label
);
2127 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
2132 c_parser_error (parser
, "expected goto expression");
2136 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
2137 c_parser_consume_token (parser
);
2140 c_parser_error (parser
, "expected else statement");
2144 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
2146 loc
= c_parser_peek_token (parser
)->location
;
2147 c_parser_consume_token (parser
);
2148 if (! c_parser_next_token_is (parser
, CPP_NAME
))
2150 c_parser_error (parser
, "expected label");
2153 label
= c_parser_peek_token (parser
)->value
;
2154 c_parser_consume_token (parser
);
2156 profile_probability prob
;
2157 if ((cfun
->curr_properties
& PROP_cfg
)
2158 && c_parser_gimple_parse_bb_spec_edge_probability (label
, parser
,
2159 &dest_index
, &prob
))
2160 parser
.push_edge (parser
.current_bb
->index
, dest_index
,
2161 EDGE_FALSE_VALUE
, prob
);
2163 f_label
= lookup_label_for_goto (loc
, label
);
2164 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
2169 c_parser_error (parser
, "expected goto expression");
2173 if (cond
!= error_mark_node
)
2174 gimple_seq_add_stmt_without_update (seq
, gimple_build_cond_from_tree (cond
, t_label
,
2178 /* Parse gimple switch-statement.
2180 gimple-switch-statement:
2181 switch (gimple-postfix-expression) gimple-case-statement
2183 gimple-case-statement:
2184 gimple-case-statement
2185 gimple-label-statement : gimple-goto-statment
2189 c_parser_gimple_switch_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2192 tree case_label
, label
;
2193 auto_vec
<tree
> labels
;
2194 tree default_label
= NULL_TREE
;
2195 c_parser_consume_token (parser
);
2197 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2199 cond_expr
= c_parser_gimple_postfix_expression (parser
);
2200 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2203 if (! c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
2206 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
2208 if (c_parser_next_token_is (parser
, CPP_EOF
))
2210 c_parser_error (parser
, "expected statement");
2214 switch (c_parser_peek_token (parser
)->keyword
)
2219 location_t loc
= c_parser_peek_token (parser
)->location
;
2220 c_parser_consume_token (parser
);
2222 if (c_parser_next_token_is (parser
, CPP_NAME
)
2223 || c_parser_peek_token (parser
)->type
== CPP_NUMBER
)
2224 exp1
= c_parser_gimple_postfix_expression (parser
);
2227 c_parser_error (parser
, "expected expression");
2231 if (c_parser_next_token_is (parser
, CPP_COLON
))
2233 c_parser_consume_token (parser
);
2234 if (c_parser_next_token_is (parser
, CPP_NAME
))
2236 label
= c_parser_peek_token (parser
)->value
;
2237 c_parser_consume_token (parser
);
2238 tree decl
= lookup_label_for_goto (loc
, label
);
2239 case_label
= build_case_label (exp1
.value
, NULL_TREE
,
2241 labels
.safe_push (case_label
);
2242 if (! c_parser_require (parser
, CPP_SEMICOLON
,
2246 else if (! c_parser_require (parser
, CPP_NAME
,
2250 else if (! c_parser_require (parser
, CPP_SEMICOLON
,
2257 location_t loc
= c_parser_peek_token (parser
)->location
;
2258 c_parser_consume_token (parser
);
2259 if (c_parser_next_token_is (parser
, CPP_COLON
))
2261 c_parser_consume_token (parser
);
2262 if (c_parser_next_token_is (parser
, CPP_NAME
))
2264 label
= c_parser_peek_token (parser
)->value
;
2265 c_parser_consume_token (parser
);
2266 tree decl
= lookup_label_for_goto (loc
, label
);
2267 default_label
= build_case_label (NULL_TREE
, NULL_TREE
,
2269 if (! c_parser_require (parser
, CPP_SEMICOLON
,
2273 else if (! c_parser_require (parser
, CPP_NAME
,
2277 else if (! c_parser_require (parser
, CPP_SEMICOLON
,
2283 c_parser_error (parser
, "expected case label");
2288 if (! c_parser_require (parser
, CPP_CLOSE_BRACE
, "expected %<}%>"))
2291 if (cond_expr
.value
!= error_mark_node
)
2293 gswitch
*s
= gimple_build_switch (cond_expr
.value
, default_label
, labels
);
2294 gimple_seq_add_stmt_without_update (seq
, s
);
2298 /* Parse gimple return statement. */
2301 c_parser_gimple_return_stmt (gimple_parser
&parser
, gimple_seq
*seq
)
2303 location_t loc
= c_parser_peek_token (parser
)->location
;
2305 c_parser_consume_token (parser
);
2306 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2308 c_finish_gimple_return (loc
, NULL_TREE
);
2309 ret
= gimple_build_return (NULL
);
2310 gimple_seq_add_stmt_without_update (seq
, ret
);
2314 location_t xloc
= c_parser_peek_token (parser
)->location
;
2315 c_expr expr
= c_parser_gimple_unary_expression (parser
);
2316 if (expr
.value
!= error_mark_node
)
2318 c_finish_gimple_return (xloc
, expr
.value
);
2319 ret
= gimple_build_return (expr
.value
);
2320 gimple_seq_add_stmt_without_update (seq
, ret
);
2325 /* Support function for c_parser_gimple_return_stmt. */
2328 c_finish_gimple_return (location_t loc
, tree retval
)
2330 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
2332 /* Use the expansion point to handle cases such as returning NULL
2333 in a function returning void. */
2334 location_t xloc
= expansion_point_location_if_in_system_header (loc
);
2336 if (TREE_THIS_VOLATILE (current_function_decl
))
2337 warning_at (xloc
, 0,
2338 "function declared %<noreturn%> has a %<return%> statement");
2341 current_function_returns_null
= 1;
2342 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
2344 current_function_returns_null
= 1;
2345 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
2348 (xloc
, "%<return%> with a value, in function returning void");
2349 inform (DECL_SOURCE_LOCATION (current_function_decl
),
2353 else if (TREE_CODE (valtype
) != TREE_CODE (TREE_TYPE (retval
)))
2356 (xloc
, "invalid conversion in return statement");
2357 inform (DECL_SOURCE_LOCATION (current_function_decl
),