gcc/c-semantics.c

   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 Free Software Foundation, Inc.
   5    Written by Benjamin Chelf (chelf@codesourcery.com).
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 2, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to the Free
  21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22 02111-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.  */
  50 void (*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.  */
  57 void (*lang_expand_decl_stmt) (tree);
  58
  59 static tree find_reachable_label_1 (tree *, int *, void *);
  60 static tree find_reachable_label (tree);
  61 static bool expand_unreachable_if_stmt (tree);
  62 static tree expand_unreachable_stmt (tree, int);
  63 static void genrtl_do_stmt_1 (tree, tree);
  64
  65 /* Create an empty statement tree rooted at T.  */
  66
  67 void
  68 begin_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
  81 tree
  82 add_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
 111 void
 112 add_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
 131 tree
 132 add_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
 165 void
 166 finish_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
 190 tree
 191 build_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
 216 tree
 217 expand_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
 230 void
 231 make_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
 265 void
 266 emit_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
 296 void
 297 genrtl_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
 305 void
 306 genrtl_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
 331 void
 332 genrtl_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
 344 void
 345 genrtl_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
 364 void
 365 genrtl_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
 398 void
 399 genrtl_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
 428 void
 429 genrtl_while_stmt (tree t)
 430 {
 431   tree cond = WHILE_COND (t);
 432
 433   emit_nop ();
 434   emit_line_note (input_location);
 435   expand_start_loop (1);
 436   genrtl_do_pushlevel ();
 437
 438   if (cond && !integer_nonzerop (cond))
 439     {
 440       cond = expand_cond (cond);
 441       emit_line_note (input_location);
 442       expand_exit_loop_top_cond (0, cond);
 443       genrtl_do_pushlevel ();
 444     }
 445
 446   expand_stmt (WHILE_BODY (t));
 447
 448   expand_end_loop ();
 449 }
 450
 451 /* Generate the RTL for a DO_STMT with condition COND and loop BODY
 452    body.  This is reused for expanding unreachable WHILE_STMTS.  */
 453
 454 static void
 455 genrtl_do_stmt_1 (tree cond, tree body)
 456 {
 457   /* Recognize the common special-case of do { ... } while (0) and do
 458      not emit the loop widgetry in this case.  In particular this
 459      avoids cluttering the rtl with dummy loop notes, which can affect
 460      alignment of adjacent labels.  COND can be NULL due to parse
 461      errors.  */
 462   if (!cond || integer_zerop (cond))
 463     {
 464       expand_start_null_loop ();
 465       expand_stmt (body);
 466       expand_end_null_loop ();
 467     }
 468   else if (integer_nonzerop (cond))
 469     {
 470       emit_nop ();
 471       emit_line_note (input_location);
 472       expand_start_loop (1);
 473
 474       expand_stmt (body);
 475
 476       emit_line_note (input_location);
 477       expand_end_loop ();
 478     }
 479   else
 480     {
 481       emit_nop ();
 482       emit_line_note (input_location);
 483       expand_start_loop_continue_elsewhere (1);
 484
 485       expand_stmt (body);
 486
 487       expand_loop_continue_here ();
 488       cond = expand_cond (cond);
 489       emit_line_note (input_location);
 490       expand_exit_loop_if_false (0, cond);
 491       expand_end_loop ();
 492     }
 493 }
 494
 495 /* Generate the RTL for T, which is a DO_STMT.  */
 496
 497 void
 498 genrtl_do_stmt (tree t)
 499 {
 500   genrtl_do_stmt_1 (DO_COND (t), DO_BODY (t));
 501 }
 502
 503 /* Build the node for a return statement and return it.  */
 504
 505 tree
 506 build_return_stmt (tree expr)
 507 {
 508   return (build_stmt (RETURN_STMT, expr));
 509 }
 510
 511 /* Generate the RTL for STMT, which is a RETURN_STMT.  */
 512
 513 void
 514 genrtl_return_stmt (tree stmt)
 515 {
 516   tree expr;
 517
 518   expr = RETURN_STMT_EXPR (stmt);
 519
 520   emit_line_note (input_location);
 521   if (!expr)
 522     expand_null_return ();
 523   else
 524     {
 525       expand_start_target_temps ();
 526       expand_return (expr);
 527       expand_end_target_temps ();
 528     }
 529 }
 530
 531 /* Generate the RTL for T, which is a FOR_STMT.  */
 532
 533 void
 534 genrtl_for_stmt (tree t)
 535 {
 536   tree cond = FOR_COND (t);
 537   location_t saved_loc;
 538
 539   if (NEW_FOR_SCOPE_P (t))
 540     genrtl_do_pushlevel ();
 541
 542   expand_stmt (FOR_INIT_STMT (t));
 543
 544   /* Expand the initialization.  */
 545   emit_nop ();
 546   emit_line_note (input_location);
 547   if (FOR_EXPR (t))
 548     expand_start_loop_continue_elsewhere (1);
 549   else
 550     expand_start_loop (1);
 551   genrtl_do_pushlevel ();
 552
 553   /* Save the filename and line number so that we expand the FOR_EXPR
 554      we can reset them back to the saved values.  */
 555   saved_loc = input_location;
 556
 557   /* Expand the condition.  */
 558   if (cond && !integer_nonzerop (cond))
 559     {
 560       cond = expand_cond (cond);
 561       emit_line_note (input_location);
 562       expand_exit_loop_top_cond (0, cond);
 563       genrtl_do_pushlevel ();
 564     }
 565
 566   /* Expand the body.  */
 567   expand_stmt (FOR_BODY (t));
 568
 569   /* Expand the increment expression.  */
 570   input_location = saved_loc;
 571   emit_line_note (input_location);
 572   if (FOR_EXPR (t))
 573     {
 574       expand_loop_continue_here ();
 575       genrtl_expr_stmt (FOR_EXPR (t));
 576     }
 577   expand_end_loop ();
 578 }
 579
 580 /* Build a break statement node and return it.  */
 581
 582 tree
 583 build_break_stmt (void)
 584 {
 585   return (build_stmt (BREAK_STMT));
 586 }
 587
 588 /* Generate the RTL for a BREAK_STMT.  */
 589
 590 void
 591 genrtl_break_stmt (void)
 592 {
 593   emit_line_note (input_location);
 594   if ( ! expand_exit_something ())
 595     abort ();
 596 }
 597
 598 /* Build a continue statement node and return it.  */
 599
 600 tree
 601 build_continue_stmt (void)
 602 {
 603   return (build_stmt (CONTINUE_STMT));
 604 }
 605
 606 /* Generate the RTL for a CONTINUE_STMT.  */
 607
 608 void
 609 genrtl_continue_stmt (void)
 610 {
 611   emit_line_note (input_location);
 612   if (! expand_continue_loop (0))
 613     abort ();
 614 }
 615
 616 /* Generate the RTL for T, which is a SCOPE_STMT.  */
 617
 618 void
 619 genrtl_scope_stmt (tree t)
 620 {
 621   tree block = SCOPE_STMT_BLOCK (t);
 622
 623   if (!SCOPE_NO_CLEANUPS_P (t))
 624     {
 625       if (SCOPE_BEGIN_P (t))
 626         expand_start_bindings_and_block (2 * SCOPE_NULLIFIED_P (t), block);
 627       else if (SCOPE_END_P (t))
 628         expand_end_bindings (NULL_TREE, !SCOPE_NULLIFIED_P (t), 0);
 629     }
 630   else if (!SCOPE_NULLIFIED_P (t))
 631     {
 632       rtx note = emit_note (SCOPE_BEGIN_P (t)
 633                             ? NOTE_INSN_BLOCK_BEG : NOTE_INSN_BLOCK_END);
 634       NOTE_BLOCK (note) = block;
 635     }
 636
 637   /* If we're at the end of a scope that contains inlined nested
 638      functions, we have to decide whether or not to write them out.  */
 639   if (block && SCOPE_END_P (t))
 640     {
 641       tree fn;
 642
 643       for (fn = BLOCK_VARS (block); fn; fn = TREE_CHAIN (fn))
 644         {
 645           if (TREE_CODE (fn) == FUNCTION_DECL
 646               && DECL_CONTEXT (fn) == current_function_decl
 647               && DECL_SAVED_INSNS (fn)
 648               && DECL_SAVED_INSNS (fn)->saved_for_inline
 649               && !TREE_ASM_WRITTEN (fn)
 650               && TREE_ADDRESSABLE (fn))
 651             {
 652               push_function_context ();
 653               output_inline_function (fn);
 654               pop_function_context ();
 655             }
 656         }
 657     }
 658 }
 659
 660 /* Generate the RTL for T, which is a SWITCH_STMT.  */
 661
 662 void
 663 genrtl_switch_stmt (tree t)
 664 {
 665   tree cond;
 666   genrtl_do_pushlevel ();
 667
 668   cond = expand_cond (SWITCH_COND (t));
 669   if (cond == error_mark_node)
 670     /* The code is in error, but we don't want expand_end_case to
 671        crash.  */
 672     cond = truthvalue_false_node;
 673
 674   emit_line_note (input_location);
 675   expand_start_case (1, cond, TREE_TYPE (cond), "switch statement");
 676   expand_stmt (expand_unreachable_stmt (SWITCH_BODY (t), warn_notreached));
 677   expand_end_case_type (cond, SWITCH_TYPE (t));
 678 }
 679
 680 /* Create a CASE_LABEL tree node and return it.  */
 681
 682 tree
 683 build_case_label (tree low_value, tree high_value, tree label_decl)
 684 {
 685   return build_stmt (CASE_LABEL, low_value, high_value, label_decl);
 686 }
 687
 688
 689 /* Generate the RTL for a CASE_LABEL.  */
 690
 691 void
 692 genrtl_case_label (tree case_label)
 693 {
 694   tree duplicate;
 695   tree cleanup;
 696
 697   cleanup = last_cleanup_this_contour ();
 698   if (cleanup)
 699     {
 700       static int explained = 0;
 701       warning ("destructor needed for `%D'", (TREE_PURPOSE (cleanup)));
 702       warning ("where case label appears here");
 703       if (!explained)
 704         {
 705           warning ("(enclose actions of previous case statements requiring destructors in their own scope.)");
 706           explained = 1;
 707         }
 708     }
 709
 710   add_case_node (CASE_LOW (case_label), CASE_HIGH (case_label),
 711                  CASE_LABEL_DECL (case_label), &duplicate);
 712 }
 713
 714 /* Generate the RTL for T, which is a COMPOUND_STMT.  */
 715
 716 void
 717 genrtl_compound_stmt (tree t)
 718 {
 719 #ifdef ENABLE_CHECKING
 720   struct nesting *n = current_nesting_level ();
 721 #endif
 722
 723   expand_stmt (COMPOUND_BODY (t));
 724
 725 #ifdef ENABLE_CHECKING
 726   /* Make sure that we've pushed and popped the same number of levels.  */
 727   if (!COMPOUND_STMT_NO_SCOPE (t) && n != current_nesting_level ())
 728     abort ();
 729 #endif
 730 }
 731
 732 /* Generate the RTL for an ASM_STMT.  */
 733
 734 void
 735 genrtl_asm_stmt (tree cv_qualifier, tree string, tree output_operands,
 736                  tree input_operands, tree clobbers, int asm_input_p)
 737 {
 738   if (cv_qualifier != NULL_TREE
 739       && cv_qualifier != ridpointers[(int) RID_VOLATILE])
 740     {
 741       warning ("%s qualifier ignored on asm",
 742                IDENTIFIER_POINTER (cv_qualifier));
 743       cv_qualifier = NULL_TREE;
 744     }
 745
 746   emit_line_note (input_location);
 747   if (asm_input_p)
 748     expand_asm (string, cv_qualifier != NULL_TREE);
 749   else
 750     c_expand_asm_operands (string, output_operands, input_operands,
 751                            clobbers, cv_qualifier != NULL_TREE,
 752                            input_location);
 753 }
 754
 755 /* Generate the RTL for a CLEANUP_STMT.  */
 756
 757 void
 758 genrtl_cleanup_stmt (tree t)
 759 {
 760   tree decl = CLEANUP_DECL (t);
 761   if (!decl || !DECL_P (decl)
 762       || (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node))
 763     expand_decl_cleanup_eh (decl, CLEANUP_EXPR (t), CLEANUP_EH_ONLY (t));
 764 }
 765
 766 /* We're about to expand T, a statement.  Set up appropriate context
 767    for the substitution.  */
 768
 769 void
 770 prep_stmt (tree t)
 771 {
 772   if (!STMT_LINENO_FOR_FN_P (t))
 773     input_line = STMT_LINENO (t);
 774   current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
 775 }
 776
 777 /* Generate the RTL for the statement T, its substatements, and any
 778    other statements at its nesting level.  */
 779
 780 void
 781 expand_stmt (tree t)
 782 {
 783   while (t && t != error_mark_node)
 784     {
 785       int saved_stmts_are_full_exprs_p;
 786
 787       /* Set up context appropriately for handling this statement.  */
 788       saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
 789       prep_stmt (t);
 790
 791       switch (TREE_CODE (t))
 792         {
 793         case FILE_STMT:
 794           input_filename = FILE_STMT_FILENAME (t);
 795           break;
 796
 797         case RETURN_STMT:
 798           genrtl_return_stmt (t);
 799           t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
 800           goto process_t;
 801
 802         case EXPR_STMT:
 803           genrtl_expr_stmt_value (EXPR_STMT_EXPR (t), TREE_ADDRESSABLE (t),
 804                                   TREE_CHAIN (t) == NULL
 805                                   || (TREE_CODE (TREE_CHAIN (t)) == SCOPE_STMT
 806                                       && TREE_CHAIN (TREE_CHAIN (t)) == NULL));
 807           break;
 808
 809         case DECL_STMT:
 810           genrtl_decl_stmt (t);
 811           break;
 812
 813         case FOR_STMT:
 814           genrtl_for_stmt (t);
 815           break;
 816
 817         case WHILE_STMT:
 818           genrtl_while_stmt (t);
 819           break;
 820
 821         case DO_STMT:
 822           genrtl_do_stmt (t);
 823           break;
 824
 825         case IF_STMT:
 826           genrtl_if_stmt (t);
 827           break;
 828
 829         case COMPOUND_STMT:
 830           genrtl_compound_stmt (t);
 831           break;
 832
 833         case BREAK_STMT:
 834           genrtl_break_stmt ();
 835           t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
 836           goto process_t;
 837
 838         case CONTINUE_STMT:
 839           genrtl_continue_stmt ();
 840           t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
 841           goto process_t;
 842
 843         case SWITCH_STMT:
 844           genrtl_switch_stmt (t);
 845           break;
 846
 847         case CASE_LABEL:
 848           genrtl_case_label (t);
 849           break;
 850
 851         case LABEL_STMT:
 852           expand_label (LABEL_STMT_LABEL (t));
 853           break;
 854
 855         case GOTO_STMT:
 856           /* Emit information for branch prediction.  */
 857           if (!GOTO_FAKE_P (t)
 858               && TREE_CODE (GOTO_DESTINATION (t)) == LABEL_DECL
 859               && flag_guess_branch_prob)
 860             {
 861               rtx note = emit_note (NOTE_INSN_PREDICTION);
 862
 863               NOTE_PREDICTION (note) = NOTE_PREDICT (PRED_GOTO, NOT_TAKEN);
 864             }
 865           genrtl_goto_stmt (GOTO_DESTINATION (t));
 866           t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
 867           goto process_t;
 868
 869         case ASM_STMT:
 870           genrtl_asm_stmt (ASM_CV_QUAL (t), ASM_STRING (t),
 871                            ASM_OUTPUTS (t), ASM_INPUTS (t),
 872                            ASM_CLOBBERS (t), ASM_INPUT_P (t));
 873           break;
 874
 875         case SCOPE_STMT:
 876           genrtl_scope_stmt (t);
 877           break;
 878
 879         case CLEANUP_STMT:
 880           genrtl_cleanup_stmt (t);
 881           break;
 882
 883         default:
 884           if (lang_expand_stmt)
 885             (*lang_expand_stmt) (t);
 886           else
 887             abort ();
 888           break;
 889         }
 890
 891       /* Go on to the next statement in this scope.  */
 892       t = TREE_CHAIN (t);
 893
 894     process_t:
 895       /* Restore saved state.  */
 896       current_stmt_tree ()->stmts_are_full_exprs_p
 897         = saved_stmts_are_full_exprs_p;
 898     }
 899 }
 900 \f
 901 /* If *TP is a potentially reachable label, return nonzero.  */
 902
 903 static tree
 904 find_reachable_label_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
 905                         void *data ATTRIBUTE_UNUSED)
 906 {
 907   switch (TREE_CODE (*tp))
 908     {
 909     case LABEL_STMT:
 910     case CASE_LABEL:
 911       return *tp;
 912
 913     default:
 914       break;
 915     }
 916   return NULL_TREE;
 917 }
 918
 919 /* Determine whether expression EXP contains a potentially
 920    reachable label.  */
 921 static tree
 922 find_reachable_label (tree exp)
 923 {
 924   location_t saved_loc = input_location;
 925   tree ret = walk_tree_without_duplicates
 926                 (&exp, find_reachable_label_1, NULL);
 927   input_location = saved_loc;
 928   return ret;
 929 }
 930
 931 /* Expand an unreachable if statement, T.  This function returns
 932    true if the IF_STMT contains a potentially reachable code_label.  */
 933 static bool
 934 expand_unreachable_if_stmt (tree t)
 935 {
 936   tree n;
 937
 938   if (find_reachable_label (IF_COND (t)) != NULL_TREE)
 939     {
 940       genrtl_if_stmt (t);
 941       return true;
 942     }
 943
 944   if (THEN_CLAUSE (t) && ELSE_CLAUSE (t))
 945     {
 946       n = expand_unreachable_stmt (THEN_CLAUSE (t), 0);
 947
 948       if (n != NULL_TREE)
 949         {
 950           rtx label;
 951           expand_stmt (n);
 952           label = gen_label_rtx ();
 953           emit_jump (label);
 954           expand_stmt (expand_unreachable_stmt (ELSE_CLAUSE (t), 0));
 955           emit_label (label);
 956           return true;
 957         }
 958       else
 959         n = expand_unreachable_stmt (ELSE_CLAUSE (t), 0);
 960     }
 961   else if (THEN_CLAUSE (t))
 962     n = expand_unreachable_stmt (THEN_CLAUSE (t), 0);
 963   else if (ELSE_CLAUSE (t))
 964     n = expand_unreachable_stmt (ELSE_CLAUSE (t), 0);
 965   else
 966     n = NULL_TREE;
 967
 968   expand_stmt (n);
 969
 970   return n != NULL_TREE;
 971 }
 972
 973 /* Expand an unreachable statement list.  This function skips all
 974    statements preceding the first potentially reachable label and
 975    then returns the label (or, in same cases, the statement after
 976    one containing the label).  */
 977 static tree
 978 expand_unreachable_stmt (tree t, int warn)
 979 {
 980   int saved;
 981
 982   while (t && t != error_mark_node)
 983     {
 984       if (warn)
 985         switch (TREE_CODE (t))
 986           {
 987           case BREAK_STMT:
 988           case CONTINUE_STMT:
 989           case EXPR_STMT:
 990           case GOTO_STMT:
 991           case IF_STMT:
 992           case RETURN_STMT:
 993             if (!STMT_LINENO_FOR_FN_P (t))
 994               input_line = STMT_LINENO (t);
 995             warning("will never be executed");
 996             warn = false;
 997             break;
 998
 999           default:
1000             break;
1001           }
1002
1003       switch (TREE_CODE (t))
1004         {
1005         case GOTO_STMT:
1006         case CONTINUE_STMT:
1007         case BREAK_STMT:
1008           break;
1009
1010         case FILE_STMT:
1011           input_filename = FILE_STMT_FILENAME (t);
1012           break;
1013
1014         case RETURN_STMT:
1015           if (find_reachable_label (RETURN_STMT_EXPR (t)) != NULL_TREE)
1016             return t;
1017           break;
1018
1019         case EXPR_STMT:
1020           if (find_reachable_label (EXPR_STMT_EXPR (t)) != NULL_TREE)
1021             return t;
1022           break;
1023
1024         case IF_STMT:
1025           if (expand_unreachable_if_stmt (t))
1026             return TREE_CHAIN (t);
1027           break;
1028
1029         case WHILE_STMT:
1030           /* If the start of a while statement is unreachable, there is
1031              no need to rotate the loop, instead the WHILE_STMT can be
1032              expanded like a DO_STMT.  */
1033           genrtl_do_stmt_1 (WHILE_COND (t), WHILE_BODY (t));
1034           return TREE_CHAIN (t);
1035
1036         case COMPOUND_STMT:
1037           {
1038             tree n;
1039             n = expand_unreachable_stmt (COMPOUND_BODY (t), warn);
1040             if (n != NULL_TREE)
1041               {
1042                 expand_stmt (n);
1043                 return TREE_CHAIN (t);
1044               }
1045             warn = false;
1046             break;
1047           }
1048
1049         case SCOPE_STMT:
1050           saved = stmts_are_full_exprs_p ();
1051           prep_stmt (t);
1052           genrtl_scope_stmt (t);
1053           current_stmt_tree ()->stmts_are_full_exprs_p = saved;
1054           break;
1055
1056         default:
1057           return t;
1058         }
1059       t = TREE_CHAIN (t);
1060     }
1061   return NULL_TREE;
1062 }