2 Copyright (C) 2016-2018 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"
59 /* Gimple parsing functions. */
60 static bool c_parser_gimple_compound_statement (c_parser
*, gimple_seq
*);
61 static void c_parser_gimple_label (c_parser
*, gimple_seq
*);
62 static void c_parser_gimple_statement (c_parser
*, gimple_seq
*);
63 static struct c_expr
c_parser_gimple_binary_expression (c_parser
*);
64 static struct c_expr
c_parser_gimple_unary_expression (c_parser
*);
65 static struct c_expr
c_parser_gimple_postfix_expression (c_parser
*);
66 static struct c_expr
c_parser_gimple_postfix_expression_after_primary (c_parser
*,
69 static void c_parser_gimple_declaration (c_parser
*);
70 static void c_parser_gimple_goto_stmt (location_t
, tree
, gimple_seq
*);
71 static void c_parser_gimple_if_stmt (c_parser
*, gimple_seq
*);
72 static void c_parser_gimple_switch_stmt (c_parser
*, gimple_seq
*);
73 static void c_parser_gimple_return_stmt (c_parser
*, gimple_seq
*);
74 static void c_finish_gimple_return (location_t
, tree
);
75 static tree
c_parser_gimple_paren_condition (c_parser
*);
76 static void c_parser_gimple_expr_list (c_parser
*, vec
<tree
> *);
79 /* Parse the body of a function declaration marked with "__GIMPLE". */
82 c_parser_parse_gimple_body (c_parser
*parser
)
84 gimple_seq seq
= NULL
;
85 gimple_seq body
= NULL
;
86 tree stmt
= push_stmt_list ();
88 location_t loc1
= c_parser_peek_token (parser
)->location
;
92 if (! c_parser_gimple_compound_statement (parser
, &seq
))
94 gimple
*ret
= gimple_build_return (NULL
);
95 gimple_seq_add_stmt (&seq
, ret
);
98 tree block
= pop_scope ();
99 stmt
= pop_stmt_list (stmt
);
100 stmt
= c_build_bind_expr (loc1
, block
, stmt
);
102 block
= DECL_INITIAL (current_function_decl
);
103 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
104 BLOCK_CHAIN (block
) = NULL_TREE
;
105 TREE_ASM_WRITTEN (block
) = 1;
107 gbind
*bind_stmt
= gimple_build_bind (BIND_EXPR_VARS (stmt
), NULL
,
108 BIND_EXPR_BLOCK (stmt
));
109 gimple_bind_set_body (bind_stmt
, seq
);
110 gimple_seq_add_stmt (&body
, bind_stmt
);
111 gimple_set_body (current_function_decl
, body
);
113 /* While we have SSA names in the IL we do not have a CFG built yet
114 and PHIs are represented using a PHI internal function. We do
115 have lowered control flow and exception handling (well, we do not
116 have parser support for EH yet). But as we still have BINDs
117 we have to go through lowering again. */
118 cfun
->curr_properties
= PROP_gimple_any
;
120 dump_function (TDI_gimple
, current_function_decl
);
123 /* Parse a compound statement in gimple function body.
127 gimple-declaration-statement
129 gimple-switch-statement
130 gimple-labeled-statement
131 gimple-expression-statement
132 gimple-goto-statement
134 gimple-return-statement
138 c_parser_gimple_compound_statement (c_parser
*parser
, gimple_seq
*seq
)
140 bool return_p
= false;
142 if (! c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
145 /* A compund statement starts with optional declarations. */
146 while (c_parser_next_tokens_start_declaration (parser
))
148 c_parser_gimple_declaration (parser
);
149 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
153 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
155 if (c_parser_error (parser
))
157 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
160 else if (c_parser_next_token_is (parser
, CPP_EOF
))
162 c_parser_error (parser
, "expected declaration or statement");
166 switch (c_parser_peek_token (parser
)->type
)
169 switch (c_parser_peek_token (parser
)->keyword
)
172 c_parser_gimple_if_stmt (parser
, seq
);
175 c_parser_gimple_switch_stmt (parser
, seq
);
179 location_t loc
= c_parser_peek_token (parser
)->location
;
180 c_parser_consume_token (parser
);
181 if (c_parser_next_token_is (parser
, CPP_NAME
))
183 c_parser_gimple_goto_stmt (loc
,
187 c_parser_consume_token (parser
);
188 if (! c_parser_require (parser
, CPP_SEMICOLON
,
196 c_parser_gimple_return_stmt (parser
, seq
);
197 if (! c_parser_require (parser
, CPP_SEMICOLON
,
206 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
208 c_parser_gimple_label (parser
, seq
);
216 location_t loc
= c_parser_peek_token (parser
)->location
;
217 c_parser_consume_token (parser
);
218 gimple
*nop
= gimple_build_nop ();
219 gimple_set_location (nop
, loc
);
220 gimple_seq_add_stmt (seq
, nop
);
226 c_parser_gimple_statement (parser
, seq
);
227 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
228 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
231 c_parser_consume_token (parser
);
235 /* Parse a gimple statement.
238 gimple-call-expression
239 gimple-assign-statement
242 gimple-assign-statement:
243 gimple-unary-expression = gimple-assign-rhs
246 gimple-cast-expression
247 gimple-unary-expression
248 gimple-binary-expression
249 gimple-call-expression
251 gimple-phi-statement:
252 identifier = __PHI ( label : gimple_primary-expression, ... )
255 gimple-primary-expression ( argument-list )
257 gimple-cast-expression:
258 ( type-name ) gimple-primary-expression
263 c_parser_gimple_statement (c_parser
*parser
, gimple_seq
*seq
)
265 struct c_expr lhs
, rhs
;
266 gimple
*assign
= NULL
;
268 tree arg
= NULL_TREE
;
269 auto_vec
<tree
> vargs
;
271 lhs
= c_parser_gimple_unary_expression (parser
);
272 loc
= EXPR_LOCATION (lhs
.value
);
275 /* GIMPLE call statement without LHS. */
276 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
277 && TREE_CODE (lhs
.value
) == CALL_EXPR
)
280 call
= gimple_build_call_from_tree (lhs
.value
, NULL
);
281 gimple_seq_add_stmt (seq
, call
);
282 gimple_set_location (call
, loc
);
286 /* All following cases are statements with LHS. */
287 if (! c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
290 /* Cast expression. */
291 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
292 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
294 c_parser_consume_token (parser
);
295 struct c_type_name
*type_name
= c_parser_type_name (parser
);
296 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
297 if (type_name
== NULL
)
299 /* ??? The actual type used in the cast expression is ignored as
300 in GIMPLE it is encoded by the type of the LHS. */
301 rhs
= c_parser_gimple_postfix_expression (parser
);
302 if (lhs
.value
!= error_mark_node
303 && rhs
.value
!= error_mark_node
)
305 enum tree_code code
= NOP_EXPR
;
306 if (VECTOR_TYPE_P (TREE_TYPE (lhs
.value
)))
308 code
= VIEW_CONVERT_EXPR
;
309 rhs
.value
= build1 (VIEW_CONVERT_EXPR
,
310 TREE_TYPE (lhs
.value
), rhs
.value
);
312 else if (FLOAT_TYPE_P (TREE_TYPE (lhs
.value
))
313 && ! FLOAT_TYPE_P (TREE_TYPE (rhs
.value
)))
315 else if (! FLOAT_TYPE_P (TREE_TYPE (lhs
.value
))
316 && FLOAT_TYPE_P (TREE_TYPE (rhs
.value
)))
317 code
= FIX_TRUNC_EXPR
;
318 assign
= gimple_build_assign (lhs
.value
, code
, rhs
.value
);
319 gimple_seq_add_stmt (seq
, assign
);
320 gimple_set_location (assign
, loc
);
325 /* Unary expression. */
326 switch (c_parser_peek_token (parser
)->type
)
330 tree id
= c_parser_peek_token (parser
)->value
;
331 if (strcmp (IDENTIFIER_POINTER (id
), "__ABS") == 0
332 || strcmp (IDENTIFIER_POINTER (id
), "__ABSU") == 0)
333 goto build_unary_expr
;
337 if (c_parser_peek_token (parser
)->keyword
!= RID_REALPART
338 && c_parser_peek_token (parser
)->keyword
!= RID_IMAGPART
)
346 case CPP_MULT
: /* pointer deref */
348 rhs
= c_parser_gimple_unary_expression (parser
);
349 if (rhs
.value
!= error_mark_node
)
351 assign
= gimple_build_assign (lhs
.value
, rhs
.value
);
352 gimple_set_location (assign
, loc
);
353 gimple_seq_add_stmt (seq
, assign
);
360 /* GIMPLE PHI statement. */
361 if (c_parser_next_token_is_keyword (parser
, RID_PHI
))
363 c_parser_consume_token (parser
);
365 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
368 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
369 c_parser_consume_token (parser
);
371 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
))
373 if (c_parser_next_token_is (parser
, CPP_NAME
)
374 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
376 arg
= lookup_label_for_goto (loc
,
377 c_parser_peek_token (parser
)->value
);
378 c_parser_consume_token (parser
);
380 if (c_parser_next_token_is (parser
, CPP_COLON
))
381 c_parser_consume_token (parser
);
382 vargs
.safe_push (arg
);
384 else if (c_parser_next_token_is (parser
, CPP_COMMA
))
385 c_parser_consume_token (parser
);
388 arg
= c_parser_gimple_unary_expression (parser
).value
;
389 vargs
.safe_push (arg
);
393 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
396 /* Build internal function for PHI. */
397 gcall
*call_stmt
= gimple_build_call_internal_vec (IFN_PHI
, vargs
);
398 gimple_call_set_lhs (call_stmt
, lhs
.value
);
399 gimple_set_location (call_stmt
, UNKNOWN_LOCATION
);
400 gimple_seq_add_stmt (seq
, call_stmt
);
404 /* GIMPLE call with lhs. */
405 if (c_parser_next_token_is (parser
, CPP_DOT
)
406 || (c_parser_next_token_is (parser
, CPP_NAME
)
407 && c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_PAREN
408 && lookup_name (c_parser_peek_token (parser
)->value
)))
410 rhs
= c_parser_gimple_unary_expression (parser
);
411 if (rhs
.value
!= error_mark_node
)
413 gimple
*call
= gimple_build_call_from_tree (rhs
.value
, NULL
);
414 gimple_call_set_lhs (call
, lhs
.value
);
415 gimple_seq_add_stmt (seq
, call
);
416 gimple_set_location (call
, loc
);
421 rhs
= c_parser_gimple_binary_expression (parser
);
422 if (lhs
.value
!= error_mark_node
423 && rhs
.value
!= error_mark_node
)
425 /* If we parsed a comparison and the next token is a '?' then
426 parse a conditional expression. */
427 if (COMPARISON_CLASS_P (rhs
.value
)
428 && c_parser_next_token_is (parser
, CPP_QUERY
))
430 struct c_expr trueval
, falseval
;
431 c_parser_consume_token (parser
);
432 trueval
= c_parser_gimple_postfix_expression (parser
);
433 falseval
.set_error ();
434 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
435 falseval
= c_parser_gimple_postfix_expression (parser
);
436 if (trueval
.value
== error_mark_node
437 || falseval
.value
== error_mark_node
)
439 rhs
.value
= build3_loc (loc
, COND_EXPR
, TREE_TYPE (trueval
.value
),
440 rhs
.value
, trueval
.value
, falseval
.value
);
442 assign
= gimple_build_assign (lhs
.value
, rhs
.value
);
443 gimple_seq_add_stmt (seq
, assign
);
444 gimple_set_location (assign
, loc
);
449 /* Parse gimple binary expr.
451 gimple-binary-expression:
452 gimple-unary-expression * gimple-unary-expression
453 gimple-unary-expression __MULT_HIGHPART gimple-unary-expression
454 gimple-unary-expression / gimple-unary-expression
455 gimple-unary-expression % gimple-unary-expression
456 gimple-unary-expression + gimple-unary-expression
457 gimple-unary-expression - gimple-unary-expression
458 gimple-unary-expression << gimple-unary-expression
459 gimple-unary-expression >> gimple-unary-expression
460 gimple-unary-expression < gimple-unary-expression
461 gimple-unary-expression > gimple-unary-expression
462 gimple-unary-expression <= gimple-unary-expression
463 gimple-unary-expression >= gimple-unary-expression
464 gimple-unary-expression == gimple-unary-expression
465 gimple-unary-expression != gimple-unary-expression
466 gimple-unary-expression & gimple-unary-expression
467 gimple-unary-expression ^ gimple-unary-expression
468 gimple-unary-expression | gimple-unary-expression
473 c_parser_gimple_binary_expression (c_parser
*parser
)
475 /* Location of the binary operator. */
476 struct c_expr ret
, lhs
, rhs
;
477 enum tree_code code
= ERROR_MARK
;
479 lhs
= c_parser_gimple_postfix_expression (parser
);
480 if (c_parser_error (parser
))
482 tree ret_type
= TREE_TYPE (lhs
.value
);
483 switch (c_parser_peek_token (parser
)->type
)
489 code
= TRUNC_DIV_EXPR
;
492 code
= TRUNC_MOD_EXPR
;
495 if (POINTER_TYPE_P (TREE_TYPE (lhs
.value
)))
496 code
= POINTER_PLUS_EXPR
;
511 ret_type
= boolean_type_node
;
515 ret_type
= boolean_type_node
;
519 ret_type
= boolean_type_node
;
523 ret_type
= boolean_type_node
;
527 ret_type
= boolean_type_node
;
531 ret_type
= boolean_type_node
;
543 c_parser_error (parser
, "%<&&%> not valid in GIMPLE");
546 c_parser_error (parser
, "%<||%> not valid in GIMPLE");
550 tree id
= c_parser_peek_token (parser
)->value
;
551 if (strcmp (IDENTIFIER_POINTER (id
), "__MULT_HIGHPART") == 0)
553 code
= MULT_HIGHPART_EXPR
;
559 /* Not a binary expression. */
562 location_t ret_loc
= c_parser_peek_token (parser
)->location
;
563 c_parser_consume_token (parser
);
564 rhs
= c_parser_gimple_postfix_expression (parser
);
565 if (lhs
.value
!= error_mark_node
&& rhs
.value
!= error_mark_node
)
566 ret
.value
= build2_loc (ret_loc
, code
, ret_type
, lhs
.value
, rhs
.value
);
570 /* Parse gimple unary expression.
572 gimple-unary-expression:
573 gimple-postfix-expression
574 unary-operator gimple-postfix-expression
576 unary-operator: one of
581 c_parser_gimple_unary_expression (c_parser
*parser
)
583 struct c_expr ret
, op
;
584 location_t op_loc
= c_parser_peek_token (parser
)->location
;
587 switch (c_parser_peek_token (parser
)->type
)
590 c_parser_consume_token (parser
);
591 op
= c_parser_gimple_postfix_expression (parser
);
592 mark_exp_read (op
.value
);
593 return parser_build_unary_op (op_loc
, ADDR_EXPR
, op
);
596 c_parser_consume_token (parser
);
597 op
= c_parser_gimple_postfix_expression (parser
);
598 if (op
.value
== error_mark_node
)
600 if (! POINTER_TYPE_P (TREE_TYPE (op
.value
)))
602 error_at (op_loc
, "expected pointer as argument of unary %<*%>");
605 finish
= op
.get_finish ();
606 location_t combined_loc
= make_location (op_loc
, op_loc
, finish
);
607 ret
.value
= build_simple_mem_ref_loc (combined_loc
, op
.value
);
608 TREE_SIDE_EFFECTS (ret
.value
)
609 = TREE_THIS_VOLATILE (ret
.value
)
610 = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op
.value
)));
611 ret
.src_range
.m_start
= op_loc
;
612 ret
.src_range
.m_finish
= finish
;
616 c_parser_consume_token (parser
);
617 op
= c_parser_gimple_postfix_expression (parser
);
618 return parser_build_unary_op (op_loc
, CONVERT_EXPR
, op
);
620 c_parser_consume_token (parser
);
621 op
= c_parser_gimple_postfix_expression (parser
);
622 return parser_build_unary_op (op_loc
, NEGATE_EXPR
, op
);
624 c_parser_consume_token (parser
);
625 op
= c_parser_gimple_postfix_expression (parser
);
626 return parser_build_unary_op (op_loc
, BIT_NOT_EXPR
, op
);
628 c_parser_error (parser
, "%<!%> not valid in GIMPLE");
631 switch (c_parser_peek_token (parser
)->keyword
)
634 c_parser_consume_token (parser
);
635 op
= c_parser_gimple_postfix_expression (parser
);
636 return parser_build_unary_op (op_loc
, REALPART_EXPR
, op
);
638 c_parser_consume_token (parser
);
639 op
= c_parser_gimple_postfix_expression (parser
);
640 return parser_build_unary_op (op_loc
, IMAGPART_EXPR
, op
);
642 return c_parser_gimple_postfix_expression (parser
);
646 tree id
= c_parser_peek_token (parser
)->value
;
647 if (strcmp (IDENTIFIER_POINTER (id
), "__ABS") == 0)
649 c_parser_consume_token (parser
);
650 op
= c_parser_gimple_postfix_expression (parser
);
651 return parser_build_unary_op (op_loc
, ABS_EXPR
, op
);
653 else if (strcmp (IDENTIFIER_POINTER (id
), "__ABSU") == 0)
655 c_parser_consume_token (parser
);
656 op
= c_parser_gimple_postfix_expression (parser
);
657 return parser_build_unary_op (op_loc
, ABSU_EXPR
, op
);
660 return c_parser_gimple_postfix_expression (parser
);
663 return c_parser_gimple_postfix_expression (parser
);
667 /* Decompose ID into base name (ID until ver_offset) and VERSION. Return
668 true if ID matches a SSA name. */
671 c_parser_parse_ssa_name_id (tree id
, unsigned *version
, unsigned *ver_offset
)
673 const char *token
= IDENTIFIER_POINTER (id
);
674 const char *var_version
= strrchr (token
, '_');
678 *ver_offset
= var_version
- token
;
679 for (const char *p
= var_version
+ 1; *p
; ++p
)
682 *version
= atoi (var_version
+ 1);
686 /* Get at the actual SSA name ID with VERSION starting at VER_OFFSET.
687 TYPE is the type if the SSA name is being declared. */
690 c_parser_parse_ssa_name (c_parser
*parser
,
691 tree id
, tree type
, unsigned version
,
694 tree name
= NULL_TREE
;
695 const char *token
= IDENTIFIER_POINTER (id
);
699 /* Anonymous unnamed SSA name. */
700 if (version
< num_ssa_names
)
701 name
= ssa_name (version
);
706 c_parser_error (parser
, "SSA name undeclared");
707 return error_mark_node
;
709 name
= make_ssa_name_fn (cfun
, type
, NULL
, version
);
714 if (version
< num_ssa_names
)
715 name
= ssa_name (version
);
718 /* Separate var name from version. */
719 char *var_name
= XNEWVEC (char, ver_offset
+ 1);
720 memcpy (var_name
, token
, ver_offset
);
721 var_name
[ver_offset
] = '\0';
722 /* lookup for parent decl. */
723 id
= get_identifier (var_name
);
724 tree parent
= lookup_name (id
);
725 XDELETEVEC (var_name
);
726 if (! parent
|| parent
== error_mark_node
)
728 c_parser_error (parser
, "base variable or SSA name undeclared");
729 return error_mark_node
;
732 || TREE_CODE (parent
) == PARM_DECL
733 || TREE_CODE (parent
) == RESULT_DECL
))
735 error ("invalid base %qE for SSA name", parent
);
736 return error_mark_node
;
738 if (VECTOR_TYPE_P (TREE_TYPE (parent
))
739 || TREE_CODE (TREE_TYPE (parent
)) == COMPLEX_TYPE
)
740 DECL_GIMPLE_REG_P (parent
) = 1;
741 name
= make_ssa_name_fn (cfun
, parent
,
742 gimple_build_nop (), version
);
749 /* Parse a gimple call to an internal function.
751 gimple-call-internal:
752 . identifier ( gimple-argument-expression-list[opt] ) */
755 c_parser_gimple_call_internal (c_parser
*parser
)
760 gcc_assert (c_parser_next_token_is (parser
, CPP_DOT
));
761 c_parser_consume_token (parser
);
762 location_t loc
= c_parser_peek_token (parser
)->location
;
763 if (!c_parser_next_token_is (parser
, CPP_NAME
)
764 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
766 c_parser_error (parser
, "expecting internal function name");
769 tree id
= c_parser_peek_token (parser
)->value
;
770 internal_fn ifn
= lookup_internal_fn (IDENTIFIER_POINTER (id
));
771 c_parser_consume_token (parser
);
772 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
774 auto_vec
<tree
> exprlist
;
775 if (!c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
776 c_parser_gimple_expr_list (parser
, &exprlist
);
777 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
779 error_at (loc
, "unknown internal function %qE", id
);
782 expr
.value
= build_call_expr_internal_loc_array
783 (loc
, ifn
, void_type_node
, exprlist
.length (),
784 exprlist
.address ());
785 expr
.original_code
= ERROR_MARK
;
786 expr
.original_type
= NULL
;
792 /* Parse gimple postfix expression.
794 gimple-postfix-expression:
795 gimple-primary-expression
796 gimple-primary-expression [ gimple-primary-expression ]
797 gimple-primary-expression ( gimple-argument-expression-list[opt] )
798 gimple-postfix-expression . identifier
799 gimple-postfix-expression -> identifier
801 gimple-argument-expression-list:
802 gimple-unary-expression
803 gimple-argument-expression-list , gimple-unary-expression
805 gimple-primary-expression:
814 c_parser_gimple_postfix_expression (c_parser
*parser
)
816 location_t loc
= c_parser_peek_token (parser
)->location
;
817 source_range tok_range
= c_parser_peek_token (parser
)->get_range ();
820 switch (c_parser_peek_token (parser
)->type
)
823 expr
.value
= c_parser_peek_token (parser
)->value
;
824 set_c_expr_source_range (&expr
, tok_range
);
825 loc
= c_parser_peek_token (parser
)->location
;
826 c_parser_consume_token (parser
);
832 expr
.value
= c_parser_peek_token (parser
)->value
;
833 set_c_expr_source_range (&expr
, tok_range
);
834 c_parser_consume_token (parser
);
841 expr
.value
= c_parser_peek_token (parser
)->value
;
842 set_c_expr_source_range (&expr
, tok_range
);
843 expr
.original_code
= STRING_CST
;
844 c_parser_consume_token (parser
);
847 expr
= c_parser_gimple_call_internal (parser
);
850 if (c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
852 tree id
= c_parser_peek_token (parser
)->value
;
853 if (strcmp (IDENTIFIER_POINTER (id
), "__MEM") == 0)
855 /* __MEM '<' type-name [ ',' number ] '>'
856 '(' [ '(' type-name ')' ] unary-expression
857 [ '+' number ] ')' */
858 location_t loc
= c_parser_peek_token (parser
)->location
;
859 c_parser_consume_token (parser
);
860 struct c_type_name
*type_name
= NULL
;
861 tree alignment
= NULL_TREE
;
862 if (c_parser_require (parser
, CPP_LESS
, "expected %<<%>"))
864 type_name
= c_parser_type_name (parser
);
865 /* Optional alignment. */
866 if (c_parser_next_token_is (parser
, CPP_COMMA
))
868 c_parser_consume_token (parser
);
870 = c_parser_gimple_postfix_expression (parser
).value
;
872 c_parser_skip_until_found (parser
,
873 CPP_GREATER
, "expected %<>%>");
876 ptr
.value
= error_mark_node
;
877 tree alias_off
= NULL_TREE
;
878 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
880 tree alias_type
= NULL_TREE
;
881 /* Optional alias-type cast. */
882 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
884 c_parser_consume_token (parser
);
885 struct c_type_name
*alias_type_name
886 = c_parser_type_name (parser
);
887 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
892 alias_type
= groktypename (alias_type_name
,
896 ptr
= c_parser_gimple_unary_expression (parser
);
897 if (ptr
.value
== error_mark_node
898 || ! POINTER_TYPE_P (TREE_TYPE (ptr
.value
)))
900 if (ptr
.value
!= error_mark_node
)
901 error_at (ptr
.get_start (),
902 "invalid type of %<__MEM%> operand");
903 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
908 alias_type
= TREE_TYPE (ptr
.value
);
909 /* Optional constant offset. */
910 if (c_parser_next_token_is (parser
, CPP_PLUS
))
912 c_parser_consume_token (parser
);
914 = c_parser_gimple_postfix_expression (parser
).value
;
915 alias_off
= fold_convert (alias_type
, alias_off
);
918 alias_off
= build_int_cst (alias_type
, 0);
919 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
922 if (! type_name
|| c_parser_error (parser
))
924 c_parser_set_error (parser
, false);
927 tree tem
= NULL_TREE
;
928 tree type
= groktypename (type_name
, &tem
, NULL
);
930 type
= build_aligned_type (type
, tree_to_uhwi (alignment
));
931 expr
.value
= build2_loc (loc
, MEM_REF
,
932 type
, ptr
.value
, alias_off
);
935 else if (strcmp (IDENTIFIER_POINTER (id
), "_Literal") == 0)
937 /* _Literal '(' type-name ')' [ '-' ] constant */
938 c_parser_consume_token (parser
);
939 tree type
= NULL_TREE
;
940 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
942 struct c_type_name
*type_name
= c_parser_type_name (parser
);
945 type
= groktypename (type_name
, &tem
, NULL
);
946 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
950 if ((neg_p
= c_parser_next_token_is (parser
, CPP_MINUS
)))
951 c_parser_consume_token (parser
);
952 tree val
= c_parser_gimple_postfix_expression (parser
).value
;
955 || val
== error_mark_node
956 || ! CONSTANT_CLASS_P (val
))
958 c_parser_error (parser
, "invalid _Literal");
963 val
= const_unop (NEGATE_EXPR
, TREE_TYPE (val
), val
);
966 c_parser_error (parser
, "invalid _Literal");
970 expr
.value
= fold_convert (type
, val
);
975 unsigned version
, ver_offset
;
976 if (! lookup_name (id
)
977 && c_parser_parse_ssa_name_id (id
, &version
, &ver_offset
))
979 c_parser_consume_token (parser
);
980 expr
.value
= c_parser_parse_ssa_name (parser
, id
, NULL_TREE
,
981 version
, ver_offset
);
982 if (expr
.value
== error_mark_node
)
984 set_c_expr_source_range (&expr
, tok_range
);
985 /* For default definition SSA names. */
986 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
987 && c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
990 (c_parser_peek_2nd_token (parser
)->value
)) == 0
991 && c_parser_peek_nth_token (parser
, 3)->type
== CPP_CLOSE_PAREN
)
993 c_parser_consume_token (parser
);
994 c_parser_consume_token (parser
);
995 c_parser_consume_token (parser
);
996 if (! SSA_NAME_IS_DEFAULT_DEF (expr
.value
))
998 if (!SSA_NAME_VAR (expr
.value
))
1000 error_at (loc
, "anonymous SSA name cannot have"
1001 " default definition");
1002 expr
.value
= error_mark_node
;
1005 set_ssa_default_def (cfun
, SSA_NAME_VAR (expr
.value
),
1007 SSA_NAME_DEF_STMT (expr
.value
) = gimple_build_nop ();
1013 c_parser_consume_token (parser
);
1015 = build_external_ref (loc
, id
,
1016 (c_parser_peek_token (parser
)->type
1017 == CPP_OPEN_PAREN
), &expr
.original_type
);
1018 set_c_expr_source_range (&expr
, tok_range
);
1024 c_parser_error (parser
, "expected expression");
1030 c_parser_error (parser
, "expected expression");
1034 return c_parser_gimple_postfix_expression_after_primary
1035 (parser
, EXPR_LOC_OR_LOC (expr
.value
, loc
), expr
);
1038 /* Parse a gimple postfix expression after the initial primary or compound
1041 static struct c_expr
1042 c_parser_gimple_postfix_expression_after_primary (c_parser
*parser
,
1043 location_t expr_loc
,
1049 location_t comp_loc
;
1053 location_t op_loc
= c_parser_peek_token (parser
)->location
;
1054 switch (c_parser_peek_token (parser
)->type
)
1056 case CPP_OPEN_SQUARE
:
1058 c_parser_consume_token (parser
);
1059 tree idx
= c_parser_gimple_unary_expression (parser
).value
;
1061 if (! c_parser_require (parser
, CPP_CLOSE_SQUARE
, "expected %<]%>"))
1063 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
1067 start
= expr
.get_start ();
1068 finish
= c_parser_tokens_buf (parser
, 0)->location
;
1069 expr
.value
= build_array_ref (op_loc
, expr
.value
, idx
);
1070 set_c_expr_source_range (&expr
, start
, finish
);
1072 expr
.original_code
= ERROR_MARK
;
1073 expr
.original_type
= NULL
;
1076 case CPP_OPEN_PAREN
:
1078 /* Function call. */
1079 c_parser_consume_token (parser
);
1080 auto_vec
<tree
> exprlist
;
1081 if (! c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
1082 c_parser_gimple_expr_list (parser
, &exprlist
);
1083 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1085 expr
.value
= build_call_array_loc
1086 (expr_loc
, TREE_TYPE (TREE_TYPE (expr
.value
)),
1087 expr
.value
, exprlist
.length (), exprlist
.address ());
1088 expr
.original_code
= ERROR_MARK
;
1089 expr
.original_type
= NULL
;
1094 /* Structure element reference. */
1095 c_parser_consume_token (parser
);
1096 if (c_parser_next_token_is (parser
, CPP_NAME
))
1098 c_token
*comp_tok
= c_parser_peek_token (parser
);
1099 ident
= comp_tok
->value
;
1100 comp_loc
= comp_tok
->location
;
1104 c_parser_error (parser
, "expected identifier");
1106 expr
.original_code
= ERROR_MARK
;
1107 expr
.original_type
= NULL
;
1110 start
= expr
.get_start ();
1111 finish
= c_parser_peek_token (parser
)->get_finish ();
1112 c_parser_consume_token (parser
);
1113 expr
.value
= build_component_ref (op_loc
, expr
.value
, ident
,
1115 set_c_expr_source_range (&expr
, start
, finish
);
1116 expr
.original_code
= ERROR_MARK
;
1117 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1118 expr
.original_type
= NULL
;
1121 /* Remember the original type of a bitfield. */
1122 tree field
= TREE_OPERAND (expr
.value
, 1);
1123 if (TREE_CODE (field
) != FIELD_DECL
)
1124 expr
.original_type
= NULL
;
1126 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1132 /* Structure element reference. */
1133 c_parser_consume_token (parser
);
1134 if (c_parser_next_token_is (parser
, CPP_NAME
))
1136 c_token
*comp_tok
= c_parser_peek_token (parser
);
1137 ident
= comp_tok
->value
;
1138 comp_loc
= comp_tok
->location
;
1142 c_parser_error (parser
, "expected identifier");
1144 expr
.original_code
= ERROR_MARK
;
1145 expr
.original_type
= NULL
;
1148 start
= expr
.get_start ();
1149 finish
= c_parser_peek_token (parser
)->get_finish ();
1150 c_parser_consume_token (parser
);
1151 expr
.value
= build_component_ref (op_loc
,
1152 build_simple_mem_ref_loc
1153 (op_loc
, expr
.value
),
1155 set_c_expr_source_range (&expr
, start
, finish
);
1156 expr
.original_code
= ERROR_MARK
;
1157 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1158 expr
.original_type
= NULL
;
1161 /* Remember the original type of a bitfield. */
1162 tree field
= TREE_OPERAND (expr
.value
, 1);
1163 if (TREE_CODE (field
) != FIELD_DECL
)
1164 expr
.original_type
= NULL
;
1166 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1176 /* Parse expression list.
1179 gimple-unary-expression
1180 gimple-expr-list , gimple-unary-expression
1185 c_parser_gimple_expr_list (c_parser
*parser
, vec
<tree
> *ret
)
1189 expr
= c_parser_gimple_unary_expression (parser
);
1190 ret
->safe_push (expr
.value
);
1191 while (c_parser_next_token_is (parser
, CPP_COMMA
))
1193 c_parser_consume_token (parser
);
1194 expr
= c_parser_gimple_unary_expression (parser
);
1195 ret
->safe_push (expr
.value
);
1199 /* Parse gimple label.
1203 case constant-expression :
1209 c_parser_gimple_label (c_parser
*parser
, gimple_seq
*seq
)
1211 tree name
= c_parser_peek_token (parser
)->value
;
1212 location_t loc1
= c_parser_peek_token (parser
)->location
;
1213 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
1214 c_parser_consume_token (parser
);
1215 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
1216 c_parser_consume_token (parser
);
1217 tree label
= define_label (loc1
, name
);
1218 gimple_seq_add_stmt (seq
, gimple_build_label (label
));
1222 /* Parse gimple/RTL pass list.
1224 gimple-or-rtl-pass-list:
1225 startwith("pass-name")
1229 c_parser_gimple_or_rtl_pass_list (c_parser
*parser
)
1233 /* Accept __GIMPLE/__RTL. */
1234 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
1236 c_parser_consume_token (parser
);
1238 if (c_parser_next_token_is (parser
, CPP_NAME
))
1240 const char *op
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
1241 c_parser_consume_token (parser
);
1242 if (! strcmp (op
, "startwith"))
1244 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1246 if (c_parser_next_token_is_not (parser
, CPP_STRING
))
1248 error_at (c_parser_peek_token (parser
)->location
,
1249 "expected pass name");
1252 pass
= xstrdup (TREE_STRING_POINTER
1253 (c_parser_peek_token (parser
)->value
));
1254 c_parser_consume_token (parser
);
1255 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1260 error_at (c_parser_peek_token (parser
)->location
,
1261 "invalid operation");
1266 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1272 /* Parse gimple local declaration.
1274 declaration-specifiers:
1275 storage-class-specifier declaration-specifiers[opt]
1276 type-specifier declaration-specifiers[opt]
1277 type-qualifier declaration-specifiers[opt]
1278 function-specifier declaration-specifiers[opt]
1279 alignment-specifier declaration-specifiers[opt]
1281 storage-class-specifier:
1305 address-space-qualifier
1311 c_parser_gimple_declaration (c_parser
*parser
)
1313 struct c_declarator
*declarator
;
1314 struct c_declspecs
*specs
= build_null_declspecs ();
1315 c_parser_declspecs (parser
, specs
, true, true, true,
1316 true, true, cla_nonabstract_decl
);
1317 finish_declspecs (specs
);
1319 /* Provide better error recovery. Note that a type name here is usually
1320 better diagnosed as a redeclaration. */
1321 if (c_parser_next_token_starts_declspecs (parser
)
1322 && ! c_parser_next_token_is (parser
, CPP_NAME
))
1324 c_parser_error (parser
, "expected %<;%>");
1325 c_parser_set_error (parser
, false);
1330 declarator
= c_parser_declarator (parser
,
1331 specs
->typespec_kind
!= ctsk_none
,
1332 C_DTR_NORMAL
, &dummy
);
1334 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1336 /* Handle SSA name decls specially, they do not go into the identifier
1337 table but we simply build the SSA name for later lookup. */
1338 unsigned version
, ver_offset
;
1339 if (declarator
->kind
== cdk_id
1340 && is_gimple_reg_type (specs
->type
)
1341 && c_parser_parse_ssa_name_id (declarator
->u
.id
,
1342 &version
, &ver_offset
)
1343 /* The following restricts it to unnamed anonymous SSA names
1344 which fails parsing of named ones in dumps (we could
1345 decide to not dump their name for -gimple). */
1347 c_parser_parse_ssa_name (parser
, declarator
->u
.id
, specs
->type
,
1348 version
, ver_offset
);
1351 tree postfix_attrs
= NULL_TREE
;
1352 tree all_prefix_attrs
= specs
->attrs
;
1353 specs
->attrs
= NULL
;
1354 tree decl
= start_decl (declarator
, specs
, false,
1355 chainon (postfix_attrs
, all_prefix_attrs
));
1357 finish_decl (decl
, UNKNOWN_LOCATION
, NULL_TREE
, NULL_TREE
,
1363 c_parser_error (parser
, "expected %<;%>");
1368 /* Parse gimple goto statement. */
1371 c_parser_gimple_goto_stmt (location_t loc
, tree label
, gimple_seq
*seq
)
1373 tree decl
= lookup_label_for_goto (loc
, label
);
1374 gimple_seq_add_stmt (seq
, gimple_build_goto (decl
));
1378 /* Parse a parenthesized condition.
1380 ( gimple-binary-expression ) */
1383 c_parser_gimple_paren_condition (c_parser
*parser
)
1385 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1386 return error_mark_node
;
1387 tree cond
= c_parser_gimple_binary_expression (parser
).value
;
1388 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1389 return error_mark_node
;
1393 /* Parse gimple if-else statement.
1396 if ( gimple-binary-expression ) gimple-goto-statement
1397 if ( gimple-binary-expression ) gimple-goto-statement \
1398 else gimple-goto-statement
1402 c_parser_gimple_if_stmt (c_parser
*parser
, gimple_seq
*seq
)
1404 tree t_label
, f_label
, label
;
1406 c_parser_consume_token (parser
);
1407 tree cond
= c_parser_gimple_paren_condition (parser
);
1409 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
1411 loc
= c_parser_peek_token (parser
)->location
;
1412 c_parser_consume_token (parser
);
1413 if (! c_parser_next_token_is (parser
, CPP_NAME
))
1415 c_parser_error (parser
, "expected label");
1418 label
= c_parser_peek_token (parser
)->value
;
1419 c_parser_consume_token (parser
);
1420 t_label
= lookup_label_for_goto (loc
, label
);
1421 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
1426 c_parser_error (parser
, "expected goto expression");
1430 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
1431 c_parser_consume_token (parser
);
1434 c_parser_error (parser
, "expected else statement");
1438 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
1440 loc
= c_parser_peek_token (parser
)->location
;
1441 c_parser_consume_token (parser
);
1442 if (! c_parser_next_token_is (parser
, CPP_NAME
))
1444 c_parser_error (parser
, "expected label");
1447 label
= c_parser_peek_token (parser
)->value
;
1448 f_label
= lookup_label_for_goto (loc
, label
);
1449 c_parser_consume_token (parser
);
1450 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
1455 c_parser_error (parser
, "expected goto expression");
1459 if (cond
!= error_mark_node
)
1460 gimple_seq_add_stmt (seq
, gimple_build_cond_from_tree (cond
, t_label
,
1464 /* Parse gimple switch-statement.
1466 gimple-switch-statement:
1467 switch (gimple-postfix-expression) gimple-case-statement
1469 gimple-case-statement:
1470 gimple-case-statement
1471 gimple-label-statement : gimple-goto-statment
1475 c_parser_gimple_switch_stmt (c_parser
*parser
, gimple_seq
*seq
)
1478 tree case_label
, label
;
1479 auto_vec
<tree
> labels
;
1480 tree default_label
= NULL_TREE
;
1481 gimple_seq switch_body
= NULL
;
1482 c_parser_consume_token (parser
);
1484 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1486 cond_expr
= c_parser_gimple_postfix_expression (parser
);
1487 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1490 if (! c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
1493 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
1495 if (c_parser_next_token_is (parser
, CPP_EOF
))
1497 c_parser_error (parser
, "expected statement");
1501 switch (c_parser_peek_token (parser
)->keyword
)
1506 location_t loc
= c_parser_peek_token (parser
)->location
;
1507 c_parser_consume_token (parser
);
1509 if (c_parser_next_token_is (parser
, CPP_NAME
)
1510 || c_parser_peek_token (parser
)->type
== CPP_NUMBER
)
1511 exp1
= c_parser_gimple_postfix_expression (parser
);
1514 c_parser_error (parser
, "expected expression");
1518 if (c_parser_next_token_is (parser
, CPP_COLON
))
1520 c_parser_consume_token (parser
);
1521 if (c_parser_next_token_is (parser
, CPP_NAME
))
1523 label
= c_parser_peek_token (parser
)->value
;
1524 c_parser_consume_token (parser
);
1525 tree decl
= lookup_label_for_goto (loc
, label
);
1526 case_label
= build_case_label (exp1
.value
, NULL_TREE
,
1528 labels
.safe_push (case_label
);
1529 if (! c_parser_require (parser
, CPP_SEMICOLON
,
1533 else if (! c_parser_require (parser
, CPP_NAME
,
1537 else if (! c_parser_require (parser
, CPP_SEMICOLON
,
1544 location_t loc
= c_parser_peek_token (parser
)->location
;
1545 c_parser_consume_token (parser
);
1546 if (c_parser_next_token_is (parser
, CPP_COLON
))
1548 c_parser_consume_token (parser
);
1549 if (c_parser_next_token_is (parser
, CPP_NAME
))
1551 label
= c_parser_peek_token (parser
)->value
;
1552 c_parser_consume_token (parser
);
1553 tree decl
= lookup_label_for_goto (loc
, label
);
1554 default_label
= build_case_label (NULL_TREE
, NULL_TREE
,
1556 if (! c_parser_require (parser
, CPP_SEMICOLON
,
1560 else if (! c_parser_require (parser
, CPP_NAME
,
1564 else if (! c_parser_require (parser
, CPP_SEMICOLON
,
1571 location_t loc
= c_parser_peek_token (parser
)->location
;
1572 c_parser_consume_token (parser
);
1573 if (c_parser_next_token_is (parser
, CPP_NAME
))
1575 c_parser_gimple_goto_stmt (loc
,
1579 c_parser_consume_token (parser
);
1580 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1581 c_parser_consume_token (parser
);
1584 c_parser_error (parser
, "expected semicolon");
1588 else if (! c_parser_require (parser
, CPP_NAME
,
1594 c_parser_error (parser
, "expected case label or goto statement");
1599 if (! c_parser_require (parser
, CPP_CLOSE_BRACE
, "expected %<}%>"))
1602 if (cond_expr
.value
!= error_mark_node
)
1604 gimple_seq_add_stmt (seq
, gimple_build_switch (cond_expr
.value
,
1605 default_label
, labels
));
1606 gimple_seq_add_seq (seq
, switch_body
);
1610 /* Parse gimple return statement. */
1613 c_parser_gimple_return_stmt (c_parser
*parser
, gimple_seq
*seq
)
1615 location_t loc
= c_parser_peek_token (parser
)->location
;
1617 c_parser_consume_token (parser
);
1618 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1620 c_finish_gimple_return (loc
, NULL_TREE
);
1621 ret
= gimple_build_return (NULL
);
1622 gimple_seq_add_stmt (seq
, ret
);
1626 location_t xloc
= c_parser_peek_token (parser
)->location
;
1627 c_expr expr
= c_parser_gimple_unary_expression (parser
);
1628 if (expr
.value
!= error_mark_node
)
1630 c_finish_gimple_return (xloc
, expr
.value
);
1631 ret
= gimple_build_return (expr
.value
);
1632 gimple_seq_add_stmt (seq
, ret
);
1637 /* Support function for c_parser_gimple_return_stmt. */
1640 c_finish_gimple_return (location_t loc
, tree retval
)
1642 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
1644 /* Use the expansion point to handle cases such as returning NULL
1645 in a function returning void. */
1646 location_t xloc
= expansion_point_location_if_in_system_header (loc
);
1648 if (TREE_THIS_VOLATILE (current_function_decl
))
1649 warning_at (xloc
, 0,
1650 "function declared %<noreturn%> has a %<return%> statement");
1653 current_function_returns_null
= 1;
1654 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
1656 current_function_returns_null
= 1;
1657 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
1660 (xloc
, "%<return%> with a value, in function returning void");
1661 inform (DECL_SOURCE_LOCATION (current_function_decl
),
1665 else if (TREE_CODE (valtype
) != TREE_CODE (TREE_TYPE (retval
)))
1668 (xloc
, "invalid conversion in return statement");
1669 inform (DECL_SOURCE_LOCATION (current_function_decl
),