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 (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;
1008   if (TREE_CODE (*tp) == CALL_EXPR)
1009     fn = CALL_EXPR_FN (*tp);
1010   else if (TREE_CODE (*tp) == AGGR_INIT_EXPR)
1011     fn = AGGR_INIT_EXPR_FN (*tp);
1012   else
1013     return NULL_TREE;
1014
1015   if (TREE_CODE (fn) == ADDR_EXPR)
1016     fn = TREE_OPERAND (fn, 0);
1017
1018   if (TREE_CODE (fn) != FUNCTION_DECL
1019       || !trivial_fn_p (fn))
1020     return fn;
1021   return NULL_TREE;
1022 }
1023
1024 /* Return declval<T>() = declval<U>() treated as an unevaluated operand.  */
1025
1026 static tree
1027 assignable_expr (tree to, tree from)
1028 {
1029   ++cp_unevaluated_operand;
1030   to = build_stub_object (to);
1031   from = build_stub_object (from);
1032   tree r = cp_build_modify_expr (to, NOP_EXPR, from, tf_none);
1033   --cp_unevaluated_operand;
1034   return r;
1035 }
1036
1037 /* The predicate condition for a template specialization
1038    is_constructible<T, Args...> shall be satisfied if and only if the
1039    following variable definition would be well-formed for some invented
1040    variable t: T t(create<Args>()...);
1041
1042    Return something equivalent in well-formedness and triviality.  */
1043
1044 static tree
1045 constructible_expr (tree to, tree from)
1046 {
1047   tree expr;
1048   if (CLASS_TYPE_P (to))
1049     {
1050       tree ctype = to;
1051       vec<tree, va_gc> *args = NULL;
1052       if (TREE_CODE (to) != REFERENCE_TYPE)
1053         to = cp_build_reference_type (to, /*rval*/false);
1054       tree ob = build_stub_object (to);
1055       for (; from; from = TREE_CHAIN (from))
1056         vec_safe_push (args, build_stub_object (TREE_VALUE (from)));
1057       expr = build_special_member_call (ob, complete_ctor_identifier, &args,
1058                                         ctype, LOOKUP_NORMAL, tf_none);
1059       if (expr == error_mark_node)
1060         return error_mark_node;
1061       /* The current state of the standard vis-a-vis LWG 2116 is that
1062          is_*constructible involves destruction as well.  */
1063       if (type_build_dtor_call (ctype))
1064         {
1065           tree dtor = build_special_member_call (ob, complete_dtor_identifier,
1066                                                  NULL, ctype, LOOKUP_NORMAL,
1067                                                  tf_none);
1068           if (dtor == error_mark_node)
1069             return error_mark_node;
1070           if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (ctype))
1071             expr = build2 (COMPOUND_EXPR, void_type_node, expr, dtor);
1072         }
1073     }
1074   else
1075     {
1076       if (from == NULL_TREE)
1077         return build_value_init (to, tf_none);
1078       else if (TREE_CHAIN (from))
1079         return error_mark_node; // too many initializers
1080       from = build_stub_object (TREE_VALUE (from));
1081       expr = perform_direct_initialization_if_possible (to, from,
1082                                                         /*cast*/false,
1083                                                         tf_none);
1084     }
1085   return expr;
1086 }
1087
1088 /* Returns true iff TO is trivially assignable (if CODE is MODIFY_EXPR) or
1089    constructible (otherwise) from FROM, which is a single type for
1090    assignment or a list of types for construction.  */
1091
1092 bool
1093 is_trivially_xible (enum tree_code code, tree to, tree from)
1094 {
1095   tree expr;
1096   if (code == MODIFY_EXPR)
1097     expr = assignable_expr (to, from);
1098   else if (from && TREE_CHAIN (from))
1099     return false; // only 0- and 1-argument ctors can be trivial
1100   else
1101     expr = constructible_expr (to, from);
1102
1103   if (expr == error_mark_node)
1104     return false;
1105   tree nt = cp_walk_tree_without_duplicates (&expr, check_nontriv, NULL);
1106   return !nt;
1107 }
1108
1109 /* Subroutine of synthesized_method_walk.  Update SPEC_P, TRIVIAL_P and
1110    DELETED_P or give an error message MSG with argument ARG.  */
1111
1112 static void
1113 process_subob_fn (tree fn, tree *spec_p, bool *trivial_p,
1114                   bool *deleted_p, bool *constexpr_p,
1115                   bool diag, tree arg, bool dtor_from_ctor = false)
1116 {
1117   if (!fn || fn == error_mark_node)
1118     goto bad;
1119
1120   if (spec_p)
1121     {
1122       maybe_instantiate_noexcept (fn);
1123       tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
1124       *spec_p = merge_exception_specifiers (*spec_p, raises);
1125     }
1126
1127   if (!trivial_fn_p (fn) && !dtor_from_ctor)
1128     {
1129       if (trivial_p)
1130         *trivial_p = false;
1131       if (TREE_CODE (arg) == FIELD_DECL
1132           && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
1133         {
1134           if (deleted_p)
1135             *deleted_p = true;
1136           if (diag)
1137             error ("union member %q+D with non-trivial %qD", arg, fn);
1138         }
1139     }
1140
1141   if (constexpr_p && !DECL_DECLARED_CONSTEXPR_P (fn))
1142     {
1143       *constexpr_p = false;
1144       if (diag)
1145         {
1146           inform (DECL_SOURCE_LOCATION (fn),
1147                   "defaulted constructor calls non-constexpr %qD", fn);
1148           explain_invalid_constexpr_fn (fn);
1149         }
1150     }
1151
1152   return;
1153
1154  bad:
1155   if (deleted_p)
1156     *deleted_p = true;
1157 }
1158
1159 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
1160    aggregates.  If DTOR_FROM_CTOR is true, we're walking subobject destructors
1161    called from a synthesized constructor, in which case we don't consider
1162    the triviality of the subobject destructor.  */
1163
1164 static void
1165 walk_field_subobs (tree fields, tree fnname, special_function_kind sfk,
1166                    int quals, bool copy_arg_p, bool move_p,
1167                    bool assign_p, tree *spec_p, bool *trivial_p,
1168                    bool *deleted_p, bool *constexpr_p,
1169                    bool diag, int flags, tsubst_flags_t complain,
1170                    bool dtor_from_ctor)
1171 {
1172   tree field;
1173   for (field = fields; field; field = DECL_CHAIN (field))
1174     {
1175       tree mem_type, argtype, rval;
1176
1177       if (TREE_CODE (field) != FIELD_DECL
1178           || DECL_ARTIFICIAL (field))
1179         continue;
1180
1181       mem_type = strip_array_types (TREE_TYPE (field));
1182       if (assign_p)
1183         {
1184           bool bad = true;
1185           if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
1186             {
1187               if (diag)
1188                 error ("non-static const member %q#D, can%'t use default "
1189                        "assignment operator", field);
1190             }
1191           else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1192             {
1193               if (diag)
1194                 error ("non-static reference member %q#D, can%'t use "
1195                        "default assignment operator", field);
1196             }
1197           else
1198             bad = false;
1199
1200           if (bad && deleted_p)
1201             *deleted_p = true;
1202         }
1203       else if (sfk == sfk_constructor)
1204         {
1205           bool bad;
1206
1207           if (DECL_INITIAL (field))
1208             {
1209               if (diag && DECL_INITIAL (field) == error_mark_node)
1210                 inform (DECL_SOURCE_LOCATION (field),
1211                         "initializer for %q#D is invalid", field);
1212               if (trivial_p)
1213                 *trivial_p = false;
1214               /* Core 1351: If the field has an NSDMI that could throw, the
1215                  default constructor is noexcept(false).  */
1216               if (spec_p)
1217                 {
1218                   tree nsdmi = get_nsdmi (field, /*ctor*/false);
1219                   if (!expr_noexcept_p (nsdmi, complain))
1220                     *spec_p = noexcept_false_spec;
1221                 }
1222               /* Don't do the normal processing.  */
1223               continue;
1224             }
1225
1226           bad = false;
1227           if (CP_TYPE_CONST_P (mem_type)
1228               && default_init_uninitialized_part (mem_type))
1229             {
1230               if (diag)
1231                 {
1232                   error ("uninitialized const member in %q#T",
1233                          current_class_type);
1234                   inform (DECL_SOURCE_LOCATION (field),
1235                           "%q#D should be initialized", field);
1236                 }
1237               bad = true;
1238             }
1239           else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1240             {
1241               if (diag)
1242                 {
1243                   error ("uninitialized reference member in %q#T",
1244                          current_class_type);
1245                   inform (DECL_SOURCE_LOCATION (field),
1246                           "%q#D should be initialized", field);
1247                 }
1248               bad = true;
1249             }
1250
1251           if (bad && deleted_p)
1252             *deleted_p = true;
1253
1254           /* For an implicitly-defined default constructor to be constexpr,
1255              every member must have a user-provided default constructor or
1256              an explicit initializer.  */
1257           if (constexpr_p && !CLASS_TYPE_P (mem_type)
1258               && TREE_CODE (DECL_CONTEXT (field)) != UNION_TYPE)
1259             {
1260               *constexpr_p = false;
1261               if (diag)
1262                 inform (DECL_SOURCE_LOCATION (field),
1263                         "defaulted default constructor does not "
1264                         "initialize %q#D", field);
1265             }
1266         }
1267       else if (sfk == sfk_copy_constructor)
1268         {
1269           /* 12.8p11b5 */
1270           if (TREE_CODE (mem_type) == REFERENCE_TYPE
1271               && TYPE_REF_IS_RVALUE (mem_type))
1272             {
1273               if (diag)
1274                 error ("copying non-static data member %q#D of rvalue "
1275                        "reference type", field);
1276               if (deleted_p)
1277                 *deleted_p = true;
1278             }
1279         }
1280
1281       if (!CLASS_TYPE_P (mem_type))
1282         continue;
1283
1284       if (ANON_AGGR_TYPE_P (mem_type))
1285         {
1286           walk_field_subobs (TYPE_FIELDS (mem_type), fnname, sfk, quals,
1287                              copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1288                              deleted_p, constexpr_p,
1289                              diag, flags, complain, dtor_from_ctor);
1290           continue;
1291         }
1292
1293       if (copy_arg_p)
1294         {
1295           int mem_quals = cp_type_quals (mem_type) | quals;
1296           if (DECL_MUTABLE_P (field))
1297             mem_quals &= ~TYPE_QUAL_CONST;
1298           argtype = build_stub_type (mem_type, mem_quals, move_p);
1299         }
1300       else
1301         argtype = NULL_TREE;
1302
1303       rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
1304
1305       process_subob_fn (rval, spec_p, trivial_p, deleted_p,
1306                         constexpr_p, diag, field, dtor_from_ctor);
1307     }
1308 }
1309
1310 /* The caller wants to generate an implicit declaration of SFK for CTYPE
1311    which is const if relevant and CONST_P is set.  If spec_p, trivial_p and
1312    deleted_p are non-null, set their referent appropriately.  If diag is
1313    true, we're either being called from maybe_explain_implicit_delete to
1314    give errors, or if constexpr_p is non-null, from
1315    explain_invalid_constexpr_fn.  */
1316
1317 static void
1318 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
1319                          tree *spec_p, bool *trivial_p, bool *deleted_p,
1320                          bool *constexpr_p, bool diag,
1321                          tree inherited_base, tree inherited_parms)
1322 {
1323   tree binfo, base_binfo, scope, fnname, rval, argtype;
1324   bool move_p, copy_arg_p, assign_p, expected_trivial, check_vdtor;
1325   vec<tree, va_gc> *vbases;
1326   int i, quals, flags;
1327   tsubst_flags_t complain;
1328   bool ctor_p;
1329
1330   if (spec_p)
1331     *spec_p = (cxx_dialect >= cxx11 ? noexcept_true_spec : empty_except_spec);
1332
1333   if (deleted_p)
1334     {
1335       /* "The closure type associated with a lambda-expression has a deleted
1336          default constructor and a deleted copy assignment operator."
1337          This is diagnosed in maybe_explain_implicit_delete.  */
1338       if (LAMBDA_TYPE_P (ctype)
1339           && (sfk == sfk_constructor
1340               || sfk == sfk_copy_assignment))
1341         {
1342           *deleted_p = true;
1343           return;
1344         }
1345
1346       *deleted_p = false;
1347     }
1348
1349   ctor_p = false;
1350   assign_p = false;
1351   check_vdtor = false;
1352   switch (sfk)
1353     {
1354     case sfk_move_assignment:
1355     case sfk_copy_assignment:
1356       assign_p = true;
1357       fnname = ansi_assopname (NOP_EXPR);
1358       break;
1359
1360     case sfk_destructor:
1361       check_vdtor = true;
1362       /* The synthesized method will call base dtors, but check complete
1363          here to avoid having to deal with VTT.  */
1364       fnname = complete_dtor_identifier;
1365       break;
1366
1367     case sfk_constructor:
1368     case sfk_move_constructor:
1369     case sfk_copy_constructor:
1370     case sfk_inheriting_constructor:
1371       ctor_p = true;
1372       fnname = complete_ctor_identifier;
1373       break;
1374
1375     default:
1376       gcc_unreachable ();
1377     }
1378
1379   gcc_assert ((sfk == sfk_inheriting_constructor)
1380               == (inherited_base != NULL_TREE));
1381
1382   /* If that user-written default constructor would satisfy the
1383      requirements of a constexpr constructor (7.1.5), the
1384      implicitly-defined default constructor is constexpr.
1385
1386      The implicitly-defined copy/move assignment operator is constexpr if
1387       - X is a literal type, and
1388       - the assignment operator selected to copy/move each direct base class
1389         subobject is a constexpr function, and
1390       - for each non-static data member of X that is of class type (or array
1391         thereof), the assignment operator selected to copy/move that member is a
1392         constexpr function.  */
1393   if (constexpr_p)
1394     *constexpr_p = ctor_p
1395       || (assign_p && cxx_dialect >= cxx14);
1396
1397   move_p = false;
1398   switch (sfk)
1399     {
1400     case sfk_constructor:
1401     case sfk_destructor:
1402     case sfk_inheriting_constructor:
1403       copy_arg_p = false;
1404       break;
1405
1406     case sfk_move_constructor:
1407     case sfk_move_assignment:
1408       move_p = true;
1409     case sfk_copy_constructor:
1410     case sfk_copy_assignment:
1411       copy_arg_p = true;
1412       break;
1413
1414     default:
1415       gcc_unreachable ();
1416     }
1417
1418   expected_trivial = type_has_trivial_fn (ctype, sfk);
1419   if (trivial_p)
1420     *trivial_p = expected_trivial;
1421
1422   /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1423      class versions and other properties of the type.  But a subobject
1424      class can be trivially copyable and yet have overload resolution
1425      choose a template constructor for initialization, depending on
1426      rvalueness and cv-quals.  And furthermore, a member in a base might
1427      be trivial but deleted or otherwise not callable.  So we can't exit
1428      early in C++0x.  The same considerations apply in C++98/03, but
1429      there the definition of triviality does not consider overload
1430      resolution, so a constructor can be trivial even if it would otherwise
1431      call a non-trivial constructor.  */
1432   if (expected_trivial
1433       && (!copy_arg_p || cxx_dialect < cxx11))
1434     {
1435       if (constexpr_p && sfk == sfk_constructor)
1436         {
1437           bool cx = trivial_default_constructor_is_constexpr (ctype);
1438           *constexpr_p = cx;
1439           if (diag && !cx && TREE_CODE (ctype) == UNION_TYPE)
1440             /* A trivial constructor doesn't have any NSDMI.  */
1441             inform (input_location, "defaulted default constructor does "
1442                     "not initialize any non-static data member");
1443         }
1444       if (!diag && cxx_dialect < cxx11)
1445         return;
1446     }
1447
1448   ++cp_unevaluated_operand;
1449   ++c_inhibit_evaluation_warnings;
1450   push_deferring_access_checks (dk_no_deferred);
1451
1452   scope = push_scope (ctype);
1453
1454   flags = LOOKUP_NORMAL|LOOKUP_SPECULATIVE;
1455   if (!inherited_base)
1456     flags |= LOOKUP_DEFAULTED;
1457
1458   complain = diag ? tf_warning_or_error : tf_none;
1459
1460   if (const_p)
1461     quals = TYPE_QUAL_CONST;
1462   else
1463     quals = TYPE_UNQUALIFIED;
1464   argtype = NULL_TREE;
1465
1466   for (binfo = TYPE_BINFO (ctype), i = 0;
1467        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1468     {
1469       tree basetype = BINFO_TYPE (base_binfo);
1470
1471       if (!assign_p && BINFO_VIRTUAL_P (base_binfo))
1472         /* We'll handle virtual bases below.  */
1473         continue;
1474
1475       if (copy_arg_p)
1476         argtype = build_stub_type (basetype, quals, move_p);
1477       else if (basetype == inherited_base)
1478         argtype = inherited_parms;
1479       rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1480       if (inherited_base)
1481         argtype = NULL_TREE;
1482
1483       process_subob_fn (rval, spec_p, trivial_p, deleted_p,
1484                         constexpr_p, diag, basetype);
1485       if (ctor_p)
1486         {
1487           /* In a constructor we also need to check the subobject
1488              destructors for cleanup of partially constructed objects.  */
1489           rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1490                                   NULL_TREE, flags, complain);
1491           /* Note that we don't pass down trivial_p; the subobject
1492              destructors don't affect triviality of the constructor.  Nor
1493              do they affect constexpr-ness (a constant expression doesn't
1494              throw) or exception-specification (a throw from one of the
1495              dtors would be a double-fault).  */
1496           process_subob_fn (rval, NULL, NULL,
1497                             deleted_p, NULL, false,
1498                             basetype, /*dtor_from_ctor*/true);
1499         }
1500
1501       if (check_vdtor && type_has_virtual_destructor (basetype))
1502         {
1503           rval = locate_fn_flags (ctype, ansi_opname (DELETE_EXPR),
1504                                   ptr_type_node, flags, complain);
1505           /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1506              to have a null rval (no class-specific op delete).  */
1507           if (rval && rval == error_mark_node && deleted_p)
1508             *deleted_p = true;
1509           check_vdtor = false;
1510         }
1511
1512       if (diag && assign_p && move_p
1513           && BINFO_VIRTUAL_P (base_binfo)
1514           && rval && TREE_CODE (rval) == FUNCTION_DECL
1515           && move_fn_p (rval) && !trivial_fn_p (rval)
1516           && vbase_has_user_provided_move_assign (basetype))
1517         warning (OPT_Wvirtual_move_assign,
1518                  "defaulted move assignment for %qT calls a non-trivial "
1519                  "move assignment operator for virtual base %qT",
1520                  ctype, basetype);
1521     }
1522
1523   vbases = CLASSTYPE_VBASECLASSES (ctype);
1524   if (vec_safe_is_empty (vbases))
1525     /* No virtual bases to worry about.  */;
1526   else if (!assign_p)
1527     {
1528       if (constexpr_p)
1529         *constexpr_p = false;
1530       FOR_EACH_VEC_ELT (*vbases, i, base_binfo)
1531         {
1532           tree basetype = BINFO_TYPE (base_binfo);
1533           if (copy_arg_p)
1534             argtype = build_stub_type (basetype, quals, move_p);
1535           rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1536
1537           process_subob_fn (rval, spec_p, trivial_p, deleted_p,
1538                             constexpr_p, diag, basetype);
1539           if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1540             {
1541               rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1542                                       NULL_TREE, flags, complain);
1543               process_subob_fn (rval, NULL, NULL,
1544                                 deleted_p, NULL, false,
1545                                 basetype, /*dtor_from_ctor*/true);
1546             }
1547         }
1548     }
1549
1550   /* Now handle the non-static data members.  */
1551   walk_field_subobs (TYPE_FIELDS (ctype), fnname, sfk, quals,
1552                      copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1553                      deleted_p, constexpr_p,
1554                      diag, flags, complain, /*dtor_from_ctor*/false);
1555   if (ctor_p)
1556     walk_field_subobs (TYPE_FIELDS (ctype), complete_dtor_identifier,
1557                        sfk_destructor, TYPE_UNQUALIFIED, false,
1558                        false, false, NULL, NULL,
1559                        deleted_p, NULL,
1560                        false, flags, complain, /*dtor_from_ctor*/true);
1561
1562   pop_scope (scope);
1563
1564   pop_deferring_access_checks ();
1565   --cp_unevaluated_operand;
1566   --c_inhibit_evaluation_warnings;
1567 }
1568
1569 /* DECL is a defaulted function whose exception specification is now
1570    needed.  Return what it should be.  */
1571
1572 tree
1573 get_defaulted_eh_spec (tree decl)
1574 {
1575   if (DECL_CLONED_FUNCTION_P (decl))
1576     decl = DECL_CLONED_FUNCTION (decl);
1577   special_function_kind sfk = special_function_p (decl);
1578   tree ctype = DECL_CONTEXT (decl);
1579   tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
1580   tree parm_type = TREE_VALUE (parms);
1581   bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1582   tree spec = empty_except_spec;
1583   synthesized_method_walk (ctype, sfk, const_p, &spec, NULL, NULL,
1584                            NULL, false, DECL_INHERITED_CTOR_BASE (decl),
1585                            parms);
1586   return spec;
1587 }
1588
1589 /* DECL is a deleted function.  If it's implicitly deleted, explain why and
1590    return true; else return false.  */
1591
1592 bool
1593 maybe_explain_implicit_delete (tree decl)
1594 {
1595   /* If decl is a clone, get the primary variant.  */
1596   decl = DECL_ORIGIN (decl);
1597   gcc_assert (DECL_DELETED_FN (decl));
1598   if (DECL_DEFAULTED_FN (decl))
1599     {
1600       /* Not marked GTY; it doesn't need to be GC'd or written to PCH.  */
1601       static hash_set<tree> *explained;
1602
1603       special_function_kind sfk;
1604       location_t loc;
1605       bool informed;
1606       tree ctype;
1607
1608       if (!explained)
1609         explained = new hash_set<tree>;
1610       if (explained->add (decl))
1611         return true;
1612
1613       sfk = special_function_p (decl);
1614       ctype = DECL_CONTEXT (decl);
1615       loc = input_location;
1616       input_location = DECL_SOURCE_LOCATION (decl);
1617
1618       informed = false;
1619       if (LAMBDA_TYPE_P (ctype))
1620         {
1621           informed = true;
1622           if (sfk == sfk_constructor)
1623             inform (DECL_SOURCE_LOCATION (decl),
1624                     "a lambda closure type has a deleted default constructor");
1625           else if (sfk == sfk_copy_assignment)
1626             inform (DECL_SOURCE_LOCATION (decl),
1627                     "a lambda closure type has a deleted copy assignment operator");
1628           else
1629             informed = false;
1630         }
1631       else if (DECL_ARTIFICIAL (decl)
1632                && (sfk == sfk_copy_assignment
1633                    || sfk == sfk_copy_constructor)
1634                && (type_has_user_declared_move_constructor (ctype)
1635                    || type_has_user_declared_move_assign (ctype)))
1636         {
1637           inform (DECL_SOURCE_LOCATION (decl),
1638                   "%q#D is implicitly declared as deleted because %qT "
1639                   "declares a move constructor or move assignment operator",
1640                   decl, ctype);
1641           informed = true;
1642         }
1643       if (!informed)
1644         {
1645           tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
1646           tree parm_type = TREE_VALUE (parms);
1647           bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1648           tree raises = NULL_TREE;
1649           bool deleted_p = false;
1650           tree scope = push_scope (ctype);
1651
1652           synthesized_method_walk (ctype, sfk, const_p,
1653                                    &raises, NULL, &deleted_p, NULL, false,
1654                                    DECL_INHERITED_CTOR_BASE (decl), parms);
1655           if (deleted_p)
1656             {
1657               inform (DECL_SOURCE_LOCATION (decl),
1658                       "%q#D is implicitly deleted because the default "
1659                       "definition would be ill-formed:", decl);
1660               synthesized_method_walk (ctype, sfk, const_p,
1661                                        NULL, NULL, NULL, NULL, true,
1662                                        DECL_INHERITED_CTOR_BASE (decl), parms);
1663             }
1664           else if (!comp_except_specs
1665                    (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
1666                     raises, ce_normal))
1667             inform (DECL_SOURCE_LOCATION (decl), "%q#F is implicitly "
1668                     "deleted because its exception-specification does not "
1669                     "match the implicit exception-specification %qX",
1670                     decl, raises);
1671           else if (flag_checking)
1672             gcc_unreachable ();
1673
1674           pop_scope (scope);
1675         }
1676
1677       input_location = loc;
1678       return true;
1679     }
1680   return false;
1681 }
1682
1683 /* DECL is a defaulted function which was declared constexpr.  Explain why
1684    it can't be constexpr.  */
1685
1686 void
1687 explain_implicit_non_constexpr (tree decl)
1688 {
1689   tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1690   bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1691   bool dummy;
1692   synthesized_method_walk (DECL_CLASS_CONTEXT (decl),
1693                            special_function_p (decl), const_p,
1694                            NULL, NULL, NULL, &dummy, true,
1695                            DECL_INHERITED_CTOR_BASE (decl),
1696                            FUNCTION_FIRST_USER_PARMTYPE (decl));
1697 }
1698
1699 /* DECL is an instantiation of an inheriting constructor template.  Deduce
1700    the correct exception-specification and deletedness for this particular
1701    specialization.  */
1702
1703 void
1704 deduce_inheriting_ctor (tree decl)
1705 {
1706   gcc_assert (DECL_INHERITED_CTOR_BASE (decl));
1707   tree spec;
1708   bool trivial, constexpr_, deleted;
1709   synthesized_method_walk (DECL_CONTEXT (decl), sfk_inheriting_constructor,
1710                            false, &spec, &trivial, &deleted, &constexpr_,
1711                            /*diag*/false,
1712                            DECL_INHERITED_CTOR_BASE (decl),
1713                            FUNCTION_FIRST_USER_PARMTYPE (decl));
1714   DECL_DELETED_FN (decl) = deleted;
1715   TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl), spec);
1716 }
1717
1718 /* Implicitly declare the special function indicated by KIND, as a
1719    member of TYPE.  For copy constructors and assignment operators,
1720    CONST_P indicates whether these functions should take a const
1721    reference argument or a non-const reference.  Returns the
1722    FUNCTION_DECL for the implicitly declared function.  */
1723
1724 tree
1725 implicitly_declare_fn (special_function_kind kind, tree type,
1726                        bool const_p, tree inherited_ctor,
1727                        tree inherited_parms)
1728 {
1729   tree fn;
1730   tree parameter_types = void_list_node;
1731   tree return_type;
1732   tree fn_type;
1733   tree raises = empty_except_spec;
1734   tree rhs_parm_type = NULL_TREE;
1735   tree this_parm;
1736   tree name;
1737   HOST_WIDE_INT saved_processing_template_decl;
1738   bool deleted_p;
1739   bool constexpr_p;
1740
1741   /* Because we create declarations for implicitly declared functions
1742      lazily, we may be creating the declaration for a member of TYPE
1743      while in some completely different context.  However, TYPE will
1744      never be a dependent class (because we never want to do lookups
1745      for implicitly defined functions in a dependent class).
1746      Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1747      because we only create clones for constructors and destructors
1748      when not in a template.  */
1749   gcc_assert (!dependent_type_p (type));
1750   saved_processing_template_decl = processing_template_decl;
1751   processing_template_decl = 0;
1752
1753   type = TYPE_MAIN_VARIANT (type);
1754
1755   if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1756     {
1757       if (kind == sfk_destructor)
1758         /* See comment in check_special_function_return_type.  */
1759         return_type = build_pointer_type (void_type_node);
1760       else
1761         return_type = build_pointer_type (type);
1762     }
1763   else
1764     return_type = void_type_node;
1765
1766   switch (kind)
1767     {
1768     case sfk_destructor:
1769       /* Destructor.  */
1770       name = constructor_name (type);
1771       break;
1772
1773     case sfk_constructor:
1774       /* Default constructor.  */
1775       name = constructor_name (type);
1776       break;
1777
1778     case sfk_copy_constructor:
1779     case sfk_copy_assignment:
1780     case sfk_move_constructor:
1781     case sfk_move_assignment:
1782     case sfk_inheriting_constructor:
1783     {
1784       bool move_p;
1785       if (kind == sfk_copy_assignment
1786           || kind == sfk_move_assignment)
1787         {
1788           return_type = build_reference_type (type);
1789           name = ansi_assopname (NOP_EXPR);
1790         }
1791       else
1792         name = constructor_name (type);
1793
1794       if (kind == sfk_inheriting_constructor)
1795         parameter_types = inherited_parms;
1796       else
1797         {
1798           if (const_p)
1799             rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1800           else
1801             rhs_parm_type = type;
1802           move_p = (kind == sfk_move_assignment
1803                     || kind == sfk_move_constructor);
1804           rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
1805
1806           parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1807         }
1808       break;
1809     }
1810     default:
1811       gcc_unreachable ();
1812     }
1813
1814   tree inherited_base = (inherited_ctor
1815                          ? DECL_CONTEXT (inherited_ctor)
1816                          : NULL_TREE);
1817   bool trivial_p = false;
1818
1819   if (inherited_ctor && TREE_CODE (inherited_ctor) == TEMPLATE_DECL)
1820     {
1821       /* For an inheriting constructor template, just copy these flags from
1822          the inherited constructor template for now.  */
1823       raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (inherited_ctor));
1824       deleted_p = DECL_DELETED_FN (inherited_ctor);
1825       constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
1826     }
1827   else if (cxx_dialect >= cxx11)
1828     {
1829       raises = unevaluated_noexcept_spec ();
1830       synthesized_method_walk (type, kind, const_p, NULL, &trivial_p,
1831                                &deleted_p, &constexpr_p, false,
1832                                inherited_base, inherited_parms);
1833     }
1834   else
1835     synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
1836                              &deleted_p, &constexpr_p, false,
1837                              inherited_base, inherited_parms);
1838   /* Don't bother marking a deleted constructor as constexpr.  */
1839   if (deleted_p)
1840     constexpr_p = false;
1841   /* A trivial copy/move constructor is also a constexpr constructor,
1842      unless the class has virtual bases (7.1.5p4).  */
1843   else if (trivial_p && cxx_dialect >= cxx11
1844            && (kind == sfk_copy_constructor
1845                || kind == sfk_move_constructor)
1846            && !CLASSTYPE_VBASECLASSES (type))
1847     gcc_assert (constexpr_p);
1848
1849   if (!trivial_p && type_has_trivial_fn (type, kind))
1850     type_set_nontrivial_flag (type, kind);
1851
1852   /* Create the function.  */
1853   fn_type = build_method_type_directly (type, return_type, parameter_types);
1854   if (raises)
1855     fn_type = build_exception_variant (fn_type, raises);
1856   fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1857   if (kind != sfk_inheriting_constructor)
1858     DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1859   if (kind == sfk_constructor || kind == sfk_copy_constructor
1860       || kind == sfk_move_constructor || kind == sfk_inheriting_constructor)
1861     DECL_CONSTRUCTOR_P (fn) = 1;
1862   else if (kind == sfk_destructor)
1863     DECL_DESTRUCTOR_P (fn) = 1;
1864   else
1865     {
1866       DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1867       SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1868     }
1869
1870   DECL_ALIGN (fn) = MINIMUM_METHOD_BOUNDARY;
1871
1872   /* Create the explicit arguments.  */
1873   if (rhs_parm_type)
1874     {
1875       /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1876          want its type to be included in the mangled function
1877          name.  */
1878       tree decl = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1879       TREE_READONLY (decl) = 1;
1880       retrofit_lang_decl (decl);
1881       DECL_PARM_INDEX (decl) = DECL_PARM_LEVEL (decl) = 1;
1882       DECL_ARGUMENTS (fn) = decl;
1883     }
1884   else if (kind == sfk_inheriting_constructor)
1885     {
1886       tree *p = &DECL_ARGUMENTS (fn);
1887       int index = 1;
1888       for (tree parm = inherited_parms; parm != void_list_node;
1889            parm = TREE_CHAIN (parm))
1890         {
1891           *p = cp_build_parm_decl (NULL_TREE, TREE_VALUE (parm));
1892           retrofit_lang_decl (*p);
1893           DECL_PARM_LEVEL (*p) = 1;
1894           DECL_PARM_INDEX (*p) = index++;
1895           DECL_CONTEXT (*p) = fn;
1896           p = &DECL_CHAIN (*p);
1897         }
1898       SET_DECL_INHERITED_CTOR_BASE (fn, inherited_base);
1899       DECL_NONCONVERTING_P (fn) = DECL_NONCONVERTING_P (inherited_ctor);
1900       /* A constructor so declared has the same access as the corresponding
1901          constructor in X.  */
1902       TREE_PRIVATE (fn) = TREE_PRIVATE (inherited_ctor);
1903       TREE_PROTECTED (fn) = TREE_PROTECTED (inherited_ctor);
1904       /* Copy constexpr from the inherited constructor even if the
1905          inheriting constructor doesn't satisfy the requirements.  */
1906       constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
1907     }
1908   /* Add the "this" parameter.  */
1909   this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1910   DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1911   DECL_ARGUMENTS (fn) = this_parm;
1912
1913   grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1914   DECL_IN_AGGR_P (fn) = 1;
1915   DECL_ARTIFICIAL (fn) = 1;
1916   DECL_DEFAULTED_FN (fn) = 1;
1917   if (cxx_dialect >= cxx11)
1918     {
1919       /* "The closure type associated with a lambda-expression has a deleted
1920          default constructor and a deleted copy assignment operator."  */
1921       if ((kind == sfk_constructor
1922            || kind == sfk_copy_assignment)
1923           && LAMBDA_TYPE_P (type))
1924         deleted_p = true;
1925       DECL_DELETED_FN (fn) = deleted_p;
1926       DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
1927     }
1928   DECL_EXTERNAL (fn) = true;
1929   DECL_NOT_REALLY_EXTERN (fn) = 1;
1930   DECL_DECLARED_INLINE_P (fn) = 1;
1931   set_linkage_according_to_type (type, fn);
1932   if (TREE_PUBLIC (fn))
1933     DECL_COMDAT (fn) = 1;
1934   rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1935   gcc_assert (!TREE_USED (fn));
1936
1937   /* Propagate constraints from the inherited constructor. */
1938   if (flag_concepts && inherited_ctor)
1939     if (tree orig_ci = get_constraints (inherited_ctor))
1940       {
1941         tree new_ci = copy_node (orig_ci);
1942         set_constraints (fn, new_ci);
1943       }
1944
1945   /* Restore PROCESSING_TEMPLATE_DECL.  */
1946   processing_template_decl = saved_processing_template_decl;
1947
1948   if (inherited_ctor && TREE_CODE (inherited_ctor) == TEMPLATE_DECL)
1949     fn = add_inherited_template_parms (fn, inherited_ctor);
1950
1951   /* Warn about calling a non-trivial move assignment in a virtual base.  */
1952   if (kind == sfk_move_assignment && !deleted_p && !trivial_p
1953       && CLASSTYPE_VBASECLASSES (type))
1954     {
1955       location_t loc = input_location;
1956       input_location = DECL_SOURCE_LOCATION (fn);
1957       synthesized_method_walk (type, kind, const_p,
1958                                NULL, NULL, NULL, NULL, true,
1959                                NULL_TREE, NULL_TREE);
1960       input_location = loc;
1961     }
1962
1963   return fn;
1964 }
1965
1966 /* Gives any errors about defaulted functions which need to be deferred
1967    until the containing class is complete.  */
1968
1969 void
1970 defaulted_late_check (tree fn)
1971 {
1972   /* Complain about invalid signature for defaulted fn.  */
1973   tree ctx = DECL_CONTEXT (fn);
1974   special_function_kind kind = special_function_p (fn);
1975   bool fn_const_p = (copy_fn_p (fn) == 2);
1976   tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p,
1977                                             NULL, NULL);
1978   tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
1979
1980   if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
1981                     TREE_TYPE (TREE_TYPE (implicit_fn)))
1982       || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1983                      TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
1984     {
1985       error ("defaulted declaration %q+D", fn);
1986       error_at (DECL_SOURCE_LOCATION (fn),
1987                 "does not match expected signature %qD", implicit_fn);
1988     }
1989
1990   /* 8.4.2/2: An explicitly-defaulted function (...) may have an explicit
1991      exception-specification only if it is compatible (15.4) with the
1992      exception-specification on the implicit declaration.  If a function
1993      is explicitly defaulted on its first declaration, (...) it is
1994      implicitly considered to have the same exception-specification as if
1995      it had been implicitly declared.  */
1996   maybe_instantiate_noexcept (fn);
1997   tree fn_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
1998   if (!fn_spec)
1999     {
2000       if (DECL_DEFAULTED_IN_CLASS_P (fn))
2001         TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
2002     }
2003   else if (UNEVALUATED_NOEXCEPT_SPEC_P (fn_spec))
2004     /* Equivalent to the implicit spec.  */;
2005   else if (DECL_DEFAULTED_IN_CLASS_P (fn)
2006            && !CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
2007     /* We can't compare an explicit exception-specification on a
2008        constructor defaulted in the class body to the implicit
2009        exception-specification until after we've parsed any NSDMI; see
2010        after_nsdmi_defaulted_late_checks.  */;
2011   else
2012     {
2013       tree eh_spec = get_defaulted_eh_spec (fn);
2014       if (!comp_except_specs (fn_spec, eh_spec, ce_normal))
2015         {
2016           if (DECL_DEFAULTED_IN_CLASS_P (fn))
2017             DECL_DELETED_FN (fn) = true;
2018           else
2019             error ("function %q+D defaulted on its redeclaration "
2020                    "with an exception-specification that differs from "
2021                    "the implicit exception-specification %qX", fn, eh_spec);
2022         }
2023     }
2024
2025   if (DECL_DEFAULTED_IN_CLASS_P (fn)
2026       && DECL_DECLARED_CONSTEXPR_P (implicit_fn))
2027     {
2028       /* Hmm...should we do this for out-of-class too? Should it be OK to
2029          add constexpr later like inline, rather than requiring
2030          declarations to match?  */
2031       DECL_DECLARED_CONSTEXPR_P (fn) = true;
2032       if (kind == sfk_constructor)
2033         TYPE_HAS_CONSTEXPR_CTOR (ctx) = true;
2034     }
2035
2036   if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
2037       && DECL_DECLARED_CONSTEXPR_P (fn))
2038     {
2039       if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
2040         {
2041           error ("explicitly defaulted function %q+D cannot be declared "
2042                  "as constexpr because the implicit declaration is not "
2043                  "constexpr:", fn);
2044           explain_implicit_non_constexpr (fn);
2045         }
2046       DECL_DECLARED_CONSTEXPR_P (fn) = false;
2047     }
2048
2049   if (DECL_DELETED_FN (implicit_fn))
2050     DECL_DELETED_FN (fn) = 1;
2051 }
2052
2053 /* OK, we've parsed the NSDMI for class T, now we can check any explicit
2054    exception-specifications on functions defaulted in the class body.  */
2055
2056 void
2057 after_nsdmi_defaulted_late_checks (tree t)
2058 {
2059   if (uses_template_parms (t))
2060     return;
2061   if (t == error_mark_node)
2062     return;
2063   for (tree fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
2064     if (!DECL_ARTIFICIAL (fn) && DECL_DEFAULTED_IN_CLASS_P (fn))
2065       {
2066         tree fn_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
2067         if (UNEVALUATED_NOEXCEPT_SPEC_P (fn_spec))
2068           continue;
2069
2070         tree eh_spec = get_defaulted_eh_spec (fn);
2071         if (!comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)),
2072                                 eh_spec, ce_normal))
2073           DECL_DELETED_FN (fn) = true;
2074       }
2075 }
2076
2077 /* Returns true iff FN can be explicitly defaulted, and gives any
2078    errors if defaulting FN is ill-formed.  */
2079
2080 bool
2081 defaultable_fn_check (tree fn)
2082 {
2083   special_function_kind kind = sfk_none;
2084
2085   if (template_parm_scope_p ())
2086     {
2087       error ("a template cannot be defaulted");
2088       return false;
2089     }
2090
2091   if (DECL_CONSTRUCTOR_P (fn))
2092     {
2093       if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
2094         kind = sfk_constructor;
2095       else if (copy_fn_p (fn) > 0
2096                && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
2097                    == void_list_node))
2098         kind = sfk_copy_constructor;
2099       else if (move_fn_p (fn))
2100         kind = sfk_move_constructor;
2101     }
2102   else if (DECL_DESTRUCTOR_P (fn))
2103     kind = sfk_destructor;
2104   else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
2105            && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
2106     {
2107       if (copy_fn_p (fn))
2108         kind = sfk_copy_assignment;
2109       else if (move_fn_p (fn))
2110         kind = sfk_move_assignment;
2111     }
2112
2113   if (kind == sfk_none)
2114     {
2115       error ("%qD cannot be defaulted", fn);
2116       return false;
2117     }
2118   else
2119     {
2120       for (tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
2121            t && t != void_list_node; t = TREE_CHAIN (t))
2122         if (TREE_PURPOSE (t))
2123           {
2124             error ("defaulted function %q+D with default argument", fn);
2125             break;
2126           }
2127
2128       /* Avoid do_warn_unused_parameter warnings.  */
2129       for (tree p = FUNCTION_FIRST_USER_PARM (fn); p; p = DECL_CHAIN (p))
2130         if (DECL_NAME (p))
2131           TREE_NO_WARNING (p) = 1;
2132
2133       if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
2134         /* Defer checking.  */;
2135       else if (!processing_template_decl)
2136         defaulted_late_check (fn);
2137
2138       return true;
2139     }
2140 }
2141
2142 /* Add an implicit declaration to TYPE for the kind of function
2143    indicated by SFK.  Return the FUNCTION_DECL for the new implicit
2144    declaration.  */
2145
2146 tree
2147 lazily_declare_fn (special_function_kind sfk, tree type)
2148 {
2149   tree fn;
2150   /* Whether or not the argument has a const reference type.  */
2151   bool const_p = false;
2152
2153   type = TYPE_MAIN_VARIANT (type);
2154
2155   switch (sfk)
2156     {
2157     case sfk_constructor:
2158       CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
2159       break;
2160     case sfk_copy_constructor:
2161       const_p = TYPE_HAS_CONST_COPY_CTOR (type);
2162       CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
2163       break;
2164     case sfk_move_constructor:
2165       CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
2166       break;
2167     case sfk_copy_assignment:
2168       const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
2169       CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
2170       break;
2171     case sfk_move_assignment:
2172       CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
2173       break;
2174     case sfk_destructor:
2175       CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
2176       break;
2177     default:
2178       gcc_unreachable ();
2179     }
2180
2181   /* Declare the function.  */
2182   fn = implicitly_declare_fn (sfk, type, const_p, NULL, NULL);
2183
2184   /* [class.copy]/8 If the class definition declares a move constructor or
2185      move assignment operator, the implicitly declared copy constructor is
2186      defined as deleted.... */
2187   if ((sfk == sfk_copy_assignment
2188        || sfk == sfk_copy_constructor)
2189       && (type_has_user_declared_move_constructor (type)
2190           || type_has_user_declared_move_assign (type)))
2191     DECL_DELETED_FN (fn) = true;
2192
2193   /* A destructor may be virtual.  */
2194   if (sfk == sfk_destructor
2195       || sfk == sfk_move_assignment
2196       || sfk == sfk_copy_assignment)
2197     check_for_override (fn, type);
2198   /* Add it to CLASSTYPE_METHOD_VEC.  */
2199   add_method (type, fn, NULL_TREE);
2200   /* Add it to TYPE_METHODS.  */
2201   if (sfk == sfk_destructor
2202       && DECL_VIRTUAL_P (fn))
2203     /* The ABI requires that a virtual destructor go at the end of the
2204        vtable.  */
2205     TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
2206   else
2207     {
2208       DECL_CHAIN (fn) = TYPE_METHODS (type);
2209       TYPE_METHODS (type) = fn;
2210     }
2211   maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
2212   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
2213       || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
2214     /* Create appropriate clones.  */
2215     clone_function_decl (fn, /*update_method_vec=*/true);
2216
2217   return fn;
2218 }
2219
2220 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
2221    as there are artificial parms in FN.  */
2222
2223 tree
2224 skip_artificial_parms_for (const_tree fn, tree list)
2225 {
2226   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
2227     list = TREE_CHAIN (list);
2228   else
2229     return list;
2230
2231   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
2232     list = TREE_CHAIN (list);
2233   if (DECL_HAS_VTT_PARM_P (fn))
2234     list = TREE_CHAIN (list);
2235   return list;
2236 }
2237
2238 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
2239    artificial parms in FN.  */
2240
2241 int
2242 num_artificial_parms_for (const_tree fn)
2243 {
2244   int count = 0;
2245
2246   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
2247     count++;
2248   else
2249     return 0;
2250
2251   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
2252     count++;
2253   if (DECL_HAS_VTT_PARM_P (fn))
2254     count++;
2255   return count;
2256 }
2257
2258
2259 #include "gt-cp-method.h"