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-2018 Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22
  23 /* Handle method declarations.  */
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "target.h"
  28 #include "cp-tree.h"
  29 #include "stringpool.h"
  30 #include "cgraph.h"
  31 #include "varasm.h"
  32 #include "toplev.h"
  33 #include "common/common-target.h"
  34
  35 static void do_build_copy_assign (tree);
  36 static void do_build_copy_constructor (tree);
  37 static tree make_alias_for_thunk (tree);
  38
  39 /* Called once to initialize method.c.  */
  40
  41 void
  42 init_method (void)
  43 {
  44   init_mangle ();
  45 }
  46 \f
  47 /* Return a this or result adjusting thunk to FUNCTION.  THIS_ADJUSTING
  48    indicates whether it is a this or result adjusting thunk.
  49    FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
  50    (see thunk_adjust).  VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
  51    never is.  VIRTUAL_OFFSET is the /index/ into the vtable for this
  52    adjusting thunks, we scale it to a byte offset. For covariant
  53    thunks VIRTUAL_OFFSET is the virtual binfo.  You must post process
  54    the returned thunk with finish_thunk.  */
  55
  56 tree
  57 make_thunk (tree function, bool this_adjusting,
  58             tree fixed_offset, tree virtual_offset)
  59 {
  60   HOST_WIDE_INT d;
  61   tree thunk;
  62
  63   gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
  64   /* We can have this thunks to covariant thunks, but not vice versa.  */
  65   gcc_assert (!DECL_THIS_THUNK_P (function));
  66   gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
  67
  68   /* Scale the VIRTUAL_OFFSET to be in terms of bytes.  */
  69   if (this_adjusting && virtual_offset)
  70     virtual_offset
  71       = size_binop (MULT_EXPR,
  72                     virtual_offset,
  73                     convert (ssizetype,
  74                              TYPE_SIZE_UNIT (vtable_entry_type)));
  75
  76   d = tree_to_shwi (fixed_offset);
  77
  78   /* See if we already have the thunk in question.  For this_adjusting
  79      thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
  80      will be a BINFO.  */
  81   for (thunk = DECL_THUNKS (function); thunk; thunk = DECL_CHAIN (thunk))
  82     if (DECL_THIS_THUNK_P (thunk) == this_adjusting
  83         && THUNK_FIXED_OFFSET (thunk) == d
  84         && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
  85         && (!virtual_offset
  86             || (this_adjusting
  87                 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
  88                                       virtual_offset)
  89                 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
  90       return thunk;
  91
  92   /* All thunks must be created before FUNCTION is actually emitted;
  93      the ABI requires that all thunks be emitted together with the
  94      function to which they transfer control.  */
  95   gcc_assert (!TREE_ASM_WRITTEN (function));
  96   /* Likewise, we can only be adding thunks to a function declared in
  97      the class currently being laid out.  */
  98   gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
  99               && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
 100
 101   thunk = build_decl (DECL_SOURCE_LOCATION (function),
 102                       FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
 103   DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
 104   cxx_dup_lang_specific_decl (thunk);
 105   DECL_VIRTUAL_P (thunk) = true;
 106   SET_DECL_THUNKS (thunk, NULL_TREE);
 107
 108   DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
 109   TREE_READONLY (thunk) = TREE_READONLY (function);
 110   TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
 111   TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
 112   SET_DECL_THUNK_P (thunk, this_adjusting);
 113   THUNK_TARGET (thunk) = function;
 114   THUNK_FIXED_OFFSET (thunk) = d;
 115   THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
 116   THUNK_ALIAS (thunk) = NULL_TREE;
 117
 118   DECL_INTERFACE_KNOWN (thunk) = 1;
 119   DECL_NOT_REALLY_EXTERN (thunk) = 1;
 120   DECL_COMDAT (thunk) = DECL_COMDAT (function);
 121   DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
 122   /* The thunk itself is not a constructor or destructor, even if
 123      the thing it is thunking to is.  */
 124   DECL_CXX_DESTRUCTOR_P (thunk) = 0;
 125   DECL_CXX_CONSTRUCTOR_P (thunk) = 0;
 126   DECL_EXTERNAL (thunk) = 1;
 127   DECL_ARTIFICIAL (thunk) = 1;
 128   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
 129   DECL_PENDING_INLINE_P (thunk) = 0;
 130   DECL_DECLARED_INLINE_P (thunk) = 0;
 131   /* Nor is it a template instantiation.  */
 132   DECL_USE_TEMPLATE (thunk) = 0;
 133   DECL_TEMPLATE_INFO (thunk) = NULL;
 134
 135   /* Add it to the list of thunks associated with FUNCTION.  */
 136   DECL_CHAIN (thunk) = DECL_THUNKS (function);
 137   SET_DECL_THUNKS (function, thunk);
 138
 139   return thunk;
 140 }
 141
 142 /* Finish THUNK, a thunk decl.  */
 143
 144 void
 145 finish_thunk (tree thunk)
 146 {
 147   tree function, name;
 148   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
 149   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
 150
 151   gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
 152   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
 153     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 154   function = THUNK_TARGET (thunk);
 155   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
 156                        fixed_offset, virtual_offset, thunk);
 157
 158   /* We can end up with declarations of (logically) different
 159      covariant thunks, that do identical adjustments.  The two thunks
 160      will be adjusting between within different hierarchies, which
 161      happen to have the same layout.  We must nullify one of them to
 162      refer to the other.  */
 163   if (DECL_RESULT_THUNK_P (thunk))
 164     {
 165       tree cov_probe;
 166
 167       for (cov_probe = DECL_THUNKS (function);
 168            cov_probe; cov_probe = DECL_CHAIN (cov_probe))
 169         if (DECL_NAME (cov_probe) == name)
 170           {
 171             gcc_assert (!DECL_THUNKS (thunk));
 172             THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
 173                                    ? THUNK_ALIAS (cov_probe) : cov_probe);
 174             break;
 175           }
 176     }
 177
 178   DECL_NAME (thunk) = name;
 179   SET_DECL_ASSEMBLER_NAME (thunk, name);
 180 }
 181
 182 static GTY (()) int thunk_labelno;
 183
 184 /* Create a static alias to target.  */
 185
 186 tree
 187 make_alias_for (tree target, tree newid)
 188 {
 189   tree alias = build_decl (DECL_SOURCE_LOCATION (target),
 190                            TREE_CODE (target), newid, TREE_TYPE (target));
 191   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (target);
 192   cxx_dup_lang_specific_decl (alias);
 193   DECL_CONTEXT (alias) = DECL_CONTEXT (target);
 194   TREE_READONLY (alias) = TREE_READONLY (target);
 195   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (target);
 196   TREE_PUBLIC (alias) = 0;
 197   DECL_INTERFACE_KNOWN (alias) = 1;
 198   if (DECL_LANG_SPECIFIC (alias))
 199     {
 200       DECL_NOT_REALLY_EXTERN (alias) = 1;
 201       DECL_USE_TEMPLATE (alias) = 0;
 202       DECL_TEMPLATE_INFO (alias) = NULL;
 203     }
 204   DECL_EXTERNAL (alias) = 0;
 205   DECL_ARTIFICIAL (alias) = 1;
 206   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
 207   if (TREE_CODE (alias) == FUNCTION_DECL)
 208     {
 209       DECL_SAVED_FUNCTION_DATA (alias) = NULL;
 210       DECL_CXX_DESTRUCTOR_P (alias) = 0;
 211       DECL_CXX_CONSTRUCTOR_P (alias) = 0;
 212       DECL_PENDING_INLINE_P (alias) = 0;
 213       DECL_DECLARED_INLINE_P (alias) = 0;
 214       DECL_INITIAL (alias) = error_mark_node;
 215       DECL_ARGUMENTS (alias) = copy_list (DECL_ARGUMENTS (target));
 216     }
 217   else
 218     TREE_STATIC (alias) = 1;
 219   TREE_ADDRESSABLE (alias) = 1;
 220   TREE_USED (alias) = 1;
 221   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
 222   return alias;
 223 }
 224
 225 static tree
 226 make_alias_for_thunk (tree function)
 227 {
 228   tree alias;
 229   char buf[256];
 230
 231   targetm.asm_out.generate_internal_label (buf, "LTHUNK", thunk_labelno);
 232   thunk_labelno++;
 233
 234   alias = make_alias_for (function, get_identifier (buf));
 235
 236   if (!flag_syntax_only)
 237     {
 238       struct cgraph_node *funcn, *aliasn;
 239       funcn = cgraph_node::get (function);
 240       gcc_checking_assert (funcn);
 241       aliasn = cgraph_node::create_same_body_alias (alias, function);
 242       DECL_ASSEMBLER_NAME (function);
 243       gcc_assert (aliasn != NULL);
 244     }
 245
 246   return alias;
 247 }
 248
 249 /* Emit the definition of a C++ multiple inheritance or covariant
 250    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
 251    immediately.  */
 252
 253 void
 254 use_thunk (tree thunk_fndecl, bool emit_p)
 255 {
 256   tree a, t, function, alias;
 257   tree virtual_offset;
 258   HOST_WIDE_INT fixed_offset, virtual_value;
 259   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
 260   struct cgraph_node *funcn, *thunk_node;
 261
 262   /* We should have called finish_thunk to give it a name.  */
 263   gcc_assert (DECL_NAME (thunk_fndecl));
 264
 265   /* We should never be using an alias, always refer to the
 266      aliased thunk.  */
 267   gcc_assert (!THUNK_ALIAS (thunk_fndecl));
 268
 269   if (TREE_ASM_WRITTEN (thunk_fndecl))
 270     return;
 271
 272   function = THUNK_TARGET (thunk_fndecl);
 273   if (DECL_RESULT (thunk_fndecl))
 274     /* We already turned this thunk into an ordinary function.
 275        There's no need to process this thunk again.  */
 276     return;
 277
 278   if (DECL_THUNK_P (function))
 279     /* The target is itself a thunk, process it now.  */
 280     use_thunk (function, emit_p);
 281
 282   /* Thunks are always addressable; they only appear in vtables.  */
 283   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 284
 285   /* Figure out what function is being thunked to.  It's referenced in
 286      this translation unit.  */
 287   TREE_ADDRESSABLE (function) = 1;
 288   mark_used (function);
 289   if (!emit_p)
 290     return;
 291
 292   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
 293    alias = make_alias_for_thunk (function);
 294   else
 295    alias = function;
 296
 297   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
 298   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
 299
 300   if (virtual_offset)
 301     {
 302       if (!this_adjusting)
 303         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 304       virtual_value = tree_to_shwi (virtual_offset);
 305       gcc_assert (virtual_value);
 306     }
 307   else
 308     virtual_value = 0;
 309
 310   /* And, if we need to emit the thunk, it's used.  */
 311   mark_used (thunk_fndecl);
 312   /* This thunk is actually defined.  */
 313   DECL_EXTERNAL (thunk_fndecl) = 0;
 314   /* The linkage of the function may have changed.  FIXME in linkage
 315      rewrite.  */
 316   gcc_assert (DECL_INTERFACE_KNOWN (function));
 317   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
 318   DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
 319   DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
 320     = DECL_VISIBILITY_SPECIFIED (function);
 321   DECL_COMDAT (thunk_fndecl) = DECL_COMDAT (function);
 322   DECL_WEAK (thunk_fndecl) = DECL_WEAK (function);
 323
 324   if (flag_syntax_only)
 325     {
 326       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 327       return;
 328     }
 329
 330   push_to_top_level ();
 331
 332   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
 333       && targetm_common.have_named_sections)
 334     {
 335       tree fn = function;
 336       struct symtab_node *symbol;
 337
 338       if ((symbol = symtab_node::get (function))
 339           && symbol->alias)
 340         {
 341           if (symbol->analyzed)
 342             fn = symtab_node::get (function)->ultimate_alias_target ()->decl;
 343           else
 344             fn = symtab_node::get (function)->alias_target;
 345         }
 346       resolve_unique_section (fn, 0, flag_function_sections);
 347
 348       if (DECL_SECTION_NAME (fn) != NULL && DECL_ONE_ONLY (fn))
 349         {
 350           resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
 351
 352           /* Output the thunk into the same section as function.  */
 353           set_decl_section_name (thunk_fndecl, DECL_SECTION_NAME (fn));
 354           symtab_node::get (thunk_fndecl)->implicit_section
 355             = symtab_node::get (fn)->implicit_section;
 356         }
 357     }
 358
 359   /* Set up cloned argument trees for the thunk.  */
 360   t = NULL_TREE;
 361   for (a = DECL_ARGUMENTS (function); a; a = DECL_CHAIN (a))
 362     {
 363       tree x = copy_node (a);
 364       DECL_CHAIN (x) = t;
 365       DECL_CONTEXT (x) = thunk_fndecl;
 366       SET_DECL_RTL (x, NULL);
 367       DECL_HAS_VALUE_EXPR_P (x) = 0;
 368       TREE_ADDRESSABLE (x) = 0;
 369       t = x;
 370     }
 371   a = nreverse (t);
 372   DECL_ARGUMENTS (thunk_fndecl) = a;
 373   TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 374   funcn = cgraph_node::get (function);
 375   gcc_checking_assert (funcn);
 376   thunk_node = funcn->create_thunk (thunk_fndecl, function,
 377                                     this_adjusting, fixed_offset, virtual_value,
 378                                     virtual_offset, alias);
 379   if (DECL_ONE_ONLY (function))
 380     thunk_node->add_to_same_comdat_group (funcn);
 381
 382   pop_from_top_level ();
 383 }
 384 \f
 385 /* Code for synthesizing methods which have default semantics defined.  */
 386
 387 /* True iff CTYPE has a trivial SFK.  */
 388
 389 static bool
 390 type_has_trivial_fn (tree ctype, special_function_kind sfk)
 391 {
 392   switch (sfk)
 393     {
 394     case sfk_constructor:
 395       return !TYPE_HAS_COMPLEX_DFLT (ctype);
 396     case sfk_copy_constructor:
 397       return !TYPE_HAS_COMPLEX_COPY_CTOR (ctype);
 398     case sfk_move_constructor:
 399       return !TYPE_HAS_COMPLEX_MOVE_CTOR (ctype);
 400     case sfk_copy_assignment:
 401       return !TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype);
 402     case sfk_move_assignment:
 403       return !TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype);
 404     case sfk_destructor:
 405       return !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype);
 406     case sfk_inheriting_constructor:
 407       return false;
 408     default:
 409       gcc_unreachable ();
 410     }
 411 }
 412
 413 /* Note that CTYPE has a non-trivial SFK even though we previously thought
 414    it was trivial.  */
 415
 416 static void
 417 type_set_nontrivial_flag (tree ctype, special_function_kind sfk)
 418 {
 419   switch (sfk)
 420     {
 421     case sfk_constructor:
 422       TYPE_HAS_COMPLEX_DFLT (ctype) = true;
 423       return;
 424     case sfk_copy_constructor:
 425       TYPE_HAS_COMPLEX_COPY_CTOR (ctype) = true;
 426       return;
 427     case sfk_move_constructor:
 428       TYPE_HAS_COMPLEX_MOVE_CTOR (ctype) = true;
 429       return;
 430     case sfk_copy_assignment:
 431       TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype) = true;
 432       return;
 433     case sfk_move_assignment:
 434       TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype) = true;
 435       return;
 436     case sfk_destructor:
 437       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true;
 438       return;
 439     case sfk_inheriting_constructor:
 440     default:
 441       gcc_unreachable ();
 442     }
 443 }
 444
 445 /* True iff FN is a trivial defaulted member function ([cd]tor, op=).  */
 446
 447 bool
 448 trivial_fn_p (tree fn)
 449 {
 450   if (TREE_CODE (fn) == TEMPLATE_DECL)
 451     return false;
 452   if (!DECL_DEFAULTED_FN (fn))
 453     return false;
 454
 455   /* If fn is a clone, get the primary variant.  */
 456   if (tree prim = DECL_CLONED_FUNCTION (fn))
 457     fn = prim;
 458   return type_has_trivial_fn (DECL_CONTEXT (fn), special_function_p (fn));
 459 }
 460
 461 /* PARM is a PARM_DECL for a function which we want to forward to another
 462    function without changing its value category, a la std::forward.  */
 463
 464 tree
 465 forward_parm (tree parm)
 466 {
 467   tree exp = convert_from_reference (parm);
 468   tree type = TREE_TYPE (parm);
 469   if (DECL_PACK_P (parm))
 470     type = PACK_EXPANSION_PATTERN (type);
 471   if (TREE_CODE (type) != REFERENCE_TYPE)
 472     type = cp_build_reference_type (type, /*rval=*/true);
 473   warning_sentinel w (warn_useless_cast);
 474   exp = build_static_cast (type, exp, tf_warning_or_error);
 475   if (DECL_PACK_P (parm))
 476     exp = make_pack_expansion (exp);
 477   return exp;
 478 }
 479
 480 /* Strip all inheriting constructors, if any, to return the original
 481    constructor from a (possibly indirect) base class.  */
 482
 483 tree
 484 strip_inheriting_ctors (tree dfn)
 485 {
 486   if (!flag_new_inheriting_ctors)
 487     return dfn;
 488   tree fn = dfn;
 489   while (tree inh = DECL_INHERITED_CTOR (fn))
 490     fn = OVL_FIRST (inh);
 491
 492   if (TREE_CODE (fn) == TEMPLATE_DECL
 493       && TREE_CODE (dfn) == FUNCTION_DECL)
 494     fn = DECL_TEMPLATE_RESULT (fn);
 495   return fn;
 496 }
 497
 498 /* Find the binfo for the base subobject of BINFO being initialized by
 499    inherited constructor FNDECL (a member of a direct base of BINFO).  */
 500
 501 static tree inherited_ctor_binfo (tree, tree);
 502 static tree
 503 inherited_ctor_binfo_1 (tree binfo, tree fndecl)
 504 {
 505   tree base = DECL_CONTEXT (fndecl);
 506   tree base_binfo;
 507   for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 508     if (BINFO_TYPE (base_binfo) == base)
 509       return inherited_ctor_binfo (base_binfo, fndecl);
 510
 511   gcc_unreachable();
 512 }
 513
 514 /* Find the binfo for the base subobject of BINFO being initialized by
 515    inheriting constructor FNDECL (a member of BINFO), or BINFO if FNDECL is not
 516    an inheriting constructor.  */
 517
 518 static tree
 519 inherited_ctor_binfo (tree binfo, tree fndecl)
 520 {
 521   tree inh = DECL_INHERITED_CTOR (fndecl);
 522   if (!inh)
 523     return binfo;
 524
 525   tree results = NULL_TREE;
 526   for (ovl_iterator iter (inh); iter; ++iter)
 527     {
 528       tree one = inherited_ctor_binfo_1 (binfo, *iter);
 529       if (!results)
 530         results = one;
 531       else if (one != results)
 532         results = tree_cons (NULL_TREE, one, results);
 533     }
 534   return results;
 535 }
 536
 537 /* Find the binfo for the base subobject being initialized by inheriting
 538    constructor FNDECL, or NULL_TREE if FNDECL is not an inheriting
 539    constructor.  */
 540
 541 tree
 542 inherited_ctor_binfo (tree fndecl)
 543 {
 544   if (!DECL_INHERITED_CTOR (fndecl))
 545     return NULL_TREE;
 546   tree binfo = TYPE_BINFO (DECL_CONTEXT (fndecl));
 547   return inherited_ctor_binfo (binfo, fndecl);
 548 }
 549
 550 /* True if we should omit all user-declared parameters from constructor FN,
 551    because it is a base clone of a ctor inherited from a virtual base.  */
 552
 553 bool
 554 ctor_omit_inherited_parms (tree fn)
 555 {
 556   if (!flag_new_inheriting_ctors)
 557     /* We only optimize away the parameters in the new model.  */
 558     return false;
 559   if (!DECL_BASE_CONSTRUCTOR_P (fn)
 560       || !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
 561     return false;
 562   if (FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (fn)) == void_list_node)
 563     /* No user-declared parameters to omit.  */
 564     return false;
 565   tree binfo = inherited_ctor_binfo (fn);
 566   for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo))
 567     if (BINFO_VIRTUAL_P (binfo))
 568       return true;
 569   return false;
 570 }
 571
 572 /* True iff constructor(s) INH inherited into BINFO initializes INIT_BINFO.
 573    This can be true for multiple virtual bases as well as one direct
 574    non-virtual base.  */
 575
 576 static bool
 577 binfo_inherited_from (tree binfo, tree init_binfo, tree inh)
 578 {
 579   /* inh is an OVERLOAD if we inherited the same constructor along
 580      multiple paths, check all of them.  */
 581   for (ovl_iterator iter (inh); iter; ++iter)
 582     {
 583       tree fn = *iter;
 584       tree base = DECL_CONTEXT (fn);
 585       tree base_binfo = NULL_TREE;
 586       for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 587         if (BINFO_TYPE (base_binfo) == base)
 588           break;
 589       if (base_binfo == init_binfo
 590           || (flag_new_inheriting_ctors
 591               && binfo_inherited_from (base_binfo, init_binfo,
 592                                        DECL_INHERITED_CTOR (fn))))
 593         return true;
 594     }
 595   return false;
 596 }
 597
 598 /* Subroutine of do_build_copy_constructor: Add a mem-initializer for BINFO
 599    given the parameter or parameters PARM, possibly inherited constructor
 600    base INH, or move flag MOVE_P.  */
 601
 602 static tree
 603 add_one_base_init (tree binfo, tree parm, bool move_p, tree inh,
 604                    tree member_init_list)
 605 {
 606   tree init;
 607   if (inh)
 608     {
 609       /* An inheriting constructor only has a mem-initializer for
 610          the base it inherits from.  */
 611       if (!binfo_inherited_from (TYPE_BINFO (current_class_type), binfo, inh))
 612         return member_init_list;
 613
 614       tree *p = &init;
 615       init = NULL_TREE;
 616       for (; parm; parm = DECL_CHAIN (parm))
 617         {
 618           tree exp = forward_parm (parm);
 619           *p = build_tree_list (NULL_TREE, exp);
 620           p = &TREE_CHAIN (*p);
 621         }
 622     }
 623   else
 624     {
 625       init = build_base_path (PLUS_EXPR, parm, binfo, 1,
 626                               tf_warning_or_error);
 627       if (move_p)
 628         init = move (init);
 629       init = build_tree_list (NULL_TREE, init);
 630     }
 631   return tree_cons (binfo, init, member_init_list);
 632 }
 633
 634 /* Generate code for default X(X&) or X(X&&) constructor or an inheriting
 635    constructor.  */
 636
 637 static void
 638 do_build_copy_constructor (tree fndecl)
 639 {
 640   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
 641   bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
 642   bool trivial = trivial_fn_p (fndecl);
 643   tree inh = DECL_INHERITED_CTOR (fndecl);
 644
 645   if (!inh)
 646     parm = convert_from_reference (parm);
 647
 648   if (trivial)
 649     {
 650       if (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 (tree_int_cst_equal (TYPE_SIZE (current_class_type),
 654                                    CLASSTYPE_SIZE (current_class_type)))
 655         {
 656           tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
 657           finish_expr_stmt (t);
 658         }
 659       else
 660         {
 661           /* We must only copy the non-tail padding parts.  */
 662           tree base_size = CLASSTYPE_SIZE_UNIT (current_class_type);
 663           base_size = size_binop (MINUS_EXPR, base_size, size_int (1));
 664           tree array_type = build_array_type (unsigned_char_type_node,
 665                                               build_index_type (base_size));
 666           tree alias_set = build_int_cst (TREE_TYPE (current_class_ptr), 0);
 667           tree lhs = build2 (MEM_REF, array_type,
 668                              current_class_ptr, alias_set);
 669           tree rhs = build2 (MEM_REF, array_type,
 670                              TREE_OPERAND (parm, 0), alias_set);
 671           tree t = build2 (INIT_EXPR, void_type_node, lhs, rhs);
 672           finish_expr_stmt (t);
 673         }
 674     }
 675   else
 676     {
 677       tree fields = TYPE_FIELDS (current_class_type);
 678       tree member_init_list = NULL_TREE;
 679       int cvquals = cp_type_quals (TREE_TYPE (parm));
 680       int i;
 681       tree binfo, base_binfo;
 682       tree init;
 683       vec<tree, va_gc> *vbases;
 684
 685       /* Initialize all the base-classes with the parameter converted
 686          to their type so that we get their copy constructor and not
 687          another constructor that takes current_class_type.  We must
 688          deal with the binfo's directly as a direct base might be
 689          inaccessible due to ambiguity.  */
 690       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
 691            vec_safe_iterate (vbases, i, &binfo); i++)
 692         {
 693           member_init_list = add_one_base_init (binfo, parm, move_p, inh,
 694                                                 member_init_list);
 695         }
 696
 697       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 698            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 699         {
 700           if (BINFO_VIRTUAL_P (base_binfo))
 701             continue;
 702           member_init_list = add_one_base_init (base_binfo, parm, move_p,
 703                                                 inh, member_init_list);
 704         }
 705
 706       for (; fields; fields = DECL_CHAIN (fields))
 707         {
 708           tree field = fields;
 709           tree expr_type;
 710
 711           if (TREE_CODE (field) != FIELD_DECL)
 712             continue;
 713           if (inh)
 714             continue;
 715
 716           expr_type = TREE_TYPE (field);
 717           if (DECL_NAME (field))
 718             {
 719               if (VFIELD_NAME_P (DECL_NAME (field)))
 720                 continue;
 721             }
 722           else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
 723             /* Just use the field; anonymous types can't have
 724                nontrivial copy ctors or assignment ops or this
 725                function would be deleted.  */;
 726           else
 727             continue;
 728
 729           /* Compute the type of "init->field".  If the copy-constructor
 730              parameter is, for example, "const S&", and the type of
 731              the field is "T", then the type will usually be "const
 732              T".  (There are no cv-qualified variants of reference
 733              types.)  */
 734           if (TREE_CODE (expr_type) != REFERENCE_TYPE)
 735             {
 736               int quals = cvquals;
 737
 738               if (DECL_MUTABLE_P (field))
 739                 quals &= ~TYPE_QUAL_CONST;
 740               quals |= cp_type_quals (expr_type);
 741               expr_type = cp_build_qualified_type (expr_type, quals);
 742             }
 743
 744           init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
 745           if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE
 746               /* 'move' breaks bit-fields, and has no effect for scalars.  */
 747               && !scalarish_type_p (expr_type))
 748             init = move (init);
 749           init = build_tree_list (NULL_TREE, init);
 750
 751           member_init_list = tree_cons (field, init, member_init_list);
 752         }
 753       finish_mem_initializers (member_init_list);
 754     }
 755 }
 756
 757 static void
 758 do_build_copy_assign (tree fndecl)
 759 {
 760   tree parm = DECL_CHAIN (DECL_ARGUMENTS (fndecl));
 761   tree compound_stmt;
 762   bool move_p = move_fn_p (fndecl);
 763   bool trivial = trivial_fn_p (fndecl);
 764   int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
 765
 766   compound_stmt = begin_compound_stmt (0);
 767   parm = convert_from_reference (parm);
 768
 769   if (trivial
 770       && is_empty_class (current_class_type))
 771     /* Don't copy the padding byte; it might not have been allocated
 772        if *this is a base subobject.  */;
 773   else if (trivial)
 774     {
 775       tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
 776       finish_expr_stmt (t);
 777     }
 778   else
 779     {
 780       tree fields;
 781       int cvquals = cp_type_quals (TREE_TYPE (parm));
 782       int i;
 783       tree binfo, base_binfo;
 784
 785       /* Assign to each of the direct base classes.  */
 786       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 787            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 788         {
 789           tree converted_parm;
 790           vec<tree, va_gc> *parmvec;
 791
 792           /* We must convert PARM directly to the base class
 793              explicitly since the base class may be ambiguous.  */
 794           converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1,
 795                                             tf_warning_or_error);
 796           if (move_p)
 797             converted_parm = move (converted_parm);
 798           /* Call the base class assignment operator.  */
 799           parmvec = make_tree_vector_single (converted_parm);
 800           finish_expr_stmt
 801             (build_special_member_call (current_class_ref,
 802                                         assign_op_identifier,
 803                                         &parmvec,
 804                                         base_binfo,
 805                                         flags,
 806                                         tf_warning_or_error));
 807           release_tree_vector (parmvec);
 808         }
 809
 810       /* Assign to each of the non-static data members.  */
 811       for (fields = TYPE_FIELDS (current_class_type);
 812            fields;
 813            fields = DECL_CHAIN (fields))
 814         {
 815           tree comp = current_class_ref;
 816           tree init = parm;
 817           tree field = fields;
 818           tree expr_type;
 819           int quals;
 820
 821           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 822             continue;
 823
 824           expr_type = TREE_TYPE (field);
 825
 826           if (CP_TYPE_CONST_P (expr_type))
 827             {
 828               error ("non-static const member %q#D, can%'t use default "
 829                      "assignment operator", field);
 830               continue;
 831             }
 832           else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
 833             {
 834               error ("non-static reference member %q#D, can%'t use "
 835                      "default assignment operator", field);
 836               continue;
 837             }
 838
 839           if (DECL_NAME (field))
 840             {
 841               if (VFIELD_NAME_P (DECL_NAME (field)))
 842                 continue;
 843             }
 844           else if (ANON_AGGR_TYPE_P (expr_type)
 845                    && TYPE_FIELDS (expr_type) != NULL_TREE)
 846             /* Just use the field; anonymous types can't have
 847                nontrivial copy ctors or assignment ops or this
 848                function would be deleted.  */;
 849           else
 850             continue;
 851
 852           comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
 853
 854           /* Compute the type of init->field  */
 855           quals = cvquals;
 856           if (DECL_MUTABLE_P (field))
 857             quals &= ~TYPE_QUAL_CONST;
 858           expr_type = cp_build_qualified_type (expr_type, quals);
 859
 860           init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
 861           if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE
 862               /* 'move' breaks bit-fields, and has no effect for scalars.  */
 863               && !scalarish_type_p (expr_type))
 864             init = move (init);
 865
 866           if (DECL_NAME (field))
 867             init = cp_build_modify_expr (input_location, comp, NOP_EXPR, init,
 868                                          tf_warning_or_error);
 869           else
 870             init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
 871           finish_expr_stmt (init);
 872         }
 873     }
 874   finish_return_stmt (current_class_ref);
 875   finish_compound_stmt (compound_stmt);
 876 }
 877
 878 /* Synthesize FNDECL, a non-static member function.   */
 879
 880 void
 881 synthesize_method (tree fndecl)
 882 {
 883   bool nested = (current_function_decl != NULL_TREE);
 884   tree context = decl_function_context (fndecl);
 885   bool need_body = true;
 886   tree stmt;
 887   location_t save_input_location = input_location;
 888   int error_count = errorcount;
 889   int warning_count = warningcount + werrorcount;
 890
 891   /* Reset the source location, we might have been previously
 892      deferred, and thus have saved where we were first needed.  */
 893   DECL_SOURCE_LOCATION (fndecl)
 894     = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
 895
 896   /* If we've been asked to synthesize a clone, just synthesize the
 897      cloned function instead.  Doing so will automatically fill in the
 898      body for the clone.  */
 899   if (DECL_CLONED_FUNCTION_P (fndecl))
 900     fndecl = DECL_CLONED_FUNCTION (fndecl);
 901
 902   /* We may be in the middle of deferred access check.  Disable
 903      it now.  */
 904   push_deferring_access_checks (dk_no_deferred);
 905
 906   if (! context)
 907     push_to_top_level ();
 908   else if (nested)
 909     push_function_context ();
 910
 911   input_location = DECL_SOURCE_LOCATION (fndecl);
 912
 913   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 914   stmt = begin_function_body ();
 915
 916   if (DECL_ASSIGNMENT_OPERATOR_P (fndecl)
 917       && DECL_OVERLOADED_OPERATOR_IS (fndecl, NOP_EXPR))
 918     {
 919       do_build_copy_assign (fndecl);
 920       need_body = false;
 921     }
 922   else if (DECL_CONSTRUCTOR_P (fndecl))
 923     {
 924       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 925       if (arg_chain != void_list_node)
 926         do_build_copy_constructor (fndecl);
 927       else
 928         finish_mem_initializers (NULL_TREE);
 929     }
 930
 931   /* If we haven't yet generated the body of the function, just
 932      generate an empty compound statement.  */
 933   if (need_body)
 934     {
 935       tree compound_stmt;
 936       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
 937       finish_compound_stmt (compound_stmt);
 938     }
 939
 940   finish_function_body (stmt);
 941   expand_or_defer_fn (finish_function (/*inline_p=*/false));
 942
 943   input_location = save_input_location;
 944
 945   if (! context)
 946     pop_from_top_level ();
 947   else if (nested)
 948     pop_function_context ();
 949
 950   pop_deferring_access_checks ();
 951
 952   if (error_count != errorcount || warning_count != warningcount + werrorcount)
 953     inform (input_location, "synthesized method %qD first required here ",
 954             fndecl);
 955 }
 956
 957 /* Build a reference to type TYPE with cv-quals QUALS, which is an
 958    rvalue if RVALUE is true.  */
 959
 960 static tree
 961 build_stub_type (tree type, int quals, bool rvalue)
 962 {
 963   tree argtype = cp_build_qualified_type (type, quals);
 964   return cp_build_reference_type (argtype, rvalue);
 965 }
 966
 967 /* Build a dummy glvalue from dereferencing a dummy reference of type
 968    REFTYPE.  */
 969
 970 static tree
 971 build_stub_object (tree reftype)
 972 {
 973   if (TREE_CODE (reftype) != REFERENCE_TYPE)
 974     reftype = cp_build_reference_type (reftype, /*rval*/true);
 975   tree stub = build1 (CONVERT_EXPR, reftype, integer_one_node);
 976   return convert_from_reference (stub);
 977 }
 978
 979 /* Determine which function will be called when looking up NAME in TYPE,
 980    called with a single ARGTYPE argument, or no argument if ARGTYPE is
 981    null.  FLAGS and COMPLAIN are as for build_new_method_call.
 982
 983    Returns a FUNCTION_DECL if all is well.
 984    Returns NULL_TREE if overload resolution failed.
 985    Returns error_mark_node if the chosen function cannot be called.  */
 986
 987 static tree
 988 locate_fn_flags (tree type, tree name, tree argtype, int flags,
 989                  tsubst_flags_t complain)
 990 {
 991   tree ob, fn, fns, binfo, rval;
 992   vec<tree, va_gc> *args;
 993
 994   if (TYPE_P (type))
 995     binfo = TYPE_BINFO (type);
 996   else
 997     {
 998       binfo = type;
 999       type = BINFO_TYPE (binfo);
1000     }
1001
1002   ob = build_stub_object (cp_build_reference_type (type, false));
1003   args = make_tree_vector ();
1004   if (argtype)
1005     {
1006       if (TREE_CODE (argtype) == TREE_LIST)
1007         {
1008           for (tree elt = argtype; elt && elt != void_list_node;
1009                elt = TREE_CHAIN (elt))
1010             {
1011               tree type = TREE_VALUE (elt);
1012               tree arg = build_stub_object (type);
1013               vec_safe_push (args, arg);
1014             }
1015         }
1016       else
1017         {
1018           tree arg = build_stub_object (argtype);
1019           args->quick_push (arg);
1020         }
1021     }
1022
1023   fns = lookup_fnfields (binfo, name, 0);
1024   rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
1025
1026   release_tree_vector (args);
1027   if (fn && rval == error_mark_node)
1028     return rval;
1029   else
1030     return fn;
1031 }
1032
1033 /* Locate the dtor of TYPE.  */
1034
1035 tree
1036 get_dtor (tree type, tsubst_flags_t complain)
1037 {
1038   tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
1039                              LOOKUP_NORMAL, complain);
1040   if (fn == error_mark_node)
1041     return NULL_TREE;
1042   return fn;
1043 }
1044
1045 /* Locate the default ctor of TYPE.  */
1046
1047 tree
1048 locate_ctor (tree type)
1049 {
1050   tree fn;
1051
1052   push_deferring_access_checks (dk_no_check);
1053   fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
1054                         LOOKUP_SPECULATIVE, tf_none);
1055   pop_deferring_access_checks ();
1056   if (fn == error_mark_node)
1057     return NULL_TREE;
1058   return fn;
1059 }
1060
1061 /* Likewise, but give any appropriate errors.  */
1062
1063 tree
1064 get_default_ctor (tree type)
1065 {
1066   tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
1067                              LOOKUP_NORMAL, tf_warning_or_error);
1068   if (fn == error_mark_node)
1069     return NULL_TREE;
1070   return fn;
1071 }
1072
1073 /* Locate the copy ctor of TYPE.  */
1074
1075 tree
1076 get_copy_ctor (tree type, tsubst_flags_t complain)
1077 {
1078   int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
1079                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
1080   tree argtype = build_stub_type (type, quals, false);
1081   tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
1082                              LOOKUP_NORMAL, complain);
1083   if (fn == error_mark_node)
1084     return NULL_TREE;
1085   return fn;
1086 }
1087
1088 /* Locate the copy assignment operator of TYPE.  */
1089
1090 tree
1091 get_copy_assign (tree type)
1092 {
1093   int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
1094                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
1095   tree argtype = build_stub_type (type, quals, false);
1096   tree fn = locate_fn_flags (type, assign_op_identifier, argtype,
1097                              LOOKUP_NORMAL, tf_warning_or_error);
1098   if (fn == error_mark_node)
1099     return NULL_TREE;
1100   return fn;
1101 }
1102
1103 /* walk_tree helper function for is_trivially_xible.  If *TP is a call,
1104    return it if it calls something other than a trivial special member
1105    function.  */
1106
1107 static tree
1108 check_nontriv (tree *tp, int *, void *)
1109 {
1110   tree fn = cp_get_callee (*tp);
1111   if (fn == NULL_TREE)
1112     return NULL_TREE;
1113
1114   if (TREE_CODE (fn) == ADDR_EXPR)
1115     fn = TREE_OPERAND (fn, 0);
1116
1117   if (TREE_CODE (fn) != FUNCTION_DECL
1118       || !trivial_fn_p (fn))
1119     return fn;
1120   return NULL_TREE;
1121 }
1122
1123 /* Return declval<T>() = declval<U>() treated as an unevaluated operand.  */
1124
1125 static tree
1126 assignable_expr (tree to, tree from)
1127 {
1128   ++cp_unevaluated_operand;
1129   to = build_stub_object (to);
1130   from = build_stub_object (from);
1131   tree r = cp_build_modify_expr (input_location, to, NOP_EXPR, from, tf_none);
1132   --cp_unevaluated_operand;
1133   return r;
1134 }
1135
1136 /* The predicate condition for a template specialization
1137    is_constructible<T, Args...> shall be satisfied if and only if the
1138    following variable definition would be well-formed for some invented
1139    variable t: T t(create<Args>()...);
1140
1141    Return something equivalent in well-formedness and triviality.  */
1142
1143 static tree
1144 constructible_expr (tree to, tree from)
1145 {
1146   tree expr;
1147   if (CLASS_TYPE_P (to))
1148     {
1149       tree ctype = to;
1150       vec<tree, va_gc> *args = NULL;
1151       cp_unevaluated cp_uneval_guard;
1152       if (TREE_CODE (to) != REFERENCE_TYPE)
1153         to = cp_build_reference_type (to, /*rval*/false);
1154       tree ob = build_stub_object (to);
1155       for (; from; from = TREE_CHAIN (from))
1156         vec_safe_push (args, build_stub_object (TREE_VALUE (from)));
1157       expr = build_special_member_call (ob, complete_ctor_identifier, &args,
1158                                         ctype, LOOKUP_NORMAL, tf_none);
1159       if (expr == error_mark_node)
1160         return error_mark_node;
1161       /* The current state of the standard vis-a-vis LWG 2116 is that
1162          is_*constructible involves destruction as well.  */
1163       if (type_build_dtor_call (ctype))
1164         {
1165           tree dtor = build_special_member_call (ob, complete_dtor_identifier,
1166                                                  NULL, ctype, LOOKUP_NORMAL,
1167                                                  tf_none);
1168           if (dtor == error_mark_node)
1169             return error_mark_node;
1170           if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (ctype))
1171             expr = build2 (COMPOUND_EXPR, void_type_node, expr, dtor);
1172         }
1173     }
1174   else
1175     {
1176       if (from == NULL_TREE)
1177         return build_value_init (strip_array_types (to), tf_none);
1178       else if (TREE_CHAIN (from))
1179         return error_mark_node; // too many initializers
1180       from = build_stub_object (TREE_VALUE (from));
1181       expr = perform_direct_initialization_if_possible (to, from,
1182                                                         /*cast*/false,
1183                                                         tf_none);
1184     }
1185   return expr;
1186 }
1187
1188 /* Returns a tree iff TO is assignable (if CODE is MODIFY_EXPR) or
1189    constructible (otherwise) from FROM, which is a single type for
1190    assignment or a list of types for construction.  */
1191
1192 static tree
1193 is_xible_helper (enum tree_code code, tree to, tree from, bool trivial)
1194 {
1195   if (VOID_TYPE_P (to) || ABSTRACT_CLASS_TYPE_P (to)
1196       || (from && FUNC_OR_METHOD_TYPE_P (from)
1197           && (TYPE_READONLY (from) || FUNCTION_REF_QUALIFIED (from))))
1198     return error_mark_node;
1199   tree expr;
1200   if (code == MODIFY_EXPR)
1201     expr = assignable_expr (to, from);
1202   else if (trivial && from && TREE_CHAIN (from))
1203     return error_mark_node; // only 0- and 1-argument ctors can be trivial
1204   else
1205     expr = constructible_expr (to, from);
1206   return expr;
1207 }
1208
1209 /* Returns true iff TO is trivially assignable (if CODE is MODIFY_EXPR) or
1210    constructible (otherwise) from FROM, which is a single type for
1211    assignment or a list of types for construction.  */
1212
1213 bool
1214 is_trivially_xible (enum tree_code code, tree to, tree from)
1215 {
1216   tree expr;
1217   expr = is_xible_helper (code, to, from, /*trivial*/true);
1218
1219   if (expr == error_mark_node)
1220     return false;
1221   tree nt = cp_walk_tree_without_duplicates (&expr, check_nontriv, NULL);
1222   return !nt;
1223 }
1224
1225 /* Returns true iff TO is assignable (if CODE is MODIFY_EXPR) or
1226    constructible (otherwise) from FROM, which is a single type for
1227    assignment or a list of types for construction.  */
1228
1229 bool
1230 is_xible (enum tree_code code, tree to, tree from)
1231 {
1232   tree expr = is_xible_helper (code, to, from, /*trivial*/false);
1233   if (expr == error_mark_node)
1234     return false;
1235   return !!expr;
1236 }
1237
1238 /* Subroutine of synthesized_method_walk.  Update SPEC_P, TRIVIAL_P and
1239    DELETED_P or give an error message MSG with argument ARG.  */
1240
1241 static void
1242 process_subob_fn (tree fn, tree *spec_p, bool *trivial_p,
1243                   bool *deleted_p, bool *constexpr_p,
1244                   bool diag, tree arg, bool dtor_from_ctor = false)
1245 {
1246   if (!fn || fn == error_mark_node)
1247     {
1248       if (deleted_p)
1249         *deleted_p = true;
1250       return;
1251     }
1252
1253   if (spec_p)
1254     {
1255       maybe_instantiate_noexcept (fn);
1256       tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
1257       *spec_p = merge_exception_specifiers (*spec_p, raises);
1258     }
1259
1260   if (!trivial_fn_p (fn) && !dtor_from_ctor)
1261     {
1262       if (trivial_p)
1263         *trivial_p = false;
1264       if (TREE_CODE (arg) == FIELD_DECL
1265           && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
1266         {
1267           if (deleted_p)
1268             *deleted_p = true;
1269           if (diag)
1270             error ("union member %q+D with non-trivial %qD", arg, fn);
1271         }
1272     }
1273
1274   if (constexpr_p && !DECL_DECLARED_CONSTEXPR_P (fn))
1275     {
1276       *constexpr_p = false;
1277       if (diag)
1278         {
1279           inform (DECL_SOURCE_LOCATION (fn),
1280                   "defaulted constructor calls non-%<constexpr%> %qD", fn);
1281           explain_invalid_constexpr_fn (fn);
1282         }
1283     }
1284 }
1285
1286 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
1287    aggregates.  If DTOR_FROM_CTOR is true, we're walking subobject destructors
1288    called from a synthesized constructor, in which case we don't consider
1289    the triviality of the subobject destructor.  */
1290
1291 static void
1292 walk_field_subobs (tree fields, tree fnname, special_function_kind sfk,
1293                    int quals, bool copy_arg_p, bool move_p,
1294                    bool assign_p, tree *spec_p, bool *trivial_p,
1295                    bool *deleted_p, bool *constexpr_p,
1296                    bool diag, int flags, tsubst_flags_t complain,
1297                    bool dtor_from_ctor)
1298 {
1299   tree field;
1300   for (field = fields; field; field = DECL_CHAIN (field))
1301     {
1302       tree mem_type, argtype, rval;
1303
1304       if (TREE_CODE (field) != FIELD_DECL
1305           || DECL_ARTIFICIAL (field))
1306         continue;
1307
1308       mem_type = strip_array_types (TREE_TYPE (field));
1309       if (assign_p)
1310         {
1311           bool bad = true;
1312           if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
1313             {
1314               if (diag)
1315                 error ("non-static const member %q#D, can%'t use default "
1316                        "assignment operator", field);
1317             }
1318           else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1319             {
1320               if (diag)
1321                 error ("non-static reference member %q#D, can%'t use "
1322                        "default assignment operator", field);
1323             }
1324           else
1325             bad = false;
1326
1327           if (bad && deleted_p)
1328             *deleted_p = true;
1329         }
1330       else if (sfk == sfk_constructor || sfk == sfk_inheriting_constructor)
1331         {
1332           bool bad;
1333
1334           if (DECL_INITIAL (field))
1335             {
1336               if (diag && DECL_INITIAL (field) == error_mark_node)
1337                 inform (DECL_SOURCE_LOCATION (field),
1338                         "initializer for %q#D is invalid", field);
1339               if (trivial_p)
1340                 *trivial_p = false;
1341               /* Core 1351: If the field has an NSDMI that could throw, the
1342                  default constructor is noexcept(false).  */
1343               if (spec_p)
1344                 {
1345                   tree nsdmi = get_nsdmi (field, /*ctor*/false, complain);
1346                   if (!expr_noexcept_p (nsdmi, complain))
1347                     *spec_p = noexcept_false_spec;
1348                 }
1349               /* Don't do the normal processing.  */
1350               continue;
1351             }
1352
1353           bad = false;
1354           if (CP_TYPE_CONST_P (mem_type)
1355               && default_init_uninitialized_part (mem_type))
1356             {
1357               if (diag)
1358                 {
1359                   error ("uninitialized const member in %q#T",
1360                          current_class_type);
1361                   inform (DECL_SOURCE_LOCATION (field),
1362                           "%q#D should be initialized", field);
1363                 }
1364               bad = true;
1365             }
1366           else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1367             {
1368               if (diag)
1369                 {
1370                   error ("uninitialized reference member in %q#T",
1371                          current_class_type);
1372                   inform (DECL_SOURCE_LOCATION (field),
1373                           "%q#D should be initialized", field);
1374                 }
1375               bad = true;
1376             }
1377
1378           if (bad && deleted_p)
1379             *deleted_p = true;
1380
1381           /* For an implicitly-defined default constructor to be constexpr,
1382              every member must have a user-provided default constructor or
1383              an explicit initializer.  */
1384           if (constexpr_p && !CLASS_TYPE_P (mem_type)
1385               && TREE_CODE (DECL_CONTEXT (field)) != UNION_TYPE)
1386             {
1387               *constexpr_p = false;
1388               if (diag)
1389                 inform (DECL_SOURCE_LOCATION (field),
1390                         "defaulted default constructor does not "
1391                         "initialize %q#D", field);
1392             }
1393         }
1394       else if (sfk == sfk_copy_constructor)
1395         {
1396           /* 12.8p11b5 */
1397           if (TREE_CODE (mem_type) == REFERENCE_TYPE
1398               && TYPE_REF_IS_RVALUE (mem_type))
1399             {
1400               if (diag)
1401                 error ("copying non-static data member %q#D of rvalue "
1402                        "reference type", field);
1403               if (deleted_p)
1404                 *deleted_p = true;
1405             }
1406         }
1407
1408       if (!CLASS_TYPE_P (mem_type))
1409         continue;
1410
1411       if (ANON_AGGR_TYPE_P (mem_type))
1412         {
1413           walk_field_subobs (TYPE_FIELDS (mem_type), fnname, sfk, quals,
1414                              copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1415                              deleted_p, constexpr_p,
1416                              diag, flags, complain, dtor_from_ctor);
1417           continue;
1418         }
1419
1420       if (copy_arg_p)
1421         {
1422           int mem_quals = cp_type_quals (mem_type) | quals;
1423           if (DECL_MUTABLE_P (field))
1424             mem_quals &= ~TYPE_QUAL_CONST;
1425           argtype = build_stub_type (mem_type, mem_quals, move_p);
1426         }
1427       else
1428         argtype = NULL_TREE;
1429
1430       rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
1431
1432       process_subob_fn (rval, spec_p, trivial_p, deleted_p,
1433                         constexpr_p, diag, field, dtor_from_ctor);
1434     }
1435 }
1436
1437 /* Base walker helper for synthesized_method_walk.  Inspect a direct
1438    or virtual base.  BINFO is the parent type's binfo.  BASE_BINFO is
1439    the base binfo of interests.  All other parms are as for
1440    synthesized_method_walk, or its local vars.  */
1441
1442 static tree
1443 synthesized_method_base_walk (tree binfo, tree base_binfo,
1444                               int quals, bool copy_arg_p,
1445                               bool move_p, bool ctor_p,
1446                               tree *inheriting_ctor, tree inherited_parms,
1447                               tree fnname, int flags, bool diag,
1448                               tree *spec_p, bool *trivial_p,
1449                               bool *deleted_p, bool *constexpr_p)
1450 {
1451   bool inherited_binfo = false;
1452   tree argtype = NULL_TREE;
1453   deferring_kind defer = dk_no_deferred;
1454
1455   if (copy_arg_p)
1456     argtype = build_stub_type (BINFO_TYPE (base_binfo), quals, move_p);
1457   else if (inheriting_ctor
1458            && (inherited_binfo
1459                = binfo_inherited_from (binfo, base_binfo, *inheriting_ctor)))
1460     {
1461       argtype = inherited_parms;
1462       /* Don't check access on the inherited constructor.  */
1463       if (flag_new_inheriting_ctors)
1464         defer = dk_deferred;
1465     }
1466   /* To be conservative, ignore access to the base dtor that
1467      DR1658 instructs us to ignore.  See the comment in
1468      synthesized_method_walk.  */
1469   else if (cxx_dialect >= cxx14 && fnname == complete_dtor_identifier
1470            && BINFO_VIRTUAL_P (base_binfo)
1471            && ABSTRACT_CLASS_TYPE_P (BINFO_TYPE (binfo)))
1472     defer = dk_no_check;
1473
1474   if (defer != dk_no_deferred)
1475     push_deferring_access_checks (defer);
1476   tree rval = locate_fn_flags (base_binfo, fnname, argtype, flags,
1477                                diag ? tf_warning_or_error : tf_none);
1478   if (defer != dk_no_deferred)
1479     pop_deferring_access_checks ();
1480
1481   /* Replace an inherited template with the appropriate specialization.  */
1482   if (inherited_binfo && rval
1483       && DECL_P (*inheriting_ctor) && DECL_P (rval)
1484       && DECL_CONTEXT (*inheriting_ctor) == DECL_CONTEXT (rval))
1485     *inheriting_ctor = DECL_CLONED_FUNCTION (rval);
1486
1487   process_subob_fn (rval, spec_p, trivial_p, deleted_p,
1488                     constexpr_p, diag, BINFO_TYPE (base_binfo));
1489   if (ctor_p &&
1490       (!BINFO_VIRTUAL_P (base_binfo)
1491        || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))))
1492     {
1493       /* In a constructor we also need to check the subobject
1494          destructors for cleanup of partially constructed objects.  */
1495       tree dtor = locate_fn_flags (base_binfo, complete_dtor_identifier,
1496                                    NULL_TREE, flags,
1497                                    diag ? tf_warning_or_error : tf_none);
1498           /* Note that we don't pass down trivial_p; the subobject
1499              destructors don't affect triviality of the constructor.  Nor
1500              do they affect constexpr-ness (a constant expression doesn't
1501              throw) or exception-specification (a throw from one of the
1502              dtors would be a double-fault).  */
1503       process_subob_fn (dtor, NULL, NULL, deleted_p, NULL, false,
1504                         BINFO_TYPE (base_binfo), /*dtor_from_ctor*/true);
1505     }
1506
1507   return rval;
1508 }
1509
1510 /* The caller wants to generate an implicit declaration of SFK for
1511    CTYPE which is const if relevant and CONST_P is set.  If SPEC_P,
1512    TRIVIAL_P, DELETED_P or CONSTEXPR_P are non-null, set their
1513    referent appropriately.  If DIAG is true, we're either being called
1514    from maybe_explain_implicit_delete to give errors, or if
1515    CONSTEXPR_P is non-null, from explain_invalid_constexpr_fn.  */
1516
1517 static void
1518 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
1519                          tree *spec_p, bool *trivial_p, bool *deleted_p,
1520                          bool *constexpr_p, bool diag,
1521                          tree *inheriting_ctor, tree inherited_parms)
1522 {
1523   tree binfo, base_binfo, fnname;
1524   int i;
1525
1526   if (spec_p)
1527     *spec_p = (cxx_dialect >= cxx11 ? noexcept_true_spec : empty_except_spec);
1528
1529   if (deleted_p)
1530     {
1531       /* "The closure type associated with a lambda-expression has a deleted
1532          default constructor and a deleted copy assignment operator."
1533          This is diagnosed in maybe_explain_implicit_delete.  */
1534       if (LAMBDA_TYPE_P (ctype)
1535           && (sfk == sfk_constructor
1536               || sfk == sfk_copy_assignment))
1537         {
1538           *deleted_p = true;
1539           return;
1540         }
1541
1542       *deleted_p = false;
1543     }
1544
1545   bool ctor_p = false;
1546   bool assign_p = false;
1547   bool check_vdtor = false;
1548   switch (sfk)
1549     {
1550     case sfk_move_assignment:
1551     case sfk_copy_assignment:
1552       assign_p = true;
1553       fnname = assign_op_identifier;
1554       break;
1555
1556     case sfk_destructor:
1557       check_vdtor = true;
1558       /* The synthesized method will call base dtors, but check complete
1559          here to avoid having to deal with VTT.  */
1560       fnname = complete_dtor_identifier;
1561       break;
1562
1563     case sfk_constructor:
1564     case sfk_move_constructor:
1565     case sfk_copy_constructor:
1566     case sfk_inheriting_constructor:
1567       ctor_p = true;
1568       fnname = complete_ctor_identifier;
1569       break;
1570
1571     default:
1572       gcc_unreachable ();
1573     }
1574
1575   gcc_assert ((sfk == sfk_inheriting_constructor)
1576               == (inheriting_ctor && *inheriting_ctor != NULL_TREE));
1577
1578   /* If that user-written default constructor would satisfy the
1579      requirements of a constexpr constructor (7.1.5), the
1580      implicitly-defined default constructor is constexpr.
1581
1582      The implicitly-defined copy/move assignment operator is constexpr if
1583       - X is a literal type, and
1584       - the assignment operator selected to copy/move each direct base class
1585         subobject is a constexpr function, and
1586       - for each non-static data member of X that is of class type (or array
1587         thereof), the assignment operator selected to copy/move that
1588         member is a constexpr function.  */
1589   if (constexpr_p)
1590     *constexpr_p = ctor_p || (assign_p && cxx_dialect >= cxx14);
1591
1592   bool move_p = false;
1593   bool copy_arg_p = false;
1594   switch (sfk)
1595     {
1596     case sfk_constructor:
1597     case sfk_destructor:
1598     case sfk_inheriting_constructor:
1599       break;
1600
1601     case sfk_move_constructor:
1602     case sfk_move_assignment:
1603       move_p = true;
1604       /* FALLTHRU */
1605     case sfk_copy_constructor:
1606     case sfk_copy_assignment:
1607       copy_arg_p = true;
1608       break;
1609
1610     default:
1611       gcc_unreachable ();
1612     }
1613
1614   bool expected_trivial = type_has_trivial_fn (ctype, sfk);
1615   if (trivial_p)
1616     *trivial_p = expected_trivial;
1617
1618   /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1619      class versions and other properties of the type.  But a subobject
1620      class can be trivially copyable and yet have overload resolution
1621      choose a template constructor for initialization, depending on
1622      rvalueness and cv-quals.  And furthermore, a member in a base might
1623      be trivial but deleted or otherwise not callable.  So we can't exit
1624      early in C++0x.  The same considerations apply in C++98/03, but
1625      there the definition of triviality does not consider overload
1626      resolution, so a constructor can be trivial even if it would otherwise
1627      call a non-trivial constructor.  */
1628   if (expected_trivial
1629       && (!copy_arg_p || cxx_dialect < cxx11))
1630     {
1631       if (constexpr_p && sfk == sfk_constructor)
1632         {
1633           bool cx = trivial_default_constructor_is_constexpr (ctype);
1634           *constexpr_p = cx;
1635           if (diag && !cx && TREE_CODE (ctype) == UNION_TYPE)
1636             /* A trivial constructor doesn't have any NSDMI.  */
1637             inform (input_location, "defaulted default constructor does "
1638                     "not initialize any non-static data member");
1639         }
1640       if (!diag && cxx_dialect < cxx11)
1641         return;
1642     }
1643
1644   ++cp_unevaluated_operand;
1645   ++c_inhibit_evaluation_warnings;
1646   push_deferring_access_checks (dk_no_deferred);
1647
1648   tree scope = push_scope (ctype);
1649
1650   int flags = LOOKUP_NORMAL | LOOKUP_SPECULATIVE;
1651   if (sfk != sfk_inheriting_constructor)
1652     flags |= LOOKUP_DEFAULTED;
1653
1654   tsubst_flags_t complain = diag ? tf_warning_or_error : tf_none;
1655   if (diag && spec_p)
1656     /* We're in get_defaulted_eh_spec; we don't actually want any walking
1657        diagnostics, we just want complain set.  */
1658     diag = false;
1659   int quals = const_p ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED;
1660
1661   for (binfo = TYPE_BINFO (ctype), i = 0;
1662        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1663     {
1664       if (!assign_p && BINFO_VIRTUAL_P (base_binfo))
1665         /* We'll handle virtual bases below.  */
1666         continue;
1667
1668       tree fn = synthesized_method_base_walk (binfo, base_binfo, quals,
1669                                               copy_arg_p, move_p, ctor_p,
1670                                               inheriting_ctor,
1671                                               inherited_parms,
1672                                               fnname, flags, diag,
1673                                               spec_p, trivial_p,
1674                                               deleted_p, constexpr_p);
1675
1676       if (diag && assign_p && move_p
1677           && BINFO_VIRTUAL_P (base_binfo)
1678           && fn && TREE_CODE (fn) == FUNCTION_DECL
1679           && move_fn_p (fn) && !trivial_fn_p (fn)
1680           && vbase_has_user_provided_move_assign (BINFO_TYPE (base_binfo)))
1681         warning (OPT_Wvirtual_move_assign,
1682                  "defaulted move assignment for %qT calls a non-trivial "
1683                  "move assignment operator for virtual base %qT",
1684                  ctype, BINFO_TYPE (base_binfo));
1685
1686       if (check_vdtor && type_has_virtual_destructor (BINFO_TYPE (base_binfo)))
1687         {
1688           /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1689              to have a null fn (no class-specific op delete).  */
1690           fn = locate_fn_flags (ctype, ovl_op_identifier (false, DELETE_EXPR),
1691                                 ptr_type_node, flags, tf_none);
1692           if (fn && fn == error_mark_node)
1693             {
1694               if (complain & tf_error)
1695                 locate_fn_flags (ctype, ovl_op_identifier (false, DELETE_EXPR),
1696                                  ptr_type_node, flags, complain);
1697               if (deleted_p)
1698                 *deleted_p = true;
1699             }
1700           check_vdtor = false;
1701         }
1702     }
1703
1704   vec<tree, va_gc> *vbases = CLASSTYPE_VBASECLASSES (ctype);
1705   if (assign_p)
1706     /* Already examined vbases above.  */;
1707   else if (vec_safe_is_empty (vbases))
1708     /* No virtual bases to worry about.  */;
1709   else if (ABSTRACT_CLASS_TYPE_P (ctype) && cxx_dialect >= cxx14
1710            /* DR 1658 specifies that vbases of abstract classes are
1711               ignored for both ctors and dtors.  However, that breaks
1712               virtual dtor overriding when the ignored base has a
1713               throwing destructor.  So, ignore that piece of 1658.  A
1714               defect has been filed (no number yet).  */
1715            && sfk != sfk_destructor)
1716     /* Vbase cdtors are not relevant.  */;
1717   else
1718     {
1719       if (constexpr_p)
1720         *constexpr_p = false;
1721
1722       FOR_EACH_VEC_ELT (*vbases, i, base_binfo)
1723         synthesized_method_base_walk (binfo, base_binfo, quals,
1724                                       copy_arg_p, move_p, ctor_p,
1725                                       inheriting_ctor, inherited_parms,
1726                                       fnname, flags, diag,
1727                                       spec_p, trivial_p,
1728                                       deleted_p, constexpr_p);
1729     }
1730
1731   /* Now handle the non-static data members.  */
1732   walk_field_subobs (TYPE_FIELDS (ctype), fnname, sfk, quals,
1733                      copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1734                      deleted_p, constexpr_p,
1735                      diag, flags, complain, /*dtor_from_ctor*/false);
1736   if (ctor_p)
1737     walk_field_subobs (TYPE_FIELDS (ctype), complete_dtor_identifier,
1738                        sfk_destructor, TYPE_UNQUALIFIED, false,
1739                        false, false, NULL, NULL,
1740                        deleted_p, NULL,
1741                        false, flags, complain, /*dtor_from_ctor*/true);
1742
1743   pop_scope (scope);
1744
1745   pop_deferring_access_checks ();
1746   --cp_unevaluated_operand;
1747   --c_inhibit_evaluation_warnings;
1748 }
1749
1750 /* DECL is a defaulted function whose exception specification is now
1751    needed.  Return what it should be.  */
1752
1753 tree
1754 get_defaulted_eh_spec (tree decl, tsubst_flags_t complain)
1755 {
1756   if (DECL_CLONED_FUNCTION_P (decl))
1757     decl = DECL_CLONED_FUNCTION (decl);
1758   special_function_kind sfk = special_function_p (decl);
1759   tree ctype = DECL_CONTEXT (decl);
1760   tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
1761   tree parm_type = TREE_VALUE (parms);
1762   bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1763   tree spec = empty_except_spec;
1764   bool diag = !DECL_DELETED_FN (decl) && (complain & tf_error);
1765   tree inh = DECL_INHERITED_CTOR (decl);
1766   synthesized_method_walk (ctype, sfk, const_p, &spec, NULL, NULL,
1767                            NULL, diag, &inh, parms);
1768   return spec;
1769 }
1770
1771 /* DECL is a deleted function.  If it's implicitly deleted, explain why and
1772    return true; else return false.  */
1773
1774 bool
1775 maybe_explain_implicit_delete (tree decl)
1776 {
1777   /* If decl is a clone, get the primary variant.  */
1778   decl = DECL_ORIGIN (decl);
1779   gcc_assert (DECL_DELETED_FN (decl));
1780   if (DECL_DEFAULTED_FN (decl))
1781     {
1782       /* Not marked GTY; it doesn't need to be GC'd or written to PCH.  */
1783       static hash_set<tree> *explained;
1784
1785       special_function_kind sfk;
1786       location_t loc;
1787       bool informed;
1788       tree ctype;
1789
1790       if (!explained)
1791         explained = new hash_set<tree>;
1792       if (explained->add (decl))
1793         return true;
1794
1795       sfk = special_function_p (decl);
1796       ctype = DECL_CONTEXT (decl);
1797       loc = input_location;
1798       input_location = DECL_SOURCE_LOCATION (decl);
1799
1800       informed = false;
1801       if (LAMBDA_TYPE_P (ctype))
1802         {
1803           informed = true;
1804           if (sfk == sfk_constructor)
1805             inform (DECL_SOURCE_LOCATION (decl),
1806                     "a lambda closure type has a deleted default constructor");
1807           else if (sfk == sfk_copy_assignment)
1808             inform (DECL_SOURCE_LOCATION (decl),
1809                     "a lambda closure type has a deleted copy assignment operator");
1810           else
1811             informed = false;
1812         }
1813       else if (DECL_ARTIFICIAL (decl)
1814                && (sfk == sfk_copy_assignment || sfk == sfk_copy_constructor)
1815                && classtype_has_move_assign_or_move_ctor_p (ctype, true))
1816         {
1817           inform (DECL_SOURCE_LOCATION (decl),
1818                   "%q#D is implicitly declared as deleted because %qT "
1819                   "declares a move constructor or move assignment operator",
1820                   decl, ctype);
1821           informed = true;
1822         }
1823       else if (sfk == sfk_inheriting_constructor)
1824         {
1825           tree binfo = inherited_ctor_binfo (decl);
1826           if (TREE_CODE (binfo) != TREE_BINFO)
1827             {
1828               inform (DECL_SOURCE_LOCATION (decl),
1829                       "%q#D inherits from multiple base subobjects",
1830                       decl);
1831               informed = true;
1832             }
1833         }
1834       if (!informed)
1835         {
1836           tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
1837           tree parm_type = TREE_VALUE (parms);
1838           bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1839           tree raises = NULL_TREE;
1840           bool deleted_p = false;
1841           tree scope = push_scope (ctype);
1842           tree inh = DECL_INHERITED_CTOR (decl);
1843
1844           synthesized_method_walk (ctype, sfk, const_p,
1845                                    &raises, NULL, &deleted_p, NULL, false,
1846                                    &inh, parms);
1847           if (deleted_p)
1848             {
1849               inform (DECL_SOURCE_LOCATION (decl),
1850                       "%q#D is implicitly deleted because the default "
1851                       "definition would be ill-formed:", decl);
1852               synthesized_method_walk (ctype, sfk, const_p,
1853                                        NULL, NULL, NULL, NULL, true,
1854                                        &inh, parms);
1855             }
1856           else if (!comp_except_specs
1857                    (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
1858                     raises, ce_normal))
1859             inform (DECL_SOURCE_LOCATION (decl), "%q#F is implicitly "
1860                     "deleted because its exception-specification does not "
1861                     "match the implicit exception-specification %qX",
1862                     decl, raises);
1863           else if (flag_checking)
1864             gcc_unreachable ();
1865
1866           pop_scope (scope);
1867         }
1868
1869       input_location = loc;
1870       return true;
1871     }
1872   return false;
1873 }
1874
1875 /* DECL is a defaulted function which was declared constexpr.  Explain why
1876    it can't be constexpr.  */
1877
1878 void
1879 explain_implicit_non_constexpr (tree decl)
1880 {
1881   tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1882   bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1883   tree inh = DECL_INHERITED_CTOR (decl);
1884   bool dummy;
1885   synthesized_method_walk (DECL_CLASS_CONTEXT (decl),
1886                            special_function_p (decl), const_p,
1887                            NULL, NULL, NULL, &dummy, true,
1888                            &inh,
1889                            FUNCTION_FIRST_USER_PARMTYPE (decl));
1890 }
1891
1892 /* DECL is an instantiation of an inheriting constructor template.  Deduce
1893    the correct exception-specification and deletedness for this particular
1894    specialization.  */
1895
1896 void
1897 deduce_inheriting_ctor (tree decl)
1898 {
1899   decl = DECL_ORIGIN (decl);
1900   gcc_assert (DECL_INHERITED_CTOR (decl));
1901   tree spec;
1902   bool trivial, constexpr_, deleted;
1903   tree inh = DECL_INHERITED_CTOR (decl);
1904   synthesized_method_walk (DECL_CONTEXT (decl), sfk_inheriting_constructor,
1905                            false, &spec, &trivial, &deleted, &constexpr_,
1906                            /*diag*/false,
1907                            &inh,
1908                            FUNCTION_FIRST_USER_PARMTYPE (decl));
1909   if (TREE_CODE (inherited_ctor_binfo (decl)) != TREE_BINFO)
1910     /* Inherited the same constructor from different base subobjects.  */
1911     deleted = true;
1912   DECL_DELETED_FN (decl) = deleted;
1913   TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl), spec);
1914   SET_DECL_INHERITED_CTOR (decl, inh);
1915
1916   tree clone;
1917   FOR_EACH_CLONE (clone, decl)
1918     {
1919       DECL_DELETED_FN (clone) = deleted;
1920       TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone), spec);
1921       SET_DECL_INHERITED_CTOR (clone, inh);
1922     }
1923 }
1924
1925 /* Implicitly declare the special function indicated by KIND, as a
1926    member of TYPE.  For copy constructors and assignment operators,
1927    CONST_P indicates whether these functions should take a const
1928    reference argument or a non-const reference.  Returns the
1929    FUNCTION_DECL for the implicitly declared function.  */
1930
1931 tree
1932 implicitly_declare_fn (special_function_kind kind, tree type,
1933                        bool const_p, tree inherited_ctor,
1934                        tree inherited_parms)
1935 {
1936   tree fn;
1937   tree parameter_types = void_list_node;
1938   tree return_type;
1939   tree fn_type;
1940   tree raises = empty_except_spec;
1941   tree rhs_parm_type = NULL_TREE;
1942   tree this_parm;
1943   tree name;
1944   HOST_WIDE_INT saved_processing_template_decl;
1945   bool deleted_p;
1946   bool constexpr_p;
1947
1948   /* Because we create declarations for implicitly declared functions
1949      lazily, we may be creating the declaration for a member of TYPE
1950      while in some completely different context.  However, TYPE will
1951      never be a dependent class (because we never want to do lookups
1952      for implicitly defined functions in a dependent class).
1953      Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1954      because we only create clones for constructors and destructors
1955      when not in a template.  */
1956   gcc_assert (!dependent_type_p (type));
1957   saved_processing_template_decl = processing_template_decl;
1958   processing_template_decl = 0;
1959
1960   type = TYPE_MAIN_VARIANT (type);
1961
1962   if (targetm.cxx.cdtor_returns_this ())
1963     {
1964       if (kind == sfk_destructor)
1965         /* See comment in check_special_function_return_type.  */
1966         return_type = build_pointer_type (void_type_node);
1967       else
1968         return_type = build_pointer_type (type);
1969     }
1970   else
1971     return_type = void_type_node;
1972
1973   switch (kind)
1974     {
1975     case sfk_destructor:
1976       /* Destructor.  */
1977       name = dtor_identifier;
1978       break;
1979
1980     case sfk_constructor:
1981       /* Default constructor.  */
1982       name = ctor_identifier;
1983       break;
1984
1985     case sfk_copy_constructor:
1986     case sfk_copy_assignment:
1987     case sfk_move_constructor:
1988     case sfk_move_assignment:
1989     case sfk_inheriting_constructor:
1990     {
1991       if (kind == sfk_copy_assignment
1992           || kind == sfk_move_assignment)
1993         {
1994           return_type = build_reference_type (type);
1995           name = assign_op_identifier;
1996         }
1997       else
1998         name = ctor_identifier;
1999
2000       if (kind == sfk_inheriting_constructor)
2001         parameter_types = inherited_parms;
2002       else
2003         {
2004           if (const_p)
2005             rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
2006           else
2007             rhs_parm_type = type;
2008           bool move_p = (kind == sfk_move_assignment
2009                          || kind == sfk_move_constructor);
2010           rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
2011
2012           parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
2013         }
2014       break;
2015     }
2016     default:
2017       gcc_unreachable ();
2018     }
2019
2020   bool trivial_p = false;
2021
2022   if (inherited_ctor)
2023     {
2024       /* For an inheriting constructor, just copy these flags from the
2025          inherited constructor until deduce_inheriting_ctor.  */
2026       raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (inherited_ctor));
2027       deleted_p = DECL_DELETED_FN (inherited_ctor);
2028       constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
2029     }
2030   else if (cxx_dialect >= cxx11)
2031     {
2032       raises = noexcept_deferred_spec;
2033       synthesized_method_walk (type, kind, const_p, NULL, &trivial_p,
2034                                &deleted_p, &constexpr_p, false,
2035                                &inherited_ctor, inherited_parms);
2036     }
2037   else
2038     synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
2039                              &deleted_p, &constexpr_p, false,
2040                              &inherited_ctor, inherited_parms);
2041   /* Don't bother marking a deleted constructor as constexpr.  */
2042   if (deleted_p)
2043     constexpr_p = false;
2044   /* A trivial copy/move constructor is also a constexpr constructor,
2045      unless the class has virtual bases (7.1.5p4).  */
2046   else if (trivial_p && cxx_dialect >= cxx11
2047            && (kind == sfk_copy_constructor
2048                || kind == sfk_move_constructor)
2049            && !CLASSTYPE_VBASECLASSES (type))
2050     gcc_assert (constexpr_p);
2051
2052   if (!trivial_p && type_has_trivial_fn (type, kind))
2053     type_set_nontrivial_flag (type, kind);
2054
2055   /* Create the function.  */
2056   fn_type = build_method_type_directly (type, return_type, parameter_types);
2057   if (raises)
2058     fn_type = build_exception_variant (fn_type, raises);
2059   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
2060   if (kind != sfk_inheriting_constructor)
2061     DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
2062
2063   if (!IDENTIFIER_CDTOR_P (name))
2064     /* Assignment operator.  */
2065     DECL_OVERLOADED_OPERATOR_CODE_RAW (fn) = OVL_OP_NOP_EXPR;
2066   else if (IDENTIFIER_CTOR_P (name))
2067     DECL_CXX_CONSTRUCTOR_P (fn) = true;
2068   else
2069     DECL_CXX_DESTRUCTOR_P (fn) = true;
2070
2071   SET_DECL_ALIGN (fn, MINIMUM_METHOD_BOUNDARY);
2072
2073   /* Create the explicit arguments.  */
2074   if (rhs_parm_type)
2075     {
2076       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
2077          want its type to be included in the mangled function
2078          name.  */
2079       tree decl = cp_build_parm_decl (fn, NULL_TREE, rhs_parm_type);
2080       TREE_READONLY (decl) = 1;
2081       retrofit_lang_decl (decl);
2082       DECL_PARM_INDEX (decl) = DECL_PARM_LEVEL (decl) = 1;
2083       DECL_ARGUMENTS (fn) = decl;
2084     }
2085   else if (kind == sfk_inheriting_constructor)
2086     {
2087       tree *p = &DECL_ARGUMENTS (fn);
2088       int index = 1;
2089       for (tree parm = inherited_parms; parm && parm != void_list_node;
2090            parm = TREE_CHAIN (parm))
2091         {
2092           *p = cp_build_parm_decl (fn, NULL_TREE, TREE_VALUE (parm));
2093           retrofit_lang_decl (*p);
2094           DECL_PARM_LEVEL (*p) = 1;
2095           DECL_PARM_INDEX (*p) = index++;
2096           p = &DECL_CHAIN (*p);
2097         }
2098       SET_DECL_INHERITED_CTOR (fn, inherited_ctor);
2099       DECL_NONCONVERTING_P (fn) = DECL_NONCONVERTING_P (inherited_ctor);
2100       /* A constructor so declared has the same access as the corresponding
2101          constructor in X.  */
2102       TREE_PRIVATE (fn) = TREE_PRIVATE (inherited_ctor);
2103       TREE_PROTECTED (fn) = TREE_PROTECTED (inherited_ctor);
2104       /* Copy constexpr from the inherited constructor even if the
2105          inheriting constructor doesn't satisfy the requirements.  */
2106       constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
2107     }
2108   /* Add the "this" parameter.  */
2109   this_parm = build_this_parm (fn, fn_type, TYPE_UNQUALIFIED);
2110   DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
2111   DECL_ARGUMENTS (fn) = this_parm;
2112
2113   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
2114   DECL_IN_AGGR_P (fn) = 1;
2115   DECL_ARTIFICIAL (fn) = 1;
2116   DECL_DEFAULTED_FN (fn) = 1;
2117   if (cxx_dialect >= cxx11)
2118     {
2119       DECL_DELETED_FN (fn) = deleted_p;
2120       DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
2121     }
2122   DECL_EXTERNAL (fn) = true;
2123   DECL_NOT_REALLY_EXTERN (fn) = 1;
2124   DECL_DECLARED_INLINE_P (fn) = 1;
2125   set_linkage_according_to_type (type, fn);
2126   if (TREE_PUBLIC (fn))
2127     DECL_COMDAT (fn) = 1;
2128   rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
2129   gcc_assert (!TREE_USED (fn));
2130
2131   /* Propagate constraints from the inherited constructor. */
2132   if (flag_concepts && inherited_ctor)
2133     if (tree orig_ci = get_constraints (inherited_ctor))
2134       {
2135         tree new_ci = copy_node (orig_ci);
2136         set_constraints (fn, new_ci);
2137       }
2138
2139   /* Restore PROCESSING_TEMPLATE_DECL.  */
2140   processing_template_decl = saved_processing_template_decl;
2141
2142   if (inherited_ctor && TREE_CODE (inherited_ctor) == TEMPLATE_DECL)
2143     fn = add_inherited_template_parms (fn, inherited_ctor);
2144
2145   /* Warn about calling a non-trivial move assignment in a virtual base.  */
2146   if (kind == sfk_move_assignment && !deleted_p && !trivial_p
2147       && CLASSTYPE_VBASECLASSES (type))
2148     {
2149       location_t loc = input_location;
2150       input_location = DECL_SOURCE_LOCATION (fn);
2151       synthesized_method_walk (type, kind, const_p,
2152                                NULL, NULL, NULL, NULL, true,
2153                                NULL, NULL_TREE);
2154       input_location = loc;
2155     }
2156
2157   return fn;
2158 }
2159
2160 /* Gives any errors about defaulted functions which need to be deferred
2161    until the containing class is complete.  */
2162
2163 void
2164 defaulted_late_check (tree fn)
2165 {
2166   /* Complain about invalid signature for defaulted fn.  */
2167   tree ctx = DECL_CONTEXT (fn);
2168   special_function_kind kind = special_function_p (fn);
2169   bool fn_const_p = (copy_fn_p (fn) == 2);
2170   tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p,
2171                                             NULL, NULL);
2172   tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
2173
2174   if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
2175                     TREE_TYPE (TREE_TYPE (implicit_fn)))
2176       || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2177                      TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
2178     {
2179       error ("defaulted declaration %q+D does not match the "
2180              "expected signature", fn);
2181       inform (DECL_SOURCE_LOCATION (fn),
2182               "expected signature: %qD", implicit_fn);
2183       return;
2184     }
2185
2186   if (DECL_DELETED_FN (implicit_fn))
2187     {
2188       DECL_DELETED_FN (fn) = 1;
2189       return;
2190     }
2191
2192   /* 8.4.2/2: An explicitly-defaulted function (...) may have an explicit
2193      exception-specification only if it is compatible (15.4) with the
2194      exception-specification on the implicit declaration.  If a function
2195      is explicitly defaulted on its first declaration, (...) it is
2196      implicitly considered to have the same exception-specification as if
2197      it had been implicitly declared.  */
2198   maybe_instantiate_noexcept (fn);
2199   tree fn_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
2200   if (!fn_spec)
2201     {
2202       if (DECL_DEFAULTED_IN_CLASS_P (fn))
2203         TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
2204     }
2205   else if (UNEVALUATED_NOEXCEPT_SPEC_P (fn_spec))
2206     /* Equivalent to the implicit spec.  */;
2207   else if (DECL_DEFAULTED_IN_CLASS_P (fn)
2208            && !CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
2209     /* We can't compare an explicit exception-specification on a
2210        constructor defaulted in the class body to the implicit
2211        exception-specification until after we've parsed any NSDMI; see
2212        after_nsdmi_defaulted_late_checks.  */;
2213   else
2214     {
2215       tree eh_spec = get_defaulted_eh_spec (fn);
2216       if (!comp_except_specs (fn_spec, eh_spec, ce_normal))
2217         {
2218           if (DECL_DEFAULTED_IN_CLASS_P (fn))
2219             DECL_DELETED_FN (fn) = true;
2220           else
2221             error ("function %q+D defaulted on its redeclaration "
2222                    "with an exception-specification that differs from "
2223                    "the implicit exception-specification %qX", fn, eh_spec);
2224         }
2225     }
2226
2227   if (DECL_DEFAULTED_IN_CLASS_P (fn)
2228       && DECL_DECLARED_CONSTEXPR_P (implicit_fn))
2229     {
2230       /* Hmm...should we do this for out-of-class too? Should it be OK to
2231          add constexpr later like inline, rather than requiring
2232          declarations to match?  */
2233       DECL_DECLARED_CONSTEXPR_P (fn) = true;
2234       if (kind == sfk_constructor)
2235         TYPE_HAS_CONSTEXPR_CTOR (ctx) = true;
2236     }
2237
2238   if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
2239       && DECL_DECLARED_CONSTEXPR_P (fn))
2240     {
2241       if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
2242         {
2243           error ("explicitly defaulted function %q+D cannot be declared "
2244                  "as %<constexpr%> because the implicit declaration is not "
2245                  "%<constexpr%>:", fn);
2246           explain_implicit_non_constexpr (fn);
2247         }
2248       DECL_DECLARED_CONSTEXPR_P (fn) = false;
2249     }
2250 }
2251
2252 /* OK, we've parsed the NSDMI for class T, now we can check any explicit
2253    exception-specifications on functions defaulted in the class body.  */
2254
2255 void
2256 after_nsdmi_defaulted_late_checks (tree t)
2257 {
2258   if (uses_template_parms (t))
2259     return;
2260   if (t == error_mark_node)
2261     return;
2262   for (tree fn = TYPE_FIELDS (t); fn; fn = DECL_CHAIN (fn))
2263     if (!DECL_ARTIFICIAL (fn)
2264         && DECL_DECLARES_FUNCTION_P (fn)
2265         && DECL_DEFAULTED_IN_CLASS_P (fn))
2266       {
2267         tree fn_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
2268         if (UNEVALUATED_NOEXCEPT_SPEC_P (fn_spec))
2269           continue;
2270
2271         tree eh_spec = get_defaulted_eh_spec (fn);
2272         if (!comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)),
2273                                 eh_spec, ce_normal))
2274           DECL_DELETED_FN (fn) = true;
2275       }
2276 }
2277
2278 /* Returns true iff FN can be explicitly defaulted, and gives any
2279    errors if defaulting FN is ill-formed.  */
2280
2281 bool
2282 defaultable_fn_check (tree fn)
2283 {
2284   special_function_kind kind = sfk_none;
2285
2286   if (template_parm_scope_p ())
2287     {
2288       error ("a template cannot be defaulted");
2289       return false;
2290     }
2291
2292   if (DECL_CONSTRUCTOR_P (fn))
2293     {
2294       if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
2295         kind = sfk_constructor;
2296       else if (copy_fn_p (fn) > 0
2297                && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
2298                    == void_list_node))
2299         kind = sfk_copy_constructor;
2300       else if (move_fn_p (fn))
2301         kind = sfk_move_constructor;
2302     }
2303   else if (DECL_DESTRUCTOR_P (fn))
2304     kind = sfk_destructor;
2305   else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
2306            && DECL_OVERLOADED_OPERATOR_IS (fn, NOP_EXPR))
2307     {
2308       if (copy_fn_p (fn))
2309         kind = sfk_copy_assignment;
2310       else if (move_fn_p (fn))
2311         kind = sfk_move_assignment;
2312     }
2313
2314   if (kind == sfk_none)
2315     {
2316       error ("%qD cannot be defaulted", fn);
2317       return false;
2318     }
2319   else
2320     {
2321       for (tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
2322            t && t != void_list_node; t = TREE_CHAIN (t))
2323         if (TREE_PURPOSE (t))
2324           {
2325             error ("defaulted function %q+D with default argument", fn);
2326             break;
2327           }
2328
2329       /* Avoid do_warn_unused_parameter warnings.  */
2330       for (tree p = FUNCTION_FIRST_USER_PARM (fn); p; p = DECL_CHAIN (p))
2331         if (DECL_NAME (p))
2332           TREE_NO_WARNING (p) = 1;
2333
2334       if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
2335         /* Defer checking.  */;
2336       else if (!processing_template_decl)
2337         defaulted_late_check (fn);
2338
2339       return true;
2340     }
2341 }
2342
2343 /* Add an implicit declaration to TYPE for the kind of function
2344    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
2345    declaration.  */
2346
2347 tree
2348 lazily_declare_fn (special_function_kind sfk, tree type)
2349 {
2350   tree fn;
2351   /* Whether or not the argument has a const reference type.  */
2352   bool const_p = false;
2353
2354   type = TYPE_MAIN_VARIANT (type);
2355
2356   switch (sfk)
2357     {
2358     case sfk_constructor:
2359       CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
2360       break;
2361     case sfk_copy_constructor:
2362       const_p = TYPE_HAS_CONST_COPY_CTOR (type);
2363       CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
2364       break;
2365     case sfk_move_constructor:
2366       CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
2367       break;
2368     case sfk_copy_assignment:
2369       const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
2370       CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
2371       break;
2372     case sfk_move_assignment:
2373       CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
2374       break;
2375     case sfk_destructor:
2376       CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
2377       break;
2378     default:
2379       gcc_unreachable ();
2380     }
2381
2382   /* Declare the function.  */
2383   fn = implicitly_declare_fn (sfk, type, const_p, NULL, NULL);
2384
2385   /* [class.copy]/8 If the class definition declares a move constructor or
2386      move assignment operator, the implicitly declared copy constructor is
2387      defined as deleted.... */
2388   if ((sfk == sfk_copy_assignment || sfk == sfk_copy_constructor)
2389       && classtype_has_move_assign_or_move_ctor_p (type, true))
2390     DECL_DELETED_FN (fn) = true;
2391
2392   /* Destructors and assignment operators may be virtual.  */
2393   if (sfk == sfk_destructor
2394       || sfk == sfk_move_assignment
2395       || sfk == sfk_copy_assignment)
2396     check_for_override (fn, type);
2397
2398   /* Add it to the class  */
2399   bool added = add_method (type, fn, false);
2400   gcc_assert (added);
2401
2402   /* Add it to TYPE_FIELDS.  */
2403   if (sfk == sfk_destructor
2404       && DECL_VIRTUAL_P (fn))
2405     /* The ABI requires that a virtual destructor go at the end of the
2406        vtable.  */
2407     TYPE_FIELDS (type) = chainon (TYPE_FIELDS (type), fn);
2408   else
2409     {
2410       DECL_CHAIN (fn) = TYPE_FIELDS (type);
2411       TYPE_FIELDS (type) = fn;
2412     }
2413   /* Propagate TYPE_FIELDS.  */
2414   fixup_type_variants (type);
2415
2416   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
2417   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
2418       || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
2419     /* Create appropriate clones.  */
2420     clone_function_decl (fn, /*update_methods=*/true);
2421
2422   return fn;
2423 }
2424
2425 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
2426    as there are artificial parms in FN.  */
2427
2428 tree
2429 skip_artificial_parms_for (const_tree fn, tree list)
2430 {
2431   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
2432     list = TREE_CHAIN (list);
2433   else
2434     return list;
2435
2436   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
2437     list = TREE_CHAIN (list);
2438   if (DECL_HAS_VTT_PARM_P (fn))
2439     list = TREE_CHAIN (list);
2440   return list;
2441 }
2442
2443 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
2444    artificial parms in FN.  */
2445
2446 int
2447 num_artificial_parms_for (const_tree fn)
2448 {
2449   int count = 0;
2450
2451   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
2452     count++;
2453   else
2454     return 0;
2455
2456   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
2457     count++;
2458   if (DECL_HAS_VTT_PARM_P (fn))
2459     count++;
2460   return count;
2461 }
2462
2463
2464 #include "gt-cp-method.h"