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