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