gcc/cp/method.c

   1 /* Handle the hair of processing (but not expanding) inline functions.
   2    Also manage function and variable name overloading.
   3    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   4    1999, 2000 Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GNU CC.
   8
   9 GNU CC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GNU CC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GNU CC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.  */
  23
  24
  25 /* Handle method declarations.  */
  26 #include "config.h"
  27 #include "system.h"
  28 #include "tree.h"
  29 #include "cp-tree.h"
  30 #include "obstack.h"
  31 #include "rtl.h"
  32 #include "expr.h"
  33 #include "output.h"
  34 #include "flags.h"
  35 #include "toplev.h"
  36 #include "ggc.h"
  37 #include "tm_p.h"
  38
  39 /* Various flags to control the mangling process.  */
  40
  41 enum mangling_flags
  42 {
  43   /* No flags.  */
  44   mf_none = 0,
  45   /* The thing we are presently mangling is part of a template type,
  46      rather than a fully instantiated type.  Therefore, we may see
  47      complex expressions where we would normally expect to see a
  48      simple integer constant.  */
  49   mf_maybe_uninstantiated = 1,
  50   /* When mangling a numeric value, use the form `_XX_' (instead of
  51      just `XX') if the value has more than one digit.  */
  52   mf_use_underscores_around_value = 2,
  53 };
  54
  55 typedef enum mangling_flags mangling_flags;
  56
  57 #define obstack_chunk_alloc xmalloc
  58 #define obstack_chunk_free free
  59
  60 static void do_build_assign_ref PARAMS ((tree));
  61 static void do_build_copy_constructor PARAMS ((tree));
  62 static tree synthesize_exception_spec PARAMS ((tree, tree (*) (tree, void *), void *));
  63 static tree locate_dtor PARAMS ((tree, void *));
  64 static tree locate_ctor PARAMS ((tree, void *));
  65 static tree locate_copy PARAMS ((tree, void *));
  66
  67 /* Called once to initialize method.c.  */
  68
  69 void
  70 init_method ()
  71 {
  72   init_mangle ();
  73 }
  74
  75 \f
  76 /* Set the mangled name (DECL_ASSEMBLER_NAME) for DECL.  */
  77
  78 void
  79 set_mangled_name_for_decl (decl)
  80      tree decl;
  81 {
  82   if (processing_template_decl)
  83     /* There's no need to mangle the name of a template function.  */
  84     return;
  85
  86   mangle_decl (decl);
  87 }
  88
  89 \f
  90 /* Given a tree_code CODE, and some arguments (at least one),
  91    attempt to use an overloaded operator on the arguments.
  92
  93    For unary operators, only the first argument need be checked.
  94    For binary operators, both arguments may need to be checked.
  95
  96    Member functions can convert class references to class pointers,
  97    for one-level deep indirection.  More than that is not supported.
  98    Operators [](), ()(), and ->() must be member functions.
  99
 100    We call function call building calls with LOOKUP_COMPLAIN if they
 101    are our only hope.  This is true when we see a vanilla operator
 102    applied to something of aggregate type.  If this fails, we are free
 103    to return `error_mark_node', because we will have reported the
 104    error.
 105
 106    Operators NEW and DELETE overload in funny ways: operator new takes
 107    a single `size' parameter, and operator delete takes a pointer to the
 108    storage being deleted.  When overloading these operators, success is
 109    assumed.  If there is a failure, report an error message and return
 110    `error_mark_node'.  */
 111
 112 /* NOSTRICT */
 113 tree
 114 build_opfncall (code, flags, xarg1, xarg2, arg3)
 115      enum tree_code code;
 116      int flags;
 117      tree xarg1, xarg2, arg3;
 118 {
 119   return build_new_op (code, flags, xarg1, xarg2, arg3);
 120 }
 121 \f
 122 /* This function takes an identifier, ID, and attempts to figure out what
 123    it means. There are a number of possible scenarios, presented in increasing
 124    order of hair:
 125
 126    1) not in a class's scope
 127    2) in class's scope, member name of the class's method
 128    3) in class's scope, but not a member name of the class
 129    4) in class's scope, member name of a class's variable
 130
 131    NAME is $1 from the bison rule. It is an IDENTIFIER_NODE.
 132    VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1)
 133
 134    As a last ditch, try to look up the name as a label and return that
 135    address.
 136
 137    Values which are declared as being of REFERENCE_TYPE are
 138    automatically dereferenced here (as a hack to make the
 139    compiler faster).  */
 140
 141 tree
 142 hack_identifier (value, name)
 143      tree value, name;
 144 {
 145   tree type;
 146
 147   if (value == error_mark_node)
 148     {
 149       if (current_class_name)
 150         {
 151           tree fields = lookup_fnfields (TYPE_BINFO (current_class_type),
 152                                          name, 1);
 153           if (fields == error_mark_node)
 154             return error_mark_node;
 155           if (fields)
 156             {
 157               tree fndecl;
 158
 159               fndecl = TREE_VALUE (fields);
 160               my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 251);
 161               /* I could not trigger this code. MvL */
 162               my_friendly_abort (980325);
 163 #ifdef DEAD
 164               if (DECL_CHAIN (fndecl) == NULL_TREE)
 165                 {
 166                   warning ("methods cannot be converted to function pointers");
 167                   return fndecl;
 168                 }
 169               else
 170                 {
 171                   error ("ambiguous request for method pointer `%s'",
 172                          IDENTIFIER_POINTER (name));
 173                   return error_mark_node;
 174                 }
 175 #endif
 176             }
 177         }
 178       return error_mark_node;
 179     }
 180
 181   type = TREE_TYPE (value);
 182   if (TREE_CODE (value) == FIELD_DECL)
 183     {
 184       if (current_class_ptr == NULL_TREE)
 185         {
 186           if (current_function_decl
 187               && DECL_STATIC_FUNCTION_P (current_function_decl))
 188             cp_error ("invalid use of member `%D' in static member function",
 189                       value);
 190           else
 191             /* We can get here when processing a bad default
 192                argument, like:
 193                  struct S { int a; void f(int i = a); }  */
 194             cp_error ("invalid use of member `%D'", value);
 195
 196           return error_mark_node;
 197         }
 198       TREE_USED (current_class_ptr) = 1;
 199
 200       /* Mark so that if we are in a constructor, and then find that
 201          this field was initialized by a base initializer,
 202          we can emit an error message.  */
 203       TREE_USED (value) = 1;
 204       value = build_component_ref (current_class_ref, name, NULL_TREE, 1);
 205     }
 206   else if ((TREE_CODE (value) == FUNCTION_DECL
 207             && DECL_FUNCTION_MEMBER_P (value))
 208            || (TREE_CODE (value) == OVERLOAD
 209                && DECL_FUNCTION_MEMBER_P (OVL_CURRENT (value))))
 210     {
 211       tree decl;
 212
 213       if (TREE_CODE (value) == OVERLOAD)
 214         value = OVL_CURRENT (value);
 215
 216       decl = maybe_dummy_object (DECL_CONTEXT (value), 0);
 217       value = build_component_ref (decl, name, NULL_TREE, 1);
 218     }
 219   else if (really_overloaded_fn (value))
 220     ;
 221   else if (TREE_CODE (value) == OVERLOAD)
 222     /* not really overloaded function */
 223     mark_used (OVL_FUNCTION (value));
 224   else if (TREE_CODE (value) == TREE_LIST)
 225     {
 226       /* Ambiguous reference to base members, possibly other cases?.  */
 227       tree t = value;
 228       while (t && TREE_CODE (t) == TREE_LIST)
 229         {
 230           mark_used (TREE_VALUE (t));
 231           t = TREE_CHAIN (t);
 232         }
 233     }
 234   else if (TREE_CODE (value) == NAMESPACE_DECL)
 235     {
 236       cp_error ("use of namespace `%D' as expression", value);
 237       return error_mark_node;
 238     }
 239   else if (DECL_CLASS_TEMPLATE_P (value))
 240     {
 241       cp_error ("use of class template `%T' as expression", value);
 242       return error_mark_node;
 243     }
 244   else
 245     mark_used (value);
 246
 247   if (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == PARM_DECL
 248       || TREE_CODE (value) == RESULT_DECL)
 249     {
 250       tree context = decl_function_context (value);
 251       if (context != NULL_TREE && context != current_function_decl
 252           && ! TREE_STATIC (value))
 253         {
 254           cp_error ("use of %s from containing function",
 255                       (TREE_CODE (value) == VAR_DECL
 256                        ? "`auto' variable" : "parameter"));
 257           cp_error_at ("  `%#D' declared here", value);
 258           value = error_mark_node;
 259         }
 260     }
 261
 262   if (DECL_P (value) && DECL_NONLOCAL (value))
 263     {
 264       if (DECL_CLASS_SCOPE_P (value)
 265           && DECL_CONTEXT (value) != current_class_type)
 266         {
 267           tree path;
 268           path = currently_open_derived_class (DECL_CONTEXT (value));
 269           enforce_access (path, value);
 270         }
 271     }
 272   else if (TREE_CODE (value) == TREE_LIST
 273            && TREE_TYPE (value) == error_mark_node)
 274     {
 275       cp_error ("\
 276 request for member `%D' is ambiguous in multiple inheritance lattice",
 277                 name);
 278       print_candidates (value);
 279       return error_mark_node;
 280     }
 281
 282   if (! processing_template_decl)
 283     value = convert_from_reference (value);
 284   return value;
 285 }
 286
 287 \f
 288 /* Return a thunk to FUNCTION.  For a virtual thunk, DELTA is the
 289    offset to this used to locate the vptr, and VCALL_INDEX is used to
 290    look up the eventual subobject location.  For a non-virtual thunk,
 291    DELTA is the offset to this and VCALL_INDEX is NULL.  */
 292
 293 tree
 294 make_thunk (function, delta, vcall_index)
 295      tree function;
 296      tree delta;
 297      tree vcall_index;
 298 {
 299   tree thunk_id;
 300   tree thunk;
 301   tree func_decl;
 302   tree vcall_offset;
 303   HOST_WIDE_INT d;
 304
 305   /* Scale the VCALL_INDEX to be in terms of bytes.  */
 306   if (vcall_index)
 307     vcall_offset
 308       = size_binop (MULT_EXPR,
 309                     vcall_index,
 310                     convert (ssizetype,
 311                              TYPE_SIZE_UNIT (vtable_entry_type)));
 312   else
 313     vcall_offset = NULL_TREE;
 314
 315   d = tree_low_cst (delta, 0);
 316
 317   if (TREE_CODE (function) != ADDR_EXPR)
 318     abort ();
 319   func_decl = TREE_OPERAND (function, 0);
 320   if (TREE_CODE (func_decl) != FUNCTION_DECL)
 321     abort ();
 322
 323   thunk_id = mangle_thunk (TREE_OPERAND (function, 0),
 324                            delta, vcall_offset);
 325   thunk = IDENTIFIER_GLOBAL_VALUE (thunk_id);
 326   if (thunk && !DECL_THUNK_P (thunk))
 327     {
 328       cp_error ("implementation-reserved name `%D' used", thunk_id);
 329       thunk = NULL_TREE;
 330       SET_IDENTIFIER_GLOBAL_VALUE (thunk_id, thunk);
 331     }
 332   if (thunk == NULL_TREE)
 333     {
 334       thunk = build_decl (FUNCTION_DECL, thunk_id, TREE_TYPE (func_decl));
 335       DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (func_decl);
 336       copy_lang_decl (func_decl);
 337       SET_DECL_ASSEMBLER_NAME (thunk, thunk_id);
 338       DECL_CONTEXT (thunk) = DECL_CONTEXT (func_decl);
 339       TREE_READONLY (thunk) = TREE_READONLY (func_decl);
 340       TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (func_decl);
 341       comdat_linkage (thunk);
 342       SET_DECL_THUNK_P (thunk);
 343       DECL_INITIAL (thunk) = function;
 344       THUNK_DELTA (thunk) = d;
 345       THUNK_VCALL_OFFSET (thunk) = vcall_offset;
 346       /* The thunk itself is not a constructor or destructor, even if
 347          the thing it is thunking to is.  */
 348       DECL_INTERFACE_KNOWN (thunk) = 1;
 349       DECL_NOT_REALLY_EXTERN (thunk) = 1;
 350       DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
 351       DECL_DESTRUCTOR_P (thunk) = 0;
 352       DECL_CONSTRUCTOR_P (thunk) = 0;
 353       /* And neither is it a clone.  */
 354       DECL_CLONED_FUNCTION (thunk) = NULL_TREE;
 355       DECL_EXTERNAL (thunk) = 1;
 356       DECL_ARTIFICIAL (thunk) = 1;
 357       /* Even if this thunk is a member of a local class, we don't
 358          need a static chain.  */
 359       DECL_NO_STATIC_CHAIN (thunk) = 1;
 360       /* The THUNK is not a pending inline, even if the FUNC_DECL is.  */
 361       DECL_PENDING_INLINE_P (thunk) = 0;
 362       /* Nor has it been deferred.  */
 363       DECL_DEFERRED_FN (thunk) = 0;
 364       /* So that finish_file can write out any thunks that need to be: */
 365       pushdecl_top_level (thunk);
 366       SET_IDENTIFIER_GLOBAL_VALUE (thunk_id, thunk);
 367     }
 368   return thunk;
 369 }
 370
 371 /* Emit the definition of a C++ multiple inheritance vtable thunk.  If
 372    EMIT_P is non-zero, the thunk is emitted immediately.  */
 373
 374 void
 375 use_thunk (thunk_fndecl, emit_p)
 376      tree thunk_fndecl;
 377      int emit_p;
 378 {
 379   tree fnaddr;
 380   tree function;
 381   tree vcall_offset;
 382   HOST_WIDE_INT delta;
 383
 384   if (TREE_ASM_WRITTEN (thunk_fndecl))
 385     return;
 386
 387   fnaddr = DECL_INITIAL (thunk_fndecl);
 388   if (TREE_CODE (DECL_INITIAL (thunk_fndecl)) != ADDR_EXPR)
 389     /* We already turned this thunk into an ordinary function.
 390        There's no need to process this thunk again.  */
 391     return;
 392
 393   /* Thunks are always addressable; they only appear in vtables.  */
 394   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 395
 396   /* Figure out what function is being thunked to.  It's referenced in
 397      this translation unit.  */
 398   function = TREE_OPERAND (fnaddr, 0);
 399   TREE_ADDRESSABLE (function) = 1;
 400   mark_used (function);
 401   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (function)) = 1;
 402   if (!emit_p)
 403     return;
 404
 405   delta = THUNK_DELTA (thunk_fndecl);
 406   vcall_offset = THUNK_VCALL_OFFSET (thunk_fndecl);
 407
 408   /* And, if we need to emit the thunk, it's used.  */
 409   mark_used (thunk_fndecl);
 410   /* This thunk is actually defined.  */
 411   DECL_EXTERNAL (thunk_fndecl) = 0;
 412
 413   if (flag_syntax_only)
 414     {
 415       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 416       return;
 417     }
 418
 419   push_to_top_level ();
 420
 421 #ifdef ASM_OUTPUT_MI_THUNK
 422   if (!vcall_offset)
 423     {
 424       const char *fnname;
 425       current_function_decl = thunk_fndecl;
 426       DECL_RESULT (thunk_fndecl)
 427         = build_decl (RESULT_DECL, 0, integer_type_node);
 428       fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
 429       init_function_start (thunk_fndecl, input_filename, lineno);
 430       current_function_is_thunk = 1;
 431       assemble_start_function (thunk_fndecl, fnname);
 432       ASM_OUTPUT_MI_THUNK (asm_out_file, thunk_fndecl, delta, function);
 433       assemble_end_function (thunk_fndecl, fnname);
 434       current_function_decl = 0;
 435       cfun = 0;
 436       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 437     }
 438   else
 439 #endif /* ASM_OUTPUT_MI_THUNK */
 440   {
 441   /* If we don't have the necessary macro for efficient thunks, generate a
 442      thunk function that just makes a call to the real function.
 443      Unfortunately, this doesn't work for varargs.  */
 444
 445     tree a, t;
 446
 447     if (varargs_function_p (function))
 448       cp_error ("generic thunk code fails for method `%#D' which uses `...'",
 449                 function);
 450
 451     /* Set up clone argument trees for the thunk.  */
 452     t = NULL_TREE;
 453     for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
 454       {
 455         tree x = copy_node (a);
 456         TREE_CHAIN (x) = t;
 457         DECL_CONTEXT (x) = thunk_fndecl;
 458         t = x;
 459       }
 460     a = nreverse (t);
 461     DECL_ARGUMENTS (thunk_fndecl) = a;
 462     DECL_RESULT (thunk_fndecl) = NULL_TREE;
 463
 464     start_function (NULL_TREE, thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
 465
 466     /* Adjust the this pointer by the constant.  */
 467     t = ssize_int (delta);
 468     t = fold (build (PLUS_EXPR, TREE_TYPE (a), a, t));
 469     /* If there's a vcall offset, look up that value in the vtable and
 470        adjust the `this' pointer again.  */
 471     if (vcall_offset && !integer_zerop (vcall_offset))
 472       {
 473         tree orig_this;
 474
 475         t = save_expr (t);
 476         orig_this = t;
 477         /* The vptr is always at offset zero in the object.  */
 478         t = build1 (NOP_EXPR,
 479                     build_pointer_type (build_pointer_type
 480                                         (vtable_entry_type)),
 481                     t);
 482         /* Form the vtable address.  */
 483         t = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (t)), t);
 484         /* Find the entry with the vcall offset.  */
 485         t = build (PLUS_EXPR, TREE_TYPE (t), t, vcall_offset);
 486         /* Calculate the offset itself.  */
 487         t = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (t)), t);
 488         /* Adjust the `this' pointer.  */
 489         t = fold (build (PLUS_EXPR,
 490                          TREE_TYPE (orig_this),
 491                          orig_this,
 492                          t));
 493       }
 494
 495     /* Build up the call to the real function.  */
 496     t = tree_cons (NULL_TREE, t, NULL_TREE);
 497     for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
 498       t = tree_cons (NULL_TREE, a, t);
 499     t = nreverse (t);
 500     t = build_call (function, t);
 501     if (VOID_TYPE_P (TREE_TYPE (t)))
 502       finish_expr_stmt (t);
 503     else
 504       finish_return_stmt (t);
 505
 506     /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
 507        create one.  */
 508     DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
 509     BLOCK_VARS (DECL_INITIAL (thunk_fndecl))
 510       = DECL_ARGUMENTS (thunk_fndecl);
 511
 512     /* Since we want to emit the thunk, we explicitly mark its name as
 513        referenced.  */
 514     TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (thunk_fndecl)) = 1;
 515
 516     /* But we don't want debugging information about it.  */
 517     DECL_IGNORED_P (thunk_fndecl) = 1;
 518
 519     expand_body (finish_function (0));
 520   }
 521
 522   pop_from_top_level ();
 523 }
 524 \f
 525 /* Code for synthesizing methods which have default semantics defined.  */
 526
 527 /* Generate code for default X(X&) constructor.  */
 528
 529 static void
 530 do_build_copy_constructor (fndecl)
 531      tree fndecl;
 532 {
 533   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
 534   tree t;
 535
 536   parm = convert_from_reference (parm);
 537
 538   if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
 539       && is_empty_class (current_class_type))
 540     /* Don't copy the padding byte; it might not have been allocated
 541        if *this is a base subobject.  */;
 542   else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
 543     {
 544       t = build (INIT_EXPR, void_type_node, current_class_ref, parm);
 545       finish_expr_stmt (t);
 546     }
 547   else
 548     {
 549       tree fields = TYPE_FIELDS (current_class_type);
 550       int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
 551       tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
 552       tree member_init_list = NULL_TREE;
 553       tree base_init_list = NULL_TREE;
 554       int cvquals = cp_type_quals (TREE_TYPE (parm));
 555       int i;
 556
 557       /* Initialize all the base-classes with the parameter converted to
 558          their type so that we get their copy constructor and not another
 559          constructor that takes current_class_type.  */
 560       for (t = CLASSTYPE_VBASECLASSES (current_class_type); t;
 561            t = TREE_CHAIN (t))
 562         {
 563           tree type = BINFO_TYPE (TREE_VALUE (t));
 564           base_init_list = tree_cons (type, convert_lvalue (type, parm),
 565                                       base_init_list);
 566         }
 567
 568       for (i = 0; i < n_bases; ++i)
 569         {
 570           t = TREE_VEC_ELT (binfos, i);
 571           if (TREE_VIA_VIRTUAL (t))
 572             continue;
 573
 574           t = BINFO_TYPE (t);
 575           base_init_list = tree_cons (t, convert_lvalue (t, parm),
 576                                       base_init_list);
 577         }
 578
 579       for (; fields; fields = TREE_CHAIN (fields))
 580         {
 581           tree init;
 582           tree field = fields;
 583
 584           if (TREE_CODE (field) != FIELD_DECL)
 585             continue;
 586
 587           init = parm;
 588           if (DECL_NAME (field))
 589             {
 590               if (VFIELD_NAME_P (DECL_NAME (field)))
 591                 continue;
 592
 593               /* True for duplicate members.  */
 594               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 595                 continue;
 596             }
 597           else if ((t = TREE_TYPE (field)) != NULL_TREE
 598                    && ANON_AGGR_TYPE_P (t)
 599                    && TYPE_FIELDS (t) != NULL_TREE)
 600             /* Just use the field; anonymous types can't have
 601                nontrivial copy ctors or assignment ops.  */;
 602           else
 603             continue;
 604
 605           init = build (COMPONENT_REF,
 606                         build_qualified_type (TREE_TYPE (field), cvquals),
 607                         init, field);
 608           init = build_tree_list (NULL_TREE, init);
 609
 610           member_init_list
 611             = tree_cons (field, init, member_init_list);
 612         }
 613       member_init_list = nreverse (member_init_list);
 614       base_init_list = nreverse (base_init_list);
 615       setup_vtbl_ptr (member_init_list, base_init_list);
 616     }
 617 }
 618
 619 static void
 620 do_build_assign_ref (fndecl)
 621      tree fndecl;
 622 {
 623   tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
 624   tree compound_stmt;
 625
 626   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
 627   parm = convert_from_reference (parm);
 628
 629   if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
 630       && is_empty_class (current_class_type))
 631     /* Don't copy the padding byte; it might not have been allocated
 632        if *this is a base subobject.  */;
 633   else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
 634     {
 635       tree t = build (MODIFY_EXPR, void_type_node, current_class_ref, parm);
 636       finish_expr_stmt (t);
 637     }
 638   else
 639     {
 640       tree fields = TYPE_FIELDS (current_class_type);
 641       int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
 642       tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
 643       int cvquals = cp_type_quals (TREE_TYPE (parm));
 644       int i;
 645
 646       for (i = 0; i < n_bases; ++i)
 647         {
 648           tree basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
 649           tree p = convert_lvalue (basetype, parm);
 650           p = build_member_call (basetype, ansi_assopname (NOP_EXPR),
 651                                  build_tree_list (NULL_TREE, p));
 652           finish_expr_stmt (p);
 653         }
 654       for (; fields; fields = TREE_CHAIN (fields))
 655         {
 656           tree comp, init, t;
 657           tree field = fields;
 658
 659           if (TREE_CODE (field) != FIELD_DECL)
 660             continue;
 661
 662           if (CP_TYPE_CONST_P (TREE_TYPE (field)))
 663             {
 664               cp_error ("non-static const member `%#D', can't use default assignment operator", field);
 665               continue;
 666             }
 667           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 668             {
 669               cp_error ("non-static reference member `%#D', can't use default assignment operator", field);
 670               continue;
 671             }
 672
 673           comp = current_class_ref;
 674           init = parm;
 675
 676           if (DECL_NAME (field))
 677             {
 678               if (VFIELD_NAME_P (DECL_NAME (field)))
 679                 continue;
 680
 681               /* True for duplicate members.  */
 682               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 683                 continue;
 684             }
 685           else if ((t = TREE_TYPE (field)) != NULL_TREE
 686                    && ANON_AGGR_TYPE_P (t)
 687                    && TYPE_FIELDS (t) != NULL_TREE)
 688             /* Just use the field; anonymous types can't have
 689                nontrivial copy ctors or assignment ops.  */;
 690           else
 691             continue;
 692
 693           comp = build (COMPONENT_REF, TREE_TYPE (field), comp, field);
 694           init = build (COMPONENT_REF,
 695                         build_qualified_type (TREE_TYPE (field), cvquals),
 696                         init, field);
 697
 698           if (DECL_NAME (field))
 699             finish_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
 700           else
 701             finish_expr_stmt (build (MODIFY_EXPR, TREE_TYPE (comp), comp,
 702                                      init));
 703         }
 704     }
 705   finish_return_stmt (current_class_ref);
 706   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
 707 }
 708
 709 void
 710 synthesize_method (fndecl)
 711      tree fndecl;
 712 {
 713   int nested = (current_function_decl != NULL_TREE);
 714   tree context = decl_function_context (fndecl);
 715   int need_body = 1;
 716
 717   if (at_eof)
 718     import_export_decl (fndecl);
 719
 720   /* If we've been asked to synthesize a clone, just synthesize the
 721      cloned function instead.  Doing so will automatically fill in the
 722      body for the clone.  */
 723   if (DECL_CLONED_FUNCTION_P (fndecl))
 724     {
 725       synthesize_method (DECL_CLONED_FUNCTION (fndecl));
 726       return;
 727     }
 728
 729   if (! context)
 730     push_to_top_level ();
 731   else if (nested)
 732     push_function_context_to (context);
 733
 734   /* Put the function definition at the position where it is needed,
 735      rather than within the body of the class.  That way, an error
 736      during the generation of the implicit body points at the place
 737      where the attempt to generate the function occurs, giving the
 738      user a hint as to why we are attempting to generate the
 739      function. */
 740   DECL_SOURCE_LINE (fndecl) = lineno;
 741   DECL_SOURCE_FILE (fndecl) = input_filename;
 742
 743   interface_unknown = 1;
 744   start_function (NULL_TREE, fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 745   clear_last_expr ();
 746
 747   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 748     {
 749       do_build_assign_ref (fndecl);
 750       need_body = 0;
 751     }
 752   else if (DECL_DESTRUCTOR_P (fndecl))
 753     setup_vtbl_ptr (NULL_TREE, NULL_TREE);
 754   else
 755     {
 756       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 757       if (arg_chain != void_list_node)
 758         do_build_copy_constructor (fndecl);
 759       else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
 760         setup_vtbl_ptr (NULL_TREE, NULL_TREE);
 761     }
 762
 763   /* If we haven't yet generated the body of the function, just
 764      generate an empty compound statement.  */
 765   if (need_body)
 766     {
 767       tree compound_stmt;
 768       compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
 769       finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
 770     }
 771
 772   expand_body (finish_function (0));
 773
 774   extract_interface_info ();
 775   if (! context)
 776     pop_from_top_level ();
 777   else if (nested)
 778     pop_function_context_from (context);
 779 }
 780
 781 /* Use EXTRACTOR to locate the relevant function called for each base &
 782    class field of TYPE. CLIENT allows additional information to be passed
 783    to EXTRACTOR.  Generates the union of all exceptions generated by
 784    those functions.  */
 785
 786 static tree
 787 synthesize_exception_spec (type, extractor, client)
 788      tree type;
 789      tree (*extractor) (tree, void *);
 790      void *client;
 791 {
 792   tree raises = empty_except_spec;
 793   tree fields = TYPE_FIELDS (type);
 794   int i, n_bases = CLASSTYPE_N_BASECLASSES (type);
 795   tree binfos = TYPE_BINFO_BASETYPES (type);
 796
 797   for (i = 0; i != n_bases; i++)
 798     {
 799       tree base = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
 800       tree fn = (*extractor) (base, client);
 801       if (fn)
 802         {
 803           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 804
 805           raises = merge_exception_specifiers (raises, fn_raises);
 806         }
 807     }
 808   for (; fields; fields = TREE_CHAIN (fields))
 809     {
 810       tree type = TREE_TYPE (fields);
 811       tree fn;
 812
 813       if (TREE_CODE (fields) != FIELD_DECL)
 814         continue;
 815       while (TREE_CODE (type) == ARRAY_TYPE)
 816         type = TREE_TYPE (type);
 817       if (TREE_CODE (type) != RECORD_TYPE)
 818         continue;
 819
 820       fn = (*extractor) (type, client);
 821       if (fn)
 822         {
 823           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 824
 825           raises = merge_exception_specifiers (raises, fn_raises);
 826         }
 827     }
 828   return raises;
 829 }
 830
 831 /* Locate the dtor of TYPE.  */
 832
 833 static tree
 834 locate_dtor (type, client)
 835      tree type;
 836      void *client ATTRIBUTE_UNUSED;
 837 {
 838   tree fns;
 839
 840   if (!TYPE_HAS_DESTRUCTOR (type))
 841     return NULL_TREE;
 842   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 843                       CLASSTYPE_DESTRUCTOR_SLOT);
 844   return fns;
 845 }
 846
 847 /* Locate the default ctor of TYPE.  */
 848
 849 static tree
 850 locate_ctor (type, client)
 851      tree type;
 852      void *client ATTRIBUTE_UNUSED;
 853 {
 854   tree fns;
 855
 856   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 857     return NULL_TREE;
 858
 859   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 860                       CLASSTYPE_CONSTRUCTOR_SLOT);
 861   for (; fns; fns = OVL_NEXT (fns))
 862     {
 863       tree fn = OVL_CURRENT (fns);
 864       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 865
 866       if (sufficient_parms_p (TREE_CHAIN (parms)))
 867         return fn;
 868     }
 869   return NULL_TREE;
 870 }
 871
 872 struct copy_data
 873 {
 874   tree name;
 875   int quals;
 876 };
 877
 878 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
 879    points to a COPY_DATA holding the name (NULL for the ctor)
 880    and desired qualifiers of the source operand.  */
 881
 882 static tree
 883 locate_copy (type, client_)
 884      tree type;
 885      void *client_;
 886 {
 887   struct copy_data *client = (struct copy_data *)client_;
 888   tree fns;
 889   int ix = -1;
 890   tree best = NULL_TREE;
 891   int excess_p = 0;
 892
 893   if (client->name)
 894     {
 895       if (TYPE_HAS_ASSIGN_REF (type))
 896         ix = lookup_fnfields_1 (type, client->name);
 897     }
 898   else if (TYPE_HAS_INIT_REF (type))
 899     ix = CLASSTYPE_CONSTRUCTOR_SLOT;
 900   if (ix < 0)
 901     return NULL_TREE;
 902   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), ix);
 903
 904   for (; fns; fns = OVL_NEXT (fns))
 905     {
 906       tree fn = OVL_CURRENT (fns);
 907       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 908       tree src_type;
 909       int excess;
 910       int quals;
 911
 912       parms = TREE_CHAIN (parms);
 913       if (!parms)
 914         continue;
 915       src_type = TREE_VALUE (parms);
 916       if (TREE_CODE (src_type) == REFERENCE_TYPE)
 917         src_type = TREE_TYPE (src_type);
 918       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 919         continue;
 920       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 921         continue;
 922       quals = cp_type_quals (src_type);
 923       if (client->quals & ~quals)
 924         continue;
 925       excess = quals & ~client->quals;
 926       if (!best || (excess_p && !excess))
 927         {
 928           best = fn;
 929           excess_p = excess;
 930         }
 931       else
 932         /* Ambiguous */
 933         return NULL_TREE;
 934     }
 935   return best;
 936 }
 937
 938 /* Implicitly declare the special function indicated by KIND, as a
 939    member of TYPE.  For copy constructors and assignment operators,
 940    CONST_P indicates whether these functions should take a const
 941    reference argument or a non-const reference.  */
 942
 943 tree
 944 implicitly_declare_fn (kind, type, const_p)
 945      special_function_kind kind;
 946      tree type;
 947      int const_p;
 948 {
 949   tree declspecs = NULL_TREE;
 950   tree fn, args = NULL_TREE;
 951   tree raises = empty_except_spec;
 952   int retref = 0;
 953   int has_parm = 0;
 954   tree name = constructor_name (TYPE_IDENTIFIER (type));
 955
 956   switch (kind)
 957     {
 958     case sfk_destructor:
 959       /* Destructor.  */
 960       name = build_nt (BIT_NOT_EXPR, name);
 961       args = void_list_node;
 962       raises = synthesize_exception_spec (type, &locate_dtor, 0);
 963       break;
 964
 965     case sfk_constructor:
 966       /* Default constructor.  */
 967       args = void_list_node;
 968       raises = synthesize_exception_spec (type, &locate_ctor, 0);
 969       break;
 970
 971     case sfk_copy_constructor:
 972     case sfk_assignment_operator:
 973     {
 974       struct copy_data data;
 975       tree argtype;
 976
 977       has_parm = 1;
 978       data.name = NULL;
 979       data.quals = 0;
 980       if (kind == sfk_assignment_operator)
 981         {
 982           retref = 1;
 983           declspecs = build_tree_list (NULL_TREE, type);
 984
 985           name = ansi_assopname (NOP_EXPR);
 986           data.name = name;
 987         }
 988       if (const_p)
 989         {
 990           data.quals = TYPE_QUAL_CONST;
 991           type = build_qualified_type (type, TYPE_QUAL_CONST);
 992         }
 993
 994       argtype = build_reference_type (type);
 995       args = build_tree_list (hash_tree_chain (argtype, NULL_TREE),
 996                               get_identifier ("_ctor_arg"));
 997       args = tree_cons (NULL_TREE, args, void_list_node);
 998
 999       raises = synthesize_exception_spec (type, &locate_copy, &data);
1000       break;
1001     }
1002     default:
1003       my_friendly_abort (59);
1004     }
1005
1006   TREE_PARMLIST (args) = 1;
1007
1008   {
1009     tree declarator = make_call_declarator (name, args, NULL_TREE, raises);
1010
1011     if (retref)
1012       declarator = build_nt (ADDR_EXPR, declarator);
1013
1014     fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
1015     if (has_parm)
1016       TREE_USED (FUNCTION_FIRST_USER_PARM (fn)) = 1;
1017   }
1018
1019   my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 20000408);
1020
1021   DECL_ARTIFICIAL (fn) = 1;
1022   DECL_NOT_REALLY_EXTERN (fn) = 1;
1023   DECL_DECLARED_INLINE_P (fn) = 1;
1024   DECL_INLINE (fn) = 1;
1025   defer_fn (fn);
1026
1027   return fn;
1028 }
1029
1030 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1031    as there are artificial parms in FN.  */
1032
1033 tree
1034 skip_artificial_parms_for (fn, list)
1035      tree fn, list;
1036 {
1037   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1038     list = TREE_CHAIN (list);
1039   else
1040     return list;
1041
1042   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1043     list = TREE_CHAIN (list);
1044   if (DECL_HAS_VTT_PARM_P (fn))
1045     list = TREE_CHAIN (list);
1046   return list;
1047 }