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