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