gcc/cp/method.c

   1 /* Handle the hair of processing (but not expanding) inline functions.
   2    Also manage function and variable name overloading.
   3    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   4    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  22 Boston, MA 02110-1301, 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 #include "tree-pass.h"
  40 #include "diagnostic.h"
  41
  42 /* Various flags to control the mangling process.  */
  43
  44 enum mangling_flags
  45 {
  46   /* No flags.  */
  47   mf_none = 0,
  48   /* The thing we are presently mangling is part of a template type,
  49      rather than a fully instantiated type.  Therefore, we may see
  50      complex expressions where we would normally expect to see a
  51      simple integer constant.  */
  52   mf_maybe_uninstantiated = 1,
  53   /* When mangling a numeric value, use the form `_XX_' (instead of
  54      just `XX') if the value has more than one digit.  */
  55   mf_use_underscores_around_value = 2
  56 };
  57
  58 typedef enum mangling_flags mangling_flags;
  59
  60 static tree thunk_adjust (tree, bool, HOST_WIDE_INT, tree);
  61 static void do_build_assign_ref (tree);
  62 static void do_build_copy_constructor (tree);
  63 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *);
  64 static tree locate_dtor (tree, void *);
  65 static tree locate_ctor (tree, void *);
  66 static tree locate_copy (tree, void *);
  67 static tree make_alias_for_thunk (tree);
  68
  69 /* Called once to initialize method.c.  */
  70
  71 void
  72 init_method (void)
  73 {
  74   init_mangle ();
  75 }
  76 \f
  77 /* Return a this or result adjusting thunk to FUNCTION.  THIS_ADJUSTING
  78    indicates whether it is a this or result adjusting thunk.
  79    FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
  80    (see thunk_adjust).  VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
  81    never is.  VIRTUAL_OFFSET is the /index/ into the vtable for this
  82    adjusting thunks, we scale it to a byte offset. For covariant
  83    thunks VIRTUAL_OFFSET is the virtual binfo.  You must post process
  84    the returned thunk with finish_thunk.  */
  85
  86 tree
  87 make_thunk (tree function, bool this_adjusting,
  88             tree fixed_offset, tree virtual_offset)
  89 {
  90   HOST_WIDE_INT d;
  91   tree thunk;
  92
  93   gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
  94   /* We can have this thunks to covariant thunks, but not vice versa.  */
  95   gcc_assert (!DECL_THIS_THUNK_P (function));
  96   gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
  97
  98   /* Scale the VIRTUAL_OFFSET to be in terms of bytes.  */
  99   if (this_adjusting && virtual_offset)
 100     virtual_offset
 101       = size_binop (MULT_EXPR,
 102                     virtual_offset,
 103                     convert (ssizetype,
 104                              TYPE_SIZE_UNIT (vtable_entry_type)));
 105
 106   d = tree_low_cst (fixed_offset, 0);
 107
 108   /* See if we already have the thunk in question.  For this_adjusting
 109      thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
 110      will be a BINFO.  */
 111   for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
 112     if (DECL_THIS_THUNK_P (thunk) == this_adjusting
 113         && THUNK_FIXED_OFFSET (thunk) == d
 114         && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
 115         && (!virtual_offset
 116             || (this_adjusting
 117                 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
 118                                       virtual_offset)
 119                 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
 120       return thunk;
 121
 122   /* All thunks must be created before FUNCTION is actually emitted;
 123      the ABI requires that all thunks be emitted together with the
 124      function to which they transfer control.  */
 125   gcc_assert (!TREE_ASM_WRITTEN (function));
 126   /* Likewise, we can only be adding thunks to a function declared in
 127      the class currently being laid out.  */
 128   gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
 129               && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
 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   SET_DECL_THUNK_P (thunk, this_adjusting);
 141   THUNK_TARGET (thunk) = function;
 142   THUNK_FIXED_OFFSET (thunk) = d;
 143   THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
 144   THUNK_ALIAS (thunk) = NULL_TREE;
 145
 146   /* The thunk itself is not a constructor or destructor, even if
 147      the thing it is thunking to is.  */
 148   DECL_INTERFACE_KNOWN (thunk) = 1;
 149   DECL_NOT_REALLY_EXTERN (thunk) = 1;
 150   DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
 151   DECL_DESTRUCTOR_P (thunk) = 0;
 152   DECL_CONSTRUCTOR_P (thunk) = 0;
 153   DECL_EXTERNAL (thunk) = 1;
 154   DECL_ARTIFICIAL (thunk) = 1;
 155   /* Even if this thunk is a member of a local class, we don't
 156      need a static chain.  */
 157   DECL_NO_STATIC_CHAIN (thunk) = 1;
 158   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
 159   DECL_PENDING_INLINE_P (thunk) = 0;
 160   DECL_INLINE (thunk) = 0;
 161   DECL_DECLARED_INLINE_P (thunk) = 0;
 162   /* Nor has it been deferred.  */
 163   DECL_DEFERRED_FN (thunk) = 0;
 164   /* Nor is it a template instantiation.  */
 165   DECL_USE_TEMPLATE (thunk) = 0;
 166   DECL_TEMPLATE_INFO (thunk) = NULL;
 167
 168   /* Add it to the list of thunks associated with FUNCTION.  */
 169   TREE_CHAIN (thunk) = DECL_THUNKS (function);
 170   DECL_THUNKS (function) = thunk;
 171
 172   return thunk;
 173 }
 174
 175 /* Finish THUNK, a thunk decl.  */
 176
 177 void
 178 finish_thunk (tree thunk)
 179 {
 180   tree function, name;
 181   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
 182   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
 183
 184   gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
 185   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
 186     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 187   function = THUNK_TARGET (thunk);
 188   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
 189                        fixed_offset, virtual_offset);
 190
 191   /* We can end up with declarations of (logically) different
 192      covariant thunks, that do identical adjustments.  The two thunks
 193      will be adjusting between within different hierarchies, which
 194      happen to have the same layout.  We must nullify one of them to
 195      refer to the other.  */
 196   if (DECL_RESULT_THUNK_P (thunk))
 197     {
 198       tree cov_probe;
 199
 200       for (cov_probe = DECL_THUNKS (function);
 201            cov_probe; cov_probe = TREE_CHAIN (cov_probe))
 202         if (DECL_NAME (cov_probe) == name)
 203           {
 204             gcc_assert (!DECL_THUNKS (thunk));
 205             THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
 206                                    ? THUNK_ALIAS (cov_probe) : cov_probe);
 207             break;
 208           }
 209     }
 210
 211   DECL_NAME (thunk) = name;
 212   SET_DECL_ASSEMBLER_NAME (thunk, name);
 213 }
 214
 215 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
 216    offset indicated by VIRTUAL_OFFSET, if that is
 217    non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
 218    zero for a result adjusting thunk.  */
 219
 220 static tree
 221 thunk_adjust (tree ptr, bool this_adjusting,
 222               HOST_WIDE_INT fixed_offset, tree virtual_offset)
 223 {
 224   if (this_adjusting)
 225     /* Adjust the pointer by the constant.  */
 226     ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 227                        ssize_int (fixed_offset));
 228
 229   /* If there's a virtual offset, look up that value in the vtable and
 230      adjust the pointer again.  */
 231   if (virtual_offset)
 232     {
 233       tree vtable;
 234
 235       ptr = save_expr (ptr);
 236       /* The vptr is always at offset zero in the object.  */
 237       vtable = build1 (NOP_EXPR,
 238                        build_pointer_type (build_pointer_type
 239                                            (vtable_entry_type)),
 240                        ptr);
 241       /* Form the vtable address.  */
 242       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 243       /* Find the entry with the vcall offset.  */
 244       vtable = build2 (PLUS_EXPR, TREE_TYPE (vtable), vtable, virtual_offset);
 245       /* Get the offset itself.  */
 246       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 247       /* Adjust the `this' pointer.  */
 248       ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable);
 249     }
 250
 251   if (!this_adjusting)
 252     /* Adjust the pointer by the constant.  */
 253     ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr,
 254                        ssize_int (fixed_offset));
 255
 256   return ptr;
 257 }
 258
 259 static GTY (()) int thunk_labelno;
 260
 261 /* Create a static alias to function.  */
 262
 263 tree
 264 make_alias_for (tree function, tree newid)
 265 {
 266   tree alias = build_decl (FUNCTION_DECL, newid, TREE_TYPE (function));
 267   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
 268   cxx_dup_lang_specific_decl (alias);
 269   DECL_CONTEXT (alias) = NULL;
 270   TREE_READONLY (alias) = TREE_READONLY (function);
 271   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
 272   TREE_PUBLIC (alias) = 0;
 273   DECL_INTERFACE_KNOWN (alias) = 1;
 274   DECL_NOT_REALLY_EXTERN (alias) = 1;
 275   DECL_THIS_STATIC (alias) = 1;
 276   DECL_SAVED_FUNCTION_DATA (alias) = NULL;
 277   DECL_DESTRUCTOR_P (alias) = 0;
 278   DECL_CONSTRUCTOR_P (alias) = 0;
 279   DECL_CLONED_FUNCTION (alias) = NULL_TREE;
 280   DECL_EXTERNAL (alias) = 0;
 281   DECL_ARTIFICIAL (alias) = 1;
 282   DECL_NO_STATIC_CHAIN (alias) = 1;
 283   DECL_PENDING_INLINE_P (alias) = 0;
 284   DECL_INLINE (alias) = 0;
 285   DECL_DECLARED_INLINE_P (alias) = 0;
 286   DECL_DEFERRED_FN (alias) = 0;
 287   DECL_USE_TEMPLATE (alias) = 0;
 288   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
 289   DECL_TEMPLATE_INFO (alias) = NULL;
 290   DECL_INITIAL (alias) = error_mark_node;
 291   TREE_ADDRESSABLE (alias) = 1;
 292   TREE_USED (alias) = 1;
 293   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
 294   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
 295   return alias;
 296 }
 297
 298 static tree
 299 make_alias_for_thunk (tree function)
 300 {
 301   tree alias;
 302   char buf[256];
 303
 304   ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
 305   thunk_labelno++;
 306
 307   alias = make_alias_for (function, get_identifier (buf));
 308
 309   if (!flag_syntax_only)
 310     assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
 311
 312   return alias;
 313 }
 314
 315 /* Emit the definition of a C++ multiple inheritance or covariant
 316    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
 317    immediately.  */
 318
 319 void
 320 use_thunk (tree thunk_fndecl, bool emit_p)
 321 {
 322   tree a, t, function, alias;
 323   tree virtual_offset;
 324   HOST_WIDE_INT fixed_offset, virtual_value;
 325   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
 326
 327   /* We should have called finish_thunk to give it a name.  */
 328   gcc_assert (DECL_NAME (thunk_fndecl));
 329
 330   /* We should never be using an alias, always refer to the
 331      aliased thunk.  */
 332   gcc_assert (!THUNK_ALIAS (thunk_fndecl));
 333
 334   if (TREE_ASM_WRITTEN (thunk_fndecl))
 335     return;
 336
 337   function = THUNK_TARGET (thunk_fndecl);
 338   if (DECL_RESULT (thunk_fndecl))
 339     /* We already turned this thunk into an ordinary function.
 340        There's no need to process this thunk again.  */
 341     return;
 342
 343   if (DECL_THUNK_P (function))
 344     /* The target is itself a thunk, process it now.  */
 345     use_thunk (function, emit_p);
 346
 347   /* Thunks are always addressable; they only appear in vtables.  */
 348   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 349
 350   /* Figure out what function is being thunked to.  It's referenced in
 351      this translation unit.  */
 352   TREE_ADDRESSABLE (function) = 1;
 353   mark_used (function);
 354   if (!emit_p)
 355     return;
 356
 357   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
 358    alias = make_alias_for_thunk (function);
 359   else
 360    alias = function;
 361
 362   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
 363   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
 364
 365   if (virtual_offset)
 366     {
 367       if (!this_adjusting)
 368         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 369       virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
 370       gcc_assert (virtual_value);
 371     }
 372   else
 373     virtual_value = 0;
 374
 375   /* And, if we need to emit the thunk, it's used.  */
 376   mark_used (thunk_fndecl);
 377   /* This thunk is actually defined.  */
 378   DECL_EXTERNAL (thunk_fndecl) = 0;
 379   /* The linkage of the function may have changed.  FIXME in linkage
 380      rewrite.  */
 381   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
 382   DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
 383   DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
 384     = DECL_VISIBILITY_SPECIFIED (function);
 385   if (DECL_ONE_ONLY (function))
 386     make_decl_one_only (thunk_fndecl);
 387
 388   if (flag_syntax_only)
 389     {
 390       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 391       return;
 392     }
 393
 394   push_to_top_level ();
 395
 396   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
 397       && targetm.have_named_sections)
 398     {
 399       resolve_unique_section (function, 0, flag_function_sections);
 400
 401       if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
 402         {
 403           resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
 404
 405           /* Output the thunk into the same section as function.  */
 406           DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
 407         }
 408     }
 409
 410   /* Set up cloned argument trees for the thunk.  */
 411   t = NULL_TREE;
 412   for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
 413     {
 414       tree x = copy_node (a);
 415       TREE_CHAIN (x) = t;
 416       DECL_CONTEXT (x) = thunk_fndecl;
 417       SET_DECL_RTL (x, NULL_RTX);
 418       DECL_HAS_VALUE_EXPR_P (x) = 0;
 419       t = x;
 420     }
 421   a = nreverse (t);
 422   DECL_ARGUMENTS (thunk_fndecl) = a;
 423
 424   if (this_adjusting
 425       && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
 426                                               virtual_value, alias))
 427     {
 428       const char *fnname;
 429       tree fn_block;
 430
 431       current_function_decl = thunk_fndecl;
 432       DECL_RESULT (thunk_fndecl)
 433         = build_decl (RESULT_DECL, 0, integer_type_node);
 434       fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
 435       /* The back end expects DECL_INITIAL to contain a BLOCK, so we
 436          create one.  */
 437       fn_block = make_node (BLOCK);
 438       BLOCK_VARS (fn_block) = a;
 439       DECL_INITIAL (thunk_fndecl) = fn_block;
 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       init_insn_lengths ();
 449       current_function_decl = 0;
 450       cfun = 0;
 451       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 452     }
 453   else
 454     {
 455       int i;
 456       tree *argarray = (tree *) alloca (list_length (a) * sizeof (tree));
 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       if (varargs_function_p (function))
 463         error ("generic thunk code fails for method %q#D which uses %<...%>",
 464                function);
 465
 466       DECL_RESULT (thunk_fndecl) = NULL_TREE;
 467
 468       start_preparsed_function (thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
 469       /* We don't bother with a body block for thunks.  */
 470
 471       /* There's no need to check accessibility inside the thunk body.  */
 472       push_deferring_access_checks (dk_no_check);
 473
 474       t = a;
 475       if (this_adjusting)
 476         t = thunk_adjust (t, /*this_adjusting=*/1,
 477                           fixed_offset, virtual_offset);
 478
 479       /* Build up the call to the real function.  */
 480       argarray[0] = t;
 481       for (i = 1, a = TREE_CHAIN (a); a; a = TREE_CHAIN (a), i++)
 482         argarray[i] = a;
 483       t = build_call_a (alias, i, argarray);
 484       CALL_FROM_THUNK_P (t) = 1;
 485
 486       if (VOID_TYPE_P (TREE_TYPE (t)))
 487         finish_expr_stmt (t);
 488       else
 489         {
 490           if (!this_adjusting)
 491             {
 492               tree cond = NULL_TREE;
 493
 494               if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
 495                 {
 496                   /* If the return type is a pointer, we need to
 497                      protect against NULL.  We know there will be an
 498                      adjustment, because that's why we're emitting a
 499                      thunk.  */
 500                   t = save_expr (t);
 501                   cond = cp_convert (boolean_type_node, t);
 502                 }
 503
 504               t = thunk_adjust (t, /*this_adjusting=*/0,
 505                                 fixed_offset, virtual_offset);
 506               if (cond)
 507                 t = build3 (COND_EXPR, TREE_TYPE (t), cond, t,
 508                             cp_convert (TREE_TYPE (t), integer_zero_node));
 509             }
 510           if (IS_AGGR_TYPE (TREE_TYPE (t)))
 511             t = build_cplus_new (TREE_TYPE (t), t);
 512           finish_return_stmt (t);
 513         }
 514
 515       /* Since we want to emit the thunk, we explicitly mark its name as
 516          referenced.  */
 517       mark_decl_referenced (thunk_fndecl);
 518
 519       /* But we don't want debugging information about it.  */
 520       DECL_IGNORED_P (thunk_fndecl) = 1;
 521
 522       /* Re-enable access control.  */
 523       pop_deferring_access_checks ();
 524
 525       thunk_fndecl = finish_function (0);
 526       tree_lowering_passes (thunk_fndecl);
 527       expand_body (thunk_fndecl);
 528     }
 529
 530   pop_from_top_level ();
 531 }
 532 \f
 533 /* Code for synthesizing methods which have default semantics defined.  */
 534
 535 /* Generate code for default X(X&) constructor.  */
 536
 537 static void
 538 do_build_copy_constructor (tree fndecl)
 539 {
 540   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
 541
 542   parm = convert_from_reference (parm);
 543
 544   if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)
 545       && is_empty_class (current_class_type))
 546     /* Don't copy the padding byte; it might not have been allocated
 547        if *this is a base subobject.  */;
 548   else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type))
 549     {
 550       tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
 551       finish_expr_stmt (t);
 552     }
 553   else
 554     {
 555       tree fields = TYPE_FIELDS (current_class_type);
 556       tree member_init_list = NULL_TREE;
 557       int cvquals = cp_type_quals (TREE_TYPE (parm));
 558       int i;
 559       tree binfo, base_binfo;
 560       VEC(tree,gc) *vbases;
 561
 562       /* Initialize all the base-classes with the parameter converted
 563          to their type so that we get their copy constructor and not
 564          another constructor that takes current_class_type.  We must
 565          deal with the binfo's directly as a direct base might be
 566          inaccessible due to ambiguity.  */
 567       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
 568            VEC_iterate (tree, vbases, i, binfo); i++)
 569         {
 570           member_init_list
 571             = tree_cons (binfo,
 572                          build_tree_list (NULL_TREE,
 573                                           build_base_path (PLUS_EXPR, parm,
 574                                                            binfo, 1)),
 575                          member_init_list);
 576         }
 577
 578       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 579            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 580         {
 581           if (BINFO_VIRTUAL_P (base_binfo))
 582             continue;
 583
 584           member_init_list
 585             = tree_cons (base_binfo,
 586                          build_tree_list (NULL_TREE,
 587                                           build_base_path (PLUS_EXPR, parm,
 588                                                            base_binfo, 1)),
 589                          member_init_list);
 590         }
 591
 592       for (; fields; fields = TREE_CHAIN (fields))
 593         {
 594           tree init = parm;
 595           tree field = fields;
 596           tree expr_type;
 597
 598           if (TREE_CODE (field) != FIELD_DECL)
 599             continue;
 600
 601           expr_type = TREE_TYPE (field);
 602           if (DECL_NAME (field))
 603             {
 604               if (VFIELD_NAME_P (DECL_NAME (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 = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
 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 (0);
 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 = build2 (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       tree binfo, base_binfo;
 660
 661       /* Assign to each of the direct base classes.  */
 662       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 663            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 664         {
 665           tree converted_parm;
 666
 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, base_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                                         base_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
 696           if (CP_TYPE_CONST_P (expr_type))
 697             {
 698               error ("non-static const member %q#D, can't use default "
 699                      "assignment operator", field);
 700               continue;
 701             }
 702           else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
 703             {
 704               error ("non-static reference member %q#D, can't use "
 705                      "default assignment operator", field);
 706               continue;
 707             }
 708
 709           if (DECL_NAME (field))
 710             {
 711               if (VFIELD_NAME_P (DECL_NAME (field)))
 712                 continue;
 713             }
 714           else if (ANON_AGGR_TYPE_P (expr_type)
 715                    && TYPE_FIELDS (expr_type) != NULL_TREE)
 716             /* Just use the field; anonymous types can't have
 717                nontrivial copy ctors or assignment ops.  */;
 718           else
 719             continue;
 720
 721           comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
 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 = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
 730
 731           if (DECL_NAME (field))
 732             init = build_modify_expr (comp, NOP_EXPR, init);
 733           else
 734             init = build2 (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 /* Synthesize FNDECL, a non-static member function.   */
 743
 744 void
 745 synthesize_method (tree fndecl)
 746 {
 747   bool nested = (current_function_decl != NULL_TREE);
 748   tree context = decl_function_context (fndecl);
 749   bool need_body = true;
 750   tree stmt;
 751   location_t save_input_location = input_location;
 752   int error_count = errorcount;
 753   int warning_count = warningcount;
 754
 755   /* Reset the source location, we might have been previously
 756      deferred, and thus have saved where we were first needed.  */
 757   DECL_SOURCE_LOCATION (fndecl)
 758     = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
 759
 760   /* If we've been asked to synthesize a clone, just synthesize the
 761      cloned function instead.  Doing so will automatically fill in the
 762      body for the clone.  */
 763   if (DECL_CLONED_FUNCTION_P (fndecl))
 764     fndecl = DECL_CLONED_FUNCTION (fndecl);
 765
 766   /* We may be in the middle of deferred access check.  Disable
 767      it now.  */
 768   push_deferring_access_checks (dk_no_deferred);
 769
 770   if (! context)
 771     push_to_top_level ();
 772   else if (nested)
 773     push_function_context_to (context);
 774
 775   input_location = DECL_SOURCE_LOCATION (fndecl);
 776
 777   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 778   stmt = begin_function_body ();
 779
 780   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 781     {
 782       do_build_assign_ref (fndecl);
 783       need_body = false;
 784     }
 785   else if (DECL_CONSTRUCTOR_P (fndecl))
 786     {
 787       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 788       if (arg_chain != void_list_node)
 789         do_build_copy_constructor (fndecl);
 790       else
 791         finish_mem_initializers (NULL_TREE);
 792     }
 793
 794   /* If we haven't yet generated the body of the function, just
 795      generate an empty compound statement.  */
 796   if (need_body)
 797     {
 798       tree compound_stmt;
 799       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
 800       finish_compound_stmt (compound_stmt);
 801     }
 802
 803   finish_function_body (stmt);
 804   expand_or_defer_fn (finish_function (0));
 805
 806   input_location = save_input_location;
 807
 808   if (! context)
 809     pop_from_top_level ();
 810   else if (nested)
 811     pop_function_context_from (context);
 812
 813   pop_deferring_access_checks ();
 814
 815   if (error_count != errorcount || warning_count != warningcount)
 816     inform ("%Hsynthesized method %qD first required here ",
 817             &input_location, fndecl);
 818 }
 819
 820 /* Use EXTRACTOR to locate the relevant function called for each base &
 821    class field of TYPE. CLIENT allows additional information to be passed
 822    to EXTRACTOR.  Generates the union of all exceptions generated by those
 823    functions.  Note that we haven't updated TYPE_FIELDS and such of any
 824    variants yet, so we need to look at the main one.  */
 825
 826 static tree
 827 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
 828                            void *client)
 829 {
 830   tree raises = empty_except_spec;
 831   tree fields = TYPE_FIELDS (type);
 832   tree binfo, base_binfo;
 833   int i;
 834
 835   for (binfo = TYPE_BINFO (type), i = 0;
 836        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 837     {
 838       tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
 839       if (fn)
 840         {
 841           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 842
 843           raises = merge_exception_specifiers (raises, fn_raises);
 844         }
 845     }
 846   for (; fields; fields = TREE_CHAIN (fields))
 847     {
 848       tree type = TREE_TYPE (fields);
 849       tree fn;
 850
 851       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
 852         continue;
 853       while (TREE_CODE (type) == ARRAY_TYPE)
 854         type = TREE_TYPE (type);
 855       if (!CLASS_TYPE_P (type))
 856         continue;
 857
 858       fn = (*extractor) (type, client);
 859       if (fn)
 860         {
 861           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 862
 863           raises = merge_exception_specifiers (raises, fn_raises);
 864         }
 865     }
 866   return raises;
 867 }
 868
 869 /* Locate the dtor of TYPE.  */
 870
 871 static tree
 872 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
 873 {
 874   return CLASSTYPE_DESTRUCTORS (type);
 875 }
 876
 877 /* Locate the default ctor of TYPE.  */
 878
 879 static tree
 880 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
 881 {
 882   tree fns;
 883
 884   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 885     return NULL_TREE;
 886
 887   /* Call lookup_fnfields_1 to create the constructor declarations, if
 888      necessary.  */
 889   if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
 890     return lazily_declare_fn (sfk_constructor, type);
 891
 892   for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
 893     {
 894       tree fn = OVL_CURRENT (fns);
 895       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 896
 897       parms = skip_artificial_parms_for (fn, parms);
 898
 899       if (sufficient_parms_p (parms))
 900         return fn;
 901     }
 902   gcc_unreachable ();
 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   tree best = NULL_TREE;
 921   bool excess_p = false;
 922
 923   if (client->name)
 924     {
 925       int ix;
 926       ix = lookup_fnfields_1 (type, client->name);
 927       if (ix < 0)
 928         return NULL_TREE;
 929       fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
 930     }
 931   else if (TYPE_HAS_INIT_REF (type))
 932     {
 933       /* If construction of the copy constructor was postponed, create
 934          it now.  */
 935       if (CLASSTYPE_LAZY_COPY_CTOR (type))
 936         lazily_declare_fn (sfk_copy_constructor, type);
 937       fns = CLASSTYPE_CONSTRUCTORS (type);
 938     }
 939   else
 940     return NULL_TREE;
 941   for (; fns; fns = OVL_NEXT (fns))
 942     {
 943       tree fn = OVL_CURRENT (fns);
 944       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 945       tree src_type;
 946       int excess;
 947       int quals;
 948
 949       parms = skip_artificial_parms_for (fn, parms);
 950       if (!parms)
 951         continue;
 952       src_type = non_reference (TREE_VALUE (parms));
 953
 954       if (src_type == error_mark_node)
 955         return NULL_TREE;
 956
 957       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 958         continue;
 959       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 960         continue;
 961       quals = cp_type_quals (src_type);
 962       if (client->quals & ~quals)
 963         continue;
 964       excess = quals & ~client->quals;
 965       if (!best || (excess_p && !excess))
 966         {
 967           best = fn;
 968           excess_p = excess;
 969         }
 970       else
 971         /* Ambiguous */
 972         return NULL_TREE;
 973     }
 974   return best;
 975 }
 976
 977 /* Implicitly declare the special function indicated by KIND, as a
 978    member of TYPE.  For copy constructors and assignment operators,
 979    CONST_P indicates whether these functions should take a const
 980    reference argument or a non-const reference.  Returns the
 981    FUNCTION_DECL for the implicitly declared function.  */
 982
 983 static tree
 984 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
 985 {
 986   tree fn;
 987   tree parameter_types = void_list_node;
 988   tree return_type;
 989   tree fn_type;
 990   tree raises = empty_except_spec;
 991   tree rhs_parm_type = NULL_TREE;
 992   tree this_parm;
 993   tree name;
 994   HOST_WIDE_INT saved_processing_template_decl;
 995
 996   /* Because we create declarations for implicitly declared functions
 997      lazily, we may be creating the declaration for a member of TYPE
 998      while in some completely different context.  However, TYPE will
 999      never be a dependent class (because we never want to do lookups
1000      for implicitly defined functions in a dependent class).
1001      Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1002      because we only create clones for constructors and destructors
1003      when not in a template.  */
1004   gcc_assert (!dependent_type_p (type));
1005   saved_processing_template_decl = processing_template_decl;
1006   processing_template_decl = 0;
1007
1008   type = TYPE_MAIN_VARIANT (type);
1009
1010   if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1011     {
1012       if (kind == sfk_destructor)
1013         /* See comment in check_special_function_return_type.  */
1014         return_type = build_pointer_type (void_type_node);
1015       else
1016         return_type = build_pointer_type (type);
1017     }
1018   else
1019     return_type = void_type_node;
1020
1021   switch (kind)
1022     {
1023     case sfk_destructor:
1024       /* Destructor.  */
1025       name = constructor_name (type);
1026       raises = synthesize_exception_spec (type, &locate_dtor, 0);
1027       break;
1028
1029     case sfk_constructor:
1030       /* Default constructor.  */
1031       name = constructor_name (type);
1032       raises = synthesize_exception_spec (type, &locate_ctor, 0);
1033       break;
1034
1035     case sfk_copy_constructor:
1036     case sfk_assignment_operator:
1037     {
1038       struct copy_data data;
1039
1040       data.name = NULL;
1041       data.quals = 0;
1042       if (kind == sfk_assignment_operator)
1043         {
1044           return_type = build_reference_type (type);
1045           name = ansi_assopname (NOP_EXPR);
1046           data.name = name;
1047         }
1048       else
1049         name = constructor_name (type);
1050
1051       if (const_p)
1052         {
1053           data.quals = TYPE_QUAL_CONST;
1054           rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
1055         }
1056       else
1057         rhs_parm_type = type;
1058       rhs_parm_type = build_reference_type (rhs_parm_type);
1059       parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1060       raises = synthesize_exception_spec (type, &locate_copy, &data);
1061       break;
1062     }
1063     default:
1064       gcc_unreachable ();
1065     }
1066
1067   /* Create the function.  */
1068   fn_type = build_method_type_directly (type, return_type, parameter_types);
1069   if (raises)
1070     fn_type = build_exception_variant (fn_type, raises);
1071   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1072   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1073   if (kind == sfk_constructor || kind == sfk_copy_constructor)
1074     DECL_CONSTRUCTOR_P (fn) = 1;
1075   else if (kind == sfk_destructor)
1076     DECL_DESTRUCTOR_P (fn) = 1;
1077   else
1078     {
1079       DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1080       SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1081     }
1082   /* Create the explicit arguments.  */
1083   if (rhs_parm_type)
1084     {
1085       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1086          want its type to be included in the mangled function
1087          name.  */
1088       DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1089       TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1090     }
1091   /* Add the "this" parameter.  */
1092   this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1093   TREE_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1094   DECL_ARGUMENTS (fn) = this_parm;
1095
1096   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1097   set_linkage_according_to_type (type, fn);
1098   rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1099   DECL_IN_AGGR_P (fn) = 1;
1100   DECL_ARTIFICIAL (fn) = 1;
1101   DECL_NOT_REALLY_EXTERN (fn) = 1;
1102   DECL_DECLARED_INLINE_P (fn) = 1;
1103   DECL_INLINE (fn) = 1;
1104   gcc_assert (!TREE_USED (fn));
1105
1106   /* Restore PROCESSING_TEMPLATE_DECL.  */
1107   processing_template_decl = saved_processing_template_decl;
1108
1109   return fn;
1110 }
1111
1112 /* Add an implicit declaration to TYPE for the kind of function
1113    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
1114    declaration.  */
1115
1116 tree
1117 lazily_declare_fn (special_function_kind sfk, tree type)
1118 {
1119   tree fn;
1120   bool const_p;
1121
1122   /* Figure out whether or not the argument has a const reference
1123      type.  */
1124   if (sfk == sfk_copy_constructor)
1125     const_p = TYPE_HAS_CONST_INIT_REF (type);
1126   else if (sfk == sfk_assignment_operator)
1127     const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1128   else
1129     /* In this case, CONST_P will be ignored.  */
1130     const_p = false;
1131   /* Declare the function.  */
1132   fn = implicitly_declare_fn (sfk, type, const_p);
1133   /* A destructor may be virtual.  */
1134   if (sfk == sfk_destructor)
1135     check_for_override (fn, type);
1136   /* Add it to CLASSTYPE_METHOD_VEC.  */
1137   add_method (type, fn, NULL_TREE);
1138   /* Add it to TYPE_METHODS.  */
1139   if (sfk == sfk_destructor
1140       && DECL_VIRTUAL_P (fn)
1141       && abi_version_at_least (2))
1142     /* The ABI requires that a virtual destructor go at the end of the
1143        vtable.  */
1144     TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1145   else
1146     {
1147       /* G++ 3.2 put the implicit destructor at the *beginning* of the
1148          TYPE_METHODS list, which cause the destructor to be emitted
1149          in an incorrect location in the vtable.  */
1150       if (warn_abi && DECL_VIRTUAL_P (fn))
1151         warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1152                  "and may change in a future version of GCC due to "
1153                  "implicit virtual destructor",
1154                  type);
1155       TREE_CHAIN (fn) = TYPE_METHODS (type);
1156       TYPE_METHODS (type) = fn;
1157     }
1158   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1159   if (sfk == sfk_assignment_operator)
1160     CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1161   else
1162     {
1163       /* Remember that the function has been created.  */
1164       if (sfk == sfk_constructor)
1165         CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1166       else if (sfk == sfk_copy_constructor)
1167         CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1168       else if (sfk == sfk_destructor)
1169         CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1170       /* Create appropriate clones.  */
1171       clone_function_decl (fn, /*update_method_vec=*/true);
1172     }
1173
1174   return fn;
1175 }
1176
1177 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1178    as there are artificial parms in FN.  */
1179
1180 tree
1181 skip_artificial_parms_for (tree fn, tree list)
1182 {
1183   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1184     list = TREE_CHAIN (list);
1185   else
1186     return list;
1187
1188   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1189     list = TREE_CHAIN (list);
1190   if (DECL_HAS_VTT_PARM_P (fn))
1191     list = TREE_CHAIN (list);
1192   return list;
1193 }
1194
1195 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1196    artificial parms in FN.  */
1197
1198 int
1199 num_artificial_parms_for (tree fn)
1200 {
1201   int count = 0;
1202
1203   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1204     count++;
1205   else
1206     return 0;
1207
1208   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1209     count++;
1210   if (DECL_HAS_VTT_PARM_P (fn))
1211     count++;
1212   return count;
1213 }
1214
1215
1216 #include "gt-cp-method.h"