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