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