contrib/gcc-3.4/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, 2004 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_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
 453 static void
 454 genrtl_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
 494 void
 495 genrtl_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
 502 tree
 503 build_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
 510 void
 511 genrtl_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
 530 void
 531 genrtl_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
 578 tree
 579 build_break_stmt (void)
 580 {
 581   return (build_stmt (BREAK_STMT));
 582 }
 583
 584 /* Generate the RTL for a BREAK_STMT.  */
 585
 586 void
 587 genrtl_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
 596 tree
 597 build_continue_stmt (void)
 598 {
 599   return (build_stmt (CONTINUE_STMT));
 600 }
 601
 602 /* Generate the RTL for a CONTINUE_STMT.  */
 603
 604 void
 605 genrtl_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
 614 void
 615 genrtl_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
 658 void
 659 genrtl_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
 678 tree
 679 build_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
 687 void
 688 genrtl_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
 712 void
 713 genrtl_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
 730 void
 731 genrtl_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
 753 void
 754 genrtl_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
 765 void
 766 prep_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
 776 void
 777 expand_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 \f
 897 /* If *TP is a potentially reachable label, return nonzero.  */
 898
 899 static tree
 900 find_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.  */
 917 static tree
 918 find_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.  */
 929 static bool
 930 expand_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.  */
 978 static tree
 979 expand_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 }