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