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   my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 20021025);
  92   /* We can have this thunks to covariant thunks, but not vice versa.  */
  93   my_friendly_assert (!DECL_THIS_THUNK_P (function), 20021127);
  94   my_friendly_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting,
  95                       20031123);
  96
  97   /* Scale the VIRTUAL_OFFSET to be in terms of bytes.  */
  98   if (this_adjusting && virtual_offset)
  99     virtual_offset
 100       = size_binop (MULT_EXPR,
 101                     virtual_offset,
 102                     convert (ssizetype,
 103                              TYPE_SIZE_UNIT (vtable_entry_type)));
 104
 105   d = tree_low_cst (fixed_offset, 0);
 106
 107   /* See if we already have the thunk in question.  For this_adjusting
 108      thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
 109      will be a BINFO.  */
 110   for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
 111     if (DECL_THIS_THUNK_P (thunk) == this_adjusting
 112         && THUNK_FIXED_OFFSET (thunk) == d
 113         && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
 114         && (!virtual_offset
 115             || (this_adjusting
 116                 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
 117                                       virtual_offset)
 118                 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
 119       return thunk;
 120
 121   /* All thunks must be created before FUNCTION is actually emitted;
 122      the ABI requires that all thunks be emitted together with the
 123      function to which they transfer control.  */
 124   my_friendly_assert (!TREE_ASM_WRITTEN (function), 20021025);
 125   /* Likewise, we can only be adding thunks to a function declared in
 126      the class currently being laid out.  */
 127   my_friendly_assert (TYPE_SIZE (DECL_CONTEXT (function))
 128                       && TYPE_BEING_DEFINED (DECL_CONTEXT (function)),
 129                       20031211);
 130
 131   thunk = build_decl (FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
 132   DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
 133   cxx_dup_lang_specific_decl (thunk);
 134   DECL_THUNKS (thunk) = NULL_TREE;
 135
 136   DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
 137   TREE_READONLY (thunk) = TREE_READONLY (function);
 138   TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
 139   TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
 140   if (flag_weak)
 141     comdat_linkage (thunk);
 142   SET_DECL_THUNK_P (thunk, this_adjusting);
 143   THUNK_TARGET (thunk) = function;
 144   THUNK_FIXED_OFFSET (thunk) = d;
 145   THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
 146   THUNK_ALIAS (thunk) = NULL_TREE;
 147
 148   /* The thunk itself is not a constructor or destructor, even if
 149      the thing it is thunking to is.  */
 150   DECL_INTERFACE_KNOWN (thunk) = 1;
 151   DECL_NOT_REALLY_EXTERN (thunk) = 1;
 152   DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
 153   DECL_DESTRUCTOR_P (thunk) = 0;
 154   DECL_CONSTRUCTOR_P (thunk) = 0;
 155   /* And neither is it a clone.  */
 156   DECL_CLONED_FUNCTION (thunk) = NULL_TREE;
 157   DECL_EXTERNAL (thunk) = 1;
 158   DECL_ARTIFICIAL (thunk) = 1;
 159   /* Even if this thunk is a member of a local class, we don't
 160      need a static chain.  */
 161   DECL_NO_STATIC_CHAIN (thunk) = 1;
 162   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
 163   DECL_PENDING_INLINE_P (thunk) = 0;
 164   DECL_INLINE (thunk) = 0;
 165   DECL_DECLARED_INLINE_P (thunk) = 0;
 166   /* Nor has it been deferred.  */
 167   DECL_DEFERRED_FN (thunk) = 0;
 168
 169   /* Add it to the list of thunks associated with FUNCTION.  */
 170   TREE_CHAIN (thunk) = DECL_THUNKS (function);
 171   DECL_THUNKS (function) = thunk;
 172
 173   return thunk;
 174 }
 175
 176 /* Finish THUNK, a thunk decl.  */
 177
 178 void
 179 finish_thunk (tree thunk)
 180 {
 181   tree function, name;
 182   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
 183   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
 184
 185   my_friendly_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk), 20021127);
 186   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
 187     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 188   function = THUNK_TARGET (thunk);
 189   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
 190                        fixed_offset, virtual_offset);
 191
 192   /* We can end up with declarations of (logically) different
 193      covariant thunks, that do identical adjustments.  The two thunks
 194      will be adjusting between within different hierarchies, which
 195      happen to have the same layout.  We must nullify one of them to
 196      refer to the other.  */
 197   if (DECL_RESULT_THUNK_P (thunk))
 198     {
 199       tree cov_probe;
 200
 201       for (cov_probe = DECL_THUNKS (function);
 202            cov_probe; cov_probe = TREE_CHAIN (cov_probe))
 203         if (DECL_NAME (cov_probe) == name)
 204           {
 205             my_friendly_assert (!DECL_THUNKS (thunk), 20031023);
 206             THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
 207                                    ? THUNK_ALIAS (cov_probe) : cov_probe);
 208             break;
 209           }
 210     }
 211
 212   DECL_NAME (thunk) = name;
 213   SET_DECL_ASSEMBLER_NAME (thunk, name);
 214 }
 215
 216 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
 217    offset indicated by VIRTUAL_OFFSET, if that is
 218    non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
 219    zero for a result adjusting thunk.  */
 220
 221 static tree
 222 thunk_adjust (tree ptr, bool this_adjusting,
 223               HOST_WIDE_INT fixed_offset, tree virtual_offset)
 224 {
 225   if (this_adjusting)
 226     /* Adjust the pointer by the constant.  */
 227     ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 228                        ssize_int (fixed_offset)));
 229
 230   /* If there's a virtual offset, look up that value in the vtable and
 231      adjust the pointer again.  */
 232   if (virtual_offset)
 233     {
 234       tree vtable;
 235
 236       ptr = save_expr (ptr);
 237       /* The vptr is always at offset zero in the object.  */
 238       vtable = build1 (NOP_EXPR,
 239                        build_pointer_type (build_pointer_type
 240                                            (vtable_entry_type)),
 241                        ptr);
 242       /* Form the vtable address.  */
 243       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 244       /* Find the entry with the vcall offset.  */
 245       vtable = build (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
 246       /* Get the offset itself.  */
 247       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 248       /* Adjust the `this' pointer.  */
 249       ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable));
 250     }
 251
 252   if (!this_adjusting)
 253     /* Adjust the pointer by the constant.  */
 254     ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 255                        ssize_int (fixed_offset)));
 256
 257   return ptr;
 258 }
 259
 260 static GTY (()) int thunk_labelno;
 261
 262 /* Create a static alias to function.  */
 263
 264 static tree
 265 make_alias_for_thunk (tree function)
 266 {
 267   tree alias;
 268   char buf[256];
 269
 270   ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
 271   thunk_labelno++;
 272   alias = build_decl (FUNCTION_DECL, get_identifier (buf),
 273                       TREE_TYPE (function));
 274   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
 275   cxx_dup_lang_specific_decl (alias);
 276   DECL_CONTEXT (alias) = NULL;
 277   TREE_READONLY (alias) = TREE_READONLY (function);
 278   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
 279   TREE_PUBLIC (alias) = 0;
 280   DECL_INTERFACE_KNOWN (alias) = 1;
 281   DECL_NOT_REALLY_EXTERN (alias) = 1;
 282   DECL_THIS_STATIC (alias) = 1;
 283   DECL_SAVED_FUNCTION_DATA (alias) = NULL;
 284   DECL_DESTRUCTOR_P (alias) = 0;
 285   DECL_CONSTRUCTOR_P (alias) = 0;
 286   DECL_CLONED_FUNCTION (alias) = NULL_TREE;
 287   DECL_EXTERNAL (alias) = 0;
 288   DECL_ARTIFICIAL (alias) = 1;
 289   DECL_NO_STATIC_CHAIN (alias) = 1;
 290   DECL_PENDING_INLINE_P (alias) = 0;
 291   DECL_INLINE (alias) = 0;
 292   DECL_DECLARED_INLINE_P (alias) = 0;
 293   DECL_DEFERRED_FN (alias) = 0;
 294   DECL_USE_TEMPLATE (alias) = 0;
 295   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
 296   DECL_TEMPLATE_INFO (alias) = NULL;
 297   DECL_INITIAL (alias) = error_mark_node;
 298   TREE_ADDRESSABLE (alias) = 1;
 299   TREE_USED (alias) = 1;
 300   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
 301   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
 302   if (!flag_syntax_only)
 303     assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
 304   return alias;
 305 }
 306
 307 /* Emit the definition of a C++ multiple inheritance or covariant
 308    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
 309    immediately.  */
 310
 311 void
 312 use_thunk (tree thunk_fndecl, bool emit_p)
 313 {
 314   tree a, t, function, alias;
 315   tree virtual_offset;
 316   HOST_WIDE_INT fixed_offset, virtual_value;
 317   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
 318
 319   /* We should have called finish_thunk to give it a name.  */
 320   my_friendly_assert (DECL_NAME (thunk_fndecl), 20021127);
 321
 322   /* We should never be using an alias, always refer to the
 323      aliased thunk.  */
 324   my_friendly_assert (!THUNK_ALIAS (thunk_fndecl), 20031023);
 325
 326   if (TREE_ASM_WRITTEN (thunk_fndecl))
 327     return;
 328
 329   function = THUNK_TARGET (thunk_fndecl);
 330   if (DECL_RESULT (thunk_fndecl))
 331     /* We already turned this thunk into an ordinary function.
 332        There's no need to process this thunk again.  */
 333     return;
 334
 335   /* Thunks are always addressable; they only appear in vtables.  */
 336   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 337
 338   /* Figure out what function is being thunked to.  It's referenced in
 339      this translation unit.  */
 340   TREE_ADDRESSABLE (function) = 1;
 341   mark_used (function);
 342   if (!emit_p)
 343     return;
 344
 345   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
 346    alias = make_alias_for_thunk (function);
 347   else
 348    alias = function;
 349
 350   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
 351   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
 352
 353   if (virtual_offset)
 354     {
 355       if (!this_adjusting)
 356         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 357       virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
 358       my_friendly_assert (virtual_value, 20021026);
 359     }
 360   else
 361     virtual_value = 0;
 362
 363   /* And, if we need to emit the thunk, it's used.  */
 364   mark_used (thunk_fndecl);
 365   /* This thunk is actually defined.  */
 366   DECL_EXTERNAL (thunk_fndecl) = 0;
 367   /* The linkage of the function may have changed.  FIXME in linkage
 368      rewrite.  */
 369   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
 370   DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (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 `%#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 = build (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 = build (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 = build (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 `%#D', can't use default assignment operator", field);
 653               continue;
 654             }
 655           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 656             {
 657               error ("non-static reference member `%#D', can't use default assignment operator", field);
 658               continue;
 659             }
 660
 661           comp = current_class_ref;
 662           init = parm;
 663
 664           if (DECL_NAME (field))
 665             {
 666               if (VFIELD_NAME_P (DECL_NAME (field)))
 667                 continue;
 668             }
 669           else if ((t = TREE_TYPE (field)) != NULL_TREE
 670                    && ANON_AGGR_TYPE_P (t)
 671                    && TYPE_FIELDS (t) != NULL_TREE)
 672             /* Just use the field; anonymous types can't have
 673                nontrivial copy ctors or assignment ops.  */;
 674           else
 675             continue;
 676
 677           comp = build (COMPONENT_REF, TREE_TYPE (field), comp, field,
 678                         NULL_TREE);
 679           init = build (COMPONENT_REF,
 680                         cp_build_qualified_type (TREE_TYPE (field), cvquals),
 681                         init, field, NULL_TREE);
 682
 683           if (DECL_NAME (field))
 684             finish_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
 685           else
 686             finish_expr_stmt (build (MODIFY_EXPR, TREE_TYPE (comp), comp,
 687                                      init));
 688         }
 689     }
 690   finish_return_stmt (current_class_ref);
 691   finish_compound_stmt (compound_stmt);
 692 }
 693
 694 void
 695 synthesize_method (tree fndecl)
 696 {
 697   bool nested = (current_function_decl != NULL_TREE);
 698   tree context = decl_function_context (fndecl);
 699   bool need_body = true;
 700   tree stmt;
 701
 702   if (at_eof)
 703     import_export_decl (fndecl);
 704
 705   /* If we've been asked to synthesize a clone, just synthesize the
 706      cloned function instead.  Doing so will automatically fill in the
 707      body for the clone.  */
 708   if (DECL_CLONED_FUNCTION_P (fndecl))
 709     {
 710       synthesize_method (DECL_CLONED_FUNCTION (fndecl));
 711       return;
 712     }
 713
 714   /* We may be in the middle of deferred access check.  Disable
 715      it now.  */
 716   push_deferring_access_checks (dk_no_deferred);
 717
 718   if (! context)
 719     push_to_top_level ();
 720   else if (nested)
 721     push_function_context_to (context);
 722
 723   /* Put the function definition at the position where it is needed,
 724      rather than within the body of the class.  That way, an error
 725      during the generation of the implicit body points at the place
 726      where the attempt to generate the function occurs, giving the
 727      user a hint as to why we are attempting to generate the
 728      function.  */
 729   DECL_SOURCE_LOCATION (fndecl) = input_location;
 730
 731   interface_unknown = 1;
 732   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 733   stmt = begin_function_body ();
 734
 735   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 736     {
 737       do_build_assign_ref (fndecl);
 738       need_body = false;
 739     }
 740   else if (DECL_CONSTRUCTOR_P (fndecl))
 741     {
 742       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 743       if (arg_chain != void_list_node)
 744         do_build_copy_constructor (fndecl);
 745       else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
 746         finish_mem_initializers (NULL_TREE);
 747     }
 748
 749   /* If we haven't yet generated the body of the function, just
 750      generate an empty compound statement.  */
 751   if (need_body)
 752     {
 753       tree compound_stmt;
 754       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
 755       finish_compound_stmt (compound_stmt);
 756     }
 757
 758   finish_function_body (stmt);
 759   expand_or_defer_fn (finish_function (0));
 760
 761   extract_interface_info ();
 762   if (! context)
 763     pop_from_top_level ();
 764   else if (nested)
 765     pop_function_context_from (context);
 766
 767   pop_deferring_access_checks ();
 768 }
 769
 770 /* Use EXTRACTOR to locate the relevant function called for each base &
 771    class field of TYPE. CLIENT allows additional information to be passed
 772    to EXTRACTOR.  Generates the union of all exceptions generated by those
 773    functions.  Note that we haven't updated TYPE_FIELDS and such of any
 774    variants yet, so we need to look at the main one.  */
 775
 776 static tree
 777 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
 778                            void *client)
 779 {
 780   tree raises = empty_except_spec;
 781   tree fields = TYPE_FIELDS (type);
 782   tree binfo, base_binfo;
 783   int i;
 784
 785   for (binfo = TYPE_BINFO (type), i = 0;
 786        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 787     {
 788       tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
 789       if (fn)
 790         {
 791           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 792
 793           raises = merge_exception_specifiers (raises, fn_raises);
 794         }
 795     }
 796   for (; fields; fields = TREE_CHAIN (fields))
 797     {
 798       tree type = TREE_TYPE (fields);
 799       tree fn;
 800
 801       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
 802         continue;
 803       while (TREE_CODE (type) == ARRAY_TYPE)
 804         type = TREE_TYPE (type);
 805       if (TREE_CODE (type) != RECORD_TYPE)
 806         continue;
 807
 808       fn = (*extractor) (type, client);
 809       if (fn)
 810         {
 811           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 812
 813           raises = merge_exception_specifiers (raises, fn_raises);
 814         }
 815     }
 816   return raises;
 817 }
 818
 819 /* Locate the dtor of TYPE.  */
 820
 821 static tree
 822 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
 823 {
 824   return (CLASSTYPE_METHOD_VEC (type)
 825           ? CLASSTYPE_DESTRUCTORS (type)
 826           : NULL_TREE);
 827 }
 828
 829 /* Locate the default ctor of TYPE.  */
 830
 831 static tree
 832 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
 833 {
 834   tree fns;
 835
 836   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 837     return NULL_TREE;
 838
 839   /* Call lookup_fnfields_1 to create the constructor declarations, if
 840      necessary.  */
 841   if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
 842     return lazily_declare_fn (sfk_constructor, type);
 843
 844   for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
 845     {
 846       tree fn = OVL_CURRENT (fns);
 847       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 848
 849       if (sufficient_parms_p (TREE_CHAIN (parms)))
 850         return fn;
 851     }
 852   return NULL_TREE;
 853 }
 854
 855 struct copy_data
 856 {
 857   tree name;
 858   int quals;
 859 };
 860
 861 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
 862    points to a COPY_DATA holding the name (NULL for the ctor)
 863    and desired qualifiers of the source operand.  */
 864
 865 static tree
 866 locate_copy (tree type, void *client_)
 867 {
 868   struct copy_data *client = (struct copy_data *)client_;
 869   tree fns;
 870   tree best = NULL_TREE;
 871   bool excess_p = false;
 872
 873   if (client->name)
 874     {
 875       int ix;
 876       ix = lookup_fnfields_1 (type, client->name);
 877       if (ix < 0)
 878         return NULL_TREE;
 879       fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
 880     }
 881   else if (TYPE_HAS_INIT_REF (type))
 882     {
 883       /* If construction of the copy constructor was postponed, create
 884          it now.  */
 885       if (CLASSTYPE_LAZY_COPY_CTOR (type))
 886         lazily_declare_fn (sfk_copy_constructor, type);
 887       fns = CLASSTYPE_CONSTRUCTORS (type);
 888     }
 889   else
 890     return NULL_TREE;
 891   for (; fns; fns = OVL_NEXT (fns))
 892     {
 893       tree fn = OVL_CURRENT (fns);
 894       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 895       tree src_type;
 896       int excess;
 897       int quals;
 898
 899       parms = TREE_CHAIN (parms);
 900       if (!parms)
 901         continue;
 902       src_type = non_reference (TREE_VALUE (parms));
 903       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 904         continue;
 905       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 906         continue;
 907       quals = cp_type_quals (src_type);
 908       if (client->quals & ~quals)
 909         continue;
 910       excess = quals & ~client->quals;
 911       if (!best || (excess_p && !excess))
 912         {
 913           best = fn;
 914           excess_p = excess;
 915         }
 916       else
 917         /* Ambiguous */
 918         return NULL_TREE;
 919     }
 920   return best;
 921 }
 922
 923 /* Implicitly declare the special function indicated by KIND, as a
 924    member of TYPE.  For copy constructors and assignment operators,
 925    CONST_P indicates whether these functions should take a const
 926    reference argument or a non-const reference.  */
 927
 928 tree
 929 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
 930 {
 931   tree fn;
 932   tree parameter_types = void_list_node;
 933   tree return_type = void_type_node;
 934   tree fn_type;
 935   tree raises = empty_except_spec;
 936   tree rhs_parm_type = NULL_TREE;
 937   tree name;
 938
 939   type = TYPE_MAIN_VARIANT (type);
 940
 941   switch (kind)
 942     {
 943     case sfk_destructor:
 944       /* Destructor.  */
 945       name = constructor_name (type);
 946       raises = synthesize_exception_spec (type, &locate_dtor, 0);
 947       break;
 948
 949     case sfk_constructor:
 950       /* Default constructor.  */
 951       name = constructor_name (type);
 952       raises = synthesize_exception_spec (type, &locate_ctor, 0);
 953       break;
 954
 955     case sfk_copy_constructor:
 956     case sfk_assignment_operator:
 957     {
 958       struct copy_data data;
 959
 960       data.name = NULL;
 961       data.quals = 0;
 962       if (kind == sfk_assignment_operator)
 963         {
 964           return_type = build_reference_type (type);
 965           name = ansi_assopname (NOP_EXPR);
 966           data.name = name;
 967         }
 968       else
 969         name = constructor_name (type);
 970
 971       if (const_p)
 972         {
 973           data.quals = TYPE_QUAL_CONST;
 974           rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
 975         }
 976       else
 977         rhs_parm_type = type;
 978       rhs_parm_type = build_reference_type (rhs_parm_type);
 979       parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
 980       raises = synthesize_exception_spec (type, &locate_copy, &data);
 981       break;
 982     }
 983     default:
 984       abort ();
 985     }
 986
 987   /* Create the function.  */
 988   fn_type = build_method_type_directly (type, return_type, parameter_types);
 989   if (raises)
 990     fn_type = build_exception_variant (fn_type, raises);
 991   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
 992   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
 993   if (kind == sfk_constructor || kind == sfk_copy_constructor)
 994     DECL_CONSTRUCTOR_P (fn) = 1;
 995   else if (kind == sfk_destructor)
 996     DECL_DESTRUCTOR_P (fn) = 1;
 997   else
 998     {
 999       DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1000       SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1001     }
1002   /* Create the argument list.  The call to "grokclassfn" will add the
1003      "this" parameter and any other implicit parameters.  */
1004   if (rhs_parm_type)
1005     {
1006       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1007          want its type to be included in the mangled function
1008          name.  */
1009       DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1010       TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1011     }
1012
1013   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL,
1014                TYPE_UNQUALIFIED);
1015   grok_special_member_properties (fn);
1016   TREE_PUBLIC (fn) = !decl_function_context (TYPE_MAIN_DECL (type));
1017   rest_of_decl_compilation (fn, /*asmspec=*/NULL,
1018                             toplevel_bindings_p (), at_eof);
1019   DECL_IN_AGGR_P (fn) = 1;
1020   DECL_ARTIFICIAL (fn) = 1;
1021   DECL_NOT_REALLY_EXTERN (fn) = 1;
1022   DECL_DECLARED_INLINE_P (fn) = 1;
1023   DECL_INLINE (fn) = 1;
1024   if (TREE_USED (fn))
1025     abort ();
1026
1027   return fn;
1028 }
1029
1030 /* Add an implicit declaration to TYPE for the kind of function
1031    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
1032    declaration.  */
1033
1034 tree
1035 lazily_declare_fn (special_function_kind sfk, tree type)
1036 {
1037   tree fn;
1038   bool const_p;
1039
1040   /* Figure out whether or not the argument has a const reference
1041      type.  */
1042   if (sfk == sfk_copy_constructor)
1043     const_p = TYPE_HAS_CONST_INIT_REF (type);
1044   else if (sfk == sfk_assignment_operator)
1045     const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1046   else
1047     /* In this case, CONST_P will be ignored.  */
1048     const_p = false;
1049   /* Declare the function.  */
1050   fn = implicitly_declare_fn (sfk, type, const_p);
1051   /* Add it to CLASSTYPE_METHOD_VEC.  */
1052   add_method (type, fn);
1053   /* Add it to TYPE_METHODS.  */
1054   TREE_CHAIN (fn) = TYPE_METHODS (type);
1055   TYPE_METHODS (type) = fn;
1056   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1057   if (sfk == sfk_constructor || sfk == sfk_copy_constructor)
1058     {
1059       /* Remember that the function has been created.  */
1060       if (sfk == sfk_constructor)
1061         CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1062       else
1063         CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1064       /* Create appropriate clones.  */
1065       clone_function_decl (fn, /*update_method_vec=*/true);
1066     }
1067   else if (sfk == sfk_assignment_operator)
1068     CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1069
1070   return fn;
1071 }
1072
1073 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1074    as there are artificial parms in FN.  */
1075
1076 tree
1077 skip_artificial_parms_for (tree fn, tree list)
1078 {
1079   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1080     list = TREE_CHAIN (list);
1081   else
1082     return list;
1083
1084   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1085     list = TREE_CHAIN (list);
1086   if (DECL_HAS_VTT_PARM_P (fn))
1087     list = TREE_CHAIN (list);
1088   return list;
1089 }
1090
1091 #include "gt-cp-method.h"