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   if (TREE_CODE (type) != REFERENCE_TYPE)
 488     type = cp_build_reference_type (type, /*rval=*/true);
 489   exp = build_static_cast (type, exp, tf_warning_or_error);
 490   if (DECL_PACK_P (parm))
 491     exp = make_pack_expansion (exp);
 492   return exp;
 493 }
 494
 495 /* Subroutine of do_build_copy_constructor: Add a mem-initializer for BINFO
 496    given the parameter or parameters PARM, possibly inherited constructor
 497    base INH, or move flag MOVE_P.  */
 498
 499 static tree
 500 add_one_base_init (tree binfo, tree parm, bool move_p, tree inh,
 501                    tree member_init_list)
 502 {
 503   tree init;
 504   if (inh)
 505     {
 506       /* An inheriting constructor only has a mem-initializer for
 507          the base it inherits from.  */
 508       if (BINFO_TYPE (binfo) != inh)
 509         return member_init_list;
 510
 511       tree *p = &init;
 512       init = NULL_TREE;
 513       for (; parm; parm = DECL_CHAIN (parm))
 514         {
 515           tree exp = forward_parm (parm);
 516           *p = build_tree_list (NULL_TREE, exp);
 517           p = &TREE_CHAIN (*p);
 518         }
 519     }
 520   else
 521     {
 522       init = build_base_path (PLUS_EXPR, parm, binfo, 1,
 523                               tf_warning_or_error);
 524       if (move_p)
 525         init = move (init);
 526       init = build_tree_list (NULL_TREE, init);
 527     }
 528   return tree_cons (binfo, init, member_init_list);
 529 }
 530
 531 /* Generate code for default X(X&) or X(X&&) constructor or an inheriting
 532    constructor.  */
 533
 534 static void
 535 do_build_copy_constructor (tree fndecl)
 536 {
 537   tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
 538   bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
 539   bool trivial = trivial_fn_p (fndecl);
 540   tree inh = DECL_INHERITED_CTOR_BASE (fndecl);
 541
 542   if (!inh)
 543     parm = convert_from_reference (parm);
 544
 545   if (trivial
 546       && is_empty_class (current_class_type))
 547     /* Don't copy the padding byte; it might not have been allocated
 548        if *this is a base subobject.  */;
 549   else if (trivial)
 550     {
 551       tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
 552       finish_expr_stmt (t);
 553     }
 554   else
 555     {
 556       tree fields = TYPE_FIELDS (current_class_type);
 557       tree member_init_list = NULL_TREE;
 558       int cvquals = cp_type_quals (TREE_TYPE (parm));
 559       int i;
 560       tree binfo, base_binfo;
 561       tree init;
 562       vec<tree, va_gc> *vbases;
 563
 564       /* Initialize all the base-classes with the parameter converted
 565          to their type so that we get their copy constructor and not
 566          another constructor that takes current_class_type.  We must
 567          deal with the binfo's directly as a direct base might be
 568          inaccessible due to ambiguity.  */
 569       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
 570            vec_safe_iterate (vbases, i, &binfo); i++)
 571         {
 572           member_init_list = add_one_base_init (binfo, parm, move_p, inh,
 573                                                 member_init_list);
 574         }
 575
 576       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 577            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 578         {
 579           if (BINFO_VIRTUAL_P (base_binfo))
 580             continue;
 581           member_init_list = add_one_base_init (base_binfo, parm, move_p,
 582                                                 inh, member_init_list);
 583         }
 584
 585       for (; fields; fields = DECL_CHAIN (fields))
 586         {
 587           tree field = fields;
 588           tree expr_type;
 589
 590           if (TREE_CODE (field) != FIELD_DECL)
 591             continue;
 592           if (inh)
 593             continue;
 594
 595           expr_type = TREE_TYPE (field);
 596           if (DECL_NAME (field))
 597             {
 598               if (VFIELD_NAME_P (DECL_NAME (field)))
 599                 continue;
 600             }
 601           else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
 602             /* Just use the field; anonymous types can't have
 603                nontrivial copy ctors or assignment ops or this
 604                function would be deleted.  */;
 605           else
 606             continue;
 607
 608           /* Compute the type of "init->field".  If the copy-constructor
 609              parameter is, for example, "const S&", and the type of
 610              the field is "T", then the type will usually be "const
 611              T".  (There are no cv-qualified variants of reference
 612              types.)  */
 613           if (TREE_CODE (expr_type) != REFERENCE_TYPE)
 614             {
 615               int quals = cvquals;
 616
 617               if (DECL_MUTABLE_P (field))
 618                 quals &= ~TYPE_QUAL_CONST;
 619               quals |= cp_type_quals (expr_type);
 620               expr_type = cp_build_qualified_type (expr_type, quals);
 621             }
 622
 623           init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
 624           if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE
 625               /* 'move' breaks bit-fields, and has no effect for scalars.  */
 626               && !scalarish_type_p (expr_type))
 627             init = move (init);
 628           init = build_tree_list (NULL_TREE, init);
 629
 630           member_init_list = tree_cons (field, init, member_init_list);
 631         }
 632       finish_mem_initializers (member_init_list);
 633     }
 634 }
 635
 636 static void
 637 do_build_copy_assign (tree fndecl)
 638 {
 639   tree parm = DECL_CHAIN (DECL_ARGUMENTS (fndecl));
 640   tree compound_stmt;
 641   bool move_p = move_fn_p (fndecl);
 642   bool trivial = trivial_fn_p (fndecl);
 643   int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
 644
 645   compound_stmt = begin_compound_stmt (0);
 646   parm = convert_from_reference (parm);
 647
 648   if (trivial
 649       && is_empty_class (current_class_type))
 650     /* Don't copy the padding byte; it might not have been allocated
 651        if *this is a base subobject.  */;
 652   else if (trivial)
 653     {
 654       tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
 655       finish_expr_stmt (t);
 656     }
 657   else
 658     {
 659       tree fields;
 660       int cvquals = cp_type_quals (TREE_TYPE (parm));
 661       int i;
 662       tree binfo, base_binfo;
 663
 664       /* Assign to each of the direct base classes.  */
 665       for (binfo = TYPE_BINFO (current_class_type), i = 0;
 666            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 667         {
 668           tree converted_parm;
 669           vec<tree, va_gc> *parmvec;
 670
 671           /* We must convert PARM directly to the base class
 672              explicitly since the base class may be ambiguous.  */
 673           converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1,
 674                                             tf_warning_or_error);
 675           if (move_p)
 676             converted_parm = move (converted_parm);
 677           /* Call the base class assignment operator.  */
 678           parmvec = make_tree_vector_single (converted_parm);
 679           finish_expr_stmt
 680             (build_special_member_call (current_class_ref,
 681                                         ansi_assopname (NOP_EXPR),
 682                                         &parmvec,
 683                                         base_binfo,
 684                                         flags,
 685                                         tf_warning_or_error));
 686           release_tree_vector (parmvec);
 687         }
 688
 689       /* Assign to each of the non-static data members.  */
 690       for (fields = TYPE_FIELDS (current_class_type);
 691            fields;
 692            fields = DECL_CHAIN (fields))
 693         {
 694           tree comp = current_class_ref;
 695           tree init = parm;
 696           tree field = fields;
 697           tree expr_type;
 698           int quals;
 699
 700           if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
 701             continue;
 702
 703           expr_type = TREE_TYPE (field);
 704
 705           if (CP_TYPE_CONST_P (expr_type))
 706             {
 707               error ("non-static const member %q#D, can%'t use default "
 708                      "assignment operator", field);
 709               continue;
 710             }
 711           else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
 712             {
 713               error ("non-static reference member %q#D, can%'t use "
 714                      "default assignment operator", field);
 715               continue;
 716             }
 717
 718           if (DECL_NAME (field))
 719             {
 720               if (VFIELD_NAME_P (DECL_NAME (field)))
 721                 continue;
 722             }
 723           else if (ANON_AGGR_TYPE_P (expr_type)
 724                    && TYPE_FIELDS (expr_type) != NULL_TREE)
 725             /* Just use the field; anonymous types can't have
 726                nontrivial copy ctors or assignment ops or this
 727                function would be deleted.  */;
 728           else
 729             continue;
 730
 731           comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
 732
 733           /* Compute the type of init->field  */
 734           quals = cvquals;
 735           if (DECL_MUTABLE_P (field))
 736             quals &= ~TYPE_QUAL_CONST;
 737           expr_type = cp_build_qualified_type (expr_type, quals);
 738
 739           init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
 740           if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE
 741               /* 'move' breaks bit-fields, and has no effect for scalars.  */
 742               && !scalarish_type_p (expr_type))
 743             init = move (init);
 744
 745           if (DECL_NAME (field))
 746             init = cp_build_modify_expr (input_location, comp, NOP_EXPR, init,
 747                                          tf_warning_or_error);
 748           else
 749             init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
 750           finish_expr_stmt (init);
 751         }
 752     }
 753   finish_return_stmt (current_class_ref);
 754   finish_compound_stmt (compound_stmt);
 755 }
 756
 757 /* Synthesize FNDECL, a non-static member function.   */
 758
 759 void
 760 synthesize_method (tree fndecl)
 761 {
 762   bool nested = (current_function_decl != NULL_TREE);
 763   tree context = decl_function_context (fndecl);
 764   bool need_body = true;
 765   tree stmt;
 766   location_t save_input_location = input_location;
 767   int error_count = errorcount;
 768   int warning_count = warningcount + werrorcount;
 769
 770   /* Reset the source location, we might have been previously
 771      deferred, and thus have saved where we were first needed.  */
 772   DECL_SOURCE_LOCATION (fndecl)
 773     = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
 774
 775   /* If we've been asked to synthesize a clone, just synthesize the
 776      cloned function instead.  Doing so will automatically fill in the
 777      body for the clone.  */
 778   if (DECL_CLONED_FUNCTION_P (fndecl))
 779     fndecl = DECL_CLONED_FUNCTION (fndecl);
 780
 781   /* We may be in the middle of deferred access check.  Disable
 782      it now.  */
 783   push_deferring_access_checks (dk_no_deferred);
 784
 785   if (! context)
 786     push_to_top_level ();
 787   else if (nested)
 788     push_function_context ();
 789
 790   input_location = DECL_SOURCE_LOCATION (fndecl);
 791
 792   start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 793   stmt = begin_function_body ();
 794
 795   if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
 796     {
 797       do_build_copy_assign (fndecl);
 798       need_body = false;
 799     }
 800   else if (DECL_CONSTRUCTOR_P (fndecl))
 801     {
 802       tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
 803       if (arg_chain != void_list_node)
 804         do_build_copy_constructor (fndecl);
 805       else
 806         finish_mem_initializers (NULL_TREE);
 807     }
 808
 809   /* If we haven't yet generated the body of the function, just
 810      generate an empty compound statement.  */
 811   if (need_body)
 812     {
 813       tree compound_stmt;
 814       compound_stmt = begin_compound_stmt (BCS_FN_BODY);
 815       finish_compound_stmt (compound_stmt);
 816     }
 817
 818   finish_function_body (stmt);
 819   expand_or_defer_fn (finish_function (0));
 820
 821   input_location = save_input_location;
 822
 823   if (! context)
 824     pop_from_top_level ();
 825   else if (nested)
 826     pop_function_context ();
 827
 828   pop_deferring_access_checks ();
 829
 830   if (error_count != errorcount || warning_count != warningcount + werrorcount)
 831     inform (input_location, "synthesized method %qD first required here ",
 832             fndecl);
 833 }
 834
 835 /* Build a reference to type TYPE with cv-quals QUALS, which is an
 836    rvalue if RVALUE is true.  */
 837
 838 static tree
 839 build_stub_type (tree type, int quals, bool rvalue)
 840 {
 841   tree argtype = cp_build_qualified_type (type, quals);
 842   return cp_build_reference_type (argtype, rvalue);
 843 }
 844
 845 /* Build a dummy glvalue from dereferencing a dummy reference of type
 846    REFTYPE.  */
 847
 848 static tree
 849 build_stub_object (tree reftype)
 850 {
 851   if (TREE_CODE (reftype) != REFERENCE_TYPE)
 852     reftype = cp_build_reference_type (reftype, /*rval*/true);
 853   tree stub = build1 (CONVERT_EXPR, reftype, integer_one_node);
 854   return convert_from_reference (stub);
 855 }
 856
 857 /* Determine which function will be called when looking up NAME in TYPE,
 858    called with a single ARGTYPE argument, or no argument if ARGTYPE is
 859    null.  FLAGS and COMPLAIN are as for build_new_method_call.
 860
 861    Returns a FUNCTION_DECL if all is well.
 862    Returns NULL_TREE if overload resolution failed.
 863    Returns error_mark_node if the chosen function cannot be called.  */
 864
 865 static tree
 866 locate_fn_flags (tree type, tree name, tree argtype, int flags,
 867                  tsubst_flags_t complain)
 868 {
 869   tree ob, fn, fns, binfo, rval;
 870   vec<tree, va_gc> *args;
 871
 872   if (TYPE_P (type))
 873     binfo = TYPE_BINFO (type);
 874   else
 875     {
 876       binfo = type;
 877       type = BINFO_TYPE (binfo);
 878     }
 879
 880   ob = build_stub_object (cp_build_reference_type (type, false));
 881   args = make_tree_vector ();
 882   if (argtype)
 883     {
 884       if (TREE_CODE (argtype) == TREE_LIST)
 885         {
 886           for (tree elt = argtype; elt != void_list_node;
 887                elt = TREE_CHAIN (elt))
 888             {
 889               tree type = TREE_VALUE (elt);
 890               tree arg = build_stub_object (type);
 891               vec_safe_push (args, arg);
 892             }
 893         }
 894       else
 895         {
 896           tree arg = build_stub_object (argtype);
 897           args->quick_push (arg);
 898         }
 899     }
 900
 901   fns = lookup_fnfields (binfo, name, 0);
 902   rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
 903
 904   release_tree_vector (args);
 905   if (fn && rval == error_mark_node)
 906     return rval;
 907   else
 908     return fn;
 909 }
 910
 911 /* Locate the dtor of TYPE.  */
 912
 913 tree
 914 get_dtor (tree type, tsubst_flags_t complain)
 915 {
 916   tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
 917                              LOOKUP_NORMAL, complain);
 918   if (fn == error_mark_node)
 919     return NULL_TREE;
 920   return fn;
 921 }
 922
 923 /* Locate the default ctor of TYPE.  */
 924
 925 tree
 926 locate_ctor (tree type)
 927 {
 928   tree fn;
 929
 930   push_deferring_access_checks (dk_no_check);
 931   fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
 932                         LOOKUP_SPECULATIVE, tf_none);
 933   pop_deferring_access_checks ();
 934   if (fn == error_mark_node)
 935     return NULL_TREE;
 936   return fn;
 937 }
 938
 939 /* Likewise, but give any appropriate errors.  */
 940
 941 tree
 942 get_default_ctor (tree type)
 943 {
 944   tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
 945                              LOOKUP_NORMAL, tf_warning_or_error);
 946   if (fn == error_mark_node)
 947     return NULL_TREE;
 948   return fn;
 949 }
 950
 951 /* Locate the copy ctor of TYPE.  */
 952
 953 tree
 954 get_copy_ctor (tree type, tsubst_flags_t complain)
 955 {
 956   int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
 957                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
 958   tree argtype = build_stub_type (type, quals, false);
 959   tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
 960                              LOOKUP_NORMAL, complain);
 961   if (fn == error_mark_node)
 962     return NULL_TREE;
 963   return fn;
 964 }
 965
 966 /* Locate the copy assignment operator of TYPE.  */
 967
 968 tree
 969 get_copy_assign (tree type)
 970 {
 971   int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
 972                ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
 973   tree argtype = build_stub_type (type, quals, false);
 974   tree fn = locate_fn_flags (type, ansi_assopname (NOP_EXPR), argtype,
 975                              LOOKUP_NORMAL, tf_warning_or_error);
 976   if (fn == error_mark_node)
 977     return NULL_TREE;
 978   return fn;
 979 }
 980
 981 /* Locate the inherited constructor of constructor CTOR.  */
 982
 983 tree
 984 get_inherited_ctor (tree ctor)
 985 {
 986   gcc_assert (DECL_INHERITED_CTOR_BASE (ctor));
 987
 988   push_deferring_access_checks (dk_no_check);
 989   tree fn = locate_fn_flags (DECL_INHERITED_CTOR_BASE (ctor),
 990                              complete_ctor_identifier,
 991                              FUNCTION_FIRST_USER_PARMTYPE (ctor),
 992                              LOOKUP_NORMAL|LOOKUP_SPECULATIVE,
 993                              tf_none);
 994   pop_deferring_access_checks ();
 995   if (fn == error_mark_node)
 996     return NULL_TREE;
 997   return fn;
 998 }
 999
1000 /* walk_tree helper function for is_trivially_xible.  If *TP is a call,
1001    return it if it calls something other than a trivial special member
1002    function.  */
1003
1004 static tree
1005 check_nontriv (tree *tp, int *, void *)
1006 {
1007   tree fn = cp_get_callee (*tp);
1008   if (fn == NULL_TREE)
1009     return NULL_TREE;
1010
1011   if (TREE_CODE (fn) == ADDR_EXPR)
1012     fn = TREE_OPERAND (fn, 0);
1013
1014   if (TREE_CODE (fn) != FUNCTION_DECL
1015       || !trivial_fn_p (fn))
1016     return fn;
1017   return NULL_TREE;
1018 }
1019
1020 /* Return declval<T>() = declval<U>() treated as an unevaluated operand.  */
1021
1022 static tree
1023 assignable_expr (tree to, tree from)
1024 {
1025   ++cp_unevaluated_operand;
1026   to = build_stub_object (to);
1027   from = build_stub_object (from);
1028   tree r = cp_build_modify_expr (input_location, to, NOP_EXPR, from, tf_none);
1029   --cp_unevaluated_operand;
1030   return r;
1031 }
1032
1033 /* The predicate condition for a template specialization
1034    is_constructible<T, Args...> shall be satisfied if and only if the
1035    following variable definition would be well-formed for some invented
1036    variable t: T t(create<Args>()...);
1037
1038    Return something equivalent in well-formedness and triviality.  */
1039
1040 static tree
1041 constructible_expr (tree to, tree from)
1042 {
1043   tree expr;
1044   if (CLASS_TYPE_P (to))
1045     {
1046       tree ctype = to;
1047       vec<tree, va_gc> *args = NULL;
1048       if (TREE_CODE (to) != REFERENCE_TYPE)
1049         to = cp_build_reference_type (to, /*rval*/false);
1050       tree ob = build_stub_object (to);
1051       for (; from; from = TREE_CHAIN (from))
1052         vec_safe_push (args, build_stub_object (TREE_VALUE (from)));
1053       expr = build_special_member_call (ob, complete_ctor_identifier, &args,
1054                                         ctype, LOOKUP_NORMAL, tf_none);
1055       if (expr == error_mark_node)
1056         return error_mark_node;
1057       /* The current state of the standard vis-a-vis LWG 2116 is that
1058          is_*constructible involves destruction as well.  */
1059       if (type_build_dtor_call (ctype))
1060         {
1061           tree dtor = build_special_member_call (ob, complete_dtor_identifier,
1062                                                  NULL, ctype, LOOKUP_NORMAL,
1063                                                  tf_none);
1064           if (dtor == error_mark_node)
1065             return error_mark_node;
1066           if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (ctype))
1067             expr = build2 (COMPOUND_EXPR, void_type_node, expr, dtor);
1068         }
1069     }
1070   else
1071     {
1072       if (from == NULL_TREE)
1073         return build_value_init (to, tf_none);
1074       else if (TREE_CHAIN (from))
1075         return error_mark_node; // too many initializers
1076       from = build_stub_object (TREE_VALUE (from));
1077       expr = perform_direct_initialization_if_possible (to, from,
1078                                                         /*cast*/false,
1079                                                         tf_none);
1080     }
1081   return expr;
1082 }
1083
1084 /* Returns true iff TO is trivially assignable (if CODE is MODIFY_EXPR) or
1085    constructible (otherwise) from FROM, which is a single type for
1086    assignment or a list of types for construction.  */
1087
1088 bool
1089 is_trivially_xible (enum tree_code code, tree to, tree from)
1090 {
1091   tree expr;
1092   if (code == MODIFY_EXPR)
1093     expr = assignable_expr (to, from);
1094   else if (from && TREE_CHAIN (from))
1095     return false; // only 0- and 1-argument ctors can be trivial
1096   else
1097     expr = constructible_expr (to, from);
1098
1099   if (expr == error_mark_node)
1100     return false;
1101   tree nt = cp_walk_tree_without_duplicates (&expr, check_nontriv, NULL);
1102   return !nt;
1103 }
1104
1105 /* Subroutine of synthesized_method_walk.  Update SPEC_P, TRIVIAL_P and
1106    DELETED_P or give an error message MSG with argument ARG.  */
1107
1108 static void
1109 process_subob_fn (tree fn, tree *spec_p, bool *trivial_p,
1110                   bool *deleted_p, bool *constexpr_p,
1111                   bool diag, tree arg, bool dtor_from_ctor = false)
1112 {
1113   if (!fn || fn == error_mark_node)
1114     goto bad;
1115
1116   if (spec_p)
1117     {
1118       maybe_instantiate_noexcept (fn);
1119       tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
1120       *spec_p = merge_exception_specifiers (*spec_p, raises);
1121     }
1122
1123   if (!trivial_fn_p (fn) && !dtor_from_ctor)
1124     {
1125       if (trivial_p)
1126         *trivial_p = false;
1127       if (TREE_CODE (arg) == FIELD_DECL
1128           && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
1129         {
1130           if (deleted_p)
1131             *deleted_p = true;
1132           if (diag)
1133             error ("union member %q+D with non-trivial %qD", arg, fn);
1134         }
1135     }
1136
1137   if (constexpr_p && !DECL_DECLARED_CONSTEXPR_P (fn))
1138     {
1139       *constexpr_p = false;
1140       if (diag)
1141         {
1142           inform (DECL_SOURCE_LOCATION (fn),
1143                   "defaulted constructor calls non-constexpr %qD", fn);
1144           explain_invalid_constexpr_fn (fn);
1145         }
1146     }
1147
1148   return;
1149
1150  bad:
1151   if (deleted_p)
1152     *deleted_p = true;
1153 }
1154
1155 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
1156    aggregates.  If DTOR_FROM_CTOR is true, we're walking subobject destructors
1157    called from a synthesized constructor, in which case we don't consider
1158    the triviality of the subobject destructor.  */
1159
1160 static void
1161 walk_field_subobs (tree fields, tree fnname, special_function_kind sfk,
1162                    int quals, bool copy_arg_p, bool move_p,
1163                    bool assign_p, tree *spec_p, bool *trivial_p,
1164                    bool *deleted_p, bool *constexpr_p,
1165                    bool diag, int flags, tsubst_flags_t complain,
1166                    bool dtor_from_ctor)
1167 {
1168   tree field;
1169   for (field = fields; field; field = DECL_CHAIN (field))
1170     {
1171       tree mem_type, argtype, rval;
1172
1173       if (TREE_CODE (field) != FIELD_DECL
1174           || DECL_ARTIFICIAL (field))
1175         continue;
1176
1177       mem_type = strip_array_types (TREE_TYPE (field));
1178       if (assign_p)
1179         {
1180           bool bad = true;
1181           if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
1182             {
1183               if (diag)
1184                 error ("non-static const member %q#D, can%'t use default "
1185                        "assignment operator", field);
1186             }
1187           else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1188             {
1189               if (diag)
1190                 error ("non-static reference member %q#D, can%'t use "
1191                        "default assignment operator", field);
1192             }
1193           else
1194             bad = false;
1195
1196           if (bad && deleted_p)
1197             *deleted_p = true;
1198         }
1199       else if (sfk == sfk_constructor)
1200         {
1201           bool bad;
1202
1203           if (DECL_INITIAL (field))
1204             {
1205               if (diag && DECL_INITIAL (field) == error_mark_node)
1206                 inform (DECL_SOURCE_LOCATION (field),
1207                         "initializer for %q#D is invalid", field);
1208               if (trivial_p)
1209                 *trivial_p = false;
1210               /* Core 1351: If the field has an NSDMI that could throw, the
1211                  default constructor is noexcept(false).  */
1212               if (spec_p)
1213                 {
1214                   tree nsdmi = get_nsdmi (field, /*ctor*/false);
1215                   if (!expr_noexcept_p (nsdmi, complain))
1216                     *spec_p = noexcept_false_spec;
1217                 }
1218               /* Don't do the normal processing.  */
1219               continue;
1220             }
1221
1222           bad = false;
1223           if (CP_TYPE_CONST_P (mem_type)
1224               && default_init_uninitialized_part (mem_type))
1225             {
1226               if (diag)
1227                 {
1228                   error ("uninitialized const member in %q#T",
1229                          current_class_type);
1230                   inform (DECL_SOURCE_LOCATION (field),
1231                           "%q#D should be initialized", field);
1232                 }
1233               bad = true;
1234             }
1235           else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1236             {
1237               if (diag)
1238                 {
1239                   error ("uninitialized reference member in %q#T",
1240                          current_class_type);
1241                   inform (DECL_SOURCE_LOCATION (field),
1242                           "%q#D should be initialized", field);
1243                 }
1244               bad = true;
1245             }
1246
1247           if (bad && deleted_p)
1248             *deleted_p = true;
1249
1250           /* For an implicitly-defined default constructor to be constexpr,
1251              every member must have a user-provided default constructor or
1252              an explicit initializer.  */
1253           if (constexpr_p && !CLASS_TYPE_P (mem_type)
1254               && TREE_CODE (DECL_CONTEXT (field)) != UNION_TYPE)
1255             {
1256               *constexpr_p = false;
1257               if (diag)
1258                 inform (DECL_SOURCE_LOCATION (field),
1259                         "defaulted default constructor does not "
1260                         "initialize %q#D", field);
1261             }
1262         }
1263       else if (sfk == sfk_copy_constructor)
1264         {
1265           /* 12.8p11b5 */
1266           if (TREE_CODE (mem_type) == REFERENCE_TYPE
1267               && TYPE_REF_IS_RVALUE (mem_type))
1268             {
1269               if (diag)
1270                 error ("copying non-static data member %q#D of rvalue "
1271                        "reference type", field);
1272               if (deleted_p)
1273                 *deleted_p = true;
1274             }
1275         }
1276
1277       if (!CLASS_TYPE_P (mem_type))
1278         continue;
1279
1280       if (ANON_AGGR_TYPE_P (mem_type))
1281         {
1282           walk_field_subobs (TYPE_FIELDS (mem_type), fnname, sfk, quals,
1283                              copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1284                              deleted_p, constexpr_p,
1285                              diag, flags, complain, dtor_from_ctor);
1286           continue;
1287         }
1288
1289       if (copy_arg_p)
1290         {
1291           int mem_quals = cp_type_quals (mem_type) | quals;
1292           if (DECL_MUTABLE_P (field))
1293             mem_quals &= ~TYPE_QUAL_CONST;
1294           argtype = build_stub_type (mem_type, mem_quals, move_p);
1295         }
1296       else
1297         argtype = NULL_TREE;
1298
1299       rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
1300
1301       process_subob_fn (rval, spec_p, trivial_p, deleted_p,
1302                         constexpr_p, diag, field, dtor_from_ctor);
1303     }
1304 }
1305
1306 /* The caller wants to generate an implicit declaration of SFK for CTYPE
1307    which is const if relevant and CONST_P is set.  If spec_p, trivial_p and
1308    deleted_p are non-null, set their referent appropriately.  If diag is
1309    true, we're either being called from maybe_explain_implicit_delete to
1310    give errors, or if constexpr_p is non-null, from
1311    explain_invalid_constexpr_fn.  */
1312
1313 static void
1314 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
1315                          tree *spec_p, bool *trivial_p, bool *deleted_p,
1316                          bool *constexpr_p, bool diag,
1317                          tree inherited_base, tree inherited_parms)
1318 {
1319   tree binfo, base_binfo, scope, fnname, rval, argtype;
1320   bool move_p, copy_arg_p, assign_p, expected_trivial, check_vdtor;
1321   vec<tree, va_gc> *vbases;
1322   int i, quals, flags;
1323   tsubst_flags_t complain;
1324   bool ctor_p;
1325
1326   if (spec_p)
1327     *spec_p = (cxx_dialect >= cxx11 ? noexcept_true_spec : empty_except_spec);
1328
1329   if (deleted_p)
1330     {
1331       /* "The closure type associated with a lambda-expression has a deleted
1332          default constructor and a deleted copy assignment operator."
1333          This is diagnosed in maybe_explain_implicit_delete.  */
1334       if (LAMBDA_TYPE_P (ctype)
1335           && (sfk == sfk_constructor
1336               || sfk == sfk_copy_assignment))
1337         {
1338           *deleted_p = true;
1339           return;
1340         }
1341
1342       *deleted_p = false;
1343     }
1344
1345   ctor_p = false;
1346   assign_p = false;
1347   check_vdtor = false;
1348   switch (sfk)
1349     {
1350     case sfk_move_assignment:
1351     case sfk_copy_assignment:
1352       assign_p = true;
1353       fnname = ansi_assopname (NOP_EXPR);
1354       break;
1355
1356     case sfk_destructor:
1357       check_vdtor = true;
1358       /* The synthesized method will call base dtors, but check complete
1359          here to avoid having to deal with VTT.  */
1360       fnname = complete_dtor_identifier;
1361       break;
1362
1363     case sfk_constructor:
1364     case sfk_move_constructor:
1365     case sfk_copy_constructor:
1366     case sfk_inheriting_constructor:
1367       ctor_p = true;
1368       fnname = complete_ctor_identifier;
1369       break;
1370
1371     default:
1372       gcc_unreachable ();
1373     }
1374
1375   gcc_assert ((sfk == sfk_inheriting_constructor)
1376               == (inherited_base != NULL_TREE));
1377
1378   /* If that user-written default constructor would satisfy the
1379      requirements of a constexpr constructor (7.1.5), the
1380      implicitly-defined default constructor is constexpr.
1381
1382      The implicitly-defined copy/move assignment operator is constexpr if
1383       - X is a literal type, and
1384       - the assignment operator selected to copy/move each direct base class
1385         subobject is a constexpr function, and
1386       - for each non-static data member of X that is of class type (or array
1387         thereof), the assignment operator selected to copy/move that member is a
1388         constexpr function.  */
1389   if (constexpr_p)
1390     *constexpr_p = ctor_p
1391       || (assign_p && cxx_dialect >= cxx14);
1392
1393   move_p = false;
1394   switch (sfk)
1395     {
1396     case sfk_constructor:
1397     case sfk_destructor:
1398     case sfk_inheriting_constructor:
1399       copy_arg_p = false;
1400       break;
1401
1402     case sfk_move_constructor:
1403     case sfk_move_assignment:
1404       move_p = true;
1405     case sfk_copy_constructor:
1406     case sfk_copy_assignment:
1407       copy_arg_p = true;
1408       break;
1409
1410     default:
1411       gcc_unreachable ();
1412     }
1413
1414   expected_trivial = type_has_trivial_fn (ctype, sfk);
1415   if (trivial_p)
1416     *trivial_p = expected_trivial;
1417
1418   /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1419      class versions and other properties of the type.  But a subobject
1420      class can be trivially copyable and yet have overload resolution
1421      choose a template constructor for initialization, depending on
1422      rvalueness and cv-quals.  And furthermore, a member in a base might
1423      be trivial but deleted or otherwise not callable.  So we can't exit
1424      early in C++0x.  The same considerations apply in C++98/03, but
1425      there the definition of triviality does not consider overload
1426      resolution, so a constructor can be trivial even if it would otherwise
1427      call a non-trivial constructor.  */
1428   if (expected_trivial
1429       && (!copy_arg_p || cxx_dialect < cxx11))
1430     {
1431       if (constexpr_p && sfk == sfk_constructor)
1432         {
1433           bool cx = trivial_default_constructor_is_constexpr (ctype);
1434           *constexpr_p = cx;
1435           if (diag && !cx && TREE_CODE (ctype) == UNION_TYPE)
1436             /* A trivial constructor doesn't have any NSDMI.  */
1437             inform (input_location, "defaulted default constructor does "
1438                     "not initialize any non-static data member");
1439         }
1440       if (!diag && cxx_dialect < cxx11)
1441         return;
1442     }
1443
1444   ++cp_unevaluated_operand;
1445   ++c_inhibit_evaluation_warnings;
1446   push_deferring_access_checks (dk_no_deferred);
1447
1448   scope = push_scope (ctype);
1449
1450   flags = LOOKUP_NORMAL|LOOKUP_SPECULATIVE;
1451   if (!inherited_base)
1452     flags |= LOOKUP_DEFAULTED;
1453
1454   complain = diag ? tf_warning_or_error : tf_none;
1455
1456   if (const_p)
1457     quals = TYPE_QUAL_CONST;
1458   else
1459     quals = TYPE_UNQUALIFIED;
1460   argtype = NULL_TREE;
1461
1462   for (binfo = TYPE_BINFO (ctype), i = 0;
1463        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1464     {
1465       tree basetype = BINFO_TYPE (base_binfo);
1466
1467       if (!assign_p && BINFO_VIRTUAL_P (base_binfo))
1468         /* We'll handle virtual bases below.  */
1469         continue;
1470
1471       if (copy_arg_p)
1472         argtype = build_stub_type (basetype, quals, move_p);
1473       else if (basetype == inherited_base)
1474         argtype = inherited_parms;
1475       rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1476       if (inherited_base)
1477         argtype = NULL_TREE;
1478
1479       process_subob_fn (rval, spec_p, trivial_p, deleted_p,
1480                         constexpr_p, diag, basetype);
1481       if (ctor_p)
1482         {
1483           /* In a constructor we also need to check the subobject
1484              destructors for cleanup of partially constructed objects.  */
1485           rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1486                                   NULL_TREE, flags, complain);
1487           /* Note that we don't pass down trivial_p; the subobject
1488              destructors don't affect triviality of the constructor.  Nor
1489              do they affect constexpr-ness (a constant expression doesn't
1490              throw) or exception-specification (a throw from one of the
1491              dtors would be a double-fault).  */
1492           process_subob_fn (rval, NULL, NULL,
1493                             deleted_p, NULL, false,
1494                             basetype, /*dtor_from_ctor*/true);
1495         }
1496
1497       if (check_vdtor && type_has_virtual_destructor (basetype))
1498         {
1499           rval = locate_fn_flags (ctype, ansi_opname (DELETE_EXPR),
1500                                   ptr_type_node, flags, complain);
1501           /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1502              to have a null rval (no class-specific op delete).  */
1503           if (rval && rval == error_mark_node && deleted_p)
1504             *deleted_p = true;
1505           check_vdtor = false;
1506         }
1507
1508       if (diag && assign_p && move_p
1509           && BINFO_VIRTUAL_P (base_binfo)
1510           && rval && TREE_CODE (rval) == FUNCTION_DECL
1511           && move_fn_p (rval) && !trivial_fn_p (rval)
1512           && vbase_has_user_provided_move_assign (basetype))
1513         warning (OPT_Wvirtual_move_assign,
1514                  "defaulted move assignment for %qT calls a non-trivial "
1515                  "move assignment operator for virtual base %qT",
1516                  ctype, basetype);
1517     }
1518
1519   vbases = CLASSTYPE_VBASECLASSES (ctype);
1520   if (vec_safe_is_empty (vbases))
1521     /* No virtual bases to worry about.  */;
1522   else if (!assign_p)
1523     {
1524       if (constexpr_p)
1525         *constexpr_p = false;
1526       FOR_EACH_VEC_ELT (*vbases, i, base_binfo)
1527         {
1528           tree basetype = BINFO_TYPE (base_binfo);
1529           if (copy_arg_p)
1530             argtype = build_stub_type (basetype, quals, move_p);
1531           rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1532
1533           process_subob_fn (rval, spec_p, trivial_p, deleted_p,
1534                             constexpr_p, diag, basetype);
1535           if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1536             {
1537               rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1538                                       NULL_TREE, flags, complain);
1539               process_subob_fn (rval, NULL, NULL,
1540                                 deleted_p, NULL, false,
1541                                 basetype, /*dtor_from_ctor*/true);
1542             }
1543         }
1544     }
1545
1546   /* Now handle the non-static data members.  */
1547   walk_field_subobs (TYPE_FIELDS (ctype), fnname, sfk, quals,
1548                      copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1549                      deleted_p, constexpr_p,
1550                      diag, flags, complain, /*dtor_from_ctor*/false);
1551   if (ctor_p)
1552     walk_field_subobs (TYPE_FIELDS (ctype), complete_dtor_identifier,
1553                        sfk_destructor, TYPE_UNQUALIFIED, false,
1554                        false, false, NULL, NULL,
1555                        deleted_p, NULL,
1556                        false, flags, complain, /*dtor_from_ctor*/true);
1557
1558   pop_scope (scope);
1559
1560   pop_deferring_access_checks ();
1561   --cp_unevaluated_operand;
1562   --c_inhibit_evaluation_warnings;
1563 }
1564
1565 /* DECL is a defaulted function whose exception specification is now
1566    needed.  Return what it should be.  */
1567
1568 tree
1569 get_defaulted_eh_spec (tree decl)
1570 {
1571   if (DECL_CLONED_FUNCTION_P (decl))
1572     decl = DECL_CLONED_FUNCTION (decl);
1573   special_function_kind sfk = special_function_p (decl);
1574   tree ctype = DECL_CONTEXT (decl);
1575   tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
1576   tree parm_type = TREE_VALUE (parms);
1577   bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1578   tree spec = empty_except_spec;
1579   synthesized_method_walk (ctype, sfk, const_p, &spec, NULL, NULL,
1580                            NULL, false, DECL_INHERITED_CTOR_BASE (decl),
1581                            parms);
1582   return spec;
1583 }
1584
1585 /* DECL is a deleted function.  If it's implicitly deleted, explain why and
1586    return true; else return false.  */
1587
1588 bool
1589 maybe_explain_implicit_delete (tree decl)
1590 {
1591   /* If decl is a clone, get the primary variant.  */
1592   decl = DECL_ORIGIN (decl);
1593   gcc_assert (DECL_DELETED_FN (decl));
1594   if (DECL_DEFAULTED_FN (decl))
1595     {
1596       /* Not marked GTY; it doesn't need to be GC'd or written to PCH.  */
1597       static hash_set<tree> *explained;
1598
1599       special_function_kind sfk;
1600       location_t loc;
1601       bool informed;
1602       tree ctype;
1603
1604       if (!explained)
1605         explained = new hash_set<tree>;
1606       if (explained->add (decl))
1607         return true;
1608
1609       sfk = special_function_p (decl);
1610       ctype = DECL_CONTEXT (decl);
1611       loc = input_location;
1612       input_location = DECL_SOURCE_LOCATION (decl);
1613
1614       informed = false;
1615       if (LAMBDA_TYPE_P (ctype))
1616         {
1617           informed = true;
1618           if (sfk == sfk_constructor)
1619             inform (DECL_SOURCE_LOCATION (decl),
1620                     "a lambda closure type has a deleted default constructor");
1621           else if (sfk == sfk_copy_assignment)
1622             inform (DECL_SOURCE_LOCATION (decl),
1623                     "a lambda closure type has a deleted copy assignment operator");
1624           else
1625             informed = false;
1626         }
1627       else if (DECL_ARTIFICIAL (decl)
1628                && (sfk == sfk_copy_assignment
1629                    || sfk == sfk_copy_constructor)
1630                && (type_has_user_declared_move_constructor (ctype)
1631                    || type_has_user_declared_move_assign (ctype)))
1632         {
1633           inform (DECL_SOURCE_LOCATION (decl),
1634                   "%q#D is implicitly declared as deleted because %qT "
1635                   "declares a move constructor or move assignment operator",
1636                   decl, ctype);
1637           informed = true;
1638         }
1639       if (!informed)
1640         {
1641           tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
1642           tree parm_type = TREE_VALUE (parms);
1643           bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1644           tree raises = NULL_TREE;
1645           bool deleted_p = false;
1646           tree scope = push_scope (ctype);
1647
1648           synthesized_method_walk (ctype, sfk, const_p,
1649                                    &raises, NULL, &deleted_p, NULL, false,
1650                                    DECL_INHERITED_CTOR_BASE (decl), parms);
1651           if (deleted_p)
1652             {
1653               inform (DECL_SOURCE_LOCATION (decl),
1654                       "%q#D is implicitly deleted because the default "
1655                       "definition would be ill-formed:", decl);
1656               synthesized_method_walk (ctype, sfk, const_p,
1657                                        NULL, NULL, NULL, NULL, true,
1658                                        DECL_INHERITED_CTOR_BASE (decl), parms);
1659             }
1660           else if (!comp_except_specs
1661                    (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
1662                     raises, ce_normal))
1663             inform (DECL_SOURCE_LOCATION (decl), "%q#F is implicitly "
1664                     "deleted because its exception-specification does not "
1665                     "match the implicit exception-specification %qX",
1666                     decl, raises);
1667           else if (flag_checking)
1668             gcc_unreachable ();
1669
1670           pop_scope (scope);
1671         }
1672
1673       input_location = loc;
1674       return true;
1675     }
1676   return false;
1677 }
1678
1679 /* DECL is a defaulted function which was declared constexpr.  Explain why
1680    it can't be constexpr.  */
1681
1682 void
1683 explain_implicit_non_constexpr (tree decl)
1684 {
1685   tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1686   bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1687   bool dummy;
1688   synthesized_method_walk (DECL_CLASS_CONTEXT (decl),
1689                            special_function_p (decl), const_p,
1690                            NULL, NULL, NULL, &dummy, true,
1691                            DECL_INHERITED_CTOR_BASE (decl),
1692                            FUNCTION_FIRST_USER_PARMTYPE (decl));
1693 }
1694
1695 /* DECL is an instantiation of an inheriting constructor template.  Deduce
1696    the correct exception-specification and deletedness for this particular
1697    specialization.  */
1698
1699 void
1700 deduce_inheriting_ctor (tree decl)
1701 {
1702   gcc_assert (DECL_INHERITED_CTOR_BASE (decl));
1703   tree spec;
1704   bool trivial, constexpr_, deleted;
1705   synthesized_method_walk (DECL_CONTEXT (decl), sfk_inheriting_constructor,
1706                            false, &spec, &trivial, &deleted, &constexpr_,
1707                            /*diag*/false,
1708                            DECL_INHERITED_CTOR_BASE (decl),
1709                            FUNCTION_FIRST_USER_PARMTYPE (decl));
1710   DECL_DELETED_FN (decl) = deleted;
1711   TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl), spec);
1712 }
1713
1714 /* Implicitly declare the special function indicated by KIND, as a
1715    member of TYPE.  For copy constructors and assignment operators,
1716    CONST_P indicates whether these functions should take a const
1717    reference argument or a non-const reference.  Returns the
1718    FUNCTION_DECL for the implicitly declared function.  */
1719
1720 tree
1721 implicitly_declare_fn (special_function_kind kind, tree type,
1722                        bool const_p, tree inherited_ctor,
1723                        tree inherited_parms)
1724 {
1725   tree fn;
1726   tree parameter_types = void_list_node;
1727   tree return_type;
1728   tree fn_type;
1729   tree raises = empty_except_spec;
1730   tree rhs_parm_type = NULL_TREE;
1731   tree this_parm;
1732   tree name;
1733   HOST_WIDE_INT saved_processing_template_decl;
1734   bool deleted_p;
1735   bool constexpr_p;
1736
1737   /* Because we create declarations for implicitly declared functions
1738      lazily, we may be creating the declaration for a member of TYPE
1739      while in some completely different context.  However, TYPE will
1740      never be a dependent class (because we never want to do lookups
1741      for implicitly defined functions in a dependent class).
1742      Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1743      because we only create clones for constructors and destructors
1744      when not in a template.  */
1745   gcc_assert (!dependent_type_p (type));
1746   saved_processing_template_decl = processing_template_decl;
1747   processing_template_decl = 0;
1748
1749   type = TYPE_MAIN_VARIANT (type);
1750
1751   if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1752     {
1753       if (kind == sfk_destructor)
1754         /* See comment in check_special_function_return_type.  */
1755         return_type = build_pointer_type (void_type_node);
1756       else
1757         return_type = build_pointer_type (type);
1758     }
1759   else
1760     return_type = void_type_node;
1761
1762   switch (kind)
1763     {
1764     case sfk_destructor:
1765       /* Destructor.  */
1766       name = constructor_name (type);
1767       break;
1768
1769     case sfk_constructor:
1770       /* Default constructor.  */
1771       name = constructor_name (type);
1772       break;
1773
1774     case sfk_copy_constructor:
1775     case sfk_copy_assignment:
1776     case sfk_move_constructor:
1777     case sfk_move_assignment:
1778     case sfk_inheriting_constructor:
1779     {
1780       bool move_p;
1781       if (kind == sfk_copy_assignment
1782           || kind == sfk_move_assignment)
1783         {
1784           return_type = build_reference_type (type);
1785           name = ansi_assopname (NOP_EXPR);
1786         }
1787       else
1788         name = constructor_name (type);
1789
1790       if (kind == sfk_inheriting_constructor)
1791         parameter_types = inherited_parms;
1792       else
1793         {
1794           if (const_p)
1795             rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1796           else
1797             rhs_parm_type = type;
1798           move_p = (kind == sfk_move_assignment
1799                     || kind == sfk_move_constructor);
1800           rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
1801
1802           parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1803         }
1804       break;
1805     }
1806     default:
1807       gcc_unreachable ();
1808     }
1809
1810   tree inherited_base = (inherited_ctor
1811                          ? DECL_CONTEXT (inherited_ctor)
1812                          : NULL_TREE);
1813   bool trivial_p = false;
1814
1815   if (inherited_ctor && TREE_CODE (inherited_ctor) == TEMPLATE_DECL)
1816     {
1817       /* For an inheriting constructor template, just copy these flags from
1818          the inherited constructor template for now.  */
1819       raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (inherited_ctor));
1820       deleted_p = DECL_DELETED_FN (inherited_ctor);
1821       constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
1822     }
1823   else if (cxx_dialect >= cxx11)
1824     {
1825       raises = unevaluated_noexcept_spec ();
1826       synthesized_method_walk (type, kind, const_p, NULL, &trivial_p,
1827                                &deleted_p, &constexpr_p, false,
1828                                inherited_base, inherited_parms);
1829     }
1830   else
1831     synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
1832                              &deleted_p, &constexpr_p, false,
1833                              inherited_base, inherited_parms);
1834   /* Don't bother marking a deleted constructor as constexpr.  */
1835   if (deleted_p)
1836     constexpr_p = false;
1837   /* A trivial copy/move constructor is also a constexpr constructor,
1838      unless the class has virtual bases (7.1.5p4).  */
1839   else if (trivial_p && cxx_dialect >= cxx11
1840            && (kind == sfk_copy_constructor
1841                || kind == sfk_move_constructor)
1842            && !CLASSTYPE_VBASECLASSES (type))
1843     gcc_assert (constexpr_p);
1844
1845   if (!trivial_p && type_has_trivial_fn (type, kind))
1846     type_set_nontrivial_flag (type, kind);
1847
1848   /* Create the function.  */
1849   fn_type = build_method_type_directly (type, return_type, parameter_types);
1850   if (raises)
1851     fn_type = build_exception_variant (fn_type, raises);
1852   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1853   if (kind != sfk_inheriting_constructor)
1854     DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1855   if (kind == sfk_constructor || kind == sfk_copy_constructor
1856       || kind == sfk_move_constructor || kind == sfk_inheriting_constructor)
1857     DECL_CONSTRUCTOR_P (fn) = 1;
1858   else if (kind == sfk_destructor)
1859     DECL_DESTRUCTOR_P (fn) = 1;
1860   else
1861     {
1862       DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1863       SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1864     }
1865
1866   SET_DECL_ALIGN (fn, MINIMUM_METHOD_BOUNDARY);
1867
1868   /* Create the explicit arguments.  */
1869   if (rhs_parm_type)
1870     {
1871       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1872          want its type to be included in the mangled function
1873          name.  */
1874       tree decl = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1875       TREE_READONLY (decl) = 1;
1876       retrofit_lang_decl (decl);
1877       DECL_PARM_INDEX (decl) = DECL_PARM_LEVEL (decl) = 1;
1878       DECL_ARGUMENTS (fn) = decl;
1879     }
1880   else if (kind == sfk_inheriting_constructor)
1881     {
1882       tree *p = &DECL_ARGUMENTS (fn);
1883       int index = 1;
1884       for (tree parm = inherited_parms; parm != void_list_node;
1885            parm = TREE_CHAIN (parm))
1886         {
1887           *p = cp_build_parm_decl (NULL_TREE, TREE_VALUE (parm));
1888           retrofit_lang_decl (*p);
1889           DECL_PARM_LEVEL (*p) = 1;
1890           DECL_PARM_INDEX (*p) = index++;
1891           DECL_CONTEXT (*p) = fn;
1892           p = &DECL_CHAIN (*p);
1893         }
1894       SET_DECL_INHERITED_CTOR_BASE (fn, inherited_base);
1895       DECL_NONCONVERTING_P (fn) = DECL_NONCONVERTING_P (inherited_ctor);
1896       /* A constructor so declared has the same access as the corresponding
1897          constructor in X.  */
1898       TREE_PRIVATE (fn) = TREE_PRIVATE (inherited_ctor);
1899       TREE_PROTECTED (fn) = TREE_PROTECTED (inherited_ctor);
1900       /* Copy constexpr from the inherited constructor even if the
1901          inheriting constructor doesn't satisfy the requirements.  */
1902       constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
1903     }
1904   /* Add the "this" parameter.  */
1905   this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1906   DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1907   DECL_ARGUMENTS (fn) = this_parm;
1908
1909   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1910   DECL_IN_AGGR_P (fn) = 1;
1911   DECL_ARTIFICIAL (fn) = 1;
1912   DECL_DEFAULTED_FN (fn) = 1;
1913   if (cxx_dialect >= cxx11)
1914     {
1915       /* "The closure type associated with a lambda-expression has a deleted
1916          default constructor and a deleted copy assignment operator."  */
1917       if ((kind == sfk_constructor
1918            || kind == sfk_copy_assignment)
1919           && LAMBDA_TYPE_P (type))
1920         deleted_p = true;
1921       DECL_DELETED_FN (fn) = deleted_p;
1922       DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
1923     }
1924   DECL_EXTERNAL (fn) = true;
1925   DECL_NOT_REALLY_EXTERN (fn) = 1;
1926   DECL_DECLARED_INLINE_P (fn) = 1;
1927   set_linkage_according_to_type (type, fn);
1928   if (TREE_PUBLIC (fn))
1929     DECL_COMDAT (fn) = 1;
1930   rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1931   gcc_assert (!TREE_USED (fn));
1932
1933   /* Propagate constraints from the inherited constructor. */
1934   if (flag_concepts && inherited_ctor)
1935     if (tree orig_ci = get_constraints (inherited_ctor))
1936       {
1937         tree new_ci = copy_node (orig_ci);
1938         set_constraints (fn, new_ci);
1939       }
1940
1941   /* Restore PROCESSING_TEMPLATE_DECL.  */
1942   processing_template_decl = saved_processing_template_decl;
1943
1944   if (inherited_ctor && TREE_CODE (inherited_ctor) == TEMPLATE_DECL)
1945     fn = add_inherited_template_parms (fn, inherited_ctor);
1946
1947   /* Warn about calling a non-trivial move assignment in a virtual base.  */
1948   if (kind == sfk_move_assignment && !deleted_p && !trivial_p
1949       && CLASSTYPE_VBASECLASSES (type))
1950     {
1951       location_t loc = input_location;
1952       input_location = DECL_SOURCE_LOCATION (fn);
1953       synthesized_method_walk (type, kind, const_p,
1954                                NULL, NULL, NULL, NULL, true,
1955                                NULL_TREE, NULL_TREE);
1956       input_location = loc;
1957     }
1958
1959   return fn;
1960 }
1961
1962 /* Gives any errors about defaulted functions which need to be deferred
1963    until the containing class is complete.  */
1964
1965 void
1966 defaulted_late_check (tree fn)
1967 {
1968   /* Complain about invalid signature for defaulted fn.  */
1969   tree ctx = DECL_CONTEXT (fn);
1970   special_function_kind kind = special_function_p (fn);
1971   bool fn_const_p = (copy_fn_p (fn) == 2);
1972   tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p,
1973                                             NULL, NULL);
1974   tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
1975
1976   if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
1977                     TREE_TYPE (TREE_TYPE (implicit_fn)))
1978       || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1979                      TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
1980     {
1981       error ("defaulted declaration %q+D", fn);
1982       error_at (DECL_SOURCE_LOCATION (fn),
1983                 "does not match expected signature %qD", implicit_fn);
1984     }
1985
1986   /* 8.4.2/2: An explicitly-defaulted function (...) may have an explicit
1987      exception-specification only if it is compatible (15.4) with the
1988      exception-specification on the implicit declaration.  If a function
1989      is explicitly defaulted on its first declaration, (...) it is
1990      implicitly considered to have the same exception-specification as if
1991      it had been implicitly declared.  */
1992   maybe_instantiate_noexcept (fn);
1993   tree fn_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
1994   if (!fn_spec)
1995     {
1996       if (DECL_DEFAULTED_IN_CLASS_P (fn))
1997         TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
1998     }
1999   else if (UNEVALUATED_NOEXCEPT_SPEC_P (fn_spec))
2000     /* Equivalent to the implicit spec.  */;
2001   else if (DECL_DEFAULTED_IN_CLASS_P (fn)
2002            && !CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
2003     /* We can't compare an explicit exception-specification on a
2004        constructor defaulted in the class body to the implicit
2005        exception-specification until after we've parsed any NSDMI; see
2006        after_nsdmi_defaulted_late_checks.  */;
2007   else
2008     {
2009       tree eh_spec = get_defaulted_eh_spec (fn);
2010       if (!comp_except_specs (fn_spec, eh_spec, ce_normal))
2011         {
2012           if (DECL_DEFAULTED_IN_CLASS_P (fn))
2013             DECL_DELETED_FN (fn) = true;
2014           else
2015             error ("function %q+D defaulted on its redeclaration "
2016                    "with an exception-specification that differs from "
2017                    "the implicit exception-specification %qX", fn, eh_spec);
2018         }
2019     }
2020
2021   if (DECL_DEFAULTED_IN_CLASS_P (fn)
2022       && DECL_DECLARED_CONSTEXPR_P (implicit_fn))
2023     {
2024       /* Hmm...should we do this for out-of-class too? Should it be OK to
2025          add constexpr later like inline, rather than requiring
2026          declarations to match?  */
2027       DECL_DECLARED_CONSTEXPR_P (fn) = true;
2028       if (kind == sfk_constructor)
2029         TYPE_HAS_CONSTEXPR_CTOR (ctx) = true;
2030     }
2031
2032   if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
2033       && DECL_DECLARED_CONSTEXPR_P (fn))
2034     {
2035       if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
2036         {
2037           error ("explicitly defaulted function %q+D cannot be declared "
2038                  "as constexpr because the implicit declaration is not "
2039                  "constexpr:", fn);
2040           explain_implicit_non_constexpr (fn);
2041         }
2042       DECL_DECLARED_CONSTEXPR_P (fn) = false;
2043     }
2044
2045   if (DECL_DELETED_FN (implicit_fn))
2046     DECL_DELETED_FN (fn) = 1;
2047 }
2048
2049 /* OK, we've parsed the NSDMI for class T, now we can check any explicit
2050    exception-specifications on functions defaulted in the class body.  */
2051
2052 void
2053 after_nsdmi_defaulted_late_checks (tree t)
2054 {
2055   if (uses_template_parms (t))
2056     return;
2057   if (t == error_mark_node)
2058     return;
2059   for (tree fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
2060     if (!DECL_ARTIFICIAL (fn) && DECL_DEFAULTED_IN_CLASS_P (fn))
2061       {
2062         tree fn_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
2063         if (UNEVALUATED_NOEXCEPT_SPEC_P (fn_spec))
2064           continue;
2065
2066         tree eh_spec = get_defaulted_eh_spec (fn);
2067         if (!comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)),
2068                                 eh_spec, ce_normal))
2069           DECL_DELETED_FN (fn) = true;
2070       }
2071 }
2072
2073 /* Returns true iff FN can be explicitly defaulted, and gives any
2074    errors if defaulting FN is ill-formed.  */
2075
2076 bool
2077 defaultable_fn_check (tree fn)
2078 {
2079   special_function_kind kind = sfk_none;
2080
2081   if (template_parm_scope_p ())
2082     {
2083       error ("a template cannot be defaulted");
2084       return false;
2085     }
2086
2087   if (DECL_CONSTRUCTOR_P (fn))
2088     {
2089       if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
2090         kind = sfk_constructor;
2091       else if (copy_fn_p (fn) > 0
2092                && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
2093                    == void_list_node))
2094         kind = sfk_copy_constructor;
2095       else if (move_fn_p (fn))
2096         kind = sfk_move_constructor;
2097     }
2098   else if (DECL_DESTRUCTOR_P (fn))
2099     kind = sfk_destructor;
2100   else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
2101            && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
2102     {
2103       if (copy_fn_p (fn))
2104         kind = sfk_copy_assignment;
2105       else if (move_fn_p (fn))
2106         kind = sfk_move_assignment;
2107     }
2108
2109   if (kind == sfk_none)
2110     {
2111       error ("%qD cannot be defaulted", fn);
2112       return false;
2113     }
2114   else
2115     {
2116       for (tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
2117            t && t != void_list_node; t = TREE_CHAIN (t))
2118         if (TREE_PURPOSE (t))
2119           {
2120             error ("defaulted function %q+D with default argument", fn);
2121             break;
2122           }
2123
2124       /* Avoid do_warn_unused_parameter warnings.  */
2125       for (tree p = FUNCTION_FIRST_USER_PARM (fn); p; p = DECL_CHAIN (p))
2126         if (DECL_NAME (p))
2127           TREE_NO_WARNING (p) = 1;
2128
2129       if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
2130         /* Defer checking.  */;
2131       else if (!processing_template_decl)
2132         defaulted_late_check (fn);
2133
2134       return true;
2135     }
2136 }
2137
2138 /* Add an implicit declaration to TYPE for the kind of function
2139    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
2140    declaration.  */
2141
2142 tree
2143 lazily_declare_fn (special_function_kind sfk, tree type)
2144 {
2145   tree fn;
2146   /* Whether or not the argument has a const reference type.  */
2147   bool const_p = false;
2148
2149   type = TYPE_MAIN_VARIANT (type);
2150
2151   switch (sfk)
2152     {
2153     case sfk_constructor:
2154       CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
2155       break;
2156     case sfk_copy_constructor:
2157       const_p = TYPE_HAS_CONST_COPY_CTOR (type);
2158       CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
2159       break;
2160     case sfk_move_constructor:
2161       CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
2162       break;
2163     case sfk_copy_assignment:
2164       const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
2165       CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
2166       break;
2167     case sfk_move_assignment:
2168       CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
2169       break;
2170     case sfk_destructor:
2171       CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
2172       break;
2173     default:
2174       gcc_unreachable ();
2175     }
2176
2177   /* Declare the function.  */
2178   fn = implicitly_declare_fn (sfk, type, const_p, NULL, NULL);
2179
2180   /* [class.copy]/8 If the class definition declares a move constructor or
2181      move assignment operator, the implicitly declared copy constructor is
2182      defined as deleted.... */
2183   if ((sfk == sfk_copy_assignment
2184        || sfk == sfk_copy_constructor)
2185       && (type_has_user_declared_move_constructor (type)
2186           || type_has_user_declared_move_assign (type)))
2187     DECL_DELETED_FN (fn) = true;
2188
2189   /* A destructor may be virtual.  */
2190   if (sfk == sfk_destructor
2191       || sfk == sfk_move_assignment
2192       || sfk == sfk_copy_assignment)
2193     check_for_override (fn, type);
2194   /* Add it to CLASSTYPE_METHOD_VEC.  */
2195   add_method (type, fn, NULL_TREE);
2196   /* Add it to TYPE_METHODS.  */
2197   if (sfk == sfk_destructor
2198       && DECL_VIRTUAL_P (fn))
2199     /* The ABI requires that a virtual destructor go at the end of the
2200        vtable.  */
2201     TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
2202   else
2203     {
2204       DECL_CHAIN (fn) = TYPE_METHODS (type);
2205       TYPE_METHODS (type) = fn;
2206     }
2207   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
2208   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
2209       || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
2210     /* Create appropriate clones.  */
2211     clone_function_decl (fn, /*update_method_vec=*/true);
2212
2213   return fn;
2214 }
2215
2216 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
2217    as there are artificial parms in FN.  */
2218
2219 tree
2220 skip_artificial_parms_for (const_tree fn, tree list)
2221 {
2222   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
2223     list = TREE_CHAIN (list);
2224   else
2225     return list;
2226
2227   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
2228     list = TREE_CHAIN (list);
2229   if (DECL_HAS_VTT_PARM_P (fn))
2230     list = TREE_CHAIN (list);
2231   return list;
2232 }
2233
2234 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
2235    artificial parms in FN.  */
2236
2237 int
2238 num_artificial_parms_for (const_tree fn)
2239 {
2240   int count = 0;
2241
2242   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
2243     count++;
2244   else
2245     return 0;
2246
2247   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
2248     count++;
2249   if (DECL_HAS_VTT_PARM_P (fn))
2250     count++;
2251   return count;
2252 }
2253
2254
2255 #include "gt-cp-method.h"