gcc/cp/method.cc

   1 /* Handle the hair of processing (but not expanding) inline functions.
   2    Also manage function and variable name overloading.
   3    Copyright (C) 1987-2024 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 "intl.h"
  34 #include "common/common-target.h"
  35
  36 static void do_build_copy_assign (tree);
  37 static void do_build_copy_constructor (tree);
  38 static tree make_alias_for_thunk (tree);
  39
  40 /* Called once to initialize method.cc.  */
  41
  42 void
  43 init_method (void)
  44 {
  45   init_mangle ();
  46 }
  47 \f
  48 /* Return a this or result adjusting thunk to FUNCTION.  THIS_ADJUSTING
  49    indicates whether it is a this or result adjusting thunk.
  50    FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
  51    (see thunk_adjust).  VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
  52    never is.  VIRTUAL_OFFSET is the /index/ into the vtable for this
  53    adjusting thunks, we scale it to a byte offset. For covariant
  54    thunks VIRTUAL_OFFSET is the virtual binfo.  You must post process
  55    the returned thunk with finish_thunk.  */
  56
  57 tree
  58 make_thunk (tree function, bool this_adjusting,
  59             tree fixed_offset, tree virtual_offset)
  60 {
  61   HOST_WIDE_INT d;
  62   tree thunk;
  63
  64   gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
  65   /* We can have this thunks to covariant thunks, but not vice versa.  */
  66   gcc_assert (!DECL_THIS_THUNK_P (function));
  67   gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
  68
  69   /* Scale the VIRTUAL_OFFSET to be in terms of bytes.  */
  70   if (this_adjusting && virtual_offset)
  71     virtual_offset
  72       = size_binop (MULT_EXPR,
  73                     virtual_offset,
  74                     convert (ssizetype,
  75                              TYPE_SIZE_UNIT (vtable_entry_type)));
  76
  77   d = tree_to_shwi (fixed_offset);
  78
  79   /* See if we already have the thunk in question.  For this_adjusting
  80      thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
  81      will be a BINFO.  */
  82   for (thunk = DECL_THUNKS (function); thunk; thunk = DECL_CHAIN (thunk))
  83     if (DECL_THIS_THUNK_P (thunk) == this_adjusting
  84         && THUNK_FIXED_OFFSET (thunk) == d
  85         && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
  86         && (!virtual_offset
  87             || (this_adjusting
  88                 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
  89                                       virtual_offset)
  90                 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
  91       return thunk;
  92
  93   /* All thunks must be created before FUNCTION is actually emitted;
  94      the ABI requires that all thunks be emitted together with the
  95      function to which they transfer control.  */
  96   gcc_assert (!TREE_ASM_WRITTEN (function));
  97   /* Likewise, we can only be adding thunks to a function declared in
  98      the class currently being laid out.  */
  99   gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
 100               && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
 101
 102   thunk = build_decl (DECL_SOURCE_LOCATION (function),
 103                       FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
 104   DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
 105   cxx_dup_lang_specific_decl (thunk);
 106   DECL_VIRTUAL_P (thunk) = true;
 107   SET_DECL_THUNKS (thunk, NULL_TREE);
 108
 109   DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
 110   TREE_READONLY (thunk) = TREE_READONLY (function);
 111   TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
 112   TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
 113   SET_DECL_THUNK_P (thunk, this_adjusting);
 114   THUNK_TARGET (thunk) = function;
 115   THUNK_FIXED_OFFSET (thunk) = d;
 116   THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
 117   THUNK_ALIAS (thunk) = NULL_TREE;
 118
 119   DECL_INTERFACE_KNOWN (thunk) = 1;
 120   DECL_NOT_REALLY_EXTERN (thunk) = 1;
 121   DECL_COMDAT (thunk) = DECL_COMDAT (function);
 122   DECL_SAVED_AUTO_RETURN_TYPE (thunk) = NULL;
 123   /* The thunk itself is not a constructor or destructor, even if
 124      the thing it is thunking to is.  */
 125   DECL_CXX_DESTRUCTOR_P (thunk) = 0;
 126   DECL_CXX_CONSTRUCTOR_P (thunk) = 0;
 127   DECL_EXTERNAL (thunk) = 1;
 128   DECL_ARTIFICIAL (thunk) = 1;
 129   /* The THUNK is not a pending inline, even if the FUNCTION is.  */
 130   DECL_PENDING_INLINE_P (thunk) = 0;
 131   DECL_DECLARED_INLINE_P (thunk) = 0;
 132   /* Nor is it a template instantiation.  */
 133   DECL_USE_TEMPLATE (thunk) = 0;
 134   DECL_TEMPLATE_INFO (thunk) = NULL;
 135
 136   /* Add it to the list of thunks associated with FUNCTION.  */
 137   DECL_CHAIN (thunk) = DECL_THUNKS (function);
 138   SET_DECL_THUNKS (function, thunk);
 139
 140   return thunk;
 141 }
 142
 143 /* Finish THUNK, a thunk decl.  */
 144
 145 void
 146 finish_thunk (tree thunk)
 147 {
 148   tree function, name;
 149   tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
 150   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
 151
 152   gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
 153   if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
 154     virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 155   function = THUNK_TARGET (thunk);
 156   name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
 157                        fixed_offset, virtual_offset, thunk);
 158
 159   /* We can end up with declarations of (logically) different
 160      covariant thunks, that do identical adjustments.  The two thunks
 161      will be adjusting between within different hierarchies, which
 162      happen to have the same layout.  We must nullify one of them to
 163      refer to the other.  */
 164   if (DECL_RESULT_THUNK_P (thunk))
 165     {
 166       tree cov_probe;
 167
 168       for (cov_probe = DECL_THUNKS (function);
 169            cov_probe; cov_probe = DECL_CHAIN (cov_probe))
 170         if (DECL_NAME (cov_probe) == name)
 171           {
 172             gcc_assert (!DECL_THUNKS (thunk));
 173             THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
 174                                    ? THUNK_ALIAS (cov_probe) : cov_probe);
 175             break;
 176           }
 177     }
 178
 179   DECL_NAME (thunk) = name;
 180   SET_DECL_ASSEMBLER_NAME (thunk, name);
 181 }
 182
 183 static GTY (()) int thunk_labelno;
 184
 185 /* Create a static alias to target.  */
 186
 187 tree
 188 make_alias_for (tree target, tree newid)
 189 {
 190   tree alias = build_decl (DECL_SOURCE_LOCATION (target),
 191                            TREE_CODE (target), newid, TREE_TYPE (target));
 192   DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (target);
 193   cxx_dup_lang_specific_decl (alias);
 194   DECL_CONTEXT (alias) = DECL_CONTEXT (target);
 195   TREE_READONLY (alias) = TREE_READONLY (target);
 196   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (target);
 197   TREE_PUBLIC (alias) = 0;
 198   DECL_INTERFACE_KNOWN (alias) = 1;
 199   if (DECL_LANG_SPECIFIC (alias))
 200     {
 201       DECL_NOT_REALLY_EXTERN (alias) = 1;
 202       DECL_USE_TEMPLATE (alias) = 0;
 203       DECL_TEMPLATE_INFO (alias) = NULL;
 204     }
 205   DECL_EXTERNAL (alias) = 0;
 206   DECL_ARTIFICIAL (alias) = 1;
 207   DECL_TEMPLATE_INSTANTIATED (alias) = 0;
 208   if (TREE_CODE (alias) == FUNCTION_DECL)
 209     {
 210       DECL_SAVED_AUTO_RETURN_TYPE (alias) = NULL;
 211       DECL_CXX_DESTRUCTOR_P (alias) = 0;
 212       DECL_CXX_CONSTRUCTOR_P (alias) = 0;
 213       DECL_PENDING_INLINE_P (alias) = 0;
 214       DECL_DECLARED_INLINE_P (alias) = 0;
 215       DECL_INITIAL (alias) = error_mark_node;
 216       DECL_ARGUMENTS (alias) = copy_list (DECL_ARGUMENTS (target));
 217     }
 218   else
 219     TREE_STATIC (alias) = 1;
 220   TREE_ADDRESSABLE (alias) = 1;
 221   TREE_USED (alias) = 1;
 222   SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
 223   return alias;
 224 }
 225
 226 static tree
 227 make_alias_for_thunk (tree function)
 228 {
 229   tree alias;
 230   char buf[256];
 231
 232   targetm.asm_out.generate_internal_label (buf, "LTHUNK", thunk_labelno);
 233   thunk_labelno++;
 234
 235   alias = make_alias_for (function, get_identifier (buf));
 236
 237   if (!flag_syntax_only)
 238     {
 239       struct cgraph_node *funcn, *aliasn;
 240       funcn = cgraph_node::get (function);
 241       gcc_checking_assert (funcn);
 242       aliasn = cgraph_node::create_same_body_alias (alias, function);
 243       DECL_ASSEMBLER_NAME (function);
 244       gcc_assert (aliasn != NULL);
 245     }
 246
 247   return alias;
 248 }
 249
 250 /* Emit the definition of a C++ multiple inheritance or covariant
 251    return vtable thunk.  If EMIT_P is nonzero, the thunk is emitted
 252    immediately.  */
 253
 254 void
 255 use_thunk (tree thunk_fndecl, bool emit_p)
 256 {
 257   tree a, t, function, alias;
 258   tree virtual_offset;
 259   HOST_WIDE_INT fixed_offset, virtual_value;
 260   bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
 261   struct cgraph_node *funcn, *thunk_node;
 262
 263   /* We should have called finish_thunk to give it a name.  */
 264   gcc_assert (DECL_NAME (thunk_fndecl));
 265
 266   /* We should never be using an alias, always refer to the
 267      aliased thunk.  */
 268   gcc_assert (!THUNK_ALIAS (thunk_fndecl));
 269
 270   if (TREE_ASM_WRITTEN (thunk_fndecl))
 271     return;
 272
 273   function = THUNK_TARGET (thunk_fndecl);
 274   if (DECL_RESULT (thunk_fndecl))
 275     /* We already turned this thunk into an ordinary function.
 276        There's no need to process this thunk again.  */
 277     return;
 278
 279   if (DECL_THUNK_P (function))
 280     /* The target is itself a thunk, process it now.  */
 281     use_thunk (function, emit_p);
 282
 283   /* Thunks are always addressable; they only appear in vtables.  */
 284   TREE_ADDRESSABLE (thunk_fndecl) = 1;
 285
 286   /* Figure out what function is being thunked to.  It's referenced in
 287      this translation unit.  */
 288   TREE_ADDRESSABLE (function) = 1;
 289   mark_used (function);
 290   if (!emit_p)
 291     return;
 292
 293   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
 294    alias = make_alias_for_thunk (function);
 295   else
 296    alias = function;
 297
 298   fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
 299   virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
 300
 301   if (virtual_offset)
 302     {
 303       if (!this_adjusting)
 304         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
 305       virtual_value = tree_to_shwi (virtual_offset);
 306       gcc_assert (virtual_value);
 307     }
 308   else
 309     virtual_value = 0;
 310
 311   /* And, if we need to emit the thunk, it's used.  */
 312   mark_used (thunk_fndecl);
 313   /* This thunk is actually defined.  */
 314   DECL_EXTERNAL (thunk_fndecl) = 0;
 315   /* The linkage of the function may have changed.  FIXME in linkage
 316      rewrite.  */
 317   gcc_assert (DECL_INTERFACE_KNOWN (function));
 318   TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
 319   DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
 320   DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
 321     = DECL_VISIBILITY_SPECIFIED (function);
 322   DECL_COMDAT (thunk_fndecl) = DECL_COMDAT (function);
 323   DECL_WEAK (thunk_fndecl) = DECL_WEAK (function);
 324
 325   if (flag_syntax_only)
 326     {
 327       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 328       return;
 329     }
 330
 331   push_to_top_level ();
 332
 333   if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
 334       && targetm_common.have_named_sections)
 335     {
 336       tree fn = function;
 337       struct symtab_node *symbol;
 338
 339       if ((symbol = symtab_node::get (function))
 340           && symbol->alias)
 341         {
 342           if (symbol->analyzed)
 343             fn = symtab_node::get (function)->ultimate_alias_target ()->decl;
 344           else
 345             fn = symtab_node::get (function)->alias_target;
 346         }
 347       resolve_unique_section (fn, 0, flag_function_sections);
 348
 349       if (DECL_SECTION_NAME (fn) != NULL && DECL_ONE_ONLY (fn))
 350         {
 351           resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
 352
 353           /* Output the thunk into the same section as function.  */
 354           set_decl_section_name (thunk_fndecl, fn);
 355           symtab_node::get (thunk_fndecl)->implicit_section
 356             = symtab_node::get (fn)->implicit_section;
 357         }
 358     }
 359
 360   /* Set up cloned argument trees for the thunk.  */
 361   t = NULL_TREE;
 362   for (a = DECL_ARGUMENTS (function); a; a = DECL_CHAIN (a))
 363     {
 364       tree x = copy_node (a);
 365       DECL_CHAIN (x) = t;
 366       DECL_CONTEXT (x) = thunk_fndecl;
 367       SET_DECL_RTL (x, NULL);
 368       DECL_HAS_VALUE_EXPR_P (x) = 0;
 369       TREE_ADDRESSABLE (x) = 0;
 370       t = x;
 371     }
 372   a = nreverse (t);
 373   DECL_ARGUMENTS (thunk_fndecl) = a;
 374   TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 375   funcn = cgraph_node::get (function);
 376   gcc_checking_assert (funcn);
 377   thunk_node = funcn->create_thunk (thunk_fndecl, function,
 378                                     this_adjusting, fixed_offset, virtual_value,
 379                                     0, virtual_offset, alias);
 380   if (DECL_ONE_ONLY (function))
 381     thunk_node->add_to_same_comdat_group (funcn);
 382
 383   pop_from_top_level ();
 384 }
 385 \f
 386 /* Code for synthesizing methods which have default semantics defined.  */
 387
 388 /* True iff CTYPE has a trivial SFK.  */
 389
 390 static bool
 391 type_has_trivial_fn (tree ctype, special_function_kind sfk)
 392 {
 393   switch (sfk)
 394     {
 395     case sfk_constructor:
 396       return !TYPE_HAS_COMPLEX_DFLT (ctype);
 397     case sfk_copy_constructor:
 398       return !TYPE_HAS_COMPLEX_COPY_CTOR (ctype);
 399     case sfk_move_constructor:
 400       return !TYPE_HAS_COMPLEX_MOVE_CTOR (ctype);
 401     case sfk_copy_assignment:
 402       return !TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype);
 403     case sfk_move_assignment:
 404       return !TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype);
 405     case sfk_destructor:
 406     case sfk_virtual_destructor:
 407       return !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype);
 408     case sfk_inheriting_constructor:
 409     case sfk_comparison:
 410       return false;
 411     default:
 412       gcc_unreachable ();
 413     }
 414 }
 415
 416 /* Note that CTYPE has a non-trivial SFK even though we previously thought
 417    it was trivial.  */
 418
 419 static void
 420 type_set_nontrivial_flag (tree ctype, special_function_kind sfk)
 421 {
 422   switch (sfk)
 423     {
 424     case sfk_constructor:
 425       TYPE_HAS_COMPLEX_DFLT (ctype) = true;
 426       return;
 427     case sfk_copy_constructor:
 428       TYPE_HAS_COMPLEX_COPY_CTOR (ctype) = true;
 429       return;
 430     case sfk_move_constructor:
 431       TYPE_HAS_COMPLEX_MOVE_CTOR (ctype) = true;
 432       return;
 433     case sfk_copy_assignment:
 434       TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype) = true;
 435       return;
 436     case sfk_move_assignment:
 437       TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype) = true;
 438       return;
 439     case sfk_destructor:
 440       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true;
 441       return;
 442     case sfk_inheriting_constructor:
 443     default:
 444       gcc_unreachable ();
 445     }
 446 }
 447
 448 /* True iff FN is a trivial defaulted member function ([cd]tor, op=).  */
 449
 450 bool
 451 trivial_fn_p (tree fn)
 452 {
 453   if (TREE_CODE (fn) == TEMPLATE_DECL)
 454     return false;
 455   if (!DECL_DEFAULTED_FN (fn))
 456     return false;
 457
 458   /* If fn is a clone, get the primary variant.  */
 459   if (tree prim = DECL_CLONED_FUNCTION (fn))
 460     fn = prim;
 461   return type_has_trivial_fn (DECL_CONTEXT (fn), special_function_p (fn));
 462 }
 463
 464 /* PARM is a PARM_DECL for a function which we want to forward to another
 465    function without changing its value category, a la std::forward.  */
 466
 467 tree
 468 forward_parm (tree parm)
 469 {
 470   tree exp = convert_from_reference (parm);
 471   tree type = TREE_TYPE (parm);
 472   if (DECL_PACK_P (parm))
 473     type = PACK_EXPANSION_PATTERN (type);
 474   if (!TYPE_REF_P (type))
 475     type = cp_build_reference_type (type, /*rval=*/true);
 476   warning_sentinel w (warn_useless_cast);
 477   exp = build_static_cast (input_location, type, exp,
 478                            tf_warning_or_error);
 479   if (DECL_PACK_P (parm))
 480     exp = make_pack_expansion (exp);
 481   return exp;
 482 }
 483
 484 /* Strip all inheriting constructors, if any, to return the original
 485    constructor from a (possibly indirect) base class.  */
 486
 487 tree
 488 strip_inheriting_ctors (tree dfn)
 489 {
 490   if (!flag_new_inheriting_ctors)
 491     return dfn;
 492   tree fn = dfn;
 493   while (tree inh = DECL_INHERITED_CTOR (fn))
 494     fn = OVL_FIRST (inh);
 495
 496   if (TREE_CODE (fn) == TEMPLATE_DECL
 497       && TREE_CODE (dfn) == FUNCTION_DECL)
 498     fn = DECL_TEMPLATE_RESULT (fn);
 499   return fn;
 500 }
 501
 502 /* Find the binfo for the base subobject of BINFO being initialized by
 503    inherited constructor FNDECL (a member of a direct base of BINFO).  */
 504
 505 static tree inherited_ctor_binfo (tree, tree);
 506 static tree
 507 inherited_ctor_binfo_1 (tree binfo, tree fndecl)
 508 {
 509   tree base = DECL_CONTEXT (fndecl);
 510   tree base_binfo;
 511   for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 512     if (BINFO_TYPE (base_binfo) == base)
 513       return inherited_ctor_binfo (base_binfo, fndecl);
 514
 515   gcc_unreachable();
 516 }
 517
 518 /* Find the binfo for the base subobject of BINFO being initialized by
 519    inheriting constructor FNDECL (a member of BINFO), or BINFO if FNDECL is not
 520    an inheriting constructor.  */
 521
 522 static tree
 523 inherited_ctor_binfo (tree binfo, tree fndecl)
 524 {
 525   tree inh = DECL_INHERITED_CTOR (fndecl);
 526   if (!inh)
 527     return binfo;
 528
 529   tree results = NULL_TREE;
 530   for (ovl_iterator iter (inh); iter; ++iter)
 531     {
 532       tree one = inherited_ctor_binfo_1 (binfo, *iter);
 533       if (!results)
 534         results = one;
 535       else if (one != results)
 536         results = tree_cons (NULL_TREE, one, results);
 537     }
 538   return results;
 539 }
 540
 541 /* Find the binfo for the base subobject being initialized by inheriting
 542    constructor FNDECL, or NULL_TREE if FNDECL is not an inheriting
 543    constructor.  */
 544
 545 tree
 546 inherited_ctor_binfo (tree fndecl)
 547 {
 548   if (!DECL_INHERITED_CTOR (fndecl))
 549     return NULL_TREE;
 550   tree binfo = TYPE_BINFO (DECL_CONTEXT (fndecl));
 551   return inherited_ctor_binfo (binfo, fndecl);
 552 }
 553
 554
 555 /* True if we should omit all user-declared parameters from a base
 556    construtor built from complete constructor FN.
 557    That's when the ctor is inherited from a virtual base.  */
 558
 559 bool
 560 base_ctor_omit_inherited_parms (tree comp_ctor)
 561 {
 562   gcc_checking_assert (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (comp_ctor));
 563
 564   if (!flag_new_inheriting_ctors)
 565     /* We only optimize away the parameters in the new model.  */
 566     return false;
 567
 568   if (!CLASSTYPE_VBASECLASSES (DECL_CONTEXT (comp_ctor)))
 569     return false;
 570
 571   if (FUNCTION_FIRST_USER_PARMTYPE (comp_ctor) == void_list_node)
 572     /* No user-declared parameters to omit.  */
 573     return false;
 574
 575   for (tree binfo = inherited_ctor_binfo (comp_ctor);
 576        binfo;
 577        binfo = BINFO_INHERITANCE_CHAIN (binfo))
 578     if (BINFO_VIRTUAL_P (binfo))
 579       return true;
 580
 581   return false;
 582 }
 583
 584
 585 /* True if we should omit all user-declared parameters from constructor FN,
 586    because it is a base clone of a ctor inherited from a virtual base.  */
 587
 588 bool
 589 ctor_omit_inherited_parms (tree fn)
 590 {
 591   gcc_checking_assert (TREE_CODE (fn) == FUNCTION_DECL);
 592
 593   if (!DECL_BASE_CONSTRUCTOR_P (fn))
 594     return false;
 595
 596   return base_ctor_omit_inherited_parms (DECL_CLONED_FUNCTION (fn));
 597 }
 598
 599 /* True iff constructor(s) INH inherited into BINFO initializes INIT_BINFO.
 600    This can be true for multiple virtual bases as well as one direct
 601    non-virtual base.  */
 602
 603 static bool
 604 binfo_inherited_from (tree binfo, tree init_binfo, tree inh)
 605 {
 606   /* inh is an OVERLOAD if we inherited the same constructor along
 607      multiple paths, check all of them.  */
 608   for (ovl_iterator iter (inh); iter; ++iter)
 609     {
 610       tree fn = *iter;
 611       tree base = DECL_CONTEXT (fn);
 612       tree base_binfo = NULL_TREE;
 613       for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 614         if (BINFO_TYPE (base_binfo) == base)
 615           break;
 616       if (base_binfo == init_binfo
 617           || (flag_new_inheriting_ctors
 618               && binfo_inherited_from (base_binfo, init_binfo,
 619                                        DECL_INHERITED_CTOR (fn))))
 620         return true;
 621     }
 622   return false;
 623 }
 624
 625 /* Subroutine of do_build_copy_constructor: Add a mem-initializer for BINFO
 626    given the parameter or parameters PARM, possibly inherited constructor
 627    base INH, or move flag MOVE_P.  */
 628
 629 static tree
 630 add_one_base_init (tree binfo, tree parm, bool move_p, tree inh,
 631                    tree member_init_list)
 632 {
 633   tree init;
 634   if (inh)
 635     {
 636       /* An inheriting constructor only has a mem-initializer for
 637          the base it inherits from.  */
 638       if (!binfo_inherited_from (TYPE_BINFO (current_class_type), binfo, inh))
 639         return member_init_list;
 640
 641       tree *p = &init;
 642       init = NULL_TREE;
 643       for (; parm; parm = DECL_CHAIN (parm))
 644         {
 645           tree exp = forward_parm (parm);
 646           *p = build_tree_list (NULL_TREE, exp);
 647           p = &TREE_CHAIN (*p);
 648         }
 649     }
 650   else
 651     {
 652       init = build_base_path (PLUS_EXPR, parm, binfo, 1,
 653                               tf_warning_or_error);
 654       if (move_p)
 655         init = move (init);
 656       init = build_tree_list (NULL_TREE, init);
 657     }
 658   return tree_cons (binfo, init, member_init_list);
 659 }
 660
 661 /* Generate code for default X(X&) or X(X&&) constructor or an inheriting
 662    constructor.  */
 663
 664 static void
 665 do_build_copy_constructor (tree fndecl)
 666 {
 667   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
 668   bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
 669   bool trivial = trivial_fn_p (fndecl);
 670   tree inh = DECL_INHERITED_CTOR (fndecl);
 671
 672   if (!inh)
 673     parm = convert_from_reference (parm);
 674
 675   if (trivial)
 676     {
 677       if (is_empty_class (current_class_type))
 678         /* Don't copy the padding byte; it might not have been allocated
 679            if *this is a base subobject.  */;
 680       else if (tree_int_cst_equal (TYPE_SIZE (current_class_type),
 681                                    CLASSTYPE_SIZE (current_class_type)))
 682         {
 683           tree t = cp_build_init_expr (current_class_ref, parm);
 684           finish_expr_stmt (t);
 685         }
 686       else
 687         {
 688           /* We must only copy the non-tail padding parts.  */
 689           tree base_size = CLASSTYPE_SIZE_UNIT (current_class_type);
 690           base_size = size_binop (MINUS_EXPR, base_size, size_int (1));
 691           tree array_type = build_array_type (unsigned_char_type_node,
 692                                               build_index_type (base_size));
 693           tree alias_set = build_int_cst (TREE_TYPE (current_class_ptr), 0);
 694           tree lhs = build2 (MEM_REF, array_type,
 695                              current_class_ptr, alias_set);
 696           tree rhs = build2 (MEM_REF, array_type,
 697                              TREE_OPERAND (parm, 0), alias_set);
 698           tree t = cp_build_init_expr (lhs, rhs);
 699           finish_expr_stmt (t);
 700         }
 701     }
 702   else
 703     {
 704       tree member_init_list = NULL_TREE;
 705       int i;
 706       tree binfo, base_binfo;
 707       vec<tree, va_gc> *vbases;
 708
 709       /* Initialize all the base-classes with the parameter converted
 710          to their type so that we get their copy constructor and not
 711          another constructor that takes current_class_type.  We must
 712          deal with the binfo's directly as a direct base might be
 713          inaccessible due to ambiguity.  */
 714       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
 715            vec_safe_iterate (vbases, i, &binfo); i++)
 716         {
 717           member_init_list = add_one_base_init (binfo, parm, move_p, inh,
 718                                                 member_init_list);
 719         }
 720
 721       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 722            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 723         {
 724           if (BINFO_VIRTUAL_P (base_binfo))
 725             continue;
 726           member_init_list = add_one_base_init (base_binfo, parm, move_p,
 727                                                 inh, member_init_list);
 728         }
 729
 730       if (!inh)
 731         {
 732           int cvquals = cp_type_quals (TREE_TYPE (parm));
 733
 734           for (tree fields = TYPE_FIELDS (current_class_type);
 735                fields; fields = DECL_CHAIN (fields))
 736             {
 737               tree field = fields;
 738               tree expr_type;
 739
 740               if (TREE_CODE (field) != FIELD_DECL)
 741                 continue;
 742
 743               expr_type = TREE_TYPE (field);
 744               if (DECL_NAME (field))
 745                 {
 746                   if (VFIELD_NAME_P (DECL_NAME (field)))
 747                     continue;
 748                 }
 749               else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
 750                 /* Just use the field; anonymous types can't have
 751                    nontrivial copy ctors or assignment ops or this
 752                    function would be deleted.  */;
 753               else
 754                 continue;
 755
 756               /* Compute the type of "init->field".  If the copy-constructor
 757                  parameter is, for example, "const S&", and the type of
 758                  the field is "T", then the type will usually be "const
 759                  T".  (There are no cv-qualified variants of reference
 760                  types.)  */
 761               if (!TYPE_REF_P (expr_type))
 762                 {
 763                   int quals = cvquals;
 764
 765                   if (DECL_MUTABLE_P (field))
 766                     quals &= ~TYPE_QUAL_CONST;
 767                   quals |= cp_type_quals (expr_type);
 768                   expr_type = cp_build_qualified_type (expr_type, quals);
 769                 }
 770
 771               tree init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
 772               if (move_p && !TYPE_REF_P (expr_type)
 773                   /* 'move' breaks bit-fields, and has no effect for scalars.  */
 774                   && !scalarish_type_p (expr_type))
 775                 init = move (init);
 776               init = build_tree_list (NULL_TREE, init);
 777
 778               member_init_list = tree_cons (field, init, member_init_list);
 779             }
 780         }
 781
 782       finish_mem_initializers (member_init_list);
 783     }
 784 }
 785
 786 static void
 787 do_build_copy_assign (tree fndecl)
 788 {
 789   tree parm = DECL_CHAIN (DECL_ARGUMENTS (fndecl));
 790   tree compound_stmt;
 791   bool move_p = move_fn_p (fndecl);
 792   bool trivial = trivial_fn_p (fndecl);
 793   int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
 794
 795   compound_stmt = begin_compound_stmt (0);
 796   parm = convert_from_reference (parm);
 797
 798   if (trivial
 799       && is_empty_class (current_class_type))
 800     /* Don't copy the padding byte; it might not have been allocated
 801        if *this is a base subobject.  */;
 802   else if (trivial)
 803     {
 804       tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
 805       finish_expr_stmt (t);
 806     }
 807   else
 808     {
 809       tree fields;
 810       int cvquals = cp_type_quals (TREE_TYPE (parm));
 811       int i;
 812       tree binfo, base_binfo;
 813
 814       /* Assign to each of the direct base classes.  */
 815       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 816            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 817         {
 818           tree converted_parm;
 819
 820           /* We must convert PARM directly to the base class
 821              explicitly since the base class may be ambiguous.  */
 822           converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1,
 823                                             tf_warning_or_error);
 824           if (move_p)
 825             converted_parm = move (converted_parm);
 826           /* Call the base class assignment operator.  */
 827           releasing_vec parmvec (make_tree_vector_single (converted_parm));
 828           finish_expr_stmt
 829             (build_special_member_call (current_class_ref,
 830                                         assign_op_identifier,
 831                                         &parmvec,
 832                                         base_binfo,
 833                                         flags,
 834                                         tf_warning_or_error));
 835         }
 836
 837       /* Assign to each of the non-static data members.  */
 838       for (fields = TYPE_FIELDS (current_class_type);
 839            fields;
 840            fields = DECL_CHAIN (fields))
 841         {
 842           tree comp = current_class_ref;
 843           tree init = parm;
 844           tree field = fields;
 845           tree expr_type;
 846           int quals;
 847
 848           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 849             continue;
 850
 851           expr_type = TREE_TYPE (field);
 852
 853           if (CP_TYPE_CONST_P (expr_type))
 854             {
 855               error ("non-static const member %q#D, cannot use default "
 856                      "assignment operator", field);
 857               continue;
 858             }
 859           else if (TYPE_REF_P (expr_type))
 860             {
 861               error ("non-static reference member %q#D, cannot use "
 862                      "default assignment operator", field);
 863               continue;
 864             }
 865
 866           if (DECL_NAME (field))
 867             {
 868               if (VFIELD_NAME_P (DECL_NAME (field)))
 869                 continue;
 870             }
 871           else if (ANON_AGGR_TYPE_P (expr_type)
 872                    && TYPE_FIELDS (expr_type) != NULL_TREE)
 873             /* Just use the field; anonymous types can't have
 874                nontrivial copy ctors or assignment ops or this
 875                function would be deleted.  */;
 876           else
 877             continue;
 878
 879           comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
 880
 881           /* Compute the type of init->field  */
 882           quals = cvquals;
 883           if (DECL_MUTABLE_P (field))
 884             quals &= ~TYPE_QUAL_CONST;
 885           expr_type = cp_build_qualified_type (expr_type, quals);
 886
 887           init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
 888           if (move_p && !TYPE_REF_P (expr_type)
 889               /* 'move' breaks bit-fields, and has no effect for scalars.  */
 890               && !scalarish_type_p (expr_type))
 891             init = move (init);
 892
 893           if (DECL_NAME (field))
 894             init = cp_build_modify_expr (input_location, comp, NOP_EXPR, init,
 895                                          tf_warning_or_error);
 896           else
 897             init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
 898           finish_expr_stmt (init);
 899         }
 900     }
 901   finish_return_stmt (current_class_ref);
 902   finish_compound_stmt (compound_stmt);
 903 }
 904
 905 /* C++20 <compare> comparison category types.  */
 906
 907 enum comp_cat_tag
 908 {
 909   cc_partial_ordering,
 910   cc_weak_ordering,
 911   cc_strong_ordering,
 912   cc_last
 913 };
 914
 915 /* Names of the comparison categories and their value members, to be indexed by
 916    comp_cat_tag enumerators.  genericize_spaceship below relies on the ordering
 917    of the members.  */
 918
 919 struct comp_cat_info_t
 920 {
 921   const char *name;
 922   const char *members[4];
 923 };
 924 static const comp_cat_info_t comp_cat_info[cc_last]
 925 = {
 926    { "partial_ordering", { "equivalent", "greater", "less", "unordered" } },
 927    { "weak_ordering", { "equivalent", "greater", "less" } },
 928    { "strong_ordering", { "equal", "greater", "less" } }
 929 };
 930
 931 /* A cache of the category types to speed repeated lookups.  */
 932
 933 static GTY((deletable)) tree comp_cat_cache[cc_last];
 934
 935 /* Look up one of the result variables in the comparison category type.  */
 936
 937 static tree
 938 lookup_comparison_result (tree type, const char *name_str,
 939                           tsubst_flags_t complain = tf_warning_or_error)
 940 {
 941   tree name = get_identifier (name_str);
 942   tree decl = lookup_qualified_name (type, name);
 943   if (TREE_CODE (decl) != VAR_DECL)
 944     {
 945       if (complain & tf_error)
 946         {
 947           auto_diagnostic_group d;
 948           if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
 949             qualified_name_lookup_error (type, name, decl, input_location);
 950           else
 951             error ("%qD is not a static data member", decl);
 952           inform (input_location, "determining value of %qs", "operator<=>");
 953         }
 954       return error_mark_node;
 955     }
 956   return decl;
 957 }
 958
 959 /* Look up a <compare> comparison category type in std.  */
 960
 961 static tree
 962 lookup_comparison_category (comp_cat_tag tag,
 963                             tsubst_flags_t complain = tf_warning_or_error)
 964 {
 965   if (tree cached = comp_cat_cache[tag])
 966     return cached;
 967
 968   tree name = get_identifier (comp_cat_info[tag].name);
 969   tree decl = lookup_qualified_name (std_node, name);
 970   if (TREE_CODE (decl) != TYPE_DECL)
 971     {
 972       if (complain & tf_error)
 973         {
 974           auto_diagnostic_group d;
 975           if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
 976             qualified_name_lookup_error (std_node, name, decl, input_location);
 977           else
 978             error ("%qD is not a type", decl);
 979           inform (input_location, "forming type of %qs", "operator<=>");
 980         }
 981       return error_mark_node;
 982     }
 983   /* Also make sure we can look up the value members now, since we won't
 984      really use them until genericize time.  */
 985   tree type = TREE_TYPE (decl);
 986   for (int i = 0; i < 4; ++i)
 987     {
 988       const char *p = comp_cat_info[tag].members[i];
 989       if (!p) break;
 990       if (lookup_comparison_result (type, p, complain)
 991           == error_mark_node)
 992         return error_mark_node;
 993     }
 994   return comp_cat_cache[tag] = type;
 995 }
 996
 997 /* Wrapper that takes the tag rather than the type.  */
 998
 999 static tree
1000 lookup_comparison_result (comp_cat_tag tag, const char *name_str,
1001                           tsubst_flags_t complain = tf_warning_or_error)
1002 {
1003   tree type = lookup_comparison_category (tag, complain);
1004   return lookup_comparison_result (type, name_str, complain);
1005 }
1006
1007 /* Wrapper that takes the index into the members array instead of the name.  */
1008
1009 static tree
1010 lookup_comparison_result (comp_cat_tag tag, tree type, int idx)
1011 {
1012   const char *name_str = comp_cat_info[tag].members[idx];
1013   if (!name_str)
1014     return NULL_TREE;
1015   return lookup_comparison_result (type, name_str);
1016 }
1017
1018 /* Does TYPE correspond to TAG?  */
1019
1020 static bool
1021 is_cat (tree type, comp_cat_tag tag)
1022 {
1023   tree name = TYPE_LINKAGE_IDENTIFIER (type);
1024   return id_equal (name, comp_cat_info[tag].name);
1025 }
1026
1027 /* Return the comp_cat_tag for TYPE.  */
1028
1029 static comp_cat_tag
1030 cat_tag_for (tree type)
1031 {
1032   if (!CLASS_TYPE_P (type) || !decl_in_std_namespace_p (TYPE_MAIN_DECL (type)))
1033     return cc_last;
1034   for (int i = 0; i < cc_last; ++i)
1035     {
1036       comp_cat_tag tag = (comp_cat_tag)i;
1037       if (is_cat (type, tag))
1038         return tag;
1039     }
1040   return cc_last;
1041 }
1042
1043 /* Return the comparison category tag of a <=> expression with non-class type
1044    OPTYPE.  */
1045
1046 static comp_cat_tag
1047 spaceship_comp_cat (tree optype)
1048 {
1049   if (INTEGRAL_OR_ENUMERATION_TYPE_P (optype) || TYPE_PTROBV_P (optype))
1050     return cc_strong_ordering;
1051   else if (SCALAR_FLOAT_TYPE_P (optype))
1052     return cc_partial_ordering;
1053
1054   /* ??? should vector <=> produce a vector of one of the above?  */
1055   gcc_unreachable ();
1056 }
1057
1058 /* Return the comparison category type of a <=> expression with non-class type
1059    OPTYPE.  */
1060
1061 tree
1062 spaceship_type (tree optype, tsubst_flags_t complain)
1063 {
1064   comp_cat_tag tag = spaceship_comp_cat (optype);
1065   return lookup_comparison_category (tag, complain);
1066 }
1067
1068 /* Turn <=> with type TYPE and operands OP0 and OP1 into GENERIC.
1069    This is also used by build_comparison_op for fallback to op< and op==
1070    in a defaulted op<=>.  */
1071
1072 tree
1073 genericize_spaceship (location_t loc, tree type, tree op0, tree op1)
1074 {
1075   /* ??? maybe optimize based on knowledge of representation? */
1076   comp_cat_tag tag = cat_tag_for (type);
1077
1078   if (tag == cc_last && is_auto (type))
1079     {
1080       /* build_comparison_op is checking to see if we want to suggest changing
1081          the op<=> return type from auto to a specific comparison category; any
1082          category will do for now.  */
1083       tag = cc_strong_ordering;
1084       type = lookup_comparison_category (tag, tf_none);
1085       if (type == error_mark_node)
1086         return error_mark_node;
1087     }
1088
1089   gcc_checking_assert (tag < cc_last);
1090
1091   tree r;
1092   bool scalar = SCALAR_TYPE_P (TREE_TYPE (op0));
1093   if (scalar)
1094     {
1095       op0 = save_expr (op0);
1096       op1 = save_expr (op1);
1097     }
1098
1099   tree gt = lookup_comparison_result (tag, type, 1);
1100
1101   int flags = LOOKUP_NORMAL;
1102   tsubst_flags_t complain = tf_none;
1103   tree comp;
1104
1105   if (tag == cc_partial_ordering)
1106     {
1107       /* op0 == op1 ? equivalent : op0 < op1 ? less :
1108          op1 < op0 ? greater : unordered */
1109       tree uo = lookup_comparison_result (tag, type, 3);
1110       if (scalar)
1111         {
1112           /* For scalars use the low level operations; using build_new_op causes
1113              trouble with constexpr eval in the middle of genericize (100367).  */
1114           comp = fold_build2 (LT_EXPR, boolean_type_node, op1, op0);
1115           r = fold_build3 (COND_EXPR, type, comp, gt, uo);
1116         }
1117       else
1118         {
1119           comp = build_new_op (loc, LT_EXPR, flags, op1, op0, complain);
1120           r = build_conditional_expr (loc, comp, gt, uo, complain);
1121         }
1122     }
1123   else
1124     /* op0 == op1 ? equal : op0 < op1 ? less : greater */
1125     r = gt;
1126
1127   tree lt = lookup_comparison_result (tag, type, 2);
1128   if (scalar)
1129     {
1130       comp = fold_build2 (LT_EXPR, boolean_type_node, op0, op1);
1131       r = fold_build3 (COND_EXPR, type, comp, lt, r);
1132     }
1133   else
1134     {
1135       comp = build_new_op (loc, LT_EXPR, flags, op0, op1, complain);
1136       r = build_conditional_expr (loc, comp, lt, r, complain);
1137     }
1138
1139   tree eq = lookup_comparison_result (tag, type, 0);
1140   if (scalar)
1141     {
1142       comp = fold_build2 (EQ_EXPR, boolean_type_node, op0, op1);
1143       r = fold_build3 (COND_EXPR, type, comp, eq, r);
1144     }
1145   else
1146     {
1147       comp = build_new_op (loc, EQ_EXPR, flags, op0, op1, complain);
1148       r = build_conditional_expr (loc, comp, eq, r, complain);
1149     }
1150
1151   return r;
1152 }
1153
1154 /* Check that the signature of a defaulted comparison operator is
1155    well-formed.  */
1156
1157 static bool
1158 early_check_defaulted_comparison (tree fn)
1159 {
1160   location_t loc = DECL_SOURCE_LOCATION (fn);
1161   tree ctx;
1162   if (DECL_CLASS_SCOPE_P (fn))
1163     ctx = DECL_CONTEXT (fn);
1164   else
1165     ctx = DECL_FRIEND_CONTEXT (fn);
1166   bool ok = true;
1167
1168   if (cxx_dialect < cxx20)
1169     {
1170       error_at (loc, "defaulted %qD only available with %<-std=c++20%> or "
1171                      "%<-std=gnu++20%>", fn);
1172       return false;
1173     }
1174
1175   if (!DECL_OVERLOADED_OPERATOR_IS (fn, SPACESHIP_EXPR)
1176       && !same_type_p (TREE_TYPE (TREE_TYPE (fn)), boolean_type_node))
1177     {
1178       diagnostic_t kind = DK_UNSPECIFIED;
1179       int opt = 0;
1180       if (is_auto (TREE_TYPE (fn)))
1181         kind = DK_PEDWARN;
1182       else
1183         kind = DK_ERROR;
1184       emit_diagnostic (kind, loc, opt,
1185                        "defaulted %qD must return %<bool%>", fn);
1186       if (kind == DK_ERROR)
1187         ok = false;
1188     }
1189
1190   bool mem = DECL_NONSTATIC_MEMBER_FUNCTION_P (fn);
1191   if (mem && type_memfn_quals (TREE_TYPE (fn)) != TYPE_QUAL_CONST)
1192     {
1193       error_at (loc, "defaulted %qD must be %<const%>", fn);
1194       ok = false;
1195     }
1196   if (mem && type_memfn_rqual (TREE_TYPE (fn)) == REF_QUAL_RVALUE)
1197     {
1198       error_at (loc, "defaulted %qD must not have %<&&%> ref-qualifier", fn);
1199       ok = false;
1200     }
1201   tree parmnode = FUNCTION_FIRST_USER_PARMTYPE (fn);
1202   bool saw_byval = false;
1203   bool saw_byref = mem;
1204   bool saw_bad = false;
1205   for (; parmnode != void_list_node; parmnode = TREE_CHAIN (parmnode))
1206     {
1207       tree parmtype = TREE_VALUE (parmnode);
1208       if (CLASS_TYPE_P (parmtype))
1209         saw_byval = true;
1210       else if (TREE_CODE (parmtype) == REFERENCE_TYPE
1211                && !TYPE_REF_IS_RVALUE (parmtype)
1212                && TYPE_QUALS (TREE_TYPE (parmtype)) == TYPE_QUAL_CONST)
1213         {
1214           saw_byref = true;
1215           parmtype = TREE_TYPE (parmtype);
1216         }
1217       else
1218         saw_bad = true;
1219
1220       if (!saw_bad && !ctx)
1221         {
1222           /* Defaulted outside the class body.  */
1223           ctx = TYPE_MAIN_VARIANT (parmtype);
1224           if (!is_friend (ctx, fn))
1225             error_at (loc, "defaulted %qD is not a friend of %qT", fn, ctx);
1226         }
1227       else if (!same_type_ignoring_top_level_qualifiers_p (parmtype, ctx))
1228         saw_bad = true;
1229     }
1230
1231   if (saw_bad || (saw_byval && saw_byref))
1232     {
1233       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1234         error_at (loc, "defaulted member %qD must have parameter type "
1235                   "%<const %T&%>", fn, ctx);
1236       else if (saw_bad)
1237         error_at (loc, "defaulted %qD must have parameters of either type "
1238                   "%<const %T&%> or %qT", fn, ctx, ctx);
1239       else
1240         error_at (loc, "defaulted %qD must have parameters of either type "
1241                   "%<const %T&%> or %qT, not both", fn, ctx, ctx);
1242       ok = false;
1243     }
1244
1245   /* We still need to deduce deleted/constexpr/noexcept and maybe return. */
1246   DECL_MAYBE_DELETED (fn) = ok;
1247
1248   return ok;
1249 }
1250
1251 /* Subroutine of build_comparison_op.  Given the vec of memberwise
1252    comparisons COMPS, calculate the overall comparison category for
1253    operator<=>.  */
1254
1255 static tree
1256 common_comparison_type (vec<tree> &comps)
1257 {
1258   tree seen[cc_last] = {};
1259
1260   for (unsigned i = 0; i < comps.length(); ++i)
1261     {
1262       tree comp = comps[i];
1263       if (TREE_CODE (comp) == TREE_LIST)
1264         comp = TREE_VALUE (comp);
1265       tree ctype = TREE_TYPE (comp);
1266       comp_cat_tag tag = cat_tag_for (ctype);
1267       /* build_comparison_op already checked this.  */
1268       gcc_checking_assert (tag < cc_last);
1269       seen[tag] = ctype;
1270     }
1271
1272   /* Otherwise, if at least one T i is std::partial_ordering, U is
1273      std::partial_ordering.  */
1274   if (tree t = seen[cc_partial_ordering]) return t;
1275
1276   /* Otherwise, if at least one T i is std::weak_ordering, U is
1277      std::weak_ordering.  */
1278   if (tree t = seen[cc_weak_ordering]) return t;
1279
1280   /* Otherwise, U is std::strong_ordering.  */
1281   if (tree t = seen[cc_strong_ordering]) return t;
1282   return lookup_comparison_category (cc_strong_ordering);
1283 }
1284
1285 /* Data structure for build_comparison_op.  */
1286
1287 struct comp_info
1288 {
1289   tree fndecl;
1290   location_t loc;
1291   tsubst_flags_t complain;
1292   tree_code code;
1293   comp_cat_tag retcat;
1294   bool first_time;
1295   bool constexp;
1296   bool was_constexp;
1297   bool noex;
1298
1299   comp_info (tree fndecl, tsubst_flags_t complain)
1300     : fndecl (fndecl), complain (complain)
1301   {
1302     loc = DECL_SOURCE_LOCATION (fndecl);
1303
1304     first_time = DECL_MAYBE_DELETED (fndecl);
1305     DECL_MAYBE_DELETED (fndecl) = false;
1306
1307     /* Do we want to try to set constexpr?  */
1308     was_constexp = DECL_DECLARED_CONSTEXPR_P (fndecl);
1309     constexp = first_time;
1310     if (constexp)
1311       /* Set this for var_in_constexpr_fn.  */
1312       DECL_DECLARED_CONSTEXPR_P (fndecl) = true;
1313
1314     /* Do we want to try to set noexcept?  */
1315     noex = first_time;
1316     if (noex)
1317       {
1318         tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fndecl));
1319         if (raises && !UNEVALUATED_NOEXCEPT_SPEC_P (raises))
1320           /* There was an explicit exception-specification.  */
1321           noex = false;
1322       }
1323   }
1324
1325   /* EXPR is an expression built as part of the function body.
1326      Adjust the properties appropriately.  */
1327   void check (tree expr)
1328   {
1329     if (expr == error_mark_node)
1330       DECL_DELETED_FN (fndecl) = true;
1331     if ((constexp || was_constexp)
1332         && !potential_rvalue_constant_expression (expr))
1333       {
1334         if (was_constexp)
1335           require_potential_rvalue_constant_expression_fncheck (expr);
1336         else
1337           constexp = false;
1338       }
1339     if (noex && !expr_noexcept_p (expr, tf_none))
1340       noex = false;
1341   }
1342
1343   ~comp_info ()
1344   {
1345     if (first_time)
1346       {
1347         DECL_DECLARED_CONSTEXPR_P (fndecl) = constexp || was_constexp;
1348         tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fndecl));
1349         if (!raises || UNEVALUATED_NOEXCEPT_SPEC_P (raises))
1350           {
1351             raises = noex ? noexcept_true_spec : noexcept_false_spec;
1352             TREE_TYPE (fndecl) = build_exception_variant (TREE_TYPE (fndecl),
1353                                                           raises);
1354           }
1355       }
1356   }
1357 };
1358
1359 /* Subroutine of build_comparison_op, to compare a single subobject.  */
1360
1361 static tree
1362 do_one_comp (location_t loc, const comp_info &info, tree sub, tree lhs, tree rhs)
1363 {
1364   const tree_code code = info.code;
1365   const tree fndecl = info.fndecl;
1366   const comp_cat_tag retcat = info.retcat;
1367   const tsubst_flags_t complain = info.complain;
1368
1369   tree overload = NULL_TREE;
1370   int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
1371   /* If we have an explicit comparison category return type we can fall back
1372      to </=, so don't give an error yet if <=> lookup fails.  */
1373   bool tentative = retcat != cc_last;
1374   tree comp = build_new_op (loc, code, flags, lhs, rhs,
1375                             NULL_TREE, NULL_TREE, &overload,
1376                             tentative ? tf_none : complain);
1377
1378   if (code != SPACESHIP_EXPR)
1379     return comp;
1380
1381   tree rettype = TREE_TYPE (TREE_TYPE (fndecl));
1382
1383   if (comp == error_mark_node)
1384     {
1385       if (overload == NULL_TREE && (tentative || complain))
1386         {
1387           /* No viable <=>, try using op< and op==.  */
1388           tree lteq = genericize_spaceship (loc, rettype, lhs, rhs);
1389           if (lteq != error_mark_node)
1390             {
1391               /* We found usable < and ==.  */
1392               if (retcat != cc_last)
1393                 /* Return type is a comparison category, use them.  */
1394                 comp = lteq;
1395               else if (complain & tf_error)
1396                 /* Return type is auto, suggest changing it.  */
1397                 inform (info.loc, "changing the return type from %qs "
1398                         "to a comparison category type will allow the "
1399                         "comparison to use %qs and %qs", "auto",
1400                         "operator<", "operator==");
1401             }
1402           else if (tentative && complain)
1403             /* No usable < and ==, give an error for op<=>.  */
1404             build_new_op (loc, code, flags, lhs, rhs, complain);
1405         }
1406       if (comp == error_mark_node)
1407         return error_mark_node;
1408     }
1409
1410   if (FNDECL_USED_AUTO (fndecl)
1411       && cat_tag_for (TREE_TYPE (comp)) == cc_last)
1412     {
1413       /* The operator function is defined as deleted if ... Ri is not a
1414          comparison category type.  */
1415       if (complain & tf_error)
1416         inform (loc,
1417                 "three-way comparison of %qD has type %qT, not a "
1418                 "comparison category type", sub, TREE_TYPE (comp));
1419       return error_mark_node;
1420     }
1421   else if (!FNDECL_USED_AUTO (fndecl)
1422            && !can_convert (rettype, TREE_TYPE (comp), complain))
1423     {
1424       if (complain & tf_error)
1425         error_at (loc,
1426                   "three-way comparison of %qD has type %qT, which "
1427                   "does not convert to %qT",
1428                   sub, TREE_TYPE (comp), rettype);
1429       return error_mark_node;
1430     }
1431
1432   return comp;
1433 }
1434
1435 /* Build up the definition of a defaulted comparison operator.  Unlike other
1436    defaulted functions that use synthesized_method_walk to determine whether
1437    the function is e.g. deleted, for comparisons we use the same code.  We try
1438    to use synthesize_method at the earliest opportunity and bail out if the
1439    function ends up being deleted.  */
1440
1441 void
1442 build_comparison_op (tree fndecl, bool defining, tsubst_flags_t complain)
1443 {
1444   comp_info info (fndecl, complain);
1445
1446   if (!defining && !(complain & tf_error) && !DECL_MAYBE_DELETED (fndecl))
1447     return;
1448
1449   int flags = LOOKUP_NORMAL;
1450   const ovl_op_info_t *op = IDENTIFIER_OVL_OP_INFO (DECL_NAME (fndecl));
1451   tree_code code = info.code = op->tree_code;
1452
1453   tree lhs = DECL_ARGUMENTS (fndecl);
1454   tree rhs = DECL_CHAIN (lhs);
1455   if (is_this_parameter (lhs))
1456     lhs = cp_build_fold_indirect_ref (lhs);
1457   else
1458     lhs = convert_from_reference (lhs);
1459   rhs = convert_from_reference (rhs);
1460   tree ctype = TYPE_MAIN_VARIANT (TREE_TYPE (lhs));
1461   gcc_assert (!defining || COMPLETE_TYPE_P (ctype));
1462
1463   iloc_sentinel ils (info.loc);
1464
1465   /* A defaulted comparison operator function for class C is defined as
1466      deleted if ... C has variant members.  */
1467   if (TREE_CODE (ctype) == UNION_TYPE
1468       && next_aggregate_field (TYPE_FIELDS (ctype)))
1469     {
1470       if (complain & tf_error)
1471         inform (info.loc, "cannot default compare union %qT", ctype);
1472       DECL_DELETED_FN (fndecl) = true;
1473       return;
1474     }
1475
1476   tree compound_stmt = NULL_TREE;
1477   if (defining)
1478     compound_stmt = begin_compound_stmt (0);
1479   else
1480     ++cp_unevaluated_operand;
1481
1482   tree rettype = TREE_TYPE (TREE_TYPE (fndecl));
1483   if (code != SPACESHIP_EXPR && is_auto (rettype))
1484     {
1485       rettype = boolean_type_node;
1486       apply_deduced_return_type (fndecl, rettype);
1487     }
1488
1489   if (code == EQ_EXPR || code == SPACESHIP_EXPR)
1490     {
1491       comp_cat_tag &retcat = (info.retcat = cc_last);
1492       if (code == SPACESHIP_EXPR && !FNDECL_USED_AUTO (fndecl))
1493         retcat = cat_tag_for (rettype);
1494
1495       bool bad = false;
1496       auto_vec<tree> comps;
1497
1498       /* Compare the base subobjects.  We handle them this way, rather than in
1499          the field loop below, because maybe_instantiate_noexcept might bring
1500          us here before we've built the base fields.  */
1501       for (tree base_binfo : BINFO_BASE_BINFOS (TYPE_BINFO (ctype)))
1502         {
1503           tree lhs_base
1504             = build_base_path (PLUS_EXPR, lhs, base_binfo, 0, complain);
1505           tree rhs_base
1506             = build_base_path (PLUS_EXPR, rhs, base_binfo, 0, complain);
1507
1508           location_t loc = DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (ctype));
1509           tree comp = do_one_comp (loc, info, BINFO_TYPE (base_binfo),
1510                                    lhs_base, rhs_base);
1511           if (comp == error_mark_node)
1512             {
1513               bad = true;
1514               continue;
1515             }
1516
1517           comps.safe_push (comp);
1518         }
1519
1520       /* Now compare the field subobjects.  */
1521       for (tree field = next_aggregate_field (TYPE_FIELDS (ctype));
1522            field;
1523            field = next_aggregate_field (DECL_CHAIN (field)))
1524         {
1525           if (DECL_VIRTUAL_P (field) || DECL_FIELD_IS_BASE (field))
1526             /* We ignore the vptr, and we already handled bases.  */
1527             continue;
1528
1529           tree expr_type = TREE_TYPE (field);
1530
1531           location_t field_loc = DECL_SOURCE_LOCATION (field);
1532
1533           /* A defaulted comparison operator function for class C is defined as
1534              deleted if any non-static data member of C is of reference type or
1535              C has variant members.  */
1536           if (TREE_CODE (expr_type) == REFERENCE_TYPE)
1537             {
1538               if (complain & tf_error)
1539                 inform (field_loc, "cannot default compare "
1540                         "reference member %qD", field);
1541               bad = true;
1542               continue;
1543             }
1544           else if (ANON_UNION_TYPE_P (expr_type)
1545                    && next_aggregate_field (TYPE_FIELDS (expr_type)))
1546             {
1547               if (complain & tf_error)
1548                 inform (field_loc, "cannot default compare "
1549                         "anonymous union member");
1550               bad = true;
1551               continue;
1552             }
1553
1554           tree lhs_mem = build3_loc (field_loc, COMPONENT_REF, expr_type, lhs,
1555                                      field, NULL_TREE);
1556           tree rhs_mem = build3_loc (field_loc, COMPONENT_REF, expr_type, rhs,
1557                                      field, NULL_TREE);
1558           tree loop_indexes = NULL_TREE;
1559           while (TREE_CODE (expr_type) == ARRAY_TYPE)
1560             {
1561               /* Flexible array member.  */
1562               if (TYPE_DOMAIN (expr_type) == NULL_TREE
1563                   || TYPE_MAX_VALUE (TYPE_DOMAIN (expr_type)) == NULL_TREE)
1564                 {
1565                   if (complain & tf_error)
1566                     inform (field_loc, "cannot default compare "
1567                                        "flexible array member");
1568                   bad = true;
1569                   break;
1570                 }
1571               tree maxval = TYPE_MAX_VALUE (TYPE_DOMAIN (expr_type));
1572               /* [0] array.  No subobjects to compare, just skip it.  */
1573               if (integer_all_onesp (maxval))
1574                 break;
1575               tree idx;
1576               /* [1] array, no loop needed, just add [0] ARRAY_REF.
1577                  Similarly if !defining.  */
1578               if (integer_zerop (maxval) || !defining)
1579                 idx = size_zero_node;
1580               /* Some other array, will need runtime loop.  */
1581               else
1582                 {
1583                   idx = force_target_expr (sizetype, maxval, complain);
1584                   loop_indexes = tree_cons (idx, NULL_TREE, loop_indexes);
1585                 }
1586               expr_type = TREE_TYPE (expr_type);
1587               lhs_mem = build4_loc (field_loc, ARRAY_REF, expr_type, lhs_mem,
1588                                     idx, NULL_TREE, NULL_TREE);
1589               rhs_mem = build4_loc (field_loc, ARRAY_REF, expr_type, rhs_mem,
1590                                     idx, NULL_TREE, NULL_TREE);
1591             }
1592           if (TREE_CODE (expr_type) == ARRAY_TYPE)
1593             continue;
1594
1595           tree comp = do_one_comp (field_loc, info, field, lhs_mem, rhs_mem);
1596           if (comp == error_mark_node)
1597             {
1598               bad = true;
1599               continue;
1600             }
1601
1602           /* Most of the time, comp is the expression that should be evaluated
1603              to compare the two members.  If the expression needs to be
1604              evaluated more than once in a loop, it will be a TREE_LIST
1605              instead, whose TREE_VALUE is the expression for one array element,
1606              TREE_PURPOSE is innermost iterator temporary and if the array
1607              is multidimensional, TREE_CHAIN will contain another TREE_LIST
1608              with second innermost iterator in its TREE_PURPOSE and so on.  */
1609           if (loop_indexes)
1610             {
1611               TREE_VALUE (loop_indexes) = comp;
1612               comp = loop_indexes;
1613             }
1614           comps.safe_push (comp);
1615         }
1616       if (code == SPACESHIP_EXPR && is_auto (rettype))
1617         {
1618           rettype = common_comparison_type (comps);
1619           apply_deduced_return_type (fndecl, rettype);
1620         }
1621       if (bad)
1622         {
1623           DECL_DELETED_FN (fndecl) = true;
1624           goto out;
1625         }
1626       for (unsigned i = 0; i < comps.length(); ++i)
1627         {
1628           tree comp = comps[i];
1629           tree eq, retval = NULL_TREE, if_ = NULL_TREE;
1630           tree loop_indexes = NULL_TREE;
1631           if (defining)
1632             {
1633               if (TREE_CODE (comp) == TREE_LIST)
1634                 {
1635                   loop_indexes = comp;
1636                   comp = TREE_VALUE (comp);
1637                   loop_indexes = nreverse (loop_indexes);
1638                   for (tree loop_index = loop_indexes; loop_index;
1639                        loop_index = TREE_CHAIN (loop_index))
1640                     {
1641                       tree for_stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
1642                       tree idx = TREE_PURPOSE (loop_index);
1643                       tree maxval = TARGET_EXPR_INITIAL (idx);
1644                       TARGET_EXPR_INITIAL (idx) = size_zero_node;
1645                       add_stmt (idx);
1646                       finish_init_stmt (for_stmt);
1647                       finish_for_cond (build2 (LE_EXPR, boolean_type_node, idx,
1648                                                maxval), for_stmt, false, 0,
1649                                                false);
1650                       finish_for_expr (cp_build_unary_op (PREINCREMENT_EXPR,
1651                                                           TARGET_EXPR_SLOT (idx),
1652                                                           false, complain),
1653                                                           for_stmt);
1654                       /* Store in TREE_VALUE the for_stmt tree, so that we can
1655                          later on call finish_for_stmt on it (in the reverse
1656                          order).  */
1657                       TREE_VALUE (loop_index) = for_stmt;
1658                     }
1659                   loop_indexes = nreverse (loop_indexes);
1660                 }
1661               if_ = begin_if_stmt ();
1662             }
1663           /* Spaceship is specified to use !=, but for the comparison category
1664              types, != is equivalent to !(==), so let's use == directly.  */
1665           if (code == EQ_EXPR)
1666             {
1667               /* if (x==y); else return false; */
1668               eq = comp;
1669               retval = boolean_false_node;
1670             }
1671           else
1672             {
1673               /* if (auto v = x<=>y, v == 0); else return v; */
1674               if (TREE_CODE (comp) == SPACESHIP_EXPR)
1675                 TREE_TYPE (comp) = rettype;
1676               else
1677                 comp = build_static_cast (input_location, rettype, comp,
1678                                           complain);
1679               info.check (comp);
1680               if (defining)
1681                 {
1682                   tree var = create_temporary_var (rettype);
1683                   DECL_NAME (var) = get_identifier ("retval");
1684                   pushdecl (var);
1685                   cp_finish_decl (var, comp, false, NULL_TREE, flags);
1686                   comp = retval = var;
1687                 }
1688               eq = build_new_op (info.loc, EQ_EXPR, flags, comp,
1689                                  integer_zero_node, NULL_TREE, NULL_TREE,
1690                                  NULL, complain);
1691             }
1692           tree ceq = contextual_conv_bool (eq, complain);
1693           info.check (ceq);
1694           if (defining)
1695             {
1696               finish_if_stmt_cond (ceq, if_);
1697               finish_then_clause (if_);
1698               begin_else_clause (if_);
1699               finish_return_stmt (retval);
1700               finish_else_clause (if_);
1701               finish_if_stmt (if_);
1702               for (tree loop_index = loop_indexes; loop_index;
1703                    loop_index = TREE_CHAIN (loop_index))
1704                 finish_for_stmt (TREE_VALUE (loop_index));
1705             }
1706         }
1707       if (defining)
1708         {
1709           tree val;
1710           if (code == EQ_EXPR)
1711             val = boolean_true_node;
1712           else
1713             {
1714               tree seql = lookup_comparison_result (cc_strong_ordering,
1715                                                     "equal", complain);
1716               val = build_static_cast (input_location, rettype, seql,
1717                                        complain);
1718             }
1719           finish_return_stmt (val);
1720         }
1721     }
1722   else if (code == NE_EXPR)
1723     {
1724       tree comp = build_new_op (info.loc, EQ_EXPR, flags, lhs, rhs,
1725                                 NULL_TREE, NULL_TREE, NULL, complain);
1726       comp = contextual_conv_bool (comp, complain);
1727       info.check (comp);
1728       if (defining)
1729         {
1730           tree neg = build1 (TRUTH_NOT_EXPR, boolean_type_node, comp);
1731           finish_return_stmt (neg);
1732         }
1733     }
1734   else
1735     {
1736       tree comp = build_new_op (info.loc, SPACESHIP_EXPR, flags, lhs, rhs,
1737                                 NULL_TREE, NULL_TREE, NULL, complain);
1738       tree comp2 = build_new_op (info.loc, code, flags, comp, integer_zero_node,
1739                                  NULL_TREE, NULL_TREE, NULL, complain);
1740       info.check (comp2);
1741       if (defining)
1742         finish_return_stmt (comp2);
1743     }
1744
1745  out:
1746   if (defining)
1747     finish_compound_stmt (compound_stmt);
1748   else
1749     --cp_unevaluated_operand;
1750 }
1751
1752 /* True iff DECL is an implicitly-declared special member function with no real
1753    source location, so we can use its DECL_SOURCE_LOCATION to remember where we
1754    triggered its synthesis.  */
1755
1756 bool
1757 decl_remember_implicit_trigger_p (tree decl)
1758 {
1759   if (!DECL_ARTIFICIAL (decl))
1760     return false;
1761   special_function_kind sfk = special_function_p (decl);
1762   /* Inherited constructors have the location of their using-declaration, and
1763      operator== has the location of the corresponding operator<=>.  */
1764   return (sfk != sfk_inheriting_constructor
1765           && sfk != sfk_comparison);
1766 }
1767
1768 /* Synthesize FNDECL, a non-static member function.   */
1769
1770 void
1771 synthesize_method (tree fndecl)
1772 {
1773   bool need_body = true;
1774   tree stmt;
1775   location_t save_input_location = input_location;
1776   int error_count = errorcount;
1777   int warning_count = warningcount + werrorcount;
1778   special_function_kind sfk = special_function_p (fndecl);
1779
1780   /* Reset the source location, we might have been previously
1781      deferred, and thus have saved where we were first needed.  */
1782   if (decl_remember_implicit_trigger_p (fndecl))
1783     DECL_SOURCE_LOCATION (fndecl)
1784       = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
1785
1786   /* If we've been asked to synthesize a clone, just synthesize the
1787      cloned function instead.  Doing so will automatically fill in the
1788      body for the clone.  */
1789   if (DECL_CLONED_FUNCTION_P (fndecl))
1790     fndecl = DECL_CLONED_FUNCTION (fndecl);
1791
1792   /* We may be in the middle of deferred access check.  Disable
1793      it now.  */
1794   push_deferring_access_checks (dk_no_deferred);
1795
1796   bool push_to_top = maybe_push_to_top_level (fndecl);
1797
1798   input_location = DECL_SOURCE_LOCATION (fndecl);
1799
1800   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
1801   stmt = begin_function_body ();
1802
1803   if (DECL_ASSIGNMENT_OPERATOR_P (fndecl)
1804       && DECL_OVERLOADED_OPERATOR_IS (fndecl, NOP_EXPR))
1805     {
1806       do_build_copy_assign (fndecl);
1807       need_body = false;
1808     }
1809   else if (DECL_CONSTRUCTOR_P (fndecl))
1810     {
1811       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
1812       if (arg_chain != void_list_node)
1813         do_build_copy_constructor (fndecl);
1814       else
1815         finish_mem_initializers (NULL_TREE);
1816     }
1817   else if (sfk == sfk_comparison)
1818     {
1819       /* Pass tf_none so the function is just deleted if there's a problem.  */
1820       build_comparison_op (fndecl, true, tf_none);
1821       need_body = false;
1822     }
1823
1824   /* If we haven't yet generated the body of the function, just
1825      generate an empty compound statement.  */
1826   if (need_body)
1827     {
1828       tree compound_stmt;
1829       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
1830       finish_compound_stmt (compound_stmt);
1831     }
1832
1833   finish_function_body (stmt);
1834   finish_function (/*inline_p=*/false);
1835
1836   if (!DECL_DELETED_FN (fndecl))
1837     expand_or_defer_fn (fndecl);
1838
1839   input_location = save_input_location;
1840
1841   maybe_pop_from_top_level (push_to_top);
1842
1843   pop_deferring_access_checks ();
1844
1845   if (error_count != errorcount || warning_count != warningcount + werrorcount)
1846     if (DECL_ARTIFICIAL (fndecl))
1847       inform (input_location, "synthesized method %qD first required here",
1848               fndecl);
1849 }
1850
1851 /* Like synthesize_method, but don't actually synthesize defaulted comparison
1852    methods if their class is still incomplete.  Just deduce the return
1853    type in that case.  */
1854
1855 void
1856 maybe_synthesize_method (tree fndecl)
1857 {
1858   if (special_function_p (fndecl) == sfk_comparison)
1859     {
1860       tree lhs = DECL_ARGUMENTS (fndecl);
1861       if (is_this_parameter (lhs))
1862         lhs = cp_build_fold_indirect_ref (lhs);
1863       else
1864         lhs = convert_from_reference (lhs);
1865       tree ctype = TYPE_MAIN_VARIANT (TREE_TYPE (lhs));
1866       if (!COMPLETE_TYPE_P (ctype))
1867         {
1868           push_deferring_access_checks (dk_no_deferred);
1869           build_comparison_op (fndecl, false, tf_none);
1870           pop_deferring_access_checks ();
1871           return;
1872         }
1873     }
1874   return synthesize_method (fndecl);
1875 }
1876
1877 /* Build a reference to type TYPE with cv-quals QUALS, which is an
1878    rvalue if RVALUE is true.  */
1879
1880 static tree
1881 build_stub_type (tree type, int quals, bool rvalue)
1882 {
1883   tree argtype = cp_build_qualified_type (type, quals);
1884   return cp_build_reference_type (argtype, rvalue);
1885 }
1886
1887 /* Build a dummy glvalue from dereferencing a dummy reference of type
1888    REFTYPE.  */
1889
1890 tree
1891 build_stub_object (tree reftype)
1892 {
1893   if (!TYPE_REF_P (reftype))
1894     reftype = cp_build_reference_type (reftype, /*rval*/true);
1895   tree stub = build1 (CONVERT_EXPR, reftype, integer_one_node);
1896   return convert_from_reference (stub);
1897 }
1898
1899 /* Build a std::declval<TYPE>() expression and return it.  */
1900
1901 tree
1902 build_trait_object (tree type)
1903 {
1904   /* TYPE can't be a function with cv-/ref-qualifiers: std::declval is
1905      defined as
1906
1907        template<class T>
1908        typename std::add_rvalue_reference<T>::type declval() noexcept;
1909
1910      and std::add_rvalue_reference yields T when T is a function with
1911      cv- or ref-qualifiers, making the definition ill-formed.  */
1912   if (FUNC_OR_METHOD_TYPE_P (type)
1913       && (type_memfn_quals (type) != TYPE_UNQUALIFIED
1914           || type_memfn_rqual (type) != REF_QUAL_NONE))
1915     return error_mark_node;
1916
1917   return build_stub_object (type);
1918 }
1919
1920 /* Determine which function will be called when looking up NAME in TYPE,
1921    called with a single ARGTYPE argument, or no argument if ARGTYPE is
1922    null.  FLAGS and COMPLAIN are as for build_new_method_call.
1923
1924    Returns a FUNCTION_DECL if all is well.
1925    Returns NULL_TREE if overload resolution failed.
1926    Returns error_mark_node if the chosen function cannot be called.  */
1927
1928 static tree
1929 locate_fn_flags (tree type, tree name, tree argtype, int flags,
1930                  tsubst_flags_t complain)
1931 {
1932   tree ob, fn, fns, binfo, rval;
1933
1934   if (TYPE_P (type))
1935     binfo = TYPE_BINFO (type);
1936   else
1937     {
1938       binfo = type;
1939       type = BINFO_TYPE (binfo);
1940     }
1941
1942   ob = build_stub_object (cp_build_reference_type (type, false));
1943   releasing_vec args;
1944   if (argtype)
1945     {
1946       if (TREE_CODE (argtype) == TREE_LIST)
1947         {
1948           for (tree elt = argtype; elt && elt != void_list_node;
1949                elt = TREE_CHAIN (elt))
1950             {
1951               tree type = TREE_VALUE (elt);
1952               tree arg = build_stub_object (type);
1953               vec_safe_push (args, arg);
1954             }
1955         }
1956       else
1957         {
1958           tree arg = build_stub_object (argtype);
1959           args->quick_push (arg);
1960         }
1961     }
1962
1963   fns = lookup_fnfields (binfo, name, 0, complain);
1964   rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
1965
1966   if (fn && rval == error_mark_node)
1967     return rval;
1968   else
1969     return fn;
1970 }
1971
1972 /* Locate the dtor of TYPE.  */
1973
1974 tree
1975 get_dtor (tree type, tsubst_flags_t complain)
1976 {
1977   tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
1978                              LOOKUP_NORMAL, complain);
1979   if (fn == error_mark_node)
1980     return NULL_TREE;
1981   return fn;
1982 }
1983
1984 /* Locate the default ctor of TYPE.  */
1985
1986 tree
1987 locate_ctor (tree type)
1988 {
1989   tree fn;
1990
1991   push_deferring_access_checks (dk_no_check);
1992   fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
1993                         LOOKUP_SPECULATIVE, tf_none);
1994   pop_deferring_access_checks ();
1995   if (fn == error_mark_node)
1996     return NULL_TREE;
1997   return fn;
1998 }
1999
2000 /* Likewise, but give any appropriate errors.  */
2001
2002 tree
2003 get_default_ctor (tree type)
2004 {
2005   tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
2006                              LOOKUP_NORMAL, tf_warning_or_error);
2007   if (fn == error_mark_node)
2008     return NULL_TREE;
2009   return fn;
2010 }
2011
2012 /* Locate the copy ctor of TYPE.  */
2013
2014 tree
2015 get_copy_ctor (tree type, tsubst_flags_t complain)
2016 {
2017   int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
2018                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
2019   tree argtype = build_stub_type (type, quals, false);
2020   tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
2021                              LOOKUP_NORMAL, complain);
2022   if (fn == error_mark_node)
2023     return NULL_TREE;
2024   return fn;
2025 }
2026
2027 /* Locate the copy assignment operator of TYPE.  */
2028
2029 tree
2030 get_copy_assign (tree type)
2031 {
2032   int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
2033                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
2034   tree argtype = build_stub_type (type, quals, false);
2035   tree fn = locate_fn_flags (type, assign_op_identifier, argtype,
2036                              LOOKUP_NORMAL, tf_warning_or_error);
2037   if (fn == error_mark_node)
2038     return NULL_TREE;
2039   return fn;
2040 }
2041
2042 /* walk_tree helper function for is_trivially_xible.  If *TP is a call,
2043    return it if it calls something other than a trivial special member
2044    function.  */
2045
2046 static tree
2047 check_nontriv (tree *tp, int *, void *)
2048 {
2049   tree fn = cp_get_callee (*tp);
2050   if (fn == NULL_TREE)
2051     return NULL_TREE;
2052
2053   if (TREE_CODE (fn) == ADDR_EXPR)
2054     fn = TREE_OPERAND (fn, 0);
2055
2056   if (TREE_CODE (fn) != FUNCTION_DECL
2057       || !trivial_fn_p (fn))
2058     return fn;
2059   return NULL_TREE;
2060 }
2061
2062 /* Return declval<T>() = declval<U>() treated as an unevaluated operand.  */
2063
2064 static tree
2065 assignable_expr (tree to, tree from)
2066 {
2067   cp_unevaluated cp_uneval_guard;
2068   to = build_trait_object (to);
2069   from = build_trait_object (from);
2070   tree r = cp_build_modify_expr (input_location, to, NOP_EXPR, from, tf_none);
2071   return r;
2072 }
2073
2074 /* The predicate condition for a template specialization
2075    is_constructible<T, Args...> shall be satisfied if and only if the
2076    following variable definition would be well-formed for some invented
2077    variable t: T t(create<Args>()...);
2078
2079    Return something equivalent in well-formedness and triviality.  */
2080
2081 static tree
2082 constructible_expr (tree to, tree from)
2083 {
2084   tree expr;
2085   cp_unevaluated cp_uneval_guard;
2086   const int len = TREE_VEC_LENGTH (from);
2087   if (CLASS_TYPE_P (to))
2088     {
2089       tree ctype = to;
2090       vec<tree, va_gc> *args = NULL;
2091       if (!TYPE_REF_P (to))
2092         to = cp_build_reference_type (to, /*rval*/false);
2093       tree ob = build_stub_object (to);
2094       if (len == 0)
2095         expr = build_value_init (ctype, tf_none);
2096       else
2097         {
2098           vec_alloc (args, len);
2099           for (tree arg : tree_vec_range (from))
2100             args->quick_push (build_stub_object (arg));
2101           expr = build_special_member_call (ob, complete_ctor_identifier, &args,
2102                                             ctype, LOOKUP_NORMAL, tf_none);
2103         }
2104       if (expr == error_mark_node)
2105         return error_mark_node;
2106       /* The current state of the standard vis-a-vis LWG 2116 is that
2107          is_*constructible involves destruction as well.  */
2108       if (type_build_dtor_call (ctype))
2109         {
2110           tree dtor = build_special_member_call (ob, complete_dtor_identifier,
2111                                                  NULL, ctype, LOOKUP_NORMAL,
2112                                                  tf_none);
2113           if (dtor == error_mark_node)
2114             return error_mark_node;
2115           if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (ctype))
2116             expr = build2 (COMPOUND_EXPR, void_type_node, expr, dtor);
2117         }
2118     }
2119   else
2120     {
2121       if (len == 0)
2122         return build_value_init (strip_array_types (to), tf_none);
2123       if (len > 1)
2124         {
2125           if (cxx_dialect < cxx20)
2126             /* Too many initializers.  */
2127             return error_mark_node;
2128
2129           /* In C++20 this is well-formed:
2130                using T = int[2];
2131                T t(1, 2);
2132              which means that std::is_constructible_v<int[2], int, int>
2133              should be true.  */
2134           vec<constructor_elt, va_gc> *v;
2135           vec_alloc (v, len);
2136           for (tree arg : tree_vec_range (from))
2137             {
2138               tree stub = build_stub_object (arg);
2139               constructor_elt elt = { NULL_TREE, stub };
2140               v->quick_push (elt);
2141             }
2142           from = build_constructor (init_list_type_node, v);
2143           CONSTRUCTOR_IS_DIRECT_INIT (from) = true;
2144           CONSTRUCTOR_IS_PAREN_INIT (from) = true;
2145         }
2146       else
2147         from = build_stub_object (TREE_VEC_ELT (from, 0));
2148       expr = perform_direct_initialization_if_possible (to, from,
2149                                                         /*cast*/false,
2150                                                         tf_none);
2151       /* If t(e) didn't work, maybe t{e} will.  */
2152       if (expr == NULL_TREE
2153           && len == 1
2154           && cxx_dialect >= cxx20)
2155         {
2156           from = build_constructor_single (init_list_type_node, NULL_TREE,
2157                                            from);
2158           CONSTRUCTOR_IS_DIRECT_INIT (from) = true;
2159           CONSTRUCTOR_IS_PAREN_INIT (from) = true;
2160           expr = perform_direct_initialization_if_possible (to, from,
2161                                                             /*cast*/false,
2162                                                             tf_none);
2163         }
2164     }
2165   return expr;
2166 }
2167
2168 /* Returns a tree iff TO is assignable (if CODE is MODIFY_EXPR) or
2169    constructible (otherwise) from FROM, which is a single type for
2170    assignment or a list of types for construction.  */
2171
2172 static tree
2173 is_xible_helper (enum tree_code code, tree to, tree from, bool trivial)
2174 {
2175   to = complete_type (to);
2176   deferring_access_check_sentinel acs (dk_no_deferred);
2177   if (VOID_TYPE_P (to) || ABSTRACT_CLASS_TYPE_P (to)
2178       || (from && FUNC_OR_METHOD_TYPE_P (from)
2179           && (TYPE_READONLY (from) || FUNCTION_REF_QUALIFIED (from))))
2180     return error_mark_node;
2181   tree expr;
2182   if (code == MODIFY_EXPR)
2183     expr = assignable_expr (to, from);
2184   else if (trivial && TREE_VEC_LENGTH (from) > 1
2185            && cxx_dialect < cxx20)
2186     return error_mark_node; // only 0- and 1-argument ctors can be trivial
2187                             // before C++20 aggregate paren init
2188   else if (TREE_CODE (to) == ARRAY_TYPE && !TYPE_DOMAIN (to))
2189     return error_mark_node; // can't construct an array of unknown bound
2190   else
2191     expr = constructible_expr (to, from);
2192   return expr;
2193 }
2194
2195 /* Returns true iff TO is trivially assignable (if CODE is MODIFY_EXPR) or
2196    constructible (otherwise) from FROM, which is a single type for
2197    assignment or a list of types for construction.  */
2198
2199 bool
2200 is_trivially_xible (enum tree_code code, tree to, tree from)
2201 {
2202   tree expr = is_xible_helper (code, to, from, /*trivial*/true);
2203   if (expr == NULL_TREE || expr == error_mark_node)
2204     return false;
2205   tree nt = cp_walk_tree_without_duplicates (&expr, check_nontriv, NULL);
2206   return !nt;
2207 }
2208
2209 /* Returns true iff TO is nothrow assignable (if CODE is MODIFY_EXPR) or
2210    constructible (otherwise) from FROM, which is a single type for
2211    assignment or a list of types for construction.  */
2212
2213 bool
2214 is_nothrow_xible (enum tree_code code, tree to, tree from)
2215 {
2216   ++cp_noexcept_operand;
2217   tree expr = is_xible_helper (code, to, from, /*trivial*/false);
2218   --cp_noexcept_operand;
2219   if (expr == NULL_TREE || expr == error_mark_node)
2220     return false;
2221   return expr_noexcept_p (expr, tf_none);
2222 }
2223
2224 /* Returns true iff TO is assignable (if CODE is MODIFY_EXPR) or
2225    constructible (otherwise) from FROM, which is a single type for
2226    assignment or a list of types for construction.  */
2227
2228 bool
2229 is_xible (enum tree_code code, tree to, tree from)
2230 {
2231   tree expr = is_xible_helper (code, to, from, /*trivial*/false);
2232   if (expr == error_mark_node)
2233     return false;
2234   return !!expr;
2235 }
2236
2237 /* Return true iff conjunction_v<is_reference<T>, is_constructible<T, U>> is
2238    true, and the initialization
2239      T t(VAL<U>); // DIRECT_INIT_P
2240    or
2241      T t = VAL<U>; // !DIRECT_INIT_P
2242    binds t to a temporary object whose lifetime is extended.
2243    VAL<T> is defined in [meta.unary.prop]:
2244    -- If T is a reference or function type, VAL<T> is an expression with the
2245    same type and value category as declval<T>().
2246    -- Otherwise, VAL<T> is a prvalue that initially has type T.   */
2247
2248 bool
2249 ref_xes_from_temporary (tree to, tree from, bool direct_init_p)
2250 {
2251   /* Check is_reference<T>.  */
2252   if (!TYPE_REF_P (to))
2253     return false;
2254   /* We don't check is_constructible<T, U>: if T isn't constructible
2255      from U, we won't be able to create a conversion.  */
2256   tree val = build_trait_object (from);
2257   if (val == error_mark_node)
2258     return false;
2259   if (!TYPE_REF_P (from) && TREE_CODE (from) != FUNCTION_TYPE)
2260     val = CLASS_TYPE_P (from) ? force_rvalue (val, tf_none) : rvalue (val);
2261   return ref_conv_binds_to_temporary (to, val, direct_init_p).is_true ();
2262 }
2263
2264 /* Worker for is_{,nothrow_}convertible.  Attempt to perform an implicit
2265    conversion from FROM to TO and return the result.  */
2266
2267 static tree
2268 is_convertible_helper (tree from, tree to)
2269 {
2270   if (VOID_TYPE_P (from) && VOID_TYPE_P (to))
2271     return integer_one_node;
2272   cp_unevaluated u;
2273   tree expr = build_trait_object (from);
2274   /* std::is_{,nothrow_}convertible test whether the imaginary function
2275      definition
2276
2277        To test() { return std::declval<From>(); }
2278
2279      is well-formed.  A function can't return a function.  */
2280   if (FUNC_OR_METHOD_TYPE_P (to) || expr == error_mark_node)
2281     return error_mark_node;
2282   deferring_access_check_sentinel acs (dk_no_deferred);
2283   return perform_implicit_conversion (to, expr, tf_none);
2284 }
2285
2286 /* Return true if FROM can be converted to TO using implicit conversions,
2287    or both FROM and TO are possibly cv-qualified void.  NB: This doesn't
2288    implement the "Access checks are performed as if from a context unrelated
2289    to either type" restriction.  */
2290
2291 bool
2292 is_convertible (tree from, tree to)
2293 {
2294   tree expr = is_convertible_helper (from, to);
2295   if (expr == error_mark_node)
2296     return false;
2297   return !!expr;
2298 }
2299
2300 /* Like is_convertible, but the conversion is also noexcept.  */
2301
2302 bool
2303 is_nothrow_convertible (tree from, tree to)
2304 {
2305   tree expr = is_convertible_helper (from, to);
2306   if (expr == NULL_TREE || expr == error_mark_node)
2307     return false;
2308   return expr_noexcept_p (expr, tf_none);
2309 }
2310
2311 /* Categorize various special_function_kinds.  */
2312 #define SFK_CTOR_P(sfk) \
2313   ((sfk) >= sfk_constructor && (sfk) <= sfk_move_constructor)
2314 #define SFK_DTOR_P(sfk) \
2315   ((sfk) == sfk_destructor || (sfk) == sfk_virtual_destructor)
2316 #define SFK_ASSIGN_P(sfk) \
2317   ((sfk) == sfk_copy_assignment || (sfk) == sfk_move_assignment)
2318 #define SFK_COPY_P(sfk) \
2319   ((sfk) == sfk_copy_constructor || (sfk) == sfk_copy_assignment)
2320 #define SFK_MOVE_P(sfk) \
2321   ((sfk) == sfk_move_constructor || (sfk) == sfk_move_assignment)
2322
2323 /* Subroutine of synthesized_method_walk.  Update SPEC_P, TRIVIAL_P and
2324    DELETED_P or give an error message MSG with argument ARG.  */
2325
2326 static void
2327 process_subob_fn (tree fn, special_function_kind sfk, tree *spec_p,
2328                   bool *trivial_p, bool *deleted_p, bool *constexpr_p,
2329                   bool diag, tree arg, bool dtor_from_ctor = false)
2330 {
2331   if (!fn || fn == error_mark_node)
2332     {
2333       if (deleted_p)
2334         *deleted_p = true;
2335       return;
2336     }
2337
2338   if (spec_p)
2339     {
2340       if (!maybe_instantiate_noexcept (fn))
2341         *spec_p = error_mark_node;
2342       else
2343         {
2344           tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
2345           *spec_p = merge_exception_specifiers (*spec_p, raises);
2346         }
2347     }
2348
2349   if (!trivial_fn_p (fn) && !dtor_from_ctor)
2350     {
2351       if (trivial_p)
2352         *trivial_p = false;
2353       if (TREE_CODE (arg) == FIELD_DECL
2354           && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
2355         {
2356           if (deleted_p)
2357             *deleted_p = true;
2358           if (diag)
2359             error ("union member %q+D with non-trivial %qD", arg, fn);
2360         }
2361     }
2362
2363   if (constexpr_p && !DECL_DECLARED_CONSTEXPR_P (fn))
2364     {
2365       *constexpr_p = false;
2366       if (diag)
2367         {
2368           inform (DECL_SOURCE_LOCATION (fn),
2369                   SFK_DTOR_P (sfk)
2370                   ? G_("defaulted destructor calls non-%<constexpr%> %qD")
2371                   : G_("defaulted constructor calls non-%<constexpr%> %qD"),
2372                   fn);
2373           explain_invalid_constexpr_fn (fn);
2374         }
2375     }
2376 }
2377
2378 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
2379    aggregates.  If DTOR_FROM_CTOR is true, we're walking subobject destructors
2380    called from a synthesized constructor, in which case we don't consider
2381    the triviality of the subobject destructor.  */
2382
2383 static void
2384 walk_field_subobs (tree fields, special_function_kind sfk, tree fnname,
2385                    int quals, tree *spec_p, bool *trivial_p,
2386                    bool *deleted_p, bool *constexpr_p,
2387                    bool diag, int flags, tsubst_flags_t complain,
2388                    bool dtor_from_ctor)
2389 {
2390   if (!fields)
2391     return;
2392
2393   tree ctx = DECL_CONTEXT (fields);
2394
2395   /* CWG2084: A defaulted default ctor for a union with a DMI only initializes
2396      that member, so don't check other members.  */
2397   enum { unknown, no, yes }
2398   only_dmi_mem = (sfk == sfk_constructor && TREE_CODE (ctx) == UNION_TYPE
2399                   ? unknown : no);
2400
2401  again:
2402   for (tree field = fields; field; field = DECL_CHAIN (field))
2403     {
2404       tree mem_type, argtype, rval;
2405
2406       if (TREE_CODE (field) != FIELD_DECL
2407           || DECL_ARTIFICIAL (field)
2408           || DECL_UNNAMED_BIT_FIELD (field))
2409         continue;
2410
2411       /* Variant members only affect deletedness.  In particular, they don't
2412          affect the exception-specification of a user-provided destructor,
2413          which we're figuring out via get_defaulted_eh_spec.  So if we aren't
2414          asking if this is deleted, don't even look up the function; we don't
2415          want an error about a deleted function we aren't actually calling.  */
2416       if (sfk == sfk_destructor && deleted_p == NULL
2417           && TREE_CODE (ctx) == UNION_TYPE)
2418         break;
2419
2420       if (only_dmi_mem != no)
2421         {
2422           if (DECL_INITIAL (field))
2423             only_dmi_mem = yes;
2424           else
2425             /* Don't check this until we know there's no DMI.  */
2426             continue;
2427         }
2428
2429       mem_type = strip_array_types (TREE_TYPE (field));
2430       if (SFK_ASSIGN_P (sfk))
2431         {
2432           bool bad = true;
2433           if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
2434             {
2435               if (diag)
2436                 error ("non-static const member %q#D, cannot use default "
2437                        "assignment operator", field);
2438             }
2439           else if (TYPE_REF_P (mem_type))
2440             {
2441               if (diag)
2442                 error ("non-static reference member %q#D, cannot use "
2443                        "default assignment operator", field);
2444             }
2445           else
2446             bad = false;
2447
2448           if (bad && deleted_p)
2449             *deleted_p = true;
2450         }
2451       else if (sfk == sfk_constructor || sfk == sfk_inheriting_constructor)
2452         {
2453           bool bad;
2454
2455           if (DECL_INITIAL (field))
2456             {
2457               if (diag && DECL_INITIAL (field) == error_mark_node)
2458                 inform (DECL_SOURCE_LOCATION (field),
2459                         "initializer for %q#D is invalid", field);
2460               if (trivial_p)
2461                 *trivial_p = false;
2462               /* Core 1351: If the field has an NSDMI that could throw, the
2463                  default constructor is noexcept(false).  */
2464               if (spec_p)
2465                 {
2466                   tree nsdmi = get_nsdmi (field, /*ctor*/false, complain);
2467                   if (nsdmi == error_mark_node)
2468                     *spec_p = error_mark_node;
2469                   else if (*spec_p != error_mark_node
2470                            && !expr_noexcept_p (nsdmi, tf_none))
2471                     *spec_p = noexcept_false_spec;
2472                 }
2473               /* Don't do the normal processing.  */
2474               continue;
2475             }
2476
2477           bad = false;
2478           if (CP_TYPE_CONST_P (mem_type)
2479               && default_init_uninitialized_part (mem_type))
2480             {
2481               if (diag)
2482                 {
2483                   error ("uninitialized const member in %q#T",
2484                          current_class_type);
2485                   inform (DECL_SOURCE_LOCATION (field),
2486                           "%q#D should be initialized", field);
2487                 }
2488               bad = true;
2489             }
2490           else if (TYPE_REF_P (mem_type))
2491             {
2492               if (diag)
2493                 {
2494                   error ("uninitialized reference member in %q#T",
2495                          current_class_type);
2496                   inform (DECL_SOURCE_LOCATION (field),
2497                           "%q#D should be initialized", field);
2498                 }
2499               bad = true;
2500             }
2501
2502           if (bad && deleted_p)
2503             *deleted_p = true;
2504
2505           /* Before C++20, for an implicitly-defined default constructor to
2506              be constexpr, every member must have a user-provided default
2507              constructor or an explicit initializer.  */
2508           if (constexpr_p
2509               && cxx_dialect < cxx20
2510               && !CLASS_TYPE_P (mem_type)
2511               && TREE_CODE (ctx) != UNION_TYPE)
2512             {
2513               *constexpr_p = false;
2514               if (diag)
2515                 inform (DECL_SOURCE_LOCATION (field),
2516                         "defaulted default constructor does not "
2517                         "initialize %q#D", field);
2518             }
2519         }
2520       else if (sfk == sfk_copy_constructor)
2521         {
2522           /* 12.8p11b5 */
2523           if (TYPE_REF_P (mem_type)
2524               && TYPE_REF_IS_RVALUE (mem_type))
2525             {
2526               if (diag)
2527                 error ("copying non-static data member %q#D of rvalue "
2528                        "reference type", field);
2529               if (deleted_p)
2530                 *deleted_p = true;
2531             }
2532         }
2533
2534       if (!CLASS_TYPE_P (mem_type))
2535         continue;
2536
2537       if (ANON_AGGR_TYPE_P (mem_type))
2538         {
2539           walk_field_subobs (TYPE_FIELDS (mem_type), sfk, fnname, quals,
2540                              spec_p, trivial_p, deleted_p, constexpr_p,
2541                              diag, flags, complain, dtor_from_ctor);
2542           continue;
2543         }
2544
2545       if (SFK_COPY_P (sfk) || SFK_MOVE_P (sfk))
2546         {
2547           int mem_quals = cp_type_quals (mem_type) | quals;
2548           if (DECL_MUTABLE_P (field))
2549             mem_quals &= ~TYPE_QUAL_CONST;
2550           argtype = build_stub_type (mem_type, mem_quals, SFK_MOVE_P (sfk));
2551         }
2552       else
2553         argtype = NULL_TREE;
2554
2555       rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
2556
2557       process_subob_fn (rval, sfk, spec_p, trivial_p, deleted_p,
2558                         constexpr_p, diag, field, dtor_from_ctor);
2559     }
2560
2561   /* We didn't find a DMI in this union, now check all the members.  */
2562   if (only_dmi_mem == unknown)
2563     {
2564       only_dmi_mem = no;
2565       goto again;
2566     }
2567 }
2568
2569 /* Base walker helper for synthesized_method_walk.  Inspect a direct
2570    or virtual base.  BINFO is the parent type's binfo.  BASE_BINFO is
2571    the base binfo of interests.  All other parms are as for
2572    synthesized_method_walk, or its local vars.  */
2573
2574 static tree
2575 synthesized_method_base_walk (tree binfo, tree base_binfo,
2576                               special_function_kind sfk, tree fnname, int quals,
2577                               tree *inheriting_ctor, tree inherited_parms,
2578                               int flags, bool diag,
2579                               tree *spec_p, bool *trivial_p,
2580                               bool *deleted_p, bool *constexpr_p)
2581 {
2582   bool inherited_binfo = false;
2583   tree argtype = NULL_TREE;
2584   deferring_kind defer = dk_no_deferred;
2585
2586   if (SFK_COPY_P (sfk) || SFK_MOVE_P (sfk))
2587     argtype = build_stub_type (BINFO_TYPE (base_binfo), quals, SFK_MOVE_P (sfk));
2588   else if (inheriting_ctor
2589            && (inherited_binfo
2590                = binfo_inherited_from (binfo, base_binfo, *inheriting_ctor)))
2591     {
2592       argtype = inherited_parms;
2593       /* Don't check access on the inherited constructor.  */
2594       if (flag_new_inheriting_ctors)
2595         defer = dk_deferred;
2596     }
2597   else if (cxx_dialect >= cxx14 && sfk == sfk_virtual_destructor
2598            && BINFO_VIRTUAL_P (base_binfo)
2599            && ABSTRACT_CLASS_TYPE_P (BINFO_TYPE (binfo)))
2600     /* Don't check access when looking at vbases of abstract class's
2601        virtual destructor.  */
2602     defer = dk_no_check;
2603
2604   if (defer != dk_no_deferred)
2605     push_deferring_access_checks (defer);
2606   tree rval = locate_fn_flags (base_binfo, fnname, argtype, flags,
2607                                diag ? tf_warning_or_error : tf_none);
2608   if (defer != dk_no_deferred)
2609     pop_deferring_access_checks ();
2610
2611   /* Replace an inherited template with the appropriate specialization.  */
2612   if (inherited_binfo && rval
2613       && DECL_P (*inheriting_ctor) && DECL_P (rval)
2614       && DECL_CONTEXT (*inheriting_ctor) == DECL_CONTEXT (rval))
2615     *inheriting_ctor = DECL_CLONED_FUNCTION (rval);
2616
2617   process_subob_fn (rval, sfk, spec_p, trivial_p, deleted_p,
2618                     constexpr_p, diag, BINFO_TYPE (base_binfo));
2619   if (SFK_CTOR_P (sfk)
2620       && (!BINFO_VIRTUAL_P (base_binfo)
2621           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))))
2622     {
2623       /* In a constructor we also need to check the subobject
2624          destructors for cleanup of partially constructed objects.  */
2625       tree dtor = locate_fn_flags (base_binfo, complete_dtor_identifier,
2626                                    NULL_TREE, flags,
2627                                    diag ? tf_warning_or_error : tf_none);
2628       /* Note that we don't pass down trivial_p; the subobject
2629          destructors don't affect triviality of the constructor.  Nor
2630          do they affect constexpr-ness (a constant expression doesn't
2631          throw) or exception-specification (a throw from one of the
2632          dtors would be a double-fault).  */
2633       process_subob_fn (dtor, sfk, NULL, NULL, deleted_p, NULL, false,
2634                         BINFO_TYPE (base_binfo), /*dtor_from_ctor*/true);
2635     }
2636
2637   return rval;
2638 }
2639
2640 /* The caller wants to generate an implicit declaration of SFK for
2641    CTYPE which is const if relevant and CONST_P is set.  If SPEC_P,
2642    TRIVIAL_P, DELETED_P or CONSTEXPR_P are non-null, set their
2643    referent appropriately.  If DIAG is true, we're either being called
2644    from maybe_explain_implicit_delete to give errors, or if
2645    CONSTEXPR_P is non-null, from explain_invalid_constexpr_fn.  */
2646
2647 static void
2648 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
2649                          tree *spec_p, bool *trivial_p, bool *deleted_p,
2650                          bool *constexpr_p, bool diag,
2651                          tree *inheriting_ctor, tree inherited_parms)
2652 {
2653   tree binfo, base_binfo;
2654   int i;
2655
2656   /* SFK must be exactly one category.  */
2657   gcc_checking_assert (SFK_DTOR_P(sfk) + SFK_CTOR_P(sfk)
2658                        + SFK_ASSIGN_P(sfk) == 1);
2659
2660   if (spec_p)
2661     *spec_p = (cxx_dialect >= cxx11 ? noexcept_true_spec : empty_except_spec);
2662
2663   if (deleted_p)
2664     {
2665       /* "The closure type associated with a lambda-expression has a deleted
2666          default constructor and a deleted copy assignment operator."
2667          This is diagnosed in maybe_explain_implicit_delete.
2668          In C++20, only lambda-expressions with lambda-captures have those
2669          deleted.  */
2670       if (LAMBDA_TYPE_P (ctype)
2671           && (sfk == sfk_constructor || sfk == sfk_copy_assignment)
2672           && (cxx_dialect < cxx20
2673               || LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (ctype))
2674               || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE
2675                                 (CLASSTYPE_LAMBDA_EXPR (ctype)) != CPLD_NONE))
2676         {
2677           *deleted_p = true;
2678           return;
2679         }
2680
2681       *deleted_p = false;
2682     }
2683
2684   bool check_vdtor = false;
2685   tree fnname;
2686
2687   if (SFK_DTOR_P (sfk))
2688     {
2689       check_vdtor = true;
2690       /* The synthesized method will call base dtors, but check complete
2691          here to avoid having to deal with VTT.  */
2692       fnname = complete_dtor_identifier;
2693     }
2694   else if (SFK_ASSIGN_P (sfk))
2695     fnname = assign_op_identifier;
2696   else
2697     fnname = complete_ctor_identifier;
2698
2699   gcc_assert ((sfk == sfk_inheriting_constructor)
2700               == (inheriting_ctor && *inheriting_ctor != NULL_TREE));
2701
2702   /* If that user-written default constructor would satisfy the
2703      requirements of a constexpr constructor (7.1.5), the
2704      implicitly-defined default constructor is constexpr.
2705
2706      C++20:
2707      The implicitly-defined copy/move assignment operator is constexpr if
2708       - X is a literal type, and
2709       - the assignment operator selected to copy/move each direct base class
2710         subobject is a constexpr function, and
2711       - for each non-static data member of X that is of class type (or array
2712         thereof), the assignment operator selected to copy/move that
2713         member is a constexpr function.
2714
2715       C++23:
2716       The implicitly-defined copy/move assignment operator is constexpr.  */
2717   if (constexpr_p)
2718     *constexpr_p = (SFK_CTOR_P (sfk)
2719                     || (SFK_ASSIGN_P (sfk) && cxx_dialect >= cxx14)
2720                     || (SFK_DTOR_P (sfk) && cxx_dialect >= cxx20));
2721
2722   bool expected_trivial = type_has_trivial_fn (ctype, sfk);
2723   if (trivial_p)
2724     *trivial_p = expected_trivial;
2725
2726   /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
2727      class versions and other properties of the type.  But a subobject
2728      class can be trivially copyable and yet have overload resolution
2729      choose a template constructor for initialization, depending on
2730      rvalueness and cv-quals.  And furthermore, a member in a base might
2731      be trivial but deleted or otherwise not callable.  So we can't exit
2732      early in C++0x.  The same considerations apply in C++98/03, but
2733      there the definition of triviality does not consider overload
2734      resolution, so a constructor can be trivial even if it would otherwise
2735      call a non-trivial constructor.  */
2736   if (expected_trivial
2737       && (!(SFK_COPY_P (sfk) || SFK_MOVE_P (sfk)) || cxx_dialect < cxx11))
2738     {
2739       if (constexpr_p && sfk == sfk_constructor)
2740         {
2741           bool cx = trivial_default_constructor_is_constexpr (ctype);
2742           *constexpr_p = cx;
2743           if (diag && !cx && TREE_CODE (ctype) == UNION_TYPE)
2744             /* A trivial constructor doesn't have any NSDMI.  */
2745             inform (input_location, "defaulted default constructor does "
2746                     "not initialize any non-static data member");
2747         }
2748       if (!diag && cxx_dialect < cxx11)
2749         return;
2750     }
2751
2752   ++cp_unevaluated_operand;
2753   ++c_inhibit_evaluation_warnings;
2754   push_deferring_access_checks (dk_no_deferred);
2755
2756   tree scope = push_scope (ctype);
2757
2758   int flags = LOOKUP_NORMAL | LOOKUP_SPECULATIVE;
2759   if (sfk != sfk_inheriting_constructor)
2760     flags |= LOOKUP_DEFAULTED;
2761
2762   tsubst_flags_t complain = diag ? tf_warning_or_error : tf_none;
2763   if (diag && spec_p)
2764     /* We're in get_defaulted_eh_spec; we don't actually want any walking
2765        diagnostics, we just want complain set.  */
2766     diag = false;
2767   int quals = const_p ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED;
2768
2769   for (binfo = TYPE_BINFO (ctype), i = 0;
2770        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
2771     {
2772       if (!SFK_ASSIGN_P (sfk) && BINFO_VIRTUAL_P (base_binfo))
2773         /* We'll handle virtual bases below.  */
2774         continue;
2775
2776       tree fn = synthesized_method_base_walk (binfo, base_binfo,
2777                                               sfk, fnname, quals,
2778                                               inheriting_ctor, inherited_parms,
2779                                               flags, diag, spec_p, trivial_p,
2780                                               deleted_p, constexpr_p);
2781
2782       if (diag && SFK_ASSIGN_P (sfk) && SFK_MOVE_P (sfk)
2783           && BINFO_VIRTUAL_P (base_binfo)
2784           && fn && TREE_CODE (fn) == FUNCTION_DECL
2785           && move_fn_p (fn) && !trivial_fn_p (fn)
2786           && vbase_has_user_provided_move_assign (BINFO_TYPE (base_binfo)))
2787         warning (OPT_Wvirtual_move_assign,
2788                  "defaulted move assignment for %qT calls a non-trivial "
2789                  "move assignment operator for virtual base %qT",
2790                  ctype, BINFO_TYPE (base_binfo));
2791
2792       if (check_vdtor && type_has_virtual_destructor (BINFO_TYPE (base_binfo)))
2793         {
2794           /* Unlike for base ctor/op=/dtor, for operator delete it's fine
2795              to have a null fn (no class-specific op delete).  */
2796           fn = locate_fn_flags (ctype, ovl_op_identifier (false, DELETE_EXPR),
2797                                 ptr_type_node, flags, tf_none);
2798           if (fn && fn == error_mark_node)
2799             {
2800               if (complain & tf_error)
2801                 locate_fn_flags (ctype, ovl_op_identifier (false, DELETE_EXPR),
2802                                  ptr_type_node, flags, complain);
2803               if (deleted_p)
2804                 *deleted_p = true;
2805             }
2806           check_vdtor = false;
2807         }
2808     }
2809
2810   vec<tree, va_gc> *vbases = CLASSTYPE_VBASECLASSES (ctype);
2811   if (SFK_ASSIGN_P (sfk))
2812     /* Already examined vbases above.  */;
2813   else if (vec_safe_is_empty (vbases))
2814     /* No virtual bases to worry about.  */;
2815   else if (ABSTRACT_CLASS_TYPE_P (ctype) && cxx_dialect >= cxx14
2816            /* DR 1658 specifies that vbases of abstract classes are
2817               ignored for both ctors and dtors.  Except DR 2336
2818               overrides that skipping when determing the eh-spec of a
2819               virtual destructor.  */
2820            && sfk != sfk_virtual_destructor)
2821     /* Vbase cdtors are not relevant.  */;
2822   else
2823     {
2824       if (constexpr_p)
2825         *constexpr_p = false;
2826
2827       FOR_EACH_VEC_ELT (*vbases, i, base_binfo)
2828         synthesized_method_base_walk (binfo, base_binfo, sfk, fnname, quals,
2829                                       inheriting_ctor, inherited_parms,
2830                                       flags, diag,
2831                                       spec_p, trivial_p, deleted_p, constexpr_p);
2832     }
2833
2834   /* Now handle the non-static data members.  */
2835   walk_field_subobs (TYPE_FIELDS (ctype), sfk, fnname, quals,
2836                      spec_p, trivial_p, deleted_p, constexpr_p,
2837                      diag, flags, complain, /*dtor_from_ctor*/false);
2838   if (SFK_CTOR_P (sfk))
2839     walk_field_subobs (TYPE_FIELDS (ctype), sfk_destructor,
2840                        complete_dtor_identifier, TYPE_UNQUALIFIED,
2841                        NULL, NULL, deleted_p, NULL,
2842                        false, flags, complain, /*dtor_from_ctor*/true);
2843
2844   pop_scope (scope);
2845
2846   pop_deferring_access_checks ();
2847   --cp_unevaluated_operand;
2848   --c_inhibit_evaluation_warnings;
2849 }
2850
2851 /* DECL is a defaulted function whose exception specification is now
2852    needed.  Return what it should be.  */
2853
2854 tree
2855 get_defaulted_eh_spec (tree decl, tsubst_flags_t complain)
2856 {
2857   /* For DECL_MAYBE_DELETED this should already have been handled by
2858      synthesize_method.  */
2859   gcc_assert (!DECL_MAYBE_DELETED (decl));
2860
2861   if (DECL_CLONED_FUNCTION_P (decl))
2862     decl = DECL_CLONED_FUNCTION (decl);
2863   special_function_kind sfk = special_function_p (decl);
2864   tree ctype = DECL_CONTEXT (decl);
2865   tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
2866   tree parm_type = TREE_VALUE (parms);
2867   bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
2868   tree spec = empty_except_spec;
2869   bool diag = !DECL_DELETED_FN (decl) && (complain & tf_error);
2870   tree inh = DECL_INHERITED_CTOR (decl);
2871   if (SFK_DTOR_P (sfk) && DECL_VIRTUAL_P (decl))
2872     /* We have to examine virtual bases even if abstract.  */
2873     sfk = sfk_virtual_destructor;
2874   bool pushed = false;
2875   if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2876     pushed = push_tinst_level (decl);
2877   synthesized_method_walk (ctype, sfk, const_p, &spec, NULL, NULL,
2878                            NULL, diag, &inh, parms);
2879   if (pushed)
2880     pop_tinst_level ();
2881   return spec;
2882 }
2883
2884 /* DECL is a deleted function.  If it's implicitly deleted, explain why and
2885    return true; else return false.  */
2886
2887 bool
2888 maybe_explain_implicit_delete (tree decl)
2889 {
2890   /* If decl is a clone, get the primary variant.  */
2891   decl = DECL_ORIGIN (decl);
2892   gcc_assert (DECL_DELETED_FN (decl));
2893   if (DECL_DEFAULTED_FN (decl))
2894     {
2895       /* Not marked GTY; it doesn't need to be GC'd or written to PCH.  */
2896       static hash_set<tree> *explained;
2897
2898       special_function_kind sfk;
2899       location_t loc;
2900       bool informed;
2901       tree ctype;
2902
2903       if (!explained)
2904         explained = new hash_set<tree>;
2905       if (explained->add (decl))
2906         return true;
2907
2908       sfk = special_function_p (decl);
2909       ctype = DECL_CONTEXT (decl);
2910       loc = input_location;
2911       input_location = DECL_SOURCE_LOCATION (decl);
2912
2913       informed = false;
2914       if (LAMBDA_TYPE_P (ctype))
2915         {
2916           informed = true;
2917           if (sfk == sfk_constructor)
2918             inform (DECL_SOURCE_LOCATION (decl),
2919                     "a lambda closure type has a deleted default constructor");
2920           else if (sfk == sfk_copy_assignment)
2921             inform (DECL_SOURCE_LOCATION (decl),
2922                     "a lambda closure type has a deleted copy assignment operator");
2923           else
2924             informed = false;
2925         }
2926       else if (DECL_ARTIFICIAL (decl)
2927                && (sfk == sfk_copy_assignment || sfk == sfk_copy_constructor)
2928                && classtype_has_move_assign_or_move_ctor_p (ctype, true))
2929         {
2930           inform (DECL_SOURCE_LOCATION (decl),
2931                   "%q#D is implicitly declared as deleted because %qT "
2932                   "declares a move constructor or move assignment operator",
2933                   decl, ctype);
2934           informed = true;
2935         }
2936       else if (sfk == sfk_inheriting_constructor)
2937         {
2938           tree binfo = inherited_ctor_binfo (decl);
2939           if (TREE_CODE (binfo) != TREE_BINFO)
2940             {
2941               inform (DECL_SOURCE_LOCATION (decl),
2942                       "%q#D inherits from multiple base subobjects",
2943                       decl);
2944               informed = true;
2945             }
2946         }
2947       if (!informed && sfk == sfk_comparison)
2948         {
2949           inform (DECL_SOURCE_LOCATION (decl),
2950                   "%q#D is implicitly deleted because the default "
2951                   "definition would be ill-formed:", decl);
2952           build_comparison_op (decl, false, tf_warning_or_error);
2953         }
2954       else if (!informed)
2955         {
2956           tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
2957           bool const_p = false;
2958           if (parms)
2959             {
2960               tree parm_type = TREE_VALUE (parms);
2961               const_p = CP_TYPE_CONST_P (non_reference (parm_type));
2962             }
2963           tree raises = NULL_TREE;
2964           bool deleted_p = false;
2965           tree scope = push_scope (ctype);
2966           tree inh = DECL_INHERITED_CTOR (decl);
2967
2968           synthesized_method_walk (ctype, sfk, const_p,
2969                                    &raises, NULL, &deleted_p, NULL, false,
2970                                    &inh, parms);
2971           if (deleted_p)
2972             {
2973               inform (DECL_SOURCE_LOCATION (decl),
2974                       "%q#D is implicitly deleted because the default "
2975                       "definition would be ill-formed:", decl);
2976               synthesized_method_walk (ctype, sfk, const_p,
2977                                        NULL, NULL, &deleted_p, NULL, true,
2978                                        &inh, parms);
2979             }
2980           else if (!comp_except_specs
2981                    (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
2982                     raises, ce_normal))
2983             inform (DECL_SOURCE_LOCATION (decl), "%q#F is implicitly "
2984                     "deleted because its exception-specification does not "
2985                     "match the implicit exception-specification %qX",
2986                     decl, raises);
2987           else if (flag_checking)
2988             gcc_unreachable ();
2989
2990           pop_scope (scope);
2991         }
2992
2993       input_location = loc;
2994       return true;
2995     }
2996   return false;
2997 }
2998
2999 /* DECL is a defaulted function which was declared constexpr.  Explain why
3000    it can't be constexpr.  */
3001
3002 void
3003 explain_implicit_non_constexpr (tree decl)
3004 {
3005   tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
3006   bool const_p = CP_TYPE_CONST_P (non_reference (TREE_VALUE (parms)));
3007   tree inh = DECL_INHERITED_CTOR (decl);
3008   bool dummy;
3009   special_function_kind sfk = special_function_p (decl);
3010   if (sfk == sfk_comparison)
3011     {
3012       DECL_DECLARED_CONSTEXPR_P (decl) = true;
3013       build_comparison_op (decl, false, tf_warning_or_error);
3014       DECL_DECLARED_CONSTEXPR_P (decl) = false;
3015     }
3016   else
3017     synthesized_method_walk (DECL_CLASS_CONTEXT (decl),
3018                              sfk, const_p,
3019                              NULL, NULL, NULL, &dummy, true,
3020                              &inh, parms);
3021 }
3022
3023 /* DECL is an instantiation of an inheriting constructor template.  Deduce
3024    the correct exception-specification and deletedness for this particular
3025    specialization.  Return true if the deduction succeeds; false otherwise.  */
3026
3027 bool
3028 deduce_inheriting_ctor (tree decl)
3029 {
3030   decl = DECL_ORIGIN (decl);
3031   gcc_assert (DECL_INHERITED_CTOR (decl));
3032   tree spec;
3033   bool trivial, constexpr_, deleted;
3034   tree inh = DECL_INHERITED_CTOR (decl);
3035   synthesized_method_walk (DECL_CONTEXT (decl), sfk_inheriting_constructor,
3036                            false, &spec, &trivial, &deleted, &constexpr_,
3037                            /*diag*/false,
3038                            &inh,
3039                            FUNCTION_FIRST_USER_PARMTYPE (decl));
3040   if (spec == error_mark_node)
3041     return false;
3042   if (TREE_CODE (inherited_ctor_binfo (decl)) != TREE_BINFO)
3043     /* Inherited the same constructor from different base subobjects.  */
3044     deleted = true;
3045   DECL_DELETED_FN (decl) = deleted;
3046   TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl), spec);
3047   SET_DECL_INHERITED_CTOR (decl, inh);
3048
3049   tree clone;
3050   FOR_EACH_CLONE (clone, decl)
3051     {
3052       DECL_DELETED_FN (clone) = deleted;
3053       TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone), spec);
3054       SET_DECL_INHERITED_CTOR (clone, inh);
3055     }
3056
3057   return true;
3058 }
3059
3060 /* Implicitly declare the special function indicated by KIND, as a
3061    member of TYPE.  For copy constructors and assignment operators,
3062    CONST_P indicates whether these functions should take a const
3063    reference argument or a non-const reference.
3064    Returns the FUNCTION_DECL for the implicitly declared function.  */
3065
3066 tree
3067 implicitly_declare_fn (special_function_kind kind, tree type,
3068                        bool const_p, tree pattern_fn,
3069                        tree inherited_parms)
3070 {
3071   tree fn;
3072   tree parameter_types = void_list_node;
3073   tree return_type;
3074   tree fn_type;
3075   tree raises = empty_except_spec;
3076   tree rhs_parm_type = NULL_TREE;
3077   tree this_parm;
3078   tree name;
3079   HOST_WIDE_INT saved_processing_template_decl;
3080   bool deleted_p = false;
3081   bool constexpr_p = false;
3082   tree inherited_ctor = (kind == sfk_inheriting_constructor
3083                          ? pattern_fn : NULL_TREE);
3084
3085   /* Because we create declarations for implicitly declared functions
3086      lazily, we may be creating the declaration for a member of TYPE
3087      while in some completely different context.  However, TYPE will
3088      never be a dependent class (because we never want to do lookups
3089      for implicitly defined functions in a dependent class).  */
3090   gcc_assert (!dependent_type_p (type));
3091
3092   /* If the member-specification does not explicitly declare any member or
3093      friend named operator==, an == operator function is declared
3094      implicitly for each three-way comparison operator function defined as
3095      defaulted in the member-specification, with the same access and
3096      function-definition and in the same class scope as the respective
3097      three-way comparison operator function, except that the return type is
3098      replaced with bool and the declarator-id is replaced with
3099      operator==.
3100
3101      [Note: Such an implicitly-declared == operator for a class X is
3102      defined as defaulted in the definition of X and has the same
3103      parameter-declaration-clause and trailing requires-clause as the
3104      respective three-way comparison operator. It is declared with friend,
3105      virtual, constexpr, or consteval if the three-way comparison operator
3106      function is so declared. If the three-way comparison operator function
3107      has no noexcept-specifier, the implicitly-declared == operator
3108      function has an implicit exception specification (14.5) that may
3109      differ from the implicit exception specification of the three-way
3110      comparison operator function. --end note]  */
3111   if (kind == sfk_comparison)
3112     {
3113       fn = copy_operator_fn (pattern_fn, EQ_EXPR);
3114       DECL_ARTIFICIAL (fn) = 1;
3115       apply_deduced_return_type (fn, boolean_type_node);
3116       return fn;
3117     }
3118
3119   /* Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
3120      because we only create clones for constructors and destructors
3121      when not in a template.  */
3122   saved_processing_template_decl = processing_template_decl;
3123   processing_template_decl = 0;
3124
3125   type = TYPE_MAIN_VARIANT (type);
3126
3127   if (targetm.cxx.cdtor_returns_this ())
3128     {
3129       if (kind == sfk_destructor)
3130         /* See comment in check_special_function_return_type.  */
3131         return_type = build_pointer_type (void_type_node);
3132       else
3133         return_type = build_pointer_type (type);
3134     }
3135   else
3136     return_type = void_type_node;
3137
3138   int this_quals = TYPE_UNQUALIFIED;
3139   switch (kind)
3140     {
3141     case sfk_destructor:
3142       /* Destructor.  */
3143       name = dtor_identifier;
3144       break;
3145
3146     case sfk_constructor:
3147       /* Default constructor.  */
3148       name = ctor_identifier;
3149       break;
3150
3151     case sfk_copy_constructor:
3152     case sfk_copy_assignment:
3153     case sfk_move_constructor:
3154     case sfk_move_assignment:
3155     case sfk_inheriting_constructor:
3156     {
3157       if (kind == sfk_copy_assignment
3158           || kind == sfk_move_assignment)
3159         {
3160           return_type = build_reference_type (type);
3161           name = assign_op_identifier;
3162         }
3163       else
3164         name = ctor_identifier;
3165
3166       if (kind == sfk_inheriting_constructor)
3167         parameter_types = inherited_parms;
3168       else
3169         {
3170           if (const_p)
3171             rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
3172           else
3173             rhs_parm_type = type;
3174           bool move_p = (kind == sfk_move_assignment
3175                          || kind == sfk_move_constructor);
3176           rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
3177
3178           parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
3179         }
3180       break;
3181     }
3182
3183     default:
3184       gcc_unreachable ();
3185     }
3186
3187   bool trivial_p = false;
3188
3189   if (inherited_ctor)
3190     {
3191       /* For an inheriting constructor, just copy these flags from the
3192          inherited constructor until deduce_inheriting_ctor.  */
3193       raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (inherited_ctor));
3194       deleted_p = DECL_DELETED_FN (inherited_ctor);
3195       constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
3196     }
3197   else if (cxx_dialect >= cxx11)
3198     {
3199       raises = noexcept_deferred_spec;
3200       synthesized_method_walk (type, kind, const_p, NULL, &trivial_p,
3201                                &deleted_p, &constexpr_p, false,
3202                                &inherited_ctor, inherited_parms);
3203     }
3204   else
3205     synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
3206                              &deleted_p, &constexpr_p, false,
3207                              &inherited_ctor, inherited_parms);
3208   /* Don't bother marking a deleted constructor as constexpr.  */
3209   if (deleted_p)
3210     constexpr_p = false;
3211   /* A trivial copy/move constructor is also a constexpr constructor,
3212      unless the class has virtual bases (7.1.5p4).  */
3213   else if (trivial_p
3214            && cxx_dialect >= cxx11
3215            && (kind == sfk_copy_constructor
3216                || kind == sfk_move_constructor)
3217            && !CLASSTYPE_VBASECLASSES (type))
3218     gcc_assert (constexpr_p);
3219
3220   if (!trivial_p && type_has_trivial_fn (type, kind))
3221     type_set_nontrivial_flag (type, kind);
3222
3223   /* Create the function.  */
3224   tree this_type = cp_build_qualified_type (type, this_quals);
3225   fn_type = build_method_type_directly (this_type, return_type,
3226                                         parameter_types);
3227
3228   if (raises)
3229     {
3230       if (raises != error_mark_node)
3231         fn_type = build_exception_variant (fn_type, raises);
3232       else
3233         {
3234           /* Can happen, e.g., in C++98 mode for an ill-formed non-static data
3235              member initializer (c++/89914).  Also, in C++98, we might have
3236              failed to deduce RAISES, so try again but complain this time.  */
3237           if (cxx_dialect < cxx11)
3238             synthesized_method_walk (type, kind, const_p, &raises, nullptr,
3239                                      nullptr, nullptr, /*diag=*/true,
3240                                      &inherited_ctor, inherited_parms);
3241           /* We should have seen an error at this point.  */
3242           gcc_assert (seen_error ());
3243         }
3244     }
3245   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
3246   if (kind != sfk_inheriting_constructor)
3247     DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
3248
3249   if (IDENTIFIER_OVL_OP_P (name))
3250     {
3251       const ovl_op_info_t *op = IDENTIFIER_OVL_OP_INFO (name);
3252       DECL_OVERLOADED_OPERATOR_CODE_RAW (fn) = op->ovl_op_code;
3253     }
3254   else if (IDENTIFIER_CTOR_P (name))
3255     DECL_CXX_CONSTRUCTOR_P (fn) = true;
3256   else if (IDENTIFIER_DTOR_P (name))
3257     DECL_CXX_DESTRUCTOR_P (fn) = true;
3258   else
3259     gcc_unreachable ();
3260
3261   SET_DECL_ALIGN (fn, MINIMUM_METHOD_BOUNDARY);
3262
3263   /* Create the explicit arguments.  */
3264   if (rhs_parm_type)
3265     {
3266       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
3267          want its type to be included in the mangled function
3268          name.  */
3269       tree decl = cp_build_parm_decl (fn, NULL_TREE, rhs_parm_type);
3270       TREE_READONLY (decl) = 1;
3271       retrofit_lang_decl (decl);
3272       DECL_PARM_INDEX (decl) = DECL_PARM_LEVEL (decl) = 1;
3273       DECL_ARGUMENTS (fn) = decl;
3274     }
3275   else if (kind == sfk_inheriting_constructor)
3276     {
3277       tree *p = &DECL_ARGUMENTS (fn);
3278       int index = 1;
3279       for (tree parm = inherited_parms; parm && parm != void_list_node;
3280            parm = TREE_CHAIN (parm))
3281         {
3282           *p = cp_build_parm_decl (fn, NULL_TREE, TREE_VALUE (parm));
3283           retrofit_lang_decl (*p);
3284           DECL_PARM_LEVEL (*p) = 1;
3285           DECL_PARM_INDEX (*p) = index++;
3286           p = &DECL_CHAIN (*p);
3287         }
3288       SET_DECL_INHERITED_CTOR (fn, inherited_ctor);
3289       DECL_NONCONVERTING_P (fn) = DECL_NONCONVERTING_P (inherited_ctor);
3290       /* A constructor so declared has the same access as the corresponding
3291          constructor in X.  */
3292       TREE_PRIVATE (fn) = TREE_PRIVATE (inherited_ctor);
3293       TREE_PROTECTED (fn) = TREE_PROTECTED (inherited_ctor);
3294       /* Copy constexpr from the inherited constructor even if the
3295          inheriting constructor doesn't satisfy the requirements.  */
3296       constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
3297       /* Also copy any attributes.  */
3298       DECL_ATTRIBUTES (fn) = clone_attrs (DECL_ATTRIBUTES (inherited_ctor));
3299     }
3300
3301   /* Add the "this" parameter.  */
3302   this_parm = build_this_parm (fn, fn_type, this_quals);
3303   DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
3304   DECL_ARGUMENTS (fn) = this_parm;
3305
3306   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
3307
3308   DECL_IN_AGGR_P (fn) = 1;
3309   DECL_ARTIFICIAL (fn) = 1;
3310   DECL_DEFAULTED_FN (fn) = 1;
3311   if (cxx_dialect >= cxx11)
3312     {
3313       DECL_DELETED_FN (fn) = deleted_p;
3314       DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
3315     }
3316   DECL_EXTERNAL (fn) = true;
3317   DECL_NOT_REALLY_EXTERN (fn) = 1;
3318   DECL_DECLARED_INLINE_P (fn) = 1;
3319   set_linkage_according_to_type (type, fn);
3320   if (TREE_PUBLIC (fn))
3321     DECL_COMDAT (fn) = 1;
3322   rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
3323   gcc_assert (!TREE_USED (fn));
3324
3325   /* Propagate constraints from the inherited constructor. */
3326   if (flag_concepts && inherited_ctor)
3327     if (tree orig_ci = get_constraints (inherited_ctor))
3328       {
3329         tree new_ci = copy_node (orig_ci);
3330         set_constraints (fn, new_ci);
3331       }
3332
3333   /* Restore PROCESSING_TEMPLATE_DECL.  */
3334   processing_template_decl = saved_processing_template_decl;
3335
3336   if (inherited_ctor && TREE_CODE (inherited_ctor) == TEMPLATE_DECL)
3337     fn = add_inherited_template_parms (fn, inherited_ctor);
3338
3339   /* Warn about calling a non-trivial move assignment in a virtual base.  */
3340   if (kind == sfk_move_assignment && !deleted_p && !trivial_p
3341       && CLASSTYPE_VBASECLASSES (type))
3342     {
3343       location_t loc = input_location;
3344       input_location = DECL_SOURCE_LOCATION (fn);
3345       synthesized_method_walk (type, kind, const_p,
3346                                NULL, NULL, NULL, NULL, true,
3347                                NULL, NULL_TREE);
3348       input_location = loc;
3349     }
3350
3351   return fn;
3352 }
3353
3354 /* Gives any errors about defaulted functions which need to be deferred
3355    until the containing class is complete.  */
3356
3357 void
3358 defaulted_late_check (tree fn)
3359 {
3360   /* Complain about invalid signature for defaulted fn.  */
3361   tree ctx = DECL_CONTEXT (fn);
3362   special_function_kind kind = special_function_p (fn);
3363
3364   if (kind == sfk_comparison)
3365     {
3366       /* If the function was declared constexpr, check that the definition
3367          qualifies.  Otherwise we can define the function lazily.  */
3368       if (DECL_DECLARED_CONSTEXPR_P (fn) && !DECL_INITIAL (fn))
3369         {
3370           /* Prevent GC.  */
3371           function_depth++;
3372           synthesize_method (fn);
3373           function_depth--;
3374         }
3375       return;
3376     }
3377
3378   bool fn_const_p = (copy_fn_p (fn) == 2);
3379   tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p,
3380                                             NULL, NULL);
3381   tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
3382
3383   if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
3384                     TREE_TYPE (TREE_TYPE (implicit_fn)))
3385       || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
3386                      TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
3387     {
3388       error ("defaulted declaration %q+D does not match the "
3389              "expected signature", fn);
3390       inform (DECL_SOURCE_LOCATION (fn),
3391               "expected signature: %qD", implicit_fn);
3392     }
3393
3394   if (DECL_DELETED_FN (implicit_fn))
3395     {
3396       DECL_DELETED_FN (fn) = 1;
3397       return;
3398     }
3399
3400   /* If a function is explicitly defaulted on its first declaration without an
3401      exception-specification, it is implicitly considered to have the same
3402      exception-specification as if it had been implicitly declared.  */
3403   if (!TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
3404       && DECL_DEFAULTED_IN_CLASS_P (fn))
3405     TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
3406
3407   if (DECL_DEFAULTED_IN_CLASS_P (fn)
3408       && DECL_DECLARED_CONSTEXPR_P (implicit_fn))
3409     {
3410       /* Hmm...should we do this for out-of-class too? Should it be OK to
3411          add constexpr later like inline, rather than requiring
3412          declarations to match?  */
3413       DECL_DECLARED_CONSTEXPR_P (fn) = true;
3414       if (kind == sfk_constructor)
3415         TYPE_HAS_CONSTEXPR_CTOR (ctx) = true;
3416     }
3417
3418   if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
3419       && DECL_DECLARED_CONSTEXPR_P (fn))
3420     {
3421       if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
3422         {
3423           error ("explicitly defaulted function %q+D cannot be declared "
3424                  "%qs because the implicit declaration is not %qs:", fn,
3425                  DECL_IMMEDIATE_FUNCTION_P (fn) ? "consteval" : "constexpr",
3426                  "constexpr");
3427           explain_implicit_non_constexpr (fn);
3428         }
3429       DECL_DECLARED_CONSTEXPR_P (fn) = false;
3430     }
3431 }
3432
3433 /* Returns true iff FN can be explicitly defaulted, and gives any
3434    errors if defaulting FN is ill-formed.  */
3435
3436 bool
3437 defaultable_fn_check (tree fn)
3438 {
3439   special_function_kind kind = sfk_none;
3440
3441   if (template_parm_scope_p ())
3442     {
3443       error ("a template cannot be defaulted");
3444       return false;
3445     }
3446
3447   if (DECL_CONSTRUCTOR_P (fn))
3448     {
3449       if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
3450         kind = sfk_constructor;
3451       else if (copy_fn_p (fn) > 0
3452                && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
3453                    == void_list_node))
3454         kind = sfk_copy_constructor;
3455       else if (move_fn_p (fn))
3456         kind = sfk_move_constructor;
3457     }
3458   else if (DECL_DESTRUCTOR_P (fn))
3459     kind = sfk_destructor;
3460   else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
3461            && DECL_OVERLOADED_OPERATOR_IS (fn, NOP_EXPR))
3462     {
3463       if (copy_fn_p (fn))
3464         kind = sfk_copy_assignment;
3465       else if (move_fn_p (fn))
3466         kind = sfk_move_assignment;
3467     }
3468   else if (DECL_OVERLOADED_OPERATOR_CODE_RAW (fn) >= OVL_OP_EQ_EXPR
3469            && DECL_OVERLOADED_OPERATOR_CODE_RAW (fn) <= OVL_OP_SPACESHIP_EXPR)
3470     {
3471       kind = sfk_comparison;
3472       if (!early_check_defaulted_comparison (fn))
3473         return false;
3474     }
3475
3476   if (kind == sfk_none)
3477     {
3478       error ("%qD cannot be defaulted", fn);
3479       return false;
3480     }
3481   else
3482     {
3483       for (tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
3484            t && t != void_list_node; t = TREE_CHAIN (t))
3485         if (TREE_PURPOSE (t))
3486           {
3487             error ("defaulted function %q+D with default argument", fn);
3488             break;
3489           }
3490
3491       /* Avoid do_warn_unused_parameter warnings.  */
3492       for (tree p = FUNCTION_FIRST_USER_PARM (fn); p; p = DECL_CHAIN (p))
3493         if (DECL_NAME (p))
3494           suppress_warning (p, OPT_Wunused_parameter);
3495
3496       if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
3497         /* Defer checking.  */;
3498       else if (!processing_template_decl)
3499         defaulted_late_check (fn);
3500
3501       return true;
3502     }
3503 }
3504
3505 /* Add an implicit declaration to TYPE for the kind of function
3506    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
3507    declaration.  */
3508
3509 tree
3510 lazily_declare_fn (special_function_kind sfk, tree type)
3511 {
3512   tree fn;
3513   /* Whether or not the argument has a const reference type.  */
3514   bool const_p = false;
3515
3516   type = TYPE_MAIN_VARIANT (type);
3517
3518   switch (sfk)
3519     {
3520     case sfk_constructor:
3521       CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
3522       break;
3523     case sfk_copy_constructor:
3524       const_p = TYPE_HAS_CONST_COPY_CTOR (type);
3525       CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
3526       break;
3527     case sfk_move_constructor:
3528       CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
3529       break;
3530     case sfk_copy_assignment:
3531       const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
3532       CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
3533       break;
3534     case sfk_move_assignment:
3535       CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
3536       break;
3537     case sfk_destructor:
3538       CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
3539       break;
3540     default:
3541       gcc_unreachable ();
3542     }
3543
3544   /* Declare the function.  */
3545   fn = implicitly_declare_fn (sfk, type, const_p, NULL, NULL);
3546
3547   /* [class.copy]/8 If the class definition declares a move constructor or
3548      move assignment operator, the implicitly declared copy constructor is
3549      defined as deleted.... */
3550   if ((sfk == sfk_copy_assignment || sfk == sfk_copy_constructor)
3551       && cxx_dialect >= cxx11)
3552     {
3553       if (classtype_has_move_assign_or_move_ctor_p (type, true))
3554         DECL_DELETED_FN (fn) = true;
3555       else if (classtype_has_depr_implicit_copy (type))
3556         /* The implicit definition of a copy constructor as defaulted is
3557            deprecated if the class has a user-declared copy assignment operator
3558            or a user-declared destructor. The implicit definition of a copy
3559            assignment operator as defaulted is deprecated if the class has a
3560            user-declared copy constructor or a user-declared destructor (15.4,
3561            15.8).  */
3562         TREE_DEPRECATED (fn) = true;
3563     }
3564
3565   /* Destructors and assignment operators may be virtual.  */
3566   if (sfk == sfk_destructor
3567       || sfk == sfk_move_assignment
3568       || sfk == sfk_copy_assignment)
3569     check_for_override (fn, type);
3570
3571   /* Add it to the class  */
3572   bool added = add_method (type, fn, false);
3573   gcc_assert (added || errorcount);
3574
3575   /* Add it to TYPE_FIELDS.  */
3576   if (sfk == sfk_destructor
3577       && DECL_VIRTUAL_P (fn))
3578     /* The ABI requires that a virtual destructor go at the end of the
3579        vtable.  */
3580     TYPE_FIELDS (type) = chainon (TYPE_FIELDS (type), fn);
3581   else
3582     {
3583       DECL_CHAIN (fn) = TYPE_FIELDS (type);
3584       TYPE_FIELDS (type) = fn;
3585     }
3586   /* Propagate TYPE_FIELDS.  */
3587   fixup_type_variants (type);
3588
3589   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
3590   if (DECL_MAYBE_IN_CHARGE_CDTOR_P (fn))
3591     /* Create appropriate clones.  */
3592     clone_cdtor (fn, /*update_methods=*/true);
3593
3594   /* Classes, structs or unions TYPE marked with hotness attributes propagate
3595      the attribute to all methods.  This is typically done in
3596      check_bases_and_members, but we must also inject them here for deferred
3597      lazily-declared functions.  */
3598   maybe_propagate_warmth_attributes (fn, type);
3599
3600   return fn;
3601 }
3602
3603 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
3604    as there are artificial parms in FN.  */
3605
3606 tree
3607 skip_artificial_parms_for (const_tree fn, tree list)
3608 {
3609   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3610     list = TREE_CHAIN (list);
3611   else
3612     return list;
3613
3614   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
3615     list = TREE_CHAIN (list);
3616   if (DECL_HAS_VTT_PARM_P (fn))
3617     list = TREE_CHAIN (list);
3618   return list;
3619 }
3620
3621 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
3622    artificial parms in FN.  */
3623
3624 int
3625 num_artificial_parms_for (const_tree fn)
3626 {
3627   int count = 0;
3628
3629   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3630     count++;
3631   else
3632     return 0;
3633
3634   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
3635     count++;
3636   if (DECL_HAS_VTT_PARM_P (fn))
3637     count++;
3638   return count;
3639 }
3640
3641
3642 #include "gt-cp-method.h"