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