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