c-semantics.c revision 146895
1/* This file contains the definitions and documentation for the common 2 tree codes used in the GNU C and C++ compilers (see c-common.def 3 for the standard codes). 4 Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 5 Written by Benjamin Chelf (chelf@codesourcery.com). 6 7This file is part of GCC. 8 9GCC is free software; you can redistribute it and/or modify it under 10the terms of the GNU General Public License as published by the Free 11Software Foundation; either version 2, or (at your option) any later 12version. 13 14GCC is distributed in the hope that it will be useful, but WITHOUT ANY 15WARRANTY; without even the implied warranty of MERCHANTABILITY or 16FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 17for more details. 18 19You should have received a copy of the GNU General Public License 20along with GCC; see the file COPYING. If not, write to the Free 21Software Foundation, 59 Temple Place - Suite 330, Boston, MA 2202111-1307, USA. */ 23 24#include "config.h" 25#include "system.h" 26#include "coretypes.h" 27#include "tm.h" 28#include "tree.h" 29#include "function.h" 30#include "splay-tree.h" 31#include "varray.h" 32#include "c-common.h" 33#include "except.h" 34/* In order for the format checking to accept the C frontend 35 diagnostic framework extensions, you must define this token before 36 including toplev.h. */ 37#define GCC_DIAG_STYLE __gcc_cdiag__ 38#include "toplev.h" 39#include "flags.h" 40#include "ggc.h" 41#include "rtl.h" 42#include "expr.h" 43#include "output.h" 44#include "timevar.h" 45#include "predict.h" 46#include "tree-inline.h" 47 48/* If non-NULL, the address of a language-specific function for 49 expanding statements. */ 50void (*lang_expand_stmt) (tree); 51 52/* If non-NULL, the address of a language-specific function for 53 expanding a DECL_STMT. After the language-independent cases are 54 handled, this function will be called. If this function is not 55 defined, it is assumed that declarations other than those for 56 variables and labels do not require any RTL generation. */ 57void (*lang_expand_decl_stmt) (tree); 58 59static tree find_reachable_label_1 (tree *, int *, void *); 60static tree find_reachable_label (tree); 61static bool expand_unreachable_if_stmt (tree); 62static tree expand_unreachable_stmt (tree, int); 63static void genrtl_do_stmt_1 (tree, tree); 64 65/* Create an empty statement tree rooted at T. */ 66 67void 68begin_stmt_tree (tree *t) 69{ 70 /* We create a trivial EXPR_STMT so that last_tree is never NULL in 71 what follows. We remove the extraneous statement in 72 finish_stmt_tree. */ 73 *t = build_nt (EXPR_STMT, void_zero_node); 74 last_tree = *t; 75 last_expr_type = NULL_TREE; 76 last_expr_filename = input_filename; 77} 78 79/* T is a statement. Add it to the statement-tree. */ 80 81tree 82add_stmt (tree t) 83{ 84 if (input_filename != last_expr_filename) 85 { 86 /* If the filename has changed, also add in a FILE_STMT. Do a string 87 compare first, though, as it might be an equivalent string. */ 88 int add = (strcmp (input_filename, last_expr_filename) != 0); 89 last_expr_filename = input_filename; 90 if (add) 91 { 92 tree pos = build_nt (FILE_STMT, get_identifier (input_filename)); 93 add_stmt (pos); 94 } 95 } 96 97 /* Add T to the statement-tree. */ 98 TREE_CHAIN (last_tree) = t; 99 last_tree = t; 100 101 /* When we expand a statement-tree, we must know whether or not the 102 statements are full-expressions. We record that fact here. */ 103 STMT_IS_FULL_EXPR_P (last_tree) = stmts_are_full_exprs_p (); 104 105 return t; 106} 107 108/* Create a declaration statement for the declaration given by the 109 DECL. */ 110 111void 112add_decl_stmt (tree decl) 113{ 114 tree decl_stmt; 115 116 /* We need the type to last until instantiation time. */ 117 decl_stmt = build_stmt (DECL_STMT, decl); 118 add_stmt (decl_stmt); 119} 120 121/* Add a scope-statement to the statement-tree. BEGIN_P indicates 122 whether this statements opens or closes a scope. PARTIAL_P is true 123 for a partial scope, i.e, the scope that begins after a label when 124 an object that needs a cleanup is created. If BEGIN_P is nonzero, 125 returns a new TREE_LIST representing the top of the SCOPE_STMT 126 stack. The TREE_PURPOSE is the new SCOPE_STMT. If BEGIN_P is 127 zero, returns a TREE_LIST whose TREE_VALUE is the new SCOPE_STMT, 128 and whose TREE_PURPOSE is the matching SCOPE_STMT with 129 SCOPE_BEGIN_P set. */ 130 131tree 132add_scope_stmt (int begin_p, int partial_p) 133{ 134 tree *stack_ptr = current_scope_stmt_stack (); 135 tree ss; 136 tree top = *stack_ptr; 137 138 /* Build the statement. */ 139 ss = build_stmt (SCOPE_STMT, NULL_TREE); 140 SCOPE_BEGIN_P (ss) = begin_p; 141 SCOPE_PARTIAL_P (ss) = partial_p; 142 143 /* Keep the scope stack up to date. */ 144 if (begin_p) 145 { 146 top = tree_cons (ss, NULL_TREE, top); 147 *stack_ptr = top; 148 } 149 else 150 { 151 if (partial_p != SCOPE_PARTIAL_P (TREE_PURPOSE (top))) 152 abort (); 153 TREE_VALUE (top) = ss; 154 *stack_ptr = TREE_CHAIN (top); 155 } 156 157 /* Add the new statement to the statement-tree. */ 158 add_stmt (ss); 159 160 return top; 161} 162 163/* Finish the statement tree rooted at T. */ 164 165void 166finish_stmt_tree (tree *t) 167{ 168 tree stmt; 169 170 /* Remove the fake extra statement added in begin_stmt_tree. */ 171 stmt = TREE_CHAIN (*t); 172 *t = stmt; 173 last_tree = NULL_TREE; 174 175 if (cfun && stmt) 176 { 177 /* The line-number recorded in the outermost statement in a function 178 is the line number of the end of the function. */ 179 STMT_LINENO (stmt) = input_line; 180 STMT_LINENO_FOR_FN_P (stmt) = 1; 181 } 182} 183 184/* Build a generic statement based on the given type of node and 185 arguments. Similar to `build_nt', except that we set 186 STMT_LINENO to be the current line number. */ 187/* ??? This should be obsolete with the lineno_stmt productions 188 in the grammar. */ 189 190tree 191build_stmt (enum tree_code code, ...) 192{ 193 tree t; 194 int length; 195 int i; 196 va_list p; 197 198 va_start (p, code); 199 200 t = make_node (code); 201 length = TREE_CODE_LENGTH (code); 202 STMT_LINENO (t) = input_line; 203 204 for (i = 0; i < length; i++) 205 TREE_OPERAND (t, i) = va_arg (p, tree); 206 207 va_end (p); 208 return t; 209} 210 211/* Some statements, like for-statements or if-statements, require a 212 condition. This condition can be a declaration. If T is such a 213 declaration it is processed, and an expression appropriate to use 214 as the condition is returned. Otherwise, T itself is returned. */ 215 216tree 217expand_cond (tree t) 218{ 219 if (t && TREE_CODE (t) == TREE_LIST) 220 { 221 expand_stmt (TREE_PURPOSE (t)); 222 return TREE_VALUE (t); 223 } 224 else 225 return t; 226} 227 228/* Create RTL for the local static variable DECL. */ 229 230void 231make_rtl_for_local_static (tree decl) 232{ 233 const char *asmspec = NULL; 234 235 /* If we inlined this variable, we could see it's declaration 236 again. */ 237 if (TREE_ASM_WRITTEN (decl)) 238 return; 239 240 /* If the DECL_ASSEMBLER_NAME is not the same as the DECL_NAME, then 241 either we already created RTL for this DECL (and since it was a 242 local variable, its DECL_ASSEMBLER_NAME got hacked up to prevent 243 clashes with other local statics with the same name by a previous 244 call to make_decl_rtl), or the user explicitly requested a 245 particular assembly name for this variable, using the GNU 246 extension for this purpose: 247 248 int i asm ("j"); 249 250 There's no way to know which case we're in, here. But, it turns 251 out we're safe. If there's already RTL, then 252 rest_of_decl_compilation ignores the ASMSPEC parameter, so we 253 may as well not pass it in. If there isn't RTL, then we didn't 254 already create RTL, which means that the modification to 255 DECL_ASSEMBLER_NAME came only via the explicit extension. */ 256 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl) 257 && !DECL_RTL_SET_P (decl)) 258 asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 259 260 rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0); 261} 262 263/* Let the back-end know about DECL. */ 264 265void 266emit_local_var (tree decl) 267{ 268 /* Create RTL for this variable. */ 269 if (!DECL_RTL_SET_P (decl)) 270 { 271 if (DECL_C_HARD_REGISTER (decl)) 272 /* The user specified an assembler name for this variable. 273 Set that up now. */ 274 rest_of_decl_compilation 275 (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 276 /*top_level=*/0, /*at_end=*/0); 277 else 278 expand_decl (decl); 279 } 280 281 if (DECL_INITIAL (decl)) 282 { 283 /* Actually do the initialization. */ 284 if (stmts_are_full_exprs_p ()) 285 expand_start_target_temps (); 286 287 expand_decl_init (decl); 288 289 if (stmts_are_full_exprs_p ()) 290 expand_end_target_temps (); 291 } 292} 293 294/* Helper for generating the RTL at the beginning of a scope. */ 295 296void 297genrtl_do_pushlevel (void) 298{ 299 emit_line_note (input_location); 300 clear_last_expr (); 301} 302 303/* Generate the RTL for DESTINATION, which is a GOTO_STMT. */ 304 305void 306genrtl_goto_stmt (tree destination) 307{ 308 if (TREE_CODE (destination) == IDENTIFIER_NODE) 309 abort (); 310 311 /* We warn about unused labels with -Wunused. That means we have to 312 mark the used labels as used. */ 313 if (TREE_CODE (destination) == LABEL_DECL) 314 TREE_USED (destination) = 1; 315 316 emit_line_note (input_location); 317 318 if (TREE_CODE (destination) == LABEL_DECL) 319 { 320 label_rtx (destination); 321 expand_goto (destination); 322 } 323 else 324 expand_computed_goto (destination); 325} 326 327/* Generate the RTL for EXPR, which is an EXPR_STMT. Provided just 328 for backward compatibility. genrtl_expr_stmt_value() should be 329 used for new code. */ 330 331void 332genrtl_expr_stmt (tree expr) 333{ 334 genrtl_expr_stmt_value (expr, -1, 1); 335} 336 337/* Generate the RTL for EXPR, which is an EXPR_STMT. WANT_VALUE tells 338 whether to (1) save the value of the expression, (0) discard it or 339 (-1) use expr_stmts_for_value to tell. The use of -1 is 340 deprecated, and retained only for backward compatibility. 341 MAYBE_LAST is nonzero if this EXPR_STMT might be the last statement 342 in expression statement. */ 343 344void 345genrtl_expr_stmt_value (tree expr, int want_value, int maybe_last) 346{ 347 if (expr != NULL_TREE) 348 { 349 emit_line_note (input_location); 350 351 if (stmts_are_full_exprs_p ()) 352 expand_start_target_temps (); 353 354 if (expr != error_mark_node) 355 expand_expr_stmt_value (expr, want_value, maybe_last); 356 357 if (stmts_are_full_exprs_p ()) 358 expand_end_target_temps (); 359 } 360} 361 362/* Generate the RTL for T, which is a DECL_STMT. */ 363 364void 365genrtl_decl_stmt (tree t) 366{ 367 tree decl; 368 emit_line_note (input_location); 369 decl = DECL_STMT_DECL (t); 370 /* If this is a declaration for an automatic local 371 variable, initialize it. Note that we might also see a 372 declaration for a namespace-scope object (declared with 373 `extern'). We don't have to handle the initialization 374 of those objects here; they can only be declarations, 375 rather than definitions. */ 376 if (TREE_CODE (decl) == VAR_DECL 377 && !TREE_STATIC (decl) 378 && !DECL_EXTERNAL (decl)) 379 { 380 /* Let the back-end know about this variable. */ 381 if (!anon_aggr_type_p (TREE_TYPE (decl))) 382 emit_local_var (decl); 383 else 384 expand_anon_union_decl (decl, NULL_TREE, 385 DECL_ANON_UNION_ELEMS (decl)); 386 } 387 else if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)) 388 make_rtl_for_local_static (decl); 389 else if (TREE_CODE (decl) == LABEL_DECL 390 && C_DECLARED_LABEL_FLAG (decl)) 391 declare_nonlocal_label (decl); 392 else if (lang_expand_decl_stmt) 393 (*lang_expand_decl_stmt) (t); 394} 395 396/* Generate the RTL for T, which is an IF_STMT. */ 397 398void 399genrtl_if_stmt (tree t) 400{ 401 tree cond; 402 genrtl_do_pushlevel (); 403 cond = expand_cond (IF_COND (t)); 404 emit_line_note (input_location); 405 expand_start_cond (cond, 0); 406 if (THEN_CLAUSE (t)) 407 { 408 tree nextt = THEN_CLAUSE (t); 409 410 if (cond && integer_zerop (cond)) 411 nextt = expand_unreachable_stmt (nextt, warn_notreached); 412 expand_stmt (nextt); 413 } 414 415 if (ELSE_CLAUSE (t)) 416 { 417 tree nextt = ELSE_CLAUSE (t); 418 expand_start_else (); 419 if (cond && integer_nonzerop (cond)) 420 nextt = expand_unreachable_stmt (nextt, warn_notreached); 421 expand_stmt (nextt); 422 } 423 expand_end_cond (); 424} 425 426/* Generate the RTL for T, which is a WHILE_STMT. */ 427 428void 429genrtl_while_stmt (tree t) 430{ 431 tree cond = WHILE_COND (t); 432 433 emit_line_note (input_location); 434 expand_start_loop (1); 435 genrtl_do_pushlevel (); 436 437 if (cond && !integer_nonzerop (cond)) 438 { 439 cond = expand_cond (cond); 440 emit_line_note (input_location); 441 expand_exit_loop_top_cond (0, cond); 442 genrtl_do_pushlevel (); 443 } 444 445 expand_stmt (WHILE_BODY (t)); 446 447 expand_end_loop (); 448} 449 450/* Generate the RTL for a DO_STMT with condition COND and loop BODY 451 body. This is reused for expanding unreachable WHILE_STMTS. */ 452 453static void 454genrtl_do_stmt_1 (tree cond, tree body) 455{ 456 /* Recognize the common special-case of do { ... } while (0) and do 457 not emit the loop widgetry in this case. In particular this 458 avoids cluttering the rtl with dummy loop notes, which can affect 459 alignment of adjacent labels. COND can be NULL due to parse 460 errors. */ 461 if (!cond || integer_zerop (cond)) 462 { 463 expand_start_null_loop (); 464 expand_stmt (body); 465 expand_end_null_loop (); 466 } 467 else if (integer_nonzerop (cond)) 468 { 469 emit_line_note (input_location); 470 expand_start_loop (1); 471 472 expand_stmt (body); 473 474 emit_line_note (input_location); 475 expand_end_loop (); 476 } 477 else 478 { 479 emit_line_note (input_location); 480 expand_start_loop_continue_elsewhere (1); 481 482 expand_stmt (body); 483 484 expand_loop_continue_here (); 485 cond = expand_cond (cond); 486 emit_line_note (input_location); 487 expand_exit_loop_if_false (0, cond); 488 expand_end_loop (); 489 } 490} 491 492/* Generate the RTL for T, which is a DO_STMT. */ 493 494void 495genrtl_do_stmt (tree t) 496{ 497 genrtl_do_stmt_1 (DO_COND (t), DO_BODY (t)); 498} 499 500/* Build the node for a return statement and return it. */ 501 502tree 503build_return_stmt (tree expr) 504{ 505 return (build_stmt (RETURN_STMT, expr)); 506} 507 508/* Generate the RTL for STMT, which is a RETURN_STMT. */ 509 510void 511genrtl_return_stmt (tree stmt) 512{ 513 tree expr; 514 515 expr = RETURN_STMT_EXPR (stmt); 516 517 emit_line_note (input_location); 518 if (!expr) 519 expand_null_return (); 520 else 521 { 522 expand_start_target_temps (); 523 expand_return (expr); 524 expand_end_target_temps (); 525 } 526} 527 528/* Generate the RTL for T, which is a FOR_STMT. */ 529 530void 531genrtl_for_stmt (tree t) 532{ 533 tree cond = FOR_COND (t); 534 location_t saved_loc; 535 536 if (NEW_FOR_SCOPE_P (t)) 537 genrtl_do_pushlevel (); 538 539 expand_stmt (FOR_INIT_STMT (t)); 540 541 /* Expand the initialization. */ 542 emit_line_note (input_location); 543 if (FOR_EXPR (t)) 544 expand_start_loop_continue_elsewhere (1); 545 else 546 expand_start_loop (1); 547 genrtl_do_pushlevel (); 548 549 /* Save the filename and line number so that we expand the FOR_EXPR 550 we can reset them back to the saved values. */ 551 saved_loc = input_location; 552 553 /* Expand the condition. */ 554 if (cond && !integer_nonzerop (cond)) 555 { 556 cond = expand_cond (cond); 557 emit_line_note (input_location); 558 expand_exit_loop_top_cond (0, cond); 559 genrtl_do_pushlevel (); 560 } 561 562 /* Expand the body. */ 563 expand_stmt (FOR_BODY (t)); 564 565 /* Expand the increment expression. */ 566 input_location = saved_loc; 567 emit_line_note (input_location); 568 if (FOR_EXPR (t)) 569 { 570 expand_loop_continue_here (); 571 genrtl_expr_stmt (FOR_EXPR (t)); 572 } 573 expand_end_loop (); 574} 575 576/* Build a break statement node and return it. */ 577 578tree 579build_break_stmt (void) 580{ 581 return (build_stmt (BREAK_STMT)); 582} 583 584/* Generate the RTL for a BREAK_STMT. */ 585 586void 587genrtl_break_stmt (void) 588{ 589 emit_line_note (input_location); 590 if ( ! expand_exit_something ()) 591 abort (); 592} 593 594/* Build a continue statement node and return it. */ 595 596tree 597build_continue_stmt (void) 598{ 599 return (build_stmt (CONTINUE_STMT)); 600} 601 602/* Generate the RTL for a CONTINUE_STMT. */ 603 604void 605genrtl_continue_stmt (void) 606{ 607 emit_line_note (input_location); 608 if (! expand_continue_loop (0)) 609 abort (); 610} 611 612/* Generate the RTL for T, which is a SCOPE_STMT. */ 613 614void 615genrtl_scope_stmt (tree t) 616{ 617 tree block = SCOPE_STMT_BLOCK (t); 618 619 if (!SCOPE_NO_CLEANUPS_P (t)) 620 { 621 if (SCOPE_BEGIN_P (t)) 622 expand_start_bindings_and_block (2 * SCOPE_NULLIFIED_P (t), block); 623 else if (SCOPE_END_P (t)) 624 expand_end_bindings (NULL_TREE, !SCOPE_NULLIFIED_P (t), 0); 625 } 626 else if (!SCOPE_NULLIFIED_P (t)) 627 { 628 rtx note = emit_note (SCOPE_BEGIN_P (t) 629 ? NOTE_INSN_BLOCK_BEG : NOTE_INSN_BLOCK_END); 630 NOTE_BLOCK (note) = block; 631 } 632 633 /* If we're at the end of a scope that contains inlined nested 634 functions, we have to decide whether or not to write them out. */ 635 if (block && SCOPE_END_P (t)) 636 { 637 tree fn; 638 639 for (fn = BLOCK_VARS (block); fn; fn = TREE_CHAIN (fn)) 640 { 641 if (TREE_CODE (fn) == FUNCTION_DECL 642 && DECL_CONTEXT (fn) == current_function_decl 643 && DECL_SAVED_INSNS (fn) 644 && DECL_SAVED_INSNS (fn)->saved_for_inline 645 && !TREE_ASM_WRITTEN (fn) 646 && TREE_ADDRESSABLE (fn)) 647 { 648 push_function_context (); 649 output_inline_function (fn); 650 pop_function_context (); 651 } 652 } 653 } 654} 655 656/* Generate the RTL for T, which is a SWITCH_STMT. */ 657 658void 659genrtl_switch_stmt (tree t) 660{ 661 tree cond; 662 genrtl_do_pushlevel (); 663 664 cond = expand_cond (SWITCH_COND (t)); 665 if (cond == error_mark_node) 666 /* The code is in error, but we don't want expand_end_case to 667 crash. */ 668 cond = truthvalue_false_node; 669 670 emit_line_note (input_location); 671 expand_start_case (1, cond, TREE_TYPE (cond), "switch statement"); 672 expand_stmt (expand_unreachable_stmt (SWITCH_BODY (t), warn_notreached)); 673 expand_end_case_type (cond, SWITCH_TYPE (t)); 674} 675 676/* Create a CASE_LABEL tree node and return it. */ 677 678tree 679build_case_label (tree low_value, tree high_value, tree label_decl) 680{ 681 return build_stmt (CASE_LABEL, low_value, high_value, label_decl); 682} 683 684 685/* Generate the RTL for a CASE_LABEL. */ 686 687void 688genrtl_case_label (tree case_label) 689{ 690 tree duplicate; 691 tree cleanup; 692 693 cleanup = last_cleanup_this_contour (); 694 if (cleanup) 695 { 696 static int explained = 0; 697 warning ("destructor needed for `%D'", (TREE_PURPOSE (cleanup))); 698 warning ("where case label appears here"); 699 if (!explained) 700 { 701 warning ("(enclose actions of previous case statements requiring destructors in their own scope.)"); 702 explained = 1; 703 } 704 } 705 706 add_case_node (CASE_LOW (case_label), CASE_HIGH (case_label), 707 CASE_LABEL_DECL (case_label), &duplicate); 708} 709 710/* Generate the RTL for T, which is a COMPOUND_STMT. */ 711 712void 713genrtl_compound_stmt (tree t) 714{ 715#ifdef ENABLE_CHECKING 716 struct nesting *n = current_nesting_level (); 717#endif 718 719 expand_stmt (COMPOUND_BODY (t)); 720 721#ifdef ENABLE_CHECKING 722 /* Make sure that we've pushed and popped the same number of levels. */ 723 if (!COMPOUND_STMT_NO_SCOPE (t) && n != current_nesting_level ()) 724 abort (); 725#endif 726} 727 728/* Generate the RTL for an ASM_STMT. */ 729 730void 731genrtl_asm_stmt (tree cv_qualifier, tree string, tree output_operands, 732 tree input_operands, tree clobbers, int asm_input_p) 733{ 734 if (cv_qualifier != NULL_TREE 735 && cv_qualifier != ridpointers[(int) RID_VOLATILE]) 736 { 737 warning ("%s qualifier ignored on asm", 738 IDENTIFIER_POINTER (cv_qualifier)); 739 cv_qualifier = NULL_TREE; 740 } 741 742 emit_line_note (input_location); 743 if (asm_input_p) 744 expand_asm (string, cv_qualifier != NULL_TREE); 745 else 746 c_expand_asm_operands (string, output_operands, input_operands, 747 clobbers, cv_qualifier != NULL_TREE, 748 input_location); 749} 750 751/* Generate the RTL for a CLEANUP_STMT. */ 752 753void 754genrtl_cleanup_stmt (tree t) 755{ 756 tree decl = CLEANUP_DECL (t); 757 if (!decl || !DECL_P (decl) 758 || (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node)) 759 expand_decl_cleanup_eh (decl, CLEANUP_EXPR (t), CLEANUP_EH_ONLY (t)); 760} 761 762/* We're about to expand T, a statement. Set up appropriate context 763 for the substitution. */ 764 765void 766prep_stmt (tree t) 767{ 768 if (!STMT_LINENO_FOR_FN_P (t)) 769 input_line = STMT_LINENO (t); 770 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t); 771} 772 773/* Generate the RTL for the statement T, its substatements, and any 774 other statements at its nesting level. */ 775 776void 777expand_stmt (tree t) 778{ 779 while (t && t != error_mark_node) 780 { 781 int saved_stmts_are_full_exprs_p; 782 783 /* Set up context appropriately for handling this statement. */ 784 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p (); 785 prep_stmt (t); 786 787 switch (TREE_CODE (t)) 788 { 789 case FILE_STMT: 790 input_filename = FILE_STMT_FILENAME (t); 791 break; 792 793 case RETURN_STMT: 794 genrtl_return_stmt (t); 795 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached); 796 goto process_t; 797 798 case EXPR_STMT: 799 genrtl_expr_stmt_value (EXPR_STMT_EXPR (t), TREE_ADDRESSABLE (t), 800 TREE_CHAIN (t) == NULL 801 || (TREE_CODE (TREE_CHAIN (t)) == SCOPE_STMT 802 && TREE_CHAIN (TREE_CHAIN (t)) == NULL)); 803 break; 804 805 case DECL_STMT: 806 genrtl_decl_stmt (t); 807 break; 808 809 case FOR_STMT: 810 genrtl_for_stmt (t); 811 break; 812 813 case WHILE_STMT: 814 genrtl_while_stmt (t); 815 break; 816 817 case DO_STMT: 818 genrtl_do_stmt (t); 819 break; 820 821 case IF_STMT: 822 genrtl_if_stmt (t); 823 break; 824 825 case COMPOUND_STMT: 826 genrtl_compound_stmt (t); 827 break; 828 829 case BREAK_STMT: 830 genrtl_break_stmt (); 831 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached); 832 goto process_t; 833 834 case CONTINUE_STMT: 835 genrtl_continue_stmt (); 836 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached); 837 goto process_t; 838 839 case SWITCH_STMT: 840 genrtl_switch_stmt (t); 841 break; 842 843 case CASE_LABEL: 844 genrtl_case_label (t); 845 break; 846 847 case LABEL_STMT: 848 expand_label (LABEL_STMT_LABEL (t)); 849 break; 850 851 case GOTO_STMT: 852 /* Emit information for branch prediction. */ 853 if (!GOTO_FAKE_P (t) 854 && TREE_CODE (GOTO_DESTINATION (t)) == LABEL_DECL 855 && flag_guess_branch_prob) 856 { 857 rtx note = emit_note (NOTE_INSN_PREDICTION); 858 859 NOTE_PREDICTION (note) = NOTE_PREDICT (PRED_GOTO, NOT_TAKEN); 860 } 861 genrtl_goto_stmt (GOTO_DESTINATION (t)); 862 t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached); 863 goto process_t; 864 865 case ASM_STMT: 866 genrtl_asm_stmt (ASM_CV_QUAL (t), ASM_STRING (t), 867 ASM_OUTPUTS (t), ASM_INPUTS (t), 868 ASM_CLOBBERS (t), ASM_INPUT_P (t)); 869 break; 870 871 case SCOPE_STMT: 872 genrtl_scope_stmt (t); 873 break; 874 875 case CLEANUP_STMT: 876 genrtl_cleanup_stmt (t); 877 break; 878 879 default: 880 if (lang_expand_stmt) 881 (*lang_expand_stmt) (t); 882 else 883 abort (); 884 break; 885 } 886 887 /* Go on to the next statement in this scope. */ 888 t = TREE_CHAIN (t); 889 890 process_t: 891 /* Restore saved state. */ 892 current_stmt_tree ()->stmts_are_full_exprs_p 893 = saved_stmts_are_full_exprs_p; 894 } 895} 896 897/* If *TP is a potentially reachable label, return nonzero. */ 898 899static tree 900find_reachable_label_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, 901 void *data ATTRIBUTE_UNUSED) 902{ 903 switch (TREE_CODE (*tp)) 904 { 905 case LABEL_STMT: 906 case CASE_LABEL: 907 return *tp; 908 909 default: 910 break; 911 } 912 return NULL_TREE; 913} 914 915/* Determine whether expression EXP contains a potentially 916 reachable label. */ 917static tree 918find_reachable_label (tree exp) 919{ 920 location_t saved_loc = input_location; 921 tree ret = walk_tree_without_duplicates 922 (&exp, find_reachable_label_1, NULL); 923 input_location = saved_loc; 924 return ret; 925} 926 927/* Expand an unreachable if statement, T. This function returns 928 true if the IF_STMT contains a potentially reachable code_label. */ 929static bool 930expand_unreachable_if_stmt (tree t) 931{ 932 tree n; 933 934 if (find_reachable_label (IF_COND (t)) != NULL_TREE) 935 { 936 genrtl_if_stmt (t); 937 return true; 938 } 939 940 /* Account for declarations as conditions. */ 941 expand_cond (IF_COND (t)); 942 943 if (THEN_CLAUSE (t) && ELSE_CLAUSE (t)) 944 { 945 n = expand_unreachable_stmt (THEN_CLAUSE (t), 0); 946 947 if (n != NULL_TREE) 948 { 949 rtx label; 950 expand_stmt (n); 951 label = gen_label_rtx (); 952 emit_jump (label); 953 expand_stmt (expand_unreachable_stmt (ELSE_CLAUSE (t), 0)); 954 emit_label (label); 955 return true; 956 } 957 else 958 n = expand_unreachable_stmt (ELSE_CLAUSE (t), 0); 959 } 960 else if (THEN_CLAUSE (t)) 961 n = expand_unreachable_stmt (THEN_CLAUSE (t), 0); 962 else if (ELSE_CLAUSE (t)) 963 n = expand_unreachable_stmt (ELSE_CLAUSE (t), 0); 964 else 965 n = NULL_TREE; 966 967 expand_stmt (n); 968 969 return n != NULL_TREE; 970} 971 972/* Expand an unreachable statement list. This function skips all 973 statements preceding the first potentially reachable label and 974 then returns the label (or, in same cases, the statement after 975 one containing the label). This function returns NULL_TREE if 976 the end of the given statement list is unreachable, and a 977 non-NULL value, possibly error_mark_node, otherwise. */ 978static tree 979expand_unreachable_stmt (tree t, int warn) 980{ 981 int saved; 982 983 while (t && t != error_mark_node) 984 { 985 if (warn) 986 switch (TREE_CODE (t)) 987 { 988 case BREAK_STMT: 989 case CONTINUE_STMT: 990 case EXPR_STMT: 991 case GOTO_STMT: 992 case IF_STMT: 993 case RETURN_STMT: 994 if (!STMT_LINENO_FOR_FN_P (t)) 995 input_line = STMT_LINENO (t); 996 warning("will never be executed"); 997 warn = false; 998 break; 999 1000 default: 1001 break; 1002 } 1003 1004 switch (TREE_CODE (t)) 1005 { 1006 case GOTO_STMT: 1007 case CONTINUE_STMT: 1008 case BREAK_STMT: 1009 break; 1010 1011 case FILE_STMT: 1012 input_filename = FILE_STMT_FILENAME (t); 1013 break; 1014 1015 case RETURN_STMT: 1016 if (find_reachable_label (RETURN_STMT_EXPR (t)) != NULL_TREE) 1017 return t; 1018 break; 1019 1020 case EXPR_STMT: 1021 if (find_reachable_label (EXPR_STMT_EXPR (t)) != NULL_TREE) 1022 return t; 1023 break; 1024 1025 case IF_STMT: 1026 if (expand_unreachable_if_stmt (t)) 1027 return TREE_CHAIN (t) ? TREE_CHAIN (t) : error_mark_node; 1028 break; 1029 1030 case WHILE_STMT: 1031 /* If the start of a while statement is unreachable, there is 1032 no need to rotate the loop, instead the WHILE_STMT can be 1033 expanded like a DO_STMT. */ 1034 genrtl_do_stmt_1 (WHILE_COND (t), WHILE_BODY (t)); 1035 return TREE_CHAIN (t) ? TREE_CHAIN (t) : error_mark_node; 1036 1037 case COMPOUND_STMT: 1038 { 1039 tree n; 1040 n = expand_unreachable_stmt (COMPOUND_BODY (t), warn); 1041 if (n != NULL_TREE) 1042 { 1043 expand_stmt (n); 1044 return TREE_CHAIN (t) ? TREE_CHAIN (t) : error_mark_node; 1045 } 1046 warn = false; 1047 break; 1048 } 1049 1050 case SCOPE_STMT: 1051 saved = stmts_are_full_exprs_p (); 1052 prep_stmt (t); 1053 genrtl_scope_stmt (t); 1054 current_stmt_tree ()->stmts_are_full_exprs_p = saved; 1055 break; 1056 1057 default: 1058 return t; 1059 } 1060 t = TREE_CHAIN (t); 1061 } 1062 return NULL_TREE; 1063} 1064