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
 558          to their type so that we get their copy constructor and not
 559          another constructor that takes current_class_type.  We must
 560          deal with the binfo's directly as a direct base might be
 561          inaccessible due to ambiguity.  */
 562       for (t = CLASSTYPE_VBASECLASSES (current_class_type); t;
 563            t = TREE_CHAIN (t))
 564         {
 565           tree binfo = TREE_VALUE (t);
 566
 567           base_init_list = tree_cons (binfo,
 568                                       build_base_path (PLUS_EXPR, parm,
 569                                                        binfo, 1),
 570                                       base_init_list);
 571         }
 572
 573       for (i = 0; i < n_bases; ++i)
 574         {
 575           tree binfo = TREE_VEC_ELT (binfos, i);
 576           if (TREE_VIA_VIRTUAL (binfo))
 577             continue;
 578
 579           base_init_list = tree_cons (binfo,
 580                                       build_base_path (PLUS_EXPR, parm,
 581                                                        binfo, 1),
 582                                       base_init_list);
 583         }
 584
 585       for (; fields; fields = TREE_CHAIN (fields))
 586         {
 587           tree init;
 588           tree field = fields;
 589
 590           if (TREE_CODE (field) != FIELD_DECL)
 591             continue;
 592
 593           init = parm;
 594           if (DECL_NAME (field))
 595             {
 596               if (VFIELD_NAME_P (DECL_NAME (field)))
 597                 continue;
 598
 599               /* True for duplicate members.  */
 600               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 601                 continue;
 602             }
 603           else if ((t = TREE_TYPE (field)) != NULL_TREE
 604                    && ANON_AGGR_TYPE_P (t)
 605                    && TYPE_FIELDS (t) != NULL_TREE)
 606             /* Just use the field; anonymous types can't have
 607                nontrivial copy ctors or assignment ops.  */;
 608           else
 609             continue;
 610
 611           init = build (COMPONENT_REF,
 612                         build_qualified_type (TREE_TYPE (field), cvquals),
 613                         init, field);
 614           init = build_tree_list (NULL_TREE, init);
 615
 616           member_init_list
 617             = tree_cons (field, init, member_init_list);
 618         }
 619       member_init_list = nreverse (member_init_list);
 620       base_init_list = nreverse (base_init_list);
 621       setup_vtbl_ptr (member_init_list, base_init_list);
 622     }
 623 }
 624
 625 static void
 626 do_build_assign_ref (fndecl)
 627      tree fndecl;
 628 {
 629   tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
 630   tree compound_stmt;
 631
 632   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
 633   parm = convert_from_reference (parm);
 634
 635   if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
 636       && is_empty_class (current_class_type))
 637     /* Don't copy the padding byte; it might not have been allocated
 638        if *this is a base subobject.  */;
 639   else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
 640     {
 641       tree t = build (MODIFY_EXPR, void_type_node, current_class_ref, parm);
 642       finish_expr_stmt (t);
 643     }
 644   else
 645     {
 646       tree fields = TYPE_FIELDS (current_class_type);
 647       int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
 648       tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
 649       int cvquals = cp_type_quals (TREE_TYPE (parm));
 650       int i;
 651
 652       for (i = 0; i < n_bases; ++i)
 653         {
 654           /* We must deal with the binfo's directly as a direct base
 655              might be inaccessible due to ambiguity.  */
 656           tree binfo = TREE_VEC_ELT (binfos, i);
 657           tree src = build_base_path (PLUS_EXPR, parm, binfo, 1);
 658           tree dst = build_base_path (PLUS_EXPR, current_class_ref, binfo, 1);
 659
 660           tree expr = build_method_call (dst,
 661                                          ansi_assopname (NOP_EXPR),
 662                                          build_tree_list (NULL_TREE, src),
 663                                          NULL,
 664                                          LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
 665           finish_expr_stmt (expr);
 666         }
 667       for (; fields; fields = TREE_CHAIN (fields))
 668         {
 669           tree comp, init, t;
 670           tree field = fields;
 671
 672           if (TREE_CODE (field) != FIELD_DECL)
 673             continue;
 674
 675           if (CP_TYPE_CONST_P (TREE_TYPE (field)))
 676             {
 677               cp_error ("non-static const member `%#D', can't use default assignment operator", field);
 678               continue;
 679             }
 680           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 681             {
 682               cp_error ("non-static reference member `%#D', can't use default assignment operator", field);
 683               continue;
 684             }
 685
 686           comp = current_class_ref;
 687           init = parm;
 688
 689           if (DECL_NAME (field))
 690             {
 691               if (VFIELD_NAME_P (DECL_NAME (field)))
 692                 continue;
 693
 694               /* True for duplicate members.  */
 695               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 696                 continue;
 697             }
 698           else if ((t = TREE_TYPE (field)) != NULL_TREE
 699                    && ANON_AGGR_TYPE_P (t)
 700                    && TYPE_FIELDS (t) != NULL_TREE)
 701             /* Just use the field; anonymous types can't have
 702                nontrivial copy ctors or assignment ops.  */;
 703           else
 704             continue;
 705
 706           comp = build (COMPONENT_REF, TREE_TYPE (field), comp, field);
 707           init = build (COMPONENT_REF,
 708                         build_qualified_type (TREE_TYPE (field), cvquals),
 709                         init, field);
 710
 711           if (DECL_NAME (field))
 712             finish_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
 713           else
 714             finish_expr_stmt (build (MODIFY_EXPR, TREE_TYPE (comp), comp,
 715                                      init));
 716         }
 717     }
 718   finish_return_stmt (current_class_ref);
 719   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
 720 }
 721
 722 void
 723 synthesize_method (fndecl)
 724      tree fndecl;
 725 {
 726   int nested = (current_function_decl != NULL_TREE);
 727   tree context = decl_function_context (fndecl);
 728   int need_body = 1;
 729
 730   if (at_eof)
 731     import_export_decl (fndecl);
 732
 733   /* If we've been asked to synthesize a clone, just synthesize the
 734      cloned function instead.  Doing so will automatically fill in the
 735      body for the clone.  */
 736   if (DECL_CLONED_FUNCTION_P (fndecl))
 737     {
 738       synthesize_method (DECL_CLONED_FUNCTION (fndecl));
 739       return;
 740     }
 741
 742   if (! context)
 743     push_to_top_level ();
 744   else if (nested)
 745     push_function_context_to (context);
 746
 747   /* Put the function definition at the position where it is needed,
 748      rather than within the body of the class.  That way, an error
 749      during the generation of the implicit body points at the place
 750      where the attempt to generate the function occurs, giving the
 751      user a hint as to why we are attempting to generate the
 752      function. */
 753   DECL_SOURCE_LINE (fndecl) = lineno;
 754   DECL_SOURCE_FILE (fndecl) = input_filename;
 755
 756   interface_unknown = 1;
 757   start_function (NULL_TREE, fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 758   clear_last_expr ();
 759
 760   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 761     {
 762       do_build_assign_ref (fndecl);
 763       need_body = 0;
 764     }
 765   else if (DECL_DESTRUCTOR_P (fndecl))
 766     setup_vtbl_ptr (NULL_TREE, NULL_TREE);
 767   else
 768     {
 769       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 770       if (arg_chain != void_list_node)
 771         do_build_copy_constructor (fndecl);
 772       else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
 773         setup_vtbl_ptr (NULL_TREE, NULL_TREE);
 774     }
 775
 776   /* If we haven't yet generated the body of the function, just
 777      generate an empty compound statement.  */
 778   if (need_body)
 779     {
 780       tree compound_stmt;
 781       compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
 782       finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
 783     }
 784
 785   expand_body (finish_function (0));
 786
 787   extract_interface_info ();
 788   if (! context)
 789     pop_from_top_level ();
 790   else if (nested)
 791     pop_function_context_from (context);
 792 }
 793
 794 /* Use EXTRACTOR to locate the relevant function called for each base &
 795    class field of TYPE. CLIENT allows additional information to be passed
 796    to EXTRACTOR.  Generates the union of all exceptions generated by
 797    those functions.  */
 798
 799 static tree
 800 synthesize_exception_spec (type, extractor, client)
 801      tree type;
 802      tree (*extractor) (tree, void *);
 803      void *client;
 804 {
 805   tree raises = empty_except_spec;
 806   tree fields = TYPE_FIELDS (type);
 807   int i, n_bases = CLASSTYPE_N_BASECLASSES (type);
 808   tree binfos = TYPE_BINFO_BASETYPES (type);
 809
 810   for (i = 0; i != n_bases; i++)
 811     {
 812       tree base = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
 813       tree fn = (*extractor) (base, client);
 814       if (fn)
 815         {
 816           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 817
 818           raises = merge_exception_specifiers (raises, fn_raises);
 819         }
 820     }
 821   for (; fields; fields = TREE_CHAIN (fields))
 822     {
 823       tree type = TREE_TYPE (fields);
 824       tree fn;
 825
 826       if (TREE_CODE (fields) != FIELD_DECL)
 827         continue;
 828       while (TREE_CODE (type) == ARRAY_TYPE)
 829         type = TREE_TYPE (type);
 830       if (TREE_CODE (type) != RECORD_TYPE)
 831         continue;
 832
 833       fn = (*extractor) (type, client);
 834       if (fn)
 835         {
 836           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 837
 838           raises = merge_exception_specifiers (raises, fn_raises);
 839         }
 840     }
 841   return raises;
 842 }
 843
 844 /* Locate the dtor of TYPE.  */
 845
 846 static tree
 847 locate_dtor (type, client)
 848      tree type;
 849      void *client ATTRIBUTE_UNUSED;
 850 {
 851   tree fns;
 852
 853   if (!TYPE_HAS_DESTRUCTOR (type))
 854     return NULL_TREE;
 855   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 856                       CLASSTYPE_DESTRUCTOR_SLOT);
 857   return fns;
 858 }
 859
 860 /* Locate the default ctor of TYPE.  */
 861
 862 static tree
 863 locate_ctor (type, client)
 864      tree type;
 865      void *client ATTRIBUTE_UNUSED;
 866 {
 867   tree fns;
 868
 869   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 870     return NULL_TREE;
 871
 872   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 873                       CLASSTYPE_CONSTRUCTOR_SLOT);
 874   for (; fns; fns = OVL_NEXT (fns))
 875     {
 876       tree fn = OVL_CURRENT (fns);
 877       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 878
 879       if (sufficient_parms_p (TREE_CHAIN (parms)))
 880         return fn;
 881     }
 882   return NULL_TREE;
 883 }
 884
 885 struct copy_data
 886 {
 887   tree name;
 888   int quals;
 889 };
 890
 891 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
 892    points to a COPY_DATA holding the name (NULL for the ctor)
 893    and desired qualifiers of the source operand.  */
 894
 895 static tree
 896 locate_copy (type, client_)
 897      tree type;
 898      void *client_;
 899 {
 900   struct copy_data *client = (struct copy_data *)client_;
 901   tree fns;
 902   int ix = -1;
 903   tree best = NULL_TREE;
 904   int excess_p = 0;
 905
 906   if (client->name)
 907     {
 908       if (TYPE_HAS_ASSIGN_REF (type))
 909         ix = lookup_fnfields_1 (type, client->name);
 910     }
 911   else if (TYPE_HAS_INIT_REF (type))
 912     ix = CLASSTYPE_CONSTRUCTOR_SLOT;
 913   if (ix < 0)
 914     return NULL_TREE;
 915   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), ix);
 916
 917   for (; fns; fns = OVL_NEXT (fns))
 918     {
 919       tree fn = OVL_CURRENT (fns);
 920       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 921       tree src_type;
 922       int excess;
 923       int quals;
 924
 925       parms = TREE_CHAIN (parms);
 926       if (!parms)
 927         continue;
 928       src_type = TREE_VALUE (parms);
 929       if (TREE_CODE (src_type) == REFERENCE_TYPE)
 930         src_type = TREE_TYPE (src_type);
 931       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 932         continue;
 933       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 934         continue;
 935       quals = cp_type_quals (src_type);
 936       if (client->quals & ~quals)
 937         continue;
 938       excess = quals & ~client->quals;
 939       if (!best || (excess_p && !excess))
 940         {
 941           best = fn;
 942           excess_p = excess;
 943         }
 944       else
 945         /* Ambiguous */
 946         return NULL_TREE;
 947     }
 948   return best;
 949 }
 950
 951 /* Implicitly declare the special function indicated by KIND, as a
 952    member of TYPE.  For copy constructors and assignment operators,
 953    CONST_P indicates whether these functions should take a const
 954    reference argument or a non-const reference.  */
 955
 956 tree
 957 implicitly_declare_fn (kind, type, const_p)
 958      special_function_kind kind;
 959      tree type;
 960      int const_p;
 961 {
 962   tree declspecs = NULL_TREE;
 963   tree fn, args = NULL_TREE;
 964   tree raises = empty_except_spec;
 965   int retref = 0;
 966   int has_parm = 0;
 967   tree name = constructor_name (TYPE_IDENTIFIER (type));
 968
 969   switch (kind)
 970     {
 971     case sfk_destructor:
 972       /* Destructor.  */
 973       name = build_nt (BIT_NOT_EXPR, name);
 974       args = void_list_node;
 975       raises = synthesize_exception_spec (type, &locate_dtor, 0);
 976       break;
 977
 978     case sfk_constructor:
 979       /* Default constructor.  */
 980       args = void_list_node;
 981       raises = synthesize_exception_spec (type, &locate_ctor, 0);
 982       break;
 983
 984     case sfk_copy_constructor:
 985     case sfk_assignment_operator:
 986     {
 987       struct copy_data data;
 988       tree argtype;
 989
 990       has_parm = 1;
 991       data.name = NULL;
 992       data.quals = 0;
 993       if (kind == sfk_assignment_operator)
 994         {
 995           retref = 1;
 996           declspecs = build_tree_list (NULL_TREE, type);
 997
 998           name = ansi_assopname (NOP_EXPR);
 999           data.name = name;
1000         }
1001       if (const_p)
1002         {
1003           data.quals = TYPE_QUAL_CONST;
1004           type = build_qualified_type (type, TYPE_QUAL_CONST);
1005         }
1006
1007       argtype = build_reference_type (type);
1008       args = build_tree_list (hash_tree_chain (argtype, NULL_TREE),
1009                               get_identifier ("_ctor_arg"));
1010       args = tree_cons (NULL_TREE, args, void_list_node);
1011
1012       raises = synthesize_exception_spec (type, &locate_copy, &data);
1013       break;
1014     }
1015     default:
1016       my_friendly_abort (59);
1017     }
1018
1019   TREE_PARMLIST (args) = 1;
1020
1021   {
1022     tree declarator = make_call_declarator (name, args, NULL_TREE, raises);
1023
1024     if (retref)
1025       declarator = build_nt (ADDR_EXPR, declarator);
1026
1027     fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
1028     if (has_parm)
1029       TREE_USED (FUNCTION_FIRST_USER_PARM (fn)) = 1;
1030   }
1031
1032   my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 20000408);
1033
1034   DECL_ARTIFICIAL (fn) = 1;
1035   DECL_NOT_REALLY_EXTERN (fn) = 1;
1036   DECL_DECLARED_INLINE_P (fn) = 1;
1037   DECL_INLINE (fn) = 1;
1038   defer_fn (fn);
1039
1040   return fn;
1041 }
1042
1043 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1044    as there are artificial parms in FN.  */
1045
1046 tree
1047 skip_artificial_parms_for (fn, list)
1048      tree fn, list;
1049 {
1050   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1051     list = TREE_CHAIN (list);
1052   else
1053     return list;
1054
1055   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1056     list = TREE_CHAIN (list);
1057   if (DECL_HAS_VTT_PARM_P (fn))
1058     list = TREE_CHAIN (list);
1059   return list;
1060 }