gcc/cp/semantics.c

   1 /* Perform the semantic phase of parsing, i.e., the process of
   2    building tree structure, checking semantic consistency, and
   3    building RTL.  These routines are used both during actual parsing
   4    and during the instantiation of template functions.
   5
   6    Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
   7    Written by Mark Mitchell (mmitchell@usa.net) based on code found
   8    formerly in parse.y and pt.c.
   9
  10    This file is part of GNU CC.
  11
  12    GNU CC is free software; you can redistribute it and/or modify it
  13    under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 2, or (at your option)
  15    any later version.
  16
  17    GNU CC is distributed in the hope that it will be useful, but
  18    WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20    General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with GNU CC; see the file COPYING.  If not, write to the Free
  24    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  25    02111-1307, USA.  */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "tree.h"
  30 #include "cp-tree.h"
  31 #include "except.h"
  32 #include "lex.h"
  33 #include "toplev.h"
  34 #include "flags.h"
  35 #include "ggc.h"
  36 #include "rtl.h"
  37 #include "output.h"
  38
  39 /* There routines provide a modular interface to perform many parsing
  40    operations.  They may therefore be used during actual parsing, or
  41    during template instantiation, which may be regarded as a
  42    degenerate form of parsing.  Since the current g++ parser is
  43    lacking in several respects, and will be reimplemented, we are
  44    attempting to move most code that is not directly related to
  45    parsing into this file; that will make implementing the new parser
  46    much easier since it will be able to make use of these routines.  */
  47
  48 static tree expand_cond PARAMS ((tree));
  49 static tree maybe_convert_cond PARAMS ((tree));
  50 static tree simplify_aggr_init_exprs_r PARAMS ((tree *, int *, void *));
  51 static void deferred_type_access_control PARAMS ((void));
  52
  53 /* Record the fact that STMT was the last statement added to the
  54    statement tree.  */
  55
  56 #define SET_LAST_STMT(stmt) \
  57   (current_stmt_tree->x_last_stmt = (stmt))
  58
  59 /* When parsing a template, LAST_TREE contains the last statement
  60    parsed.  These are chained together through the TREE_CHAIN field,
  61    but often need to be re-organized since the parse is performed
  62    bottom-up.  This macro makes LAST_TREE the indicated SUBSTMT of
  63    STMT.  */
  64
  65 #define RECHAIN_STMTS(stmt, substmt)    \
  66   do {                                  \
  67     substmt = TREE_CHAIN (stmt);        \
  68     TREE_CHAIN (stmt) = NULL_TREE;      \
  69     SET_LAST_STMT (stmt);               \
  70   } while (0)
  71
  72 /* Finish processing the COND, the SUBSTMT condition for STMT.  */
  73
  74 #define FINISH_COND(cond, stmt, substmt)                \
  75   do {                                                  \
  76     if (last_tree != stmt)                              \
  77       {                                                 \
  78         RECHAIN_STMTS (stmt, substmt);                  \
  79         if (!processing_template_decl)                  \
  80           {                                             \
  81             cond = build_tree_list (substmt, cond);     \
  82             substmt = cond;                             \
  83           }                                             \
  84       }                                                 \
  85     else                                                \
  86       substmt = cond;                                   \
  87   } while (0)
  88
  89 /* T is a statement.  Add it to the statement-tree.  */
  90
  91 void
  92 add_tree (t)
  93      tree t;
  94 {
  95   /* Add T to the statement-tree.  */
  96   TREE_CHAIN (last_tree) = t;
  97   SET_LAST_STMT (t);
  98
  99   /* When we expand a statement-tree, we must know whether or not the
 100      statements are full-expresions.  We record that fact here.  */
 101   if (building_stmt_tree ())
 102     STMT_IS_FULL_EXPR_P (last_tree) = stmts_are_full_exprs_p;
 103 }
 104
 105 /* COND is the condition-expression for an if, while, etc.,
 106    statement.  Convert it to a boolean value, if appropriate.  */
 107
 108 static tree
 109 maybe_convert_cond (cond)
 110      tree cond;
 111 {
 112   /* Empty conditions remain empty.  */
 113   if (!cond)
 114     return NULL_TREE;
 115
 116   /* Wait until we instantiate templates before doing conversion.  */
 117   if (processing_template_decl)
 118     return cond;
 119
 120   /* Do the conversion.  */
 121   cond = convert_from_reference (cond);
 122   return condition_conversion (cond);
 123 }
 124
 125 /* Finish an expression-statement, whose EXPRESSION is as indicated.  */
 126
 127 void
 128 finish_expr_stmt (expr)
 129      tree expr;
 130 {
 131   if (expr != NULL_TREE)
 132     {
 133       if (building_stmt_tree ())
 134         {
 135           /* Do default conversion if safe and possibly important,
 136              in case within ({...}).  */
 137           if (!processing_template_decl
 138               && !stmts_are_full_exprs_p
 139               && ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
 140                    && lvalue_p (expr))
 141                   || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE))
 142             expr = default_conversion (expr);
 143
 144           if (stmts_are_full_exprs_p)
 145             expr = convert_to_void (expr, "statement");
 146
 147           if (!processing_template_decl)
 148             expr = break_out_cleanups (expr);
 149
 150           add_tree (build_min_nt (EXPR_STMT, expr));
 151         }
 152       else
 153         {
 154           emit_line_note (input_filename, lineno);
 155
 156           if (stmts_are_full_exprs_p)
 157             expand_start_target_temps ();
 158
 159           cplus_expand_expr_stmt (expr);
 160
 161           if (stmts_are_full_exprs_p)
 162             expand_end_target_temps ();
 163         }
 164     }
 165
 166   finish_stmt ();
 167
 168   /* This was an expression-statement, so we save the type of the
 169      expression.  */
 170   last_expr_type = expr ? TREE_TYPE (expr) : NULL_TREE;
 171 }
 172
 173 /* Begin an if-statement.  Returns a newly created IF_STMT if
 174    appropriate.  */
 175
 176 tree
 177 begin_if_stmt ()
 178 {
 179   tree r;
 180
 181   do_pushlevel ();
 182
 183   if (building_stmt_tree ())
 184     {
 185       r = build_min_nt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
 186       add_tree (r);
 187     }
 188   else
 189     r = NULL_TREE;
 190
 191   return r;
 192 }
 193
 194 /* Process the COND of an if-statement, which may be given by
 195    IF_STMT.  */
 196
 197 void
 198 finish_if_stmt_cond (cond, if_stmt)
 199      tree cond;
 200      tree if_stmt;
 201 {
 202   cond = maybe_convert_cond (cond);
 203
 204   if (building_stmt_tree ())
 205     FINISH_COND (cond, if_stmt, IF_COND (if_stmt));
 206   else
 207     {
 208       emit_line_note (input_filename, lineno);
 209       expand_start_cond (cond, 0);
 210     }
 211 }
 212
 213 /* Finish the then-clause of an if-statement, which may be given by
 214    IF_STMT.  */
 215
 216 tree
 217 finish_then_clause (if_stmt)
 218      tree if_stmt;
 219 {
 220   if (building_stmt_tree ())
 221     {
 222       RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
 223       SET_LAST_STMT (if_stmt);
 224       return if_stmt;
 225     }
 226   else
 227     return NULL_TREE;
 228 }
 229
 230 /* Begin the else-clause of an if-statement.  */
 231
 232 void
 233 begin_else_clause ()
 234 {
 235   if (!building_stmt_tree ())
 236     expand_start_else ();
 237 }
 238
 239 /* Finish the else-clause of an if-statement, which may be given by
 240    IF_STMT.  */
 241
 242 void
 243 finish_else_clause (if_stmt)
 244      tree if_stmt;
 245 {
 246   if (building_stmt_tree ())
 247     RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
 248 }
 249
 250 /* Finsh an if-statement.  */
 251
 252 void
 253 finish_if_stmt ()
 254 {
 255   if (!building_stmt_tree ())
 256     expand_end_cond ();
 257
 258   do_poplevel ();
 259   finish_stmt ();
 260 }
 261
 262 /* Begin a while-statement.  Returns a newly created WHILE_STMT if
 263    appropriate.  */
 264
 265 tree
 266 begin_while_stmt ()
 267 {
 268   tree r;
 269
 270   if (building_stmt_tree ())
 271     {
 272       r = build_min_nt (WHILE_STMT, NULL_TREE, NULL_TREE);
 273       add_tree (r);
 274     }
 275   else
 276     {
 277       emit_nop ();
 278       emit_line_note (input_filename, lineno);
 279       expand_start_loop (1);
 280       r = NULL_TREE;
 281     }
 282
 283   do_pushlevel ();
 284
 285   return r;
 286 }
 287
 288 /* Process the COND of a while-statement, which may be given by
 289    WHILE_STMT.  */
 290
 291 void
 292 finish_while_stmt_cond (cond, while_stmt)
 293      tree cond;
 294      tree while_stmt;
 295 {
 296   cond = maybe_convert_cond (cond);
 297
 298   if (building_stmt_tree ())
 299     FINISH_COND (cond, while_stmt, WHILE_COND (while_stmt));
 300   else
 301     {
 302       emit_line_note (input_filename, lineno);
 303       expand_exit_loop_if_false (0, cond);
 304     }
 305
 306   /* If COND wasn't a declaration, clear out the
 307      block we made for it and start a new one here so the
 308      optimization in expand_end_loop will work.  */
 309   if (getdecls () == NULL_TREE)
 310     {
 311       do_poplevel ();
 312       do_pushlevel ();
 313     }
 314 }
 315
 316 /* Finish a while-statement, which may be given by WHILE_STMT.  */
 317
 318 void
 319 finish_while_stmt (while_stmt)
 320      tree while_stmt;
 321 {
 322   do_poplevel ();
 323
 324   if (building_stmt_tree ())
 325     RECHAIN_STMTS (while_stmt, WHILE_BODY (while_stmt));
 326   else
 327     expand_end_loop ();
 328   finish_stmt ();
 329 }
 330
 331 /* Begin a do-statement.  Returns a newly created DO_STMT if
 332    appropriate.  */
 333
 334 tree
 335 begin_do_stmt ()
 336 {
 337   if (building_stmt_tree ())
 338     {
 339       tree r = build_min_nt (DO_STMT, NULL_TREE, NULL_TREE);
 340       add_tree (r);
 341       return r;
 342     }
 343   else
 344     {
 345       emit_nop ();
 346       emit_line_note (input_filename, lineno);
 347       expand_start_loop_continue_elsewhere (1);
 348       return NULL_TREE;
 349     }
 350 }
 351
 352 /* Finish the body of a do-statement, which may be given by DO_STMT.  */
 353
 354 void
 355 finish_do_body (do_stmt)
 356      tree do_stmt;
 357 {
 358   if (building_stmt_tree ())
 359     RECHAIN_STMTS (do_stmt, DO_BODY (do_stmt));
 360   else
 361     expand_loop_continue_here ();
 362 }
 363
 364 /* Finish a do-statement, which may be given by DO_STMT, and whose
 365    COND is as indicated.  */
 366
 367 void
 368 finish_do_stmt (cond, do_stmt)
 369      tree cond;
 370      tree do_stmt;
 371 {
 372   cond = maybe_convert_cond (cond);
 373
 374   if (building_stmt_tree ())
 375     DO_COND (do_stmt) = cond;
 376   else
 377     {
 378       emit_line_note (input_filename, lineno);
 379       expand_exit_loop_if_false (0, cond);
 380       expand_end_loop ();
 381     }
 382
 383   finish_stmt ();
 384 }
 385
 386 /* Finish a return-statement.  The EXPRESSION returned, if any, is as
 387    indicated.  */
 388
 389 void
 390 finish_return_stmt (expr)
 391      tree expr;
 392 {
 393   if (doing_semantic_analysis_p () && !processing_template_decl)
 394     expr = check_return_expr (expr);
 395
 396   if (doing_semantic_analysis_p () && !processing_template_decl)
 397     {
 398       if (DECL_CONSTRUCTOR_P (current_function_decl) && ctor_label)
 399         {
 400           /* Even returns without a value in a constructor must return
 401              `this'.  We accomplish this by sending all returns in a
 402              constructor to the CTOR_LABEL; finish_function emits code to
 403              return a value there.  When we finally generate the real
 404              return statement, CTOR_LABEL is no longer set, and we fall
 405              through into the normal return-processing code below.  */
 406           finish_goto_stmt (ctor_label);
 407           return;
 408         }
 409       else if (DECL_DESTRUCTOR_P (current_function_decl))
 410         {
 411           /* Similarly, all destructors must run destructors for
 412              base-classes before returning.  So, all returns in a
 413              destructor get sent to the DTOR_LABEL; finsh_function emits
 414              code to return a value there.  */
 415           finish_goto_stmt (dtor_label);
 416           return;
 417         }
 418     }
 419
 420   if (building_stmt_tree ())
 421     add_tree (build_min_nt (RETURN_STMT, expr));
 422   else
 423     {
 424       emit_line_note (input_filename, lineno);
 425       c_expand_return (expr);
 426     }
 427
 428   finish_stmt ();
 429 }
 430
 431 /* Begin a for-statement.  Returns a new FOR_STMT if appropriate.  */
 432
 433 tree
 434 begin_for_stmt ()
 435 {
 436   tree r;
 437
 438   if (building_stmt_tree ())
 439     {
 440       r = build_min_nt (FOR_STMT, NULL_TREE, NULL_TREE,
 441                         NULL_TREE, NULL_TREE);
 442       add_tree (r);
 443     }
 444   else
 445     r = NULL_TREE;
 446
 447   if (flag_new_for_scope > 0)
 448     {
 449       do_pushlevel ();
 450       note_level_for_for ();
 451     }
 452
 453   return r;
 454 }
 455
 456 /* Finish the for-init-statement of a for-statement, which may be
 457    given by FOR_STMT.  */
 458
 459 void
 460 finish_for_init_stmt (for_stmt)
 461      tree for_stmt;
 462 {
 463   if (building_stmt_tree ())
 464     {
 465       if (last_tree != for_stmt)
 466         RECHAIN_STMTS (for_stmt, FOR_INIT_STMT (for_stmt));
 467     }
 468   else
 469     {
 470       emit_nop ();
 471       emit_line_note (input_filename, lineno);
 472       expand_start_loop_continue_elsewhere (1);
 473     }
 474
 475   do_pushlevel ();
 476 }
 477
 478 /* Finish the COND of a for-statement, which may be given by
 479    FOR_STMT.  */
 480
 481 void
 482 finish_for_cond (cond, for_stmt)
 483      tree cond;
 484      tree for_stmt;
 485 {
 486   cond = maybe_convert_cond (cond);
 487
 488   if (building_stmt_tree ())
 489     FINISH_COND (cond, for_stmt, FOR_COND (for_stmt));
 490   else
 491     {
 492       emit_line_note (input_filename, lineno);
 493       if (cond)
 494         expand_exit_loop_if_false (0, cond);
 495     }
 496
 497   /* If the cond wasn't a declaration, clear out the
 498      block we made for it and start a new one here so the
 499      optimization in expand_end_loop will work.  */
 500   if (getdecls () == NULL_TREE)
 501     {
 502       do_poplevel ();
 503       do_pushlevel ();
 504     }
 505 }
 506
 507 /* Finish the increment-EXPRESSION in a for-statement, which may be
 508    given by FOR_STMT.  */
 509
 510 void
 511 finish_for_expr (expr, for_stmt)
 512      tree expr;
 513      tree for_stmt;
 514 {
 515   if (building_stmt_tree ())
 516     FOR_EXPR (for_stmt) = expr;
 517 }
 518
 519 /* Finish the body of a for-statement, which may be given by
 520    FOR_STMT.  The increment-EXPR for the loop must be
 521    provided.  */
 522
 523 void
 524 finish_for_stmt (expr, for_stmt)
 525      tree expr;
 526      tree for_stmt;
 527 {
 528   /* Pop the scope for the body of the loop.  */
 529   do_poplevel ();
 530
 531   if (building_stmt_tree ())
 532     RECHAIN_STMTS (for_stmt, FOR_BODY (for_stmt));
 533   else
 534     {
 535       emit_line_note (input_filename, lineno);
 536       expand_loop_continue_here ();
 537       if (expr)
 538         finish_expr_stmt (expr);
 539       expand_end_loop ();
 540     }
 541
 542   if (flag_new_for_scope > 0)
 543     do_poplevel ();
 544
 545   finish_stmt ();
 546 }
 547
 548 /* Finish a break-statement.  */
 549
 550 void
 551 finish_break_stmt ()
 552 {
 553   emit_line_note (input_filename, lineno);
 554   if (building_stmt_tree ())
 555     add_tree (build_min_nt (BREAK_STMT));
 556   else if ( ! expand_exit_something ())
 557     cp_error ("break statement not within loop or switch");
 558 }
 559
 560 /* Finish a continue-statement.  */
 561
 562 void
 563 finish_continue_stmt ()
 564 {
 565   emit_line_note (input_filename, lineno);
 566   if (building_stmt_tree ())
 567     add_tree (build_min_nt (CONTINUE_STMT));
 568   else if (! expand_continue_loop (0))
 569     cp_error ("continue statement not within a loop");
 570 }
 571
 572 /* Begin a switch-statement.  Returns a new SWITCH_STMT if
 573    appropriate.  */
 574
 575 tree
 576 begin_switch_stmt ()
 577 {
 578   tree r;
 579
 580   if (building_stmt_tree ())
 581     {
 582       r = build_min_nt (SWITCH_STMT, NULL_TREE, NULL_TREE);
 583       add_tree (r);
 584     }
 585   else
 586     r = NULL_TREE;
 587
 588   do_pushlevel ();
 589
 590   return r;
 591 }
 592
 593 /* Finish the cond of a switch-statement.  */
 594
 595 void
 596 finish_switch_cond (cond, switch_stmt)
 597      tree cond;
 598      tree switch_stmt;
 599 {
 600   if (building_stmt_tree ())
 601     {
 602       if (!processing_template_decl)
 603         {
 604           /* Convert the condition to an integer or enumeration type.  */
 605           cond = build_expr_type_conversion (WANT_INT | WANT_ENUM, cond, 1);
 606           if (cond == NULL_TREE)
 607             {
 608               error ("switch quantity not an integer");
 609               cond = error_mark_node;
 610             }
 611           if (cond != error_mark_node)
 612             {
 613               tree idx;
 614               tree type;
 615
 616               cond = default_conversion (cond);
 617               type = TREE_TYPE (cond);
 618               idx = get_unwidened (cond, 0);
 619               /* We can't strip a conversion from a signed type to an unsigned,
 620                  because if we did, int_fits_type_p would do the wrong thing
 621                  when checking case values for being in range,
 622                  and it's too hard to do the right thing.  */
 623               if (TREE_UNSIGNED (TREE_TYPE (cond))
 624                   == TREE_UNSIGNED (TREE_TYPE (idx)))
 625                 cond = idx;
 626
 627               cond = fold (build1 (CLEANUP_POINT_EXPR, type, cond));
 628             }
 629         }
 630       FINISH_COND (cond, switch_stmt, SWITCH_COND (switch_stmt));
 631     }
 632   else if (cond != error_mark_node)
 633     {
 634       emit_line_note (input_filename, lineno);
 635       c_expand_start_case (cond);
 636     }
 637   else
 638     /* The code is in error, but we don't want expand_end_case to
 639        crash. */
 640     c_expand_start_case (boolean_false_node);
 641
 642   push_switch ();
 643 }
 644
 645 /* Finish the body of a switch-statement, which may be given by
 646    SWITCH_STMT.  The COND to switch on is indicated.  */
 647
 648 void
 649 finish_switch_stmt (cond, switch_stmt)
 650      tree cond;
 651      tree switch_stmt;
 652 {
 653   if (building_stmt_tree ())
 654     RECHAIN_STMTS (switch_stmt, SWITCH_BODY (switch_stmt));
 655   else
 656     expand_end_case (cond);
 657   pop_switch ();
 658   do_poplevel ();
 659   finish_stmt ();
 660 }
 661
 662 /* Finish a case-label.  */
 663
 664 void
 665 finish_case_label (low_value, high_value)
 666      tree low_value;
 667      tree high_value;
 668 {
 669   if (building_stmt_tree ())
 670     {
 671       /* Add a representation for the case label to the statement
 672          tree.  */
 673       add_tree (build_min_nt (CASE_LABEL, low_value, high_value));
 674       /* And warn about crossing initializations, etc.  */
 675       if (!processing_template_decl)
 676         define_case_label ();
 677       return;
 678     }
 679
 680   do_case (low_value, high_value);
 681 }
 682
 683 /* Finish a goto-statement.  */
 684
 685 void
 686 finish_goto_stmt (destination)
 687      tree destination;
 688 {
 689   if (TREE_CODE (destination) == IDENTIFIER_NODE)
 690     destination = lookup_label (destination);
 691
 692   /* We warn about unused labels with -Wunused.  That means we have to
 693      mark the used labels as used.  */
 694   if (TREE_CODE (destination) == LABEL_DECL)
 695     TREE_USED (destination) = 1;
 696
 697   if (building_stmt_tree ())
 698     {
 699       if (TREE_CODE (destination) != LABEL_DECL)
 700         /* We don't inline calls to functions with computed gotos.
 701            Those functions are typically up to some funny business,
 702            and may be depending on the labels being at particular
 703            addresses, or some such.  */
 704         DECL_UNINLINABLE (current_function_decl) = 1;
 705
 706       add_tree (build_min_nt (GOTO_STMT, destination));
 707     }
 708   else
 709     {
 710       emit_line_note (input_filename, lineno);
 711
 712       if (TREE_CODE (destination) == LABEL_DECL)
 713         {
 714           label_rtx (destination);
 715           expand_goto (destination);
 716         }
 717       else
 718         expand_computed_goto (destination);
 719     }
 720 }
 721
 722 /* Begin a try-block.  Returns a newly-created TRY_BLOCK if
 723    appropriate.  */
 724
 725 tree
 726 begin_try_block ()
 727 {
 728   if (building_stmt_tree ())
 729     {
 730       tree r = build_min_nt (TRY_BLOCK, NULL_TREE,
 731                              NULL_TREE);
 732       add_tree (r);
 733       return r;
 734     }
 735   else
 736     {
 737       emit_line_note (input_filename, lineno);
 738       expand_start_try_stmts ();
 739       return NULL_TREE;
 740     }
 741 }
 742
 743 /* Likewise, for a function-try-block.  */
 744
 745 tree
 746 begin_function_try_block ()
 747 {
 748   if (building_stmt_tree ())
 749     {
 750       tree r = build_min_nt (TRY_BLOCK, NULL_TREE,
 751                              NULL_TREE);
 752       FN_TRY_BLOCK_P (r) = 1;
 753       add_tree (r);
 754       return r;
 755     }
 756   else
 757     {
 758       if (! current_function_parms_stored)
 759         store_parm_decls ();
 760       expand_start_early_try_stmts ();
 761       return NULL_TREE;
 762     }
 763 }
 764
 765 /* Finish a try-block, which may be given by TRY_BLOCK.  */
 766
 767 void
 768 finish_try_block (try_block)
 769      tree try_block;
 770 {
 771   if (building_stmt_tree ())
 772     RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
 773   else
 774     expand_start_all_catch ();
 775 }
 776
 777 /* Finish the body of a cleanup try-block, which may be given by
 778    TRY_BLOCK.  */
 779
 780 void
 781 finish_cleanup_try_block (try_block)
 782      tree try_block;
 783 {
 784   if (building_stmt_tree ())
 785     RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
 786 }
 787
 788 /* Finish an implicitly generated try-block, with a cleanup is given
 789    by CLEANUP.  */
 790
 791 void
 792 finish_cleanup (cleanup, try_block)
 793      tree cleanup;
 794      tree try_block;
 795 {
 796   if (building_stmt_tree ())
 797     {
 798       TRY_HANDLERS (try_block) = cleanup;
 799       CLEANUP_P (try_block) = 1;
 800     }
 801   else
 802     expand_eh_region_end (protect_with_terminate (cleanup));
 803 }
 804
 805 /* Likewise, for a function-try-block.  */
 806
 807 void
 808 finish_function_try_block (try_block)
 809      tree try_block;
 810 {
 811   if (building_stmt_tree ())
 812     {
 813       if (TREE_CHAIN (try_block)
 814           && TREE_CODE (TREE_CHAIN (try_block)) == CTOR_INITIALIZER)
 815         {
 816           /* Chain the compound statement after the CTOR_INITIALIZER.  */
 817           TREE_CHAIN (TREE_CHAIN (try_block)) = last_tree;
 818           /* And make the CTOR_INITIALIZER the body of the try-block.  */
 819           RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
 820         }
 821       else
 822         RECHAIN_STMTS (try_block, TRY_STMTS (try_block));
 823     }
 824   else
 825     {
 826       end_protect_partials ();
 827       expand_start_all_catch ();
 828     }
 829
 830   in_function_try_handler = 1;
 831 }
 832
 833 /* Finish a handler-sequence for a try-block, which may be given by
 834    TRY_BLOCK.  */
 835
 836 void
 837 finish_handler_sequence (try_block)
 838      tree try_block;
 839 {
 840   if (building_stmt_tree ())
 841     {
 842       RECHAIN_STMTS (try_block, TRY_HANDLERS (try_block));
 843       check_handlers (TRY_HANDLERS (try_block));
 844     }
 845   else
 846     expand_end_all_catch ();
 847 }
 848
 849 /* Likewise, for a function-try-block.  */
 850
 851 void
 852 finish_function_handler_sequence (try_block)
 853      tree try_block;
 854 {
 855   in_function_try_handler = 0;
 856
 857   if (building_stmt_tree ())
 858     {
 859       RECHAIN_STMTS (try_block, TRY_HANDLERS (try_block));
 860       check_handlers (TRY_HANDLERS (try_block));
 861     }
 862   else
 863     expand_end_all_catch ();
 864 }
 865
 866 /* Begin a handler.  Returns a HANDLER if appropriate.  */
 867
 868 tree
 869 begin_handler ()
 870 {
 871   tree r;
 872
 873   if (building_stmt_tree ())
 874     {
 875       r = build_min_nt (HANDLER, NULL_TREE, NULL_TREE);
 876       add_tree (r);
 877     }
 878   else
 879     r = NULL_TREE;
 880
 881   do_pushlevel ();
 882
 883   return r;
 884 }
 885
 886 /* Finish the handler-parameters for a handler, which may be given by
 887    HANDLER.  DECL is the declaration for the catch parameter, or NULL
 888    if this is a `catch (...)' clause.  */
 889
 890 tree
 891 finish_handler_parms (decl, handler)
 892      tree decl;
 893      tree handler;
 894 {
 895   tree blocks = NULL_TREE;
 896
 897   if (processing_template_decl)
 898     {
 899       if (decl)
 900         {
 901           decl = pushdecl (decl);
 902           decl = push_template_decl (decl);
 903           add_decl_stmt (decl);
 904           RECHAIN_STMTS (handler, HANDLER_PARMS (handler));
 905         }
 906     }
 907   else if (building_stmt_tree ())
 908     blocks = expand_start_catch_block (decl);
 909
 910   if (decl)
 911     TREE_TYPE (handler) = TREE_TYPE (decl);
 912
 913   return blocks;
 914 }
 915
 916 /* Note the beginning of a handler for TYPE.  This function is called
 917    at the point to which control should be transferred when an
 918    appropriately-typed exception is thrown.  */
 919
 920 void
 921 begin_catch_block (type)
 922      tree type;
 923 {
 924   if (building_stmt_tree ())
 925     add_tree (build (START_CATCH_STMT, type));
 926   else
 927     start_catch_handler (type);
 928 }
 929
 930 /* Finish a handler, which may be given by HANDLER.  The BLOCKs are
 931    the return value from the matching call to finish_handler_parms.  */
 932
 933 void
 934 finish_handler (blocks, handler)
 935      tree blocks;
 936      tree handler;
 937 {
 938   if (!processing_template_decl)
 939     {
 940       if (building_stmt_tree ())
 941         expand_end_catch_block (blocks);
 942
 943       if (!building_stmt_tree ())
 944         {
 945           /* Fall to outside the try statement when done executing
 946              handler and we fall off end of handler.  This is jump
 947              Lresume in the documentation.  */
 948           expand_goto (top_label_entry (&caught_return_label_stack));
 949           end_catch_handler ();
 950         }
 951     }
 952
 953   do_poplevel ();
 954
 955   if (building_stmt_tree ())
 956     RECHAIN_STMTS (handler, HANDLER_BODY (handler));
 957 }
 958
 959 /* Begin a compound-statement.  If HAS_NO_SCOPE is non-zero, the
 960    compound-statement does not define a scope.  Returns a new
 961    COMPOUND_STMT if appropriate.  */
 962
 963 tree
 964 begin_compound_stmt (has_no_scope)
 965      int has_no_scope;
 966 {
 967   tree r;
 968
 969   if (building_stmt_tree ())
 970     {
 971       r = build_min_nt (COMPOUND_STMT, NULL_TREE);
 972       add_tree (r);
 973       if (has_no_scope)
 974         COMPOUND_STMT_NO_SCOPE (r) = 1;
 975     }
 976   else
 977     r = NULL_TREE;
 978
 979   last_expr_type = NULL_TREE;
 980
 981   if (!has_no_scope)
 982     do_pushlevel ();
 983   else
 984     /* Normally, we try hard to keep the BLOCK for a
 985        statement-expression.  But, if it's a statement-expression with
 986        a scopeless block, there's nothing to keep, and we don't want
 987        to accidentally keep a block *inside* the scopeless block.  */
 988     keep_next_level (0);
 989
 990   /* If this is the outermost block of the function, declare the
 991      variables __FUNCTION__, __PRETTY_FUNCTION__, and so forth.  */
 992   if (cfun
 993       && !current_function_name_declared
 994       && !has_no_scope)
 995     {
 996       current_function_name_declared = 1;
 997       declare_function_name ();
 998     }
 999
1000   return r;
1001 }
1002
1003
1004 /* Finish a compound-statement, which may be given by COMPOUND_STMT.
1005    If HAS_NO_SCOPE is non-zero, the compound statement does not define
1006    a scope.  */
1007
1008 tree
1009 finish_compound_stmt (has_no_scope, compound_stmt)
1010      int has_no_scope;
1011      tree compound_stmt;
1012 {
1013   tree r;
1014   tree t;
1015
1016   if (!has_no_scope)
1017     r = do_poplevel ();
1018   else
1019     r = NULL_TREE;
1020
1021   if (building_stmt_tree ())
1022     RECHAIN_STMTS (compound_stmt, COMPOUND_BODY (compound_stmt));
1023
1024   /* When we call finish_stmt we will lose LAST_EXPR_TYPE.  But, since
1025      the precise purpose of that variable is store the type of the
1026      last expression statement within the last compound statement, we
1027      preserve the value.  */
1028   t = last_expr_type;
1029   finish_stmt ();
1030   last_expr_type = t;
1031
1032   return r;
1033 }
1034
1035 /* Finish an asm-statement, whose components are a CV_QUALIFIER, a
1036    STRING, some OUTPUT_OPERANDS, some INPUT_OPERANDS, and some
1037    CLOBBERS.  */
1038
1039 void
1040 finish_asm_stmt (cv_qualifier, string, output_operands,
1041                  input_operands, clobbers)
1042      tree cv_qualifier;
1043      tree string;
1044      tree output_operands;
1045      tree input_operands;
1046      tree clobbers;
1047 {
1048   if (TREE_CHAIN (string))
1049     string = combine_strings (string);
1050
1051   if (cv_qualifier != NULL_TREE
1052       && cv_qualifier != ridpointers[(int) RID_VOLATILE])
1053     {
1054       cp_warning ("%s qualifier ignored on asm",
1055                   IDENTIFIER_POINTER (cv_qualifier));
1056       cv_qualifier = NULL_TREE;
1057     }
1058
1059   if (building_stmt_tree ())
1060     {
1061       tree r = build_min_nt (ASM_STMT, cv_qualifier, string,
1062                              output_operands, input_operands,
1063                              clobbers);
1064       add_tree (r);
1065     }
1066   else
1067     {
1068       emit_line_note (input_filename, lineno);
1069       if (output_operands != NULL_TREE || input_operands != NULL_TREE
1070             || clobbers != NULL_TREE)
1071         {
1072           tree t;
1073
1074           for (t = input_operands; t; t = TREE_CHAIN (t))
1075             TREE_VALUE (t) = decay_conversion (TREE_VALUE (t));
1076
1077           c_expand_asm_operands (string, output_operands,
1078                                  input_operands,
1079                                  clobbers,
1080                                  cv_qualifier != NULL_TREE,
1081                                  input_filename, lineno);
1082         }
1083       else
1084         expand_asm (string);
1085
1086       finish_stmt ();
1087     }
1088 }
1089
1090 /* Finish a label with the indicated NAME.  */
1091
1092 void
1093 finish_label_stmt (name)
1094      tree name;
1095 {
1096   tree decl = define_label (input_filename, lineno, name);
1097
1098   if (building_stmt_tree ())
1099     add_tree (build_min_nt (LABEL_STMT, decl));
1100   else if (decl)
1101     expand_label (decl);
1102 }
1103
1104 /* Finish a series of declarations for local labels.  G++ allows users
1105    to declare "local" labels, i.e., labels with scope.  This extension
1106    is useful when writing code involving statement-expressions.  */
1107
1108 void
1109 finish_label_decl (name)
1110      tree name;
1111 {
1112   tree decl = declare_local_label (name);
1113   if (building_stmt_tree ())
1114     add_decl_stmt (decl);
1115 }
1116
1117 /* Create a declaration statement for the declaration given by the
1118    DECL.  */
1119
1120 void
1121 add_decl_stmt (decl)
1122      tree decl;
1123 {
1124   tree decl_stmt;
1125
1126   /* We need the type to last until instantiation time.  */
1127   decl_stmt = build_min_nt (DECL_STMT, decl);
1128   add_tree (decl_stmt);
1129 }
1130
1131 /* We're in a constructor, and have just constructed a a subobject of
1132    *THIS.  CLEANUP is code to run if an exception is thrown before the
1133    end of the current function is reached.   */
1134
1135 void
1136 finish_subobject (cleanup)
1137      tree cleanup;
1138 {
1139   if (building_stmt_tree ())
1140     {
1141       tree r = build_min_nt (SUBOBJECT, cleanup);
1142       add_tree (r);
1143     }
1144   else
1145     add_partial_entry (cleanup);
1146 }
1147
1148 /* When DECL goes out of scope, make sure that CLEANUP is executed.  */
1149
1150 void
1151 finish_decl_cleanup (decl, cleanup)
1152      tree decl;
1153      tree cleanup;
1154 {
1155   if (building_stmt_tree ())
1156     add_tree (build_min_nt (CLEANUP_STMT, decl, cleanup));
1157   else if (!decl
1158            || (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node))
1159     expand_decl_cleanup (decl, cleanup);
1160 }
1161
1162 /* Bind a name and initialization to the return value of
1163    the current function.  */
1164
1165 void
1166 finish_named_return_value (return_id, init)
1167      tree return_id, init;
1168 {
1169   tree decl = DECL_RESULT (current_function_decl);
1170
1171   if (pedantic)
1172     /* Give this error as many times as there are occurrences,
1173        so that users can use Emacs compilation buffers to find
1174        and fix all such places.  */
1175     pedwarn ("ISO C++ does not permit named return values");
1176
1177   if (return_id != NULL_TREE)
1178     {
1179       if (DECL_NAME (decl) == NULL_TREE)
1180         {
1181           DECL_NAME (decl) = return_id;
1182           DECL_ASSEMBLER_NAME (decl) = return_id;
1183         }
1184       else
1185         {
1186           cp_error ("return identifier `%D' already in place", return_id);
1187           return;
1188         }
1189     }
1190
1191   /* Can't let this happen for constructors.  */
1192   if (DECL_CONSTRUCTOR_P (current_function_decl))
1193     {
1194       error ("can't redefine default return value for constructors");
1195       return;
1196     }
1197
1198   /* If we have a named return value, put that in our scope as well.  */
1199   if (DECL_NAME (decl) != NULL_TREE)
1200     {
1201       /* Let `cp_finish_decl' know that this initializer is ok.  */
1202       DECL_INITIAL (decl) = init;
1203       if (doing_semantic_analysis_p ())
1204         pushdecl (decl);
1205
1206       if (building_stmt_tree ())
1207         add_tree (build_min_nt (RETURN_INIT, return_id, init));
1208       else
1209         {
1210           cp_finish_decl (decl, init, NULL_TREE, 0);
1211           store_return_init (decl);
1212         }
1213     }
1214
1215   /* Don't use tree-inlining for functions with named return values.
1216      That doesn't work properly because we don't do any translation of
1217      the RETURN_INITs when they are copied.  */
1218   DECL_UNINLINABLE (current_function_decl) = 1;
1219 }
1220
1221 /* Cache the value of this class's main virtual function table pointer
1222    in a register variable.  This will save one indirection if a
1223    more than one virtual function call is made this function.  */
1224
1225 void
1226 setup_vtbl_ptr ()
1227 {
1228   my_friendly_assert (doing_semantic_analysis_p (), 19990919);
1229
1230   /* If we've already done this, there's no need to do it again.  */
1231   if (vtbls_set_up_p)
1232     return;
1233
1234   if (DECL_CONSTRUCTOR_P (current_function_decl))
1235     {
1236       if (processing_template_decl)
1237         add_tree (build_min_nt
1238                   (CTOR_INITIALIZER,
1239                    current_member_init_list, current_base_init_list));
1240       else
1241         {
1242           tree ctor_stmt;
1243
1244           /* Mark the beginning of the constructor.  */
1245           ctor_stmt = build_min_nt (CTOR_STMT);
1246           CTOR_BEGIN_P (ctor_stmt) = 1;
1247           add_tree (ctor_stmt);
1248
1249           /* And actually initialize the base-classes and members.  */
1250           emit_base_init ();
1251         }
1252     }
1253   else if (DECL_DESTRUCTOR_P (current_function_decl)
1254            && !processing_template_decl)
1255     {
1256       tree if_stmt;
1257       tree compound_stmt;
1258       int saved_cfnd;
1259
1260       /* If the dtor is empty, and we know there is not possible way we
1261          could use any vtable entries, before they are possibly set by
1262          a base class dtor, we don't have to setup the vtables, as we
1263          know that any base class dtoring will set up any vtables it
1264          needs.  We avoid MI, because one base class dtor can do a
1265          virtual dispatch to an overridden function that would need to
1266          have a non-related vtable set up, we cannot avoid setting up
1267          vtables in that case.  We could change this to see if there is
1268          just one vtable.  */
1269       if_stmt = begin_if_stmt ();
1270
1271       /* If it is not safe to avoid setting up the vtables, then
1272          someone will change the condition to be boolean_true_node.
1273          (Actually, for now, we do not have code to set the condition
1274          appropriately, so we just assume that we always need to
1275          initialize the vtables.)  */
1276       finish_if_stmt_cond (boolean_true_node, if_stmt);
1277       current_vcalls_possible_p = &IF_COND (if_stmt);
1278
1279       /* Don't declare __PRETTY_FUNCTION__ and friends here when we
1280          open the block for the if-body.  */
1281       saved_cfnd = current_function_name_declared;
1282       current_function_name_declared = 1;
1283       compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
1284       current_function_name_declared = saved_cfnd;
1285
1286       /* Make all virtual function table pointers in non-virtual base
1287          classes point to CURRENT_CLASS_TYPE's virtual function
1288          tables.  */
1289       initialize_vtbl_ptrs (current_class_ptr);
1290
1291       finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
1292       finish_then_clause (if_stmt);
1293       finish_if_stmt ();
1294     }
1295
1296   /* Always keep the BLOCK node associated with the outermost pair of
1297      curly braces of a function.  These are needed for correct
1298      operation of dwarfout.c.  */
1299   keep_next_level (1);
1300
1301   /* The virtual function tables are set up now.  */
1302   vtbls_set_up_p = 1;
1303 }
1304
1305 /* Add a scope-statement to the statement-tree.  BEGIN_P indicates
1306    whether this statements opens or closes a scope.  PARTIAL_P is true
1307    for a partial scope, i.e, the scope that begins after a label when
1308    an object that needs a cleanup is created.  If BEGIN_P is nonzero,
1309    returns a new TREE_LIST representing the top of the SCOPE_STMT
1310    stack.  The TREE_PURPOSE is the new SCOPE_STMT.  If BEGIN_P is
1311    zero, returns a TREE_LIST whose TREE_VALUE is the new SCOPE_STMT,
1312    and whose TREE_PURPOSE is the matching SCOPE_STMT iwth
1313    SCOPE_BEGIN_P set.  */
1314
1315 tree
1316 add_scope_stmt (begin_p, partial_p)
1317      int begin_p;
1318      int partial_p;
1319 {
1320   tree ss;
1321   tree top;
1322
1323   /* Build the statement.  */
1324   ss = build_min_nt (SCOPE_STMT, NULL_TREE);
1325   SCOPE_BEGIN_P (ss) = begin_p;
1326   SCOPE_PARTIAL_P (ss) = partial_p;
1327
1328   /* Keep the scope stack up to date.  */
1329   if (begin_p)
1330     {
1331       current_scope_stmt_stack
1332         = tree_cons (ss, NULL_TREE, current_scope_stmt_stack);
1333       top = current_scope_stmt_stack;
1334     }
1335   else
1336     {
1337       top = current_scope_stmt_stack;
1338       TREE_VALUE (top) = ss;
1339       current_scope_stmt_stack = TREE_CHAIN (top);
1340     }
1341
1342   /* Add the new statement to the statement-tree.  */
1343   add_tree (ss);
1344
1345   return top;
1346 }
1347
1348 /* Begin a new scope.  */
1349
1350 void
1351 do_pushlevel ()
1352 {
1353   if (!building_stmt_tree ())
1354     {
1355       emit_line_note (input_filename, lineno);
1356       clear_last_expr ();
1357     }
1358   if (stmts_are_full_exprs_p)
1359     {
1360       pushlevel (0);
1361       if (!building_stmt_tree ()
1362           && !cfun->x_whole_function_mode_p)
1363         my_friendly_abort (19991129);
1364
1365       if (building_stmt_tree () && !processing_template_decl)
1366         add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
1367     }
1368 }
1369
1370 /* Finish a scope.  */
1371
1372 tree
1373 do_poplevel ()
1374 {
1375   tree block = NULL_TREE;
1376
1377   if (stmts_are_full_exprs_p)
1378     {
1379       tree scope_stmts;
1380
1381       if (building_stmt_tree () && !processing_template_decl)
1382         scope_stmts = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
1383       else
1384         scope_stmts = NULL_TREE;
1385
1386       block = poplevel (kept_level_p (), 1, 0);
1387       if (block && !processing_template_decl)
1388         {
1389           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1390           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1391         }
1392     }
1393
1394   return block;
1395 }
1396
1397 /* Finish a parenthesized expression EXPR.  */
1398
1399 tree
1400 finish_parenthesized_expr (expr)
1401      tree expr;
1402 {
1403   if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expr))))
1404     /* This inhibits warnings in truthvalue_conversion.  */
1405     C_SET_EXP_ORIGINAL_CODE (expr, ERROR_MARK);
1406
1407   return expr;
1408 }
1409
1410 /* Begin a statement-expression.  The value returned must be passed to
1411    finish_stmt_expr.  */
1412
1413 tree
1414 begin_stmt_expr ()
1415 {
1416   /* If we're outside a function, we won't have a statement-tree to
1417      work with.  But, if we see a statement-expression we need to
1418      create one.  */
1419   if (! cfun && !last_tree)
1420     begin_stmt_tree (&scope_chain->x_saved_tree);
1421
1422   keep_next_level (1);
1423   /* If we're building a statement tree, then the upcoming compound
1424      statement will be chained onto the tree structure, starting at
1425      last_tree.  We return last_tree so that we can later unhook the
1426      compound statement.  */
1427   return building_stmt_tree () ? last_tree : expand_start_stmt_expr();
1428 }
1429
1430 /* Finish a statement-expression.  RTL_EXPR should be the value
1431    returned by the previous begin_stmt_expr; EXPR is the
1432    statement-expression.  Returns an expression representing the
1433    statement-expression.  */
1434
1435 tree
1436 finish_stmt_expr (rtl_expr)
1437      tree rtl_expr;
1438 {
1439   tree result;
1440
1441   if (!building_stmt_tree ())
1442     rtl_expr = expand_end_stmt_expr (rtl_expr);
1443
1444   if (building_stmt_tree ())
1445     {
1446       /* If the last thing in the statement-expression was not an
1447          expression-statement, then it has type `void'.  */
1448       if (!last_expr_type)
1449         last_expr_type = void_type_node;
1450       result = build_min (STMT_EXPR, last_expr_type, last_tree);
1451       TREE_SIDE_EFFECTS (result) = 1;
1452
1453       /* Remove the compound statement from the tree structure; it is
1454          now saved in the STMT_EXPR.  */
1455       SET_LAST_STMT (rtl_expr);
1456       TREE_CHAIN (last_tree) = NULL_TREE;
1457     }
1458   else
1459     result = rtl_expr;
1460
1461   /* If we created a statement-tree for this statement-expression,
1462      remove it now.  */
1463   if (! cfun
1464       && TREE_CHAIN (scope_chain->x_saved_tree) == NULL_TREE)
1465     finish_stmt_tree (&scope_chain->x_saved_tree);
1466
1467   return result;
1468 }
1469
1470 /* Finish a call to FN with ARGS.  Returns a representation of the
1471    call.  */
1472
1473 tree
1474 finish_call_expr (fn, args, koenig)
1475      tree fn;
1476      tree args;
1477      int koenig;
1478 {
1479   tree result;
1480
1481   if (koenig)
1482     {
1483       if (TREE_CODE (fn) == BIT_NOT_EXPR)
1484         fn = build_x_unary_op (BIT_NOT_EXPR, TREE_OPERAND (fn, 0));
1485       else if (TREE_CODE (fn) != TEMPLATE_ID_EXPR)
1486         fn = do_identifier (fn, 2, args);
1487     }
1488   result = build_x_function_call (fn, args, current_class_ref);
1489
1490   if (TREE_CODE (result) == CALL_EXPR
1491       && (! TREE_TYPE (result)
1492           || TREE_CODE (TREE_TYPE (result)) != VOID_TYPE))
1493     result = require_complete_type (result);
1494
1495   return result;
1496 }
1497
1498 /* Finish a call to a postfix increment or decrement or EXPR.  (Which
1499    is indicated by CODE, which should be POSTINCREMENT_EXPR or
1500    POSTDECREMENT_EXPR.)  */
1501
1502 tree
1503 finish_increment_expr (expr, code)
1504      tree expr;
1505      enum tree_code code;
1506 {
1507   /* If we get an OFFSET_REF, turn it into what it really means (e.g.,
1508      a COMPONENT_REF).  This way if we've got, say, a reference to a
1509      static member that's being operated on, we don't end up trying to
1510      find a member operator for the class it's in.  */
1511
1512   if (TREE_CODE (expr) == OFFSET_REF)
1513     expr = resolve_offset_ref (expr);
1514   return build_x_unary_op (code, expr);
1515 }
1516
1517 /* Finish a use of `this'.  Returns an expression for `this'.  */
1518
1519 tree
1520 finish_this_expr ()
1521 {
1522   tree result;
1523
1524   if (current_class_ptr)
1525     {
1526 #ifdef WARNING_ABOUT_CCD
1527       TREE_USED (current_class_ptr) = 1;
1528 #endif
1529       result = current_class_ptr;
1530     }
1531   else if (current_function_decl
1532            && DECL_STATIC_FUNCTION_P (current_function_decl))
1533     {
1534       error ("`this' is unavailable for static member functions");
1535       result = error_mark_node;
1536     }
1537   else
1538     {
1539       if (current_function_decl)
1540         error ("invalid use of `this' in non-member function");
1541       else
1542         error ("invalid use of `this' at top level");
1543       result = error_mark_node;
1544     }
1545
1546   return result;
1547 }
1548
1549 /* Finish a member function call using OBJECT and ARGS as arguments to
1550    FN.  Returns an expression for the call.  */
1551
1552 tree
1553 finish_object_call_expr (fn, object, args)
1554      tree fn;
1555      tree object;
1556      tree args;
1557 {
1558 #if 0
1559   /* This is a future direction of this code, but because
1560      build_x_function_call cannot always undo what is done in
1561      build_component_ref entirely yet, we cannot do this.  */
1562
1563   tree real_fn = build_component_ref (object, fn, NULL_TREE, 1);
1564   return finish_call_expr (real_fn, args);
1565 #else
1566   if (DECL_DECLARES_TYPE_P (fn))
1567     {
1568       if (processing_template_decl)
1569         /* This can happen on code like:
1570
1571            class X;
1572            template <class T> void f(T t) {
1573              t.X();
1574            }
1575
1576            We just grab the underlying IDENTIFIER.  */
1577         fn = DECL_NAME (fn);
1578       else
1579         {
1580           cp_error ("calling type `%T' like a method", fn);
1581           return error_mark_node;
1582         }
1583     }
1584
1585   return build_method_call (object, fn, args, NULL_TREE, LOOKUP_NORMAL);
1586 #endif
1587 }
1588
1589 /* Finish a qualified member function call using OBJECT and ARGS as
1590    arguments to FN.  Returns an expressino for the call.  */
1591
1592 tree
1593 finish_qualified_object_call_expr (fn, object, args)
1594      tree fn;
1595      tree object;
1596      tree args;
1597 {
1598   return build_scoped_method_call (object, TREE_OPERAND (fn, 0),
1599                                    TREE_OPERAND (fn, 1), args);
1600 }
1601
1602 /* Finish a pseudo-destructor call expression of OBJECT, with SCOPE
1603    being the scope, if any, of DESTRUCTOR.  Returns an expression for
1604    the call.  */
1605
1606 tree
1607 finish_pseudo_destructor_call_expr (object, scope, destructor)
1608      tree object;
1609      tree scope;
1610      tree destructor;
1611 {
1612   if (processing_template_decl)
1613     return build_min_nt (PSEUDO_DTOR_EXPR, object, scope, destructor);
1614
1615   if (scope && scope != destructor)
1616     cp_error ("destructor specifier `%T::~%T()' must have matching names",
1617               scope, destructor);
1618
1619   if ((scope == NULL_TREE || IDENTIFIER_GLOBAL_VALUE (destructor))
1620       && (TREE_CODE (TREE_TYPE (object)) !=
1621           TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (destructor)))))
1622     cp_error ("`%E' is not of type `%T'", object, destructor);
1623
1624   return cp_convert (void_type_node, object);
1625 }
1626
1627 /* Finish a call to a globally qualified member function FN using
1628    ARGS.  Returns an expression for the call.  */
1629
1630 tree
1631 finish_qualified_call_expr (fn, args)
1632      tree fn;
1633      tree args;
1634 {
1635   if (processing_template_decl)
1636     return build_min_nt (CALL_EXPR, fn, args, NULL_TREE);
1637   else
1638     return build_member_call (TREE_OPERAND (fn, 0),
1639                               TREE_OPERAND (fn, 1),
1640                               args);
1641 }
1642
1643 /* Finish an expression taking the address of LABEL.  Returns an
1644    expression for the address.  */
1645
1646 tree
1647 finish_label_address_expr (label)
1648      tree label;
1649 {
1650   tree result;
1651
1652   label = lookup_label (label);
1653   if (label == NULL_TREE)
1654     result = null_pointer_node;
1655   else
1656     {
1657       TREE_USED (label) = 1;
1658       result = build1 (ADDR_EXPR, ptr_type_node, label);
1659       TREE_CONSTANT (result) = 1;
1660       /* This function cannot be inlined.  All jumps to the addressed
1661          label should wind up at the same point.  */
1662       DECL_UNINLINABLE (current_function_decl) = 1;
1663     }
1664
1665   return result;
1666 }
1667
1668 /* Finish an expression of the form CODE EXPR.  */
1669
1670 tree
1671 finish_unary_op_expr (code, expr)
1672      enum tree_code code;
1673      tree expr;
1674 {
1675   tree result = build_x_unary_op (code, expr);
1676   /* Inside a template, build_x_unary_op does not fold the
1677      expression. So check whether the result is folded before
1678      setting TREE_NEGATED_INT.  */
1679   if (code == NEGATE_EXPR && TREE_CODE (expr) == INTEGER_CST
1680       && TREE_CODE (result) == INTEGER_CST
1681       && !TREE_UNSIGNED (TREE_TYPE (result))
1682       && INT_CST_LT (result, integer_zero_node))
1683     TREE_NEGATED_INT (result) = 1;
1684   overflow_warning (result);
1685   return result;
1686 }
1687
1688 /* Finish an id-expression.  */
1689
1690 tree
1691 finish_id_expr (expr)
1692      tree expr;
1693 {
1694   if (TREE_CODE (expr) == IDENTIFIER_NODE)
1695     expr = do_identifier (expr, 1, NULL_TREE);
1696
1697   return expr;
1698 }
1699
1700 static tree current_type_lookups;
1701
1702 /* Perform deferred access control for types used in the type of a
1703    declaration.  */
1704
1705 static void
1706 deferred_type_access_control ()
1707 {
1708   tree lookup = type_lookups;
1709
1710   if (lookup == error_mark_node)
1711     return;
1712
1713   for (; lookup; lookup = TREE_CHAIN (lookup))
1714     enforce_access (TREE_PURPOSE (lookup), TREE_VALUE (lookup));
1715 }
1716
1717 void
1718 decl_type_access_control (decl)
1719      tree decl;
1720 {
1721   tree save_fn;
1722
1723   if (type_lookups == error_mark_node)
1724     return;
1725
1726   save_fn = current_function_decl;
1727
1728   if (decl && TREE_CODE (decl) == FUNCTION_DECL)
1729     current_function_decl = decl;
1730
1731   deferred_type_access_control ();
1732
1733   current_function_decl = save_fn;
1734
1735   /* Now strip away the checks for the current declarator; they were
1736      added to type_lookups after typed_declspecs saved the copy that
1737      ended up in current_type_lookups.  */
1738   type_lookups = current_type_lookups;
1739 }
1740
1741 void
1742 save_type_access_control (lookups)
1743      tree lookups;
1744 {
1745   current_type_lookups = lookups;
1746 }
1747
1748 /* Begin a function definition declared with DECL_SPECS and
1749    DECLARATOR.  Returns non-zero if the function-declaration is
1750    legal.  */
1751
1752 int
1753 begin_function_definition (decl_specs, declarator)
1754      tree decl_specs;
1755      tree declarator;
1756 {
1757   tree specs;
1758   tree attrs;
1759
1760   split_specs_attrs (decl_specs, &specs, &attrs);
1761   if (!start_function (specs, declarator, attrs, SF_DEFAULT))
1762     return 0;
1763
1764   deferred_type_access_control ();
1765   type_lookups = error_mark_node;
1766
1767   reinit_parse_for_function ();
1768   /* The things we're about to see are not directly qualified by any
1769      template headers we've seen thus far.  */
1770   reset_specialization ();
1771
1772   return 1;
1773 }
1774
1775 /* Begin a constructor declarator of the form `SCOPE::NAME'.  Returns
1776    a SCOPE_REF.  */
1777
1778 tree
1779 begin_constructor_declarator (scope, name)
1780      tree scope;
1781      tree name;
1782 {
1783   tree result = build_parse_node (SCOPE_REF, scope, name);
1784   enter_scope_of (result);
1785   return result;
1786 }
1787
1788 /* Finish an init-declarator.  Returns a DECL.  */
1789
1790 tree
1791 finish_declarator (declarator, declspecs, attributes,
1792                    prefix_attributes, initialized)
1793      tree declarator;
1794      tree declspecs;
1795      tree attributes;
1796      tree prefix_attributes;
1797      int initialized;
1798 {
1799   return start_decl (declarator, declspecs, initialized, attributes,
1800                      prefix_attributes);
1801 }
1802
1803 /* Finish a translation unit.  */
1804
1805 void
1806 finish_translation_unit ()
1807 {
1808   /* In case there were missing closebraces,
1809      get us back to the global binding level.  */
1810   pop_everything ();
1811   while (current_namespace != global_namespace)
1812     pop_namespace ();
1813   finish_file ();
1814 }
1815
1816 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
1817    Returns the parameter.  */
1818
1819 tree
1820 finish_template_type_parm (aggr, identifier)
1821      tree aggr;
1822      tree identifier;
1823 {
1824   if (aggr != class_type_node)
1825     {
1826       pedwarn ("template type parameters must use the keyword `class' or `typename'");
1827       aggr = class_type_node;
1828     }
1829
1830   return build_tree_list (aggr, identifier);
1831 }
1832
1833 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
1834    Returns the parameter.  */
1835
1836 tree
1837 finish_template_template_parm (aggr, identifier)
1838      tree aggr;
1839      tree identifier;
1840 {
1841   tree decl = build_decl (TYPE_DECL, identifier, NULL_TREE);
1842   tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
1843   DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
1844   DECL_TEMPLATE_RESULT (tmpl) = decl;
1845   SET_DECL_ARTIFICIAL (decl);
1846   end_template_decl ();
1847
1848   return finish_template_type_parm (aggr, tmpl);
1849 }
1850
1851 /* Finish a parameter list, indicated by PARMS.  If ELLIPSIS is
1852    non-zero, the parameter list was terminated by a `...'.  */
1853
1854 tree
1855 finish_parmlist (parms, ellipsis)
1856      tree parms;
1857      int ellipsis;
1858 {
1859   if (!ellipsis)
1860     chainon (parms, void_list_node);
1861   /* We mark the PARMS as a parmlist so that declarator processing can
1862      disambiguate certain constructs.  */
1863   if (parms != NULL_TREE)
1864     TREE_PARMLIST (parms) = 1;
1865
1866   return parms;
1867 }
1868
1869 /* Begin a class definition, as indicated by T.  */
1870
1871 tree
1872 begin_class_definition (t)
1873      tree t;
1874 {
1875   if (t == error_mark_node
1876       || ! IS_AGGR_TYPE (t))
1877     {
1878       t = make_aggr_type (RECORD_TYPE);
1879       pushtag (make_anon_name (), t, 0);
1880     }
1881
1882   /* In a definition of a member class template, we will get here with an
1883      implicit typename, a TYPENAME_TYPE with a type.  */
1884   if (TREE_CODE (t) == TYPENAME_TYPE)
1885     t = TREE_TYPE (t);
1886
1887   /* If we generated a partial instantiation of this type, but now
1888      we're seeing a real definition, we're actually looking at a
1889      partial specialization.  Consider:
1890
1891        template <class T, class U>
1892        struct Y {};
1893
1894        template <class T>
1895        struct X {};
1896
1897        template <class T, class U>
1898        void f()
1899        {
1900          typename X<Y<T, U> >::A a;
1901        }
1902
1903        template <class T, class U>
1904        struct X<Y<T, U> >
1905        {
1906        };
1907
1908      We have to undo the effects of the previous partial
1909      instantiation.  */
1910   if (PARTIAL_INSTANTIATION_P (t))
1911     {
1912       if (!pedantic)
1913         {
1914           /* Unfortunately, when we're not in pedantic mode, we
1915              attempt to actually fill in some of the fields of the
1916              partial instantiation, in order to support the implicit
1917              typename extension.  Clear those fields now, in
1918              preparation for the definition here.  The fields cleared
1919              here must match those set in instantiate_class_template.
1920              Look for a comment mentioning begin_class_definition
1921              there.  */
1922           TYPE_BINFO_BASETYPES (t) = NULL_TREE;
1923           TYPE_FIELDS (t) = NULL_TREE;
1924           TYPE_METHODS (t) = NULL_TREE;
1925           CLASSTYPE_TAGS (t) = NULL_TREE;
1926           TYPE_SIZE (t) = NULL_TREE;
1927         }
1928
1929       /* This isn't a partial instantiation any more.  */
1930       PARTIAL_INSTANTIATION_P (t) = 0;
1931     }
1932   /* If this type was already complete, and we see another definition,
1933      that's an error.  */
1934   else if (COMPLETE_TYPE_P (t))
1935     duplicate_tag_error (t);
1936
1937   /* Update the location of the decl.  */
1938   DECL_SOURCE_FILE (TYPE_NAME (t)) = input_filename;
1939   DECL_SOURCE_LINE (TYPE_NAME (t)) = lineno;
1940
1941   if (TYPE_BEING_DEFINED (t))
1942     {
1943       t = make_aggr_type (TREE_CODE (t));
1944       pushtag (TYPE_IDENTIFIER (t), t, 0);
1945     }
1946   maybe_process_partial_specialization (t);
1947   pushclass (t, 1);
1948   TYPE_BEING_DEFINED (t) = 1;
1949   /* Reset the interface data, at the earliest possible
1950      moment, as it might have been set via a class foo;
1951      before.  */
1952   {
1953     tree name = TYPE_IDENTIFIER (t);
1954
1955     if (! ANON_AGGRNAME_P (name))
1956       {
1957         CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
1958         SET_CLASSTYPE_INTERFACE_UNKNOWN_X
1959           (t, interface_unknown);
1960       }
1961
1962     /* Only leave this bit clear if we know this
1963        class is part of an interface-only specification.  */
1964     if (! CLASSTYPE_INTERFACE_KNOWN (t)
1965         || ! CLASSTYPE_INTERFACE_ONLY (t))
1966       CLASSTYPE_VTABLE_NEEDS_WRITING (t) = 1;
1967   }
1968   reset_specialization();
1969
1970   /* Make a declaration for this class in its own scope.  */
1971   build_self_reference ();
1972
1973   return t;
1974 }
1975
1976 /* Finish the member declaration given by DECL.  */
1977
1978 void
1979 finish_member_declaration (decl)
1980      tree decl;
1981 {
1982   if (decl == error_mark_node || decl == NULL_TREE)
1983     return;
1984
1985   if (decl == void_type_node)
1986     /* The COMPONENT was a friend, not a member, and so there's
1987        nothing for us to do.  */
1988     return;
1989
1990   /* We should see only one DECL at a time.  */
1991   my_friendly_assert (TREE_CHAIN (decl) == NULL_TREE, 0);
1992
1993   /* Set up access control for DECL.  */
1994   TREE_PRIVATE (decl)
1995     = (current_access_specifier == access_private_node);
1996   TREE_PROTECTED (decl)
1997     = (current_access_specifier == access_protected_node);
1998   if (TREE_CODE (decl) == TEMPLATE_DECL)
1999     {
2000       TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
2001       TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
2002     }
2003
2004   /* Mark the DECL as a member of the current class.  */
2005   DECL_CONTEXT (decl) = current_class_type;
2006
2007   /* [dcl.link]
2008
2009      A C language linkage is ignored for the names of class members
2010      and the member function type of class member functions.  */
2011   if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
2012     DECL_LANGUAGE (decl) = lang_cplusplus;
2013
2014   /* Put functions on the TYPE_METHODS list and everything else on the
2015      TYPE_FIELDS list.  Note that these are built up in reverse order.
2016      We reverse them (to obtain declaration order) in finish_struct.  */
2017   if (TREE_CODE (decl) == FUNCTION_DECL
2018       || DECL_FUNCTION_TEMPLATE_P (decl))
2019     {
2020       /* We also need to add this function to the
2021          CLASSTYPE_METHOD_VEC.  */
2022       add_method (current_class_type, 0, decl);
2023
2024       TREE_CHAIN (decl) = TYPE_METHODS (current_class_type);
2025       TYPE_METHODS (current_class_type) = decl;
2026     }
2027   else
2028     {
2029       /* All TYPE_DECLs go at the end of TYPE_FIELDS.  Ordinary fields
2030          go at the beginning.  The reason is that lookup_field_1
2031          searches the list in order, and we want a field name to
2032          override a type name so that the "struct stat hack" will
2033          work.  In particular:
2034
2035            struct S { enum E { }; int E } s;
2036            s.E = 3;
2037
2038          is legal.  In addition, the FIELD_DECLs must be maintained in
2039          declaration order so that class layout works as expected.
2040          However, we don't need that order until class layout, so we
2041          save a little time by putting FIELD_DECLs on in reverse order
2042          here, and then reversing them in finish_struct_1.  (We could
2043          also keep a pointer to the correct insertion points in the
2044          list.)  */
2045
2046       if (TREE_CODE (decl) == TYPE_DECL)
2047         TYPE_FIELDS (current_class_type)
2048           = chainon (TYPE_FIELDS (current_class_type), decl);
2049       else
2050         {
2051           TREE_CHAIN (decl) = TYPE_FIELDS (current_class_type);
2052           TYPE_FIELDS (current_class_type) = decl;
2053         }
2054
2055       /* Enter the DECL into the scope of the class.  */
2056       if (TREE_CODE (decl) != USING_DECL)
2057         pushdecl_class_level (decl);
2058     }
2059 }
2060
2061 /* Finish a class definition T with the indicate ATTRIBUTES.  If SEMI,
2062    the definition is immediately followed by a semicolon.  Returns the
2063    type.  */
2064
2065 tree
2066 finish_class_definition (t, attributes, semi, pop_scope_p)
2067      tree t;
2068      tree attributes;
2069      int semi;
2070      int pop_scope_p;
2071 {
2072   /* finish_struct nukes this anyway; if finish_exception does too,
2073      then it can go.  */
2074   if (semi)
2075     note_got_semicolon (t);
2076
2077   /* If we got any attributes in class_head, xref_tag will stick them in
2078      TREE_TYPE of the type.  Grab them now.  */
2079   attributes = chainon (TREE_TYPE (t), attributes);
2080   TREE_TYPE (t) = NULL_TREE;
2081
2082   if (TREE_CODE (t) == ENUMERAL_TYPE)
2083     ;
2084   else
2085     {
2086       t = finish_struct (t, attributes);
2087       if (semi)
2088         note_got_semicolon (t);
2089     }
2090
2091   if (! semi)
2092     check_for_missing_semicolon (t);
2093   if (pop_scope_p)
2094     pop_scope (CP_DECL_CONTEXT (TYPE_MAIN_DECL (t)));
2095   if (current_scope () == current_function_decl)
2096     do_pending_defargs ();
2097
2098   return t;
2099 }
2100
2101 /* Finish processing the default argument expressions cached during
2102    the processing of a class definition.  */
2103
2104 void
2105 begin_inline_definitions ()
2106 {
2107   if (pending_inlines
2108       && current_scope () == current_function_decl)
2109     do_pending_inlines ();
2110 }
2111
2112 /* Finish processing the inline function definitions cached during the
2113    processing of a class definition.  */
2114
2115 void
2116 finish_inline_definitions ()
2117 {
2118   if (current_class_type == NULL_TREE)
2119     clear_inline_text_obstack ();
2120 }
2121
2122 /* Finish processing the declaration of a member class template
2123    TYPES whose template parameters are given by PARMS.  */
2124
2125 tree
2126 finish_member_class_template (types)
2127      tree types;
2128 {
2129   tree t;
2130
2131   /* If there are declared, but undefined, partial specializations
2132      mixed in with the typespecs they will not yet have passed through
2133      maybe_process_partial_specialization, so we do that here.  */
2134   for (t = types; t != NULL_TREE; t = TREE_CHAIN (t))
2135     if (IS_AGGR_TYPE_CODE (TREE_CODE (TREE_VALUE (t))))
2136       maybe_process_partial_specialization (TREE_VALUE (t));
2137
2138   note_list_got_semicolon (types);
2139   grok_x_components (types);
2140   if (TYPE_CONTEXT (TREE_VALUE (types)) != current_class_type)
2141     /* The component was in fact a friend declaration.  We avoid
2142        finish_member_template_decl performing certain checks by
2143        unsetting TYPES.  */
2144     types = NULL_TREE;
2145
2146   finish_member_template_decl (types);
2147
2148   /* As with other component type declarations, we do
2149      not store the new DECL on the list of
2150      component_decls.  */
2151   return NULL_TREE;
2152 }
2153
2154 /* Finish processsing a complete template declaration.  The PARMS are
2155    the template parameters.  */
2156
2157 void
2158 finish_template_decl (parms)
2159      tree parms;
2160 {
2161   if (parms)
2162     end_template_decl ();
2163   else
2164     end_specialization ();
2165 }
2166
2167 /* Finish processing a a template-id (which names a type) of the form
2168    NAME < ARGS >.  Return the TYPE_DECL for the type named by the
2169    template-id.  If ENTERING_SCOPE is non-zero we are about to enter
2170    the scope of template-id indicated.  */
2171
2172 tree
2173 finish_template_type (name, args, entering_scope)
2174      tree name;
2175      tree args;
2176      int entering_scope;
2177 {
2178   tree decl;
2179
2180   decl = lookup_template_class (name, args,
2181                                 NULL_TREE, NULL_TREE, entering_scope);
2182   if (decl != error_mark_node)
2183     decl = TYPE_STUB_DECL (decl);
2184
2185   return decl;
2186 }
2187
2188 /* SR is a SCOPE_REF node.  Enter the scope of SR, whether it is a
2189    namespace scope or a class scope.  */
2190
2191 void
2192 enter_scope_of (sr)
2193      tree sr;
2194 {
2195   tree scope = TREE_OPERAND (sr, 0);
2196
2197   if (TREE_CODE (scope) == NAMESPACE_DECL)
2198     {
2199       push_decl_namespace (scope);
2200       TREE_COMPLEXITY (sr) = -1;
2201     }
2202   else if (scope != current_class_type)
2203     {
2204       if (TREE_CODE (scope) == TYPENAME_TYPE)
2205         {
2206           /* In a declarator for a template class member, the scope will
2207              get here as an implicit typename, a TYPENAME_TYPE with a type.  */
2208           scope = TREE_TYPE (scope);
2209           TREE_OPERAND (sr, 0) = scope;
2210         }
2211       push_nested_class (scope, 3);
2212       TREE_COMPLEXITY (sr) = current_class_depth;
2213     }
2214 }
2215
2216 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2217    Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2218    BASE_CLASS, or NULL_TREE if an error occurred.  The
2219    ACCESSS_SPECIFIER is one of
2220    access_{default,public,protected_private}[_virtual]_node.*/
2221
2222 tree
2223 finish_base_specifier (access_specifier, base_class)
2224      tree access_specifier;
2225      tree base_class;
2226 {
2227   tree type;
2228   tree result;
2229
2230   if (base_class == NULL_TREE)
2231     {
2232       error ("invalid base class");
2233       type = error_mark_node;
2234     }
2235   else
2236     type = TREE_TYPE (base_class);
2237
2238   if (! is_aggr_type (type, 1))
2239     result = NULL_TREE;
2240   else
2241     result = build_tree_list (access_specifier, type);
2242
2243   return result;
2244 }
2245
2246 /* Called when multiple declarators are processed.  If that is not
2247    premitted in this context, an error is issued.  */
2248
2249 void
2250 check_multiple_declarators ()
2251 {
2252   /* [temp]
2253
2254      In a template-declaration, explicit specialization, or explicit
2255      instantiation the init-declarator-list in the declaration shall
2256      contain at most one declarator.
2257
2258      We don't just use PROCESSING_TEMPLATE_DECL for the first
2259      condition since that would disallow the perfectly legal code,
2260      like `template <class T> struct S { int i, j; };'.  */
2261   tree scope = current_scope ();
2262
2263   if (scope && TREE_CODE (scope) == FUNCTION_DECL)
2264     /* It's OK to write `template <class T> void f() { int i, j;}'.  */
2265     return;
2266
2267   if (PROCESSING_REAL_TEMPLATE_DECL_P ()
2268       || processing_explicit_instantiation
2269       || processing_specialization)
2270     cp_error ("multiple declarators in template declaration");
2271 }
2272
2273 tree
2274 finish_typeof (expr)
2275      tree expr;
2276 {
2277   if (processing_template_decl)
2278     {
2279       tree t;
2280
2281       t = make_aggr_type (TYPEOF_TYPE);
2282       TYPE_FIELDS (t) = expr;
2283
2284       return t;
2285     }
2286
2287   return TREE_TYPE (expr);
2288 }
2289
2290 /* Create an empty statement tree rooted at T.  */
2291
2292 void
2293 begin_stmt_tree (t)
2294      tree *t;
2295 {
2296   /* We create a trivial EXPR_STMT so that last_tree is never NULL in
2297      what follows.  We remove the extraneous statement in
2298      finish_stmt_tree.  */
2299   *t = build_nt (EXPR_STMT, void_zero_node);
2300   SET_LAST_STMT (*t);
2301   last_expr_type = NULL_TREE;
2302 }
2303
2304 /* Finish the statement tree rooted at T.  */
2305
2306 void
2307 finish_stmt_tree (t)
2308      tree *t;
2309 {
2310   tree stmt;
2311
2312   /* Remove the fake extra statement added in begin_stmt_tree.  */
2313   stmt = TREE_CHAIN (*t);
2314   *t = stmt;
2315   SET_LAST_STMT (NULL_TREE);
2316
2317   if (cfun)
2318     {
2319       /* The line-number recorded in the outermost statement in a function
2320          is the line number of the end of the function.  */
2321       STMT_LINENO (stmt) = lineno;
2322       STMT_LINENO_FOR_FN_P (stmt) = 1;
2323     }
2324 }
2325
2326 /* We're about to expand T, a statement.  Set up appropriate context
2327    for the substitution.  */
2328
2329 void
2330 prep_stmt (t)
2331      tree t;
2332 {
2333   if (!STMT_LINENO_FOR_FN_P (t))
2334     lineno = STMT_LINENO (t);
2335   stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
2336 }
2337
2338 /* Some statements, like for-statements or if-statements, require a
2339    condition.  This condition can be a declaration.  If T is such a
2340    declaration it is processed, and an expression appropriate to use
2341    as the condition is returned.  Otherwise, T itself is returned.  */
2342
2343 static tree
2344 expand_cond (t)
2345      tree t;
2346 {
2347   if (t && TREE_CODE (t) == TREE_LIST)
2348     {
2349       expand_stmt (TREE_PURPOSE (t));
2350       return TREE_VALUE (t);
2351     }
2352   else
2353     return t;
2354 }
2355
2356 /* Generate RTL for the statement T, and its substatements, and any
2357    other statements at its nesting level.  */
2358
2359 tree
2360 expand_stmt (t)
2361      tree t;
2362 {
2363   tree rval = NULL_TREE;
2364
2365   while (t && t != error_mark_node)
2366     {
2367       int saved_stmts_are_full_exprs_p;
2368
2369       /* Assume we'll have nothing to return.  */
2370       rval = NULL_TREE;
2371
2372       /* Set up context appropriately for handling this statement.  */
2373       saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
2374       prep_stmt (t);
2375
2376       switch (TREE_CODE (t))
2377         {
2378         case RETURN_STMT:
2379           finish_return_stmt (RETURN_EXPR (t));
2380           break;
2381
2382         case EXPR_STMT:
2383           finish_expr_stmt (EXPR_STMT_EXPR (t));
2384           break;
2385
2386         case DECL_STMT:
2387           {
2388             tree decl;
2389
2390             emit_line_note (input_filename, lineno);
2391             decl = DECL_STMT_DECL (t);
2392             /* If this is a declaration for an automatic local
2393                variable, initialize it.  Note that we might also see a
2394                declaration for a namespace-scope object (declared with
2395                `extern').  We don't have to handle the initialization
2396                of those objects here; they can only be declarations,
2397                rather than definitions.  */
2398             if (TREE_CODE (decl) == VAR_DECL
2399                 && !TREE_STATIC (decl)
2400                 && !DECL_EXTERNAL (decl))
2401               {
2402                 /* Let the back-end know about this variable.  */
2403                 if (!ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
2404                   emit_local_var (decl);
2405                 else
2406                   expand_anon_union_decl (decl, NULL_TREE,
2407                                           DECL_ANON_UNION_ELEMS (decl));
2408               }
2409             else if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
2410               {
2411                 if (DECL_ARTIFICIAL (decl) && ! TREE_USED (decl))
2412                   /* Do not emit unused decls. This is not just an
2413                      optimization. We really do not want to emit
2414                      __PRETTY_FUNCTION__ etc, if they're never used.  */
2415                   DECL_IGNORED_P (decl) = 1;
2416                 else
2417                   make_rtl_for_local_static (decl);
2418               }
2419           }
2420           break;
2421
2422         case CLEANUP_STMT:
2423           finish_decl_cleanup (CLEANUP_DECL (t), CLEANUP_EXPR (t));
2424           break;
2425
2426         case START_CATCH_STMT:
2427           begin_catch_block (TREE_TYPE (t));
2428           break;
2429
2430         case CTOR_STMT:
2431           if (CTOR_BEGIN_P (t))
2432             begin_protect_partials ();
2433           else
2434             /* After this point, any exceptions will cause the
2435                destructor to be executed, so we no longer need to worry
2436                about destroying the various subobjects ourselves.  */
2437             end_protect_partials ();
2438           break;
2439
2440         case FOR_STMT:
2441           {
2442             tree tmp;
2443
2444             begin_for_stmt ();
2445             expand_stmt (FOR_INIT_STMT (t));
2446             finish_for_init_stmt (NULL_TREE);
2447             finish_for_cond (expand_cond (FOR_COND (t)), NULL_TREE);
2448             tmp = FOR_EXPR (t);
2449             finish_for_expr (tmp, NULL_TREE);
2450             expand_stmt (FOR_BODY (t));
2451             finish_for_stmt (tmp, NULL_TREE);
2452           }
2453           break;
2454
2455         case WHILE_STMT:
2456           {
2457             begin_while_stmt ();
2458             finish_while_stmt_cond (expand_cond (WHILE_COND (t)), NULL_TREE);
2459             expand_stmt (WHILE_BODY (t));
2460             finish_while_stmt (NULL_TREE);
2461           }
2462           break;
2463
2464         case DO_STMT:
2465           {
2466             begin_do_stmt ();
2467             expand_stmt (DO_BODY (t));
2468             finish_do_body (NULL_TREE);
2469             finish_do_stmt (DO_COND (t), NULL_TREE);
2470           }
2471           break;
2472
2473         case IF_STMT:
2474           begin_if_stmt ();
2475           finish_if_stmt_cond (expand_cond (IF_COND (t)), NULL_TREE);
2476           if (THEN_CLAUSE (t))
2477             {
2478               expand_stmt (THEN_CLAUSE (t));
2479               finish_then_clause (NULL_TREE);
2480             }
2481           if (ELSE_CLAUSE (t))
2482             {
2483               begin_else_clause ();
2484               expand_stmt (ELSE_CLAUSE (t));
2485               finish_else_clause (NULL_TREE);
2486             }
2487           finish_if_stmt ();
2488           break;
2489
2490         case COMPOUND_STMT:
2491           begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t));
2492           expand_stmt (COMPOUND_BODY (t));
2493           rval = finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t),
2494                                        NULL_TREE);
2495           break;
2496
2497         case BREAK_STMT:
2498           finish_break_stmt ();
2499           break;
2500
2501         case CONTINUE_STMT:
2502           finish_continue_stmt ();
2503           break;
2504
2505         case SWITCH_STMT:
2506           {
2507             tree cond;
2508
2509             begin_switch_stmt ();
2510             cond = expand_cond (SWITCH_COND (t));
2511             finish_switch_cond (cond, NULL_TREE);
2512             expand_stmt (SWITCH_BODY (t));
2513             finish_switch_stmt (cond, NULL_TREE);
2514           }
2515           break;
2516
2517         case CASE_LABEL:
2518           finish_case_label (CASE_LOW (t), CASE_HIGH (t));
2519           break;
2520
2521         case LABEL_STMT:
2522           expand_label (LABEL_STMT_LABEL (t));
2523           break;
2524
2525         case GOTO_STMT:
2526           finish_goto_stmt (GOTO_DESTINATION (t));
2527           break;
2528
2529         case ASM_STMT:
2530           finish_asm_stmt (ASM_CV_QUAL (t), ASM_STRING (t), ASM_OUTPUTS
2531                            (t), ASM_INPUTS (t), ASM_CLOBBERS (t));
2532           break;
2533
2534         case TRY_BLOCK:
2535           if (CLEANUP_P (t))
2536             {
2537               expand_eh_region_start ();
2538               expand_stmt (TRY_STMTS (t));
2539               finish_cleanup_try_block (NULL_TREE);
2540               finish_cleanup (TRY_HANDLERS (t), NULL_TREE);
2541             }
2542           else
2543             {
2544               if (FN_TRY_BLOCK_P (t))
2545                 begin_function_try_block ();
2546               else
2547                 begin_try_block ();
2548
2549               expand_stmt (TRY_STMTS (t));
2550
2551               if (FN_TRY_BLOCK_P (t))
2552                 {
2553                   finish_function_try_block (NULL_TREE);
2554                   expand_stmt (TRY_HANDLERS (t));
2555                   finish_function_handler_sequence (NULL_TREE);
2556                 }
2557               else
2558                 {
2559                   finish_try_block (NULL_TREE);
2560                   expand_stmt (TRY_HANDLERS (t));
2561                   finish_handler_sequence (NULL_TREE);
2562                 }
2563             }
2564           break;
2565
2566         case HANDLER:
2567           begin_handler ();
2568           expand_stmt (HANDLER_BODY (t));
2569           finish_handler (NULL_TREE, NULL_TREE);
2570           break;
2571
2572         case SUBOBJECT:
2573           finish_subobject (SUBOBJECT_CLEANUP (t));
2574           break;
2575
2576         case SCOPE_STMT:
2577           if (!SCOPE_NO_CLEANUPS_P (t))
2578             {
2579               if (SCOPE_BEGIN_P (t))
2580                 expand_start_bindings_and_block (2 * SCOPE_NULLIFIED_P (t),
2581                                                  SCOPE_STMT_BLOCK (t));
2582               else if (SCOPE_END_P (t))
2583                 expand_end_bindings (NULL_TREE, !SCOPE_NULLIFIED_P (t),
2584                                      SCOPE_PARTIAL_P (t));
2585             }
2586           else if (!SCOPE_NULLIFIED_P (t))
2587             {
2588               rtx note = emit_note (NULL,
2589                                     (SCOPE_BEGIN_P (t)
2590                                      ? NOTE_INSN_BLOCK_BEG
2591                                      : NOTE_INSN_BLOCK_END));
2592               NOTE_BLOCK (note) = SCOPE_STMT_BLOCK (t);
2593             }
2594
2595           break;
2596
2597         case RETURN_INIT:
2598           /* Clear this out so that finish_named_return_value can set it
2599              again.  */
2600           DECL_NAME (DECL_RESULT (current_function_decl)) = NULL_TREE;
2601           finish_named_return_value (TREE_OPERAND (t, 0),
2602                                      TREE_OPERAND (t, 1));
2603           break;
2604
2605         default:
2606           my_friendly_abort (19990810);
2607           break;
2608         }
2609
2610       /* Restore saved state.  */
2611       stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
2612
2613       /* Go on to the next statement in this scope.  */
2614       t = TREE_CHAIN (t);
2615     }
2616
2617   return rval;
2618 }
2619
2620 /* Called from expand_body via walk_tree.  Replace all AGGR_INIT_EXPRs
2621    will equivalent CALL_EXPRs.  */
2622
2623 static tree
2624 simplify_aggr_init_exprs_r (tp, walk_subtrees, data)
2625      tree *tp;
2626      int *walk_subtrees ATTRIBUTE_UNUSED;
2627      void *data ATTRIBUTE_UNUSED;
2628 {
2629   tree aggr_init_expr;
2630   tree call_expr;
2631   tree fn;
2632   tree args;
2633   tree slot;
2634   tree type;
2635   tree call_type;
2636   int copy_from_buffer_p;
2637
2638   aggr_init_expr = *tp;
2639   /* We don't need to walk into types; there's nothing in a type that
2640      needs simplification.  (And, furthermore, there are places we
2641      actively don't want to go.  For example, we don't want to wander
2642      into the default arguments for a FUNCTION_DECL that appears in a
2643      CALL_EXPR.)  */
2644   if (TYPE_P (aggr_init_expr))
2645     {
2646       *walk_subtrees = 0;
2647       return NULL_TREE;
2648     }
2649   /* Only AGGR_INIT_EXPRs are interesting.  */
2650   else if (TREE_CODE (aggr_init_expr) != AGGR_INIT_EXPR)
2651     return NULL_TREE;
2652
2653   /* Form an appropriate CALL_EXPR.  */
2654   fn = TREE_OPERAND (aggr_init_expr, 0);
2655   args = TREE_OPERAND (aggr_init_expr, 1);
2656   slot = TREE_OPERAND (aggr_init_expr, 2);
2657   type = TREE_TYPE (aggr_init_expr);
2658   call_type = type;
2659   if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
2660     {
2661       /* Replace the first argument with the address of the third
2662          argument to the AGGR_INIT_EXPR.  */
2663       call_type = build_pointer_type (type);
2664       mark_addressable (slot);
2665       args = tree_cons (NULL_TREE, build1 (ADDR_EXPR, call_type, slot),
2666                         TREE_CHAIN (args));
2667     }
2668   call_expr = build (CALL_EXPR, call_type, fn, args, NULL_TREE);
2669   TREE_SIDE_EFFECTS (call_expr) = 1;
2670
2671   /* If we're using the non-reentrant PCC calling convention, then we
2672      need to copy the returned value out of the static buffer into the
2673      SLOT.  */
2674   copy_from_buffer_p = 0;
2675 #ifdef PCC_STATIC_STRUCT_RETURN
2676   if (!AGGR_INIT_VIA_CTOR_P (aggr_init_expr) && aggregate_value_p (type))
2677     {
2678       int old_ac;
2679
2680       flag_access_control = 0;
2681       call_expr = build_aggr_init (slot, call_expr, LOOKUP_ONLYCONVERTING);
2682       flag_access_control = old_ac;
2683       copy_from_buffer_p = 1;
2684     }
2685 #endif
2686
2687   /* If this AGGR_INIT_EXPR indicates the value returned by a
2688      function, then we want to use the value of the initialized
2689      location as the result.  */
2690   if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr) || copy_from_buffer_p)
2691     {
2692       call_expr = build (COMPOUND_EXPR, type,
2693                          call_expr, slot);
2694       TREE_SIDE_EFFECTS (call_expr) = 1;
2695     }
2696
2697   /* Replace the AGGR_INIT_EXPR with the CALL_EXPR.  */
2698   TREE_CHAIN (call_expr) = TREE_CHAIN (aggr_init_expr);
2699   *tp = call_expr;
2700
2701   /* Keep iterating.  */
2702   return NULL_TREE;
2703 }
2704
2705 /* Generate RTL for FN.  */
2706
2707 void
2708 expand_body (fn)
2709      tree fn;
2710 {
2711   int saved_lineno;
2712   const char *saved_input_filename;
2713
2714   /* When the parser calls us after finishing the body of a template
2715      function, we don't really want to expand the body.  When we're
2716      processing an in-class definition of an inline function,
2717      PROCESSING_TEMPLATE_DECL will no longer be set here, so we have
2718      to look at the function itself.  */
2719   if (processing_template_decl
2720       || (DECL_LANG_SPECIFIC (fn)
2721           && DECL_TEMPLATE_INFO (fn)
2722           && uses_template_parms (DECL_TI_ARGS (fn))))
2723     {
2724       /* Normally, collection only occurs in rest_of_compilation.  So,
2725          if we don't collect here, we never collect junk generated
2726          during the processing of templates until we hit a
2727          non-template function.  */
2728       ggc_collect ();
2729       return;
2730     }
2731
2732   /* Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs.  */
2733   walk_tree (&DECL_SAVED_TREE (fn), simplify_aggr_init_exprs_r, NULL);
2734
2735   /* If this is a constructor or destructor body, we have to clone it
2736      under the new ABI.  */
2737   if (maybe_clone_body (fn))
2738     {
2739       /* We don't want to process FN again, so pretend we've written
2740          it out, even though we haven't.  */
2741       TREE_ASM_WRITTEN (fn) = 1;
2742       return;
2743     }
2744
2745   /* There's no reason to do any of the work here if we're only doing
2746      semantic analysis; this code just generates RTL.  */
2747   if (flag_syntax_only)
2748     return;
2749
2750   /* If possible, avoid generating RTL for this function.  Instead,
2751      just record it as an inline function, and wait until end-of-file
2752      to decide whether to write it out or not.  */
2753   if (/* We have to generate RTL if it's not an inline function.  */
2754       (DECL_INLINE (fn) || DECL_COMDAT (fn))
2755       /* Or if we have to keep all inline functions anyhow.  */
2756       && !flag_keep_inline_functions
2757       /* Or if we actually have a reference to the function.  */
2758       && !DECL_NEEDED_P (fn)
2759       /* Or if this is a nested function.  */
2760       && !decl_function_context (fn))
2761     {
2762       /* Give the function RTL now so that we can assign it to a
2763          function pointer, etc.  */
2764       make_function_rtl (fn);
2765       /* Set DECL_EXTERNAL so that assemble_external will be called as
2766          necessary.  We'll clear it again in finish_file.  */
2767       if (!DECL_EXTERNAL (fn))
2768         {
2769           DECL_NOT_REALLY_EXTERN (fn) = 1;
2770           DECL_EXTERNAL (fn) = 1;
2771         }
2772       /* Remember this function.  In finish_file we'll decide if
2773          we actually need to write this function out.  */
2774       defer_fn (fn);
2775       /* Let the back-end know that this funtion exists.  */
2776       note_deferral_of_defined_inline_function (fn);
2777       return;
2778     }
2779
2780   /* Optimize the body of the function before expanding it.  */
2781   optimize_function (fn);
2782
2783   /* Save the current file name and line number.  When we expand the
2784      body of the function, we'll set LINENO and INPUT_FILENAME so that
2785      error-mesages come out in the right places.  */
2786   saved_lineno = lineno;
2787   saved_input_filename = input_filename;
2788   lineno = DECL_SOURCE_LINE (fn);
2789   input_filename = DECL_SOURCE_FILE (fn);
2790
2791   start_function (NULL_TREE, fn, NULL_TREE, SF_PRE_PARSED | SF_EXPAND);
2792   store_parm_decls ();
2793   current_function_is_thunk = DECL_THUNK_P (fn);
2794
2795   /* We don't need to redeclare __FUNCTION__, __PRETTY_FUNCTION__, or
2796      any of the other magic variables we set up when starting a
2797      function body.  */
2798   current_function_name_declared = 1;
2799
2800   /* Expand the body.  */
2801   expand_stmt (DECL_SAVED_TREE (fn));
2802
2803   /* Statements should always be full-expressions at the outermost set
2804      of curly braces for a function.  */
2805   my_friendly_assert (stmts_are_full_exprs_p, 19990831);
2806
2807   /* The outermost statement for a function contains the line number
2808      recorded when we finished processing the function.  */
2809   lineno = STMT_LINENO (DECL_SAVED_TREE (fn));
2810
2811   /* Generate code for the function.  */
2812   finish_function (0);
2813
2814   /* If possible, obliterate the body of the function so that it can
2815      be garbage collected.  */
2816   if (flag_dump_translation_unit)
2817     /* Keep the body; we're going to dump it.  */
2818     ;
2819   else if (DECL_INLINE (fn) && flag_inline_trees)
2820     /* We might need the body of this function so that we can expand
2821        it inline somewhere else.  */
2822     ;
2823   else
2824     /* We don't need the body; blow it away.  */
2825     DECL_SAVED_TREE (fn) = NULL_TREE;
2826
2827   /* And restore the current source position.  */
2828   lineno = saved_lineno;
2829   input_filename = saved_input_filename;
2830 }