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.  (We can't just
 391        clear DECL_THUNK_P because that will confuse
 392        FNADDR_FROM_VTABLE_ENTRY and friends.)  */
 393     return;
 394
 395   /* Thunks are always addressable; they only appear in vtables.  */
 396   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 397
 398   /* Figure out what function is being thunked to.  It's referenced in
 399      this translation unit.  */
 400   function = TREE_OPERAND (fnaddr, 0);
 401   TREE_ADDRESSABLE (function) = 1;
 402   mark_used (function);
 403   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (function)) = 1;
 404   if (!emit_p)
 405     return;
 406
 407   delta = THUNK_DELTA (thunk_fndecl);
 408   vcall_offset = THUNK_VCALL_OFFSET (thunk_fndecl);
 409
 410   /* And, if we need to emit the thunk, it's used.  */
 411   mark_used (thunk_fndecl);
 412   /* This thunk is actually defined.  */
 413   DECL_EXTERNAL (thunk_fndecl) = 0;
 414
 415   if (flag_syntax_only)
 416     {
 417       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 418       return;
 419     }
 420
 421   push_to_top_level ();
 422
 423 #ifdef ASM_OUTPUT_MI_THUNK
 424   if (!vcall_offset)
 425     {
 426       const char *fnname;
 427       current_function_decl = thunk_fndecl;
 428       DECL_RESULT (thunk_fndecl)
 429         = build_decl (RESULT_DECL, 0, integer_type_node);
 430       fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
 431       init_function_start (thunk_fndecl, input_filename, lineno);
 432       current_function_is_thunk = 1;
 433       assemble_start_function (thunk_fndecl, fnname);
 434       ASM_OUTPUT_MI_THUNK (asm_out_file, thunk_fndecl, delta, function);
 435       assemble_end_function (thunk_fndecl, fnname);
 436       current_function_decl = 0;
 437       cfun = 0;
 438       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 439     }
 440   else
 441 #endif /* ASM_OUTPUT_MI_THUNK */
 442   {
 443   /* If we don't have the necessary macro for efficient thunks, generate a
 444      thunk function that just makes a call to the real function.
 445      Unfortunately, this doesn't work for varargs.  */
 446
 447     tree a, t;
 448
 449     if (varargs_function_p (function))
 450       cp_error ("generic thunk code fails for method `%#D' which uses `...'",
 451                 function);
 452
 453     /* Set up clone argument trees for the thunk.  */
 454     t = NULL_TREE;
 455     for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
 456       {
 457         tree x = copy_node (a);
 458         TREE_CHAIN (x) = t;
 459         DECL_CONTEXT (x) = thunk_fndecl;
 460         t = x;
 461       }
 462     a = nreverse (t);
 463     DECL_ARGUMENTS (thunk_fndecl) = a;
 464     DECL_RESULT (thunk_fndecl) = NULL_TREE;
 465
 466     start_function (NULL_TREE, thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
 467
 468     /* Adjust the this pointer by the constant.  */
 469     t = ssize_int (delta);
 470     t = fold (build (PLUS_EXPR, TREE_TYPE (a), a, t));
 471     /* If there's a vcall offset, look up that value in the vtable and
 472        adjust the `this' pointer again.  */
 473     if (vcall_offset && !integer_zerop (vcall_offset))
 474       {
 475         tree orig_this;
 476
 477         t = save_expr (t);
 478         orig_this = t;
 479         /* The vptr is always at offset zero in the object.  */
 480         t = build1 (NOP_EXPR,
 481                     build_pointer_type (build_pointer_type
 482                                         (vtable_entry_type)),
 483                     t);
 484         /* Form the vtable address.  */
 485         t = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (t)), t);
 486         /* Find the entry with the vcall offset.  */
 487         t = build (PLUS_EXPR, TREE_TYPE (t), t, vcall_offset);
 488         /* Calculate the offset itself.  */
 489         t = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (t)), t);
 490         /* Adjust the `this' pointer.  */
 491         t = fold (build (PLUS_EXPR,
 492                          TREE_TYPE (orig_this),
 493                          orig_this,
 494                          t));
 495       }
 496
 497     /* Build up the call to the real function.  */
 498     t = tree_cons (NULL_TREE, t, NULL_TREE);
 499     for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
 500       t = tree_cons (NULL_TREE, a, t);
 501     t = nreverse (t);
 502     t = build_call (function, t);
 503     if (VOID_TYPE_P (TREE_TYPE (t)))
 504       finish_expr_stmt (t);
 505     else
 506       finish_return_stmt (t);
 507
 508     /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
 509        create one.  */
 510     DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
 511     BLOCK_VARS (DECL_INITIAL (thunk_fndecl))
 512       = DECL_ARGUMENTS (thunk_fndecl);
 513
 514     /* Since we want to emit the thunk, we explicitly mark its name as
 515        referenced.  */
 516     TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (thunk_fndecl)) = 1;
 517
 518     expand_body (finish_function (0));
 519   }
 520
 521   pop_from_top_level ();
 522 }
 523 \f
 524 /* Code for synthesizing methods which have default semantics defined.  */
 525
 526 /* Generate code for default X(X&) constructor.  */
 527
 528 static void
 529 do_build_copy_constructor (fndecl)
 530      tree fndecl;
 531 {
 532   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
 533   tree t;
 534
 535   parm = convert_from_reference (parm);
 536
 537   if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
 538       && is_empty_class (current_class_type))
 539     /* Don't copy the padding byte; it might not have been allocated
 540        if *this is a base subobject.  */;
 541   else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
 542     {
 543       t = build (INIT_EXPR, void_type_node, current_class_ref, parm);
 544       finish_expr_stmt (t);
 545     }
 546   else
 547     {
 548       tree fields = TYPE_FIELDS (current_class_type);
 549       int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
 550       tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
 551       tree member_init_list = NULL_TREE;
 552       tree base_init_list = NULL_TREE;
 553       int cvquals = CP_TYPE_QUALS (TREE_TYPE (parm));
 554       int i;
 555
 556       /* Initialize all the base-classes with the parameter converted to
 557          their type so that we get their copy constructor and not another
 558          constructor that takes current_class_type.  */
 559       for (t = CLASSTYPE_VBASECLASSES (current_class_type); t;
 560            t = TREE_CHAIN (t))
 561         {
 562           tree type = BINFO_TYPE (TREE_VALUE (t));
 563           base_init_list = tree_cons (type, convert_lvalue (type, parm),
 564                                       base_init_list);
 565         }
 566
 567       for (i = 0; i < n_bases; ++i)
 568         {
 569           t = TREE_VEC_ELT (binfos, i);
 570           if (TREE_VIA_VIRTUAL (t))
 571             continue;
 572
 573           t = BINFO_TYPE (t);
 574           base_init_list = tree_cons (t, convert_lvalue (t, parm),
 575                                       base_init_list);
 576         }
 577
 578       for (; fields; fields = TREE_CHAIN (fields))
 579         {
 580           tree init;
 581           tree field = fields;
 582
 583           if (TREE_CODE (field) != FIELD_DECL)
 584             continue;
 585
 586           init = parm;
 587           if (DECL_NAME (field))
 588             {
 589               if (VFIELD_NAME_P (DECL_NAME (field)))
 590                 continue;
 591               if (VBASE_NAME_P (DECL_NAME (field)))
 592                 continue;
 593
 594               /* True for duplicate members.  */
 595               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 596                 continue;
 597             }
 598           else if ((t = TREE_TYPE (field)) != NULL_TREE
 599                    && ANON_AGGR_TYPE_P (t)
 600                    && TYPE_FIELDS (t) != NULL_TREE)
 601             /* Just use the field; anonymous types can't have
 602                nontrivial copy ctors or assignment ops.  */;
 603           else
 604             continue;
 605
 606           init = build (COMPONENT_REF,
 607                         build_qualified_type (TREE_TYPE (field), cvquals),
 608                         init, field);
 609           init = build_tree_list (NULL_TREE, init);
 610
 611           member_init_list
 612             = tree_cons (field, init, member_init_list);
 613         }
 614       member_init_list = nreverse (member_init_list);
 615       base_init_list = nreverse (base_init_list);
 616       setup_vtbl_ptr (member_init_list, base_init_list);
 617     }
 618 }
 619
 620 static void
 621 do_build_assign_ref (fndecl)
 622      tree fndecl;
 623 {
 624   tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
 625   tree compound_stmt;
 626
 627   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
 628   parm = convert_from_reference (parm);
 629
 630   if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
 631       && is_empty_class (current_class_type))
 632     /* Don't copy the padding byte; it might not have been allocated
 633        if *this is a base subobject.  */;
 634   else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
 635     {
 636       tree t = build (MODIFY_EXPR, void_type_node, current_class_ref, parm);
 637       finish_expr_stmt (t);
 638     }
 639   else
 640     {
 641       tree fields = TYPE_FIELDS (current_class_type);
 642       int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
 643       tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
 644       int cvquals = CP_TYPE_QUALS (TREE_TYPE (parm));
 645       int i;
 646
 647       for (i = 0; i < n_bases; ++i)
 648         {
 649           tree basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
 650           tree p = convert_lvalue (basetype, parm);
 651           p = build_member_call (basetype, ansi_assopname (NOP_EXPR),
 652                                  build_tree_list (NULL_TREE, p));
 653           finish_expr_stmt (p);
 654         }
 655       for (; fields; fields = TREE_CHAIN (fields))
 656         {
 657           tree comp, init, t;
 658           tree field = fields;
 659
 660           if (TREE_CODE (field) != FIELD_DECL)
 661             continue;
 662
 663           if (CP_TYPE_CONST_P (TREE_TYPE (field)))
 664             {
 665               cp_error ("non-static const member `%#D', can't use default assignment operator", field);
 666               continue;
 667             }
 668           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 669             {
 670               cp_error ("non-static reference member `%#D', can't use default assignment operator", field);
 671               continue;
 672             }
 673
 674           comp = current_class_ref;
 675           init = parm;
 676
 677           if (DECL_NAME (field))
 678             {
 679               if (VFIELD_NAME_P (DECL_NAME (field)))
 680                 continue;
 681               if (VBASE_NAME_P (DECL_NAME (field)))
 682                 continue;
 683
 684               /* True for duplicate members.  */
 685               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 686                 continue;
 687             }
 688           else if ((t = TREE_TYPE (field)) != NULL_TREE
 689                    && ANON_AGGR_TYPE_P (t)
 690                    && TYPE_FIELDS (t) != NULL_TREE)
 691             /* Just use the field; anonymous types can't have
 692                nontrivial copy ctors or assignment ops.  */;
 693           else
 694             continue;
 695
 696           comp = build (COMPONENT_REF, TREE_TYPE (field), comp, field);
 697           init = build (COMPONENT_REF,
 698                         build_qualified_type (TREE_TYPE (field), cvquals),
 699                         init, field);
 700
 701           if (DECL_NAME (field))
 702             finish_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
 703           else
 704             finish_expr_stmt (build (MODIFY_EXPR, TREE_TYPE (comp), comp,
 705                                      init));
 706         }
 707     }
 708   finish_return_stmt (current_class_ref);
 709   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
 710 }
 711
 712 void
 713 synthesize_method (fndecl)
 714      tree fndecl;
 715 {
 716   int nested = (current_function_decl != NULL_TREE);
 717   tree context = decl_function_context (fndecl);
 718   int need_body = 1;
 719
 720   if (at_eof)
 721     import_export_decl (fndecl);
 722
 723   /* If we've been asked to synthesize a clone, just synthesize the
 724      cloned function instead.  Doing so will automatically fill in the
 725      body for the clone.  */
 726   if (DECL_CLONED_FUNCTION_P (fndecl))
 727     {
 728       synthesize_method (DECL_CLONED_FUNCTION (fndecl));
 729       return;
 730     }
 731
 732   if (! context)
 733     push_to_top_level ();
 734   else if (nested)
 735     push_function_context_to (context);
 736
 737   /* Put the function definition at the position where it is needed,
 738      rather than within the body of the class.  That way, an error
 739      during the generation of the implicit body points at the place
 740      where the attempt to generate the function occurs, giving the
 741      user a hint as to why we are attempting to generate the
 742      function. */
 743   DECL_SOURCE_LINE (fndecl) = lineno;
 744   DECL_SOURCE_FILE (fndecl) = input_filename;
 745
 746   interface_unknown = 1;
 747   start_function (NULL_TREE, fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 748   clear_last_expr ();
 749
 750   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 751     {
 752       do_build_assign_ref (fndecl);
 753       need_body = 0;
 754     }
 755   else if (DECL_DESTRUCTOR_P (fndecl))
 756     setup_vtbl_ptr (NULL_TREE, NULL_TREE);
 757   else
 758     {
 759       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 760       if (arg_chain != void_list_node)
 761         do_build_copy_constructor (fndecl);
 762       else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
 763         setup_vtbl_ptr (NULL_TREE, NULL_TREE);
 764     }
 765
 766   /* If we haven't yet generated the body of the function, just
 767      generate an empty compound statement.  */
 768   if (need_body)
 769     {
 770       tree compound_stmt;
 771       compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
 772       finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
 773     }
 774
 775   expand_body (finish_function (0));
 776
 777   extract_interface_info ();
 778   if (! context)
 779     pop_from_top_level ();
 780   else if (nested)
 781     pop_function_context_from (context);
 782 }
 783
 784 /* Use EXTRACTOR to locate the relevant function called for each base &
 785    class field of TYPE. CLIENT allows additional information to be passed
 786    to EXTRACTOR.  Generates the union of all exceptions generated by
 787    those functions.  */
 788
 789 static tree
 790 synthesize_exception_spec (type, extractor, client)
 791      tree type;
 792      tree (*extractor) (tree, void *);
 793      void *client;
 794 {
 795   tree raises = empty_except_spec;
 796   tree fields = TYPE_FIELDS (type);
 797   int i, n_bases = CLASSTYPE_N_BASECLASSES (type);
 798   tree binfos = TYPE_BINFO_BASETYPES (type);
 799
 800   for (i = 0; i != n_bases; i++)
 801     {
 802       tree base = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
 803       tree fn = (*extractor) (base, client);
 804       if (fn)
 805         {
 806           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 807
 808           raises = merge_exception_specifiers (raises, fn_raises);
 809         }
 810     }
 811   for (; fields; fields = TREE_CHAIN (fields))
 812     {
 813       tree type = TREE_TYPE (fields);
 814       tree fn;
 815
 816       if (TREE_CODE (fields) != FIELD_DECL)
 817         continue;
 818       while (TREE_CODE (type) == ARRAY_TYPE)
 819         type = TREE_TYPE (type);
 820       if (TREE_CODE (type) != RECORD_TYPE)
 821         continue;
 822
 823       fn = (*extractor) (type, client);
 824       if (fn)
 825         {
 826           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 827
 828           raises = merge_exception_specifiers (raises, fn_raises);
 829         }
 830     }
 831   return raises;
 832 }
 833
 834 /* Locate the dtor of TYPE.  */
 835
 836 static tree
 837 locate_dtor (type, client)
 838      tree type;
 839      void *client ATTRIBUTE_UNUSED;
 840 {
 841   tree fns;
 842
 843   if (!TYPE_HAS_DESTRUCTOR (type))
 844     return NULL_TREE;
 845   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 846                       CLASSTYPE_DESTRUCTOR_SLOT);
 847   return fns;
 848 }
 849
 850 /* Locate the default ctor of TYPE.  */
 851
 852 static tree
 853 locate_ctor (type, client)
 854      tree type;
 855      void *client ATTRIBUTE_UNUSED;
 856 {
 857   tree fns;
 858
 859   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 860     return NULL_TREE;
 861
 862   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 863                       CLASSTYPE_CONSTRUCTOR_SLOT);
 864   for (; fns; fns = OVL_NEXT (fns))
 865     {
 866       tree fn = OVL_CURRENT (fns);
 867       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 868
 869       if (sufficient_parms_p (TREE_CHAIN (parms)))
 870         return fn;
 871     }
 872   return NULL_TREE;
 873 }
 874
 875 struct copy_data
 876 {
 877   tree name;
 878   int quals;
 879 };
 880
 881 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
 882    points to a COPY_DATA holding the name (NULL for the ctor)
 883    and desired qualifiers of the source operand.  */
 884
 885 static tree
 886 locate_copy (type, client_)
 887      tree type;
 888      void *client_;
 889 {
 890   struct copy_data *client = (struct copy_data *)client_;
 891   tree fns;
 892   int ix = -1;
 893   tree best = NULL_TREE;
 894   int excess_p = 0;
 895
 896   if (client->name)
 897     {
 898       if (TYPE_HAS_ASSIGN_REF (type))
 899         ix = lookup_fnfields_1 (type, client->name);
 900     }
 901   else if (TYPE_HAS_INIT_REF (type))
 902     ix = CLASSTYPE_CONSTRUCTOR_SLOT;
 903   if (ix < 0)
 904     return NULL_TREE;
 905   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), ix);
 906
 907   for (; fns; fns = OVL_NEXT (fns))
 908     {
 909       tree fn = OVL_CURRENT (fns);
 910       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 911       tree src_type;
 912       int excess;
 913       int quals;
 914
 915       parms = TREE_CHAIN (parms);
 916       if (!parms)
 917         continue;
 918       src_type = TREE_VALUE (parms);
 919       if (TREE_CODE (src_type) == REFERENCE_TYPE)
 920         src_type = TREE_TYPE (src_type);
 921       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 922         continue;
 923       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 924         continue;
 925       quals = CP_TYPE_QUALS (src_type);
 926       if (client->quals & ~quals)
 927         continue;
 928       excess = quals & ~client->quals;
 929       if (!best || (excess_p && !excess))
 930         {
 931           best = fn;
 932           excess_p = excess;
 933         }
 934       else
 935         /* Ambiguous */
 936         return NULL_TREE;
 937     }
 938   return best;
 939 }
 940
 941 /* Implicitly declare the special function indicated by KIND, as a
 942    member of TYPE.  For copy constructors and assignment operators,
 943    CONST_P indicates whether these functions should take a const
 944    reference argument or a non-const reference.  */
 945
 946 tree
 947 implicitly_declare_fn (kind, type, const_p)
 948      special_function_kind kind;
 949      tree type;
 950      int const_p;
 951 {
 952   tree declspecs = NULL_TREE;
 953   tree fn, args = NULL_TREE;
 954   tree raises = empty_except_spec;
 955   int retref = 0;
 956   int has_parm = 0;
 957   tree name = constructor_name (TYPE_IDENTIFIER (type));
 958
 959   switch (kind)
 960     {
 961     case sfk_destructor:
 962       /* Destructor.  */
 963       name = build_nt (BIT_NOT_EXPR, name);
 964       args = void_list_node;
 965       raises = synthesize_exception_spec (type, &locate_dtor, 0);
 966       break;
 967
 968     case sfk_constructor:
 969       /* Default constructor.  */
 970       args = void_list_node;
 971       raises = synthesize_exception_spec (type, &locate_ctor, 0);
 972       break;
 973
 974     case sfk_copy_constructor:
 975     case sfk_assignment_operator:
 976     {
 977       struct copy_data data;
 978       tree argtype;
 979
 980       has_parm = 1;
 981       data.name = NULL;
 982       data.quals = 0;
 983       if (kind == sfk_assignment_operator)
 984         {
 985           retref = 1;
 986           declspecs = build_tree_list (NULL_TREE, type);
 987
 988           name = ansi_assopname (NOP_EXPR);
 989           data.name = name;
 990         }
 991       if (const_p)
 992         {
 993           data.quals = TYPE_QUAL_CONST;
 994           type = build_qualified_type (type, TYPE_QUAL_CONST);
 995         }
 996
 997       argtype = build_reference_type (type);
 998       args = build_tree_list (hash_tree_chain (argtype, NULL_TREE),
 999                               get_identifier ("_ctor_arg"));
1000       args = tree_cons (NULL_TREE, args, void_list_node);
1001
1002       raises = synthesize_exception_spec (type, &locate_copy, &data);
1003       break;
1004     }
1005     default:
1006       my_friendly_abort (59);
1007     }
1008
1009   TREE_PARMLIST (args) = 1;
1010
1011   {
1012     tree declarator = make_call_declarator (name, args, NULL_TREE, raises);
1013
1014     if (retref)
1015       declarator = build_nt (ADDR_EXPR, declarator);
1016
1017     fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
1018     if (has_parm)
1019       TREE_USED (FUNCTION_FIRST_USER_PARM (fn)) = 1;
1020   }
1021
1022   my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 20000408);
1023
1024   DECL_ARTIFICIAL (fn) = 1;
1025   DECL_NOT_REALLY_EXTERN (fn) = 1;
1026   DECL_DECLARED_INLINE_P (fn) = 1;
1027   DECL_INLINE (fn) = 1;
1028   defer_fn (fn);
1029
1030   return fn;
1031 }
1032
1033 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1034    as there are artificial parms in FN.  */
1035
1036 tree
1037 skip_artificial_parms_for (fn, list)
1038      tree fn, list;
1039 {
1040   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1041     list = TREE_CHAIN (list);
1042   else
1043     return list;
1044
1045   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1046     list = TREE_CHAIN (list);
1047   if (DECL_HAS_VTT_PARM_P (fn))
1048     list = TREE_CHAIN (list);
1049   return list;
1050 }