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