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