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