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, 2007, 2008
   5    Free Software Foundation, Inc.
   6    Contributed by Michael Tiemann (tiemann@cygnus.com)
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 3, or (at your option)
  13 any later version.
  14
  15 GCC is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING3.  If not see
  22 <http://www.gnu.org/licenses/>.  */
  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 make_alias_for_thunk (tree);
  65
  66 /* Called once to initialize method.c.  */
  67
  68 void
  69 init_method (void)
  70 {
  71   init_mangle ();
  72 }
  73 \f
  74 /* Return a this or result adjusting thunk to FUNCTION.  THIS_ADJUSTING
  75    indicates whether it is a this or result adjusting thunk.
  76    FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
  77    (see thunk_adjust).  VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
  78    never is.  VIRTUAL_OFFSET is the /index/ into the vtable for this
  79    adjusting thunks, we scale it to a byte offset. For covariant
  80    thunks VIRTUAL_OFFSET is the virtual binfo.  You must post process
  81    the returned thunk with finish_thunk.  */
  82
  83 tree
  84 make_thunk (tree function, bool this_adjusting,
  85             tree fixed_offset, tree virtual_offset)
  86 {
  87   HOST_WIDE_INT d;
  88   tree thunk;
  89
  90   gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
  91   /* We can have this thunks to covariant thunks, but not vice versa.  */
  92   gcc_assert (!DECL_THIS_THUNK_P (function));
  93   gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
  94
  95   /* Scale the VIRTUAL_OFFSET to be in terms of bytes.  */
  96   if (this_adjusting && virtual_offset)
  97     virtual_offset
  98       = size_binop (MULT_EXPR,
  99                     virtual_offset,
 100                     convert (ssizetype,
 101                              TYPE_SIZE_UNIT (vtable_entry_type)));
 102
 103   d = tree_low_cst (fixed_offset, 0);
 104
 105   /* See if we already have the thunk in question.  For this_adjusting
 106      thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
 107      will be a BINFO.  */
 108   for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
 109     if (DECL_THIS_THUNK_P (thunk) == this_adjusting
 110         && THUNK_FIXED_OFFSET (thunk) == d
 111         && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
 112         && (!virtual_offset
 113             || (this_adjusting
 114                 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
 115                                       virtual_offset)
 116                 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
 117       return thunk;
 118
 119   /* All thunks must be created before FUNCTION is actually emitted;
 120      the ABI requires that all thunks be emitted together with the
 121      function to which they transfer control.  */
 122   gcc_assert (!TREE_ASM_WRITTEN (function));
 123   /* Likewise, we can only be adding thunks to a function declared in
 124      the class currently being laid out.  */
 125   gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
 126               && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
 127
 128   thunk = build_decl (FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
 129   DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
 130   cxx_dup_lang_specific_decl (thunk);
 131   DECL_THUNKS (thunk) = NULL_TREE;
 132
 133   DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
 134   TREE_READONLY (thunk) = TREE_READONLY (function);
 135   TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
 136   TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
 137   SET_DECL_THUNK_P (thunk, this_adjusting);
 138   THUNK_TARGET (thunk) = function;
 139   THUNK_FIXED_OFFSET (thunk) = d;
 140   THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
 141   THUNK_ALIAS (thunk) = NULL_TREE;
 142
 143   /* The thunk itself is not a constructor or destructor, even if
 144      the thing it is thunking to is.  */
 145   DECL_INTERFACE_KNOWN (thunk) = 1;
 146   DECL_NOT_REALLY_EXTERN (thunk) = 1;
 147   DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
 148   DECL_DESTRUCTOR_P (thunk) = 0;
 149   DECL_CONSTRUCTOR_P (thunk) = 0;
 150   DECL_EXTERNAL (thunk) = 1;
 151   DECL_ARTIFICIAL (thunk) = 1;
 152   /* Even if this thunk is a member of a local class, we don't
 153      need a static chain.  */
 154   DECL_NO_STATIC_CHAIN (thunk) = 1;
 155   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
 156   DECL_PENDING_INLINE_P (thunk) = 0;
 157   DECL_INLINE (thunk) = 0;
 158   DECL_DECLARED_INLINE_P (thunk) = 0;
 159   /* Nor has it been deferred.  */
 160   DECL_DEFERRED_FN (thunk) = 0;
 161   /* Nor is it a template instantiation.  */
 162   DECL_USE_TEMPLATE (thunk) = 0;
 163   DECL_TEMPLATE_INFO (thunk) = NULL;
 164
 165   /* Add it to the list of thunks associated with FUNCTION.  */
 166   TREE_CHAIN (thunk) = DECL_THUNKS (function);
 167   DECL_THUNKS (function) = thunk;
 168
 169   return thunk;
 170 }
 171
 172 /* Finish THUNK, a thunk decl.  */
 173
 174 void
 175 finish_thunk (tree thunk)
 176 {
 177   tree function, name;
 178   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
 179   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
 180
 181   gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
 182   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
 183     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 184   function = THUNK_TARGET (thunk);
 185   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
 186                        fixed_offset, virtual_offset);
 187
 188   /* We can end up with declarations of (logically) different
 189      covariant thunks, that do identical adjustments.  The two thunks
 190      will be adjusting between within different hierarchies, which
 191      happen to have the same layout.  We must nullify one of them to
 192      refer to the other.  */
 193   if (DECL_RESULT_THUNK_P (thunk))
 194     {
 195       tree cov_probe;
 196
 197       for (cov_probe = DECL_THUNKS (function);
 198            cov_probe; cov_probe = TREE_CHAIN (cov_probe))
 199         if (DECL_NAME (cov_probe) == name)
 200           {
 201             gcc_assert (!DECL_THUNKS (thunk));
 202             THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
 203                                    ? THUNK_ALIAS (cov_probe) : cov_probe);
 204             break;
 205           }
 206     }
 207
 208   DECL_NAME (thunk) = name;
 209   SET_DECL_ASSEMBLER_NAME (thunk, name);
 210 }
 211
 212 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
 213    offset indicated by VIRTUAL_OFFSET, if that is
 214    non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
 215    zero for a result adjusting thunk.  */
 216
 217 static tree
 218 thunk_adjust (tree ptr, bool this_adjusting,
 219               HOST_WIDE_INT fixed_offset, tree virtual_offset)
 220 {
 221   if (this_adjusting)
 222     /* Adjust the pointer by the constant.  */
 223     ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
 224                        size_int (fixed_offset));
 225
 226   /* If there's a virtual offset, look up that value in the vtable and
 227      adjust the pointer again.  */
 228   if (virtual_offset)
 229     {
 230       tree vtable;
 231
 232       ptr = save_expr (ptr);
 233       /* The vptr is always at offset zero in the object.  */
 234       vtable = build1 (NOP_EXPR,
 235                        build_pointer_type (build_pointer_type
 236                                            (vtable_entry_type)),
 237                        ptr);
 238       /* Form the vtable address.  */
 239       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 240       /* Find the entry with the vcall offset.  */
 241       vtable = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtable), vtable,
 242                        fold_convert (sizetype, virtual_offset));
 243       /* Get the offset itself.  */
 244       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
 245       /* Adjust the `this' pointer.  */
 246       ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
 247                          fold_convert (sizetype, vtable));
 248     }
 249
 250   if (!this_adjusting)
 251     /* Adjust the pointer by the constant.  */
 252     ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
 253                        size_int (fixed_offset));
 254
 255   return ptr;
 256 }
 257
 258 static GTY (()) int thunk_labelno;
 259
 260 /* Create a static alias to function.  */
 261
 262 tree
 263 make_alias_for (tree function, tree newid)
 264 {
 265   tree alias = build_decl (FUNCTION_DECL, newid, TREE_TYPE (function));
 266   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (function);
 267   cxx_dup_lang_specific_decl (alias);
 268   DECL_CONTEXT (alias) = NULL;
 269   TREE_READONLY (alias) = TREE_READONLY (function);
 270   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (function);
 271   TREE_PUBLIC (alias) = 0;
 272   DECL_INTERFACE_KNOWN (alias) = 1;
 273   DECL_NOT_REALLY_EXTERN (alias) = 1;
 274   DECL_THIS_STATIC (alias) = 1;
 275   DECL_SAVED_FUNCTION_DATA (alias) = NULL;
 276   DECL_DESTRUCTOR_P (alias) = 0;
 277   DECL_CONSTRUCTOR_P (alias) = 0;
 278   DECL_CLONED_FUNCTION (alias) = NULL_TREE;
 279   DECL_EXTERNAL (alias) = 0;
 280   DECL_ARTIFICIAL (alias) = 1;
 281   DECL_NO_STATIC_CHAIN (alias) = 1;
 282   DECL_PENDING_INLINE_P (alias) = 0;
 283   DECL_INLINE (alias) = 0;
 284   DECL_DECLARED_INLINE_P (alias) = 0;
 285   DECL_DEFERRED_FN (alias) = 0;
 286   DECL_USE_TEMPLATE (alias) = 0;
 287   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
 288   DECL_TEMPLATE_INFO (alias) = NULL;
 289   DECL_INITIAL (alias) = error_mark_node;
 290   TREE_ADDRESSABLE (alias) = 1;
 291   TREE_USED (alias) = 1;
 292   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
 293   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
 294   return alias;
 295 }
 296
 297 static tree
 298 make_alias_for_thunk (tree function)
 299 {
 300   tree alias;
 301   char buf[256];
 302
 303   ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno);
 304   thunk_labelno++;
 305
 306   alias = make_alias_for (function, get_identifier (buf));
 307
 308   if (!flag_syntax_only)
 309     assemble_alias (alias, DECL_ASSEMBLER_NAME (function));
 310
 311   return alias;
 312 }
 313
 314 /* Emit the definition of a C++ multiple inheritance or covariant
 315    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
 316    immediately.  */
 317
 318 void
 319 use_thunk (tree thunk_fndecl, bool emit_p)
 320 {
 321   tree a, t, function, alias;
 322   tree virtual_offset;
 323   HOST_WIDE_INT fixed_offset, virtual_value;
 324   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
 325
 326   /* We should have called finish_thunk to give it a name.  */
 327   gcc_assert (DECL_NAME (thunk_fndecl));
 328
 329   /* We should never be using an alias, always refer to the
 330      aliased thunk.  */
 331   gcc_assert (!THUNK_ALIAS (thunk_fndecl));
 332
 333   if (TREE_ASM_WRITTEN (thunk_fndecl))
 334     return;
 335
 336   function = THUNK_TARGET (thunk_fndecl);
 337   if (DECL_RESULT (thunk_fndecl))
 338     /* We already turned this thunk into an ordinary function.
 339        There's no need to process this thunk again.  */
 340     return;
 341
 342   if (DECL_THUNK_P (function))
 343     /* The target is itself a thunk, process it now.  */
 344     use_thunk (function, emit_p);
 345
 346   /* Thunks are always addressable; they only appear in vtables.  */
 347   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 348
 349   /* Figure out what function is being thunked to.  It's referenced in
 350      this translation unit.  */
 351   TREE_ADDRESSABLE (function) = 1;
 352   mark_used (function);
 353   if (!emit_p)
 354     return;
 355
 356   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
 357    alias = make_alias_for_thunk (function);
 358   else
 359    alias = function;
 360
 361   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
 362   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
 363
 364   if (virtual_offset)
 365     {
 366       if (!this_adjusting)
 367         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 368       virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
 369       gcc_assert (virtual_value);
 370     }
 371   else
 372     virtual_value = 0;
 373
 374   /* And, if we need to emit the thunk, it's used.  */
 375   mark_used (thunk_fndecl);
 376   /* This thunk is actually defined.  */
 377   DECL_EXTERNAL (thunk_fndecl) = 0;
 378   /* The linkage of the function may have changed.  FIXME in linkage
 379      rewrite.  */
 380   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
 381   DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
 382   DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
 383     = DECL_VISIBILITY_SPECIFIED (function);
 384   if (DECL_ONE_ONLY (function))
 385     make_decl_one_only (thunk_fndecl);
 386
 387   if (flag_syntax_only)
 388     {
 389       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 390       return;
 391     }
 392
 393   push_to_top_level ();
 394
 395   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
 396       && targetm.have_named_sections)
 397     {
 398       resolve_unique_section (function, 0, flag_function_sections);
 399
 400       if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
 401         {
 402           resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
 403
 404           /* Output the thunk into the same section as function.  */
 405           DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
 406         }
 407     }
 408
 409   /* Set up cloned argument trees for the thunk.  */
 410   t = NULL_TREE;
 411   for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a))
 412     {
 413       tree x = copy_node (a);
 414       TREE_CHAIN (x) = t;
 415       DECL_CONTEXT (x) = thunk_fndecl;
 416       SET_DECL_RTL (x, NULL_RTX);
 417       DECL_HAS_VALUE_EXPR_P (x) = 0;
 418       t = x;
 419     }
 420   a = nreverse (t);
 421   DECL_ARGUMENTS (thunk_fndecl) = a;
 422
 423   if (this_adjusting
 424       && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
 425                                               virtual_value, alias))
 426     {
 427       const char *fnname;
 428       tree fn_block;
 429
 430       current_function_decl = thunk_fndecl;
 431       DECL_RESULT (thunk_fndecl)
 432         = build_decl (RESULT_DECL, 0, integer_type_node);
 433       fnname = IDENTIFIER_POINTER (DECL_NAME (thunk_fndecl));
 434       /* The back end expects DECL_INITIAL to contain a BLOCK, so we
 435          create one.  */
 436       fn_block = make_node (BLOCK);
 437       BLOCK_VARS (fn_block) = a;
 438       DECL_INITIAL (thunk_fndecl) = fn_block;
 439       init_function_start (thunk_fndecl);
 440       current_function_is_thunk = 1;
 441       assemble_start_function (thunk_fndecl, fnname);
 442
 443       targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
 444                                        fixed_offset, virtual_value, alias);
 445
 446       assemble_end_function (thunk_fndecl, fnname);
 447       init_insn_lengths ();
 448       current_function_decl = 0;
 449       set_cfun (NULL);
 450       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 451     }
 452   else
 453     {
 454       int i;
 455       tree *argarray = (tree *) alloca (list_length (a) * sizeof (tree));
 456       /* If this is a covariant thunk, or we don't have the necessary
 457          code for efficient thunks, generate a thunk function that
 458          just makes a call to the real function.  Unfortunately, this
 459          doesn't work for varargs.  */
 460
 461       if (varargs_function_p (function))
 462         error ("generic thunk code fails for method %q#D which uses %<...%>",
 463                function);
 464
 465       DECL_RESULT (thunk_fndecl) = NULL_TREE;
 466
 467       start_preparsed_function (thunk_fndecl, NULL_TREE, SF_PRE_PARSED);
 468       /* We don't bother with a body block for thunks.  */
 469
 470       /* There's no need to check accessibility inside the thunk body.  */
 471       push_deferring_access_checks (dk_no_check);
 472
 473       t = a;
 474       if (this_adjusting)
 475         t = thunk_adjust (t, /*this_adjusting=*/1,
 476                           fixed_offset, virtual_offset);
 477
 478       /* Build up the call to the real function.  */
 479       argarray[0] = t;
 480       for (i = 1, a = TREE_CHAIN (a); a; a = TREE_CHAIN (a), i++)
 481         argarray[i] = a;
 482       t = build_call_a (alias, i, argarray);
 483       CALL_FROM_THUNK_P (t) = 1;
 484       CALL_CANNOT_INLINE_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 (MAYBE_CLASS_TYPE_P (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       tree_rest_of_compilation (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                                         tf_warning_or_error));
 679         }
 680
 681       /* Assign to each of the non-static data members.  */
 682       for (fields = TYPE_FIELDS (current_class_type);
 683            fields;
 684            fields = TREE_CHAIN (fields))
 685         {
 686           tree comp = current_class_ref;
 687           tree init = parm;
 688           tree field = fields;
 689           tree expr_type;
 690           int quals;
 691
 692           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 693             continue;
 694
 695           expr_type = TREE_TYPE (field);
 696
 697           if (CP_TYPE_CONST_P (expr_type))
 698             {
 699               error ("non-static const member %q#D, can't use default "
 700                      "assignment operator", field);
 701               continue;
 702             }
 703           else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
 704             {
 705               error ("non-static reference member %q#D, can't use "
 706                      "default assignment operator", field);
 707               continue;
 708             }
 709
 710           if (DECL_NAME (field))
 711             {
 712               if (VFIELD_NAME_P (DECL_NAME (field)))
 713                 continue;
 714             }
 715           else if (ANON_AGGR_TYPE_P (expr_type)
 716                    && TYPE_FIELDS (expr_type) != NULL_TREE)
 717             /* Just use the field; anonymous types can't have
 718                nontrivial copy ctors or assignment ops.  */;
 719           else
 720             continue;
 721
 722           comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
 723
 724           /* Compute the type of init->field  */
 725           quals = cvquals;
 726           if (DECL_MUTABLE_P (field))
 727             quals &= ~TYPE_QUAL_CONST;
 728           expr_type = cp_build_qualified_type (expr_type, quals);
 729
 730           init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
 731
 732           if (DECL_NAME (field))
 733             init = cp_build_modify_expr (comp, NOP_EXPR, init,
 734                                          tf_warning_or_error);
 735           else
 736             init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
 737           finish_expr_stmt (init);
 738         }
 739     }
 740   finish_return_stmt (current_class_ref);
 741   finish_compound_stmt (compound_stmt);
 742 }
 743
 744 /* Synthesize FNDECL, a non-static member function.   */
 745
 746 void
 747 synthesize_method (tree fndecl)
 748 {
 749   bool nested = (current_function_decl != NULL_TREE);
 750   tree context = decl_function_context (fndecl);
 751   bool need_body = true;
 752   tree stmt;
 753   location_t save_input_location = input_location;
 754   int error_count = errorcount;
 755   int warning_count = warningcount;
 756
 757   /* Reset the source location, we might have been previously
 758      deferred, and thus have saved where we were first needed.  */
 759   DECL_SOURCE_LOCATION (fndecl)
 760     = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
 761
 762   /* If we've been asked to synthesize a clone, just synthesize the
 763      cloned function instead.  Doing so will automatically fill in the
 764      body for the clone.  */
 765   if (DECL_CLONED_FUNCTION_P (fndecl))
 766     fndecl = DECL_CLONED_FUNCTION (fndecl);
 767
 768   /* We may be in the middle of deferred access check.  Disable
 769      it now.  */
 770   push_deferring_access_checks (dk_no_deferred);
 771
 772   if (! context)
 773     push_to_top_level ();
 774   else if (nested)
 775     push_function_context ();
 776
 777   input_location = DECL_SOURCE_LOCATION (fndecl);
 778
 779   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 780   stmt = begin_function_body ();
 781
 782   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 783     {
 784       do_build_assign_ref (fndecl);
 785       need_body = false;
 786     }
 787   else if (DECL_CONSTRUCTOR_P (fndecl))
 788     {
 789       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 790       if (arg_chain != void_list_node)
 791         do_build_copy_constructor (fndecl);
 792       else
 793         finish_mem_initializers (NULL_TREE);
 794     }
 795
 796   /* If we haven't yet generated the body of the function, just
 797      generate an empty compound statement.  */
 798   if (need_body)
 799     {
 800       tree compound_stmt;
 801       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
 802       finish_compound_stmt (compound_stmt);
 803     }
 804
 805   finish_function_body (stmt);
 806   expand_or_defer_fn (finish_function (0));
 807
 808   input_location = save_input_location;
 809
 810   if (! context)
 811     pop_from_top_level ();
 812   else if (nested)
 813     pop_function_context ();
 814
 815   pop_deferring_access_checks ();
 816
 817   if (error_count != errorcount || warning_count != warningcount)
 818     inform ("%Hsynthesized method %qD first required here ",
 819             &input_location, fndecl);
 820 }
 821
 822 /* Use EXTRACTOR to locate the relevant function called for each base &
 823    class field of TYPE. CLIENT allows additional information to be passed
 824    to EXTRACTOR.  Generates the union of all exceptions generated by those
 825    functions.  Note that we haven't updated TYPE_FIELDS and such of any
 826    variants yet, so we need to look at the main one.  */
 827
 828 static tree
 829 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*),
 830                            void *client)
 831 {
 832   tree raises = empty_except_spec;
 833   tree fields = TYPE_FIELDS (type);
 834   tree binfo, base_binfo;
 835   int i;
 836
 837   for (binfo = TYPE_BINFO (type), i = 0;
 838        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 839     {
 840       tree fn = (*extractor) (BINFO_TYPE (base_binfo), client);
 841       if (fn)
 842         {
 843           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 844
 845           raises = merge_exception_specifiers (raises, fn_raises);
 846         }
 847     }
 848   for (; fields; fields = TREE_CHAIN (fields))
 849     {
 850       tree type = TREE_TYPE (fields);
 851       tree fn;
 852
 853       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
 854         continue;
 855       while (TREE_CODE (type) == ARRAY_TYPE)
 856         type = TREE_TYPE (type);
 857       if (!CLASS_TYPE_P (type))
 858         continue;
 859
 860       fn = (*extractor) (type, client);
 861       if (fn)
 862         {
 863           tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
 864
 865           raises = merge_exception_specifiers (raises, fn_raises);
 866         }
 867     }
 868   return raises;
 869 }
 870
 871 /* Locate the dtor of TYPE.  */
 872
 873 tree
 874 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED)
 875 {
 876   return CLASSTYPE_DESTRUCTORS (type);
 877 }
 878
 879 /* Locate the default ctor of TYPE.  */
 880
 881 tree
 882 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED)
 883 {
 884   tree fns;
 885
 886   if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
 887     return NULL_TREE;
 888
 889   /* Call lookup_fnfields_1 to create the constructor declarations, if
 890      necessary.  */
 891   if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
 892     return lazily_declare_fn (sfk_constructor, type);
 893
 894   for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns))
 895     {
 896       tree fn = OVL_CURRENT (fns);
 897       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 898
 899       parms = skip_artificial_parms_for (fn, parms);
 900
 901       if (sufficient_parms_p (parms))
 902         return fn;
 903     }
 904   gcc_unreachable ();
 905 }
 906
 907 struct copy_data
 908 {
 909   tree name;
 910   int quals;
 911 };
 912
 913 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_
 914    points to a COPY_DATA holding the name (NULL for the ctor)
 915    and desired qualifiers of the source operand.  */
 916
 917 tree
 918 locate_copy (tree type, void *client_)
 919 {
 920   struct copy_data *client = (struct copy_data *)client_;
 921   tree fns;
 922   tree best = NULL_TREE;
 923   bool excess_p = false;
 924
 925   if (client->name)
 926     {
 927       int ix;
 928       ix = lookup_fnfields_1 (type, client->name);
 929       if (ix < 0)
 930         return NULL_TREE;
 931       fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
 932     }
 933   else if (TYPE_HAS_INIT_REF (type))
 934     {
 935       /* If construction of the copy constructor was postponed, create
 936          it now.  */
 937       if (CLASSTYPE_LAZY_COPY_CTOR (type))
 938         lazily_declare_fn (sfk_copy_constructor, type);
 939       fns = CLASSTYPE_CONSTRUCTORS (type);
 940     }
 941   else
 942     return NULL_TREE;
 943   for (; fns; fns = OVL_NEXT (fns))
 944     {
 945       tree fn = OVL_CURRENT (fns);
 946       tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
 947       tree src_type;
 948       int excess;
 949       int quals;
 950
 951       parms = skip_artificial_parms_for (fn, parms);
 952       if (!parms)
 953         continue;
 954       src_type = non_reference (TREE_VALUE (parms));
 955
 956       if (src_type == error_mark_node)
 957         return NULL_TREE;
 958
 959       if (!same_type_ignoring_top_level_qualifiers_p (src_type, type))
 960         continue;
 961       if (!sufficient_parms_p (TREE_CHAIN (parms)))
 962         continue;
 963       quals = cp_type_quals (src_type);
 964       if (client->quals & ~quals)
 965         continue;
 966       excess = quals & ~client->quals;
 967       if (!best || (excess_p && !excess))
 968         {
 969           best = fn;
 970           excess_p = excess;
 971         }
 972       else
 973         /* Ambiguous */
 974         return NULL_TREE;
 975     }
 976   return best;
 977 }
 978
 979 /* Implicitly declare the special function indicated by KIND, as a
 980    member of TYPE.  For copy constructors and assignment operators,
 981    CONST_P indicates whether these functions should take a const
 982    reference argument or a non-const reference.  Returns the
 983    FUNCTION_DECL for the implicitly declared function.  */
 984
 985 static tree
 986 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
 987 {
 988   tree fn;
 989   tree parameter_types = void_list_node;
 990   tree return_type;
 991   tree fn_type;
 992   tree raises = empty_except_spec;
 993   tree rhs_parm_type = NULL_TREE;
 994   tree this_parm;
 995   tree name;
 996   HOST_WIDE_INT saved_processing_template_decl;
 997
 998   /* Because we create declarations for implicitly declared functions
 999      lazily, we may be creating the declaration for a member of TYPE
1000      while in some completely different context.  However, TYPE will
1001      never be a dependent class (because we never want to do lookups
1002      for implicitly defined functions in a dependent class).
1003      Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1004      because we only create clones for constructors and destructors
1005      when not in a template.  */
1006   gcc_assert (!dependent_type_p (type));
1007   saved_processing_template_decl = processing_template_decl;
1008   processing_template_decl = 0;
1009
1010   type = TYPE_MAIN_VARIANT (type);
1011
1012   if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1013     {
1014       if (kind == sfk_destructor)
1015         /* See comment in check_special_function_return_type.  */
1016         return_type = build_pointer_type (void_type_node);
1017       else
1018         return_type = build_pointer_type (type);
1019     }
1020   else
1021     return_type = void_type_node;
1022
1023   switch (kind)
1024     {
1025     case sfk_destructor:
1026       /* Destructor.  */
1027       name = constructor_name (type);
1028       raises = synthesize_exception_spec (type, &locate_dtor, 0);
1029       break;
1030
1031     case sfk_constructor:
1032       /* Default constructor.  */
1033       name = constructor_name (type);
1034       raises = synthesize_exception_spec (type, &locate_ctor, 0);
1035       break;
1036
1037     case sfk_copy_constructor:
1038     case sfk_assignment_operator:
1039     {
1040       struct copy_data data;
1041
1042       data.name = NULL;
1043       data.quals = 0;
1044       if (kind == sfk_assignment_operator)
1045         {
1046           return_type = build_reference_type (type);
1047           name = ansi_assopname (NOP_EXPR);
1048           data.name = name;
1049         }
1050       else
1051         name = constructor_name (type);
1052
1053       if (const_p)
1054         {
1055           data.quals = TYPE_QUAL_CONST;
1056           rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST);
1057         }
1058       else
1059         rhs_parm_type = type;
1060       rhs_parm_type = build_reference_type (rhs_parm_type);
1061       parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1062       raises = synthesize_exception_spec (type, &locate_copy, &data);
1063       break;
1064     }
1065     default:
1066       gcc_unreachable ();
1067     }
1068
1069   /* Create the function.  */
1070   fn_type = build_method_type_directly (type, return_type, parameter_types);
1071   if (raises)
1072     fn_type = build_exception_variant (fn_type, raises);
1073   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1074   DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1075   if (kind == sfk_constructor || kind == sfk_copy_constructor)
1076     DECL_CONSTRUCTOR_P (fn) = 1;
1077   else if (kind == sfk_destructor)
1078     DECL_DESTRUCTOR_P (fn) = 1;
1079   else
1080     {
1081       DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1082       SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1083     }
1084
1085   /* If pointers to member functions use the least significant bit to
1086      indicate whether a function is virtual, ensure a pointer
1087      to this function will have that bit clear.  */
1088   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
1089       && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
1090     DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
1091
1092   /* Create the explicit arguments.  */
1093   if (rhs_parm_type)
1094     {
1095       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1096          want its type to be included in the mangled function
1097          name.  */
1098       DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1099       TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1100     }
1101   /* Add the "this" parameter.  */
1102   this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1103   TREE_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1104   DECL_ARGUMENTS (fn) = this_parm;
1105
1106   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1107   set_linkage_according_to_type (type, fn);
1108   rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1109   DECL_IN_AGGR_P (fn) = 1;
1110   DECL_ARTIFICIAL (fn) = 1;
1111   DECL_NOT_REALLY_EXTERN (fn) = 1;
1112   DECL_DECLARED_INLINE_P (fn) = 1;
1113   DECL_INLINE (fn) = 1;
1114   gcc_assert (!TREE_USED (fn));
1115
1116   /* Restore PROCESSING_TEMPLATE_DECL.  */
1117   processing_template_decl = saved_processing_template_decl;
1118
1119   return fn;
1120 }
1121
1122 /* Add an implicit declaration to TYPE for the kind of function
1123    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
1124    declaration.  */
1125
1126 tree
1127 lazily_declare_fn (special_function_kind sfk, tree type)
1128 {
1129   tree fn;
1130   bool const_p;
1131
1132   /* Figure out whether or not the argument has a const reference
1133      type.  */
1134   if (sfk == sfk_copy_constructor)
1135     const_p = TYPE_HAS_CONST_INIT_REF (type);
1136   else if (sfk == sfk_assignment_operator)
1137     const_p = TYPE_HAS_CONST_ASSIGN_REF (type);
1138   else
1139     /* In this case, CONST_P will be ignored.  */
1140     const_p = false;
1141   /* Declare the function.  */
1142   fn = implicitly_declare_fn (sfk, type, const_p);
1143   /* A destructor may be virtual.  */
1144   if (sfk == sfk_destructor)
1145     check_for_override (fn, type);
1146   /* Add it to CLASSTYPE_METHOD_VEC.  */
1147   add_method (type, fn, NULL_TREE);
1148   /* Add it to TYPE_METHODS.  */
1149   if (sfk == sfk_destructor
1150       && DECL_VIRTUAL_P (fn)
1151       && abi_version_at_least (2))
1152     /* The ABI requires that a virtual destructor go at the end of the
1153        vtable.  */
1154     TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1155   else
1156     {
1157       /* G++ 3.2 put the implicit destructor at the *beginning* of the
1158          TYPE_METHODS list, which cause the destructor to be emitted
1159          in an incorrect location in the vtable.  */
1160       if (warn_abi && DECL_VIRTUAL_P (fn))
1161         warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1162                  "and may change in a future version of GCC due to "
1163                  "implicit virtual destructor",
1164                  type);
1165       TREE_CHAIN (fn) = TYPE_METHODS (type);
1166       TYPE_METHODS (type) = fn;
1167     }
1168   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1169   if (sfk == sfk_assignment_operator)
1170     CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0;
1171   else
1172     {
1173       /* Remember that the function has been created.  */
1174       if (sfk == sfk_constructor)
1175         CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1176       else if (sfk == sfk_copy_constructor)
1177         CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1178       else if (sfk == sfk_destructor)
1179         CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1180       /* Create appropriate clones.  */
1181       clone_function_decl (fn, /*update_method_vec=*/true);
1182     }
1183
1184   return fn;
1185 }
1186
1187 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1188    as there are artificial parms in FN.  */
1189
1190 tree
1191 skip_artificial_parms_for (const_tree fn, tree list)
1192 {
1193   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1194     list = TREE_CHAIN (list);
1195   else
1196     return list;
1197
1198   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1199     list = TREE_CHAIN (list);
1200   if (DECL_HAS_VTT_PARM_P (fn))
1201     list = TREE_CHAIN (list);
1202   return list;
1203 }
1204
1205 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1206    artificial parms in FN.  */
1207
1208 int
1209 num_artificial_parms_for (const_tree fn)
1210 {
1211   int count = 0;
1212
1213   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1214     count++;
1215   else
1216     return 0;
1217
1218   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1219     count++;
1220   if (DECL_HAS_VTT_PARM_P (fn))
1221     count++;
1222   return count;
1223 }
1224
1225
1226 #include "gt-cp-method.h"