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 a, t, 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   if (flag_weak && TREE_PUBLIC (thunk_fndecl))
 394     comdat_linkage (thunk_fndecl);
 395
 396   if (flag_syntax_only)
 397     {
 398       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 399       return;
 400     }
 401
 402   push_to_top_level ();
 403
 404 #ifdef ASM_OUTPUT_DEF
 405   if (targetm.have_named_sections)
 406     {
 407       resolve_unique_section (function, 0, flag_function_sections);
 408
 409       if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
 410         {
 411           resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
 412
 413           /* Output the thunk into the same section as function.  */
 414           DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
 415         }
 416     }
 417 #endif
 418
 419   /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
 420      create one.  */
 421   DECL_INITIAL (thunk_fndecl) = make_node (BLOCK);
 422
 423   /* Set up cloned argument trees for the thunk.  */
 424   t = NULL_TREE;
 425   for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
 426     {
 427       tree x = copy_node (a);
 428       TREE_CHAIN (x) = t;
 429       DECL_CONTEXT (x) = thunk_fndecl;
 430       SET_DECL_RTL (x, NULL_RTX);
 431       t = x;
 432     }
 433   a = nreverse (t);
 434   DECL_ARGUMENTS (thunk_fndecl) = a;
 435   BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) = a;
 436
 437   if (this_adjusting
 438       && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
 439                                               virtual_value, alias))
 440     {
 441       const char *fnname;
 442       current_function_decl = thunk_fndecl;
 443       DECL_RESULT (thunk_fndecl)
 444         = build_decl (RESULT_DECL, 0, integer_type_node);
 445       fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
 446       init_function_start (thunk_fndecl);
 447       current_function_is_thunk = 1;
 448       assemble_start_function (thunk_fndecl, fnname);
 449
 450       targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
 451                                        fixed_offset, virtual_value, alias);
 452
 453       assemble_end_function (thunk_fndecl, fnname);
 454       current_function_decl = 0;
 455       cfun = 0;
 456       /* Because init_function_start increments this, we must
 457          decrement it.  */
 458       immediate_size_expand--;
 459       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 460     }
 461   else
 462     {
 463       /* If this is a covariant thunk, or we don't have the necessary
 464          code for efficient thunks, generate a thunk function that
 465          just makes a call to the real function.  Unfortunately, this
 466          doesn't work for varargs.  */
 467
 468       if (varargs_function_p (function))
 469         error ("generic thunk code fails for method `%#D' which uses `...'",
 470                function);
 471
 472       DECL_RESULT (thunk_fndecl) = NULL_TREE;
 473
 474       start_function (NULL_TREE, thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
 475       /* We don't bother with a body block for thunks.  */
 476
 477       /* There's no need to check accessibility inside the thunk body.  */
 478       push_deferring_access_checks (dk_no_check);
 479
 480       t = a;
 481       if (this_adjusting)
 482         t = thunk_adjust (t, /*this_adjusting=*/1,
 483                           fixed_offset, virtual_offset);
 484
 485       /* Build up the call to the real function.  */
 486       t = tree_cons (NULL_TREE, t, NULL_TREE);
 487       for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a))
 488         t = tree_cons (NULL_TREE, a, t);
 489       t = nreverse (t);
 490       t = build_call (alias, t);
 491       CALL_FROM_THUNK_P (t) = 1;
 492
 493       if (VOID_TYPE_P (TREE_TYPE (t)))
 494         finish_expr_stmt (t);
 495       else
 496         {
 497           t = force_target_expr (TREE_TYPE (t), t);
 498           if (!this_adjusting)
 499             t = thunk_adjust (t, /*this_adjusting=*/0,
 500                               fixed_offset, virtual_offset);
 501           finish_return_stmt (t);
 502         }
 503
 504       /* Since we want to emit the thunk, we explicitly mark its name as
 505          referenced.  */
 506       mark_referenced (DECL_ASSEMBLER_NAME (thunk_fndecl));
 507
 508       /* But we don't want debugging information about it.  */
 509       DECL_IGNORED_P (thunk_fndecl) = 1;
 510
 511       /* Re-enable access control.  */
 512       pop_deferring_access_checks ();
 513
 514       expand_body (finish_function (0));
 515     }
 516
 517   pop_from_top_level ();
 518 }
 519 \f
 520 /* Code for synthesizing methods which have default semantics defined.  */
 521
 522 /* Generate code for default X(X&) constructor.  */
 523
 524 static void
 525 do_build_copy_constructor (tree fndecl)
 526 {
 527   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
 528   tree t;
 529
 530   parm = convert_from_reference (parm);
 531
 532   if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
 533       && is_empty_class (current_class_type))
 534     /* Don't copy the padding byte; it might not have been allocated
 535        if *this is a base subobject.  */;
 536   else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
 537     {
 538       t = build (INIT_EXPR, void_type_node, current_class_ref, parm);
 539       finish_expr_stmt (t);
 540     }
 541   else
 542     {
 543       tree fields = TYPE_FIELDS (current_class_type);
 544       int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
 545       tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
 546       tree member_init_list = NULL_TREE;
 547       int cvquals = cp_type_quals (TREE_TYPE (parm));
 548       int i;
 549
 550       /* Initialize all the base-classes with the parameter converted
 551          to their type so that we get their copy constructor and not
 552          another constructor that takes current_class_type.  We must
 553          deal with the binfo's directly as a direct base might be
 554          inaccessible due to ambiguity.  */
 555       for (t = CLASSTYPE_VBASECLASSES (current_class_type); t;
 556            t = TREE_CHAIN (t))
 557         {
 558           tree binfo = TREE_VALUE (t);
 559
 560           member_init_list
 561             = tree_cons (binfo,
 562                          build_tree_list (NULL_TREE,
 563                                           build_base_path (PLUS_EXPR, parm,
 564                                                            binfo, 1)),
 565                          member_init_list);
 566         }
 567
 568       for (i = 0; i < n_bases; ++i)
 569         {
 570           tree binfo = TREE_VEC_ELT (binfos, i);
 571           if (TREE_VIA_VIRTUAL (binfo))
 572             continue;
 573
 574           member_init_list
 575             = tree_cons (binfo,
 576                          build_tree_list (NULL_TREE,
 577                                           build_base_path (PLUS_EXPR, parm,
 578                                                            binfo, 1)),
 579                          member_init_list);
 580         }
 581
 582       for (; fields; fields = TREE_CHAIN (fields))
 583         {
 584           tree init;
 585           tree field = fields;
 586           tree expr_type;
 587
 588           if (TREE_CODE (field) != FIELD_DECL)
 589             continue;
 590
 591           init = parm;
 592           if (DECL_NAME (field))
 593             {
 594               if (VFIELD_NAME_P (DECL_NAME (field)))
 595                 continue;
 596
 597               /* True for duplicate members.  */
 598               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 599                 continue;
 600             }
 601           else if ((t = TREE_TYPE (field)) != NULL_TREE
 602                    && ANON_AGGR_TYPE_P (t)
 603                    && TYPE_FIELDS (t) != NULL_TREE)
 604             /* Just use the field; anonymous types can't have
 605                nontrivial copy ctors or assignment ops.  */;
 606           else
 607             continue;
 608
 609           /* Compute the type of "init->field".  If the copy-constructor
 610              parameter is, for example, "const S&", and the type of
 611              the field is "T", then the type will usually be "const
 612              T".  (There are no cv-qualified variants of reference
 613              types.)  */
 614           expr_type = TREE_TYPE (field);
 615           if (TREE_CODE (expr_type) != REFERENCE_TYPE)
 616             expr_type = cp_build_qualified_type (expr_type, cvquals);
 617           init = build (COMPONENT_REF, expr_type, init, field);
 618           init = build_tree_list (NULL_TREE, init);
 619
 620           member_init_list
 621             = tree_cons (field, init, member_init_list);
 622         }
 623       finish_mem_initializers (member_init_list);
 624     }
 625 }
 626
 627 static void
 628 do_build_assign_ref (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=*/false);
 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;
 648       int cvquals = cp_type_quals (TREE_TYPE (parm));
 649       int i;
 650
 651       /* Assign to each of the direct base classes.  */
 652       for (i = 0; i < CLASSTYPE_N_BASECLASSES (current_class_type); ++i)
 653         {
 654           tree binfo;
 655           tree converted_parm;
 656
 657           binfo = BINFO_BASETYPE (TYPE_BINFO (current_class_type), i);
 658           /* We must convert PARM directly to the base class
 659              explicitly since the base class may be ambiguous.  */
 660           converted_parm = build_base_path (PLUS_EXPR, parm, binfo, 1);
 661           /* Call the base class assignment operator.  */
 662           finish_expr_stmt
 663             (build_special_member_call (current_class_ref,
 664                                         ansi_assopname (NOP_EXPR),
 665                                         build_tree_list (NULL_TREE,
 666                                                          converted_parm),
 667                                         binfo,
 668                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
 669         }
 670
 671       /* Assign to each of the non-static data members.  */
 672       for (fields = TYPE_FIELDS (current_class_type);
 673            fields;
 674            fields = TREE_CHAIN (fields))
 675         {
 676           tree comp, init, t;
 677           tree field = fields;
 678
 679           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 680             continue;
 681
 682           if (CP_TYPE_CONST_P (TREE_TYPE (field)))
 683             {
 684               error ("non-static const member `%#D', can't use default assignment operator", field);
 685               continue;
 686             }
 687           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 688             {
 689               error ("non-static reference member `%#D', can't use default assignment operator", field);
 690               continue;
 691             }
 692
 693           comp = current_class_ref;
 694           init = parm;
 695
 696           if (DECL_NAME (field))
 697             {
 698               if (VFIELD_NAME_P (DECL_NAME (field)))
 699                 continue;
 700
 701               /* True for duplicate members.  */
 702               if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field)
 703                 continue;
 704             }
 705           else if ((t = TREE_TYPE (field)) != NULL_TREE
 706                    && ANON_AGGR_TYPE_P (t)
 707                    && TYPE_FIELDS (t) != NULL_TREE)
 708             /* Just use the field; anonymous types can't have
 709                nontrivial copy ctors or assignment ops.  */;
 710           else
 711             continue;
 712
 713           comp = build (COMPONENT_REF, TREE_TYPE (field), comp, field);
 714           init = build (COMPONENT_REF,
 715                         cp_build_qualified_type (TREE_TYPE (field), cvquals),
 716                         init, field);
 717
 718           if (DECL_NAME (field))
 719             finish_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
 720           else
 721             finish_expr_stmt (build (MODIFY_EXPR, TREE_TYPE (comp), comp,
 722                                      init));
 723         }
 724     }
 725   finish_return_stmt (current_class_ref);
 726   finish_compound_stmt (compound_stmt);
 727 }
 728
 729 void
 730 synthesize_method (tree fndecl)
 731 {
 732   bool nested = (current_function_decl != NULL_TREE);
 733   tree context = decl_function_context (fndecl);
 734   bool need_body = true;
 735   tree stmt;
 736
 737   if (at_eof)
 738     import_export_decl (fndecl);
 739
 740   /* If we've been asked to synthesize a clone, just synthesize the
 741      cloned function instead.  Doing so will automatically fill in the
 742      body for the clone.  */
 743   if (DECL_CLONED_FUNCTION_P (fndecl))
 744     {
 745       synthesize_method (DECL_CLONED_FUNCTION (fndecl));
 746       return;
 747     }
 748
 749   /* We may be in the middle of deferred access check.  Disable
 750      it now.  */
 751   push_deferring_access_checks (dk_no_deferred);
 752
 753   if (! context)
 754     push_to_top_level ();
 755   else if (nested)
 756     push_function_context_to (context);
 757
 758   /* Put the function definition at the position where it is needed,
 759      rather than within the body of the class.  That way, an error
 760      during the generation of the implicit body points at the place
 761      where the attempt to generate the function occurs, giving the
 762      user a hint as to why we are attempting to generate the
 763      function.  */
 764   DECL_SOURCE_LOCATION (fndecl) = input_location;
 765
 766   interface_unknown = 1;
 767   start_function (NULL_TREE, fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 768   clear_last_expr ();
 769   stmt = begin_function_body ();
 770
 771   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 772     {
 773       do_build_assign_ref (fndecl);
 774       need_body = false;
 775     }
 776   else if (DECL_CONSTRUCTOR_P (fndecl))
 777     {
 778       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 779       if (arg_chain != void_list_node)
 780         do_build_copy_constructor (fndecl);
 781       else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
 782         finish_mem_initializers (NULL_TREE);
 783     }
 784
 785   /* If we haven't yet generated the body of the function, just
 786      generate an empty compound statement.  */
 787   if (need_body)
 788     {
 789       tree compound_stmt;
 790       compound_stmt = begin_compound_stmt (/*has_no_scope=*/false);
 791       finish_compound_stmt (compound_stmt);
 792     }
 793
 794   finish_function_body (stmt);
 795   expand_or_defer_fn (finish_function (0));
 796
 797   extract_interface_info ();
 798   if (! context)
 799     pop_from_top_level ();
 800   else if (nested)
 801     pop_function_context_from (context);
 802
 803   pop_deferring_access_checks ();
 804 }
 805
 806 /* Use EXTRACTOR to locate the relevant function called for each base &
 807    class field of TYPE. CLIENT allows additional information to be passed
 808    to EXTRACTOR.  Generates the union of all exceptions generated by those
 809    functions.  Note that we haven't updated TYPE_FIELDS and such of any
 810    variants yet, so we need to look at the main one.  */
 811
 812 static tree
 813 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
 814                            void *client)
 815 {
 816   tree raises = empty_except_spec;
 817   tree fields = TYPE_FIELDS (type);
 818   int i, n_bases = CLASSTYPE_N_BASECLASSES (type);
 819   tree binfos = TYPE_BINFO_BASETYPES (type);
 820
 821   for (i = 0; i != n_bases; i++)
 822     {
 823       tree base = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
 824       tree fn = (*extractor) (base, client);
 825       if (fn)
 826         {
 827           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 828
 829           raises = merge_exception_specifiers (raises, fn_raises);
 830         }
 831     }
 832   for (; fields; fields = TREE_CHAIN (fields))
 833     {
 834       tree type = TREE_TYPE (fields);
 835       tree fn;
 836
 837       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
 838         continue;
 839       while (TREE_CODE (type) == ARRAY_TYPE)
 840         type = TREE_TYPE (type);
 841       if (TREE_CODE (type) != RECORD_TYPE)
 842         continue;
 843
 844       fn = (*extractor) (type, client);
 845       if (fn)
 846         {
 847           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 848
 849           raises = merge_exception_specifiers (raises, fn_raises);
 850         }
 851     }
 852   return raises;
 853 }
 854
 855 /* Locate the dtor of TYPE.  */
 856
 857 static tree
 858 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
 859 {
 860   tree fns;
 861
 862   if (!TYPE_HAS_DESTRUCTOR (type))
 863     return NULL_TREE;
 864   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 865                       CLASSTYPE_DESTRUCTOR_SLOT);
 866   return fns;
 867 }
 868
 869 /* Locate the default ctor of TYPE.  */
 870
 871 static tree
 872 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
 873 {
 874   tree fns;
 875
 876   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 877     return NULL_TREE;
 878
 879   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type),
 880                       CLASSTYPE_CONSTRUCTOR_SLOT);
 881   for (; fns; fns = OVL_NEXT (fns))
 882     {
 883       tree fn = OVL_CURRENT (fns);
 884       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 885
 886       if (sufficient_parms_p (TREE_CHAIN (parms)))
 887         return fn;
 888     }
 889   return NULL_TREE;
 890 }
 891
 892 struct copy_data
 893 {
 894   tree name;
 895   int quals;
 896 };
 897
 898 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
 899    points to a COPY_DATA holding the name (NULL for the ctor)
 900    and desired qualifiers of the source operand.  */
 901
 902 static tree
 903 locate_copy (tree type, void *client_)
 904 {
 905   struct copy_data *client = (struct copy_data *)client_;
 906   tree fns;
 907   int ix = -1;
 908   tree best = NULL_TREE;
 909   bool excess_p = false;
 910
 911   if (client->name)
 912     {
 913       if (TYPE_HAS_ASSIGN_REF (type))
 914         ix = lookup_fnfields_1 (type, client->name);
 915     }
 916   else if (TYPE_HAS_INIT_REF (type))
 917     ix = CLASSTYPE_CONSTRUCTOR_SLOT;
 918   if (ix < 0)
 919     return NULL_TREE;
 920   fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), ix);
 921
 922   for (; fns; fns = OVL_NEXT (fns))
 923     {
 924       tree fn = OVL_CURRENT (fns);
 925       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 926       tree src_type;
 927       int excess;
 928       int quals;
 929
 930       parms = TREE_CHAIN (parms);
 931       if (!parms)
 932         continue;
 933       src_type = non_reference (TREE_VALUE (parms));
 934       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 935         continue;
 936       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 937         continue;
 938       quals = cp_type_quals (src_type);
 939       if (client->quals & ~quals)
 940         continue;
 941       excess = quals & ~client->quals;
 942       if (!best || (excess_p && !excess))
 943         {
 944           best = fn;
 945           excess_p = excess;
 946         }
 947       else
 948         /* Ambiguous */
 949         return NULL_TREE;
 950     }
 951   return best;
 952 }
 953
 954 /* Implicitly declare the special function indicated by KIND, as a
 955    member of TYPE.  For copy constructors and assignment operators,
 956    CONST_P indicates whether these functions should take a const
 957    reference argument or a non-const reference.  */
 958
 959 tree
 960 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
 961 {
 962   tree declspecs = NULL_TREE;
 963   tree fn, args = NULL_TREE;
 964   tree raises = empty_except_spec;
 965   bool retref = false;
 966   bool has_parm = false;
 967   tree name = constructor_name (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 = type;
 989
 990       has_parm = true;
 991       data.name = NULL;
 992       data.quals = 0;
 993       if (kind == sfk_assignment_operator)
 994         {
 995           retref = true;
 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           argtype = build_qualified_type (argtype, TYPE_QUAL_CONST);
1005         }
1006
1007       argtype = build_reference_type (argtype);
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       abort ();
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 (tree fn, tree list)
1048 {
1049   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1050     list = TREE_CHAIN (list);
1051   else
1052     return list;
1053
1054   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1055     list = TREE_CHAIN (list);
1056   if (DECL_HAS_VTT_PARM_P (fn))
1057     list = TREE_CHAIN (list);
1058   return list;
1059 }
1060
1061 #include "gt-cp-method.h"