gcc/cp/method.c

   1 /* Handle the hair of processing (but not expanding) inline functions.
   2    Also manage function and variable name overloading.
   3    Copyright (C) 1987-2020 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.c.  */
  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, DECL_SECTION_NAME (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 /* True if we should omit all user-declared parameters from constructor FN,
 555    because it is a base clone of a ctor inherited from a virtual base.  */
 556
 557 bool
 558 ctor_omit_inherited_parms (tree fn)
 559 {
 560   if (!flag_new_inheriting_ctors)
 561     /* We only optimize away the parameters in the new model.  */
 562     return false;
 563   if (!DECL_BASE_CONSTRUCTOR_P (fn)
 564       || !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
 565     return false;
 566   if (FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (fn)) == void_list_node)
 567     /* No user-declared parameters to omit.  */
 568     return false;
 569   tree binfo = inherited_ctor_binfo (fn);
 570   for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo))
 571     if (BINFO_VIRTUAL_P (binfo))
 572       return true;
 573   return false;
 574 }
 575
 576 /* True iff constructor(s) INH inherited into BINFO initializes INIT_BINFO.
 577    This can be true for multiple virtual bases as well as one direct
 578    non-virtual base.  */
 579
 580 static bool
 581 binfo_inherited_from (tree binfo, tree init_binfo, tree inh)
 582 {
 583   /* inh is an OVERLOAD if we inherited the same constructor along
 584      multiple paths, check all of them.  */
 585   for (ovl_iterator iter (inh); iter; ++iter)
 586     {
 587       tree fn = *iter;
 588       tree base = DECL_CONTEXT (fn);
 589       tree base_binfo = NULL_TREE;
 590       for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 591         if (BINFO_TYPE (base_binfo) == base)
 592           break;
 593       if (base_binfo == init_binfo
 594           || (flag_new_inheriting_ctors
 595               && binfo_inherited_from (base_binfo, init_binfo,
 596                                        DECL_INHERITED_CTOR (fn))))
 597         return true;
 598     }
 599   return false;
 600 }
 601
 602 /* Subroutine of do_build_copy_constructor: Add a mem-initializer for BINFO
 603    given the parameter or parameters PARM, possibly inherited constructor
 604    base INH, or move flag MOVE_P.  */
 605
 606 static tree
 607 add_one_base_init (tree binfo, tree parm, bool move_p, tree inh,
 608                    tree member_init_list)
 609 {
 610   tree init;
 611   if (inh)
 612     {
 613       /* An inheriting constructor only has a mem-initializer for
 614          the base it inherits from.  */
 615       if (!binfo_inherited_from (TYPE_BINFO (current_class_type), binfo, inh))
 616         return member_init_list;
 617
 618       tree *p = &init;
 619       init = NULL_TREE;
 620       for (; parm; parm = DECL_CHAIN (parm))
 621         {
 622           tree exp = forward_parm (parm);
 623           *p = build_tree_list (NULL_TREE, exp);
 624           p = &TREE_CHAIN (*p);
 625         }
 626     }
 627   else
 628     {
 629       init = build_base_path (PLUS_EXPR, parm, binfo, 1,
 630                               tf_warning_or_error);
 631       if (move_p)
 632         init = move (init);
 633       init = build_tree_list (NULL_TREE, init);
 634     }
 635   return tree_cons (binfo, init, member_init_list);
 636 }
 637
 638 /* Generate code for default X(X&) or X(X&&) constructor or an inheriting
 639    constructor.  */
 640
 641 static void
 642 do_build_copy_constructor (tree fndecl)
 643 {
 644   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
 645   bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
 646   bool trivial = trivial_fn_p (fndecl);
 647   tree inh = DECL_INHERITED_CTOR (fndecl);
 648
 649   if (!inh)
 650     parm = convert_from_reference (parm);
 651
 652   if (trivial)
 653     {
 654       if (is_empty_class (current_class_type))
 655         /* Don't copy the padding byte; it might not have been allocated
 656            if *this is a base subobject.  */;
 657       else if (tree_int_cst_equal (TYPE_SIZE (current_class_type),
 658                                    CLASSTYPE_SIZE (current_class_type)))
 659         {
 660           tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
 661           finish_expr_stmt (t);
 662         }
 663       else
 664         {
 665           /* We must only copy the non-tail padding parts.  */
 666           tree base_size = CLASSTYPE_SIZE_UNIT (current_class_type);
 667           base_size = size_binop (MINUS_EXPR, base_size, size_int (1));
 668           tree array_type = build_array_type (unsigned_char_type_node,
 669                                               build_index_type (base_size));
 670           tree alias_set = build_int_cst (TREE_TYPE (current_class_ptr), 0);
 671           tree lhs = build2 (MEM_REF, array_type,
 672                              current_class_ptr, alias_set);
 673           tree rhs = build2 (MEM_REF, array_type,
 674                              TREE_OPERAND (parm, 0), alias_set);
 675           tree t = build2 (INIT_EXPR, void_type_node, lhs, rhs);
 676           finish_expr_stmt (t);
 677         }
 678     }
 679   else
 680     {
 681       tree member_init_list = NULL_TREE;
 682       int i;
 683       tree binfo, base_binfo;
 684       vec<tree, va_gc> *vbases;
 685
 686       /* Initialize all the base-classes with the parameter converted
 687          to their type so that we get their copy constructor and not
 688          another constructor that takes current_class_type.  We must
 689          deal with the binfo's directly as a direct base might be
 690          inaccessible due to ambiguity.  */
 691       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
 692            vec_safe_iterate (vbases, i, &binfo); i++)
 693         {
 694           member_init_list = add_one_base_init (binfo, parm, move_p, inh,
 695                                                 member_init_list);
 696         }
 697
 698       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 699            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 700         {
 701           if (BINFO_VIRTUAL_P (base_binfo))
 702             continue;
 703           member_init_list = add_one_base_init (base_binfo, parm, move_p,
 704                                                 inh, member_init_list);
 705         }
 706
 707       if (!inh)
 708         {
 709           int cvquals = cp_type_quals (TREE_TYPE (parm));
 710
 711           for (tree fields = TYPE_FIELDS (current_class_type);
 712                fields; fields = DECL_CHAIN (fields))
 713             {
 714               tree field = fields;
 715               tree expr_type;
 716
 717               if (TREE_CODE (field) != FIELD_DECL)
 718                 continue;
 719
 720               expr_type = TREE_TYPE (field);
 721               if (DECL_NAME (field))
 722                 {
 723                   if (VFIELD_NAME_P (DECL_NAME (field)))
 724                     continue;
 725                 }
 726               else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
 727                 /* Just use the field; anonymous types can't have
 728                    nontrivial copy ctors or assignment ops or this
 729                    function would be deleted.  */;
 730               else
 731                 continue;
 732
 733               /* Compute the type of "init->field".  If the copy-constructor
 734                  parameter is, for example, "const S&", and the type of
 735                  the field is "T", then the type will usually be "const
 736                  T".  (There are no cv-qualified variants of reference
 737                  types.)  */
 738               if (!TYPE_REF_P (expr_type))
 739                 {
 740                   int quals = cvquals;
 741
 742                   if (DECL_MUTABLE_P (field))
 743                     quals &= ~TYPE_QUAL_CONST;
 744                   quals |= cp_type_quals (expr_type);
 745                   expr_type = cp_build_qualified_type (expr_type, quals);
 746                 }
 747
 748               tree init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
 749               if (move_p && !TYPE_REF_P (expr_type)
 750                   /* 'move' breaks bit-fields, and has no effect for scalars.  */
 751                   && !scalarish_type_p (expr_type))
 752                 init = move (init);
 753               init = build_tree_list (NULL_TREE, init);
 754
 755               member_init_list = tree_cons (field, init, member_init_list);
 756             }
 757         }
 758
 759       finish_mem_initializers (member_init_list);
 760     }
 761 }
 762
 763 static void
 764 do_build_copy_assign (tree fndecl)
 765 {
 766   tree parm = DECL_CHAIN (DECL_ARGUMENTS (fndecl));
 767   tree compound_stmt;
 768   bool move_p = move_fn_p (fndecl);
 769   bool trivial = trivial_fn_p (fndecl);
 770   int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
 771
 772   compound_stmt = begin_compound_stmt (0);
 773   parm = convert_from_reference (parm);
 774
 775   if (trivial
 776       && is_empty_class (current_class_type))
 777     /* Don't copy the padding byte; it might not have been allocated
 778        if *this is a base subobject.  */;
 779   else if (trivial)
 780     {
 781       tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
 782       finish_expr_stmt (t);
 783     }
 784   else
 785     {
 786       tree fields;
 787       int cvquals = cp_type_quals (TREE_TYPE (parm));
 788       int i;
 789       tree binfo, base_binfo;
 790
 791       /* Assign to each of the direct base classes.  */
 792       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 793            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 794         {
 795           tree converted_parm;
 796
 797           /* We must convert PARM directly to the base class
 798              explicitly since the base class may be ambiguous.  */
 799           converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1,
 800                                             tf_warning_or_error);
 801           if (move_p)
 802             converted_parm = move (converted_parm);
 803           /* Call the base class assignment operator.  */
 804           releasing_vec parmvec (make_tree_vector_single (converted_parm));
 805           finish_expr_stmt
 806             (build_special_member_call (current_class_ref,
 807                                         assign_op_identifier,
 808                                         &parmvec,
 809                                         base_binfo,
 810                                         flags,
 811                                         tf_warning_or_error));
 812         }
 813
 814       /* Assign to each of the non-static data members.  */
 815       for (fields = TYPE_FIELDS (current_class_type);
 816            fields;
 817            fields = DECL_CHAIN (fields))
 818         {
 819           tree comp = current_class_ref;
 820           tree init = parm;
 821           tree field = fields;
 822           tree expr_type;
 823           int quals;
 824
 825           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 826             continue;
 827
 828           expr_type = TREE_TYPE (field);
 829
 830           if (CP_TYPE_CONST_P (expr_type))
 831             {
 832               error ("non-static const member %q#D, cannot use default "
 833                      "assignment operator", field);
 834               continue;
 835             }
 836           else if (TYPE_REF_P (expr_type))
 837             {
 838               error ("non-static reference member %q#D, cannot use "
 839                      "default assignment operator", field);
 840               continue;
 841             }
 842
 843           if (DECL_NAME (field))
 844             {
 845               if (VFIELD_NAME_P (DECL_NAME (field)))
 846                 continue;
 847             }
 848           else if (ANON_AGGR_TYPE_P (expr_type)
 849                    && TYPE_FIELDS (expr_type) != NULL_TREE)
 850             /* Just use the field; anonymous types can't have
 851                nontrivial copy ctors or assignment ops or this
 852                function would be deleted.  */;
 853           else
 854             continue;
 855
 856           comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
 857
 858           /* Compute the type of init->field  */
 859           quals = cvquals;
 860           if (DECL_MUTABLE_P (field))
 861             quals &= ~TYPE_QUAL_CONST;
 862           expr_type = cp_build_qualified_type (expr_type, quals);
 863
 864           init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
 865           if (move_p && !TYPE_REF_P (expr_type)
 866               /* 'move' breaks bit-fields, and has no effect for scalars.  */
 867               && !scalarish_type_p (expr_type))
 868             init = move (init);
 869
 870           if (DECL_NAME (field))
 871             init = cp_build_modify_expr (input_location, comp, NOP_EXPR, init,
 872                                          tf_warning_or_error);
 873           else
 874             init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
 875           finish_expr_stmt (init);
 876         }
 877     }
 878   finish_return_stmt (current_class_ref);
 879   finish_compound_stmt (compound_stmt);
 880 }
 881
 882 /* C++20 <compare> comparison category types.  */
 883
 884 enum comp_cat_tag
 885 {
 886   cc_partial_ordering,
 887   cc_weak_ordering,
 888   cc_strong_ordering,
 889   cc_last
 890 };
 891
 892 /* Names of the comparison categories and their value members, to be indexed by
 893    comp_cat_tag enumerators.  genericize_spaceship below relies on the ordering
 894    of the members.  */
 895
 896 struct comp_cat_info_t
 897 {
 898   const char *name;
 899   const char *members[4];
 900 };
 901 static const comp_cat_info_t comp_cat_info[cc_last]
 902 = {
 903    { "partial_ordering", { "equivalent", "greater", "less", "unordered" } },
 904    { "weak_ordering", { "equivalent", "greater", "less" } },
 905    { "strong_ordering", { "equal", "greater", "less" } }
 906 };
 907
 908 /* A cache of the category types to speed repeated lookups.  */
 909
 910 static GTY((deletable)) tree comp_cat_cache[cc_last];
 911
 912 /* Look up one of the result variables in the comparison category type.  */
 913
 914 static tree
 915 lookup_comparison_result (tree type, const char *name_str,
 916                           tsubst_flags_t complain = tf_warning_or_error)
 917 {
 918   tree name = get_identifier (name_str);
 919   tree decl = lookup_qualified_name (type, name);
 920   if (TREE_CODE (decl) != VAR_DECL)
 921     {
 922       if (complain & tf_error)
 923         {
 924           auto_diagnostic_group d;
 925           if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
 926             qualified_name_lookup_error (type, name, decl, input_location);
 927           else
 928             error ("%qD is not a static data member", decl);
 929           inform (input_location, "determining value of %qs", "operator<=>");
 930         }
 931       return error_mark_node;
 932     }
 933   return decl;
 934 }
 935
 936 /* Look up a <compare> comparison category type in std.  */
 937
 938 static tree
 939 lookup_comparison_category (comp_cat_tag tag,
 940                             tsubst_flags_t complain = tf_warning_or_error)
 941 {
 942   if (tree cached = comp_cat_cache[tag])
 943     return cached;
 944
 945   tree name = get_identifier (comp_cat_info[tag].name);
 946   tree decl = lookup_qualified_name (std_node, name);
 947   if (TREE_CODE (decl) != TYPE_DECL)
 948     {
 949       if (complain & tf_error)
 950         {
 951           auto_diagnostic_group d;
 952           if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
 953             qualified_name_lookup_error (std_node, name, decl, input_location);
 954           else
 955             error ("%qD is not a type", decl);
 956           inform (input_location, "forming type of %qs", "operator<=>");
 957         }
 958       return error_mark_node;
 959     }
 960   /* Also make sure we can look up the value members now, since we won't
 961      really use them until genericize time.  */
 962   tree type = TREE_TYPE (decl);
 963   for (int i = 0; i < 4; ++i)
 964     {
 965       const char *p = comp_cat_info[tag].members[i];
 966       if (!p) break;
 967       if (lookup_comparison_result (type, p, complain)
 968           == error_mark_node)
 969         return error_mark_node;
 970     }
 971   return comp_cat_cache[tag] = type;
 972 }
 973
 974 /* Wrapper that takes the tag rather than the type.  */
 975
 976 static tree
 977 lookup_comparison_result (comp_cat_tag tag, const char *name_str,
 978                           tsubst_flags_t complain = tf_warning_or_error)
 979 {
 980   tree type = lookup_comparison_category (tag, complain);
 981   return lookup_comparison_result (type, name_str, complain);
 982 }
 983
 984 /* Wrapper that takes the index into the members array instead of the name.  */
 985
 986 static tree
 987 lookup_comparison_result (comp_cat_tag tag, tree type, int idx)
 988 {
 989   const char *name_str = comp_cat_info[tag].members[idx];
 990   if (!name_str)
 991     return NULL_TREE;
 992   return lookup_comparison_result (type, name_str);
 993 }
 994
 995 /* Does TYPE correspond to TAG?  */
 996
 997 static bool
 998 is_cat (tree type, comp_cat_tag tag)
 999 {
1000   tree name = TYPE_LINKAGE_IDENTIFIER (type);
1001   return id_equal (name, comp_cat_info[tag].name);
1002 }
1003
1004 /* Return the comp_cat_tag for TYPE.  */
1005
1006 static comp_cat_tag
1007 cat_tag_for (tree type)
1008 {
1009   for (int i = 0; i < cc_last; ++i)
1010     {
1011       comp_cat_tag tag = (comp_cat_tag)i;
1012       if (is_cat (type, tag))
1013         return tag;
1014     }
1015   return cc_last;
1016 }
1017
1018 /* Return the comparison category tag of a <=> expression with non-class type
1019    OPTYPE.  */
1020
1021 static comp_cat_tag
1022 spaceship_comp_cat (tree optype)
1023 {
1024   if (INTEGRAL_OR_ENUMERATION_TYPE_P (optype) || TYPE_PTROBV_P (optype))
1025     return cc_strong_ordering;
1026   else if (TREE_CODE (optype) == REAL_TYPE)
1027     return cc_partial_ordering;
1028
1029   /* ??? should vector <=> produce a vector of one of the above?  */
1030   gcc_unreachable ();
1031 }
1032
1033 /* Return the comparison category type of a <=> expression with non-class type
1034    OPTYPE.  */
1035
1036 tree
1037 spaceship_type (tree optype, tsubst_flags_t complain)
1038 {
1039   comp_cat_tag tag = spaceship_comp_cat (optype);
1040   return lookup_comparison_category (tag, complain);
1041 }
1042
1043 /* Turn <=> with type TYPE and operands OP0 and OP1 into GENERIC.  */
1044
1045 tree
1046 genericize_spaceship (tree type, tree op0, tree op1)
1047 {
1048   /* ??? maybe optimize based on knowledge of representation? */
1049   comp_cat_tag tag = cat_tag_for (type);
1050   gcc_checking_assert (tag < cc_last);
1051
1052   tree r;
1053   op0 = save_expr (op0);
1054   op1 = save_expr (op1);
1055
1056   tree gt = lookup_comparison_result (tag, type, 1);
1057
1058   if (tag == cc_partial_ordering)
1059     {
1060       /* op0 == op1 ? equivalent : op0 < op1 ? less :
1061          op0 > op1 ? greater : unordered */
1062       tree uo = lookup_comparison_result (tag, type, 3);
1063       tree comp = fold_build2 (GT_EXPR, boolean_type_node, op0, op1);
1064       r = fold_build3 (COND_EXPR, type, comp, gt, uo);
1065     }
1066   else
1067     /* op0 == op1 ? equal : op0 < op1 ? less : greater */
1068     r = gt;
1069
1070   tree lt = lookup_comparison_result (tag, type, 2);
1071   tree comp = fold_build2 (LT_EXPR, boolean_type_node, op0, op1);
1072   r = fold_build3 (COND_EXPR, type, comp, lt, r);
1073
1074   tree eq = lookup_comparison_result (tag, type, 0);
1075   comp = fold_build2 (EQ_EXPR, boolean_type_node, op0, op1);
1076   r = fold_build3 (COND_EXPR, type, comp, eq, r);
1077
1078   /* Wrap the whole thing in a TARGET_EXPR like build_conditional_expr_1.  */
1079   r = get_target_expr (r);
1080
1081   return r;
1082 }
1083
1084 /* Check that the signature of a defaulted comparison operator is
1085    well-formed.  */
1086
1087 static bool
1088 early_check_defaulted_comparison (tree fn)
1089 {
1090   location_t loc = DECL_SOURCE_LOCATION (fn);
1091   tree ctx;
1092   if (DECL_CLASS_SCOPE_P (fn))
1093     ctx = DECL_CONTEXT (fn);
1094   else
1095     ctx = DECL_FRIEND_CONTEXT (fn);
1096   bool ok = true;
1097
1098   if (cxx_dialect < cxx20)
1099     {
1100       error_at (loc, "defaulted %qD only available with %<-std=c++20%> or "
1101                      "%<-std=gnu++20%>", fn);
1102       return false;
1103     }
1104
1105   if (!DECL_OVERLOADED_OPERATOR_IS (fn, SPACESHIP_EXPR)
1106       && !same_type_p (TREE_TYPE (TREE_TYPE (fn)), boolean_type_node))
1107     {
1108       diagnostic_t kind = DK_UNSPECIFIED;
1109       int opt = 0;
1110       if (is_auto (TREE_TYPE (fn)))
1111         kind = DK_PEDWARN;
1112       else
1113         kind = DK_ERROR;
1114       emit_diagnostic (kind, loc, opt,
1115                        "defaulted %qD must return %<bool%>", fn);
1116       if (kind == DK_ERROR)
1117         ok = false;
1118     }
1119
1120   bool mem = DECL_NONSTATIC_MEMBER_FUNCTION_P (fn);
1121   if (mem && type_memfn_quals (TREE_TYPE (fn)) != TYPE_QUAL_CONST)
1122     {
1123       error_at (loc, "defaulted %qD must be %<const%>", fn);
1124       ok = false;
1125     }
1126   if (mem && type_memfn_rqual (TREE_TYPE (fn)) == REF_QUAL_RVALUE)
1127     {
1128       error_at (loc, "defaulted %qD must not have %<&&%> ref-qualifier", fn);
1129       ok = false;
1130     }
1131   tree parmnode = FUNCTION_FIRST_USER_PARMTYPE (fn);
1132   bool saw_byval = false;
1133   bool saw_byref = mem;
1134   bool saw_bad = false;
1135   for (; parmnode != void_list_node; parmnode = TREE_CHAIN (parmnode))
1136     {
1137       tree parmtype = TREE_VALUE (parmnode);
1138       if (CLASS_TYPE_P (parmtype))
1139         saw_byval = true;
1140       else if (TREE_CODE (parmtype) == REFERENCE_TYPE
1141                && !TYPE_REF_IS_RVALUE (parmtype)
1142                && TYPE_QUALS (TREE_TYPE (parmtype)) == TYPE_QUAL_CONST)
1143         {
1144           saw_byref = true;
1145           parmtype = TREE_TYPE (parmtype);
1146         }
1147       else
1148         saw_bad = true;
1149
1150       if (!saw_bad && !ctx)
1151         {
1152           /* Defaulted outside the class body.  */
1153           ctx = TYPE_MAIN_VARIANT (parmtype);
1154           if (!is_friend (ctx, fn))
1155             error_at (loc, "defaulted %qD is not a friend of %qT", fn, ctx);
1156         }
1157       else if (!same_type_ignoring_top_level_qualifiers_p (parmtype, ctx))
1158         saw_bad = true;
1159     }
1160
1161   if (saw_bad || (saw_byval && saw_byref))
1162     {
1163       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1164         error_at (loc, "defaulted member %qD must have parameter type "
1165                   "%<const %T&%>", fn, ctx);
1166       else if (saw_bad)
1167         error_at (loc, "defaulted %qD must have parameters of either type "
1168                   "%<const %T&%> or %qT", fn, ctx, ctx);
1169       else
1170         error_at (loc, "defaulted %qD must have parameters of either type "
1171                   "%<const %T&%> or %qT, not both", fn, ctx, ctx);
1172       ok = false;
1173     }
1174
1175   /* We still need to deduce deleted/constexpr/noexcept and maybe return. */
1176   DECL_MAYBE_DELETED (fn) = ok;
1177
1178   return ok;
1179 }
1180
1181 /* Subroutine of build_comparison_op.  Given the vec of memberwise
1182    comparisons COMPS, calculate the overall comparison category for
1183    operator<=>.  */
1184
1185 static tree
1186 common_comparison_type (vec<tree> &comps)
1187 {
1188   tree seen[cc_last] = {};
1189
1190   for (unsigned i = 0; i < comps.length(); ++i)
1191     {
1192       tree comp = comps[i];
1193       tree ctype = TREE_TYPE (comp);
1194       comp_cat_tag tag = cat_tag_for (ctype);
1195       /* build_comparison_op already checked this.  */
1196       gcc_checking_assert (tag < cc_last);
1197       seen[tag] = ctype;
1198     }
1199
1200   /* Otherwise, if at least one T i is std::partial_ordering, U is
1201      std::partial_ordering.  */
1202   if (tree t = seen[cc_partial_ordering]) return t;
1203
1204   /* Otherwise, if at least one T i is std::weak_ordering, U is
1205      std::weak_ordering.  */
1206   if (tree t = seen[cc_weak_ordering]) return t;
1207
1208   /* Otherwise, U is std::strong_ordering.  */
1209   if (tree t = seen[cc_strong_ordering]) return t;
1210   return lookup_comparison_category (cc_strong_ordering);
1211 }
1212
1213 /* Data structure for build_comparison_op.  */
1214
1215 struct comp_info
1216 {
1217   tree fndecl;
1218   location_t loc;
1219   bool defining;
1220   bool first_time;
1221   bool constexp;
1222   bool was_constexp;
1223   bool noex;
1224
1225   comp_info (tree fndecl, tsubst_flags_t &complain)
1226     : fndecl (fndecl)
1227   {
1228     loc = DECL_SOURCE_LOCATION (fndecl);
1229
1230     /* We only have tf_error set when we're called from
1231        explain_invalid_constexpr_fn or maybe_explain_implicit_delete.  */
1232     defining = !(complain & tf_error);
1233
1234     first_time = DECL_MAYBE_DELETED (fndecl);
1235     DECL_MAYBE_DELETED (fndecl) = false;
1236
1237     /* Do we want to try to set constexpr?  */
1238     was_constexp = DECL_DECLARED_CONSTEXPR_P (fndecl);
1239     constexp = first_time;
1240     if (constexp)
1241       /* Set this for var_in_constexpr_fn.  */
1242       DECL_DECLARED_CONSTEXPR_P (fndecl) = true;
1243
1244     /* Do we want to try to set noexcept?  */
1245     noex = first_time;
1246     if (noex)
1247       {
1248         tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fndecl));
1249         if (raises && !UNEVALUATED_NOEXCEPT_SPEC_P (raises))
1250           /* There was an explicit exception-specification.  */
1251           noex = false;
1252       }
1253   }
1254
1255   /* EXPR is an expression built as part of the function body.
1256      Adjust the properties appropriately.  */
1257   void check (tree expr)
1258   {
1259     if (expr == error_mark_node)
1260       DECL_DELETED_FN (fndecl) = true;
1261     if ((constexp || was_constexp)
1262         && !potential_rvalue_constant_expression (expr))
1263       {
1264         if (was_constexp)
1265           require_potential_rvalue_constant_expression (expr);
1266         else
1267           constexp = false;
1268       }
1269     if (noex && !expr_noexcept_p (expr, tf_none))
1270       noex = false;
1271   }
1272
1273   ~comp_info ()
1274   {
1275     if (first_time)
1276       {
1277         DECL_DECLARED_CONSTEXPR_P (fndecl) = constexp || was_constexp;
1278         tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fndecl));
1279         if (!raises || UNEVALUATED_NOEXCEPT_SPEC_P (raises))
1280           {
1281             raises = noex ? noexcept_true_spec : noexcept_false_spec;
1282             TREE_TYPE (fndecl) = build_exception_variant (TREE_TYPE (fndecl),
1283                                                           raises);
1284           }
1285       }
1286   }
1287 };
1288
1289 /* Build up the definition of a defaulted comparison operator.  Unlike other
1290    defaulted functions that use synthesized_method_walk to determine whether
1291    the function is e.g. deleted, for comparisons we use the same code.  We try
1292    to use synthesize_method at the earliest opportunity and bail out if the
1293    function ends up being deleted.  */
1294
1295 static void
1296 build_comparison_op (tree fndecl, tsubst_flags_t complain)
1297 {
1298   comp_info info (fndecl, complain);
1299
1300   if (!info.defining && !(complain & tf_error) && !DECL_MAYBE_DELETED (fndecl))
1301     return;
1302
1303   int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
1304   const ovl_op_info_t *op = IDENTIFIER_OVL_OP_INFO (DECL_NAME (fndecl));
1305   tree_code code = op->tree_code;
1306
1307   tree lhs = DECL_ARGUMENTS (fndecl);
1308   tree rhs = DECL_CHAIN (lhs);
1309   if (is_this_parameter (lhs))
1310     lhs = cp_build_fold_indirect_ref (lhs);
1311   else
1312     lhs = convert_from_reference (lhs);
1313   rhs = convert_from_reference (rhs);
1314   tree ctype = TYPE_MAIN_VARIANT (TREE_TYPE (lhs));
1315
1316   iloc_sentinel ils (info.loc);
1317
1318   /* A defaulted comparison operator function for class C is defined as
1319      deleted if ... C has variant members.  */
1320   if (TREE_CODE (ctype) == UNION_TYPE
1321       && next_initializable_field (TYPE_FIELDS (ctype)))
1322     {
1323       if (complain & tf_error)
1324         inform (info.loc, "cannot default compare union %qT", ctype);
1325       DECL_DELETED_FN (fndecl) = true;
1326       return;
1327     }
1328
1329   tree compound_stmt = NULL_TREE;
1330   if (info.defining)
1331     compound_stmt = begin_compound_stmt (0);
1332   else
1333     ++cp_unevaluated_operand;
1334
1335   tree rettype = TREE_TYPE (TREE_TYPE (fndecl));
1336   if (code != SPACESHIP_EXPR && is_auto (rettype))
1337     {
1338       rettype = boolean_type_node;
1339       apply_deduced_return_type (fndecl, rettype);
1340     }
1341
1342   if (code == EQ_EXPR || code == SPACESHIP_EXPR)
1343     {
1344       bool bad = false;
1345       auto_vec<tree> comps;
1346
1347       /* Compare each of the subobjects.  Note that we get bases from
1348          next_initializable_field because we're past C++17.  */
1349       for (tree field = next_initializable_field (TYPE_FIELDS (ctype));
1350            field;
1351            field = next_initializable_field (DECL_CHAIN (field)))
1352         {
1353           tree expr_type = TREE_TYPE (field);
1354
1355           /* A defaulted comparison operator function for class C is defined as
1356              deleted if any non-static data member of C is of reference type or
1357              C has variant members.  */
1358           if (TREE_CODE (expr_type) == REFERENCE_TYPE)
1359             {
1360               if (complain & tf_error)
1361                 inform (DECL_SOURCE_LOCATION (field), "cannot default compare "
1362                         "reference member %qD", field);
1363               bad = true;
1364               continue;
1365             }
1366           else if (ANON_UNION_TYPE_P (expr_type)
1367                    && next_initializable_field (TYPE_FIELDS (expr_type)))
1368             {
1369               if (complain & tf_error)
1370                 inform (DECL_SOURCE_LOCATION (field), "cannot default compare "
1371                         "anonymous union member");
1372               bad = true;
1373               continue;
1374             }
1375
1376           tree lhs_mem = build3 (COMPONENT_REF, expr_type, lhs, field,
1377                                  NULL_TREE);
1378           tree rhs_mem = build3 (COMPONENT_REF, expr_type, rhs, field,
1379                                  NULL_TREE);
1380           tree comp = build_new_op (info.loc, code, flags, lhs_mem, rhs_mem,
1381                                     NULL_TREE, NULL, complain);
1382           if (comp == error_mark_node)
1383             {
1384               bad = true;
1385               continue;
1386             }
1387           if (code == SPACESHIP_EXPR
1388               && cat_tag_for (TREE_TYPE (comp)) == cc_last)
1389             {
1390               /* The operator function is defined as deleted if ... Ri is not a
1391                  comparison category type.  */
1392               if (complain & tf_error)
1393                 inform (DECL_SOURCE_LOCATION (field),
1394                         "three-way comparison of %qD has type %qT, not a "
1395                         "comparison category type", field, TREE_TYPE (comp));
1396               bad = true;
1397               continue;
1398             }
1399           comps.safe_push (comp);
1400         }
1401       if (code == SPACESHIP_EXPR && is_auto (rettype))
1402         {
1403           rettype = common_comparison_type (comps);
1404           apply_deduced_return_type (fndecl, rettype);
1405         }
1406       if (bad)
1407         {
1408           DECL_DELETED_FN (fndecl) = true;
1409           goto out;
1410         }
1411       for (unsigned i = 0; i < comps.length(); ++i)
1412         {
1413           tree comp = comps[i];
1414           tree eq, retval = NULL_TREE, if_ = NULL_TREE;
1415           if (info.defining)
1416             if_ = begin_if_stmt ();
1417           /* Spaceship is specified to use !=, but for the comparison category
1418              types, != is equivalent to !(==), so let's use == directly.  */
1419           if (code == EQ_EXPR)
1420             {
1421               /* if (x==y); else return false; */
1422               eq = comp;
1423               retval = boolean_false_node;
1424             }
1425           else
1426             {
1427               /* if (auto v = x<=>y, v == 0); else return v; */
1428               if (TREE_CODE (comp) == SPACESHIP_EXPR)
1429                 TREE_TYPE (comp) = rettype;
1430               else
1431                 comp = build_static_cast (input_location, rettype, comp,
1432                                           complain);
1433               info.check (comp);
1434               if (info.defining)
1435                 {
1436                   tree var = create_temporary_var (rettype);
1437                   pushdecl (var);
1438                   cp_finish_decl (var, comp, false, NULL_TREE, flags);
1439                   comp = retval = var;
1440                 }
1441               eq = build_new_op (info.loc, EQ_EXPR, flags, comp,
1442                                  integer_zero_node, NULL_TREE, NULL,
1443                                  complain);
1444             }
1445           tree ceq = contextual_conv_bool (eq, complain);
1446           info.check (ceq);
1447           if (info.defining)
1448             {
1449               finish_if_stmt_cond (ceq, if_);
1450               finish_then_clause (if_);
1451               begin_else_clause (if_);
1452               finish_return_stmt (retval);
1453               finish_else_clause (if_);
1454               finish_if_stmt (if_);
1455             }
1456         }
1457       if (info.defining)
1458         {
1459           tree val;
1460           if (code == EQ_EXPR)
1461             val = boolean_true_node;
1462           else
1463             {
1464               tree seql = lookup_comparison_result (cc_strong_ordering,
1465                                                     "equal", complain);
1466               val = build_static_cast (input_location, rettype, seql,
1467                                        complain);
1468             }
1469           finish_return_stmt (val);
1470         }
1471     }
1472   else if (code == NE_EXPR)
1473     {
1474       tree comp = build_new_op (info.loc, EQ_EXPR, flags, lhs, rhs,
1475                                 NULL_TREE, NULL, complain);
1476       comp = contextual_conv_bool (comp, complain);
1477       info.check (comp);
1478       if (info.defining)
1479         {
1480           tree neg = build1 (TRUTH_NOT_EXPR, boolean_type_node, comp);
1481           finish_return_stmt (neg);
1482         }
1483     }
1484   else
1485     {
1486       tree comp = build_new_op (info.loc, SPACESHIP_EXPR, flags, lhs, rhs,
1487                                 NULL_TREE, NULL, complain);
1488       tree comp2 = build_new_op (info.loc, code, flags, comp, integer_zero_node,
1489                                  NULL_TREE, NULL, complain);
1490       info.check (comp2);
1491       if (info.defining)
1492         finish_return_stmt (comp2);
1493     }
1494
1495  out:
1496   if (info.defining)
1497     finish_compound_stmt (compound_stmt);
1498   else
1499     --cp_unevaluated_operand;
1500 }
1501
1502 /* True iff DECL is an implicitly-declared special member function with no real
1503    source location, so we can use its DECL_SOURCE_LOCATION to remember where we
1504    triggered its synthesis.  */
1505
1506 bool
1507 decl_remember_implicit_trigger_p (tree decl)
1508 {
1509   if (!DECL_ARTIFICIAL (decl))
1510     return false;
1511   special_function_kind sfk = special_function_p (decl);
1512   /* Inherited constructors have the location of their using-declaration, and
1513      operator== has the location of the corresponding operator<=>.  */
1514   return (sfk != sfk_inheriting_constructor
1515           && sfk != sfk_comparison);
1516 }
1517
1518 /* Synthesize FNDECL, a non-static member function.   */
1519
1520 void
1521 synthesize_method (tree fndecl)
1522 {
1523   bool nested = (current_function_decl != NULL_TREE);
1524   tree context = decl_function_context (fndecl);
1525   bool need_body = true;
1526   tree stmt;
1527   location_t save_input_location = input_location;
1528   int error_count = errorcount;
1529   int warning_count = warningcount + werrorcount;
1530   special_function_kind sfk = special_function_p (fndecl);
1531
1532   /* Reset the source location, we might have been previously
1533      deferred, and thus have saved where we were first needed.  */
1534   if (decl_remember_implicit_trigger_p (fndecl))
1535     DECL_SOURCE_LOCATION (fndecl)
1536       = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
1537
1538   /* If we've been asked to synthesize a clone, just synthesize the
1539      cloned function instead.  Doing so will automatically fill in the
1540      body for the clone.  */
1541   if (DECL_CLONED_FUNCTION_P (fndecl))
1542     fndecl = DECL_CLONED_FUNCTION (fndecl);
1543
1544   /* We may be in the middle of deferred access check.  Disable
1545      it now.  */
1546   push_deferring_access_checks (dk_no_deferred);
1547
1548   if (! context)
1549     push_to_top_level ();
1550   else if (nested)
1551     push_function_context ();
1552
1553   input_location = DECL_SOURCE_LOCATION (fndecl);
1554
1555   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
1556   stmt = begin_function_body ();
1557
1558   if (DECL_ASSIGNMENT_OPERATOR_P (fndecl)
1559       && DECL_OVERLOADED_OPERATOR_IS (fndecl, NOP_EXPR))
1560     {
1561       do_build_copy_assign (fndecl);
1562       need_body = false;
1563     }
1564   else if (DECL_CONSTRUCTOR_P (fndecl))
1565     {
1566       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
1567       if (arg_chain != void_list_node)
1568         do_build_copy_constructor (fndecl);
1569       else
1570         finish_mem_initializers (NULL_TREE);
1571     }
1572   else if (sfk == sfk_comparison)
1573     {
1574       /* Pass tf_none so the function is just deleted if there's a problem.  */
1575       build_comparison_op (fndecl, tf_none);
1576       need_body = false;
1577     }
1578
1579   /* If we haven't yet generated the body of the function, just
1580      generate an empty compound statement.  */
1581   if (need_body)
1582     {
1583       tree compound_stmt;
1584       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
1585       finish_compound_stmt (compound_stmt);
1586     }
1587
1588   finish_function_body (stmt);
1589   finish_function (/*inline_p=*/false);
1590
1591   if (!DECL_DELETED_FN (fndecl))
1592     expand_or_defer_fn (fndecl);
1593
1594   input_location = save_input_location;
1595
1596   if (! context)
1597     pop_from_top_level ();
1598   else if (nested)
1599     pop_function_context ();
1600
1601   pop_deferring_access_checks ();
1602
1603   if (error_count != errorcount || warning_count != warningcount + werrorcount)
1604     if (DECL_ARTIFICIAL (fndecl))
1605       inform (input_location, "synthesized method %qD first required here",
1606               fndecl);
1607 }
1608
1609 /* Build a reference to type TYPE with cv-quals QUALS, which is an
1610    rvalue if RVALUE is true.  */
1611
1612 static tree
1613 build_stub_type (tree type, int quals, bool rvalue)
1614 {
1615   tree argtype = cp_build_qualified_type (type, quals);
1616   return cp_build_reference_type (argtype, rvalue);
1617 }
1618
1619 /* Build a dummy glvalue from dereferencing a dummy reference of type
1620    REFTYPE.  */
1621
1622 static tree
1623 build_stub_object (tree reftype)
1624 {
1625   if (!TYPE_REF_P (reftype))
1626     reftype = cp_build_reference_type (reftype, /*rval*/true);
1627   tree stub = build1 (CONVERT_EXPR, reftype, integer_one_node);
1628   return convert_from_reference (stub);
1629 }
1630
1631 /* Determine which function will be called when looking up NAME in TYPE,
1632    called with a single ARGTYPE argument, or no argument if ARGTYPE is
1633    null.  FLAGS and COMPLAIN are as for build_new_method_call.
1634
1635    Returns a FUNCTION_DECL if all is well.
1636    Returns NULL_TREE if overload resolution failed.
1637    Returns error_mark_node if the chosen function cannot be called.  */
1638
1639 static tree
1640 locate_fn_flags (tree type, tree name, tree argtype, int flags,
1641                  tsubst_flags_t complain)
1642 {
1643   tree ob, fn, fns, binfo, rval;
1644
1645   if (TYPE_P (type))
1646     binfo = TYPE_BINFO (type);
1647   else
1648     {
1649       binfo = type;
1650       type = BINFO_TYPE (binfo);
1651     }
1652
1653   ob = build_stub_object (cp_build_reference_type (type, false));
1654   releasing_vec args;
1655   if (argtype)
1656     {
1657       if (TREE_CODE (argtype) == TREE_LIST)
1658         {
1659           for (tree elt = argtype; elt && elt != void_list_node;
1660                elt = TREE_CHAIN (elt))
1661             {
1662               tree type = TREE_VALUE (elt);
1663               tree arg = build_stub_object (type);
1664               vec_safe_push (args, arg);
1665             }
1666         }
1667       else
1668         {
1669           tree arg = build_stub_object (argtype);
1670           args->quick_push (arg);
1671         }
1672     }
1673
1674   fns = lookup_fnfields (binfo, name, 0, complain);
1675   rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
1676
1677   if (fn && rval == error_mark_node)
1678     return rval;
1679   else
1680     return fn;
1681 }
1682
1683 /* Locate the dtor of TYPE.  */
1684
1685 tree
1686 get_dtor (tree type, tsubst_flags_t complain)
1687 {
1688   tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
1689                              LOOKUP_NORMAL, complain);
1690   if (fn == error_mark_node)
1691     return NULL_TREE;
1692   return fn;
1693 }
1694
1695 /* Locate the default ctor of TYPE.  */
1696
1697 tree
1698 locate_ctor (tree type)
1699 {
1700   tree fn;
1701
1702   push_deferring_access_checks (dk_no_check);
1703   fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
1704                         LOOKUP_SPECULATIVE, tf_none);
1705   pop_deferring_access_checks ();
1706   if (fn == error_mark_node)
1707     return NULL_TREE;
1708   return fn;
1709 }
1710
1711 /* Likewise, but give any appropriate errors.  */
1712
1713 tree
1714 get_default_ctor (tree type)
1715 {
1716   tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
1717                              LOOKUP_NORMAL, tf_warning_or_error);
1718   if (fn == error_mark_node)
1719     return NULL_TREE;
1720   return fn;
1721 }
1722
1723 /* Locate the copy ctor of TYPE.  */
1724
1725 tree
1726 get_copy_ctor (tree type, tsubst_flags_t complain)
1727 {
1728   int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
1729                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
1730   tree argtype = build_stub_type (type, quals, false);
1731   tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
1732                              LOOKUP_NORMAL, complain);
1733   if (fn == error_mark_node)
1734     return NULL_TREE;
1735   return fn;
1736 }
1737
1738 /* Locate the copy assignment operator of TYPE.  */
1739
1740 tree
1741 get_copy_assign (tree type)
1742 {
1743   int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
1744                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
1745   tree argtype = build_stub_type (type, quals, false);
1746   tree fn = locate_fn_flags (type, assign_op_identifier, argtype,
1747                              LOOKUP_NORMAL, tf_warning_or_error);
1748   if (fn == error_mark_node)
1749     return NULL_TREE;
1750   return fn;
1751 }
1752
1753 /* walk_tree helper function for is_trivially_xible.  If *TP is a call,
1754    return it if it calls something other than a trivial special member
1755    function.  */
1756
1757 static tree
1758 check_nontriv (tree *tp, int *, void *)
1759 {
1760   tree fn = cp_get_callee (*tp);
1761   if (fn == NULL_TREE)
1762     return NULL_TREE;
1763
1764   if (TREE_CODE (fn) == ADDR_EXPR)
1765     fn = TREE_OPERAND (fn, 0);
1766
1767   if (TREE_CODE (fn) != FUNCTION_DECL
1768       || !trivial_fn_p (fn))
1769     return fn;
1770   return NULL_TREE;
1771 }
1772
1773 /* Return declval<T>() = declval<U>() treated as an unevaluated operand.  */
1774
1775 static tree
1776 assignable_expr (tree to, tree from)
1777 {
1778   cp_unevaluated cp_uneval_guard;
1779   to = build_stub_object (to);
1780   from = build_stub_object (from);
1781   tree r = cp_build_modify_expr (input_location, to, NOP_EXPR, from, tf_none);
1782   return r;
1783 }
1784
1785 /* The predicate condition for a template specialization
1786    is_constructible<T, Args...> shall be satisfied if and only if the
1787    following variable definition would be well-formed for some invented
1788    variable t: T t(create<Args>()...);
1789
1790    Return something equivalent in well-formedness and triviality.  */
1791
1792 static tree
1793 constructible_expr (tree to, tree from)
1794 {
1795   tree expr;
1796   cp_unevaluated cp_uneval_guard;
1797   if (CLASS_TYPE_P (to))
1798     {
1799       tree ctype = to;
1800       vec<tree, va_gc> *args = NULL;
1801       if (!TYPE_REF_P (to))
1802         to = cp_build_reference_type (to, /*rval*/false);
1803       tree ob = build_stub_object (to);
1804       for (; from; from = TREE_CHAIN (from))
1805         vec_safe_push (args, build_stub_object (TREE_VALUE (from)));
1806       expr = build_special_member_call (ob, complete_ctor_identifier, &args,
1807                                         ctype, LOOKUP_NORMAL, tf_none);
1808       if (expr == error_mark_node)
1809         return error_mark_node;
1810       /* The current state of the standard vis-a-vis LWG 2116 is that
1811          is_*constructible involves destruction as well.  */
1812       if (type_build_dtor_call (ctype))
1813         {
1814           tree dtor = build_special_member_call (ob, complete_dtor_identifier,
1815                                                  NULL, ctype, LOOKUP_NORMAL,
1816                                                  tf_none);
1817           if (dtor == error_mark_node)
1818             return error_mark_node;
1819           if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (ctype))
1820             expr = build2 (COMPOUND_EXPR, void_type_node, expr, dtor);
1821         }
1822     }
1823   else
1824     {
1825       if (from == NULL_TREE)
1826         return build_value_init (strip_array_types (to), tf_none);
1827       const int len = list_length (from);
1828       if (len > 1)
1829         {
1830           if (cxx_dialect < cxx20)
1831             /* Too many initializers.  */
1832             return error_mark_node;
1833
1834           /* In C++20 this is well-formed:
1835                using T = int[2];
1836                T t(1, 2);
1837              which means that std::is_constructible_v<int[2], int, int>
1838              should be true.  */
1839           vec<constructor_elt, va_gc> *v;
1840           vec_alloc (v, len);
1841           for (tree t = from; t; t = TREE_CHAIN (t))
1842             {
1843               tree stub = build_stub_object (TREE_VALUE (t));
1844               constructor_elt elt = { NULL_TREE, stub };
1845               v->quick_push (elt);
1846             }
1847           from = build_constructor (init_list_type_node, v);
1848           CONSTRUCTOR_IS_DIRECT_INIT (from) = true;
1849           CONSTRUCTOR_IS_PAREN_INIT (from) = true;
1850         }
1851       else
1852         from = build_stub_object (TREE_VALUE (from));
1853       expr = perform_direct_initialization_if_possible (to, from,
1854                                                         /*cast*/false,
1855                                                         tf_none);
1856       /* If t(e) didn't work, maybe t{e} will.  */
1857       if (expr == NULL_TREE
1858           && len == 1
1859           && cxx_dialect >= cxx20)
1860         {
1861           from = build_constructor_single (init_list_type_node, NULL_TREE,
1862                                            from);
1863           CONSTRUCTOR_IS_DIRECT_INIT (from) = true;
1864           CONSTRUCTOR_IS_PAREN_INIT (from) = true;
1865           expr = perform_direct_initialization_if_possible (to, from,
1866                                                             /*cast*/false,
1867                                                             tf_none);
1868         }
1869     }
1870   return expr;
1871 }
1872
1873 /* Returns a tree iff TO is assignable (if CODE is MODIFY_EXPR) or
1874    constructible (otherwise) from FROM, which is a single type for
1875    assignment or a list of types for construction.  */
1876
1877 static tree
1878 is_xible_helper (enum tree_code code, tree to, tree from, bool trivial)
1879 {
1880   deferring_access_check_sentinel acs (dk_no_deferred);
1881   if (VOID_TYPE_P (to) || ABSTRACT_CLASS_TYPE_P (to)
1882       || (from && FUNC_OR_METHOD_TYPE_P (from)
1883           && (TYPE_READONLY (from) || FUNCTION_REF_QUALIFIED (from))))
1884     return error_mark_node;
1885   tree expr;
1886   if (code == MODIFY_EXPR)
1887     expr = assignable_expr (to, from);
1888   else if (trivial && from && TREE_CHAIN (from))
1889     return error_mark_node; // only 0- and 1-argument ctors can be trivial
1890   else if (TREE_CODE (to) == ARRAY_TYPE && !TYPE_DOMAIN (to))
1891     return error_mark_node; // can't construct an array of unknown bound
1892   else
1893     expr = constructible_expr (to, from);
1894   return expr;
1895 }
1896
1897 /* Returns true iff TO is trivially assignable (if CODE is MODIFY_EXPR) or
1898    constructible (otherwise) from FROM, which is a single type for
1899    assignment or a list of types for construction.  */
1900
1901 bool
1902 is_trivially_xible (enum tree_code code, tree to, tree from)
1903 {
1904   tree expr;
1905   expr = is_xible_helper (code, to, from, /*trivial*/true);
1906
1907   if (expr == NULL_TREE || expr == error_mark_node)
1908     return false;
1909   tree nt = cp_walk_tree_without_duplicates (&expr, check_nontriv, NULL);
1910   return !nt;
1911 }
1912
1913 /* Returns true iff TO is assignable (if CODE is MODIFY_EXPR) or
1914    constructible (otherwise) from FROM, which is a single type for
1915    assignment or a list of types for construction.  */
1916
1917 bool
1918 is_xible (enum tree_code code, tree to, tree from)
1919 {
1920   tree expr = is_xible_helper (code, to, from, /*trivial*/false);
1921   if (expr == error_mark_node)
1922     return false;
1923   return !!expr;
1924 }
1925
1926 /* Categorize various special_function_kinds.  */
1927 #define SFK_CTOR_P(sfk) \
1928   ((sfk) >= sfk_constructor && (sfk) <= sfk_move_constructor)
1929 #define SFK_DTOR_P(sfk) \
1930   ((sfk) == sfk_destructor || (sfk) == sfk_virtual_destructor)
1931 #define SFK_ASSIGN_P(sfk) \
1932   ((sfk) == sfk_copy_assignment || (sfk) == sfk_move_assignment)
1933 #define SFK_COPY_P(sfk) \
1934   ((sfk) == sfk_copy_constructor || (sfk) == sfk_copy_assignment)
1935 #define SFK_MOVE_P(sfk) \
1936   ((sfk) == sfk_move_constructor || (sfk) == sfk_move_assignment)
1937
1938 /* Subroutine of synthesized_method_walk.  Update SPEC_P, TRIVIAL_P and
1939    DELETED_P or give an error message MSG with argument ARG.  */
1940
1941 static void
1942 process_subob_fn (tree fn, special_function_kind sfk, tree *spec_p,
1943                   bool *trivial_p, bool *deleted_p, bool *constexpr_p,
1944                   bool diag, tree arg, bool dtor_from_ctor = false)
1945 {
1946   if (!fn || fn == error_mark_node)
1947     {
1948       if (deleted_p)
1949         *deleted_p = true;
1950       return;
1951     }
1952
1953   if (spec_p)
1954     {
1955       if (!maybe_instantiate_noexcept (fn))
1956         *spec_p = error_mark_node;
1957       else
1958         {
1959           tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
1960           *spec_p = merge_exception_specifiers (*spec_p, raises);
1961         }
1962     }
1963
1964   if (!trivial_fn_p (fn) && !dtor_from_ctor)
1965     {
1966       if (trivial_p)
1967         *trivial_p = false;
1968       if (TREE_CODE (arg) == FIELD_DECL
1969           && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
1970         {
1971           if (deleted_p)
1972             *deleted_p = true;
1973           if (diag)
1974             error ("union member %q+D with non-trivial %qD", arg, fn);
1975         }
1976     }
1977
1978   if (constexpr_p && !DECL_DECLARED_CONSTEXPR_P (fn))
1979     {
1980       *constexpr_p = false;
1981       if (diag)
1982         {
1983           inform (DECL_SOURCE_LOCATION (fn),
1984                   SFK_DTOR_P (sfk)
1985                   ? G_("defaulted destructor calls non-%<constexpr%> %qD")
1986                   : G_("defaulted constructor calls non-%<constexpr%> %qD"),
1987                   fn);
1988           explain_invalid_constexpr_fn (fn);
1989         }
1990     }
1991 }
1992
1993 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
1994    aggregates.  If DTOR_FROM_CTOR is true, we're walking subobject destructors
1995    called from a synthesized constructor, in which case we don't consider
1996    the triviality of the subobject destructor.  */
1997
1998 static void
1999 walk_field_subobs (tree fields, special_function_kind sfk, tree fnname,
2000                    int quals, tree *spec_p, bool *trivial_p,
2001                    bool *deleted_p, bool *constexpr_p,
2002                    bool diag, int flags, tsubst_flags_t complain,
2003                    bool dtor_from_ctor)
2004 {
2005   tree field;
2006   for (field = fields; field; field = DECL_CHAIN (field))
2007     {
2008       tree mem_type, argtype, rval;
2009
2010       if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
2011         continue;
2012
2013       /* Variant members only affect deletedness.  In particular, they don't
2014          affect the exception-specification of a user-provided destructor,
2015          which we're figuring out via get_defaulted_eh_spec.  So if we aren't
2016          asking if this is deleted, don't even look up the function; we don't
2017          want an error about a deleted function we aren't actually calling.  */
2018       if (sfk == sfk_destructor && deleted_p == NULL
2019           && TREE_CODE (DECL_CONTEXT (field)) == UNION_TYPE)
2020         break;
2021
2022       mem_type = strip_array_types (TREE_TYPE (field));
2023       if (SFK_ASSIGN_P (sfk))
2024         {
2025           bool bad = true;
2026           if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
2027             {
2028               if (diag)
2029                 error ("non-static const member %q#D, cannot use default "
2030                        "assignment operator", field);
2031             }
2032           else if (TYPE_REF_P (mem_type))
2033             {
2034               if (diag)
2035                 error ("non-static reference member %q#D, cannot use "
2036                        "default assignment operator", field);
2037             }
2038           else
2039             bad = false;
2040
2041           if (bad && deleted_p)
2042             *deleted_p = true;
2043         }
2044       else if (sfk == sfk_constructor || sfk == sfk_inheriting_constructor)
2045         {
2046           bool bad;
2047
2048           if (DECL_INITIAL (field))
2049             {
2050               if (diag && DECL_INITIAL (field) == error_mark_node)
2051                 inform (DECL_SOURCE_LOCATION (field),
2052                         "initializer for %q#D is invalid", field);
2053               if (trivial_p)
2054                 *trivial_p = false;
2055               /* Core 1351: If the field has an NSDMI that could throw, the
2056                  default constructor is noexcept(false).  */
2057               if (spec_p)
2058                 {
2059                   tree nsdmi = get_nsdmi (field, /*ctor*/false, complain);
2060                   if (nsdmi == error_mark_node)
2061                     *spec_p = error_mark_node;
2062                   else if (*spec_p != error_mark_node
2063                            && !expr_noexcept_p (nsdmi, tf_none))
2064                     *spec_p = noexcept_false_spec;
2065                 }
2066               /* Don't do the normal processing.  */
2067               continue;
2068             }
2069
2070           bad = false;
2071           if (CP_TYPE_CONST_P (mem_type)
2072               && default_init_uninitialized_part (mem_type))
2073             {
2074               if (diag)
2075                 {
2076                   error ("uninitialized const member in %q#T",
2077                          current_class_type);
2078                   inform (DECL_SOURCE_LOCATION (field),
2079                           "%q#D should be initialized", field);
2080                 }
2081               bad = true;
2082             }
2083           else if (TYPE_REF_P (mem_type))
2084             {
2085               if (diag)
2086                 {
2087                   error ("uninitialized reference member in %q#T",
2088                          current_class_type);
2089                   inform (DECL_SOURCE_LOCATION (field),
2090                           "%q#D should be initialized", field);
2091                 }
2092               bad = true;
2093             }
2094
2095           if (bad && deleted_p)
2096             *deleted_p = true;
2097
2098           /* Before C++20, for an implicitly-defined default constructor to
2099              be constexpr, every member must have a user-provided default
2100              constructor or an explicit initializer.  */
2101           if (constexpr_p
2102               && cxx_dialect < cxx20
2103               && !CLASS_TYPE_P (mem_type)
2104               && TREE_CODE (DECL_CONTEXT (field)) != UNION_TYPE)
2105             {
2106               *constexpr_p = false;
2107               if (diag)
2108                 inform (DECL_SOURCE_LOCATION (field),
2109                         "defaulted default constructor does not "
2110                         "initialize %q#D", field);
2111             }
2112         }
2113       else if (sfk == sfk_copy_constructor)
2114         {
2115           /* 12.8p11b5 */
2116           if (TYPE_REF_P (mem_type)
2117               && TYPE_REF_IS_RVALUE (mem_type))
2118             {
2119               if (diag)
2120                 error ("copying non-static data member %q#D of rvalue "
2121                        "reference type", field);
2122               if (deleted_p)
2123                 *deleted_p = true;
2124             }
2125         }
2126
2127       if (!CLASS_TYPE_P (mem_type))
2128         continue;
2129
2130       if (ANON_AGGR_TYPE_P (mem_type))
2131         {
2132           walk_field_subobs (TYPE_FIELDS (mem_type), sfk, fnname, quals,
2133                              spec_p, trivial_p, deleted_p, constexpr_p,
2134                              diag, flags, complain, dtor_from_ctor);
2135           continue;
2136         }
2137
2138       if (SFK_COPY_P (sfk) || SFK_MOVE_P (sfk))
2139         {
2140           int mem_quals = cp_type_quals (mem_type) | quals;
2141           if (DECL_MUTABLE_P (field))
2142             mem_quals &= ~TYPE_QUAL_CONST;
2143           argtype = build_stub_type (mem_type, mem_quals, SFK_MOVE_P (sfk));
2144         }
2145       else
2146         argtype = NULL_TREE;
2147
2148       rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
2149
2150       process_subob_fn (rval, sfk, spec_p, trivial_p, deleted_p,
2151                         constexpr_p, diag, field, dtor_from_ctor);
2152     }
2153 }
2154
2155 /* Base walker helper for synthesized_method_walk.  Inspect a direct
2156    or virtual base.  BINFO is the parent type's binfo.  BASE_BINFO is
2157    the base binfo of interests.  All other parms are as for
2158    synthesized_method_walk, or its local vars.  */
2159
2160 static tree
2161 synthesized_method_base_walk (tree binfo, tree base_binfo,
2162                               special_function_kind sfk, tree fnname, int quals,
2163                               tree *inheriting_ctor, tree inherited_parms,
2164                               int flags, bool diag,
2165                               tree *spec_p, bool *trivial_p,
2166                               bool *deleted_p, bool *constexpr_p)
2167 {
2168   bool inherited_binfo = false;
2169   tree argtype = NULL_TREE;
2170   deferring_kind defer = dk_no_deferred;
2171
2172   if (SFK_COPY_P (sfk) || SFK_MOVE_P (sfk))
2173     argtype = build_stub_type (BINFO_TYPE (base_binfo), quals, SFK_MOVE_P (sfk));
2174   else if (inheriting_ctor
2175            && (inherited_binfo
2176                = binfo_inherited_from (binfo, base_binfo, *inheriting_ctor)))
2177     {
2178       argtype = inherited_parms;
2179       /* Don't check access on the inherited constructor.  */
2180       if (flag_new_inheriting_ctors)
2181         defer = dk_deferred;
2182     }
2183   else if (cxx_dialect >= cxx14 && sfk == sfk_virtual_destructor
2184            && BINFO_VIRTUAL_P (base_binfo)
2185            && ABSTRACT_CLASS_TYPE_P (BINFO_TYPE (binfo)))
2186     /* Don't check access when looking at vbases of abstract class's
2187        virtual destructor.  */
2188     defer = dk_no_check;
2189
2190   if (defer != dk_no_deferred)
2191     push_deferring_access_checks (defer);
2192   tree rval = locate_fn_flags (base_binfo, fnname, argtype, flags,
2193                                diag ? tf_warning_or_error : tf_none);
2194   if (defer != dk_no_deferred)
2195     pop_deferring_access_checks ();
2196
2197   /* Replace an inherited template with the appropriate specialization.  */
2198   if (inherited_binfo && rval
2199       && DECL_P (*inheriting_ctor) && DECL_P (rval)
2200       && DECL_CONTEXT (*inheriting_ctor) == DECL_CONTEXT (rval))
2201     *inheriting_ctor = DECL_CLONED_FUNCTION (rval);
2202
2203   process_subob_fn (rval, sfk, spec_p, trivial_p, deleted_p,
2204                     constexpr_p, diag, BINFO_TYPE (base_binfo));
2205   if (SFK_CTOR_P (sfk)
2206       && (!BINFO_VIRTUAL_P (base_binfo)
2207           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))))
2208     {
2209       /* In a constructor we also need to check the subobject
2210          destructors for cleanup of partially constructed objects.  */
2211       tree dtor = locate_fn_flags (base_binfo, complete_dtor_identifier,
2212                                    NULL_TREE, flags,
2213                                    diag ? tf_warning_or_error : tf_none);
2214       /* Note that we don't pass down trivial_p; the subobject
2215          destructors don't affect triviality of the constructor.  Nor
2216          do they affect constexpr-ness (a constant expression doesn't
2217          throw) or exception-specification (a throw from one of the
2218          dtors would be a double-fault).  */
2219       process_subob_fn (dtor, sfk, NULL, NULL, deleted_p, NULL, false,
2220                         BINFO_TYPE (base_binfo), /*dtor_from_ctor*/true);
2221     }
2222
2223   return rval;
2224 }
2225
2226 /* The caller wants to generate an implicit declaration of SFK for
2227    CTYPE which is const if relevant and CONST_P is set.  If SPEC_P,
2228    TRIVIAL_P, DELETED_P or CONSTEXPR_P are non-null, set their
2229    referent appropriately.  If DIAG is true, we're either being called
2230    from maybe_explain_implicit_delete to give errors, or if
2231    CONSTEXPR_P is non-null, from explain_invalid_constexpr_fn.  */
2232
2233 static void
2234 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
2235                          tree *spec_p, bool *trivial_p, bool *deleted_p,
2236                          bool *constexpr_p, bool diag,
2237                          tree *inheriting_ctor, tree inherited_parms)
2238 {
2239   tree binfo, base_binfo;
2240   int i;
2241
2242   /* SFK must be exactly one category.  */
2243   gcc_checking_assert (SFK_DTOR_P(sfk) + SFK_CTOR_P(sfk)
2244                        + SFK_ASSIGN_P(sfk) == 1);
2245
2246   if (spec_p)
2247     *spec_p = (cxx_dialect >= cxx11 ? noexcept_true_spec : empty_except_spec);
2248
2249   if (deleted_p)
2250     {
2251       /* "The closure type associated with a lambda-expression has a deleted
2252          default constructor and a deleted copy assignment operator."
2253          This is diagnosed in maybe_explain_implicit_delete.
2254          In C++20, only lambda-expressions with lambda-captures have those
2255          deleted.  */
2256       if (LAMBDA_TYPE_P (ctype)
2257           && (sfk == sfk_constructor || sfk == sfk_copy_assignment)
2258           && (cxx_dialect < cxx20
2259               || LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (ctype))
2260               || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE
2261                                 (CLASSTYPE_LAMBDA_EXPR (ctype)) != CPLD_NONE))
2262         {
2263           *deleted_p = true;
2264           return;
2265         }
2266
2267       *deleted_p = false;
2268     }
2269
2270   bool check_vdtor = false;
2271   tree fnname;
2272
2273   if (SFK_DTOR_P (sfk))
2274     {
2275       check_vdtor = true;
2276       /* The synthesized method will call base dtors, but check complete
2277          here to avoid having to deal with VTT.  */
2278       fnname = complete_dtor_identifier;
2279     }
2280   else if (SFK_ASSIGN_P (sfk))
2281     fnname = assign_op_identifier;
2282   else
2283     fnname = complete_ctor_identifier;
2284
2285   gcc_assert ((sfk == sfk_inheriting_constructor)
2286               == (inheriting_ctor && *inheriting_ctor != NULL_TREE));
2287
2288   /* If that user-written default constructor would satisfy the
2289      requirements of a constexpr constructor (7.1.5), the
2290      implicitly-defined default constructor is constexpr.
2291
2292      The implicitly-defined copy/move assignment operator is constexpr if
2293       - X is a literal type, and
2294       - the assignment operator selected to copy/move each direct base class
2295         subobject is a constexpr function, and
2296       - for each non-static data member of X that is of class type (or array
2297         thereof), the assignment operator selected to copy/move that
2298         member is a constexpr function.  */
2299   if (constexpr_p)
2300     *constexpr_p = (SFK_CTOR_P (sfk)
2301                     || (SFK_ASSIGN_P (sfk) && cxx_dialect >= cxx14)
2302                     || (SFK_DTOR_P (sfk) && cxx_dialect >= cxx20));
2303
2304   bool expected_trivial = type_has_trivial_fn (ctype, sfk);
2305   if (trivial_p)
2306     *trivial_p = expected_trivial;
2307
2308   /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
2309      class versions and other properties of the type.  But a subobject
2310      class can be trivially copyable and yet have overload resolution
2311      choose a template constructor for initialization, depending on
2312      rvalueness and cv-quals.  And furthermore, a member in a base might
2313      be trivial but deleted or otherwise not callable.  So we can't exit
2314      early in C++0x.  The same considerations apply in C++98/03, but
2315      there the definition of triviality does not consider overload
2316      resolution, so a constructor can be trivial even if it would otherwise
2317      call a non-trivial constructor.  */
2318   if (expected_trivial
2319       && (!(SFK_COPY_P (sfk) || SFK_MOVE_P (sfk)) || cxx_dialect < cxx11))
2320     {
2321       if (constexpr_p && sfk == sfk_constructor)
2322         {
2323           bool cx = trivial_default_constructor_is_constexpr (ctype);
2324           *constexpr_p = cx;
2325           if (diag && !cx && TREE_CODE (ctype) == UNION_TYPE)
2326             /* A trivial constructor doesn't have any NSDMI.  */
2327             inform (input_location, "defaulted default constructor does "
2328                     "not initialize any non-static data member");
2329         }
2330       if (!diag && cxx_dialect < cxx11)
2331         return;
2332     }
2333
2334   ++cp_unevaluated_operand;
2335   ++c_inhibit_evaluation_warnings;
2336   push_deferring_access_checks (dk_no_deferred);
2337
2338   tree scope = push_scope (ctype);
2339
2340   int flags = LOOKUP_NORMAL | LOOKUP_SPECULATIVE;
2341   if (sfk != sfk_inheriting_constructor)
2342     flags |= LOOKUP_DEFAULTED;
2343
2344   tsubst_flags_t complain = diag ? tf_warning_or_error : tf_none;
2345   if (diag && spec_p)
2346     /* We're in get_defaulted_eh_spec; we don't actually want any walking
2347        diagnostics, we just want complain set.  */
2348     diag = false;
2349   int quals = const_p ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED;
2350
2351   for (binfo = TYPE_BINFO (ctype), i = 0;
2352        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
2353     {
2354       if (!SFK_ASSIGN_P (sfk) && BINFO_VIRTUAL_P (base_binfo))
2355         /* We'll handle virtual bases below.  */
2356         continue;
2357
2358       tree fn = synthesized_method_base_walk (binfo, base_binfo,
2359                                               sfk, fnname, quals,
2360                                               inheriting_ctor, inherited_parms,
2361                                               flags, diag, spec_p, trivial_p,
2362                                               deleted_p, constexpr_p);
2363
2364       if (diag && SFK_ASSIGN_P (sfk) && SFK_MOVE_P (sfk)
2365           && BINFO_VIRTUAL_P (base_binfo)
2366           && fn && TREE_CODE (fn) == FUNCTION_DECL
2367           && move_fn_p (fn) && !trivial_fn_p (fn)
2368           && vbase_has_user_provided_move_assign (BINFO_TYPE (base_binfo)))
2369         warning (OPT_Wvirtual_move_assign,
2370                  "defaulted move assignment for %qT calls a non-trivial "
2371                  "move assignment operator for virtual base %qT",
2372                  ctype, BINFO_TYPE (base_binfo));
2373
2374       if (check_vdtor && type_has_virtual_destructor (BINFO_TYPE (base_binfo)))
2375         {
2376           /* Unlike for base ctor/op=/dtor, for operator delete it's fine
2377              to have a null fn (no class-specific op delete).  */
2378           fn = locate_fn_flags (ctype, ovl_op_identifier (false, DELETE_EXPR),
2379                                 ptr_type_node, flags, tf_none);
2380           if (fn && fn == error_mark_node)
2381             {
2382               if (complain & tf_error)
2383                 locate_fn_flags (ctype, ovl_op_identifier (false, DELETE_EXPR),
2384                                  ptr_type_node, flags, complain);
2385               if (deleted_p)
2386                 *deleted_p = true;
2387             }
2388           check_vdtor = false;
2389         }
2390     }
2391
2392   vec<tree, va_gc> *vbases = CLASSTYPE_VBASECLASSES (ctype);
2393   if (SFK_ASSIGN_P (sfk))
2394     /* Already examined vbases above.  */;
2395   else if (vec_safe_is_empty (vbases))
2396     /* No virtual bases to worry about.  */;
2397   else if (ABSTRACT_CLASS_TYPE_P (ctype) && cxx_dialect >= cxx14
2398            /* DR 1658 specifies that vbases of abstract classes are
2399               ignored for both ctors and dtors.  Except DR 2336
2400               overrides that skipping when determing the eh-spec of a
2401               virtual destructor.  */
2402            && sfk != sfk_virtual_destructor)
2403     /* Vbase cdtors are not relevant.  */;
2404   else
2405     {
2406       if (constexpr_p)
2407         *constexpr_p = false;
2408
2409       FOR_EACH_VEC_ELT (*vbases, i, base_binfo)
2410         synthesized_method_base_walk (binfo, base_binfo, sfk, fnname, quals,
2411                                       inheriting_ctor, inherited_parms,
2412                                       flags, diag,
2413                                       spec_p, trivial_p, deleted_p, constexpr_p);
2414     }
2415
2416   /* Now handle the non-static data members.  */
2417   walk_field_subobs (TYPE_FIELDS (ctype), sfk, fnname, quals,
2418                      spec_p, trivial_p, deleted_p, constexpr_p,
2419                      diag, flags, complain, /*dtor_from_ctor*/false);
2420   if (SFK_CTOR_P (sfk))
2421     walk_field_subobs (TYPE_FIELDS (ctype), sfk_destructor,
2422                        complete_dtor_identifier, TYPE_UNQUALIFIED,
2423                        NULL, NULL, deleted_p, NULL,
2424                        false, flags, complain, /*dtor_from_ctor*/true);
2425
2426   pop_scope (scope);
2427
2428   pop_deferring_access_checks ();
2429   --cp_unevaluated_operand;
2430   --c_inhibit_evaluation_warnings;
2431 }
2432
2433 /* DECL is a defaulted function whose exception specification is now
2434    needed.  Return what it should be.  */
2435
2436 tree
2437 get_defaulted_eh_spec (tree decl, tsubst_flags_t complain)
2438 {
2439   /* For DECL_MAYBE_DELETED this should already have been handled by
2440      synthesize_method.  */
2441   gcc_assert (!DECL_MAYBE_DELETED (decl));
2442
2443   if (DECL_CLONED_FUNCTION_P (decl))
2444     decl = DECL_CLONED_FUNCTION (decl);
2445   special_function_kind sfk = special_function_p (decl);
2446   tree ctype = DECL_CONTEXT (decl);
2447   tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
2448   tree parm_type = TREE_VALUE (parms);
2449   bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
2450   tree spec = empty_except_spec;
2451   bool diag = !DECL_DELETED_FN (decl) && (complain & tf_error);
2452   tree inh = DECL_INHERITED_CTOR (decl);
2453   if (SFK_DTOR_P (sfk) && DECL_VIRTUAL_P (decl))
2454     /* We have to examine virtual bases even if abstract.  */
2455     sfk = sfk_virtual_destructor;
2456   bool pushed = false;
2457   if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2458     pushed = push_tinst_level (decl);
2459   synthesized_method_walk (ctype, sfk, const_p, &spec, NULL, NULL,
2460                            NULL, diag, &inh, parms);
2461   if (pushed)
2462     pop_tinst_level ();
2463   return spec;
2464 }
2465
2466 /* DECL is a deleted function.  If it's implicitly deleted, explain why and
2467    return true; else return false.  */
2468
2469 bool
2470 maybe_explain_implicit_delete (tree decl)
2471 {
2472   /* If decl is a clone, get the primary variant.  */
2473   decl = DECL_ORIGIN (decl);
2474   gcc_assert (DECL_DELETED_FN (decl));
2475   if (DECL_DEFAULTED_FN (decl))
2476     {
2477       /* Not marked GTY; it doesn't need to be GC'd or written to PCH.  */
2478       static hash_set<tree> *explained;
2479
2480       special_function_kind sfk;
2481       location_t loc;
2482       bool informed;
2483       tree ctype;
2484
2485       if (!explained)
2486         explained = new hash_set<tree>;
2487       if (explained->add (decl))
2488         return true;
2489
2490       sfk = special_function_p (decl);
2491       ctype = DECL_CONTEXT (decl);
2492       loc = input_location;
2493       input_location = DECL_SOURCE_LOCATION (decl);
2494
2495       informed = false;
2496       if (LAMBDA_TYPE_P (ctype))
2497         {
2498           informed = true;
2499           if (sfk == sfk_constructor)
2500             inform (DECL_SOURCE_LOCATION (decl),
2501                     "a lambda closure type has a deleted default constructor");
2502           else if (sfk == sfk_copy_assignment)
2503             inform (DECL_SOURCE_LOCATION (decl),
2504                     "a lambda closure type has a deleted copy assignment operator");
2505           else
2506             informed = false;
2507         }
2508       else if (DECL_ARTIFICIAL (decl)
2509                && (sfk == sfk_copy_assignment || sfk == sfk_copy_constructor)
2510                && classtype_has_move_assign_or_move_ctor_p (ctype, true))
2511         {
2512           inform (DECL_SOURCE_LOCATION (decl),
2513                   "%q#D is implicitly declared as deleted because %qT "
2514                   "declares a move constructor or move assignment operator",
2515                   decl, ctype);
2516           informed = true;
2517         }
2518       else if (sfk == sfk_inheriting_constructor)
2519         {
2520           tree binfo = inherited_ctor_binfo (decl);
2521           if (TREE_CODE (binfo) != TREE_BINFO)
2522             {
2523               inform (DECL_SOURCE_LOCATION (decl),
2524                       "%q#D inherits from multiple base subobjects",
2525                       decl);
2526               informed = true;
2527             }
2528         }
2529       if (!informed && sfk == sfk_comparison)
2530         {
2531           inform (DECL_SOURCE_LOCATION (decl),
2532                   "%q#D is implicitly deleted because the default "
2533                   "definition would be ill-formed:", decl);
2534           build_comparison_op (decl, tf_warning_or_error);
2535         }
2536       else if (!informed)
2537         {
2538           tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
2539           bool const_p = false;
2540           if (parms)
2541             {
2542               tree parm_type = TREE_VALUE (parms);
2543               const_p = CP_TYPE_CONST_P (non_reference (parm_type));
2544             }
2545           tree raises = NULL_TREE;
2546           bool deleted_p = false;
2547           tree scope = push_scope (ctype);
2548           tree inh = DECL_INHERITED_CTOR (decl);
2549
2550           synthesized_method_walk (ctype, sfk, const_p,
2551                                    &raises, NULL, &deleted_p, NULL, false,
2552                                    &inh, parms);
2553           if (deleted_p)
2554             {
2555               inform (DECL_SOURCE_LOCATION (decl),
2556                       "%q#D is implicitly deleted because the default "
2557                       "definition would be ill-formed:", decl);
2558               synthesized_method_walk (ctype, sfk, const_p,
2559                                        NULL, NULL, &deleted_p, NULL, true,
2560                                        &inh, parms);
2561             }
2562           else if (!comp_except_specs
2563                    (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
2564                     raises, ce_normal))
2565             inform (DECL_SOURCE_LOCATION (decl), "%q#F is implicitly "
2566                     "deleted because its exception-specification does not "
2567                     "match the implicit exception-specification %qX",
2568                     decl, raises);
2569           else if (flag_checking)
2570             gcc_unreachable ();
2571
2572           pop_scope (scope);
2573         }
2574
2575       input_location = loc;
2576       return true;
2577     }
2578   return false;
2579 }
2580
2581 /* DECL is a defaulted function which was declared constexpr.  Explain why
2582    it can't be constexpr.  */
2583
2584 void
2585 explain_implicit_non_constexpr (tree decl)
2586 {
2587   tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
2588   bool const_p = CP_TYPE_CONST_P (non_reference (TREE_VALUE (parms)));
2589   tree inh = DECL_INHERITED_CTOR (decl);
2590   bool dummy;
2591   special_function_kind sfk = special_function_p (decl);
2592   if (sfk == sfk_comparison)
2593     {
2594       DECL_DECLARED_CONSTEXPR_P (decl) = true;
2595       build_comparison_op (decl, tf_warning_or_error);
2596       DECL_DECLARED_CONSTEXPR_P (decl) = false;
2597     }
2598   else
2599     synthesized_method_walk (DECL_CLASS_CONTEXT (decl),
2600                              sfk, const_p,
2601                              NULL, NULL, NULL, &dummy, true,
2602                              &inh, parms);
2603 }
2604
2605 /* DECL is an instantiation of an inheriting constructor template.  Deduce
2606    the correct exception-specification and deletedness for this particular
2607    specialization.  */
2608
2609 void
2610 deduce_inheriting_ctor (tree decl)
2611 {
2612   decl = DECL_ORIGIN (decl);
2613   gcc_assert (DECL_INHERITED_CTOR (decl));
2614   tree spec;
2615   bool trivial, constexpr_, deleted;
2616   tree inh = DECL_INHERITED_CTOR (decl);
2617   synthesized_method_walk (DECL_CONTEXT (decl), sfk_inheriting_constructor,
2618                            false, &spec, &trivial, &deleted, &constexpr_,
2619                            /*diag*/false,
2620                            &inh,
2621                            FUNCTION_FIRST_USER_PARMTYPE (decl));
2622   if (TREE_CODE (inherited_ctor_binfo (decl)) != TREE_BINFO)
2623     /* Inherited the same constructor from different base subobjects.  */
2624     deleted = true;
2625   DECL_DELETED_FN (decl) = deleted;
2626   TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl), spec);
2627   SET_DECL_INHERITED_CTOR (decl, inh);
2628
2629   tree clone;
2630   FOR_EACH_CLONE (clone, decl)
2631     {
2632       DECL_DELETED_FN (clone) = deleted;
2633       TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone), spec);
2634       SET_DECL_INHERITED_CTOR (clone, inh);
2635     }
2636 }
2637
2638 /* Implicitly declare the special function indicated by KIND, as a
2639    member of TYPE.  For copy constructors and assignment operators,
2640    CONST_P indicates whether these functions should take a const
2641    reference argument or a non-const reference.
2642    Returns the FUNCTION_DECL for the implicitly declared function.  */
2643
2644 tree
2645 implicitly_declare_fn (special_function_kind kind, tree type,
2646                        bool const_p, tree pattern_fn,
2647                        tree inherited_parms)
2648 {
2649   tree fn;
2650   tree parameter_types = void_list_node;
2651   tree return_type;
2652   tree fn_type;
2653   tree raises = empty_except_spec;
2654   tree rhs_parm_type = NULL_TREE;
2655   tree this_parm;
2656   tree name;
2657   HOST_WIDE_INT saved_processing_template_decl;
2658   bool deleted_p = false;
2659   bool constexpr_p = false;
2660   tree inherited_ctor = (kind == sfk_inheriting_constructor
2661                          ? pattern_fn : NULL_TREE);
2662
2663   /* Because we create declarations for implicitly declared functions
2664      lazily, we may be creating the declaration for a member of TYPE
2665      while in some completely different context.  However, TYPE will
2666      never be a dependent class (because we never want to do lookups
2667      for implicitly defined functions in a dependent class).  */
2668   gcc_assert (!dependent_type_p (type));
2669
2670   /* If the member-specification does not explicitly declare any member or
2671      friend named operator==, an == operator function is declared
2672      implicitly for each three-way comparison operator function defined as
2673      defaulted in the member-specification, with the same access and
2674      function-definition and in the same class scope as the respective
2675      three-way comparison operator function, except that the return type is
2676      replaced with bool and the declarator-id is replaced with
2677      operator==.
2678
2679      [Note: Such an implicitly-declared == operator for a class X is
2680      defined as defaulted in the definition of X and has the same
2681      parameter-declaration-clause and trailing requires-clause as the
2682      respective three-way comparison operator. It is declared with friend,
2683      virtual, constexpr, or consteval if the three-way comparison operator
2684      function is so declared. If the three-way comparison operator function
2685      has no noexcept-specifier, the implicitly-declared == operator
2686      function has an implicit exception specification (14.5) that may
2687      differ from the implicit exception specification of the three-way
2688      comparison operator function. --end note]  */
2689   if (kind == sfk_comparison)
2690     {
2691       fn = copy_operator_fn (pattern_fn, EQ_EXPR);
2692       DECL_ARTIFICIAL (fn) = 1;
2693       TREE_TYPE (fn) = change_return_type (boolean_type_node, TREE_TYPE (fn));
2694       return fn;
2695     }
2696
2697   /* Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
2698      because we only create clones for constructors and destructors
2699      when not in a template.  */
2700   saved_processing_template_decl = processing_template_decl;
2701   processing_template_decl = 0;
2702
2703   type = TYPE_MAIN_VARIANT (type);
2704
2705   if (targetm.cxx.cdtor_returns_this ())
2706     {
2707       if (kind == sfk_destructor)
2708         /* See comment in check_special_function_return_type.  */
2709         return_type = build_pointer_type (void_type_node);
2710       else
2711         return_type = build_pointer_type (type);
2712     }
2713   else
2714     return_type = void_type_node;
2715
2716   int this_quals = TYPE_UNQUALIFIED;
2717   switch (kind)
2718     {
2719     case sfk_destructor:
2720       /* Destructor.  */
2721       name = dtor_identifier;
2722       break;
2723
2724     case sfk_constructor:
2725       /* Default constructor.  */
2726       name = ctor_identifier;
2727       break;
2728
2729     case sfk_copy_constructor:
2730     case sfk_copy_assignment:
2731     case sfk_move_constructor:
2732     case sfk_move_assignment:
2733     case sfk_inheriting_constructor:
2734     {
2735       if (kind == sfk_copy_assignment
2736           || kind == sfk_move_assignment)
2737         {
2738           return_type = build_reference_type (type);
2739           name = assign_op_identifier;
2740         }
2741       else
2742         name = ctor_identifier;
2743
2744       if (kind == sfk_inheriting_constructor)
2745         parameter_types = inherited_parms;
2746       else
2747         {
2748           if (const_p)
2749             rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
2750           else
2751             rhs_parm_type = type;
2752           bool move_p = (kind == sfk_move_assignment
2753                          || kind == sfk_move_constructor);
2754           rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
2755
2756           parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
2757         }
2758       break;
2759     }
2760
2761     default:
2762       gcc_unreachable ();
2763     }
2764
2765   bool trivial_p = false;
2766
2767   if (inherited_ctor)
2768     {
2769       /* For an inheriting constructor, just copy these flags from the
2770          inherited constructor until deduce_inheriting_ctor.  */
2771       raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (inherited_ctor));
2772       deleted_p = DECL_DELETED_FN (inherited_ctor);
2773       constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
2774     }
2775   else if (cxx_dialect >= cxx11)
2776     {
2777       raises = noexcept_deferred_spec;
2778       synthesized_method_walk (type, kind, const_p, NULL, &trivial_p,
2779                                &deleted_p, &constexpr_p, false,
2780                                &inherited_ctor, inherited_parms);
2781     }
2782   else
2783     synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
2784                              &deleted_p, &constexpr_p, false,
2785                              &inherited_ctor, inherited_parms);
2786   /* Don't bother marking a deleted constructor as constexpr.  */
2787   if (deleted_p)
2788     constexpr_p = false;
2789   /* A trivial copy/move constructor is also a constexpr constructor,
2790      unless the class has virtual bases (7.1.5p4).  */
2791   else if (trivial_p
2792            && cxx_dialect >= cxx11
2793            && (kind == sfk_copy_constructor
2794                || kind == sfk_move_constructor)
2795            && !CLASSTYPE_VBASECLASSES (type))
2796     gcc_assert (constexpr_p);
2797
2798   if (!trivial_p && type_has_trivial_fn (type, kind))
2799     type_set_nontrivial_flag (type, kind);
2800
2801   /* Create the function.  */
2802   tree this_type = cp_build_qualified_type (type, this_quals);
2803   fn_type = build_method_type_directly (this_type, return_type,
2804                                         parameter_types);
2805
2806   if (raises)
2807     {
2808       if (raises != error_mark_node)
2809         fn_type = build_exception_variant (fn_type, raises);
2810       else
2811         /* Can happen, eg, in C++98 mode for an ill-formed non-static data
2812            member initializer (c++/89914).  */
2813         gcc_assert (seen_error ());
2814     }
2815   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
2816   if (kind != sfk_inheriting_constructor)
2817     DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
2818
2819   if (IDENTIFIER_OVL_OP_P (name))
2820     {
2821       const ovl_op_info_t *op = IDENTIFIER_OVL_OP_INFO (name);
2822       DECL_OVERLOADED_OPERATOR_CODE_RAW (fn) = op->ovl_op_code;
2823     }
2824   else if (IDENTIFIER_CTOR_P (name))
2825     DECL_CXX_CONSTRUCTOR_P (fn) = true;
2826   else if (IDENTIFIER_DTOR_P (name))
2827     DECL_CXX_DESTRUCTOR_P (fn) = true;
2828   else
2829     gcc_unreachable ();
2830
2831   SET_DECL_ALIGN (fn, MINIMUM_METHOD_BOUNDARY);
2832
2833   /* Create the explicit arguments.  */
2834   if (rhs_parm_type)
2835     {
2836       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
2837          want its type to be included in the mangled function
2838          name.  */
2839       tree decl = cp_build_parm_decl (fn, NULL_TREE, rhs_parm_type);
2840       TREE_READONLY (decl) = 1;
2841       retrofit_lang_decl (decl);
2842       DECL_PARM_INDEX (decl) = DECL_PARM_LEVEL (decl) = 1;
2843       DECL_ARGUMENTS (fn) = decl;
2844     }
2845   else if (kind == sfk_inheriting_constructor)
2846     {
2847       tree *p = &DECL_ARGUMENTS (fn);
2848       int index = 1;
2849       for (tree parm = inherited_parms; parm && parm != void_list_node;
2850            parm = TREE_CHAIN (parm))
2851         {
2852           *p = cp_build_parm_decl (fn, NULL_TREE, TREE_VALUE (parm));
2853           retrofit_lang_decl (*p);
2854           DECL_PARM_LEVEL (*p) = 1;
2855           DECL_PARM_INDEX (*p) = index++;
2856           p = &DECL_CHAIN (*p);
2857         }
2858       SET_DECL_INHERITED_CTOR (fn, inherited_ctor);
2859       DECL_NONCONVERTING_P (fn) = DECL_NONCONVERTING_P (inherited_ctor);
2860       /* A constructor so declared has the same access as the corresponding
2861          constructor in X.  */
2862       TREE_PRIVATE (fn) = TREE_PRIVATE (inherited_ctor);
2863       TREE_PROTECTED (fn) = TREE_PROTECTED (inherited_ctor);
2864       /* Copy constexpr from the inherited constructor even if the
2865          inheriting constructor doesn't satisfy the requirements.  */
2866       constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
2867     }
2868
2869   /* Add the "this" parameter.  */
2870   this_parm = build_this_parm (fn, fn_type, this_quals);
2871   DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
2872   DECL_ARGUMENTS (fn) = this_parm;
2873
2874   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
2875
2876   DECL_IN_AGGR_P (fn) = 1;
2877   DECL_ARTIFICIAL (fn) = 1;
2878   DECL_DEFAULTED_FN (fn) = 1;
2879   if (cxx_dialect >= cxx11)
2880     {
2881       DECL_DELETED_FN (fn) = deleted_p;
2882       DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
2883     }
2884   DECL_EXTERNAL (fn) = true;
2885   DECL_NOT_REALLY_EXTERN (fn) = 1;
2886   DECL_DECLARED_INLINE_P (fn) = 1;
2887   set_linkage_according_to_type (type, fn);
2888   if (TREE_PUBLIC (fn))
2889     DECL_COMDAT (fn) = 1;
2890   rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
2891   gcc_assert (!TREE_USED (fn));
2892
2893   /* Propagate constraints from the inherited constructor. */
2894   if (flag_concepts && inherited_ctor)
2895     if (tree orig_ci = get_constraints (inherited_ctor))
2896       {
2897         tree new_ci = copy_node (orig_ci);
2898         set_constraints (fn, new_ci);
2899       }
2900
2901   /* Restore PROCESSING_TEMPLATE_DECL.  */
2902   processing_template_decl = saved_processing_template_decl;
2903
2904   if (inherited_ctor && TREE_CODE (inherited_ctor) == TEMPLATE_DECL)
2905     fn = add_inherited_template_parms (fn, inherited_ctor);
2906
2907   /* Warn about calling a non-trivial move assignment in a virtual base.  */
2908   if (kind == sfk_move_assignment && !deleted_p && !trivial_p
2909       && CLASSTYPE_VBASECLASSES (type))
2910     {
2911       location_t loc = input_location;
2912       input_location = DECL_SOURCE_LOCATION (fn);
2913       synthesized_method_walk (type, kind, const_p,
2914                                NULL, NULL, NULL, NULL, true,
2915                                NULL, NULL_TREE);
2916       input_location = loc;
2917     }
2918
2919   return fn;
2920 }
2921
2922 /* Gives any errors about defaulted functions which need to be deferred
2923    until the containing class is complete.  */
2924
2925 void
2926 defaulted_late_check (tree fn)
2927 {
2928   /* Complain about invalid signature for defaulted fn.  */
2929   tree ctx = DECL_CONTEXT (fn);
2930   special_function_kind kind = special_function_p (fn);
2931
2932   if (kind == sfk_comparison)
2933     {
2934       /* If the function was declared constexpr, check that the definition
2935          qualifies.  Otherwise we can define the function lazily.  */
2936       if (DECL_DECLARED_CONSTEXPR_P (fn) && !DECL_INITIAL (fn))
2937         synthesize_method (fn);
2938       return;
2939     }
2940
2941   bool fn_const_p = (copy_fn_p (fn) == 2);
2942   tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p,
2943                                             NULL, NULL);
2944   tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
2945
2946   if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
2947                     TREE_TYPE (TREE_TYPE (implicit_fn)))
2948       || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2949                      TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
2950     {
2951       error ("defaulted declaration %q+D does not match the "
2952              "expected signature", fn);
2953       inform (DECL_SOURCE_LOCATION (fn),
2954               "expected signature: %qD", implicit_fn);
2955     }
2956
2957   if (DECL_DELETED_FN (implicit_fn))
2958     {
2959       DECL_DELETED_FN (fn) = 1;
2960       return;
2961     }
2962
2963   /* If a function is explicitly defaulted on its first declaration without an
2964      exception-specification, it is implicitly considered to have the same
2965      exception-specification as if it had been implicitly declared.  */
2966   if (!TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
2967       && DECL_DEFAULTED_IN_CLASS_P (fn))
2968     TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
2969
2970   if (DECL_DEFAULTED_IN_CLASS_P (fn)
2971       && DECL_DECLARED_CONSTEXPR_P (implicit_fn))
2972     {
2973       /* Hmm...should we do this for out-of-class too? Should it be OK to
2974          add constexpr later like inline, rather than requiring
2975          declarations to match?  */
2976       DECL_DECLARED_CONSTEXPR_P (fn) = true;
2977       if (kind == sfk_constructor)
2978         TYPE_HAS_CONSTEXPR_CTOR (ctx) = true;
2979     }
2980
2981   if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
2982       && DECL_DECLARED_CONSTEXPR_P (fn))
2983     {
2984       if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
2985         {
2986           error ("explicitly defaulted function %q+D cannot be declared "
2987                  "%qs because the implicit declaration is not %qs:", fn,
2988                  DECL_IMMEDIATE_FUNCTION_P (fn) ? "consteval" : "constexpr",
2989                  "constexpr");
2990           explain_implicit_non_constexpr (fn);
2991         }
2992       DECL_DECLARED_CONSTEXPR_P (fn) = false;
2993     }
2994 }
2995
2996 /* Returns true iff FN can be explicitly defaulted, and gives any
2997    errors if defaulting FN is ill-formed.  */
2998
2999 bool
3000 defaultable_fn_check (tree fn)
3001 {
3002   special_function_kind kind = sfk_none;
3003
3004   if (template_parm_scope_p ())
3005     {
3006       error ("a template cannot be defaulted");
3007       return false;
3008     }
3009
3010   if (DECL_CONSTRUCTOR_P (fn))
3011     {
3012       if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
3013         kind = sfk_constructor;
3014       else if (copy_fn_p (fn) > 0
3015                && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
3016                    == void_list_node))
3017         kind = sfk_copy_constructor;
3018       else if (move_fn_p (fn))
3019         kind = sfk_move_constructor;
3020     }
3021   else if (DECL_DESTRUCTOR_P (fn))
3022     kind = sfk_destructor;
3023   else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
3024            && DECL_OVERLOADED_OPERATOR_IS (fn, NOP_EXPR))
3025     {
3026       if (copy_fn_p (fn))
3027         kind = sfk_copy_assignment;
3028       else if (move_fn_p (fn))
3029         kind = sfk_move_assignment;
3030     }
3031   else if (DECL_OVERLOADED_OPERATOR_CODE_RAW (fn) >= OVL_OP_EQ_EXPR
3032            && DECL_OVERLOADED_OPERATOR_CODE_RAW (fn) <= OVL_OP_SPACESHIP_EXPR)
3033     {
3034       kind = sfk_comparison;
3035       if (!early_check_defaulted_comparison (fn))
3036         return false;
3037     }
3038
3039   if (kind == sfk_none)
3040     {
3041       error ("%qD cannot be defaulted", fn);
3042       return false;
3043     }
3044   else
3045     {
3046       for (tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
3047            t && t != void_list_node; t = TREE_CHAIN (t))
3048         if (TREE_PURPOSE (t))
3049           {
3050             error ("defaulted function %q+D with default argument", fn);
3051             break;
3052           }
3053
3054       /* Avoid do_warn_unused_parameter warnings.  */
3055       for (tree p = FUNCTION_FIRST_USER_PARM (fn); p; p = DECL_CHAIN (p))
3056         if (DECL_NAME (p))
3057           TREE_NO_WARNING (p) = 1;
3058
3059       if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
3060         /* Defer checking.  */;
3061       else if (!processing_template_decl)
3062         defaulted_late_check (fn);
3063
3064       return true;
3065     }
3066 }
3067
3068 /* Add an implicit declaration to TYPE for the kind of function
3069    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
3070    declaration.  */
3071
3072 tree
3073 lazily_declare_fn (special_function_kind sfk, tree type)
3074 {
3075   tree fn;
3076   /* Whether or not the argument has a const reference type.  */
3077   bool const_p = false;
3078
3079   type = TYPE_MAIN_VARIANT (type);
3080
3081   switch (sfk)
3082     {
3083     case sfk_constructor:
3084       CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
3085       break;
3086     case sfk_copy_constructor:
3087       const_p = TYPE_HAS_CONST_COPY_CTOR (type);
3088       CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
3089       break;
3090     case sfk_move_constructor:
3091       CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
3092       break;
3093     case sfk_copy_assignment:
3094       const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
3095       CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
3096       break;
3097     case sfk_move_assignment:
3098       CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
3099       break;
3100     case sfk_destructor:
3101       CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
3102       break;
3103     default:
3104       gcc_unreachable ();
3105     }
3106
3107   /* Declare the function.  */
3108   fn = implicitly_declare_fn (sfk, type, const_p, NULL, NULL);
3109
3110   /* [class.copy]/8 If the class definition declares a move constructor or
3111      move assignment operator, the implicitly declared copy constructor is
3112      defined as deleted.... */
3113   if ((sfk == sfk_copy_assignment || sfk == sfk_copy_constructor)
3114       && cxx_dialect >= cxx11)
3115     {
3116       if (classtype_has_move_assign_or_move_ctor_p (type, true))
3117         DECL_DELETED_FN (fn) = true;
3118       else if (classtype_has_depr_implicit_copy (type))
3119         /* The implicit definition of a copy constructor as defaulted is
3120            deprecated if the class has a user-declared copy assignment operator
3121            or a user-declared destructor. The implicit definition of a copy
3122            assignment operator as defaulted is deprecated if the class has a
3123            user-declared copy constructor or a user-declared destructor (15.4,
3124            15.8).  */
3125         TREE_DEPRECATED (fn) = true;
3126     }
3127
3128   /* Destructors and assignment operators may be virtual.  */
3129   if (sfk == sfk_destructor
3130       || sfk == sfk_move_assignment
3131       || sfk == sfk_copy_assignment)
3132     check_for_override (fn, type);
3133
3134   /* Add it to the class  */
3135   bool added = add_method (type, fn, false);
3136   gcc_assert (added || errorcount);
3137
3138   /* Add it to TYPE_FIELDS.  */
3139   if (sfk == sfk_destructor
3140       && DECL_VIRTUAL_P (fn))
3141     /* The ABI requires that a virtual destructor go at the end of the
3142        vtable.  */
3143     TYPE_FIELDS (type) = chainon (TYPE_FIELDS (type), fn);
3144   else
3145     {
3146       DECL_CHAIN (fn) = TYPE_FIELDS (type);
3147       TYPE_FIELDS (type) = fn;
3148     }
3149   /* Propagate TYPE_FIELDS.  */
3150   fixup_type_variants (type);
3151
3152   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
3153   if (DECL_MAYBE_IN_CHARGE_CDTOR_P (fn))
3154     /* Create appropriate clones.  */
3155     clone_cdtor (fn, /*update_methods=*/true);
3156
3157   return fn;
3158 }
3159
3160 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
3161    as there are artificial parms in FN.  */
3162
3163 tree
3164 skip_artificial_parms_for (const_tree fn, tree list)
3165 {
3166   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3167     list = TREE_CHAIN (list);
3168   else
3169     return list;
3170
3171   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
3172     list = TREE_CHAIN (list);
3173   if (DECL_HAS_VTT_PARM_P (fn))
3174     list = TREE_CHAIN (list);
3175   return list;
3176 }
3177
3178 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
3179    artificial parms in FN.  */
3180
3181 int
3182 num_artificial_parms_for (const_tree fn)
3183 {
3184   int count = 0;
3185
3186   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3187     count++;
3188   else
3189     return 0;
3190
3191   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
3192     count++;
3193   if (DECL_HAS_VTT_PARM_P (fn))
3194     count++;
3195   return count;
3196 }
3197
3198
3199 #include "gt-cp-method.h"