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