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, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC 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 GCC 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 GCC; 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 "coretypes.h"
  29 #include "tm.h"
  30 #include "tree.h"
  31 #include "cp-tree.h"
  32 #include "rtl.h"
  33 #include "expr.h"
  34 #include "output.h"
  35 #include "flags.h"
  36 #include "toplev.h"
  37 #include "tm_p.h"
  38 #include "target.h"
  39
  40 /* Various flags to control the mangling process.  */
  41
  42 enum mangling_flags
  43 {
  44   /* No flags.  */
  45   mf_none = 0,
  46   /* The thing we are presently mangling is part of a template type,
  47      rather than a fully instantiated type.  Therefore, we may see
  48      complex expressions where we would normally expect to see a
  49      simple integer constant.  */
  50   mf_maybe_uninstantiated = 1,
  51   /* When mangling a numeric value, use the form `_XX_' (instead of
  52      just `XX') if the value has more than one digit.  */
  53   mf_use_underscores_around_value = 2
  54 };
  55
  56 typedef enum mangling_flags mangling_flags;
  57
  58 static tree thunk_adjust (tree, bool, HOST_WIDE_INT, tree);
  59 static void do_build_assign_ref (tree);
  60 static void do_build_copy_constructor (tree);
  61 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *);
  62 static tree locate_dtor (tree, void *);
  63 static tree locate_ctor (tree, void *);
  64 static tree locate_copy (tree, void *);
  65 #ifdef ASM_OUTPUT_DEF
  66 static tree make_alias_for_thunk (tree);
  67 #endif
  68
  69 /* Called once to initialize method.c.  */
  70
  71 void
  72 init_method (void)
  73 {
  74   init_mangle ();
  75 }
  76
  77 \f
  78 /* Set the mangled name (DECL_ASSEMBLER_NAME) for DECL.  */
  79
  80 void
  81 set_mangled_name_for_decl (tree decl)
  82 {
  83   if (processing_template_decl)
  84     /* There's no need to mangle the name of a template function.  */
  85     return;
  86
  87   mangle_decl (decl);
  88 }
  89
  90 \f
  91 /* Return a this or result adjusting thunk to FUNCTION.  THIS_ADJUSTING
  92    indicates whether it is a this or result adjusting thunk.
  93    FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
  94    (see thunk_adjust).  VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
  95    never is.  VIRTUAL_OFFSET is the /index/ into the vtable for this
  96    adjusting thunks, we scale it to a byte offset. For covariant
  97    thunks VIRTUAL_OFFSET is the virtual binfo.  You must post process
  98    the returned thunk with finish_thunk.  */
  99
 100 tree
 101 make_thunk (tree function, bool this_adjusting,
 102             tree fixed_offset, tree virtual_offset)
 103 {
 104   HOST_WIDE_INT d;
 105   tree thunk;
 106
 107   my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 20021025);
 108   /* We can have this thunks to covariant thunks, but not vice versa.  */
 109   my_friendly_assert (!DECL_THIS_THUNK_P (function), 20021127);
 110   my_friendly_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting,
 111                       20031123);
 112
 113   /* Scale the VIRTUAL_OFFSET to be in terms of bytes.  */
 114   if (this_adjusting && virtual_offset)
 115     virtual_offset
 116       = size_binop (MULT_EXPR,
 117                     virtual_offset,
 118                     convert (ssizetype,
 119                              TYPE_SIZE_UNIT (vtable_entry_type)));
 120
 121   d = tree_low_cst (fixed_offset, 0);
 122
 123   /* See if we already have the thunk in question.  For this_adjusting
 124      thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
 125      will be a BINFO.  */
 126   for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
 127     if (DECL_THIS_THUNK_P (thunk) == this_adjusting
 128         && THUNK_FIXED_OFFSET (thunk) == d
 129         && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
 130         && (!virtual_offset
 131             || (this_adjusting
 132                 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
 133                                       virtual_offset)
 134                 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
 135       return thunk;
 136
 137   /* All thunks must be created before FUNCTION is actually emitted;
 138      the ABI requires that all thunks be emitted together with the
 139      function to which they transfer control.  */
 140   my_friendly_assert (!TREE_ASM_WRITTEN (function), 20021025);
 141   /* Likewise, we can only be adding thunks to a function declared in
 142      the class currently being laid out.  */
 143   my_friendly_assert (TYPE_SIZE (DECL_CONTEXT (function))
 144                       && TYPE_BEING_DEFINED (DECL_CONTEXT (function)),
 145                       20031211);
 146
 147   thunk = build_decl (FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
 148   DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
 149   cxx_dup_lang_specific_decl (thunk);
 150   DECL_THUNKS (thunk) = NULL_TREE;
 151
 152   DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
 153   TREE_READONLY (thunk) = TREE_READONLY (function);
 154   TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
 155   TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
 156   if (flag_weak)
 157     comdat_linkage (thunk);
 158   SET_DECL_THUNK_P (thunk, this_adjusting);
 159   THUNK_TARGET (thunk) = function;
 160   THUNK_FIXED_OFFSET (thunk) = d;
 161   THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
 162   THUNK_ALIAS (thunk) = NULL_TREE;
 163
 164   /* The thunk itself is not a constructor or destructor, even if
 165      the thing it is thunking to is.  */
 166   DECL_INTERFACE_KNOWN (thunk) = 1;
 167   DECL_NOT_REALLY_EXTERN (thunk) = 1;
 168   DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
 169   DECL_DESTRUCTOR_P (thunk) = 0;
 170   DECL_CONSTRUCTOR_P (thunk) = 0;
 171   /* And neither is it a clone.  */
 172   DECL_CLONED_FUNCTION (thunk) = NULL_TREE;
 173   DECL_EXTERNAL (thunk) = 1;
 174   DECL_ARTIFICIAL (thunk) = 1;
 175   /* Even if this thunk is a member of a local class, we don't
 176      need a static chain.  */
 177   DECL_NO_STATIC_CHAIN (thunk) = 1;
 178   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
 179   DECL_PENDING_INLINE_P (thunk) = 0;
 180   DECL_INLINE (thunk) = 0;
 181   DECL_DECLARED_INLINE_P (thunk) = 0;
 182   /* Nor has it been deferred.  */
 183   DECL_DEFERRED_FN (thunk) = 0;
 184
 185   /* Add it to the list of thunks associated with FUNCTION.  */
 186   TREE_CHAIN (thunk) = DECL_THUNKS (function);
 187   DECL_THUNKS (function) = thunk;
 188
 189   return thunk;
 190 }
 191
 192 /* Finish THUNK, a thunk decl.  */
 193
 194 void
 195 finish_thunk (tree thunk)
 196 {
 197   tree function, name;
 198   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
 199   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
 200
 201   my_friendly_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk), 20021127);
 202   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
 203     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 204   function = THUNK_TARGET (thunk);
 205   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
 206                        fixed_offset, virtual_offset);
 207
 208   /* We can end up with declarations of (logically) different
 209      covariant thunks, that do identical adjustments.  The two thunks
 210      will be adjusting between within different hierarchies, which
 211      happen to have the same layout.  We must nullify one of them to
 212      refer to the other.  */
 213   if (DECL_RESULT_THUNK_P (thunk))
 214     {
 215       tree cov_probe;
 216
 217       for (cov_probe = DECL_THUNKS (function);
 218            cov_probe; cov_probe = TREE_CHAIN (cov_probe))
 219         if (DECL_NAME (cov_probe) == name)
 220           {
 221             my_friendly_assert (!DECL_THUNKS (thunk), 20031023);
 222             THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
 223                                    ? THUNK_ALIAS (cov_probe) : cov_probe);
 224             break;
 225           }
 226     }
 227
 228   DECL_NAME (thunk) = name;
 229   SET_DECL_ASSEMBLER_NAME (thunk, name);
 230 }
 231
 232 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
 233    offset indicated by VIRTUAL_OFFSET, if that is
 234    non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
 235    zero for a result adjusting thunk.  */
 236
 237 static tree
 238 thunk_adjust (tree ptr, bool this_adjusting,
 239               HOST_WIDE_INT fixed_offset, tree virtual_offset)
 240 {
 241   if (this_adjusting)
 242     /* Adjust the pointer by the constant.  */
 243     ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 244                        ssize_int (fixed_offset)));
 245
 246   /* If there's a virtual offset, look up that value in the vtable and
 247      adjust the pointer again.  */
 248   if (virtual_offset)
 249     {
 250       tree vtable;
 251
 252       ptr = save_expr (ptr);
 253       /* The vptr is always at offset zero in the object.  */
 254       vtable = build1 (NOP_EXPR,
 255                        build_pointer_type (build_pointer_type
 256                                            (vtable_entry_type)),
 257                        ptr);
 258       /* Form the vtable address.  */
 259       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 260       /* Find the entry with the vcall offset.  */
 261       vtable = build (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
 262       /* Get the offset itself.  */
 263       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 264       /* Adjust the `this' pointer.  */
 265       ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable));
 266     }
 267
 268   if (!this_adjusting)
 269     /* Adjust the pointer by the constant.  */
 270     ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 271                        ssize_int (fixed_offset)));
 272
 273   return ptr;
 274 }
 275
 276 /* Garbage collector tables contains thunk_labelno even when places
 277    inside ifdef block.  */
 278 static GTY (()) int thunk_labelno;
 279 #ifdef ASM_OUTPUT_DEF
 280
 281 /* Create a static alias to function.  */
 282
 283 static tree
 284 make_alias_for_thunk (tree function)
 285 {
 286   tree alias;
 287   char buf[256];
 288
 289   ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
 290   thunk_labelno++;
 291   alias = build_decl (FUNCTION_DECL, get_identifier (buf),
 292                       TREE_TYPE (function));
 293   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
 294   cxx_dup_lang_specific_decl (alias);
 295   DECL_CONTEXT (alias) = NULL;
 296   TREE_READONLY (alias) = TREE_READONLY (function);
 297   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
 298   TREE_PUBLIC (alias) = 0;
 299   DECL_INTERFACE_KNOWN (alias) = 1;
 300   DECL_NOT_REALLY_EXTERN (alias) = 1;
 301   DECL_THIS_STATIC (alias) = 1;
 302   DECL_SAVED_FUNCTION_DATA (alias) = NULL;
 303   DECL_DESTRUCTOR_P (alias) = 0;
 304   DECL_CONSTRUCTOR_P (alias) = 0;
 305   DECL_CLONED_FUNCTION (alias) = NULL_TREE;
 306   DECL_EXTERNAL (alias) = 0;
 307   DECL_ARTIFICIAL (alias) = 1;
 308   DECL_NO_STATIC_CHAIN (alias) = 1;
 309   DECL_PENDING_INLINE_P (alias) = 0;
 310   DECL_INLINE (alias) = 0;
 311   DECL_DECLARED_INLINE_P (alias) = 0;
 312   DECL_DEFERRED_FN (alias) = 0;
 313   DECL_USE_TEMPLATE (alias) = 0;
 314   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
 315   DECL_TEMPLATE_INFO (alias) = NULL;
 316   DECL_INITIAL (alias) = error_mark_node;
 317   TREE_ADDRESSABLE (alias) = 1;
 318   TREE_USED (alias) = 1;
 319   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
 320   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
 321   if (!flag_syntax_only)
 322     assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
 323   return alias;
 324 }
 325 #endif
 326
 327 /* Emit the definition of a C++ multiple inheritance or covariant
 328    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
 329    immediately.  */
 330
 331 void
 332 use_thunk (tree thunk_fndecl, bool emit_p)
 333 {
 334   tree function, alias;
 335   tree virtual_offset;
 336   HOST_WIDE_INT fixed_offset, virtual_value;
 337   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
 338
 339   /* We should have called finish_thunk to give it a name.  */
 340   my_friendly_assert (DECL_NAME (thunk_fndecl), 20021127);
 341
 342   /* We should never be using an alias, always refer to the
 343      aliased thunk.  */
 344   my_friendly_assert (!THUNK_ALIAS (thunk_fndecl), 20031023);
 345
 346   if (TREE_ASM_WRITTEN (thunk_fndecl))
 347     return;
 348
 349   function = THUNK_TARGET (thunk_fndecl);
 350   if (DECL_RESULT (thunk_fndecl))
 351     /* We already turned this thunk into an ordinary function.
 352        There's no need to process this thunk again.  */
 353     return;
 354
 355   /* Thunks are always addressable; they only appear in vtables.  */
 356   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 357
 358   /* Figure out what function is being thunked to.  It's referenced in
 359      this translation unit.  */
 360   TREE_ADDRESSABLE (function) = 1;
 361   mark_used (function);
 362   mark_referenced (DECL_ASSEMBLER_NAME (function));
 363   if (!emit_p)
 364     return;
 365
 366 #ifdef ASM_OUTPUT_DEF
 367   alias = make_alias_for_thunk (function);
 368 #else
 369   alias = function;
 370 #endif
 371
 372   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
 373   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
 374
 375   if (virtual_offset)
 376     {
 377       if (!this_adjusting)
 378         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 379       virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
 380       my_friendly_assert (virtual_value, 20021026);
 381     }
 382   else
 383     virtual_value = 0;
 384
 385   /* And, if we need to emit the thunk, it's used.  */
 386   mark_used (thunk_fndecl);
 387   /* This thunk is actually defined.  */
 388   DECL_EXTERNAL (thunk_fndecl) = 0;
 389   /* The linkage of the function may have changed.  FIXME in linkage
 390      rewrite.  */
 391   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
 392   DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
 393
 394   if (flag_syntax_only)
 395     {
 396       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 397       return;
 398     }
 399
 400   push_to_top_level ();
 401
 402 #ifdef ASM_OUTPUT_DEF
 403   if (targetm.have_named_sections)
 404     {
 405       resolve_unique_section (function, 0, flag_function_sections);
 406
 407       if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
 408         {
 409           resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
 410
 411           /* Output the thunk into the same section as function.  */
 412           DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
 413         }
 414     }
 415 #endif
 416
 417   /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
 418      create one.  */
 419   DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
 420   BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) = DECL_ARGUMENTS (thunk_fndecl);
 421
 422   if (this_adjusting
 423       && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
 424                                               virtual_value, alias))
 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);
 432       current_function_is_thunk = 1;
 433       assemble_start_function (thunk_fndecl, fnname);
 434
 435       targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
 436                                        fixed_offset, virtual_value, alias);
 437
 438       assemble_end_function (thunk_fndecl, fnname);
 439       current_function_decl = 0;
 440       cfun = 0;
 441       /* Because init_function_start increments this, we must
 442          decrement it.  */
 443       immediate_size_expand--;
 444       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 445     }
 446   else
 447     {
 448       /* If this is a covariant thunk, or we don't have the necessary
 449          code for efficient thunks, generate a thunk function that
 450          just makes a call to the real function.  Unfortunately, this
 451          doesn't work for varargs.  */
 452
 453       tree a, t;
 454
 455       if (varargs_function_p (function))
 456         error ("generic thunk code fails for method `%#D' which uses `...'",
 457                function);
 458
 459       /* Set up cloned argument trees for the thunk.  */
 460       t = NULL_TREE;
 461       for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
 462         {
 463           tree x = copy_node (a);
 464           TREE_CHAIN (x) = t;
 465           DECL_CONTEXT (x) = thunk_fndecl;
 466           SET_DECL_RTL (x, NULL_RTX);
 467           t = x;
 468         }
 469       a = nreverse (t);
 470       DECL_ARGUMENTS (thunk_fndecl) = a;
 471       DECL_RESULT (thunk_fndecl) = NULL_TREE;
 472
 473       start_function (NULL_TREE, thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
 474       /* We don't bother with a body block for thunks.  */
 475
 476       /* There's no need to check accessibility inside the thunk body.  */
 477       push_deferring_access_checks (dk_no_check);
 478
 479       t = a;
 480       if (this_adjusting)
 481         t = thunk_adjust (t, /*this_adjusting=*/1,
 482                           fixed_offset, virtual_offset);
 483
 484       /* Build up the call to the real function.  */
 485       t = tree_cons (NULL_TREE, t, NULL_TREE);
 486       for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
 487         t = tree_cons (NULL_TREE, a, t);
 488       t = nreverse (t);
 489       t = build_call (alias, t);
 490       CALL_FROM_THUNK_P (t) = 1;
 491
 492       if (VOID_TYPE_P (TREE_TYPE (t)))
 493         finish_expr_stmt (t);
 494       else
 495         {
 496           t = force_target_expr (TREE_TYPE (t), t);
 497           if (!this_adjusting)
 498             t = thunk_adjust (t, /*this_adjusting=*/0,
 499                               fixed_offset, virtual_offset);
 500           finish_return_stmt (t);
 501         }
 502
 503       /* Since we want to emit the thunk, we explicitly mark its name as
 504          referenced.  */
 505       mark_referenced (DECL_ASSEMBLER_NAME (thunk_fndecl));
 506
 507       /* But we don't want debugging information about it.  */
 508       DECL_IGNORED_P (thunk_fndecl) = 1;
 509
 510       /* Re-enable access control.  */
 511       pop_deferring_access_checks ();
 512
 513       expand_body (finish_function (0));
 514     }
 515
 516   pop_from_top_level ();
 517 }
 518 \f
 519 /* Code for synthesizing methods which have default semantics defined.  */
 520
 521 /* Generate code for default X(X&) constructor.  */
 522
 523 static void
 524 do_build_copy_constructor (tree fndecl)
 525 {
 526   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
 527   tree t;
 528
 529   parm = convert_from_reference (parm);
 530
 531   if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
 532       && is_empty_class (current_class_type))
 533     /* Don't copy the padding byte; it might not have been allocated
 534        if *this is a base subobject.  */;
 535   else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
 536     {
 537       t = build (INIT_EXPR, void_type_node, current_class_ref, parm);
 538       finish_expr_stmt (t);
 539     }
 540   else
 541     {
 542       tree fields = TYPE_FIELDS (current_class_type);
 543       int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
 544       tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
 545       tree member_init_list = NULL_TREE;
 546       int cvquals = cp_type_quals (TREE_TYPE (parm));
 547       int i;
 548
 549       /* Initialize all the base-classes with the parameter converted
 550          to their type so that we get their copy constructor and not
 551          another constructor that takes current_class_type.  We must
 552          deal with the binfo's directly as a direct base might be
 553          inaccessible due to ambiguity.  */
 554       for (t = CLASSTYPE_VBASECLASSES (current_class_type); t;
 555            t = TREE_CHAIN (t))
 556         {
 557           tree binfo = TREE_VALUE (t);
 558
 559           member_init_list
 560             = tree_cons (binfo,
 561                          build_tree_list (NULL_TREE,
 562                                           build_base_path (PLUS_EXPR, parm,
 563                                                            binfo, 1)),
 564                          member_init_list);
 565         }
 566
 567       for (i = 0; i < n_bases; ++i)
 568         {
 569           tree binfo = TREE_VEC_ELT (binfos, i);
 570           if (TREE_VIA_VIRTUAL (binfo))
 571             continue;
 572
 573           member_init_list
 574             = tree_cons (binfo,
 575                          build_tree_list (NULL_TREE,
 576                                           build_base_path (PLUS_EXPR, parm,
 577                                                            binfo, 1)),
 578                          member_init_list);
 579         }
 580
 581       for (; fields; fields = TREE_CHAIN (fields))
 582         {
 583           tree init;
 584           tree field = fields;
 585           tree expr_type;
 586
 587           if (TREE_CODE (field) != FIELD_DECL)
 588             continue;
 589
 590           init = parm;
 591           if (DECL_NAME (field))
 592             {
 593               if (VFIELD_NAME_P (DECL_NAME (field)))
 594                 continue;
 595
 596               /* True for duplicate members.  */
 597               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 598                 continue;
 599             }
 600           else if ((t = TREE_TYPE (field)) != NULL_TREE
 601                    && ANON_AGGR_TYPE_P (t)
 602                    && TYPE_FIELDS (t) != NULL_TREE)
 603             /* Just use the field; anonymous types can't have
 604                nontrivial copy ctors or assignment ops.  */;
 605           else
 606             continue;
 607
 608           /* Compute the type of "init->field".  If the copy-constructor
 609              parameter is, for example, "const S&", and the type of
 610              the field is "T", then the type will usually be "const
 611              T".  (There are no cv-qualified variants of reference
 612              types.)  */
 613           expr_type = TREE_TYPE (field);
 614           if (TREE_CODE (expr_type) != REFERENCE_TYPE)
 615             expr_type = cp_build_qualified_type (expr_type, cvquals);
 616           init = build (COMPONENT_REF, expr_type, init, field);
 617           init = build_tree_list (NULL_TREE, init);
 618
 619           member_init_list
 620             = tree_cons (field, init, member_init_list);
 621         }
 622       finish_mem_initializers (member_init_list);
 623     }
 624 }
 625
 626 static void
 627 do_build_assign_ref (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=*/false);
 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;
 647       int cvquals = cp_type_quals (TREE_TYPE (parm));
 648       int i;
 649
 650       /* Assign to each of the direct base classes.  */
 651       for (i = 0; i < CLASSTYPE_N_BASECLASSES (current_class_type); ++i)
 652         {
 653           tree binfo;
 654           tree converted_parm;
 655
 656           binfo = BINFO_BASETYPE (TYPE_BINFO (current_class_type), i);
 657           /* We must convert PARM directly to the base class
 658              explicitly since the base class may be ambiguous.  */
 659           converted_parm = build_base_path (PLUS_EXPR, parm, binfo, 1);
 660           /* Call the base class assignment operator.  */
 661           finish_expr_stmt
 662             (build_special_member_call (current_class_ref,
 663                                         ansi_assopname (NOP_EXPR),
 664                                         build_tree_list (NULL_TREE,
 665                                                          converted_parm),
 666                                         binfo,
 667                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
 668         }
 669
 670       /* Assign to each of the non-static data members.  */
 671       for (fields = TYPE_FIELDS (current_class_type);
 672            fields;
 673            fields = TREE_CHAIN (fields))
 674         {
 675           tree comp, init, t;
 676           tree field = fields;
 677
 678           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 679             continue;
 680
 681           if (CP_TYPE_CONST_P (TREE_TYPE (field)))
 682             {
 683               error ("non-static const member `%#D', can't use default assignment operator", field);
 684               continue;
 685             }
 686           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 687             {
 688               error ("non-static reference member `%#D', can't use default assignment operator", field);
 689               continue;
 690             }
 691
 692           comp = current_class_ref;
 693           init = parm;
 694
 695           if (DECL_NAME (field))
 696             {
 697               if (VFIELD_NAME_P (DECL_NAME (field)))
 698                 continue;
 699
 700               /* True for duplicate members.  */
 701               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 702                 continue;
 703             }
 704           else if ((t = TREE_TYPE (field)) != NULL_TREE
 705                    && ANON_AGGR_TYPE_P (t)
 706                    && TYPE_FIELDS (t) != NULL_TREE)
 707             /* Just use the field; anonymous types can't have
 708                nontrivial copy ctors or assignment ops.  */;
 709           else
 710             continue;
 711
 712           comp = build (COMPONENT_REF, TREE_TYPE (field), comp, field);
 713           init = build (COMPONENT_REF,
 714                         cp_build_qualified_type (TREE_TYPE (field), cvquals),
 715                         init, field);
 716
 717           if (DECL_NAME (field))
 718             finish_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
 719           else
 720             finish_expr_stmt (build (MODIFY_EXPR, TREE_TYPE (comp), comp,
 721                                      init));
 722         }
 723     }
 724   finish_return_stmt (current_class_ref);
 725   finish_compound_stmt (compound_stmt);
 726 }
 727
 728 void
 729 synthesize_method (tree fndecl)
 730 {
 731   bool nested = (current_function_decl != NULL_TREE);
 732   tree context = decl_function_context (fndecl);
 733   bool need_body = true;
 734   tree stmt;
 735
 736   if (at_eof)
 737     import_export_decl (fndecl);
 738
 739   /* If we've been asked to synthesize a clone, just synthesize the
 740      cloned function instead.  Doing so will automatically fill in the
 741      body for the clone.  */
 742   if (DECL_CLONED_FUNCTION_P (fndecl))
 743     {
 744       synthesize_method (DECL_CLONED_FUNCTION (fndecl));
 745       return;
 746     }
 747
 748   /* We may be in the middle of deferred access check.  Disable
 749      it now.  */
 750   push_deferring_access_checks (dk_no_deferred);
 751
 752   if (! context)
 753     push_to_top_level ();
 754   else if (nested)
 755     push_function_context_to (context);
 756
 757   /* Put the function definition at the position where it is needed,
 758      rather than within the body of the class.  That way, an error
 759      during the generation of the implicit body points at the place
 760      where the attempt to generate the function occurs, giving the
 761      user a hint as to why we are attempting to generate the
 762      function.  */
 763   DECL_SOURCE_LOCATION (fndecl) = input_location;
 764
 765   interface_unknown = 1;
 766   start_function (NULL_TREE, fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 767   clear_last_expr ();
 768   stmt = begin_function_body ();
 769
 770   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 771     {
 772       do_build_assign_ref (fndecl);
 773       need_body = false;
 774     }
 775   else if (DECL_CONSTRUCTOR_P (fndecl))
 776     {
 777       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 778       if (arg_chain != void_list_node)
 779         do_build_copy_constructor (fndecl);
 780       else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
 781         finish_mem_initializers (NULL_TREE);
 782     }
 783
 784   /* If we haven't yet generated the body of the function, just
 785      generate an empty compound statement.  */
 786   if (need_body)
 787     {
 788       tree compound_stmt;
 789       compound_stmt = begin_compound_stmt (/*has_no_scope=*/false);
 790       finish_compound_stmt (compound_stmt);
 791     }
 792
 793   finish_function_body (stmt);
 794   expand_or_defer_fn (finish_function (0));
 795
 796   extract_interface_info ();
 797   if (! context)
 798     pop_from_top_level ();
 799   else if (nested)
 800     pop_function_context_from (context);
 801
 802   pop_deferring_access_checks ();
 803 }
 804
 805 /* Use EXTRACTOR to locate the relevant function called for each base &
 806    class field of TYPE. CLIENT allows additional information to be passed
 807    to EXTRACTOR.  Generates the union of all exceptions generated by those
 808    functions.  Note that we haven't updated TYPE_FIELDS and such of any
 809    variants yet, so we need to look at the main one.  */
 810
 811 static tree
 812 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
 813                            void *client)
 814 {
 815   tree raises = empty_except_spec;
 816   tree fields = TYPE_FIELDS (type);
 817   int i, n_bases = CLASSTYPE_N_BASECLASSES (type);
 818   tree binfos = TYPE_BINFO_BASETYPES (type);
 819
 820   for (i = 0; i != n_bases; i++)
 821     {
 822       tree base = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
 823       tree fn = (*extractor) (base, 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   for (; fields; fields = TREE_CHAIN (fields))
 832     {
 833       tree type = TREE_TYPE (fields);
 834       tree fn;
 835
 836       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
 837         continue;
 838       while (TREE_CODE (type) == ARRAY_TYPE)
 839         type = TREE_TYPE (type);
 840       if (TREE_CODE (type) != RECORD_TYPE)
 841         continue;
 842
 843       fn = (*extractor) (type, client);
 844       if (fn)
 845         {
 846           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 847
 848           raises = merge_exception_specifiers (raises, fn_raises);
 849         }
 850     }
 851   return raises;
 852 }
 853
 854 /* Locate the dtor of TYPE.  */
 855
 856 static tree
 857 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
 858 {
 859   tree fns;
 860
 861   if (!TYPE_HAS_DESTRUCTOR (type))
 862     return NULL_TREE;
 863   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 864                       CLASSTYPE_DESTRUCTOR_SLOT);
 865   return fns;
 866 }
 867
 868 /* Locate the default ctor of TYPE.  */
 869
 870 static tree
 871 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
 872 {
 873   tree fns;
 874
 875   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 876     return NULL_TREE;
 877
 878   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 879                       CLASSTYPE_CONSTRUCTOR_SLOT);
 880   for (; fns; fns = OVL_NEXT (fns))
 881     {
 882       tree fn = OVL_CURRENT (fns);
 883       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 884
 885       if (sufficient_parms_p (TREE_CHAIN (parms)))
 886         return fn;
 887     }
 888   return NULL_TREE;
 889 }
 890
 891 struct copy_data
 892 {
 893   tree name;
 894   int quals;
 895 };
 896
 897 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
 898    points to a COPY_DATA holding the name (NULL for the ctor)
 899    and desired qualifiers of the source operand.  */
 900
 901 static tree
 902 locate_copy (tree type, 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   bool excess_p = false;
 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 = non_reference (TREE_VALUE (parms));
 933       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 934         continue;
 935       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 936         continue;
 937       quals = cp_type_quals (src_type);
 938       if (client->quals & ~quals)
 939         continue;
 940       excess = quals & ~client->quals;
 941       if (!best || (excess_p && !excess))
 942         {
 943           best = fn;
 944           excess_p = excess;
 945         }
 946       else
 947         /* Ambiguous */
 948         return NULL_TREE;
 949     }
 950   return best;
 951 }
 952
 953 /* Implicitly declare the special function indicated by KIND, as a
 954    member of TYPE.  For copy constructors and assignment operators,
 955    CONST_P indicates whether these functions should take a const
 956    reference argument or a non-const reference.  */
 957
 958 tree
 959 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
 960 {
 961   tree declspecs = NULL_TREE;
 962   tree fn, args = NULL_TREE;
 963   tree raises = empty_except_spec;
 964   bool retref = false;
 965   bool has_parm = false;
 966   tree name = constructor_name (type);
 967
 968   switch (kind)
 969     {
 970     case sfk_destructor:
 971       /* Destructor.  */
 972       name = build_nt (BIT_NOT_EXPR, name);
 973       args = void_list_node;
 974       raises = synthesize_exception_spec (type, &locate_dtor, 0);
 975       break;
 976
 977     case sfk_constructor:
 978       /* Default constructor.  */
 979       args = void_list_node;
 980       raises = synthesize_exception_spec (type, &locate_ctor, 0);
 981       break;
 982
 983     case sfk_copy_constructor:
 984     case sfk_assignment_operator:
 985     {
 986       struct copy_data data;
 987       tree argtype = type;
 988
 989       has_parm = true;
 990       data.name = NULL;
 991       data.quals = 0;
 992       if (kind == sfk_assignment_operator)
 993         {
 994           retref = true;
 995           declspecs = build_tree_list (NULL_TREE, type);
 996
 997           name = ansi_assopname (NOP_EXPR);
 998           data.name = name;
 999         }
1000       if (const_p)
1001         {
1002           data.quals = TYPE_QUAL_CONST;
1003           argtype = build_qualified_type (argtype, TYPE_QUAL_CONST);
1004         }
1005
1006       argtype = build_reference_type (argtype);
1007       args = build_tree_list (hash_tree_chain (argtype, NULL_TREE),
1008                               get_identifier ("_ctor_arg"));
1009       args = tree_cons (NULL_TREE, args, void_list_node);
1010
1011       raises = synthesize_exception_spec (type, &locate_copy, &data);
1012       break;
1013     }
1014     default:
1015       abort ();
1016     }
1017
1018   TREE_PARMLIST (args) = 1;
1019
1020   {
1021     tree declarator = make_call_declarator (name, args, NULL_TREE, raises);
1022
1023     if (retref)
1024       declarator = build_nt (ADDR_EXPR, declarator);
1025
1026     fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
1027     if (has_parm)
1028       TREE_USED (FUNCTION_FIRST_USER_PARM (fn)) = 1;
1029   }
1030
1031   my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 20000408);
1032
1033   DECL_ARTIFICIAL (fn) = 1;
1034   DECL_NOT_REALLY_EXTERN (fn) = 1;
1035   DECL_DECLARED_INLINE_P (fn) = 1;
1036   DECL_INLINE (fn) = 1;
1037   defer_fn (fn);
1038
1039   return fn;
1040 }
1041
1042 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1043    as there are artificial parms in FN.  */
1044
1045 tree
1046 skip_artificial_parms_for (tree fn, tree list)
1047 {
1048   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1049     list = TREE_CHAIN (list);
1050   else
1051     return list;
1052
1053   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1054     list = TREE_CHAIN (list);
1055   if (DECL_HAS_VTT_PARM_P (fn))
1056     list = TREE_CHAIN (list);
1057   return list;
1058 }
1059
1060 #include "gt-cp-method.h"