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