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