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