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