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 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 "tree.h"
  27 #include "function.h"
  28 #include "splay-tree.h"
  29 #include "varray.h"
  30 #include "c-common.h"
  31 #include "except.h"
  32 #include "toplev.h"
  33 #include "flags.h"
  34 #include "ggc.h"
  35 #include "rtl.h"
  36 #include "expr.h"
  37 #include "output.h"
  38 #include "timevar.h"
  39 #include "predict.h"
  40
  41 /* If non-NULL, the address of a language-specific function for
  42    expanding statements.  */
  43 void (*lang_expand_stmt) PARAMS ((tree));
  44
  45 /* If non-NULL, the address of a language-specific function for
  46    expanding a DECL_STMT.  After the language-independent cases are
  47    handled, this function will be called.  If this function is not
  48    defined, it is assumed that declarations other than those for
  49    variables and labels do not require any RTL generation.  */
  50 void (*lang_expand_decl_stmt) PARAMS ((tree));
  51
  52 /* Create an empty statement tree rooted at T.  */
  53
  54 void
  55 begin_stmt_tree (t)
  56      tree *t;
  57 {
  58   /* We create a trivial EXPR_STMT so that last_tree is never NULL in
  59      what follows.  We remove the extraneous statement in
  60      finish_stmt_tree.  */
  61   *t = build_nt (EXPR_STMT, void_zero_node);
  62   last_tree = *t;
  63   last_expr_type = NULL_TREE;
  64   last_expr_filename = input_filename;
  65 }
  66
  67 /* T is a statement.  Add it to the statement-tree.  */
  68
  69 tree
  70 add_stmt (t)
  71      tree t;
  72 {
  73   if (input_filename != last_expr_filename)
  74     {
  75       /* If the filename has changed, also add in a FILE_STMT.  Do a string
  76          compare first, though, as it might be an equivalent string.  */
  77       int add = (strcmp (input_filename, last_expr_filename) != 0);
  78       last_expr_filename = input_filename;
  79       if (add)
  80         {
  81           tree pos = build_nt (FILE_STMT, get_identifier (input_filename));
  82           add_stmt (pos);
  83         }
  84     }
  85
  86   /* Add T to the statement-tree.  */
  87   TREE_CHAIN (last_tree) = t;
  88   last_tree = t;
  89
  90   /* When we expand a statement-tree, we must know whether or not the
  91      statements are full-expressions.  We record that fact here.  */
  92   STMT_IS_FULL_EXPR_P (last_tree) = stmts_are_full_exprs_p ();
  93
  94   /* Keep track of the number of statements in this function.  */
  95   if (current_function_decl)
  96     ++DECL_NUM_STMTS (current_function_decl);
  97
  98   return t;
  99 }
 100
 101 /* Create a declaration statement for the declaration given by the
 102    DECL.  */
 103
 104 void
 105 add_decl_stmt (decl)
 106      tree decl;
 107 {
 108   tree decl_stmt;
 109
 110   /* We need the type to last until instantiation time.  */
 111   decl_stmt = build_stmt (DECL_STMT, decl);
 112   add_stmt (decl_stmt);
 113 }
 114
 115 /* Add a scope-statement to the statement-tree.  BEGIN_P indicates
 116    whether this statements opens or closes a scope.  PARTIAL_P is true
 117    for a partial scope, i.e, the scope that begins after a label when
 118    an object that needs a cleanup is created.  If BEGIN_P is nonzero,
 119    returns a new TREE_LIST representing the top of the SCOPE_STMT
 120    stack.  The TREE_PURPOSE is the new SCOPE_STMT.  If BEGIN_P is
 121    zero, returns a TREE_LIST whose TREE_VALUE is the new SCOPE_STMT,
 122    and whose TREE_PURPOSE is the matching SCOPE_STMT with
 123    SCOPE_BEGIN_P set.  */
 124
 125 tree
 126 add_scope_stmt (begin_p, partial_p)
 127      int begin_p;
 128      int partial_p;
 129 {
 130   tree *stack_ptr = current_scope_stmt_stack ();
 131   tree ss;
 132   tree top = *stack_ptr;
 133
 134   /* Build the statement.  */
 135   ss = build_stmt (SCOPE_STMT, NULL_TREE);
 136   SCOPE_BEGIN_P (ss) = begin_p;
 137   SCOPE_PARTIAL_P (ss) = partial_p;
 138
 139   /* Keep the scope stack up to date.  */
 140   if (begin_p)
 141     {
 142       top = tree_cons (ss, NULL_TREE, top);
 143       *stack_ptr = top;
 144     }
 145   else
 146     {
 147       TREE_VALUE (top) = ss;
 148       *stack_ptr = TREE_CHAIN (top);
 149     }
 150
 151   /* Add the new statement to the statement-tree.  */
 152   add_stmt (ss);
 153
 154   return top;
 155 }
 156
 157 /* Finish the statement tree rooted at T.  */
 158
 159 void
 160 finish_stmt_tree (t)
 161      tree *t;
 162 {
 163   tree stmt;
 164
 165   /* Remove the fake extra statement added in begin_stmt_tree.  */
 166   stmt = TREE_CHAIN (*t);
 167   *t = stmt;
 168   last_tree = NULL_TREE;
 169
 170   if (cfun && stmt)
 171     {
 172       /* The line-number recorded in the outermost statement in a function
 173          is the line number of the end of the function.  */
 174       STMT_LINENO (stmt) = lineno;
 175       STMT_LINENO_FOR_FN_P (stmt) = 1;
 176     }
 177 }
 178
 179 /* Build a generic statement based on the given type of node and
 180    arguments. Similar to `build_nt', except that we set
 181    STMT_LINENO to be the current line number.  */
 182 /* ??? This should be obsolete with the lineno_stmt productions
 183    in the grammar.  */
 184
 185 tree
 186 build_stmt VPARAMS ((enum tree_code code, ...))
 187 {
 188   tree t;
 189   int length;
 190   int i;
 191
 192   VA_OPEN (p, code);
 193   VA_FIXEDARG (p, enum tree_code, code);
 194
 195   t = make_node (code);
 196   length = TREE_CODE_LENGTH (code);
 197   STMT_LINENO (t) = lineno;
 198
 199   for (i = 0; i < length; i++)
 200     TREE_OPERAND (t, i) = va_arg (p, tree);
 201
 202   VA_CLOSE (p);
 203   return t;
 204 }
 205
 206 /* Some statements, like for-statements or if-statements, require a
 207    condition.  This condition can be a declaration.  If T is such a
 208    declaration it is processed, and an expression appropriate to use
 209    as the condition is returned.  Otherwise, T itself is returned.  */
 210
 211 tree
 212 expand_cond (t)
 213      tree t;
 214 {
 215   if (t && TREE_CODE (t) == TREE_LIST)
 216     {
 217       expand_stmt (TREE_PURPOSE (t));
 218       return TREE_VALUE (t);
 219     }
 220   else
 221     return t;
 222 }
 223
 224 /* Create RTL for the local static variable DECL.  */
 225
 226 void
 227 make_rtl_for_local_static (decl)
 228      tree decl;
 229 {
 230   const char *asmspec = NULL;
 231
 232   /* If we inlined this variable, we could see it's declaration
 233      again.  */
 234   if (TREE_ASM_WRITTEN (decl))
 235     return;
 236
 237   /* If the DECL_ASSEMBLER_NAME is not the same as the DECL_NAME, then
 238      either we already created RTL for this DECL (and since it was a
 239      local variable, its DECL_ASSEMBLER_NAME got hacked up to prevent
 240      clashes with other local statics with the same name by a previous
 241      call to make_decl_rtl), or the user explicitly requested a
 242      particular assembly name for this variable, using the GNU
 243      extension for this purpose:
 244
 245        int i asm ("j");
 246
 247      There's no way to know which case we're in, here.  But, it turns
 248      out we're safe.  If there's already RTL, then
 249      rest_of_decl_compilation ignores the ASMSPEC parameter, so we
 250      may as well not pass it in.  If there isn't RTL, then we didn't
 251      already create RTL, which means that the modification to
 252      DECL_ASSEMBLER_NAME came only via the explicit extension.  */
 253   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
 254       && !DECL_RTL_SET_P (decl))
 255     asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 256
 257   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
 258 }
 259
 260 /* Let the back-end know about DECL.  */
 261
 262 void
 263 emit_local_var (decl)
 264      tree decl;
 265 {
 266   /* Create RTL for this variable.  */
 267   if (!DECL_RTL_SET_P (decl))
 268     {
 269       if (DECL_C_HARD_REGISTER (decl))
 270         /* The user specified an assembler name for this variable.
 271            Set that up now.  */
 272         rest_of_decl_compilation
 273           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
 274            /*top_level=*/0, /*at_end=*/0);
 275       else
 276         expand_decl (decl);
 277     }
 278
 279   /* Actually do the initialization.  */
 280   if (stmts_are_full_exprs_p ())
 281     expand_start_target_temps ();
 282
 283   expand_decl_init (decl);
 284
 285   if (stmts_are_full_exprs_p ())
 286     expand_end_target_temps ();
 287 }
 288
 289 /* Helper for generating the RTL at the beginning of a scope.  */
 290
 291 void
 292 genrtl_do_pushlevel ()
 293 {
 294   emit_line_note (input_filename, lineno);
 295   clear_last_expr ();
 296 }
 297
 298 /* Generate the RTL for DESTINATION, which is a GOTO_STMT.  */
 299
 300 void
 301 genrtl_goto_stmt (destination)
 302      tree destination;
 303 {
 304   if (TREE_CODE (destination) == IDENTIFIER_NODE)
 305     abort ();
 306
 307   /* We warn about unused labels with -Wunused.  That means we have to
 308      mark the used labels as used.  */
 309   if (TREE_CODE (destination) == LABEL_DECL)
 310     TREE_USED (destination) = 1;
 311
 312   emit_line_note (input_filename, lineno);
 313
 314   if (TREE_CODE (destination) == LABEL_DECL)
 315     {
 316       label_rtx (destination);
 317       expand_goto (destination);
 318     }
 319   else
 320     expand_computed_goto (destination);
 321 }
 322
 323 /* Generate the RTL for EXPR, which is an EXPR_STMT.  Provided just
 324    for backward compatibility.  genrtl_expr_stmt_value() should be
 325    used for new code.  */
 326
 327 void
 328 genrtl_expr_stmt (expr)
 329      tree expr;
 330 {
 331   genrtl_expr_stmt_value (expr, -1, 1);
 332 }
 333
 334 /* Generate the RTL for EXPR, which is an EXPR_STMT.  WANT_VALUE tells
 335    whether to (1) save the value of the expression, (0) discard it or
 336    (-1) use expr_stmts_for_value to tell.  The use of -1 is
 337    deprecated, and retained only for backward compatibility.
 338    MAYBE_LAST is non-zero if this EXPR_STMT might be the last statement
 339    in expression statement.  */
 340
 341 void
 342 genrtl_expr_stmt_value (expr, want_value, maybe_last)
 343      tree expr;
 344      int want_value, maybe_last;
 345 {
 346   if (expr != NULL_TREE)
 347     {
 348       emit_line_note (input_filename, lineno);
 349
 350       if (stmts_are_full_exprs_p ())
 351         expand_start_target_temps ();
 352
 353       if (expr != error_mark_node)
 354         expand_expr_stmt_value (expr, want_value, maybe_last);
 355
 356       if (stmts_are_full_exprs_p ())
 357         expand_end_target_temps ();
 358     }
 359 }
 360
 361 /* Generate the RTL for T, which is a DECL_STMT.  */
 362
 363 void
 364 genrtl_decl_stmt (t)
 365      tree t;
 366 {
 367   tree decl;
 368   emit_line_note (input_filename, lineno);
 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 (t)
 400      tree t;
 401 {
 402   tree cond;
 403   genrtl_do_pushlevel ();
 404   cond = expand_cond (IF_COND (t));
 405   emit_line_note (input_filename, lineno);
 406   expand_start_cond (cond, 0);
 407   if (THEN_CLAUSE (t))
 408     expand_stmt (THEN_CLAUSE (t));
 409   if (ELSE_CLAUSE (t))
 410     {
 411       expand_start_else ();
 412       expand_stmt (ELSE_CLAUSE (t));
 413     }
 414   expand_end_cond ();
 415 }
 416
 417 /* Generate the RTL for T, which is a WHILE_STMT.  */
 418
 419 void
 420 genrtl_while_stmt (t)
 421      tree t;
 422 {
 423   tree cond;
 424   emit_nop ();
 425   emit_line_note (input_filename, lineno);
 426   expand_start_loop (1);
 427   genrtl_do_pushlevel ();
 428
 429   cond = expand_cond (WHILE_COND (t));
 430   emit_line_note (input_filename, lineno);
 431   expand_exit_loop_top_cond (0, cond);
 432   genrtl_do_pushlevel ();
 433
 434   expand_stmt (WHILE_BODY (t));
 435
 436   expand_end_loop ();
 437 }
 438
 439 /* Generate the RTL for T, which is a DO_STMT.  */
 440
 441 void
 442 genrtl_do_stmt (t)
 443      tree t;
 444 {
 445   tree cond = DO_COND (t);
 446
 447   /* Recognize the common special-case of do { ... } while (0) and do
 448      not emit the loop widgetry in this case.  In particular this
 449      avoids cluttering the rtl with dummy loop notes, which can affect
 450      alignment of adjacent labels.  */
 451   if (integer_zerop (cond))
 452     {
 453       expand_start_null_loop ();
 454       expand_stmt (DO_BODY (t));
 455       expand_end_null_loop ();
 456     }
 457   else
 458     {
 459       emit_nop ();
 460       emit_line_note (input_filename, lineno);
 461       expand_start_loop_continue_elsewhere (1);
 462
 463       expand_stmt (DO_BODY (t));
 464
 465       expand_loop_continue_here ();
 466       cond = expand_cond (cond);
 467       emit_line_note (input_filename, lineno);
 468       expand_exit_loop_if_false (0, cond);
 469       expand_end_loop ();
 470     }
 471 }
 472
 473 /* Build the node for a return statement and return it.  */
 474
 475 tree
 476 build_return_stmt (expr)
 477      tree expr;
 478 {
 479   return (build_stmt (RETURN_STMT, expr));
 480 }
 481
 482 /* Generate the RTL for STMT, which is a RETURN_STMT.  */
 483
 484 void
 485 genrtl_return_stmt (stmt)
 486      tree stmt;
 487 {
 488   tree expr;
 489
 490   expr = RETURN_EXPR (stmt);
 491
 492   emit_line_note (input_filename, lineno);
 493   if (!expr)
 494     expand_null_return ();
 495   else
 496     {
 497       expand_start_target_temps ();
 498       expand_return (expr);
 499       expand_end_target_temps ();
 500     }
 501 }
 502
 503 /* Generate the RTL for T, which is a FOR_STMT.  */
 504
 505 void
 506 genrtl_for_stmt (t)
 507      tree t;
 508 {
 509   tree cond;
 510   const char *saved_filename;
 511   int saved_lineno;
 512
 513   if (NEW_FOR_SCOPE_P (t))
 514     genrtl_do_pushlevel ();
 515
 516   expand_stmt (FOR_INIT_STMT (t));
 517
 518   /* Expand the initialization.  */
 519   emit_nop ();
 520   emit_line_note (input_filename, lineno);
 521   expand_start_loop_continue_elsewhere (1);
 522   genrtl_do_pushlevel ();
 523   cond = expand_cond (FOR_COND (t));
 524
 525   /* Save the filename and line number so that we expand the FOR_EXPR
 526      we can reset them back to the saved values.  */
 527   saved_filename = input_filename;
 528   saved_lineno = lineno;
 529
 530   /* Expand the condition.  */
 531   emit_line_note (input_filename, lineno);
 532   if (cond)
 533     expand_exit_loop_top_cond (0, cond);
 534
 535   /* Expand the body.  */
 536   genrtl_do_pushlevel ();
 537   expand_stmt (FOR_BODY (t));
 538
 539   /* Expand the increment expression.  */
 540   input_filename = saved_filename;
 541   lineno = saved_lineno;
 542   emit_line_note (input_filename, lineno);
 543   expand_loop_continue_here ();
 544   if (FOR_EXPR (t))
 545     genrtl_expr_stmt (FOR_EXPR (t));
 546   expand_end_loop ();
 547 }
 548
 549 /* Build a break statement node and return it.  */
 550
 551 tree
 552 build_break_stmt ()
 553 {
 554   return (build_stmt (BREAK_STMT));
 555 }
 556
 557 /* Generate the RTL for a BREAK_STMT.  */
 558
 559 void
 560 genrtl_break_stmt ()
 561 {
 562   emit_line_note (input_filename, lineno);
 563   if ( ! expand_exit_something ())
 564     error ("break statement not within loop or switch");
 565 }
 566
 567 /* Build a continue statement node and return it.  */
 568
 569 tree
 570 build_continue_stmt ()
 571 {
 572   return (build_stmt (CONTINUE_STMT));
 573 }
 574
 575 /* Generate the RTL for a CONTINUE_STMT.  */
 576
 577 void
 578 genrtl_continue_stmt ()
 579 {
 580   emit_line_note (input_filename, lineno);
 581   if (! expand_continue_loop (0))
 582     error ("continue statement not within a loop");
 583 }
 584
 585 /* Generate the RTL for T, which is a SCOPE_STMT.  */
 586
 587 void
 588 genrtl_scope_stmt (t)
 589      tree t;
 590 {
 591   tree block = SCOPE_STMT_BLOCK (t);
 592
 593   if (!SCOPE_NO_CLEANUPS_P (t))
 594     {
 595       if (SCOPE_BEGIN_P (t))
 596         expand_start_bindings_and_block (2 * SCOPE_NULLIFIED_P (t), block);
 597       else if (SCOPE_END_P (t))
 598         expand_end_bindings (NULL_TREE, !SCOPE_NULLIFIED_P (t), 0);
 599     }
 600   else if (!SCOPE_NULLIFIED_P (t))
 601     {
 602       rtx note = emit_note (NULL,
 603                             (SCOPE_BEGIN_P (t)
 604                              ? NOTE_INSN_BLOCK_BEG
 605                              : NOTE_INSN_BLOCK_END));
 606       NOTE_BLOCK (note) = block;
 607     }
 608
 609   /* If we're at the end of a scope that contains inlined nested
 610      functions, we have to decide whether or not to write them out.  */
 611   if (block && SCOPE_END_P (t))
 612     {
 613       tree fn;
 614
 615       for (fn = BLOCK_VARS (block); fn; fn = TREE_CHAIN (fn))
 616         {
 617           if (TREE_CODE (fn) == FUNCTION_DECL
 618               && DECL_CONTEXT (fn) == current_function_decl
 619               && !TREE_ASM_WRITTEN (fn)
 620               && TREE_ADDRESSABLE (fn))
 621             {
 622               push_function_context ();
 623               output_inline_function (fn);
 624               pop_function_context ();
 625             }
 626         }
 627     }
 628 }
 629
 630 /* Generate the RTL for T, which is a SWITCH_STMT.  */
 631
 632 void
 633 genrtl_switch_stmt (t)
 634      tree t;
 635 {
 636   tree cond;
 637   genrtl_do_pushlevel ();
 638
 639   cond = expand_cond (SWITCH_COND (t));
 640   if (cond == error_mark_node)
 641     /* The code is in error, but we don't want expand_end_case to
 642        crash.  */
 643     cond = boolean_false_node;
 644
 645   emit_line_note (input_filename, lineno);
 646   expand_start_case (1, cond, TREE_TYPE (cond), "switch statement");
 647   expand_stmt (SWITCH_BODY (t));
 648   expand_end_case_type (cond, SWITCH_TYPE (t));
 649 }
 650
 651 /* Create a CASE_LABEL tree node and return it.  */
 652
 653 tree
 654 build_case_label (low_value, high_value, label_decl)
 655      tree low_value;
 656      tree high_value;
 657      tree label_decl;
 658 {
 659   return build_stmt (CASE_LABEL, low_value, high_value, label_decl);
 660 }
 661
 662
 663 /* Generate the RTL for a CASE_LABEL.  */
 664
 665 void
 666 genrtl_case_label (case_label)
 667      tree case_label;
 668 {
 669   tree duplicate;
 670   tree cleanup;
 671
 672   cleanup = last_cleanup_this_contour ();
 673   if (cleanup)
 674     {
 675       static int explained = 0;
 676       warning ("destructor needed for `%#D'", (TREE_PURPOSE (cleanup)));
 677       warning ("where case label appears here");
 678       if (!explained)
 679         {
 680           warning ("(enclose actions of previous case statements requiring destructors in their own scope.)");
 681           explained = 1;
 682         }
 683     }
 684
 685   add_case_node (CASE_LOW (case_label), CASE_HIGH (case_label),
 686                  CASE_LABEL_DECL (case_label), &duplicate);
 687 }
 688
 689 /* Generate the RTL for T, which is a COMPOUND_STMT.  */
 690
 691 void
 692 genrtl_compound_stmt (t)
 693     tree t;
 694 {
 695 #ifdef ENABLE_CHECKING
 696   struct nesting *n = current_nesting_level ();
 697 #endif
 698
 699   expand_stmt (COMPOUND_BODY (t));
 700
 701 #ifdef ENABLE_CHECKING
 702   /* Make sure that we've pushed and popped the same number of levels.  */
 703   if (!COMPOUND_STMT_NO_SCOPE (t) && n != current_nesting_level ())
 704     abort ();
 705 #endif
 706 }
 707
 708 /* Generate the RTL for an ASM_STMT.  */
 709
 710 void
 711 genrtl_asm_stmt (cv_qualifier, string, output_operands,
 712                  input_operands, clobbers, asm_input_p)
 713      tree cv_qualifier;
 714      tree string;
 715      tree output_operands;
 716      tree input_operands;
 717      tree clobbers;
 718      int asm_input_p;
 719 {
 720   if (cv_qualifier != NULL_TREE
 721       && cv_qualifier != ridpointers[(int) RID_VOLATILE])
 722     {
 723       warning ("%s qualifier ignored on asm",
 724                IDENTIFIER_POINTER (cv_qualifier));
 725       cv_qualifier = NULL_TREE;
 726     }
 727
 728   emit_line_note (input_filename, lineno);
 729   if (asm_input_p)
 730     expand_asm (string);
 731   else
 732     c_expand_asm_operands (string, output_operands, input_operands,
 733                            clobbers, cv_qualifier != NULL_TREE,
 734                            input_filename, lineno);
 735 }
 736
 737 /* Generate the RTL for a DECL_CLEANUP.  */
 738
 739 void
 740 genrtl_decl_cleanup (t)
 741      tree t;
 742 {
 743   tree decl = CLEANUP_DECL (t);
 744   if (!decl || (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node))
 745     expand_decl_cleanup_eh (decl, CLEANUP_EXPR (t), CLEANUP_EH_ONLY (t));
 746 }
 747
 748 /* We're about to expand T, a statement.  Set up appropriate context
 749    for the substitution.  */
 750
 751 void
 752 prep_stmt (t)
 753      tree t;
 754 {
 755   if (!STMT_LINENO_FOR_FN_P (t))
 756     lineno = STMT_LINENO (t);
 757   current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
 758 }
 759
 760 /* Generate the RTL for the statement T, its substatements, and any
 761    other statements at its nesting level.  */
 762
 763 void
 764 expand_stmt (t)
 765      tree t;
 766 {
 767   while (t && t != error_mark_node)
 768     {
 769       int saved_stmts_are_full_exprs_p;
 770
 771       /* Set up context appropriately for handling this statement.  */
 772       saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
 773       prep_stmt (t);
 774
 775       switch (TREE_CODE (t))
 776         {
 777         case FILE_STMT:
 778           input_filename = FILE_STMT_FILENAME (t);
 779           break;
 780
 781         case RETURN_STMT:
 782           genrtl_return_stmt (t);
 783           break;
 784
 785         case EXPR_STMT:
 786           genrtl_expr_stmt_value (EXPR_STMT_EXPR (t), TREE_ADDRESSABLE (t),
 787                                   TREE_CHAIN (t) == NULL
 788                                   || (TREE_CODE (TREE_CHAIN (t)) == SCOPE_STMT
 789                                       && TREE_CHAIN (TREE_CHAIN (t)) == NULL));
 790           break;
 791
 792         case DECL_STMT:
 793           genrtl_decl_stmt (t);
 794           break;
 795
 796         case FOR_STMT:
 797           genrtl_for_stmt (t);
 798           break;
 799
 800         case WHILE_STMT:
 801           genrtl_while_stmt (t);
 802           break;
 803
 804         case DO_STMT:
 805           genrtl_do_stmt (t);
 806           break;
 807
 808         case IF_STMT:
 809           genrtl_if_stmt (t);
 810           break;
 811
 812         case COMPOUND_STMT:
 813           genrtl_compound_stmt (t);
 814           break;
 815
 816         case BREAK_STMT:
 817           genrtl_break_stmt ();
 818           break;
 819
 820         case CONTINUE_STMT:
 821           genrtl_continue_stmt ();
 822           break;
 823
 824         case SWITCH_STMT:
 825           genrtl_switch_stmt (t);
 826           break;
 827
 828         case CASE_LABEL:
 829           genrtl_case_label (t);
 830           break;
 831
 832         case LABEL_STMT:
 833           expand_label (LABEL_STMT_LABEL (t));
 834           break;
 835
 836         case GOTO_STMT:
 837           /* Emit information for branch prediction.  */
 838           if (!GOTO_FAKE_P (t)
 839               && TREE_CODE (GOTO_DESTINATION (t)) == LABEL_DECL)
 840             {
 841               rtx note = emit_note (NULL, NOTE_INSN_PREDICTION);
 842
 843               NOTE_PREDICTION (note) = NOTE_PREDICT (PRED_GOTO, NOT_TAKEN);
 844             }
 845           genrtl_goto_stmt (GOTO_DESTINATION (t));
 846           break;
 847
 848         case ASM_STMT:
 849           genrtl_asm_stmt (ASM_CV_QUAL (t), ASM_STRING (t),
 850                            ASM_OUTPUTS (t), ASM_INPUTS (t),
 851                            ASM_CLOBBERS (t), ASM_INPUT_P (t));
 852           break;
 853
 854         case SCOPE_STMT:
 855           genrtl_scope_stmt (t);
 856           break;
 857
 858         case CLEANUP_STMT:
 859           genrtl_decl_cleanup (t);
 860           break;
 861
 862         default:
 863           if (lang_expand_stmt)
 864             (*lang_expand_stmt) (t);
 865           else
 866             abort ();
 867           break;
 868         }
 869
 870       /* Restore saved state.  */
 871       current_stmt_tree ()->stmts_are_full_exprs_p
 872         = saved_stmts_are_full_exprs_p;
 873
 874       /* Go on to the next statement in this scope.  */
 875       t = TREE_CHAIN (t);
 876     }
 877 }