gcc/cp/method.c

   1 /* Handle the hair of processing (but not expanding) inline functions.
   2    Also manage function and variable name overloading.
   3    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   4    1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.  */
  23
  24
  25 /* Handle method declarations.  */
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "tree.h"
  31 #include "cp-tree.h"
  32 #include "rtl.h"
  33 #include "expr.h"
  34 #include "output.h"
  35 #include "flags.h"
  36 #include "toplev.h"
  37 #include "tm_p.h"
  38 #include "target.h"
  39
  40 /* Various flags to control the mangling process.  */
  41
  42 enum mangling_flags
  43 {
  44   /* No flags.  */
  45   mf_none = 0,
  46   /* The thing we are presently mangling is part of a template type,
  47      rather than a fully instantiated type.  Therefore, we may see
  48      complex expressions where we would normally expect to see a
  49      simple integer constant.  */
  50   mf_maybe_uninstantiated = 1,
  51   /* When mangling a numeric value, use the form `_XX_' (instead of
  52      just `XX') if the value has more than one digit.  */
  53   mf_use_underscores_around_value = 2
  54 };
  55
  56 typedef enum mangling_flags mangling_flags;
  57
  58 static tree thunk_adjust (tree, bool, HOST_WIDE_INT, tree);
  59 static void do_build_assign_ref (tree);
  60 static void do_build_copy_constructor (tree);
  61 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *);
  62 static tree locate_dtor (tree, void *);
  63 static tree locate_ctor (tree, void *);
  64 static tree locate_copy (tree, void *);
  65 static tree make_alias_for_thunk (tree);
  66
  67 /* Called once to initialize method.c.  */
  68
  69 void
  70 init_method (void)
  71 {
  72   init_mangle ();
  73 }
  74 \f
  75 /* Return a this or result adjusting thunk to FUNCTION.  THIS_ADJUSTING
  76    indicates whether it is a this or result adjusting thunk.
  77    FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
  78    (see thunk_adjust).  VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
  79    never is.  VIRTUAL_OFFSET is the /index/ into the vtable for this
  80    adjusting thunks, we scale it to a byte offset. For covariant
  81    thunks VIRTUAL_OFFSET is the virtual binfo.  You must post process
  82    the returned thunk with finish_thunk.  */
  83
  84 tree
  85 make_thunk (tree function, bool this_adjusting,
  86             tree fixed_offset, tree virtual_offset)
  87 {
  88   HOST_WIDE_INT d;
  89   tree thunk;
  90
  91   my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 20021025);
  92   /* We can have this thunks to covariant thunks, but not vice versa.  */
  93   my_friendly_assert (!DECL_THIS_THUNK_P (function), 20021127);
  94   my_friendly_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting,
  95                       20031123);
  96
  97   /* Scale the VIRTUAL_OFFSET to be in terms of bytes.  */
  98   if (this_adjusting && virtual_offset)
  99     virtual_offset
 100       = size_binop (MULT_EXPR,
 101                     virtual_offset,
 102                     convert (ssizetype,
 103                              TYPE_SIZE_UNIT (vtable_entry_type)));
 104
 105   d = tree_low_cst (fixed_offset, 0);
 106
 107   /* See if we already have the thunk in question.  For this_adjusting
 108      thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
 109      will be a BINFO.  */
 110   for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
 111     if (DECL_THIS_THUNK_P (thunk) == this_adjusting
 112         && THUNK_FIXED_OFFSET (thunk) == d
 113         && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
 114         && (!virtual_offset
 115             || (this_adjusting
 116                 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
 117                                       virtual_offset)
 118                 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
 119       return thunk;
 120
 121   /* All thunks must be created before FUNCTION is actually emitted;
 122      the ABI requires that all thunks be emitted together with the
 123      function to which they transfer control.  */
 124   my_friendly_assert (!TREE_ASM_WRITTEN (function), 20021025);
 125   /* Likewise, we can only be adding thunks to a function declared in
 126      the class currently being laid out.  */
 127   my_friendly_assert (TYPE_SIZE (DECL_CONTEXT (function))
 128                       && TYPE_BEING_DEFINED (DECL_CONTEXT (function)),
 129                       20031211);
 130
 131   thunk = build_decl (FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
 132   DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
 133   cxx_dup_lang_specific_decl (thunk);
 134   DECL_THUNKS (thunk) = NULL_TREE;
 135
 136   DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
 137   TREE_READONLY (thunk) = TREE_READONLY (function);
 138   TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
 139   TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
 140   if (flag_weak)
 141     comdat_linkage (thunk);
 142   SET_DECL_THUNK_P (thunk, this_adjusting);
 143   THUNK_TARGET (thunk) = function;
 144   THUNK_FIXED_OFFSET (thunk) = d;
 145   THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
 146   THUNK_ALIAS (thunk) = NULL_TREE;
 147
 148   /* The thunk itself is not a constructor or destructor, even if
 149      the thing it is thunking to is.  */
 150   DECL_INTERFACE_KNOWN (thunk) = 1;
 151   DECL_NOT_REALLY_EXTERN (thunk) = 1;
 152   DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
 153   DECL_DESTRUCTOR_P (thunk) = 0;
 154   DECL_CONSTRUCTOR_P (thunk) = 0;
 155   /* And neither is it a clone.  */
 156   DECL_CLONED_FUNCTION (thunk) = NULL_TREE;
 157   DECL_EXTERNAL (thunk) = 1;
 158   DECL_ARTIFICIAL (thunk) = 1;
 159   /* Even if this thunk is a member of a local class, we don't
 160      need a static chain.  */
 161   DECL_NO_STATIC_CHAIN (thunk) = 1;
 162   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
 163   DECL_PENDING_INLINE_P (thunk) = 0;
 164   DECL_INLINE (thunk) = 0;
 165   DECL_DECLARED_INLINE_P (thunk) = 0;
 166   /* Nor has it been deferred.  */
 167   DECL_DEFERRED_FN (thunk) = 0;
 168
 169   /* Add it to the list of thunks associated with FUNCTION.  */
 170   TREE_CHAIN (thunk) = DECL_THUNKS (function);
 171   DECL_THUNKS (function) = thunk;
 172
 173   return thunk;
 174 }
 175
 176 /* Finish THUNK, a thunk decl.  */
 177
 178 void
 179 finish_thunk (tree thunk)
 180 {
 181   tree function, name;
 182   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
 183   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
 184
 185   my_friendly_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk), 20021127);
 186   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
 187     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 188   function = THUNK_TARGET (thunk);
 189   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
 190                        fixed_offset, virtual_offset);
 191
 192   /* We can end up with declarations of (logically) different
 193      covariant thunks, that do identical adjustments.  The two thunks
 194      will be adjusting between within different hierarchies, which
 195      happen to have the same layout.  We must nullify one of them to
 196      refer to the other.  */
 197   if (DECL_RESULT_THUNK_P (thunk))
 198     {
 199       tree cov_probe;
 200
 201       for (cov_probe = DECL_THUNKS (function);
 202            cov_probe; cov_probe = TREE_CHAIN (cov_probe))
 203         if (DECL_NAME (cov_probe) == name)
 204           {
 205             my_friendly_assert (!DECL_THUNKS (thunk), 20031023);
 206             THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
 207                                    ? THUNK_ALIAS (cov_probe) : cov_probe);
 208             break;
 209           }
 210     }
 211
 212   DECL_NAME (thunk) = name;
 213   SET_DECL_ASSEMBLER_NAME (thunk, name);
 214 }
 215
 216 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
 217    offset indicated by VIRTUAL_OFFSET, if that is
 218    non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
 219    zero for a result adjusting thunk.  */
 220
 221 static tree
 222 thunk_adjust (tree ptr, bool this_adjusting,
 223               HOST_WIDE_INT fixed_offset, tree virtual_offset)
 224 {
 225   if (this_adjusting)
 226     /* Adjust the pointer by the constant.  */
 227     ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 228                        ssize_int (fixed_offset)));
 229
 230   /* If there's a virtual offset, look up that value in the vtable and
 231      adjust the pointer again.  */
 232   if (virtual_offset)
 233     {
 234       tree vtable;
 235
 236       ptr = save_expr (ptr);
 237       /* The vptr is always at offset zero in the object.  */
 238       vtable = build1 (NOP_EXPR,
 239                        build_pointer_type (build_pointer_type
 240                                            (vtable_entry_type)),
 241                        ptr);
 242       /* Form the vtable address.  */
 243       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 244       /* Find the entry with the vcall offset.  */
 245       vtable = build (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
 246       /* Get the offset itself.  */
 247       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 248       /* Adjust the `this' pointer.  */
 249       ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable));
 250     }
 251
 252   if (!this_adjusting)
 253     /* Adjust the pointer by the constant.  */
 254     ptr = fold (build (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 255                        ssize_int (fixed_offset)));
 256
 257   return ptr;
 258 }
 259
 260 static GTY (()) int thunk_labelno;
 261
 262 /* Create a static alias to function.  */
 263
 264 static tree
 265 make_alias_for_thunk (tree function)
 266 {
 267   tree alias;
 268   char buf[256];
 269
 270   ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
 271   thunk_labelno++;
 272   alias = build_decl (FUNCTION_DECL, get_identifier (buf),
 273                       TREE_TYPE (function));
 274   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
 275   cxx_dup_lang_specific_decl (alias);
 276   DECL_CONTEXT (alias) = NULL;
 277   TREE_READONLY (alias) = TREE_READONLY (function);
 278   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
 279   TREE_PUBLIC (alias) = 0;
 280   DECL_INTERFACE_KNOWN (alias) = 1;
 281   DECL_NOT_REALLY_EXTERN (alias) = 1;
 282   DECL_THIS_STATIC (alias) = 1;
 283   DECL_SAVED_FUNCTION_DATA (alias) = NULL;
 284   DECL_DESTRUCTOR_P (alias) = 0;
 285   DECL_CONSTRUCTOR_P (alias) = 0;
 286   DECL_CLONED_FUNCTION (alias) = NULL_TREE;
 287   DECL_EXTERNAL (alias) = 0;
 288   DECL_ARTIFICIAL (alias) = 1;
 289   DECL_NO_STATIC_CHAIN (alias) = 1;
 290   DECL_PENDING_INLINE_P (alias) = 0;
 291   DECL_INLINE (alias) = 0;
 292   DECL_DECLARED_INLINE_P (alias) = 0;
 293   DECL_DEFERRED_FN (alias) = 0;
 294   DECL_USE_TEMPLATE (alias) = 0;
 295   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
 296   DECL_TEMPLATE_INFO (alias) = NULL;
 297   DECL_INITIAL (alias) = error_mark_node;
 298   TREE_ADDRESSABLE (alias) = 1;
 299   TREE_USED (alias) = 1;
 300   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
 301   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
 302   if (!flag_syntax_only)
 303     assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
 304   return alias;
 305 }
 306
 307 /* Emit the definition of a C++ multiple inheritance or covariant
 308    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
 309    immediately.  */
 310
 311 void
 312 use_thunk (tree thunk_fndecl, bool emit_p)
 313 {
 314   tree a, t, function, alias;
 315   tree virtual_offset;
 316   HOST_WIDE_INT fixed_offset, virtual_value;
 317   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
 318
 319   /* We should have called finish_thunk to give it a name.  */
 320   my_friendly_assert (DECL_NAME (thunk_fndecl), 20021127);
 321
 322   /* We should never be using an alias, always refer to the
 323      aliased thunk.  */
 324   my_friendly_assert (!THUNK_ALIAS (thunk_fndecl), 20031023);
 325
 326   if (TREE_ASM_WRITTEN (thunk_fndecl))
 327     return;
 328
 329   function = THUNK_TARGET (thunk_fndecl);
 330   if (DECL_RESULT (thunk_fndecl))
 331     /* We already turned this thunk into an ordinary function.
 332        There's no need to process this thunk again.  */
 333     return;
 334
 335   /* Thunks are always addressable; they only appear in vtables.  */
 336   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 337
 338   /* Figure out what function is being thunked to.  It's referenced in
 339      this translation unit.  */
 340   TREE_ADDRESSABLE (function) = 1;
 341   mark_used (function);
 342   if (!emit_p)
 343     return;
 344
 345   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
 346    alias = make_alias_for_thunk (function);
 347   else
 348    alias = function;
 349
 350   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
 351   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
 352
 353   if (virtual_offset)
 354     {
 355       if (!this_adjusting)
 356         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 357       virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
 358       my_friendly_assert (virtual_value, 20021026);
 359     }
 360   else
 361     virtual_value = 0;
 362
 363   /* And, if we need to emit the thunk, it's used.  */
 364   mark_used (thunk_fndecl);
 365   /* This thunk is actually defined.  */
 366   DECL_EXTERNAL (thunk_fndecl) = 0;
 367   /* The linkage of the function may have changed.  FIXME in linkage
 368      rewrite.  */
 369   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
 370   DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
 371   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 `%#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   tree t;
 505
 506   parm = convert_from_reference (parm);
 507
 508   if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
 509       && is_empty_class (current_class_type))
 510     /* Don't copy the padding byte; it might not have been allocated
 511        if *this is a base subobject.  */;
 512   else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
 513     {
 514       t = build (INIT_EXPR, void_type_node, current_class_ref, parm);
 515       finish_expr_stmt (t);
 516     }
 517   else
 518     {
 519       tree fields = TYPE_FIELDS (current_class_type);
 520       tree member_init_list = NULL_TREE;
 521       int cvquals = cp_type_quals (TREE_TYPE (parm));
 522       int i;
 523       tree binfo, base_binfo;
 524       VEC (tree) *vbases;
 525
 526       /* Initialize all the base-classes with the parameter converted
 527          to their type so that we get their copy constructor and not
 528          another constructor that takes current_class_type.  We must
 529          deal with the binfo's directly as a direct base might be
 530          inaccessible due to ambiguity.  */
 531       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
 532            VEC_iterate (tree, vbases, i, binfo); i++)
 533         {
 534           member_init_list
 535             = tree_cons (binfo,
 536                          build_tree_list (NULL_TREE,
 537                                           build_base_path (PLUS_EXPR, parm,
 538                                                            binfo, 1)),
 539                          member_init_list);
 540         }
 541
 542       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 543            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 544         {
 545           if (BINFO_VIRTUAL_P (base_binfo))
 546             continue;
 547
 548           member_init_list
 549             = tree_cons (base_binfo,
 550                          build_tree_list (NULL_TREE,
 551                                           build_base_path (PLUS_EXPR, parm,
 552                                                            base_binfo, 1)),
 553                          member_init_list);
 554         }
 555
 556       for (; fields; fields = TREE_CHAIN (fields))
 557         {
 558           tree init;
 559           tree field = fields;
 560           tree expr_type;
 561
 562           if (TREE_CODE (field) != FIELD_DECL)
 563             continue;
 564
 565           init = parm;
 566           if (DECL_NAME (field))
 567             {
 568               if (VFIELD_NAME_P (DECL_NAME (field)))
 569                 continue;
 570             }
 571           else if ((t = TREE_TYPE (field)) != NULL_TREE
 572                    && ANON_AGGR_TYPE_P (t)
 573                    && TYPE_FIELDS (t) != NULL_TREE)
 574             /* Just use the field; anonymous types can't have
 575                nontrivial copy ctors or assignment ops.  */;
 576           else
 577             continue;
 578
 579           /* Compute the type of "init->field".  If the copy-constructor
 580              parameter is, for example, "const S&", and the type of
 581              the field is "T", then the type will usually be "const
 582              T".  (There are no cv-qualified variants of reference
 583              types.)  */
 584           expr_type = TREE_TYPE (field);
 585           if (TREE_CODE (expr_type) != REFERENCE_TYPE)
 586             expr_type = cp_build_qualified_type (expr_type, cvquals);
 587           init = build (COMPONENT_REF, expr_type, init, field, NULL_TREE);
 588           init = build_tree_list (NULL_TREE, init);
 589
 590           member_init_list
 591             = tree_cons (field, init, member_init_list);
 592         }
 593       finish_mem_initializers (member_init_list);
 594     }
 595 }
 596
 597 static void
 598 do_build_assign_ref (tree fndecl)
 599 {
 600   tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
 601   tree compound_stmt;
 602
 603   compound_stmt = begin_compound_stmt (0);
 604   parm = convert_from_reference (parm);
 605
 606   if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)
 607       && is_empty_class (current_class_type))
 608     /* Don't copy the padding byte; it might not have been allocated
 609        if *this is a base subobject.  */;
 610   else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type))
 611     {
 612       tree t = build (MODIFY_EXPR, void_type_node, current_class_ref, parm);
 613       finish_expr_stmt (t);
 614     }
 615   else
 616     {
 617       tree fields;
 618       int cvquals = cp_type_quals (TREE_TYPE (parm));
 619       int i;
 620       tree binfo, base_binfo;
 621
 622       /* Assign to each of the direct base classes.  */
 623       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 624            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 625         {
 626           tree converted_parm;
 627
 628           /* We must convert PARM directly to the base class
 629              explicitly since the base class may be ambiguous.  */
 630           converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
 631           /* Call the base class assignment operator.  */
 632           finish_expr_stmt
 633             (build_special_member_call (current_class_ref,
 634                                         ansi_assopname (NOP_EXPR),
 635                                         build_tree_list (NULL_TREE,
 636                                                          converted_parm),
 637                                         base_binfo,
 638                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL));
 639         }
 640
 641       /* Assign to each of the non-static data members.  */
 642       for (fields = TYPE_FIELDS (current_class_type);
 643            fields;
 644            fields = TREE_CHAIN (fields))
 645         {
 646           tree comp, init, t;
 647           tree field = fields;
 648
 649           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 650             continue;
 651
 652           if (CP_TYPE_CONST_P (TREE_TYPE (field)))
 653             {
 654               error ("non-static const member `%#D', can't use default assignment operator", field);
 655               continue;
 656             }
 657           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
 658             {
 659               error ("non-static reference member `%#D', can't use default assignment operator", field);
 660               continue;
 661             }
 662
 663           comp = current_class_ref;
 664           init = parm;
 665
 666           if (DECL_NAME (field))
 667             {
 668               if (VFIELD_NAME_P (DECL_NAME (field)))
 669                 continue;
 670             }
 671           else if ((t = TREE_TYPE (field)) != NULL_TREE
 672                    && ANON_AGGR_TYPE_P (t)
 673                    && TYPE_FIELDS (t) != NULL_TREE)
 674             /* Just use the field; anonymous types can't have
 675                nontrivial copy ctors or assignment ops.  */;
 676           else
 677             continue;
 678
 679           comp = build (COMPONENT_REF, TREE_TYPE (field), comp, field,
 680                         NULL_TREE);
 681           init = build (COMPONENT_REF,
 682                         cp_build_qualified_type (TREE_TYPE (field), cvquals),
 683                         init, field, NULL_TREE);
 684
 685           if (DECL_NAME (field))
 686             finish_expr_stmt (build_modify_expr (comp, NOP_EXPR, init));
 687           else
 688             finish_expr_stmt (build (MODIFY_EXPR, TREE_TYPE (comp), comp,
 689                                      init));
 690         }
 691     }
 692   finish_return_stmt (current_class_ref);
 693   finish_compound_stmt (compound_stmt);
 694 }
 695
 696 void
 697 synthesize_method (tree fndecl)
 698 {
 699   bool nested = (current_function_decl != NULL_TREE);
 700   tree context = decl_function_context (fndecl);
 701   bool need_body = true;
 702   tree stmt;
 703
 704   /* If we've been asked to synthesize a clone, just synthesize the
 705      cloned function instead.  Doing so will automatically fill in the
 706      body for the clone.  */
 707   if (DECL_CLONED_FUNCTION_P (fndecl))
 708     {
 709       synthesize_method (DECL_CLONED_FUNCTION (fndecl));
 710       return;
 711     }
 712
 713   /* We may be in the middle of deferred access check.  Disable
 714      it now.  */
 715   push_deferring_access_checks (dk_no_deferred);
 716
 717   if (! context)
 718     push_to_top_level ();
 719   else if (nested)
 720     push_function_context_to (context);
 721
 722   /* Put the function definition at the position where it is needed,
 723      rather than within the body of the class.  That way, an error
 724      during the generation of the implicit body points at the place
 725      where the attempt to generate the function occurs, giving the
 726      user a hint as to why we are attempting to generate the
 727      function.  */
 728   DECL_SOURCE_LOCATION (fndecl) = input_location;
 729
 730   interface_unknown = 1;
 731   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 732   stmt = begin_function_body ();
 733
 734   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 735     {
 736       do_build_assign_ref (fndecl);
 737       need_body = false;
 738     }
 739   else if (DECL_CONSTRUCTOR_P (fndecl))
 740     {
 741       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 742       if (arg_chain != void_list_node)
 743         do_build_copy_constructor (fndecl);
 744       else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
 745         finish_mem_initializers (NULL_TREE);
 746     }
 747
 748   /* If we haven't yet generated the body of the function, just
 749      generate an empty compound statement.  */
 750   if (need_body)
 751     {
 752       tree compound_stmt;
 753       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
 754       finish_compound_stmt (compound_stmt);
 755     }
 756
 757   finish_function_body (stmt);
 758   expand_or_defer_fn (finish_function (0));
 759
 760   extract_interface_info ();
 761   if (! context)
 762     pop_from_top_level ();
 763   else if (nested)
 764     pop_function_context_from (context);
 765
 766   pop_deferring_access_checks ();
 767 }
 768
 769 /* Use EXTRACTOR to locate the relevant function called for each base &
 770    class field of TYPE. CLIENT allows additional information to be passed
 771    to EXTRACTOR.  Generates the union of all exceptions generated by those
 772    functions.  Note that we haven't updated TYPE_FIELDS and such of any
 773    variants yet, so we need to look at the main one.  */
 774
 775 static tree
 776 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
 777                            void *client)
 778 {
 779   tree raises = empty_except_spec;
 780   tree fields = TYPE_FIELDS (type);
 781   tree binfo, base_binfo;
 782   int i;
 783
 784   for (binfo = TYPE_BINFO (type), i = 0;
 785        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 786     {
 787       tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
 788       if (fn)
 789         {
 790           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 791
 792           raises = merge_exception_specifiers (raises, fn_raises);
 793         }
 794     }
 795   for (; fields; fields = TREE_CHAIN (fields))
 796     {
 797       tree type = TREE_TYPE (fields);
 798       tree fn;
 799
 800       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
 801         continue;
 802       while (TREE_CODE (type) == ARRAY_TYPE)
 803         type = TREE_TYPE (type);
 804       if (TREE_CODE (type) != RECORD_TYPE)
 805         continue;
 806
 807       fn = (*extractor) (type, client);
 808       if (fn)
 809         {
 810           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 811
 812           raises = merge_exception_specifiers (raises, fn_raises);
 813         }
 814     }
 815   return raises;
 816 }
 817
 818 /* Locate the dtor of TYPE.  */
 819
 820 static tree
 821 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
 822 {
 823   return (CLASSTYPE_METHOD_VEC (type)
 824           ? CLASSTYPE_DESTRUCTORS (type)
 825           : NULL_TREE);
 826 }
 827
 828 /* Locate the default ctor of TYPE.  */
 829
 830 static tree
 831 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
 832 {
 833   tree fns;
 834
 835   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 836     return NULL_TREE;
 837
 838   /* Call lookup_fnfields_1 to create the constructor declarations, if
 839      necessary.  */
 840   if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
 841     return lazily_declare_fn (sfk_constructor, type);
 842
 843   for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
 844     {
 845       tree fn = OVL_CURRENT (fns);
 846       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 847
 848       if (sufficient_parms_p (TREE_CHAIN (parms)))
 849         return fn;
 850     }
 851   return NULL_TREE;
 852 }
 853
 854 struct copy_data
 855 {
 856   tree name;
 857   int quals;
 858 };
 859
 860 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
 861    points to a COPY_DATA holding the name (NULL for the ctor)
 862    and desired qualifiers of the source operand.  */
 863
 864 static tree
 865 locate_copy (tree type, void *client_)
 866 {
 867   struct copy_data *client = (struct copy_data *)client_;
 868   tree fns;
 869   tree best = NULL_TREE;
 870   bool excess_p = false;
 871
 872   if (client->name)
 873     {
 874       int ix;
 875       ix = lookup_fnfields_1 (type, client->name);
 876       if (ix < 0)
 877         return NULL_TREE;
 878       fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
 879     }
 880   else if (TYPE_HAS_INIT_REF (type))
 881     {
 882       /* If construction of the copy constructor was postponed, create
 883          it now.  */
 884       if (CLASSTYPE_LAZY_COPY_CTOR (type))
 885         lazily_declare_fn (sfk_copy_constructor, type);
 886       fns = CLASSTYPE_CONSTRUCTORS (type);
 887     }
 888   else
 889     return NULL_TREE;
 890   for (; fns; fns = OVL_NEXT (fns))
 891     {
 892       tree fn = OVL_CURRENT (fns);
 893       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 894       tree src_type;
 895       int excess;
 896       int quals;
 897
 898       parms = TREE_CHAIN (parms);
 899       if (!parms)
 900         continue;
 901       src_type = non_reference (TREE_VALUE (parms));
 902       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 903         continue;
 904       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 905         continue;
 906       quals = cp_type_quals (src_type);
 907       if (client->quals & ~quals)
 908         continue;
 909       excess = quals & ~client->quals;
 910       if (!best || (excess_p && !excess))
 911         {
 912           best = fn;
 913           excess_p = excess;
 914         }
 915       else
 916         /* Ambiguous */
 917         return NULL_TREE;
 918     }
 919   return best;
 920 }
 921
 922 /* Implicitly declare the special function indicated by KIND, as a
 923    member of TYPE.  For copy constructors and assignment operators,
 924    CONST_P indicates whether these functions should take a const
 925    reference argument or a non-const reference.  */
 926
 927 tree
 928 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
 929 {
 930   tree fn;
 931   tree parameter_types = void_list_node;
 932   tree return_type = void_type_node;
 933   tree fn_type;
 934   tree raises = empty_except_spec;
 935   tree rhs_parm_type = NULL_TREE;
 936   tree name;
 937
 938   type = TYPE_MAIN_VARIANT (type);
 939
 940   switch (kind)
 941     {
 942     case sfk_destructor:
 943       /* Destructor.  */
 944       name = constructor_name (type);
 945       raises = synthesize_exception_spec (type, &locate_dtor, 0);
 946       break;
 947
 948     case sfk_constructor:
 949       /* Default constructor.  */
 950       name = constructor_name (type);
 951       raises = synthesize_exception_spec (type, &locate_ctor, 0);
 952       break;
 953
 954     case sfk_copy_constructor:
 955     case sfk_assignment_operator:
 956     {
 957       struct copy_data data;
 958
 959       data.name = NULL;
 960       data.quals = 0;
 961       if (kind == sfk_assignment_operator)
 962         {
 963           return_type = build_reference_type (type);
 964           name = ansi_assopname (NOP_EXPR);
 965           data.name = name;
 966         }
 967       else
 968         name = constructor_name (type);
 969
 970       if (const_p)
 971         {
 972           data.quals = TYPE_QUAL_CONST;
 973           rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
 974         }
 975       else
 976         rhs_parm_type = type;
 977       rhs_parm_type = build_reference_type (rhs_parm_type);
 978       parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
 979       raises = synthesize_exception_spec (type, &locate_copy, &data);
 980       break;
 981     }
 982     default:
 983       abort ();
 984     }
 985
 986   /* Create the function.  */
 987   fn_type = build_method_type_directly (type, return_type, parameter_types);
 988   if (raises)
 989     fn_type = build_exception_variant (fn_type, raises);
 990   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
 991   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
 992   if (kind == sfk_constructor || kind == sfk_copy_constructor)
 993     DECL_CONSTRUCTOR_P (fn) = 1;
 994   else if (kind == sfk_destructor)
 995     DECL_DESTRUCTOR_P (fn) = 1;
 996   else
 997     {
 998       DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
 999       SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1000     }
1001   /* Create the argument list.  The call to "grokclassfn" will add the
1002      "this" parameter and any other implicit parameters.  */
1003   if (rhs_parm_type)
1004     {
1005       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1006          want its type to be included in the mangled function
1007          name.  */
1008       DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1009       TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1010     }
1011
1012   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL,
1013                TYPE_UNQUALIFIED);
1014   grok_special_member_properties (fn);
1015   set_linkage_according_to_type (type, fn);
1016   rest_of_decl_compilation (fn, /*asmspec=*/NULL,
1017                             toplevel_bindings_p (), at_eof);
1018   DECL_IN_AGGR_P (fn) = 1;
1019   DECL_ARTIFICIAL (fn) = 1;
1020   DECL_NOT_REALLY_EXTERN (fn) = 1;
1021   DECL_DECLARED_INLINE_P (fn) = 1;
1022   DECL_INLINE (fn) = 1;
1023   if (TREE_USED (fn))
1024     abort ();
1025
1026   return fn;
1027 }
1028
1029 /* Add an implicit declaration to TYPE for the kind of function
1030    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
1031    declaration.  */
1032
1033 tree
1034 lazily_declare_fn (special_function_kind sfk, tree type)
1035 {
1036   tree fn;
1037   bool const_p;
1038
1039   /* Figure out whether or not the argument has a const reference
1040      type.  */
1041   if (sfk == sfk_copy_constructor)
1042     const_p = TYPE_HAS_CONST_INIT_REF (type);
1043   else if (sfk == sfk_assignment_operator)
1044     const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1045   else
1046     /* In this case, CONST_P will be ignored.  */
1047     const_p = false;
1048   /* Declare the function.  */
1049   fn = implicitly_declare_fn (sfk, type, const_p);
1050   /* Add it to CLASSTYPE_METHOD_VEC.  */
1051   add_method (type, fn);
1052   /* Add it to TYPE_METHODS.  */
1053   TREE_CHAIN (fn) = TYPE_METHODS (type);
1054   TYPE_METHODS (type) = fn;
1055   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1056   if (sfk == sfk_constructor || sfk == sfk_copy_constructor)
1057     {
1058       /* Remember that the function has been created.  */
1059       if (sfk == sfk_constructor)
1060         CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1061       else
1062         CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1063       /* Create appropriate clones.  */
1064       clone_function_decl (fn, /*update_method_vec=*/true);
1065     }
1066   else if (sfk == sfk_assignment_operator)
1067     CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1068
1069   return fn;
1070 }
1071
1072 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1073    as there are artificial parms in FN.  */
1074
1075 tree
1076 skip_artificial_parms_for (tree fn, tree list)
1077 {
1078   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1079     list = TREE_CHAIN (list);
1080   else
1081     return list;
1082
1083   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1084     list = TREE_CHAIN (list);
1085   if (DECL_HAS_VTT_PARM_P (fn))
1086     list = TREE_CHAIN (list);
1087   return list;
1088 }
1089
1090 #include "gt-cp-method.h"