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 / 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
472 c_parser_gimple_binary_expression (c_parser
*parser
)
474 /* Location of the binary operator. */
475 struct c_expr ret
, lhs
, rhs
;
476 enum tree_code code
= ERROR_MARK
;
478 lhs
= c_parser_gimple_postfix_expression (parser
);
479 if (c_parser_error (parser
))
481 tree ret_type
= TREE_TYPE (lhs
.value
);
482 switch (c_parser_peek_token (parser
)->type
)
488 code
= TRUNC_DIV_EXPR
;
491 code
= TRUNC_MOD_EXPR
;
494 if (POINTER_TYPE_P (TREE_TYPE (lhs
.value
)))
495 code
= POINTER_PLUS_EXPR
;
510 ret_type
= boolean_type_node
;
514 ret_type
= boolean_type_node
;
518 ret_type
= boolean_type_node
;
522 ret_type
= boolean_type_node
;
526 ret_type
= boolean_type_node
;
530 ret_type
= boolean_type_node
;
542 c_parser_error (parser
, "%<&&%> not valid in GIMPLE");
545 c_parser_error (parser
, "%<||%> not valid in GIMPLE");
548 /* Not a binary expression. */
551 location_t ret_loc
= c_parser_peek_token (parser
)->location
;
552 c_parser_consume_token (parser
);
553 rhs
= c_parser_gimple_postfix_expression (parser
);
554 if (lhs
.value
!= error_mark_node
&& rhs
.value
!= error_mark_node
)
555 ret
.value
= build2_loc (ret_loc
, code
, ret_type
, lhs
.value
, rhs
.value
);
559 /* Parse gimple unary expression.
561 gimple-unary-expression:
562 gimple-postfix-expression
563 unary-operator gimple-postfix-expression
565 unary-operator: one of
570 c_parser_gimple_unary_expression (c_parser
*parser
)
572 struct c_expr ret
, op
;
573 location_t op_loc
= c_parser_peek_token (parser
)->location
;
576 switch (c_parser_peek_token (parser
)->type
)
579 c_parser_consume_token (parser
);
580 op
= c_parser_gimple_postfix_expression (parser
);
581 mark_exp_read (op
.value
);
582 return parser_build_unary_op (op_loc
, ADDR_EXPR
, op
);
585 c_parser_consume_token (parser
);
586 op
= c_parser_gimple_postfix_expression (parser
);
587 if (op
.value
== error_mark_node
)
589 if (! POINTER_TYPE_P (TREE_TYPE (op
.value
)))
591 error_at (op_loc
, "expected pointer as argument of unary %<*%>");
594 finish
= op
.get_finish ();
595 location_t combined_loc
= make_location (op_loc
, op_loc
, finish
);
596 ret
.value
= build_simple_mem_ref_loc (combined_loc
, op
.value
);
597 TREE_SIDE_EFFECTS (ret
.value
)
598 = TREE_THIS_VOLATILE (ret
.value
)
599 = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op
.value
)));
600 ret
.src_range
.m_start
= op_loc
;
601 ret
.src_range
.m_finish
= finish
;
605 c_parser_consume_token (parser
);
606 op
= c_parser_gimple_postfix_expression (parser
);
607 return parser_build_unary_op (op_loc
, CONVERT_EXPR
, op
);
609 c_parser_consume_token (parser
);
610 op
= c_parser_gimple_postfix_expression (parser
);
611 return parser_build_unary_op (op_loc
, NEGATE_EXPR
, op
);
613 c_parser_consume_token (parser
);
614 op
= c_parser_gimple_postfix_expression (parser
);
615 return parser_build_unary_op (op_loc
, BIT_NOT_EXPR
, op
);
617 c_parser_error (parser
, "%<!%> not valid in GIMPLE");
620 switch (c_parser_peek_token (parser
)->keyword
)
623 c_parser_consume_token (parser
);
624 op
= c_parser_gimple_postfix_expression (parser
);
625 return parser_build_unary_op (op_loc
, REALPART_EXPR
, op
);
627 c_parser_consume_token (parser
);
628 op
= c_parser_gimple_postfix_expression (parser
);
629 return parser_build_unary_op (op_loc
, IMAGPART_EXPR
, op
);
631 return c_parser_gimple_postfix_expression (parser
);
635 tree id
= c_parser_peek_token (parser
)->value
;
636 if (strcmp (IDENTIFIER_POINTER (id
), "__ABS") == 0)
638 c_parser_consume_token (parser
);
639 op
= c_parser_gimple_postfix_expression (parser
);
640 return parser_build_unary_op (op_loc
, ABS_EXPR
, op
);
642 else if (strcmp (IDENTIFIER_POINTER (id
), "__ABSU") == 0)
644 c_parser_consume_token (parser
);
645 op
= c_parser_gimple_postfix_expression (parser
);
646 return parser_build_unary_op (op_loc
, ABSU_EXPR
, op
);
649 return c_parser_gimple_postfix_expression (parser
);
652 return c_parser_gimple_postfix_expression (parser
);
656 /* Decompose ID into base name (ID until ver_offset) and VERSION. Return
657 true if ID matches a SSA name. */
660 c_parser_parse_ssa_name_id (tree id
, unsigned *version
, unsigned *ver_offset
)
662 const char *token
= IDENTIFIER_POINTER (id
);
663 const char *var_version
= strrchr (token
, '_');
667 *ver_offset
= var_version
- token
;
668 for (const char *p
= var_version
+ 1; *p
; ++p
)
671 *version
= atoi (var_version
+ 1);
675 /* Get at the actual SSA name ID with VERSION starting at VER_OFFSET.
676 TYPE is the type if the SSA name is being declared. */
679 c_parser_parse_ssa_name (c_parser
*parser
,
680 tree id
, tree type
, unsigned version
,
683 tree name
= NULL_TREE
;
684 const char *token
= IDENTIFIER_POINTER (id
);
688 /* Anonymous unnamed SSA name. */
689 if (version
< num_ssa_names
)
690 name
= ssa_name (version
);
695 c_parser_error (parser
, "SSA name undeclared");
696 return error_mark_node
;
698 name
= make_ssa_name_fn (cfun
, type
, NULL
, version
);
703 if (version
< num_ssa_names
)
704 name
= ssa_name (version
);
707 /* Separate var name from version. */
708 char *var_name
= XNEWVEC (char, ver_offset
+ 1);
709 memcpy (var_name
, token
, ver_offset
);
710 var_name
[ver_offset
] = '\0';
711 /* lookup for parent decl. */
712 id
= get_identifier (var_name
);
713 tree parent
= lookup_name (id
);
714 XDELETEVEC (var_name
);
715 if (! parent
|| parent
== error_mark_node
)
717 c_parser_error (parser
, "base variable or SSA name undeclared");
718 return error_mark_node
;
721 || TREE_CODE (parent
) == PARM_DECL
722 || TREE_CODE (parent
) == RESULT_DECL
))
724 error ("invalid base %qE for SSA name", parent
);
725 return error_mark_node
;
727 if (VECTOR_TYPE_P (TREE_TYPE (parent
))
728 || TREE_CODE (TREE_TYPE (parent
)) == COMPLEX_TYPE
)
729 DECL_GIMPLE_REG_P (parent
) = 1;
730 name
= make_ssa_name_fn (cfun
, parent
,
731 gimple_build_nop (), version
);
738 /* Parse a gimple call to an internal function.
740 gimple-call-internal:
741 . identifier ( gimple-argument-expression-list[opt] ) */
744 c_parser_gimple_call_internal (c_parser
*parser
)
749 gcc_assert (c_parser_next_token_is (parser
, CPP_DOT
));
750 c_parser_consume_token (parser
);
751 location_t loc
= c_parser_peek_token (parser
)->location
;
752 if (!c_parser_next_token_is (parser
, CPP_NAME
)
753 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
755 c_parser_error (parser
, "expecting internal function name");
758 tree id
= c_parser_peek_token (parser
)->value
;
759 internal_fn ifn
= lookup_internal_fn (IDENTIFIER_POINTER (id
));
760 c_parser_consume_token (parser
);
761 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
763 auto_vec
<tree
> exprlist
;
764 if (!c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
765 c_parser_gimple_expr_list (parser
, &exprlist
);
766 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
768 error_at (loc
, "unknown internal function %qE", id
);
771 expr
.value
= build_call_expr_internal_loc_array
772 (loc
, ifn
, void_type_node
, exprlist
.length (),
773 exprlist
.address ());
774 expr
.original_code
= ERROR_MARK
;
775 expr
.original_type
= NULL
;
781 /* Parse gimple postfix expression.
783 gimple-postfix-expression:
784 gimple-primary-expression
785 gimple-primary-expression [ gimple-primary-expression ]
786 gimple-primary-expression ( gimple-argument-expression-list[opt] )
787 gimple-postfix-expression . identifier
788 gimple-postfix-expression -> identifier
790 gimple-argument-expression-list:
791 gimple-unary-expression
792 gimple-argument-expression-list , gimple-unary-expression
794 gimple-primary-expression:
803 c_parser_gimple_postfix_expression (c_parser
*parser
)
805 location_t loc
= c_parser_peek_token (parser
)->location
;
806 source_range tok_range
= c_parser_peek_token (parser
)->get_range ();
809 switch (c_parser_peek_token (parser
)->type
)
812 expr
.value
= c_parser_peek_token (parser
)->value
;
813 set_c_expr_source_range (&expr
, tok_range
);
814 loc
= c_parser_peek_token (parser
)->location
;
815 c_parser_consume_token (parser
);
821 expr
.value
= c_parser_peek_token (parser
)->value
;
822 set_c_expr_source_range (&expr
, tok_range
);
823 c_parser_consume_token (parser
);
830 expr
.value
= c_parser_peek_token (parser
)->value
;
831 set_c_expr_source_range (&expr
, tok_range
);
832 expr
.original_code
= STRING_CST
;
833 c_parser_consume_token (parser
);
836 expr
= c_parser_gimple_call_internal (parser
);
839 if (c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
841 tree id
= c_parser_peek_token (parser
)->value
;
842 if (strcmp (IDENTIFIER_POINTER (id
), "__MEM") == 0)
844 /* __MEM '<' type-name [ ',' number ] '>'
845 '(' [ '(' type-name ')' ] unary-expression
846 [ '+' number ] ')' */
847 location_t loc
= c_parser_peek_token (parser
)->location
;
848 c_parser_consume_token (parser
);
849 struct c_type_name
*type_name
= NULL
;
850 tree alignment
= NULL_TREE
;
851 if (c_parser_require (parser
, CPP_LESS
, "expected %<<%>"))
853 type_name
= c_parser_type_name (parser
);
854 /* Optional alignment. */
855 if (c_parser_next_token_is (parser
, CPP_COMMA
))
857 c_parser_consume_token (parser
);
859 = c_parser_gimple_postfix_expression (parser
).value
;
861 c_parser_skip_until_found (parser
,
862 CPP_GREATER
, "expected %<>%>");
865 ptr
.value
= error_mark_node
;
866 tree alias_off
= NULL_TREE
;
867 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
869 tree alias_type
= NULL_TREE
;
870 /* Optional alias-type cast. */
871 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
873 c_parser_consume_token (parser
);
874 struct c_type_name
*alias_type_name
875 = c_parser_type_name (parser
);
876 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
881 alias_type
= groktypename (alias_type_name
,
885 ptr
= c_parser_gimple_unary_expression (parser
);
886 if (ptr
.value
== error_mark_node
887 || ! POINTER_TYPE_P (TREE_TYPE (ptr
.value
)))
889 if (ptr
.value
!= error_mark_node
)
890 error_at (ptr
.get_start (),
891 "invalid type of %<__MEM%> operand");
892 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
897 alias_type
= TREE_TYPE (ptr
.value
);
898 /* Optional constant offset. */
899 if (c_parser_next_token_is (parser
, CPP_PLUS
))
901 c_parser_consume_token (parser
);
903 = c_parser_gimple_postfix_expression (parser
).value
;
904 alias_off
= fold_convert (alias_type
, alias_off
);
907 alias_off
= build_int_cst (alias_type
, 0);
908 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
911 if (! type_name
|| c_parser_error (parser
))
913 c_parser_set_error (parser
, false);
916 tree tem
= NULL_TREE
;
917 tree type
= groktypename (type_name
, &tem
, NULL
);
919 type
= build_aligned_type (type
, tree_to_uhwi (alignment
));
920 expr
.value
= build2_loc (loc
, MEM_REF
,
921 type
, ptr
.value
, alias_off
);
924 else if (strcmp (IDENTIFIER_POINTER (id
), "_Literal") == 0)
926 /* _Literal '(' type-name ')' [ '-' ] constant */
927 c_parser_consume_token (parser
);
928 tree type
= NULL_TREE
;
929 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
931 struct c_type_name
*type_name
= c_parser_type_name (parser
);
934 type
= groktypename (type_name
, &tem
, NULL
);
935 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
939 if ((neg_p
= c_parser_next_token_is (parser
, CPP_MINUS
)))
940 c_parser_consume_token (parser
);
941 tree val
= c_parser_gimple_postfix_expression (parser
).value
;
944 || val
== error_mark_node
945 || ! CONSTANT_CLASS_P (val
))
947 c_parser_error (parser
, "invalid _Literal");
952 val
= const_unop (NEGATE_EXPR
, TREE_TYPE (val
), val
);
955 c_parser_error (parser
, "invalid _Literal");
959 expr
.value
= fold_convert (type
, val
);
964 unsigned version
, ver_offset
;
965 if (! lookup_name (id
)
966 && c_parser_parse_ssa_name_id (id
, &version
, &ver_offset
))
968 c_parser_consume_token (parser
);
969 expr
.value
= c_parser_parse_ssa_name (parser
, id
, NULL_TREE
,
970 version
, ver_offset
);
971 if (expr
.value
== error_mark_node
)
973 set_c_expr_source_range (&expr
, tok_range
);
974 /* For default definition SSA names. */
975 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
976 && c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
979 (c_parser_peek_2nd_token (parser
)->value
)) == 0
980 && c_parser_peek_nth_token (parser
, 3)->type
== CPP_CLOSE_PAREN
)
982 c_parser_consume_token (parser
);
983 c_parser_consume_token (parser
);
984 c_parser_consume_token (parser
);
985 if (! SSA_NAME_IS_DEFAULT_DEF (expr
.value
))
987 if (!SSA_NAME_VAR (expr
.value
))
989 error_at (loc
, "anonymous SSA name cannot have"
990 " default definition");
991 expr
.value
= error_mark_node
;
994 set_ssa_default_def (cfun
, SSA_NAME_VAR (expr
.value
),
996 SSA_NAME_DEF_STMT (expr
.value
) = gimple_build_nop ();
1002 c_parser_consume_token (parser
);
1004 = build_external_ref (loc
, id
,
1005 (c_parser_peek_token (parser
)->type
1006 == CPP_OPEN_PAREN
), &expr
.original_type
);
1007 set_c_expr_source_range (&expr
, tok_range
);
1013 c_parser_error (parser
, "expected expression");
1019 c_parser_error (parser
, "expected expression");
1023 return c_parser_gimple_postfix_expression_after_primary
1024 (parser
, EXPR_LOC_OR_LOC (expr
.value
, loc
), expr
);
1027 /* Parse a gimple postfix expression after the initial primary or compound
1030 static struct c_expr
1031 c_parser_gimple_postfix_expression_after_primary (c_parser
*parser
,
1032 location_t expr_loc
,
1038 location_t comp_loc
;
1042 location_t op_loc
= c_parser_peek_token (parser
)->location
;
1043 switch (c_parser_peek_token (parser
)->type
)
1045 case CPP_OPEN_SQUARE
:
1047 c_parser_consume_token (parser
);
1048 tree idx
= c_parser_gimple_unary_expression (parser
).value
;
1050 if (! c_parser_require (parser
, CPP_CLOSE_SQUARE
, "expected %<]%>"))
1052 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
1056 start
= expr
.get_start ();
1057 finish
= c_parser_tokens_buf (parser
, 0)->location
;
1058 expr
.value
= build_array_ref (op_loc
, expr
.value
, idx
);
1059 set_c_expr_source_range (&expr
, start
, finish
);
1061 expr
.original_code
= ERROR_MARK
;
1062 expr
.original_type
= NULL
;
1065 case CPP_OPEN_PAREN
:
1067 /* Function call. */
1068 c_parser_consume_token (parser
);
1069 auto_vec
<tree
> exprlist
;
1070 if (! c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
1071 c_parser_gimple_expr_list (parser
, &exprlist
);
1072 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1074 expr
.value
= build_call_array_loc
1075 (expr_loc
, TREE_TYPE (TREE_TYPE (expr
.value
)),
1076 expr
.value
, exprlist
.length (), exprlist
.address ());
1077 expr
.original_code
= ERROR_MARK
;
1078 expr
.original_type
= NULL
;
1083 /* Structure element reference. */
1084 c_parser_consume_token (parser
);
1085 if (c_parser_next_token_is (parser
, CPP_NAME
))
1087 c_token
*comp_tok
= c_parser_peek_token (parser
);
1088 ident
= comp_tok
->value
;
1089 comp_loc
= comp_tok
->location
;
1093 c_parser_error (parser
, "expected identifier");
1095 expr
.original_code
= ERROR_MARK
;
1096 expr
.original_type
= NULL
;
1099 start
= expr
.get_start ();
1100 finish
= c_parser_peek_token (parser
)->get_finish ();
1101 c_parser_consume_token (parser
);
1102 expr
.value
= build_component_ref (op_loc
, expr
.value
, ident
,
1104 set_c_expr_source_range (&expr
, start
, finish
);
1105 expr
.original_code
= ERROR_MARK
;
1106 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1107 expr
.original_type
= NULL
;
1110 /* Remember the original type of a bitfield. */
1111 tree field
= TREE_OPERAND (expr
.value
, 1);
1112 if (TREE_CODE (field
) != FIELD_DECL
)
1113 expr
.original_type
= NULL
;
1115 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1121 /* Structure element reference. */
1122 c_parser_consume_token (parser
);
1123 if (c_parser_next_token_is (parser
, CPP_NAME
))
1125 c_token
*comp_tok
= c_parser_peek_token (parser
);
1126 ident
= comp_tok
->value
;
1127 comp_loc
= comp_tok
->location
;
1131 c_parser_error (parser
, "expected identifier");
1133 expr
.original_code
= ERROR_MARK
;
1134 expr
.original_type
= NULL
;
1137 start
= expr
.get_start ();
1138 finish
= c_parser_peek_token (parser
)->get_finish ();
1139 c_parser_consume_token (parser
);
1140 expr
.value
= build_component_ref (op_loc
,
1141 build_simple_mem_ref_loc
1142 (op_loc
, expr
.value
),
1144 set_c_expr_source_range (&expr
, start
, finish
);
1145 expr
.original_code
= ERROR_MARK
;
1146 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
1147 expr
.original_type
= NULL
;
1150 /* Remember the original type of a bitfield. */
1151 tree field
= TREE_OPERAND (expr
.value
, 1);
1152 if (TREE_CODE (field
) != FIELD_DECL
)
1153 expr
.original_type
= NULL
;
1155 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
1165 /* Parse expression list.
1168 gimple-unary-expression
1169 gimple-expr-list , gimple-unary-expression
1174 c_parser_gimple_expr_list (c_parser
*parser
, vec
<tree
> *ret
)
1178 expr
= c_parser_gimple_unary_expression (parser
);
1179 ret
->safe_push (expr
.value
);
1180 while (c_parser_next_token_is (parser
, CPP_COMMA
))
1182 c_parser_consume_token (parser
);
1183 expr
= c_parser_gimple_unary_expression (parser
);
1184 ret
->safe_push (expr
.value
);
1188 /* Parse gimple label.
1192 case constant-expression :
1198 c_parser_gimple_label (c_parser
*parser
, gimple_seq
*seq
)
1200 tree name
= c_parser_peek_token (parser
)->value
;
1201 location_t loc1
= c_parser_peek_token (parser
)->location
;
1202 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
1203 c_parser_consume_token (parser
);
1204 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
1205 c_parser_consume_token (parser
);
1206 tree label
= define_label (loc1
, name
);
1207 gimple_seq_add_stmt (seq
, gimple_build_label (label
));
1211 /* Parse gimple/RTL pass list.
1213 gimple-or-rtl-pass-list:
1214 startwith("pass-name")
1218 c_parser_gimple_or_rtl_pass_list (c_parser
*parser
)
1222 /* Accept __GIMPLE/__RTL. */
1223 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
1225 c_parser_consume_token (parser
);
1227 if (c_parser_next_token_is (parser
, CPP_NAME
))
1229 const char *op
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
1230 c_parser_consume_token (parser
);
1231 if (! strcmp (op
, "startwith"))
1233 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1235 if (c_parser_next_token_is_not (parser
, CPP_STRING
))
1237 error_at (c_parser_peek_token (parser
)->location
,
1238 "expected pass name");
1241 pass
= xstrdup (TREE_STRING_POINTER
1242 (c_parser_peek_token (parser
)->value
));
1243 c_parser_consume_token (parser
);
1244 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1249 error_at (c_parser_peek_token (parser
)->location
,
1250 "invalid operation");
1255 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1261 /* Parse gimple local declaration.
1263 declaration-specifiers:
1264 storage-class-specifier declaration-specifiers[opt]
1265 type-specifier declaration-specifiers[opt]
1266 type-qualifier declaration-specifiers[opt]
1267 function-specifier declaration-specifiers[opt]
1268 alignment-specifier declaration-specifiers[opt]
1270 storage-class-specifier:
1294 address-space-qualifier
1300 c_parser_gimple_declaration (c_parser
*parser
)
1302 struct c_declarator
*declarator
;
1303 struct c_declspecs
*specs
= build_null_declspecs ();
1304 c_parser_declspecs (parser
, specs
, true, true, true,
1305 true, true, cla_nonabstract_decl
);
1306 finish_declspecs (specs
);
1308 /* Provide better error recovery. Note that a type name here is usually
1309 better diagnosed as a redeclaration. */
1310 if (c_parser_next_token_starts_declspecs (parser
)
1311 && ! c_parser_next_token_is (parser
, CPP_NAME
))
1313 c_parser_error (parser
, "expected %<;%>");
1314 c_parser_set_error (parser
, false);
1319 declarator
= c_parser_declarator (parser
,
1320 specs
->typespec_kind
!= ctsk_none
,
1321 C_DTR_NORMAL
, &dummy
);
1323 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1325 /* Handle SSA name decls specially, they do not go into the identifier
1326 table but we simply build the SSA name for later lookup. */
1327 unsigned version
, ver_offset
;
1328 if (declarator
->kind
== cdk_id
1329 && is_gimple_reg_type (specs
->type
)
1330 && c_parser_parse_ssa_name_id (declarator
->u
.id
,
1331 &version
, &ver_offset
)
1332 /* The following restricts it to unnamed anonymous SSA names
1333 which fails parsing of named ones in dumps (we could
1334 decide to not dump their name for -gimple). */
1336 c_parser_parse_ssa_name (parser
, declarator
->u
.id
, specs
->type
,
1337 version
, ver_offset
);
1340 tree postfix_attrs
= NULL_TREE
;
1341 tree all_prefix_attrs
= specs
->attrs
;
1342 specs
->attrs
= NULL
;
1343 tree decl
= start_decl (declarator
, specs
, false,
1344 chainon (postfix_attrs
, all_prefix_attrs
));
1346 finish_decl (decl
, UNKNOWN_LOCATION
, NULL_TREE
, NULL_TREE
,
1352 c_parser_error (parser
, "expected %<;%>");
1357 /* Parse gimple goto statement. */
1360 c_parser_gimple_goto_stmt (location_t loc
, tree label
, gimple_seq
*seq
)
1362 tree decl
= lookup_label_for_goto (loc
, label
);
1363 gimple_seq_add_stmt (seq
, gimple_build_goto (decl
));
1367 /* Parse a parenthesized condition.
1369 ( gimple-binary-expression ) */
1372 c_parser_gimple_paren_condition (c_parser
*parser
)
1374 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1375 return error_mark_node
;
1376 tree cond
= c_parser_gimple_binary_expression (parser
).value
;
1377 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1378 return error_mark_node
;
1382 /* Parse gimple if-else statement.
1385 if ( gimple-binary-expression ) gimple-goto-statement
1386 if ( gimple-binary-expression ) gimple-goto-statement \
1387 else gimple-goto-statement
1391 c_parser_gimple_if_stmt (c_parser
*parser
, gimple_seq
*seq
)
1393 tree t_label
, f_label
, label
;
1395 c_parser_consume_token (parser
);
1396 tree cond
= c_parser_gimple_paren_condition (parser
);
1398 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
1400 loc
= c_parser_peek_token (parser
)->location
;
1401 c_parser_consume_token (parser
);
1402 if (! c_parser_next_token_is (parser
, CPP_NAME
))
1404 c_parser_error (parser
, "expected label");
1407 label
= c_parser_peek_token (parser
)->value
;
1408 c_parser_consume_token (parser
);
1409 t_label
= lookup_label_for_goto (loc
, label
);
1410 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
1415 c_parser_error (parser
, "expected goto expression");
1419 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
1420 c_parser_consume_token (parser
);
1423 c_parser_error (parser
, "expected else statement");
1427 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
1429 loc
= c_parser_peek_token (parser
)->location
;
1430 c_parser_consume_token (parser
);
1431 if (! c_parser_next_token_is (parser
, CPP_NAME
))
1433 c_parser_error (parser
, "expected label");
1436 label
= c_parser_peek_token (parser
)->value
;
1437 f_label
= lookup_label_for_goto (loc
, label
);
1438 c_parser_consume_token (parser
);
1439 if (! c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
1444 c_parser_error (parser
, "expected goto expression");
1448 if (cond
!= error_mark_node
)
1449 gimple_seq_add_stmt (seq
, gimple_build_cond_from_tree (cond
, t_label
,
1453 /* Parse gimple switch-statement.
1455 gimple-switch-statement:
1456 switch (gimple-postfix-expression) gimple-case-statement
1458 gimple-case-statement:
1459 gimple-case-statement
1460 gimple-label-statement : gimple-goto-statment
1464 c_parser_gimple_switch_stmt (c_parser
*parser
, gimple_seq
*seq
)
1467 tree case_label
, label
;
1468 auto_vec
<tree
> labels
;
1469 tree default_label
= NULL_TREE
;
1470 gimple_seq switch_body
= NULL
;
1471 c_parser_consume_token (parser
);
1473 if (! c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1475 cond_expr
= c_parser_gimple_postfix_expression (parser
);
1476 if (! c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
1479 if (! c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
1482 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
1484 if (c_parser_next_token_is (parser
, CPP_EOF
))
1486 c_parser_error (parser
, "expected statement");
1490 switch (c_parser_peek_token (parser
)->keyword
)
1495 location_t loc
= c_parser_peek_token (parser
)->location
;
1496 c_parser_consume_token (parser
);
1498 if (c_parser_next_token_is (parser
, CPP_NAME
)
1499 || c_parser_peek_token (parser
)->type
== CPP_NUMBER
)
1500 exp1
= c_parser_gimple_postfix_expression (parser
);
1503 c_parser_error (parser
, "expected expression");
1507 if (c_parser_next_token_is (parser
, CPP_COLON
))
1509 c_parser_consume_token (parser
);
1510 if (c_parser_next_token_is (parser
, CPP_NAME
))
1512 label
= c_parser_peek_token (parser
)->value
;
1513 c_parser_consume_token (parser
);
1514 tree decl
= lookup_label_for_goto (loc
, label
);
1515 case_label
= build_case_label (exp1
.value
, NULL_TREE
,
1517 labels
.safe_push (case_label
);
1518 if (! c_parser_require (parser
, CPP_SEMICOLON
,
1522 else if (! c_parser_require (parser
, CPP_NAME
,
1526 else if (! c_parser_require (parser
, CPP_SEMICOLON
,
1533 location_t loc
= c_parser_peek_token (parser
)->location
;
1534 c_parser_consume_token (parser
);
1535 if (c_parser_next_token_is (parser
, CPP_COLON
))
1537 c_parser_consume_token (parser
);
1538 if (c_parser_next_token_is (parser
, CPP_NAME
))
1540 label
= c_parser_peek_token (parser
)->value
;
1541 c_parser_consume_token (parser
);
1542 tree decl
= lookup_label_for_goto (loc
, label
);
1543 default_label
= build_case_label (NULL_TREE
, NULL_TREE
,
1545 if (! c_parser_require (parser
, CPP_SEMICOLON
,
1549 else if (! c_parser_require (parser
, CPP_NAME
,
1553 else if (! c_parser_require (parser
, CPP_SEMICOLON
,
1560 location_t loc
= c_parser_peek_token (parser
)->location
;
1561 c_parser_consume_token (parser
);
1562 if (c_parser_next_token_is (parser
, CPP_NAME
))
1564 c_parser_gimple_goto_stmt (loc
,
1568 c_parser_consume_token (parser
);
1569 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1570 c_parser_consume_token (parser
);
1573 c_parser_error (parser
, "expected semicolon");
1577 else if (! c_parser_require (parser
, CPP_NAME
,
1583 c_parser_error (parser
, "expected case label or goto statement");
1588 if (! c_parser_require (parser
, CPP_CLOSE_BRACE
, "expected %<}%>"))
1591 if (cond_expr
.value
!= error_mark_node
)
1593 gimple_seq_add_stmt (seq
, gimple_build_switch (cond_expr
.value
,
1594 default_label
, labels
));
1595 gimple_seq_add_seq (seq
, switch_body
);
1599 /* Parse gimple return statement. */
1602 c_parser_gimple_return_stmt (c_parser
*parser
, gimple_seq
*seq
)
1604 location_t loc
= c_parser_peek_token (parser
)->location
;
1606 c_parser_consume_token (parser
);
1607 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1609 c_finish_gimple_return (loc
, NULL_TREE
);
1610 ret
= gimple_build_return (NULL
);
1611 gimple_seq_add_stmt (seq
, ret
);
1615 location_t xloc
= c_parser_peek_token (parser
)->location
;
1616 c_expr expr
= c_parser_gimple_unary_expression (parser
);
1617 if (expr
.value
!= error_mark_node
)
1619 c_finish_gimple_return (xloc
, expr
.value
);
1620 ret
= gimple_build_return (expr
.value
);
1621 gimple_seq_add_stmt (seq
, ret
);
1626 /* Support function for c_parser_gimple_return_stmt. */
1629 c_finish_gimple_return (location_t loc
, tree retval
)
1631 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
1633 /* Use the expansion point to handle cases such as returning NULL
1634 in a function returning void. */
1635 source_location xloc
= expansion_point_location_if_in_system_header (loc
);
1637 if (TREE_THIS_VOLATILE (current_function_decl
))
1638 warning_at (xloc
, 0,
1639 "function declared %<noreturn%> has a %<return%> statement");
1642 current_function_returns_null
= 1;
1643 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
1645 current_function_returns_null
= 1;
1646 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
1649 (xloc
, "%<return%> with a value, in function returning void");
1650 inform (DECL_SOURCE_LOCATION (current_function_decl
),
1654 else if (TREE_CODE (valtype
) != TREE_CODE (TREE_TYPE (retval
)))
1657 (xloc
, "invalid conversion in return statement");
1658 inform (DECL_SOURCE_LOCATION (current_function_decl
),