1 /* Parser for GIMPLE. 2 Copyright (C) 2016-2019 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 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 9 version. 10 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 14 for more details. 15 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/>. */ 19 20 #include "config.h" 21 #include "system.h" 22 #include "coretypes.h" 23 #include "target.h" 24 #include "function.h" 25 #include "c-tree.h" 26 #include "timevar.h" 27 #include "stringpool.h" 28 #include "cgraph.h" 29 #include "attribs.h" 30 #include "stor-layout.h" 31 #include "varasm.h" 32 #include "trans-mem.h" 33 #include "c-family/c-pragma.h" 34 #include "c-lang.h" 35 #include "c-family/c-objc.h" 36 #include "plugin.h" 37 #include "builtins.h" 38 #include "gomp-constants.h" 39 #include "c-family/c-indentation.h" 40 #include "gimple-expr.h" 41 #include "context.h" 42 #include "gcc-rich-location.h" 43 #include "c-parser.h" 44 #include "tree-vrp.h" 45 #include "tree-pass.h" 46 #include "tree-pretty-print.h" 47 #include "tree.h" 48 #include "basic-block.h" 49 #include "gimple.h" 50 #include "gimple-pretty-print.h" 51 #include "tree-ssa.h" 52 #include "pass_manager.h" 53 #include "tree-ssanames.h" 54 #include "gimple-ssa.h" 55 #include "tree-dfa.h" 56 #include "internal-fn.h" 57 #include "cfg.h" 58 #include "cfghooks.h" 59 #include "cfganal.h" 60 #include "tree-cfg.h" 61 #include "gimple-iterator.h" 62 #include "cfgloop.h" 63 #include "tree-phinodes.h" 64 #include "tree-into-ssa.h" 65 #include "bitmap.h" 66 67 68 /* GIMPLE parser state. */ 69 70 struct gimple_parser 71 { 72 gimple_parser (c_parser *p) : parser (p), edges(), current_bb(NULL) {} 73 /* c_parser is not visible here, use composition and fake inheritance 74 via a conversion operator. */ 75 operator c_parser *() { return parser; } 76 c_parser *parser; 77 78 /* CFG build state. */ 79 struct gimple_parser_edge 80 { 81 int src; 82 int dest; 83 int flags; 84 }; 85 auto_vec<gimple_parser_edge> edges; 86 basic_block current_bb; 87 88 void push_edge (int, int, int); 89 }; 90 91 void 92 gimple_parser::push_edge (int src, int dest, int flags) 93 { 94 gimple_parser_edge e; 95 e.src = src; 96 e.dest = dest; 97 e.flags = flags; 98 edges.safe_push (e); 99 } 100 101 102 /* Gimple parsing functions. */ 103 static bool c_parser_gimple_compound_statement (gimple_parser &, gimple_seq *); 104 static void c_parser_gimple_label (gimple_parser &, gimple_seq *); 105 static void c_parser_gimple_statement (gimple_parser &, gimple_seq *); 106 static struct c_expr c_parser_gimple_binary_expression (gimple_parser &); 107 static struct c_expr c_parser_gimple_unary_expression (gimple_parser &); 108 static struct c_expr c_parser_gimple_postfix_expression (gimple_parser &); 109 static struct c_expr c_parser_gimple_postfix_expression_after_primary 110 (gimple_parser &, location_t, struct c_expr); 111 static void c_parser_gimple_declaration (gimple_parser &); 112 static void c_parser_gimple_goto_stmt (gimple_parser &, location_t, 113 tree, gimple_seq *); 114 static void c_parser_gimple_if_stmt (gimple_parser &, gimple_seq *); 115 static void c_parser_gimple_switch_stmt (gimple_parser &, gimple_seq *); 116 static void c_parser_gimple_return_stmt (gimple_parser &, gimple_seq *); 117 static void c_finish_gimple_return (location_t, tree); 118 static tree c_parser_gimple_paren_condition (gimple_parser &); 119 static void c_parser_gimple_expr_list (gimple_parser &, vec<tree> *); 120 121 122 /* See if VAL is an identifier matching __BB<num> and return <num> 123 in *INDEX. Return true if so. */ 124 125 static bool 126 c_parser_gimple_parse_bb_spec (tree val, int *index) 127 { 128 if (strncmp (IDENTIFIER_POINTER (val), "__BB", 4) != 0) 129 return false; 130 for (const char *p = IDENTIFIER_POINTER (val) + 4; *p; ++p) 131 if (!ISDIGIT (*p)) 132 return false; 133 *index = atoi (IDENTIFIER_POINTER (val) + 4); 134 return *index > 0; 135 } 136 137 /* Parse the body of a function declaration marked with "__GIMPLE". */ 138 139 void 140 c_parser_parse_gimple_body (c_parser *cparser, char *gimple_pass, 141 enum c_declspec_il cdil) 142 { 143 gimple_parser parser (cparser); 144 gimple_seq seq = NULL; 145 gimple_seq body = NULL; 146 tree stmt = push_stmt_list (); 147 push_scope (); 148 location_t loc1 = c_parser_peek_token (parser)->location; 149 150 cfun->pass_startwith = gimple_pass; 151 init_tree_ssa (cfun); 152 153 if (cdil == cdil_gimple) 154 /* While we have SSA names in the IL we do not have a CFG built yet 155 and PHIs are represented using a PHI internal function. We do 156 have lowered control flow and exception handling (well, we do not 157 have parser support for EH yet). But as we still have BINDs 158 we have to go through lowering again. */ 159 cfun->curr_properties = PROP_gimple_any; 160 else 161 { 162 /* We have at least cdil_gimple_cfg. */ 163 gimple_register_cfg_hooks (); 164 init_empty_tree_cfg (); 165 /* Initialize the bare loop structure - we are going to only 166 mark headers and leave the rest to fixup. */ 167 set_loops_for_fn (cfun, ggc_cleared_alloc<struct loops> ()); 168 init_loops_structure (cfun, loops_for_fn (cfun), 1); 169 loops_state_set (cfun, LOOPS_NEED_FIXUP|LOOPS_MAY_HAVE_MULTIPLE_LATCHES); 170 cfun->curr_properties 171 |= PROP_gimple_lcf | PROP_gimple_leh | PROP_cfg | PROP_loops; 172 if (cdil == cdil_gimple_ssa) 173 { 174 init_ssa_operands (cfun); 175 cfun->curr_properties |= PROP_ssa; 176 } 177 } 178 179 if (! c_parser_gimple_compound_statement (parser, &seq) 180 && cdil == cdil_gimple) 181 { 182 gimple *ret = gimple_build_return (NULL); 183 gimple_seq_add_stmt_without_update (&seq, ret); 184 } 185 186 tree block = pop_scope (); 187 stmt = pop_stmt_list (stmt); 188 stmt = c_build_bind_expr (loc1, block, stmt); 189 190 block = DECL_INITIAL (current_function_decl); 191 BLOCK_SUBBLOCKS (block) = NULL_TREE; 192 BLOCK_CHAIN (block) = NULL_TREE; 193 TREE_ASM_WRITTEN (block) = 1; 194 195 if (cdil == cdil_gimple) 196 { 197 gbind *bind_stmt = gimple_build_bind (BIND_EXPR_VARS (stmt), NULL, 198 BIND_EXPR_BLOCK (stmt)); 199 gimple_bind_set_body (bind_stmt, seq); 200 gimple_seq_add_stmt_without_update (&body, bind_stmt); 201 gimple_set_body (current_function_decl, body); 202 } 203 else 204 { 205 /* Control-flow and binds are lowered, record local decls. */ 206 for (tree var = BIND_EXPR_VARS (stmt); var; var = DECL_CHAIN (var)) 207 if (VAR_P (var) 208 && !DECL_EXTERNAL (var)) 209 add_local_decl (cfun, var); 210 /* We have a CFG. Build the edges. */ 211 for (unsigned i = 0; i < parser.edges.length (); ++i) 212 make_edge (BASIC_BLOCK_FOR_FN (cfun, parser.edges[i].src), 213 BASIC_BLOCK_FOR_FN (cfun, parser.edges[i].dest), 214 parser.edges[i].flags); 215 /* Add edges for case labels. */ 216 basic_block bb; 217 FOR_EACH_BB_FN (bb, cfun) 218 if (EDGE_COUNT (bb->succs) == 0) 219 { 220 gimple *last = last_stmt (bb); 221 if (gswitch *sw = safe_dyn_cast <gswitch *> (last)) 222 for (unsigned i = 0; i < gimple_switch_num_labels (sw); ++i) 223 { 224 basic_block label_bb = gimple_switch_label_bb (cfun, sw, i); 225 make_edge (bb, label_bb, 0); 226 } 227 } 228 /* Need those for loop fixup. */ 229 calculate_dominance_info (CDI_DOMINATORS); 230 /* With SSA lower PHIs parsed as internal function calls and 231 update stmts. */ 232 if (cdil == cdil_gimple_ssa) 233 { 234 /* Create PHI nodes, they are parsed into __PHI internal calls. */ 235 FOR_EACH_BB_FN (bb, cfun) 236 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); 237 !gsi_end_p (gsi);) 238 { 239 gimple *stmt = gsi_stmt (gsi); 240 if (!gimple_call_internal_p (stmt, IFN_PHI)) 241 break; 242 243 gphi *phi = create_phi_node (gimple_call_lhs (stmt), bb); 244 for (unsigned i = 0; i < gimple_call_num_args (stmt); i += 2) 245 { 246 int srcidx = TREE_INT_CST_LOW (gimple_call_arg (stmt, i)); 247 edge e = find_edge (BASIC_BLOCK_FOR_FN (cfun, srcidx), bb); 248 if (!e) 249 c_parser_error (parser, "edge not found"); 250 else 251 add_phi_arg (phi, gimple_call_arg (stmt, i + 1), e, 252 UNKNOWN_LOCATION); 253 } 254 gsi_remove (&gsi, false); 255 } 256 /* Fill SSA name gaps, putting them on the freelist. */ 257 for (unsigned i = 1; i < num_ssa_names; ++i) 258 if (!ssa_name (i)) 259 { 260 tree name = make_ssa_name_fn (cfun, integer_type_node, NULL, i); 261 release_ssa_name_fn (cfun, name); 262 } 263 /* No explicit virtual operands (yet). */ 264 bitmap_obstack_initialize (NULL); 265 update_ssa (TODO_update_ssa_only_virtuals); 266 bitmap_obstack_release (NULL); 267 /* ??? By flushing the freelist after virtual operand SSA rewrite 268 we keep the gaps available for re-use like needed for the 269 PR89595 testcase but then usually virtual operands would have 270 taken most of them. The fix is obviously to make virtual 271 operands explicit in the SSA IL. */ 272 flush_ssaname_freelist (); 273 } 274 fix_loop_structure (NULL); 275 } 276 277 dump_function (TDI_gimple, current_function_decl); 278 } 279 280 /* Parse a compound statement in gimple function body. 281 282 gimple-statement: 283 gimple-statement 284 gimple-declaration-statement 285 gimple-if-statement 286 gimple-switch-statement 287 gimple-labeled-statement 288 gimple-expression-statement 289 gimple-goto-statement 290 gimple-phi-statement 291 gimple-return-statement 292 */ 293 294 static bool 295 c_parser_gimple_compound_statement (gimple_parser &parser, gimple_seq *seq) 296 { 297 bool return_p = false; 298 299 if (! c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>")) 300 return false; 301 302 /* A compund statement starts with optional declarations. */ 303 while (c_parser_next_tokens_start_declaration (parser)) 304 { 305 c_parser_gimple_declaration (parser); 306 if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>")) 307 return false; 308 } 309 310 while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE)) 311 { 312 if (c_parser_error (parser)) 313 { 314 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL); 315 return return_p; 316 } 317 else if (c_parser_next_token_is (parser, CPP_EOF)) 318 { 319 c_parser_error (parser, "expected declaration or statement"); 320 return return_p; 321 } 322 323 switch (c_parser_peek_token (parser)->type) 324 { 325 case CPP_KEYWORD: 326 switch (c_parser_peek_token (parser)->keyword) 327 { 328 case RID_IF: 329 c_parser_gimple_if_stmt (parser, seq); 330 break; 331 case RID_SWITCH: 332 c_parser_gimple_switch_stmt (parser, seq); 333 break; 334 case RID_GOTO: 335 { 336 location_t loc = c_parser_peek_token (parser)->location; 337 c_parser_consume_token (parser); 338 if (c_parser_next_token_is (parser, CPP_NAME)) 339 { 340 c_parser_gimple_goto_stmt (parser, loc, 341 c_parser_peek_token 342 (parser)->value, 343 seq); 344 c_parser_consume_token (parser); 345 if (! c_parser_require (parser, CPP_SEMICOLON, 346 "expected %<;%>")) 347 return return_p; 348 } 349 } 350 break; 351 case RID_RETURN: 352 return_p = true; 353 c_parser_gimple_return_stmt (parser, seq); 354 if (! c_parser_require (parser, CPP_SEMICOLON, 355 "expected %<;%>")) 356 return return_p; 357 if (cfun->curr_properties & PROP_cfg) 358 parser.push_edge (parser.current_bb->index, EXIT_BLOCK, 0); 359 break; 360 default: 361 goto expr_stmt; 362 } 363 break; 364 case CPP_NAME: 365 if (c_parser_peek_2nd_token (parser)->type == CPP_COLON) 366 { 367 c_parser_gimple_label (parser, seq); 368 break; 369 } 370 /* Basic block specification. 371 __BB (index, ...) */ 372 if ((cfun->curr_properties & PROP_cfg) 373 && !strcmp (IDENTIFIER_POINTER 374 (c_parser_peek_token (parser)->value), "__BB")) 375 { 376 c_parser_consume_token (parser); 377 if (! c_parser_require (parser, CPP_OPEN_PAREN, 378 "expected %<(%>")) 379 return return_p; 380 if (c_parser_next_token_is_not (parser, CPP_NUMBER)) 381 { 382 c_parser_error (parser, "expected block index"); 383 return return_p; 384 } 385 tree tnum = c_parser_peek_token (parser)->value; 386 if (TREE_CODE (tnum) != INTEGER_CST) 387 { 388 c_parser_error (parser, "expected block index"); 389 return return_p; 390 } 391 int index = TREE_INT_CST_LOW (tnum); 392 if (index < NUM_FIXED_BLOCKS 393 || (index < last_basic_block_for_fn (cfun) 394 && BASIC_BLOCK_FOR_FN (cfun, index) != NULL)) 395 { 396 c_parser_error (parser, "invalid block index"); 397 return return_p; 398 } 399 int is_loop_header_of = -1; 400 c_parser_consume_token (parser); 401 while (c_parser_next_token_is (parser, CPP_COMMA)) 402 { 403 c_parser_consume_token (parser); 404 if (! c_parser_next_token_is (parser, CPP_NAME)) 405 { 406 c_parser_error (parser, "expected block specifier"); 407 return return_p; 408 } 409 /* loop_header (NUM) */ 410 if (!strcmp (IDENTIFIER_POINTER 411 (c_parser_peek_token (parser)->value), 412 "loop_header")) 413 { 414 c_parser_consume_token (parser); 415 if (! c_parser_require (parser, CPP_OPEN_PAREN, 416 "expected %<(%>")) 417 return return_p; 418 tree loop_num; 419 if (! c_parser_next_token_is (parser, CPP_NUMBER) 420 || TREE_CODE (loop_num 421 = c_parser_peek_token (parser)->value) 422 != INTEGER_CST) 423 { 424 c_parser_error (parser, "expected loop number"); 425 return return_p; 426 } 427 c_parser_consume_token (parser); 428 is_loop_header_of = TREE_INT_CST_LOW (loop_num); 429 if (! c_parser_require (parser, CPP_CLOSE_PAREN, 430 "expected %<)%>")) 431 return return_p; 432 } 433 else 434 { 435 c_parser_error (parser, "unknown block specifier"); 436 return return_p; 437 } 438 } 439 if (! c_parser_require (parser, CPP_CLOSE_PAREN, 440 "expected %<)%>") 441 || ! c_parser_require (parser, CPP_COLON, 442 "expected %<:%>")) 443 return return_p; 444 445 /* Put stmts parsed in the current block. */ 446 if (!gimple_seq_empty_p (*seq)) 447 { 448 if (!parser.current_bb) 449 c_parser_error (parser, "stmts without block"); 450 else 451 { 452 gimple_stmt_iterator gsi 453 = gsi_start_bb (parser.current_bb); 454 gsi_insert_seq_after (&gsi, *seq, GSI_CONTINUE_LINKING); 455 } 456 *seq = NULL; 457 } 458 459 /* Build an empty block with specified index, linking them 460 in source order. */ 461 basic_block bb = alloc_block (); 462 bb->index = index; 463 link_block (bb, (parser.current_bb ? parser.current_bb 464 : ENTRY_BLOCK_PTR_FOR_FN (cfun))); 465 if (basic_block_info_for_fn (cfun)->length () <= (size_t)index) 466 vec_safe_grow_cleared (basic_block_info_for_fn (cfun), 467 index + 1); 468 SET_BASIC_BLOCK_FOR_FN (cfun, index, bb); 469 if (last_basic_block_for_fn (cfun) <= index) 470 last_basic_block_for_fn (cfun) = index + 1; 471 n_basic_blocks_for_fn (cfun)++; 472 if (!parser.current_bb) 473 parser.push_edge (ENTRY_BLOCK, bb->index, EDGE_FALLTHRU); 474 475 /* We leave the proper setting to fixup. */ 476 struct loop *loop_father = loops_for_fn (cfun)->tree_root; 477 /* If the new block is a loop header, allocate a loop 478 struct. Fixup will take care of proper placement within 479 the loop tree. */ 480 if (is_loop_header_of != -1) 481 { 482 if (number_of_loops (cfun) > (unsigned)is_loop_header_of 483 && get_loop (cfun, is_loop_header_of) != NULL) 484 { 485 c_parser_error (parser, "duplicate loop header"); 486 } 487 else 488 { 489 struct loop *loop = alloc_loop (); 490 loop->num = is_loop_header_of; 491 loop->header = bb; 492 vec_safe_grow_cleared (loops_for_fn (cfun)->larray, 493 is_loop_header_of + 1); 494 (*loops_for_fn (cfun)->larray)[is_loop_header_of] = loop; 495 flow_loop_tree_node_add (loops_for_fn (cfun)->tree_root, 496 loop); 497 } 498 loop_father = get_loop (cfun, is_loop_header_of); 499 } 500 bb->loop_father = loop_father; 501 502 /* Stmts now go to the new block. */ 503 parser.current_bb = bb; 504 break; 505 } 506 goto expr_stmt; 507 508 case CPP_SEMICOLON: 509 { 510 /* Empty stmt. */ 511 location_t loc = c_parser_peek_token (parser)->location; 512 c_parser_consume_token (parser); 513 gimple *nop = gimple_build_nop (); 514 gimple_set_location (nop, loc); 515 gimple_seq_add_stmt_without_update (seq, nop); 516 break; 517 } 518 519 default: 520 expr_stmt: 521 c_parser_gimple_statement (parser, seq); 522 if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>")) 523 c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL); 524 } 525 } 526 c_parser_consume_token (parser); 527 528 /* Put stmts parsed in the current block. */ 529 if ((cfun->curr_properties & PROP_cfg) 530 && !gimple_seq_empty_p (*seq)) 531 { 532 if (!parser.current_bb) 533 c_parser_error (parser, "stmts without block"); 534 else 535 { 536 gimple_stmt_iterator gsi = gsi_start_bb (parser.current_bb); 537 gsi_insert_seq_after (&gsi, *seq, GSI_CONTINUE_LINKING); 538 } 539 *seq = NULL; 540 } 541 542 return return_p; 543 } 544 545 /* Parse a gimple statement. 546 547 gimple-statement: 548 gimple-call-expression 549 gimple-assign-statement 550 gimple-phi-statement 551 552 gimple-assign-statement: 553 gimple-unary-expression = gimple-assign-rhs 554 555 gimple-assign-rhs: 556 gimple-cast-expression 557 gimple-unary-expression 558 gimple-binary-expression 559 gimple-call-expression 560 561 gimple-phi-statement: 562 identifier = __PHI ( label : gimple_primary-expression, ... ) 563 564 gimple-call-expr: 565 gimple-primary-expression ( argument-list ) 566 567 gimple-cast-expression: 568 ( type-name ) gimple-primary-expression 569 570 */ 571 572 static void 573 c_parser_gimple_statement (gimple_parser &parser, gimple_seq *seq) 574 { 575 struct c_expr lhs, rhs; 576 gimple *assign = NULL; 577 location_t loc; 578 tree arg = NULL_TREE; 579 auto_vec<tree> vargs; 580 581 lhs = c_parser_gimple_unary_expression (parser); 582 loc = EXPR_LOCATION (lhs.value); 583 rhs.set_error (); 584 585 /* GIMPLE call statement without LHS. */ 586 if (c_parser_next_token_is (parser, CPP_SEMICOLON) 587 && TREE_CODE (lhs.value) == CALL_EXPR) 588 { 589 gimple *call; 590 call = gimple_build_call_from_tree (lhs.value, NULL); 591 gimple_seq_add_stmt_without_update (seq, call); 592 gimple_set_location (call, loc); 593 return; 594 } 595 596 /* All following cases are statements with LHS. */ 597 if (! c_parser_require (parser, CPP_EQ, "expected %<=%>")) 598 return; 599 600 /* Cast expression. */ 601 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN) 602 && c_token_starts_typename (c_parser_peek_2nd_token (parser))) 603 { 604 c_parser_consume_token (parser); 605 struct c_type_name *type_name = c_parser_type_name (parser); 606 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 607 if (type_name == NULL) 608 return; 609 /* ??? The actual type used in the cast expression is ignored as 610 in GIMPLE it is encoded by the type of the LHS. */ 611 rhs = c_parser_gimple_postfix_expression (parser); 612 if (lhs.value != error_mark_node 613 && rhs.value != error_mark_node) 614 { 615 enum tree_code code = NOP_EXPR; 616 if (VECTOR_TYPE_P (TREE_TYPE (lhs.value))) 617 { 618 code = VIEW_CONVERT_EXPR; 619 rhs.value = build1 (VIEW_CONVERT_EXPR, 620 TREE_TYPE (lhs.value), rhs.value); 621 } 622 else if (FLOAT_TYPE_P (TREE_TYPE (lhs.value)) 623 && ! FLOAT_TYPE_P (TREE_TYPE (rhs.value))) 624 code = FLOAT_EXPR; 625 else if (! FLOAT_TYPE_P (TREE_TYPE (lhs.value)) 626 && FLOAT_TYPE_P (TREE_TYPE (rhs.value))) 627 code = FIX_TRUNC_EXPR; 628 assign = gimple_build_assign (lhs.value, code, rhs.value); 629 gimple_seq_add_stmt_without_update (seq, assign); 630 gimple_set_location (assign, loc); 631 return; 632 } 633 } 634 635 /* Unary expression. */ 636 switch (c_parser_peek_token (parser)->type) 637 { 638 case CPP_NAME: 639 { 640 tree id = c_parser_peek_token (parser)->value; 641 if (strcmp (IDENTIFIER_POINTER (id), "__ABS") == 0 642 || strcmp (IDENTIFIER_POINTER (id), "__ABSU") == 0) 643 goto build_unary_expr; 644 break; 645 } 646 case CPP_KEYWORD: 647 if (c_parser_peek_token (parser)->keyword != RID_REALPART 648 && c_parser_peek_token (parser)->keyword != RID_IMAGPART) 649 break; 650 /* Fallthru. */ 651 case CPP_AND: 652 case CPP_PLUS: 653 case CPP_MINUS: 654 case CPP_COMPL: 655 case CPP_NOT: 656 case CPP_MULT: /* pointer deref */ 657 build_unary_expr: 658 rhs = c_parser_gimple_unary_expression (parser); 659 if (rhs.value != error_mark_node) 660 { 661 assign = gimple_build_assign (lhs.value, rhs.value); 662 gimple_set_location (assign, loc); 663 gimple_seq_add_stmt_without_update (seq, assign); 664 } 665 return; 666 667 default:; 668 } 669 670 /* GIMPLE PHI statement. */ 671 if (c_parser_next_token_is_keyword (parser, RID_PHI)) 672 { 673 c_parser_consume_token (parser); 674 675 if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 676 return; 677 678 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 679 c_parser_consume_token (parser); 680 681 while (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN)) 682 { 683 if (c_parser_next_token_is (parser, CPP_NAME) 684 && c_parser_peek_2nd_token (parser)->type == CPP_COLON) 685 { 686 arg = c_parser_peek_token (parser)->value; 687 c_parser_consume_token (parser); 688 if (c_parser_next_token_is (parser, CPP_COLON)) 689 c_parser_consume_token (parser); 690 int src_index = -1; 691 if (!c_parser_gimple_parse_bb_spec (arg, &src_index)) 692 c_parser_error (parser, "invalid source block specification"); 693 vargs.safe_push (size_int (src_index)); 694 } 695 else if (c_parser_next_token_is (parser, CPP_COMMA)) 696 c_parser_consume_token (parser); 697 else 698 { 699 arg = c_parser_gimple_unary_expression (parser).value; 700 vargs.safe_push (arg); 701 } 702 } 703 704 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 705 "expected %<)%>"); 706 707 /* Build internal function for PHI. */ 708 gcall *call_stmt = gimple_build_call_internal_vec (IFN_PHI, vargs); 709 gimple_call_set_lhs (call_stmt, lhs.value); 710 gimple_set_location (call_stmt, UNKNOWN_LOCATION); 711 gimple_seq_add_stmt_without_update (seq, call_stmt); 712 return; 713 } 714 715 /* GIMPLE call with lhs. */ 716 if (c_parser_next_token_is (parser, CPP_DOT) 717 || (c_parser_next_token_is (parser, CPP_NAME) 718 && c_parser_peek_2nd_token (parser)->type == CPP_OPEN_PAREN 719 && lookup_name (c_parser_peek_token (parser)->value))) 720 { 721 rhs = c_parser_gimple_unary_expression (parser); 722 if (rhs.value != error_mark_node) 723 { 724 gimple *call = gimple_build_call_from_tree (rhs.value, NULL); 725 gimple_call_set_lhs (call, lhs.value); 726 gimple_seq_add_stmt_without_update (seq, call); 727 gimple_set_location (call, loc); 728 } 729 return; 730 } 731 732 rhs = c_parser_gimple_binary_expression (parser); 733 if (lhs.value != error_mark_node 734 && rhs.value != error_mark_node) 735 { 736 /* If we parsed a comparison and the next token is a '?' then 737 parse a conditional expression. */ 738 if (COMPARISON_CLASS_P (rhs.value) 739 && c_parser_next_token_is (parser, CPP_QUERY)) 740 { 741 struct c_expr trueval, falseval; 742 c_parser_consume_token (parser); 743 trueval = c_parser_gimple_postfix_expression (parser); 744 falseval.set_error (); 745 if (c_parser_require (parser, CPP_COLON, "expected %<:%>")) 746 falseval = c_parser_gimple_postfix_expression (parser); 747 if (trueval.value == error_mark_node 748 || falseval.value == error_mark_node) 749 return; 750 rhs.value = build3_loc (loc, COND_EXPR, TREE_TYPE (trueval.value), 751 rhs.value, trueval.value, falseval.value); 752 } 753 assign = gimple_build_assign (lhs.value, rhs.value); 754 gimple_seq_add_stmt_without_update (seq, assign); 755 gimple_set_location (assign, loc); 756 } 757 return; 758 } 759 760 /* Parse gimple binary expr. 761 762 gimple-binary-expression: 763 gimple-unary-expression * gimple-unary-expression 764 gimple-unary-expression __MULT_HIGHPART gimple-unary-expression 765 gimple-unary-expression / gimple-unary-expression 766 gimple-unary-expression % gimple-unary-expression 767 gimple-unary-expression + gimple-unary-expression 768 gimple-unary-expression - gimple-unary-expression 769 gimple-unary-expression << gimple-unary-expression 770 gimple-unary-expression >> gimple-unary-expression 771 gimple-unary-expression < gimple-unary-expression 772 gimple-unary-expression > gimple-unary-expression 773 gimple-unary-expression <= gimple-unary-expression 774 gimple-unary-expression >= gimple-unary-expression 775 gimple-unary-expression == gimple-unary-expression 776 gimple-unary-expression != gimple-unary-expression 777 gimple-unary-expression & gimple-unary-expression 778 gimple-unary-expression ^ gimple-unary-expression 779 gimple-unary-expression | gimple-unary-expression 780 781 */ 782 783 static c_expr 784 c_parser_gimple_binary_expression (gimple_parser &parser) 785 { 786 /* Location of the binary operator. */ 787 struct c_expr ret, lhs, rhs; 788 enum tree_code code = ERROR_MARK; 789 ret.set_error (); 790 lhs = c_parser_gimple_postfix_expression (parser); 791 if (c_parser_error (parser)) 792 return ret; 793 tree ret_type = TREE_TYPE (lhs.value); 794 switch (c_parser_peek_token (parser)->type) 795 { 796 case CPP_MULT: 797 code = MULT_EXPR; 798 break; 799 case CPP_DIV: 800 code = TRUNC_DIV_EXPR; 801 break; 802 case CPP_MOD: 803 code = TRUNC_MOD_EXPR; 804 break; 805 case CPP_PLUS: 806 if (POINTER_TYPE_P (TREE_TYPE (lhs.value))) 807 code = POINTER_PLUS_EXPR; 808 else 809 code = PLUS_EXPR; 810 break; 811 case CPP_MINUS: 812 code = MINUS_EXPR; 813 break; 814 case CPP_LSHIFT: 815 code = LSHIFT_EXPR; 816 break; 817 case CPP_RSHIFT: 818 code = RSHIFT_EXPR; 819 break; 820 case CPP_LESS: 821 code = LT_EXPR; 822 ret_type = boolean_type_node; 823 break; 824 case CPP_GREATER: 825 code = GT_EXPR; 826 ret_type = boolean_type_node; 827 break; 828 case CPP_LESS_EQ: 829 code = LE_EXPR; 830 ret_type = boolean_type_node; 831 break; 832 case CPP_GREATER_EQ: 833 code = GE_EXPR; 834 ret_type = boolean_type_node; 835 break; 836 case CPP_EQ_EQ: 837 code = EQ_EXPR; 838 ret_type = boolean_type_node; 839 break; 840 case CPP_NOT_EQ: 841 code = NE_EXPR; 842 ret_type = boolean_type_node; 843 break; 844 case CPP_AND: 845 code = BIT_AND_EXPR; 846 break; 847 case CPP_XOR: 848 code = BIT_XOR_EXPR; 849 break; 850 case CPP_OR: 851 code = BIT_IOR_EXPR; 852 break; 853 case CPP_AND_AND: 854 c_parser_error (parser, "%<&&%> not valid in GIMPLE"); 855 return ret; 856 case CPP_OR_OR: 857 c_parser_error (parser, "%<||%> not valid in GIMPLE"); 858 return ret; 859 case CPP_NAME: 860 { 861 tree id = c_parser_peek_token (parser)->value; 862 if (strcmp (IDENTIFIER_POINTER (id), "__MULT_HIGHPART") == 0) 863 { 864 code = MULT_HIGHPART_EXPR; 865 break; 866 } 867 } 868 /* Fallthru. */ 869 default: 870 /* Not a binary expression. */ 871 return lhs; 872 } 873 location_t ret_loc = c_parser_peek_token (parser)->location; 874 c_parser_consume_token (parser); 875 rhs = c_parser_gimple_postfix_expression (parser); 876 if (lhs.value != error_mark_node && rhs.value != error_mark_node) 877 ret.value = build2_loc (ret_loc, code, ret_type, lhs.value, rhs.value); 878 return ret; 879 } 880 881 /* Parse gimple unary expression. 882 883 gimple-unary-expression: 884 gimple-postfix-expression 885 unary-operator gimple-postfix-expression 886 887 unary-operator: one of 888 & * + - ~ abs_expr 889 */ 890 891 static c_expr 892 c_parser_gimple_unary_expression (gimple_parser &parser) 893 { 894 struct c_expr ret, op; 895 location_t op_loc = c_parser_peek_token (parser)->location; 896 location_t finish; 897 ret.set_error (); 898 switch (c_parser_peek_token (parser)->type) 899 { 900 case CPP_AND: 901 c_parser_consume_token (parser); 902 op = c_parser_gimple_postfix_expression (parser); 903 mark_exp_read (op.value); 904 return parser_build_unary_op (op_loc, ADDR_EXPR, op); 905 case CPP_MULT: 906 { 907 c_parser_consume_token (parser); 908 op = c_parser_gimple_postfix_expression (parser); 909 if (op.value == error_mark_node) 910 return ret; 911 if (! POINTER_TYPE_P (TREE_TYPE (op.value))) 912 { 913 error_at (op_loc, "expected pointer as argument of unary %<*%>"); 914 return ret; 915 } 916 finish = op.get_finish (); 917 location_t combined_loc = make_location (op_loc, op_loc, finish); 918 ret.value = build_simple_mem_ref_loc (combined_loc, op.value); 919 TREE_SIDE_EFFECTS (ret.value) 920 = TREE_THIS_VOLATILE (ret.value) 921 = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op.value))); 922 ret.src_range.m_start = op_loc; 923 ret.src_range.m_finish = finish; 924 return ret; 925 } 926 case CPP_PLUS: 927 c_parser_consume_token (parser); 928 op = c_parser_gimple_postfix_expression (parser); 929 return parser_build_unary_op (op_loc, CONVERT_EXPR, op); 930 case CPP_MINUS: 931 c_parser_consume_token (parser); 932 op = c_parser_gimple_postfix_expression (parser); 933 return parser_build_unary_op (op_loc, NEGATE_EXPR, op); 934 case CPP_COMPL: 935 c_parser_consume_token (parser); 936 op = c_parser_gimple_postfix_expression (parser); 937 return parser_build_unary_op (op_loc, BIT_NOT_EXPR, op); 938 case CPP_NOT: 939 c_parser_error (parser, "%<!%> not valid in GIMPLE"); 940 return ret; 941 case CPP_KEYWORD: 942 switch (c_parser_peek_token (parser)->keyword) 943 { 944 case RID_REALPART: 945 c_parser_consume_token (parser); 946 op = c_parser_gimple_postfix_expression (parser); 947 return parser_build_unary_op (op_loc, REALPART_EXPR, op); 948 case RID_IMAGPART: 949 c_parser_consume_token (parser); 950 op = c_parser_gimple_postfix_expression (parser); 951 return parser_build_unary_op (op_loc, IMAGPART_EXPR, op); 952 default: 953 return c_parser_gimple_postfix_expression (parser); 954 } 955 case CPP_NAME: 956 { 957 tree id = c_parser_peek_token (parser)->value; 958 if (strcmp (IDENTIFIER_POINTER (id), "__ABS") == 0) 959 { 960 c_parser_consume_token (parser); 961 op = c_parser_gimple_postfix_expression (parser); 962 return parser_build_unary_op (op_loc, ABS_EXPR, op); 963 } 964 else if (strcmp (IDENTIFIER_POINTER (id), "__ABSU") == 0) 965 { 966 c_parser_consume_token (parser); 967 op = c_parser_gimple_postfix_expression (parser); 968 return parser_build_unary_op (op_loc, ABSU_EXPR, op); 969 } 970 else 971 return c_parser_gimple_postfix_expression (parser); 972 } 973 default: 974 return c_parser_gimple_postfix_expression (parser); 975 } 976 } 977 978 /* Decompose ID into base name (ID until ver_offset) and VERSION. Return 979 true if ID matches a SSA name. */ 980 981 static bool 982 c_parser_parse_ssa_name_id (tree id, unsigned *version, unsigned *ver_offset) 983 { 984 const char *token = IDENTIFIER_POINTER (id); 985 const char *var_version = strrchr (token, '_'); 986 if (! var_version) 987 return false; 988 989 *ver_offset = var_version - token; 990 for (const char *p = var_version + 1; *p; ++p) 991 if (! ISDIGIT (*p)) 992 return false; 993 *version = atoi (var_version + 1); 994 return *version > 0; 995 } 996 997 /* Get at the actual SSA name ID with VERSION starting at VER_OFFSET. 998 TYPE is the type if the SSA name is being declared. */ 999 1000 static tree 1001 c_parser_parse_ssa_name (gimple_parser &parser, 1002 tree id, tree type, unsigned version, 1003 unsigned ver_offset) 1004 { 1005 tree name = NULL_TREE; 1006 const char *token = IDENTIFIER_POINTER (id); 1007 1008 if (ver_offset == 0) 1009 { 1010 /* Anonymous unnamed SSA name. */ 1011 if (version < num_ssa_names) 1012 name = ssa_name (version); 1013 if (! name) 1014 { 1015 if (! type) 1016 { 1017 c_parser_error (parser, "SSA name undeclared"); 1018 return error_mark_node; 1019 } 1020 name = make_ssa_name_fn (cfun, type, NULL, version); 1021 } 1022 } 1023 else 1024 { 1025 if (version < num_ssa_names) 1026 name = ssa_name (version); 1027 if (! name) 1028 { 1029 /* Separate var name from version. */ 1030 char *var_name = XNEWVEC (char, ver_offset + 1); 1031 memcpy (var_name, token, ver_offset); 1032 var_name[ver_offset] = '\0'; 1033 /* lookup for parent decl. */ 1034 id = get_identifier (var_name); 1035 tree parent = lookup_name (id); 1036 XDELETEVEC (var_name); 1037 if (! parent || parent == error_mark_node) 1038 { 1039 c_parser_error (parser, "base variable or SSA name undeclared"); 1040 return error_mark_node; 1041 } 1042 if (!(VAR_P (parent) 1043 || TREE_CODE (parent) == PARM_DECL 1044 || TREE_CODE (parent) == RESULT_DECL)) 1045 { 1046 error ("invalid base %qE for SSA name", parent); 1047 return error_mark_node; 1048 } 1049 if (VECTOR_TYPE_P (TREE_TYPE (parent)) 1050 || TREE_CODE (TREE_TYPE (parent)) == COMPLEX_TYPE) 1051 DECL_GIMPLE_REG_P (parent) = 1; 1052 name = make_ssa_name_fn (cfun, parent, 1053 gimple_build_nop (), version); 1054 } 1055 } 1056 1057 return name; 1058 } 1059 1060 /* Parse a gimple call to an internal function. 1061 1062 gimple-call-internal: 1063 . identifier ( gimple-argument-expression-list[opt] ) */ 1064 1065 static struct c_expr 1066 c_parser_gimple_call_internal (gimple_parser &parser) 1067 { 1068 struct c_expr expr; 1069 expr.set_error (); 1070 1071 gcc_assert (c_parser_next_token_is (parser, CPP_DOT)); 1072 c_parser_consume_token (parser); 1073 location_t loc = c_parser_peek_token (parser)->location; 1074 if (!c_parser_next_token_is (parser, CPP_NAME) 1075 || c_parser_peek_token (parser)->id_kind != C_ID_ID) 1076 { 1077 c_parser_error (parser, "expecting internal function name"); 1078 return expr; 1079 } 1080 tree id = c_parser_peek_token (parser)->value; 1081 internal_fn ifn = lookup_internal_fn (IDENTIFIER_POINTER (id)); 1082 c_parser_consume_token (parser); 1083 if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 1084 { 1085 auto_vec<tree> exprlist; 1086 if (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 1087 c_parser_gimple_expr_list (parser, &exprlist); 1088 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 1089 if (ifn == IFN_LAST) 1090 error_at (loc, "unknown internal function %qE", id); 1091 else 1092 { 1093 expr.value = build_call_expr_internal_loc_array 1094 (loc, ifn, void_type_node, exprlist.length (), 1095 exprlist.address ()); 1096 expr.original_code = ERROR_MARK; 1097 expr.original_type = NULL; 1098 } 1099 } 1100 return expr; 1101 } 1102 1103 /* Parse gimple postfix expression. 1104 1105 gimple-postfix-expression: 1106 gimple-primary-expression 1107 gimple-primary-expression [ gimple-primary-expression ] 1108 gimple-primary-expression ( gimple-argument-expression-list[opt] ) 1109 gimple-postfix-expression . identifier 1110 gimple-postfix-expression -> identifier 1111 1112 gimple-argument-expression-list: 1113 gimple-unary-expression 1114 gimple-argument-expression-list , gimple-unary-expression 1115 1116 gimple-primary-expression: 1117 identifier 1118 constant 1119 string-literal 1120 constructor 1121 gimple-call-internal 1122 1123 */ 1124 1125 static struct c_expr 1126 c_parser_gimple_postfix_expression (gimple_parser &parser) 1127 { 1128 location_t loc = c_parser_peek_token (parser)->location; 1129 source_range tok_range = c_parser_peek_token (parser)->get_range (); 1130 struct c_expr expr; 1131 expr.set_error (); 1132 switch (c_parser_peek_token (parser)->type) 1133 { 1134 case CPP_NUMBER: 1135 expr.value = c_parser_peek_token (parser)->value; 1136 set_c_expr_source_range (&expr, tok_range); 1137 loc = c_parser_peek_token (parser)->location; 1138 c_parser_consume_token (parser); 1139 break; 1140 case CPP_CHAR: 1141 case CPP_CHAR16: 1142 case CPP_CHAR32: 1143 case CPP_WCHAR: 1144 expr.value = c_parser_peek_token (parser)->value; 1145 set_c_expr_source_range (&expr, tok_range); 1146 c_parser_consume_token (parser); 1147 break; 1148 case CPP_STRING: 1149 case CPP_STRING16: 1150 case CPP_STRING32: 1151 case CPP_WSTRING: 1152 case CPP_UTF8STRING: 1153 expr.value = c_parser_peek_token (parser)->value; 1154 set_c_expr_source_range (&expr, tok_range); 1155 expr.original_code = STRING_CST; 1156 c_parser_consume_token (parser); 1157 break; 1158 case CPP_DOT: 1159 expr = c_parser_gimple_call_internal (parser); 1160 break; 1161 case CPP_NAME: 1162 if (c_parser_peek_token (parser)->id_kind == C_ID_ID) 1163 { 1164 tree id = c_parser_peek_token (parser)->value; 1165 if (strcmp (IDENTIFIER_POINTER (id), "__MEM") == 0) 1166 { 1167 /* __MEM '<' type-name [ ',' number ] '>' 1168 '(' [ '(' type-name ')' ] unary-expression 1169 [ '+' number ] ')' */ 1170 location_t loc = c_parser_peek_token (parser)->location; 1171 c_parser_consume_token (parser); 1172 struct c_type_name *type_name = NULL; 1173 tree alignment = NULL_TREE; 1174 if (c_parser_require (parser, CPP_LESS, "expected %<<%>")) 1175 { 1176 type_name = c_parser_type_name (parser); 1177 /* Optional alignment. */ 1178 if (c_parser_next_token_is (parser, CPP_COMMA)) 1179 { 1180 c_parser_consume_token (parser); 1181 alignment 1182 = c_parser_gimple_postfix_expression (parser).value; 1183 } 1184 c_parser_skip_until_found (parser, 1185 CPP_GREATER, "expected %<>%>"); 1186 } 1187 struct c_expr ptr; 1188 ptr.value = error_mark_node; 1189 tree alias_off = NULL_TREE; 1190 if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 1191 { 1192 tree alias_type = NULL_TREE; 1193 /* Optional alias-type cast. */ 1194 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 1195 { 1196 c_parser_consume_token (parser); 1197 struct c_type_name *alias_type_name 1198 = c_parser_type_name (parser); 1199 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 1200 "expected %<)%>"); 1201 if (alias_type_name) 1202 { 1203 tree tem; 1204 alias_type = groktypename (alias_type_name, 1205 &tem, NULL); 1206 } 1207 } 1208 ptr = c_parser_gimple_unary_expression (parser); 1209 if (ptr.value == error_mark_node 1210 || ! POINTER_TYPE_P (TREE_TYPE (ptr.value))) 1211 { 1212 if (ptr.value != error_mark_node) 1213 error_at (ptr.get_start (), 1214 "invalid type of %<__MEM%> operand"); 1215 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 1216 "expected %<)%>"); 1217 return expr; 1218 } 1219 if (! alias_type) 1220 alias_type = TREE_TYPE (ptr.value); 1221 /* Optional constant offset. */ 1222 if (c_parser_next_token_is (parser, CPP_PLUS)) 1223 { 1224 c_parser_consume_token (parser); 1225 alias_off 1226 = c_parser_gimple_postfix_expression (parser).value; 1227 alias_off = fold_convert (alias_type, alias_off); 1228 } 1229 if (! alias_off) 1230 alias_off = build_int_cst (alias_type, 0); 1231 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 1232 "expected %<)%>"); 1233 } 1234 if (! type_name || c_parser_error (parser)) 1235 { 1236 c_parser_set_error (parser, false); 1237 return expr; 1238 } 1239 tree tem = NULL_TREE; 1240 tree type = groktypename (type_name, &tem, NULL); 1241 if (alignment) 1242 type = build_aligned_type (type, tree_to_uhwi (alignment)); 1243 expr.value = build2_loc (loc, MEM_REF, 1244 type, ptr.value, alias_off); 1245 break; 1246 } 1247 else if (strcmp (IDENTIFIER_POINTER (id), "_Literal") == 0) 1248 { 1249 /* _Literal '(' type-name ')' ( [ '-' ] constant | constructor ) */ 1250 c_parser_consume_token (parser); 1251 tree type = NULL_TREE; 1252 if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 1253 { 1254 struct c_type_name *type_name = c_parser_type_name (parser); 1255 tree tem; 1256 if (type_name) 1257 type = groktypename (type_name, &tem, NULL); 1258 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 1259 "expected %<)%>"); 1260 } 1261 if (! type) 1262 { 1263 c_parser_error (parser, "invalid _Literal"); 1264 return expr; 1265 } 1266 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 1267 { 1268 c_parser_consume_token (parser); 1269 if (!AGGREGATE_TYPE_P (type) 1270 && !VECTOR_TYPE_P (type)) 1271 { 1272 c_parser_error (parser, "invalid type for _Literal with " 1273 "constructor"); 1274 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, 1275 "expected %<}%>"); 1276 return expr; 1277 } 1278 vec<constructor_elt, va_gc> *v = NULL; 1279 bool constant_p = true; 1280 if (VECTOR_TYPE_P (type) 1281 && !c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 1282 { 1283 vec_alloc (v, TYPE_VECTOR_SUBPARTS (type).to_constant ()); 1284 do 1285 { 1286 tree val 1287 = c_parser_gimple_postfix_expression (parser).value; 1288 if (! val 1289 || val == error_mark_node 1290 || (! CONSTANT_CLASS_P (val) 1291 && ! SSA_VAR_P (val))) 1292 { 1293 c_parser_error (parser, "invalid _Literal"); 1294 return expr; 1295 } 1296 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, val); 1297 if (! CONSTANT_CLASS_P (val)) 1298 constant_p = false; 1299 if (c_parser_next_token_is (parser, CPP_COMMA)) 1300 c_parser_consume_token (parser); 1301 else 1302 break; 1303 } 1304 while (1); 1305 } 1306 if (c_parser_require (parser, CPP_CLOSE_BRACE, 1307 "expected %<}%>")) 1308 { 1309 if (v && constant_p) 1310 expr.value = build_vector_from_ctor (type, v); 1311 else 1312 expr.value = build_constructor (type, v); 1313 } 1314 else 1315 { 1316 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, 1317 "expected %<}%>"); 1318 return expr; 1319 } 1320 } 1321 else 1322 { 1323 bool neg_p; 1324 if ((neg_p = c_parser_next_token_is (parser, CPP_MINUS))) 1325 c_parser_consume_token (parser); 1326 tree val = c_parser_gimple_postfix_expression (parser).value; 1327 if (! val 1328 || val == error_mark_node 1329 || ! CONSTANT_CLASS_P (val)) 1330 { 1331 c_parser_error (parser, "invalid _Literal"); 1332 return expr; 1333 } 1334 if (neg_p) 1335 { 1336 val = const_unop (NEGATE_EXPR, TREE_TYPE (val), val); 1337 if (! val) 1338 { 1339 c_parser_error (parser, "invalid _Literal"); 1340 return expr; 1341 } 1342 } 1343 expr.value = fold_convert (type, val); 1344 } 1345 return expr; 1346 } 1347 1348 /* SSA name. */ 1349 unsigned version, ver_offset; 1350 if (! lookup_name (id) 1351 && c_parser_parse_ssa_name_id (id, &version, &ver_offset)) 1352 { 1353 c_parser_consume_token (parser); 1354 expr.value = c_parser_parse_ssa_name (parser, id, NULL_TREE, 1355 version, ver_offset); 1356 if (expr.value == error_mark_node) 1357 return expr; 1358 set_c_expr_source_range (&expr, tok_range); 1359 /* For default definition SSA names. */ 1360 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN) 1361 && c_parser_peek_2nd_token (parser)->type == CPP_NAME 1362 && strcmp ("D", 1363 IDENTIFIER_POINTER 1364 (c_parser_peek_2nd_token (parser)->value)) == 0 1365 && c_parser_peek_nth_token (parser, 3)->type == CPP_CLOSE_PAREN) 1366 { 1367 c_parser_consume_token (parser); 1368 c_parser_consume_token (parser); 1369 c_parser_consume_token (parser); 1370 if (! SSA_NAME_IS_DEFAULT_DEF (expr.value)) 1371 { 1372 if (!SSA_NAME_VAR (expr.value)) 1373 { 1374 error_at (loc, "anonymous SSA name cannot have" 1375 " default definition"); 1376 expr.value = error_mark_node; 1377 return expr; 1378 } 1379 set_ssa_default_def (cfun, SSA_NAME_VAR (expr.value), 1380 expr.value); 1381 SSA_NAME_DEF_STMT (expr.value) = gimple_build_nop (); 1382 } 1383 } 1384 } 1385 else 1386 { 1387 c_parser_consume_token (parser); 1388 expr.value 1389 = build_external_ref (loc, id, 1390 (c_parser_peek_token (parser)->type 1391 == CPP_OPEN_PAREN), &expr.original_type); 1392 set_c_expr_source_range (&expr, tok_range); 1393 } 1394 break; 1395 } 1396 else 1397 { 1398 c_parser_error (parser, "expected expression"); 1399 expr.set_error (); 1400 break; 1401 } 1402 break; 1403 default: 1404 c_parser_error (parser, "expected expression"); 1405 expr.set_error (); 1406 break; 1407 } 1408 return c_parser_gimple_postfix_expression_after_primary 1409 (parser, EXPR_LOC_OR_LOC (expr.value, loc), expr); 1410 } 1411 1412 /* Parse a gimple postfix expression after the initial primary or compound 1413 literal. */ 1414 1415 static struct c_expr 1416 c_parser_gimple_postfix_expression_after_primary (gimple_parser &parser, 1417 location_t expr_loc, 1418 struct c_expr expr) 1419 { 1420 location_t start; 1421 location_t finish; 1422 tree ident; 1423 location_t comp_loc; 1424 1425 while (true) 1426 { 1427 location_t op_loc = c_parser_peek_token (parser)->location; 1428 switch (c_parser_peek_token (parser)->type) 1429 { 1430 case CPP_OPEN_SQUARE: 1431 { 1432 c_parser_consume_token (parser); 1433 tree idx = c_parser_gimple_unary_expression (parser).value; 1434 1435 if (! c_parser_require (parser, CPP_CLOSE_SQUARE, "expected %<]%>")) 1436 { 1437 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL); 1438 break; 1439 } 1440 1441 start = expr.get_start (); 1442 finish = c_parser_tokens_buf (parser, 0)->location; 1443 expr.value = build_array_ref (op_loc, expr.value, idx); 1444 set_c_expr_source_range (&expr, start, finish); 1445 1446 expr.original_code = ERROR_MARK; 1447 expr.original_type = NULL; 1448 break; 1449 } 1450 case CPP_OPEN_PAREN: 1451 { 1452 /* Function call. */ 1453 c_parser_consume_token (parser); 1454 auto_vec<tree> exprlist; 1455 if (! c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 1456 c_parser_gimple_expr_list (parser, &exprlist); 1457 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 1458 "expected %<)%>"); 1459 expr.value = build_call_array_loc 1460 (expr_loc, TREE_TYPE (TREE_TYPE (expr.value)), 1461 expr.value, exprlist.length (), exprlist.address ()); 1462 expr.original_code = ERROR_MARK; 1463 expr.original_type = NULL; 1464 break; 1465 } 1466 case CPP_DOT: 1467 { 1468 /* Structure element reference. */ 1469 c_parser_consume_token (parser); 1470 if (c_parser_next_token_is (parser, CPP_NAME)) 1471 { 1472 c_token *comp_tok = c_parser_peek_token (parser); 1473 ident = comp_tok->value; 1474 comp_loc = comp_tok->location; 1475 } 1476 else 1477 { 1478 c_parser_error (parser, "expected identifier"); 1479 expr.set_error (); 1480 expr.original_code = ERROR_MARK; 1481 expr.original_type = NULL; 1482 return expr; 1483 } 1484 start = expr.get_start (); 1485 finish = c_parser_peek_token (parser)->get_finish (); 1486 c_parser_consume_token (parser); 1487 expr.value = build_component_ref (op_loc, expr.value, ident, 1488 comp_loc); 1489 set_c_expr_source_range (&expr, start, finish); 1490 expr.original_code = ERROR_MARK; 1491 if (TREE_CODE (expr.value) != COMPONENT_REF) 1492 expr.original_type = NULL; 1493 else 1494 { 1495 /* Remember the original type of a bitfield. */ 1496 tree field = TREE_OPERAND (expr.value, 1); 1497 if (TREE_CODE (field) != FIELD_DECL) 1498 expr.original_type = NULL; 1499 else 1500 expr.original_type = DECL_BIT_FIELD_TYPE (field); 1501 } 1502 break; 1503 } 1504 case CPP_DEREF: 1505 { 1506 /* Structure element reference. */ 1507 c_parser_consume_token (parser); 1508 if (c_parser_next_token_is (parser, CPP_NAME)) 1509 { 1510 c_token *comp_tok = c_parser_peek_token (parser); 1511 ident = comp_tok->value; 1512 comp_loc = comp_tok->location; 1513 } 1514 else 1515 { 1516 c_parser_error (parser, "expected identifier"); 1517 expr.set_error (); 1518 expr.original_code = ERROR_MARK; 1519 expr.original_type = NULL; 1520 return expr; 1521 } 1522 start = expr.get_start (); 1523 finish = c_parser_peek_token (parser)->get_finish (); 1524 c_parser_consume_token (parser); 1525 expr.value = build_component_ref (op_loc, 1526 build_simple_mem_ref_loc 1527 (op_loc, expr.value), 1528 ident, comp_loc); 1529 set_c_expr_source_range (&expr, start, finish); 1530 expr.original_code = ERROR_MARK; 1531 if (TREE_CODE (expr.value) != COMPONENT_REF) 1532 expr.original_type = NULL; 1533 else 1534 { 1535 /* Remember the original type of a bitfield. */ 1536 tree field = TREE_OPERAND (expr.value, 1); 1537 if (TREE_CODE (field) != FIELD_DECL) 1538 expr.original_type = NULL; 1539 else 1540 expr.original_type = DECL_BIT_FIELD_TYPE (field); 1541 } 1542 break; 1543 } 1544 default: 1545 return expr; 1546 } 1547 } 1548 } 1549 1550 /* Parse expression list. 1551 1552 gimple-expr-list: 1553 gimple-unary-expression 1554 gimple-expr-list , gimple-unary-expression 1555 1556 */ 1557 1558 static void 1559 c_parser_gimple_expr_list (gimple_parser &parser, vec<tree> *ret) 1560 { 1561 struct c_expr expr; 1562 1563 expr = c_parser_gimple_unary_expression (parser); 1564 ret->safe_push (expr.value); 1565 while (c_parser_next_token_is (parser, CPP_COMMA)) 1566 { 1567 c_parser_consume_token (parser); 1568 expr = c_parser_gimple_unary_expression (parser); 1569 ret->safe_push (expr.value); 1570 } 1571 } 1572 1573 /* Parse gimple label. 1574 1575 gimple-label: 1576 identifier : 1577 case constant-expression : 1578 default : 1579 1580 */ 1581 1582 static void 1583 c_parser_gimple_label (gimple_parser &parser, gimple_seq *seq) 1584 { 1585 tree name = c_parser_peek_token (parser)->value; 1586 location_t loc1 = c_parser_peek_token (parser)->location; 1587 gcc_assert (c_parser_next_token_is (parser, CPP_NAME)); 1588 c_parser_consume_token (parser); 1589 gcc_assert (c_parser_next_token_is (parser, CPP_COLON)); 1590 c_parser_consume_token (parser); 1591 tree label = define_label (loc1, name); 1592 gimple_seq_add_stmt_without_update (seq, gimple_build_label (label)); 1593 return; 1594 } 1595 1596 /* Parse gimple/RTL pass list. 1597 1598 gimple-or-rtl-pass-list: 1599 startwith("pass-name")[,{cfg,ssa}] 1600 */ 1601 1602 void 1603 c_parser_gimple_or_rtl_pass_list (c_parser *parser, c_declspecs *specs) 1604 { 1605 char *pass = NULL; 1606 1607 /* Accept __GIMPLE/__RTL. */ 1608 if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN)) 1609 return; 1610 c_parser_consume_token (parser); 1611 1612 while (c_parser_next_token_is (parser, CPP_NAME)) 1613 { 1614 const char *op = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value); 1615 c_parser_consume_token (parser); 1616 if (! strcmp (op, "startwith")) 1617 { 1618 if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 1619 return; 1620 if (c_parser_next_token_is_not (parser, CPP_STRING)) 1621 { 1622 error_at (c_parser_peek_token (parser)->location, 1623 "expected pass name"); 1624 return; 1625 } 1626 pass = xstrdup (TREE_STRING_POINTER 1627 (c_parser_peek_token (parser)->value)); 1628 c_parser_consume_token (parser); 1629 if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<(%>")) 1630 return; 1631 } 1632 else if (specs->declspec_il != cdil_gimple) 1633 /* Allow only one IL specifier and none on RTL. */ 1634 ; 1635 else if (! strcmp (op, "cfg")) 1636 specs->declspec_il = cdil_gimple_cfg; 1637 else if (! strcmp (op, "ssa")) 1638 specs->declspec_il = cdil_gimple_ssa; 1639 else 1640 { 1641 error_at (c_parser_peek_token (parser)->location, 1642 "invalid operation"); 1643 return; 1644 } 1645 if (c_parser_next_token_is (parser, CPP_COMMA)) 1646 c_parser_consume_token (parser); 1647 } 1648 1649 if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>")) 1650 return; 1651 1652 specs->gimple_or_rtl_pass = pass; 1653 } 1654 1655 /* Parse gimple local declaration. 1656 1657 declaration-specifiers: 1658 storage-class-specifier declaration-specifiers[opt] 1659 type-specifier declaration-specifiers[opt] 1660 type-qualifier declaration-specifiers[opt] 1661 function-specifier declaration-specifiers[opt] 1662 alignment-specifier declaration-specifiers[opt] 1663 1664 storage-class-specifier: 1665 typedef 1666 extern 1667 static 1668 auto 1669 register 1670 1671 type-specifier: 1672 void 1673 char 1674 short 1675 int 1676 long 1677 float 1678 double 1679 signed 1680 unsigned 1681 _Bool 1682 _Complex 1683 1684 type-qualifier: 1685 const 1686 restrict 1687 volatile 1688 address-space-qualifier 1689 _Atomic 1690 1691 */ 1692 1693 static void 1694 c_parser_gimple_declaration (gimple_parser &parser) 1695 { 1696 struct c_declarator *declarator; 1697 struct c_declspecs *specs = build_null_declspecs (); 1698 c_parser_declspecs (parser, specs, true, true, true, 1699 true, true, cla_nonabstract_decl); 1700 finish_declspecs (specs); 1701 1702 /* Provide better error recovery. Note that a type name here is usually 1703 better diagnosed as a redeclaration. */ 1704 if (c_parser_next_token_starts_declspecs (parser) 1705 && ! c_parser_next_token_is (parser, CPP_NAME)) 1706 { 1707 c_parser_error (parser, "expected %<;%>"); 1708 c_parser_set_error (parser, false); 1709 return; 1710 } 1711 1712 bool dummy = false; 1713 declarator = c_parser_declarator (parser, 1714 specs->typespec_kind != ctsk_none, 1715 C_DTR_NORMAL, &dummy); 1716 1717 if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 1718 { 1719 /* Handle SSA name decls specially, they do not go into the identifier 1720 table but we simply build the SSA name for later lookup. */ 1721 unsigned version, ver_offset; 1722 if (declarator->kind == cdk_id 1723 && is_gimple_reg_type (specs->type) 1724 && c_parser_parse_ssa_name_id (declarator->u.id, 1725 &version, &ver_offset) 1726 /* The following restricts it to unnamed anonymous SSA names 1727 which fails parsing of named ones in dumps (we could 1728 decide to not dump their name for -gimple). */ 1729 && ver_offset == 0) 1730 c_parser_parse_ssa_name (parser, declarator->u.id, specs->type, 1731 version, ver_offset); 1732 else 1733 { 1734 tree postfix_attrs = NULL_TREE; 1735 tree all_prefix_attrs = specs->attrs; 1736 specs->attrs = NULL; 1737 tree decl = start_decl (declarator, specs, false, 1738 chainon (postfix_attrs, all_prefix_attrs)); 1739 if (decl) 1740 finish_decl (decl, UNKNOWN_LOCATION, NULL_TREE, NULL_TREE, 1741 NULL_TREE); 1742 } 1743 } 1744 else 1745 { 1746 c_parser_error (parser, "expected %<;%>"); 1747 return; 1748 } 1749 } 1750 1751 /* Parse gimple goto statement. */ 1752 1753 static void 1754 c_parser_gimple_goto_stmt (gimple_parser &parser, 1755 location_t loc, tree label, gimple_seq *seq) 1756 { 1757 if (cfun->curr_properties & PROP_cfg) 1758 { 1759 int dest_index; 1760 if (c_parser_gimple_parse_bb_spec (label, &dest_index)) 1761 { 1762 parser.push_edge (parser.current_bb->index, dest_index, 1763 EDGE_FALLTHRU); 1764 return; 1765 } 1766 } 1767 tree decl = lookup_label_for_goto (loc, label); 1768 gimple_seq_add_stmt_without_update (seq, gimple_build_goto (decl)); 1769 } 1770 1771 /* Parse a parenthesized condition. 1772 gimple-condition: 1773 ( gimple-binary-expression ) */ 1774 1775 static tree 1776 c_parser_gimple_paren_condition (gimple_parser &parser) 1777 { 1778 if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 1779 return error_mark_node; 1780 tree cond = c_parser_gimple_binary_expression (parser).value; 1781 if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>")) 1782 return error_mark_node; 1783 return cond; 1784 } 1785 1786 /* Parse gimple if-else statement. 1787 1788 if-statement: 1789 if ( gimple-binary-expression ) gimple-goto-statement 1790 if ( gimple-binary-expression ) gimple-goto-statement \ 1791 else gimple-goto-statement 1792 */ 1793 1794 static void 1795 c_parser_gimple_if_stmt (gimple_parser &parser, gimple_seq *seq) 1796 { 1797 tree t_label = NULL_TREE, f_label = NULL_TREE, label; 1798 location_t loc; 1799 c_parser_consume_token (parser); 1800 tree cond = c_parser_gimple_paren_condition (parser); 1801 1802 if (c_parser_next_token_is_keyword (parser, RID_GOTO)) 1803 { 1804 loc = c_parser_peek_token (parser)->location; 1805 c_parser_consume_token (parser); 1806 if (! c_parser_next_token_is (parser, CPP_NAME)) 1807 { 1808 c_parser_error (parser, "expected label"); 1809 return; 1810 } 1811 label = c_parser_peek_token (parser)->value; 1812 c_parser_consume_token (parser); 1813 int dest_index; 1814 if ((cfun->curr_properties & PROP_cfg) 1815 && c_parser_gimple_parse_bb_spec (label, &dest_index)) 1816 parser.push_edge (parser.current_bb->index, dest_index, 1817 EDGE_TRUE_VALUE); 1818 else 1819 t_label = lookup_label_for_goto (loc, label); 1820 if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>")) 1821 return; 1822 } 1823 else 1824 { 1825 c_parser_error (parser, "expected goto expression"); 1826 return; 1827 } 1828 1829 if (c_parser_next_token_is_keyword (parser, RID_ELSE)) 1830 c_parser_consume_token (parser); 1831 else 1832 { 1833 c_parser_error (parser, "expected else statement"); 1834 return; 1835 } 1836 1837 if (c_parser_next_token_is_keyword (parser, RID_GOTO)) 1838 { 1839 loc = c_parser_peek_token (parser)->location; 1840 c_parser_consume_token (parser); 1841 if (! c_parser_next_token_is (parser, CPP_NAME)) 1842 { 1843 c_parser_error (parser, "expected label"); 1844 return; 1845 } 1846 label = c_parser_peek_token (parser)->value; 1847 int dest_index; 1848 if ((cfun->curr_properties & PROP_cfg) 1849 && c_parser_gimple_parse_bb_spec (label, &dest_index)) 1850 parser.push_edge (parser.current_bb->index, dest_index, 1851 EDGE_FALSE_VALUE); 1852 else 1853 f_label = lookup_label_for_goto (loc, label); 1854 c_parser_consume_token (parser); 1855 if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>")) 1856 return; 1857 } 1858 else 1859 { 1860 c_parser_error (parser, "expected goto expression"); 1861 return; 1862 } 1863 1864 if (cond != error_mark_node) 1865 gimple_seq_add_stmt_without_update (seq, gimple_build_cond_from_tree (cond, t_label, 1866 f_label)); 1867 } 1868 1869 /* Parse gimple switch-statement. 1870 1871 gimple-switch-statement: 1872 switch (gimple-postfix-expression) gimple-case-statement 1873 1874 gimple-case-statement: 1875 gimple-case-statement 1876 gimple-label-statement : gimple-goto-statment 1877 */ 1878 1879 static void 1880 c_parser_gimple_switch_stmt (gimple_parser &parser, gimple_seq *seq) 1881 { 1882 c_expr cond_expr; 1883 tree case_label, label; 1884 auto_vec<tree> labels; 1885 tree default_label = NULL_TREE; 1886 c_parser_consume_token (parser); 1887 1888 if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 1889 return; 1890 cond_expr = c_parser_gimple_postfix_expression (parser); 1891 if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>")) 1892 return; 1893 1894 if (! c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>")) 1895 return; 1896 1897 while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE)) 1898 { 1899 if (c_parser_next_token_is (parser, CPP_EOF)) 1900 { 1901 c_parser_error (parser, "expected statement"); 1902 return; 1903 } 1904 1905 switch (c_parser_peek_token (parser)->keyword) 1906 { 1907 case RID_CASE: 1908 { 1909 c_expr exp1; 1910 location_t loc = c_parser_peek_token (parser)->location; 1911 c_parser_consume_token (parser); 1912 1913 if (c_parser_next_token_is (parser, CPP_NAME) 1914 || c_parser_peek_token (parser)->type == CPP_NUMBER) 1915 exp1 = c_parser_gimple_postfix_expression (parser); 1916 else 1917 { 1918 c_parser_error (parser, "expected expression"); 1919 return; 1920 } 1921 1922 if (c_parser_next_token_is (parser, CPP_COLON)) 1923 { 1924 c_parser_consume_token (parser); 1925 if (c_parser_next_token_is (parser, CPP_NAME)) 1926 { 1927 label = c_parser_peek_token (parser)->value; 1928 c_parser_consume_token (parser); 1929 tree decl = lookup_label_for_goto (loc, label); 1930 case_label = build_case_label (exp1.value, NULL_TREE, 1931 decl); 1932 labels.safe_push (case_label); 1933 if (! c_parser_require (parser, CPP_SEMICOLON, 1934 "expected %<;%>")) 1935 return; 1936 } 1937 else if (! c_parser_require (parser, CPP_NAME, 1938 "expected label")) 1939 return; 1940 } 1941 else if (! c_parser_require (parser, CPP_SEMICOLON, 1942 "expected %<:%>")) 1943 return; 1944 break; 1945 } 1946 case RID_DEFAULT: 1947 { 1948 location_t loc = c_parser_peek_token (parser)->location; 1949 c_parser_consume_token (parser); 1950 if (c_parser_next_token_is (parser, CPP_COLON)) 1951 { 1952 c_parser_consume_token (parser); 1953 if (c_parser_next_token_is (parser, CPP_NAME)) 1954 { 1955 label = c_parser_peek_token (parser)->value; 1956 c_parser_consume_token (parser); 1957 tree decl = lookup_label_for_goto (loc, label); 1958 default_label = build_case_label (NULL_TREE, NULL_TREE, 1959 decl); 1960 if (! c_parser_require (parser, CPP_SEMICOLON, 1961 "expected %<;%>")) 1962 return; 1963 } 1964 else if (! c_parser_require (parser, CPP_NAME, 1965 "expected label")) 1966 return; 1967 } 1968 else if (! c_parser_require (parser, CPP_SEMICOLON, 1969 "expected %<:%>")) 1970 return; 1971 break; 1972 } 1973 default: 1974 c_parser_error (parser, "expected case label"); 1975 return; 1976 } 1977 1978 } 1979 if (! c_parser_require (parser, CPP_CLOSE_BRACE, "expected %<}%>")) 1980 return; 1981 1982 if (cond_expr.value != error_mark_node) 1983 { 1984 gswitch *s = gimple_build_switch (cond_expr.value, default_label, labels); 1985 gimple_seq_add_stmt_without_update (seq, s); 1986 } 1987 } 1988 1989 /* Parse gimple return statement. */ 1990 1991 static void 1992 c_parser_gimple_return_stmt (gimple_parser &parser, gimple_seq *seq) 1993 { 1994 location_t loc = c_parser_peek_token (parser)->location; 1995 gimple *ret = NULL; 1996 c_parser_consume_token (parser); 1997 if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 1998 { 1999 c_finish_gimple_return (loc, NULL_TREE); 2000 ret = gimple_build_return (NULL); 2001 gimple_seq_add_stmt_without_update (seq, ret); 2002 } 2003 else 2004 { 2005 location_t xloc = c_parser_peek_token (parser)->location; 2006 c_expr expr = c_parser_gimple_unary_expression (parser); 2007 if (expr.value != error_mark_node) 2008 { 2009 c_finish_gimple_return (xloc, expr.value); 2010 ret = gimple_build_return (expr.value); 2011 gimple_seq_add_stmt_without_update (seq, ret); 2012 } 2013 } 2014 } 2015 2016 /* Support function for c_parser_gimple_return_stmt. */ 2017 2018 static void 2019 c_finish_gimple_return (location_t loc, tree retval) 2020 { 2021 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)); 2022 2023 /* Use the expansion point to handle cases such as returning NULL 2024 in a function returning void. */ 2025 location_t xloc = expansion_point_location_if_in_system_header (loc); 2026 2027 if (TREE_THIS_VOLATILE (current_function_decl)) 2028 warning_at (xloc, 0, 2029 "function declared %<noreturn%> has a %<return%> statement"); 2030 2031 if (! retval) 2032 current_function_returns_null = 1; 2033 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE) 2034 { 2035 current_function_returns_null = 1; 2036 if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE) 2037 { 2038 error_at 2039 (xloc, "%<return%> with a value, in function returning void"); 2040 inform (DECL_SOURCE_LOCATION (current_function_decl), 2041 "declared here"); 2042 } 2043 } 2044 else if (TREE_CODE (valtype) != TREE_CODE (TREE_TYPE (retval))) 2045 { 2046 error_at 2047 (xloc, "invalid conversion in return statement"); 2048 inform (DECL_SOURCE_LOCATION (current_function_decl), 2049 "declared here"); 2050 } 2051 return; 2052 } 2053