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     error ("break statement not within loop or switch");
 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     error ("continue statement not within a loop");
 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_filename, input_line);
 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_SIZE (decl) && TREE_TYPE (decl) != error_mark_node))
 762     expand_decl_cleanup_eh (decl, CLEANUP_EXPR (t), CLEANUP_EH_ONLY (t));
 763 }
 764
 765 /* We're about to expand T, a statement.  Set up appropriate context
 766    for the substitution.  */
 767
 768 void
 769 prep_stmt (tree t)
 770 {
 771   if (!STMT_LINENO_FOR_FN_P (t))
 772     input_line = STMT_LINENO (t);
 773   current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
 774 }
 775
 776 /* Generate the RTL for the statement T, its substatements, and any
 777    other statements at its nesting level.  */
 778
 779 void
 780 expand_stmt (tree t)
 781 {
 782   while (t && t != error_mark_node)
 783     {
 784       int saved_stmts_are_full_exprs_p;
 785
 786       /* Set up context appropriately for handling this statement.  */
 787       saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
 788       prep_stmt (t);
 789
 790       switch (TREE_CODE (t))
 791         {
 792         case FILE_STMT:
 793           input_filename = FILE_STMT_FILENAME (t);
 794           break;
 795
 796         case RETURN_STMT:
 797           genrtl_return_stmt (t);
 798           t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
 799           goto process_t;
 800
 801         case EXPR_STMT:
 802           genrtl_expr_stmt_value (EXPR_STMT_EXPR (t), TREE_ADDRESSABLE (t),
 803                                   TREE_CHAIN (t) == NULL
 804                                   || (TREE_CODE (TREE_CHAIN (t)) == SCOPE_STMT
 805                                       && TREE_CHAIN (TREE_CHAIN (t)) == NULL));
 806           break;
 807
 808         case DECL_STMT:
 809           genrtl_decl_stmt (t);
 810           break;
 811
 812         case FOR_STMT:
 813           genrtl_for_stmt (t);
 814           break;
 815
 816         case WHILE_STMT:
 817           genrtl_while_stmt (t);
 818           break;
 819
 820         case DO_STMT:
 821           genrtl_do_stmt (t);
 822           break;
 823
 824         case IF_STMT:
 825           genrtl_if_stmt (t);
 826           break;
 827
 828         case COMPOUND_STMT:
 829           genrtl_compound_stmt (t);
 830           break;
 831
 832         case BREAK_STMT:
 833           genrtl_break_stmt ();
 834           t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
 835           goto process_t;
 836
 837         case CONTINUE_STMT:
 838           genrtl_continue_stmt ();
 839           t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
 840           goto process_t;
 841
 842         case SWITCH_STMT:
 843           genrtl_switch_stmt (t);
 844           break;
 845
 846         case CASE_LABEL:
 847           genrtl_case_label (t);
 848           break;
 849
 850         case LABEL_STMT:
 851           expand_label (LABEL_STMT_LABEL (t));
 852           break;
 853
 854         case GOTO_STMT:
 855           /* Emit information for branch prediction.  */
 856           if (!GOTO_FAKE_P (t)
 857               && TREE_CODE (GOTO_DESTINATION (t)) == LABEL_DECL
 858               && flag_guess_branch_prob)
 859             {
 860               rtx note = emit_note (NOTE_INSN_PREDICTION);
 861
 862               NOTE_PREDICTION (note) = NOTE_PREDICT (PRED_GOTO, NOT_TAKEN);
 863             }
 864           genrtl_goto_stmt (GOTO_DESTINATION (t));
 865           t = expand_unreachable_stmt (TREE_CHAIN (t), warn_notreached);
 866           goto process_t;
 867
 868         case ASM_STMT:
 869           genrtl_asm_stmt (ASM_CV_QUAL (t), ASM_STRING (t),
 870                            ASM_OUTPUTS (t), ASM_INPUTS (t),
 871                            ASM_CLOBBERS (t), ASM_INPUT_P (t));
 872           break;
 873
 874         case SCOPE_STMT:
 875           genrtl_scope_stmt (t);
 876           break;
 877
 878         case CLEANUP_STMT:
 879           genrtl_cleanup_stmt (t);
 880           break;
 881
 882         default:
 883           if (lang_expand_stmt)
 884             (*lang_expand_stmt) (t);
 885           else
 886             abort ();
 887           break;
 888         }
 889
 890       /* Go on to the next statement in this scope.  */
 891       t = TREE_CHAIN (t);
 892
 893     process_t:
 894       /* Restore saved state.  */
 895       current_stmt_tree ()->stmts_are_full_exprs_p
 896         = saved_stmts_are_full_exprs_p;
 897     }
 898 }
 899 \f
 900 /* If *TP is a potentially reachable label, return nonzero.  */
 901
 902 static tree
 903 find_reachable_label_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
 904                         void *data ATTRIBUTE_UNUSED)
 905 {
 906   switch (TREE_CODE (*tp))
 907     {
 908     case LABEL_STMT:
 909     case CASE_LABEL:
 910       return *tp;
 911
 912     default:
 913       break;
 914     }
 915   return NULL_TREE;
 916 }
 917
 918 /* Determine whether expression EXP contains a potentially
 919    reachable label.  */
 920 static tree
 921 find_reachable_label (tree exp)
 922 {
 923   location_t saved_loc = input_location;
 924   tree ret = walk_tree_without_duplicates
 925                 (&exp, find_reachable_label_1, NULL);
 926   input_location = saved_loc;
 927   return ret;
 928 }
 929
 930 /* Expand an unreachable if statement, T.  This function returns
 931    true if the IF_STMT contains a potentially reachable code_label.  */
 932 static bool
 933 expand_unreachable_if_stmt (tree t)
 934 {
 935   tree n;
 936
 937   if (find_reachable_label (IF_COND (t)) != NULL_TREE)
 938     {
 939       genrtl_if_stmt (t);
 940       return true;
 941     }
 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).  */
 976 static tree
 977 expand_unreachable_stmt (tree t, int warn)
 978 {
 979   int saved;
 980
 981   while (t && t != error_mark_node)
 982     {
 983       if (warn)
 984         switch (TREE_CODE (t))
 985           {
 986           case BREAK_STMT:
 987           case CONTINUE_STMT:
 988           case EXPR_STMT:
 989           case GOTO_STMT:
 990           case IF_STMT:
 991           case RETURN_STMT:
 992             if (!STMT_LINENO_FOR_FN_P (t))
 993               input_line = STMT_LINENO (t);
 994             warning("will never be executed");
 995             warn = false;
 996             break;
 997
 998           default:
 999             break;
1000           }
1001
1002       switch (TREE_CODE (t))
1003         {
1004         case GOTO_STMT:
1005         case CONTINUE_STMT:
1006         case BREAK_STMT:
1007           break;
1008
1009         case FILE_STMT:
1010           input_filename = FILE_STMT_FILENAME (t);
1011           break;
1012
1013         case RETURN_STMT:
1014           if (find_reachable_label (RETURN_STMT_EXPR (t)) != NULL_TREE)
1015             return t;
1016           break;
1017
1018         case EXPR_STMT:
1019           if (find_reachable_label (EXPR_STMT_EXPR (t)) != NULL_TREE)
1020             return t;
1021           break;
1022
1023         case IF_STMT:
1024           if (expand_unreachable_if_stmt (t))
1025             return TREE_CHAIN (t);
1026           break;
1027
1028         case WHILE_STMT:
1029           /* If the start of a while statement is unreachable, there is
1030              no need to rotate the loop, instead the WHILE_STMT can be
1031              expanded like a DO_STMT.  */
1032           genrtl_do_stmt_1 (WHILE_COND (t), WHILE_BODY (t));
1033           return TREE_CHAIN (t);
1034
1035         case COMPOUND_STMT:
1036           {
1037             tree n;
1038             n = expand_unreachable_stmt (COMPOUND_BODY (t), warn);
1039             if (n != NULL_TREE)
1040               {
1041                 expand_stmt (n);
1042                 return TREE_CHAIN (t);
1043               }
1044             warn = false;
1045             break;
1046           }
1047
1048         case SCOPE_STMT:
1049           saved = stmts_are_full_exprs_p ();
1050           prep_stmt (t);
1051           genrtl_scope_stmt (t);
1052           current_stmt_tree ()->stmts_are_full_exprs_p = saved;
1053           break;
1054
1055         default:
1056           return t;
1057         }
1058       t = TREE_CHAIN (t);
1059     }
1060   return NULL_TREE;
1061 }