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