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 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 "rtl.h" 33 #include "expr.h" 34 #include "output.h" 35 #include "flags.h" 36 #include "toplev.h" 37 #include "tm_p.h" 38 #include "target.h" 39 #include "tree-pass.h" 40 #include "diagnostic.h" 41 #include "cgraph.h" 42 #include "gimple.h" 43 44 /* Various flags to control the mangling process. */ 45 46 enum mangling_flags 47 { 48 /* No flags. */ 49 mf_none = 0, 50 /* The thing we are presently mangling is part of a template type, 51 rather than a fully instantiated type. Therefore, we may see 52 complex expressions where we would normally expect to see a 53 simple integer constant. */ 54 mf_maybe_uninstantiated = 1, 55 /* When mangling a numeric value, use the form `_XX_' (instead of 56 just `XX') if the value has more than one digit. */ 57 mf_use_underscores_around_value = 2 58 }; 59 60 typedef enum mangling_flags mangling_flags; 61 62 static void do_build_assign_ref (tree); 63 static void do_build_copy_constructor (tree); 64 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *); 65 static tree make_alias_for_thunk (tree); 66 67 /* Called once to initialize method.c. */ 68 69 void 70 init_method (void) 71 { 72 init_mangle (); 73 } 74 75 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING 76 indicates whether it is a this or result adjusting thunk. 77 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment 78 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET 79 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this 80 adjusting thunks, we scale it to a byte offset. For covariant 81 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process 82 the returned thunk with finish_thunk. */ 83 84 tree 85 make_thunk (tree function, bool this_adjusting, 86 tree fixed_offset, tree virtual_offset) 87 { 88 HOST_WIDE_INT d; 89 tree thunk; 90 91 gcc_assert (TREE_CODE (function) == FUNCTION_DECL); 92 /* We can have this thunks to covariant thunks, but not vice versa. */ 93 gcc_assert (!DECL_THIS_THUNK_P (function)); 94 gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting); 95 96 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */ 97 if (this_adjusting && virtual_offset) 98 virtual_offset 99 = size_binop (MULT_EXPR, 100 virtual_offset, 101 convert (ssizetype, 102 TYPE_SIZE_UNIT (vtable_entry_type))); 103 104 d = tree_low_cst (fixed_offset, 0); 105 106 /* See if we already have the thunk in question. For this_adjusting 107 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it 108 will be a BINFO. */ 109 for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk)) 110 if (DECL_THIS_THUNK_P (thunk) == this_adjusting 111 && THUNK_FIXED_OFFSET (thunk) == d 112 && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk) 113 && (!virtual_offset 114 || (this_adjusting 115 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk), 116 virtual_offset) 117 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset))) 118 return thunk; 119 120 /* All thunks must be created before FUNCTION is actually emitted; 121 the ABI requires that all thunks be emitted together with the 122 function to which they transfer control. */ 123 gcc_assert (!TREE_ASM_WRITTEN (function)); 124 /* Likewise, we can only be adding thunks to a function declared in 125 the class currently being laid out. */ 126 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function)) 127 && TYPE_BEING_DEFINED (DECL_CONTEXT (function))); 128 129 thunk = build_decl (DECL_SOURCE_LOCATION (function), 130 FUNCTION_DECL, NULL_TREE, TREE_TYPE (function)); 131 DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function); 132 cxx_dup_lang_specific_decl (thunk); 133 DECL_THUNKS (thunk) = NULL_TREE; 134 135 DECL_CONTEXT (thunk) = DECL_CONTEXT (function); 136 TREE_READONLY (thunk) = TREE_READONLY (function); 137 TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function); 138 TREE_PUBLIC (thunk) = TREE_PUBLIC (function); 139 SET_DECL_THUNK_P (thunk, this_adjusting); 140 THUNK_TARGET (thunk) = function; 141 THUNK_FIXED_OFFSET (thunk) = d; 142 THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset; 143 THUNK_ALIAS (thunk) = NULL_TREE; 144 145 /* The thunk itself is not a constructor or destructor, even if 146 the thing it is thunking to is. */ 147 DECL_INTERFACE_KNOWN (thunk) = 1; 148 DECL_NOT_REALLY_EXTERN (thunk) = 1; 149 DECL_SAVED_FUNCTION_DATA (thunk) = NULL; 150 DECL_DESTRUCTOR_P (thunk) = 0; 151 DECL_CONSTRUCTOR_P (thunk) = 0; 152 DECL_EXTERNAL (thunk) = 1; 153 DECL_ARTIFICIAL (thunk) = 1; 154 /* The THUNK is not a pending inline, even if the FUNCTION is. */ 155 DECL_PENDING_INLINE_P (thunk) = 0; 156 DECL_DECLARED_INLINE_P (thunk) = 0; 157 /* Nor is it a template instantiation. */ 158 DECL_USE_TEMPLATE (thunk) = 0; 159 DECL_TEMPLATE_INFO (thunk) = NULL; 160 161 /* Add it to the list of thunks associated with FUNCTION. */ 162 TREE_CHAIN (thunk) = DECL_THUNKS (function); 163 DECL_THUNKS (function) = thunk; 164 165 return thunk; 166 } 167 168 /* Finish THUNK, a thunk decl. */ 169 170 void 171 finish_thunk (tree thunk) 172 { 173 tree function, name; 174 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk)); 175 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk); 176 177 gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk)); 178 if (virtual_offset && DECL_RESULT_THUNK_P (thunk)) 179 virtual_offset = BINFO_VPTR_FIELD (virtual_offset); 180 function = THUNK_TARGET (thunk); 181 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk), 182 fixed_offset, virtual_offset); 183 184 /* We can end up with declarations of (logically) different 185 covariant thunks, that do identical adjustments. The two thunks 186 will be adjusting between within different hierarchies, which 187 happen to have the same layout. We must nullify one of them to 188 refer to the other. */ 189 if (DECL_RESULT_THUNK_P (thunk)) 190 { 191 tree cov_probe; 192 193 for (cov_probe = DECL_THUNKS (function); 194 cov_probe; cov_probe = TREE_CHAIN (cov_probe)) 195 if (DECL_NAME (cov_probe) == name) 196 { 197 gcc_assert (!DECL_THUNKS (thunk)); 198 THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe) 199 ? THUNK_ALIAS (cov_probe) : cov_probe); 200 break; 201 } 202 } 203 204 DECL_NAME (thunk) = name; 205 SET_DECL_ASSEMBLER_NAME (thunk, name); 206 } 207 208 static GTY (()) int thunk_labelno; 209 210 /* Create a static alias to target. */ 211 212 tree 213 make_alias_for (tree target, tree newid) 214 { 215 tree alias = build_decl (DECL_SOURCE_LOCATION (target), 216 TREE_CODE (target), newid, TREE_TYPE (target)); 217 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (target); 218 cxx_dup_lang_specific_decl (alias); 219 DECL_CONTEXT (alias) = NULL; 220 TREE_READONLY (alias) = TREE_READONLY (target); 221 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (target); 222 TREE_PUBLIC (alias) = 0; 223 DECL_INTERFACE_KNOWN (alias) = 1; 224 if (DECL_LANG_SPECIFIC (alias)) 225 { 226 DECL_NOT_REALLY_EXTERN (alias) = 1; 227 DECL_USE_TEMPLATE (alias) = 0; 228 DECL_TEMPLATE_INFO (alias) = NULL; 229 } 230 DECL_EXTERNAL (alias) = 0; 231 DECL_ARTIFICIAL (alias) = 1; 232 DECL_TEMPLATE_INSTANTIATED (alias) = 0; 233 if (TREE_CODE (alias) == FUNCTION_DECL) 234 { 235 DECL_SAVED_FUNCTION_DATA (alias) = NULL; 236 DECL_DESTRUCTOR_P (alias) = 0; 237 DECL_CONSTRUCTOR_P (alias) = 0; 238 DECL_PENDING_INLINE_P (alias) = 0; 239 DECL_DECLARED_INLINE_P (alias) = 0; 240 DECL_INITIAL (alias) = error_mark_node; 241 DECL_ARGUMENTS (alias) = copy_list (DECL_ARGUMENTS (target)); 242 } 243 else 244 TREE_STATIC (alias) = 1; 245 TREE_ADDRESSABLE (alias) = 1; 246 TREE_USED (alias) = 1; 247 SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias)); 248 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1; 249 return alias; 250 } 251 252 static tree 253 make_alias_for_thunk (tree function) 254 { 255 tree alias; 256 char buf[256]; 257 258 ASM_GENERATE_INTERNAL_LABEL (buf, "LTHUNK", thunk_labelno); 259 thunk_labelno++; 260 261 alias = make_alias_for (function, get_identifier (buf)); 262 263 if (!flag_syntax_only) 264 { 265 bool ok = cgraph_same_body_alias (alias, function); 266 DECL_ASSEMBLER_NAME (function); 267 gcc_assert (ok); 268 } 269 270 return alias; 271 } 272 273 /* Emit the definition of a C++ multiple inheritance or covariant 274 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted 275 immediately. */ 276 277 void 278 use_thunk (tree thunk_fndecl, bool emit_p) 279 { 280 tree a, t, function, alias; 281 tree virtual_offset; 282 HOST_WIDE_INT fixed_offset, virtual_value; 283 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl); 284 285 /* We should have called finish_thunk to give it a name. */ 286 gcc_assert (DECL_NAME (thunk_fndecl)); 287 288 /* We should never be using an alias, always refer to the 289 aliased thunk. */ 290 gcc_assert (!THUNK_ALIAS (thunk_fndecl)); 291 292 if (TREE_ASM_WRITTEN (thunk_fndecl)) 293 return; 294 295 function = THUNK_TARGET (thunk_fndecl); 296 if (DECL_RESULT (thunk_fndecl)) 297 /* We already turned this thunk into an ordinary function. 298 There's no need to process this thunk again. */ 299 return; 300 301 if (DECL_THUNK_P (function)) 302 /* The target is itself a thunk, process it now. */ 303 use_thunk (function, emit_p); 304 305 /* Thunks are always addressable; they only appear in vtables. */ 306 TREE_ADDRESSABLE (thunk_fndecl) = 1; 307 308 /* Figure out what function is being thunked to. It's referenced in 309 this translation unit. */ 310 TREE_ADDRESSABLE (function) = 1; 311 mark_used (function); 312 if (!emit_p) 313 return; 314 315 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)) 316 alias = make_alias_for_thunk (function); 317 else 318 alias = function; 319 320 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl); 321 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl); 322 323 if (virtual_offset) 324 { 325 if (!this_adjusting) 326 virtual_offset = BINFO_VPTR_FIELD (virtual_offset); 327 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0); 328 gcc_assert (virtual_value); 329 } 330 else 331 virtual_value = 0; 332 333 /* And, if we need to emit the thunk, it's used. */ 334 mark_used (thunk_fndecl); 335 /* This thunk is actually defined. */ 336 DECL_EXTERNAL (thunk_fndecl) = 0; 337 /* The linkage of the function may have changed. FIXME in linkage 338 rewrite. */ 339 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function); 340 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function); 341 DECL_VISIBILITY_SPECIFIED (thunk_fndecl) 342 = DECL_VISIBILITY_SPECIFIED (function); 343 if (DECL_ONE_ONLY (function) || DECL_WEAK (function)) 344 make_decl_one_only (thunk_fndecl, cxx_comdat_group (thunk_fndecl)); 345 346 if (flag_syntax_only) 347 { 348 TREE_ASM_WRITTEN (thunk_fndecl) = 1; 349 return; 350 } 351 352 push_to_top_level (); 353 354 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function) 355 && targetm.have_named_sections) 356 { 357 resolve_unique_section (function, 0, flag_function_sections); 358 359 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function)) 360 { 361 resolve_unique_section (thunk_fndecl, 0, flag_function_sections); 362 363 /* Output the thunk into the same section as function. */ 364 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function); 365 } 366 } 367 368 /* Set up cloned argument trees for the thunk. */ 369 t = NULL_TREE; 370 for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a)) 371 { 372 tree x = copy_node (a); 373 TREE_CHAIN (x) = t; 374 DECL_CONTEXT (x) = thunk_fndecl; 375 SET_DECL_RTL (x, NULL_RTX); 376 DECL_HAS_VALUE_EXPR_P (x) = 0; 377 TREE_ADDRESSABLE (x) = 0; 378 t = x; 379 } 380 a = nreverse (t); 381 DECL_ARGUMENTS (thunk_fndecl) = a; 382 TREE_ASM_WRITTEN (thunk_fndecl) = 1; 383 cgraph_add_thunk (thunk_fndecl, function, 384 this_adjusting, fixed_offset, virtual_value, 385 virtual_offset, alias); 386 387 if (!this_adjusting 388 || !targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset, 389 virtual_value, alias)) 390 { 391 /* If this is a covariant thunk, or we don't have the necessary 392 code for efficient thunks, generate a thunk function that 393 just makes a call to the real function. Unfortunately, this 394 doesn't work for varargs. */ 395 396 if (varargs_function_p (function)) 397 error ("generic thunk code fails for method %q#D which uses %<...%>", 398 function); 399 } 400 401 pop_from_top_level (); 402 } 403 404 /* Code for synthesizing methods which have default semantics defined. */ 405 406 /* Generate code for default X(X&) or X(X&&) constructor. */ 407 408 static void 409 do_build_copy_constructor (tree fndecl) 410 { 411 tree parm = FUNCTION_FIRST_USER_PARM (fndecl); 412 bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl); 413 414 parm = convert_from_reference (parm); 415 416 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type) 417 && is_empty_class (current_class_type)) 418 /* Don't copy the padding byte; it might not have been allocated 419 if *this is a base subobject. */; 420 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)) 421 { 422 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm); 423 finish_expr_stmt (t); 424 } 425 else 426 { 427 tree fields = TYPE_FIELDS (current_class_type); 428 tree member_init_list = NULL_TREE; 429 int cvquals = cp_type_quals (TREE_TYPE (parm)); 430 int i; 431 tree binfo, base_binfo; 432 tree init; 433 VEC(tree,gc) *vbases; 434 435 /* Initialize all the base-classes with the parameter converted 436 to their type so that we get their copy constructor and not 437 another constructor that takes current_class_type. We must 438 deal with the binfo's directly as a direct base might be 439 inaccessible due to ambiguity. */ 440 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0; 441 VEC_iterate (tree, vbases, i, binfo); i++) 442 { 443 init = build_base_path (PLUS_EXPR, parm, binfo, 1); 444 if (move_p) 445 init = move (init); 446 member_init_list 447 = tree_cons (binfo, 448 build_tree_list (NULL_TREE, init), 449 member_init_list); 450 } 451 452 for (binfo = TYPE_BINFO (current_class_type), i = 0; 453 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 454 { 455 if (BINFO_VIRTUAL_P (base_binfo)) 456 continue; 457 458 init = build_base_path (PLUS_EXPR, parm, base_binfo, 1); 459 if (move_p) 460 init = move (init); 461 member_init_list 462 = tree_cons (base_binfo, 463 build_tree_list (NULL_TREE, init), 464 member_init_list); 465 } 466 467 for (; fields; fields = TREE_CHAIN (fields)) 468 { 469 tree field = fields; 470 tree expr_type; 471 472 if (TREE_CODE (field) != FIELD_DECL) 473 continue; 474 475 expr_type = TREE_TYPE (field); 476 if (DECL_NAME (field)) 477 { 478 if (VFIELD_NAME_P (DECL_NAME (field))) 479 continue; 480 } 481 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type)) 482 /* Just use the field; anonymous types can't have 483 nontrivial copy ctors or assignment ops. */; 484 else 485 continue; 486 487 /* Compute the type of "init->field". If the copy-constructor 488 parameter is, for example, "const S&", and the type of 489 the field is "T", then the type will usually be "const 490 T". (There are no cv-qualified variants of reference 491 types.) */ 492 if (TREE_CODE (expr_type) != REFERENCE_TYPE) 493 { 494 int quals = cvquals; 495 496 if (DECL_MUTABLE_P (field)) 497 quals &= ~TYPE_QUAL_CONST; 498 quals |= TYPE_QUALS (expr_type); 499 expr_type = cp_build_qualified_type (expr_type, quals); 500 } 501 502 init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE); 503 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE) 504 init = move (init); 505 init = build_tree_list (NULL_TREE, init); 506 507 member_init_list = tree_cons (field, init, member_init_list); 508 } 509 finish_mem_initializers (member_init_list); 510 } 511 } 512 513 static void 514 do_build_assign_ref (tree fndecl) 515 { 516 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl)); 517 tree compound_stmt; 518 519 compound_stmt = begin_compound_stmt (0); 520 parm = convert_from_reference (parm); 521 522 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type) 523 && is_empty_class (current_class_type)) 524 /* Don't copy the padding byte; it might not have been allocated 525 if *this is a base subobject. */; 526 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)) 527 { 528 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm); 529 finish_expr_stmt (t); 530 } 531 else 532 { 533 tree fields; 534 int cvquals = cp_type_quals (TREE_TYPE (parm)); 535 int i; 536 tree binfo, base_binfo; 537 538 /* Assign to each of the direct base classes. */ 539 for (binfo = TYPE_BINFO (current_class_type), i = 0; 540 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 541 { 542 tree converted_parm; 543 VEC(tree,gc) *parmvec; 544 545 /* We must convert PARM directly to the base class 546 explicitly since the base class may be ambiguous. */ 547 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1); 548 /* Call the base class assignment operator. */ 549 parmvec = make_tree_vector_single (converted_parm); 550 finish_expr_stmt 551 (build_special_member_call (current_class_ref, 552 ansi_assopname (NOP_EXPR), 553 &parmvec, 554 base_binfo, 555 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL, 556 tf_warning_or_error)); 557 release_tree_vector (parmvec); 558 } 559 560 /* Assign to each of the non-static data members. */ 561 for (fields = TYPE_FIELDS (current_class_type); 562 fields; 563 fields = TREE_CHAIN (fields)) 564 { 565 tree comp = current_class_ref; 566 tree init = parm; 567 tree field = fields; 568 tree expr_type; 569 int quals; 570 571 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field)) 572 continue; 573 574 expr_type = TREE_TYPE (field); 575 576 if (CP_TYPE_CONST_P (expr_type)) 577 { 578 error ("non-static const member %q#D, can't use default " 579 "assignment operator", field); 580 continue; 581 } 582 else if (TREE_CODE (expr_type) == REFERENCE_TYPE) 583 { 584 error ("non-static reference member %q#D, can't use " 585 "default assignment operator", field); 586 continue; 587 } 588 589 if (DECL_NAME (field)) 590 { 591 if (VFIELD_NAME_P (DECL_NAME (field))) 592 continue; 593 } 594 else if (ANON_AGGR_TYPE_P (expr_type) 595 && TYPE_FIELDS (expr_type) != NULL_TREE) 596 /* Just use the field; anonymous types can't have 597 nontrivial copy ctors or assignment ops. */; 598 else 599 continue; 600 601 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE); 602 603 /* Compute the type of init->field */ 604 quals = cvquals; 605 if (DECL_MUTABLE_P (field)) 606 quals &= ~TYPE_QUAL_CONST; 607 expr_type = cp_build_qualified_type (expr_type, quals); 608 609 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE); 610 611 if (DECL_NAME (field)) 612 init = cp_build_modify_expr (comp, NOP_EXPR, init, 613 tf_warning_or_error); 614 else 615 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init); 616 finish_expr_stmt (init); 617 } 618 } 619 finish_return_stmt (current_class_ref); 620 finish_compound_stmt (compound_stmt); 621 } 622 623 /* Synthesize FNDECL, a non-static member function. */ 624 625 void 626 synthesize_method (tree fndecl) 627 { 628 bool nested = (current_function_decl != NULL_TREE); 629 tree context = decl_function_context (fndecl); 630 bool need_body = true; 631 tree stmt; 632 location_t save_input_location = input_location; 633 int error_count = errorcount; 634 int warning_count = warningcount; 635 636 /* Reset the source location, we might have been previously 637 deferred, and thus have saved where we were first needed. */ 638 DECL_SOURCE_LOCATION (fndecl) 639 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl))); 640 641 /* If we've been asked to synthesize a clone, just synthesize the 642 cloned function instead. Doing so will automatically fill in the 643 body for the clone. */ 644 if (DECL_CLONED_FUNCTION_P (fndecl)) 645 fndecl = DECL_CLONED_FUNCTION (fndecl); 646 647 /* We may be in the middle of deferred access check. Disable 648 it now. */ 649 push_deferring_access_checks (dk_no_deferred); 650 651 if (! context) 652 push_to_top_level (); 653 else if (nested) 654 push_function_context (); 655 656 input_location = DECL_SOURCE_LOCATION (fndecl); 657 658 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED); 659 stmt = begin_function_body (); 660 661 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR) 662 { 663 do_build_assign_ref (fndecl); 664 need_body = false; 665 } 666 else if (DECL_CONSTRUCTOR_P (fndecl)) 667 { 668 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl); 669 if (arg_chain != void_list_node) 670 do_build_copy_constructor (fndecl); 671 else 672 finish_mem_initializers (NULL_TREE); 673 } 674 675 /* If we haven't yet generated the body of the function, just 676 generate an empty compound statement. */ 677 if (need_body) 678 { 679 tree compound_stmt; 680 compound_stmt = begin_compound_stmt (BCS_FN_BODY); 681 finish_compound_stmt (compound_stmt); 682 } 683 684 finish_function_body (stmt); 685 expand_or_defer_fn (finish_function (0)); 686 687 input_location = save_input_location; 688 689 if (! context) 690 pop_from_top_level (); 691 else if (nested) 692 pop_function_context (); 693 694 pop_deferring_access_checks (); 695 696 if (error_count != errorcount || warning_count != warningcount) 697 inform (input_location, "synthesized method %qD first required here ", 698 fndecl); 699 } 700 701 /* Use EXTRACTOR to locate the relevant function called for each base & 702 class field of TYPE. CLIENT allows additional information to be passed 703 to EXTRACTOR. Generates the union of all exceptions generated by those 704 functions. Note that we haven't updated TYPE_FIELDS and such of any 705 variants yet, so we need to look at the main one. */ 706 707 static tree 708 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*), 709 void *client) 710 { 711 tree raises = empty_except_spec; 712 tree fields = TYPE_FIELDS (type); 713 tree binfo, base_binfo; 714 int i; 715 716 for (binfo = TYPE_BINFO (type), i = 0; 717 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 718 { 719 tree fn = (*extractor) (BINFO_TYPE (base_binfo), client); 720 if (fn) 721 { 722 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)); 723 724 raises = merge_exception_specifiers (raises, fn_raises); 725 } 726 } 727 for (; fields; fields = TREE_CHAIN (fields)) 728 { 729 tree type = TREE_TYPE (fields); 730 tree fn; 731 732 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields)) 733 continue; 734 while (TREE_CODE (type) == ARRAY_TYPE) 735 type = TREE_TYPE (type); 736 if (!CLASS_TYPE_P (type)) 737 continue; 738 739 fn = (*extractor) (type, client); 740 if (fn) 741 { 742 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)); 743 744 raises = merge_exception_specifiers (raises, fn_raises); 745 } 746 } 747 return raises; 748 } 749 750 /* Locate the dtor of TYPE. */ 751 752 tree 753 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED) 754 { 755 return CLASSTYPE_DESTRUCTORS (type); 756 } 757 758 /* Locate the default ctor of TYPE. */ 759 760 tree 761 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED) 762 { 763 tree fns; 764 765 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) 766 return NULL_TREE; 767 768 /* Call lookup_fnfields_1 to create the constructor declarations, if 769 necessary. */ 770 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type)) 771 return lazily_declare_fn (sfk_constructor, type); 772 773 for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns)) 774 { 775 tree fn = OVL_CURRENT (fns); 776 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn)); 777 778 parms = skip_artificial_parms_for (fn, parms); 779 780 if (sufficient_parms_p (parms)) 781 return fn; 782 } 783 gcc_unreachable (); 784 } 785 786 struct copy_data 787 { 788 tree name; 789 int quals; 790 }; 791 792 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_ 793 points to a COPY_DATA holding the name (NULL for the ctor) 794 and desired qualifiers of the source operand. */ 795 796 tree 797 locate_copy (tree type, void *client_) 798 { 799 struct copy_data *client = (struct copy_data *)client_; 800 tree fns; 801 tree best = NULL_TREE; 802 bool excess_p = false; 803 804 if (client->name) 805 { 806 int ix; 807 ix = lookup_fnfields_1 (type, client->name); 808 if (ix < 0) 809 return NULL_TREE; 810 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix); 811 } 812 else if (TYPE_HAS_INIT_REF (type)) 813 { 814 /* If construction of the copy constructor was postponed, create 815 it now. */ 816 if (CLASSTYPE_LAZY_COPY_CTOR (type)) 817 lazily_declare_fn (sfk_copy_constructor, type); 818 if (CLASSTYPE_LAZY_MOVE_CTOR (type)) 819 lazily_declare_fn (sfk_move_constructor, type); 820 fns = CLASSTYPE_CONSTRUCTORS (type); 821 } 822 else 823 return NULL_TREE; 824 for (; fns; fns = OVL_NEXT (fns)) 825 { 826 tree fn = OVL_CURRENT (fns); 827 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn)); 828 tree src_type; 829 int excess; 830 int quals; 831 832 parms = skip_artificial_parms_for (fn, parms); 833 if (!parms) 834 continue; 835 src_type = non_reference (TREE_VALUE (parms)); 836 837 if (src_type == error_mark_node) 838 return NULL_TREE; 839 840 if (!same_type_ignoring_top_level_qualifiers_p (src_type, type)) 841 continue; 842 if (!sufficient_parms_p (TREE_CHAIN (parms))) 843 continue; 844 quals = cp_type_quals (src_type); 845 if (client->quals & ~quals) 846 continue; 847 excess = quals & ~client->quals; 848 if (!best || (excess_p && !excess)) 849 { 850 best = fn; 851 excess_p = excess; 852 } 853 else 854 /* Ambiguous */ 855 return NULL_TREE; 856 } 857 return best; 858 } 859 860 /* Implicitly declare the special function indicated by KIND, as a 861 member of TYPE. For copy constructors and assignment operators, 862 CONST_P indicates whether these functions should take a const 863 reference argument or a non-const reference. Returns the 864 FUNCTION_DECL for the implicitly declared function. */ 865 866 static tree 867 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p) 868 { 869 tree fn; 870 tree parameter_types = void_list_node; 871 tree return_type; 872 tree fn_type; 873 tree raises = empty_except_spec; 874 tree rhs_parm_type = NULL_TREE; 875 tree this_parm; 876 tree name; 877 HOST_WIDE_INT saved_processing_template_decl; 878 879 /* Because we create declarations for implicitly declared functions 880 lazily, we may be creating the declaration for a member of TYPE 881 while in some completely different context. However, TYPE will 882 never be a dependent class (because we never want to do lookups 883 for implicitly defined functions in a dependent class). 884 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here 885 because we only create clones for constructors and destructors 886 when not in a template. */ 887 gcc_assert (!dependent_type_p (type)); 888 saved_processing_template_decl = processing_template_decl; 889 processing_template_decl = 0; 890 891 type = TYPE_MAIN_VARIANT (type); 892 893 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type)) 894 { 895 if (kind == sfk_destructor) 896 /* See comment in check_special_function_return_type. */ 897 return_type = build_pointer_type (void_type_node); 898 else 899 return_type = build_pointer_type (type); 900 } 901 else 902 return_type = void_type_node; 903 904 switch (kind) 905 { 906 case sfk_destructor: 907 /* Destructor. */ 908 name = constructor_name (type); 909 raises = synthesize_exception_spec (type, &locate_dtor, 0); 910 break; 911 912 case sfk_constructor: 913 /* Default constructor. */ 914 name = constructor_name (type); 915 raises = synthesize_exception_spec (type, &locate_ctor, 0); 916 break; 917 918 case sfk_copy_constructor: 919 case sfk_assignment_operator: 920 case sfk_move_constructor: 921 { 922 struct copy_data data; 923 924 data.name = NULL; 925 data.quals = 0; 926 if (kind == sfk_assignment_operator) 927 { 928 return_type = build_reference_type (type); 929 name = ansi_assopname (NOP_EXPR); 930 data.name = name; 931 } 932 else 933 name = constructor_name (type); 934 935 if (const_p) 936 { 937 data.quals = TYPE_QUAL_CONST; 938 rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST); 939 } 940 else 941 rhs_parm_type = type; 942 rhs_parm_type 943 = cp_build_reference_type (rhs_parm_type, 944 kind == sfk_move_constructor); 945 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types); 946 raises = synthesize_exception_spec (type, &locate_copy, &data); 947 break; 948 } 949 default: 950 gcc_unreachable (); 951 } 952 953 /* Create the function. */ 954 fn_type = build_method_type_directly (type, return_type, parameter_types); 955 if (raises) 956 fn_type = build_exception_variant (fn_type, raises); 957 fn = build_lang_decl (FUNCTION_DECL, name, fn_type); 958 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type)); 959 if (kind == sfk_constructor || kind == sfk_copy_constructor 960 || kind == sfk_move_constructor) 961 DECL_CONSTRUCTOR_P (fn) = 1; 962 else if (kind == sfk_destructor) 963 DECL_DESTRUCTOR_P (fn) = 1; 964 else 965 { 966 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1; 967 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR); 968 } 969 970 /* If pointers to member functions use the least significant bit to 971 indicate whether a function is virtual, ensure a pointer 972 to this function will have that bit clear. */ 973 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn 974 && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT) 975 DECL_ALIGN (fn) = 2 * BITS_PER_UNIT; 976 977 /* Create the explicit arguments. */ 978 if (rhs_parm_type) 979 { 980 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we 981 want its type to be included in the mangled function 982 name. */ 983 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type); 984 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1; 985 } 986 /* Add the "this" parameter. */ 987 this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED); 988 TREE_CHAIN (this_parm) = DECL_ARGUMENTS (fn); 989 DECL_ARGUMENTS (fn) = this_parm; 990 991 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL); 992 set_linkage_according_to_type (type, fn); 993 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof); 994 DECL_IN_AGGR_P (fn) = 1; 995 DECL_ARTIFICIAL (fn) = 1; 996 DECL_DEFAULTED_FN (fn) = 1; 997 DECL_NOT_REALLY_EXTERN (fn) = 1; 998 DECL_DECLARED_INLINE_P (fn) = 1; 999 gcc_assert (!TREE_USED (fn)); 1000 1001 /* Restore PROCESSING_TEMPLATE_DECL. */ 1002 processing_template_decl = saved_processing_template_decl; 1003 1004 return fn; 1005 } 1006 1007 /* Gives any errors about defaulted functions which need to be deferred 1008 until the containing class is complete. */ 1009 1010 void 1011 defaulted_late_check (tree fn) 1012 { 1013 /* Complain about invalid signature for defaulted fn. */ 1014 tree ctx = DECL_CONTEXT (fn); 1015 special_function_kind kind = special_function_p (fn); 1016 bool fn_const_p = (copy_fn_p (fn) == 2); 1017 tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p); 1018 1019 if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)), 1020 TREE_TYPE (TREE_TYPE (implicit_fn))) 1021 || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)), 1022 TYPE_ARG_TYPES (TREE_TYPE (implicit_fn)))) 1023 { 1024 error ("defaulted declaration %q+D", fn); 1025 error_at (DECL_SOURCE_LOCATION (fn), 1026 "does not match expected signature %qD", implicit_fn); 1027 } 1028 } 1029 1030 /* Returns true iff FN can be explicitly defaulted, and gives any 1031 errors if defaulting FN is ill-formed. */ 1032 1033 bool 1034 defaultable_fn_check (tree fn) 1035 { 1036 special_function_kind kind = sfk_none; 1037 1038 if (DECL_CONSTRUCTOR_P (fn)) 1039 { 1040 if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node) 1041 kind = sfk_constructor; 1042 else if (copy_fn_p (fn) > 0 1043 && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn)) 1044 == void_list_node)) 1045 kind = sfk_copy_constructor; 1046 else if (move_fn_p (fn)) 1047 kind = sfk_move_constructor; 1048 } 1049 else if (DECL_DESTRUCTOR_P (fn)) 1050 kind = sfk_destructor; 1051 else if (DECL_ASSIGNMENT_OPERATOR_P (fn) 1052 && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR 1053 && copy_fn_p (fn)) 1054 kind = sfk_assignment_operator; 1055 1056 if (kind == sfk_none) 1057 { 1058 error ("%qD cannot be defaulted", fn); 1059 return false; 1060 } 1061 else 1062 { 1063 tree t = FUNCTION_FIRST_USER_PARMTYPE (fn); 1064 for (; t && t != void_list_node; t = TREE_CHAIN (t)) 1065 if (TREE_PURPOSE (t)) 1066 { 1067 error ("defaulted function %q+D with default argument", fn); 1068 break; 1069 } 1070 if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn))) 1071 { 1072 if (DECL_NONCONVERTING_P (fn)) 1073 error ("%qD declared explicit cannot be defaulted in the class " 1074 "body", fn); 1075 if (current_access_specifier != access_public_node) 1076 error ("%qD declared with non-public access cannot be defaulted " 1077 "in the class body", fn); 1078 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))) 1079 error ("function %q+D defaulted on its first declaration " 1080 "must not have an exception-specification", fn); 1081 if (DECL_VIRTUAL_P (fn)) 1082 error ("%qD declared virtual cannot be defaulted in the class " 1083 "body", fn); 1084 } 1085 else if (!processing_template_decl) 1086 defaulted_late_check (fn); 1087 1088 return true; 1089 } 1090 } 1091 1092 /* Add an implicit declaration to TYPE for the kind of function 1093 indicated by SFK. Return the FUNCTION_DECL for the new implicit 1094 declaration. */ 1095 1096 tree 1097 lazily_declare_fn (special_function_kind sfk, tree type) 1098 { 1099 tree fn; 1100 bool const_p; 1101 1102 /* Figure out whether or not the argument has a const reference 1103 type. */ 1104 if (sfk == sfk_copy_constructor) 1105 const_p = TYPE_HAS_CONST_INIT_REF (type); 1106 else if (sfk == sfk_assignment_operator) 1107 const_p = TYPE_HAS_CONST_ASSIGN_REF (type); 1108 else 1109 /* In this case, CONST_P will be ignored. */ 1110 const_p = false; 1111 /* Declare the function. */ 1112 fn = implicitly_declare_fn (sfk, type, const_p); 1113 /* A destructor may be virtual. */ 1114 if (sfk == sfk_destructor) 1115 check_for_override (fn, type); 1116 /* Add it to CLASSTYPE_METHOD_VEC. */ 1117 add_method (type, fn, NULL_TREE); 1118 /* Add it to TYPE_METHODS. */ 1119 if (sfk == sfk_destructor 1120 && DECL_VIRTUAL_P (fn) 1121 && abi_version_at_least (2)) 1122 /* The ABI requires that a virtual destructor go at the end of the 1123 vtable. */ 1124 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn); 1125 else 1126 { 1127 /* G++ 3.2 put the implicit destructor at the *beginning* of the 1128 TYPE_METHODS list, which cause the destructor to be emitted 1129 in an incorrect location in the vtable. */ 1130 if (warn_abi && sfk == sfk_destructor && DECL_VIRTUAL_P (fn)) 1131 warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant" 1132 "and may change in a future version of GCC due to " 1133 "implicit virtual destructor", 1134 type); 1135 TREE_CHAIN (fn) = TYPE_METHODS (type); 1136 TYPE_METHODS (type) = fn; 1137 } 1138 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0); 1139 if (sfk == sfk_assignment_operator) 1140 CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0; 1141 else 1142 { 1143 /* Remember that the function has been created. */ 1144 if (sfk == sfk_constructor) 1145 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0; 1146 else if (sfk == sfk_copy_constructor) 1147 CLASSTYPE_LAZY_COPY_CTOR (type) = 0; 1148 else if (sfk == sfk_move_constructor) 1149 CLASSTYPE_LAZY_MOVE_CTOR (type) = 0; 1150 else if (sfk == sfk_destructor) 1151 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0; 1152 /* Create appropriate clones. */ 1153 clone_function_decl (fn, /*update_method_vec=*/true); 1154 } 1155 1156 return fn; 1157 } 1158 1159 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST 1160 as there are artificial parms in FN. */ 1161 1162 tree 1163 skip_artificial_parms_for (const_tree fn, tree list) 1164 { 1165 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)) 1166 list = TREE_CHAIN (list); 1167 else 1168 return list; 1169 1170 if (DECL_HAS_IN_CHARGE_PARM_P (fn)) 1171 list = TREE_CHAIN (list); 1172 if (DECL_HAS_VTT_PARM_P (fn)) 1173 list = TREE_CHAIN (list); 1174 return list; 1175 } 1176 1177 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of 1178 artificial parms in FN. */ 1179 1180 int 1181 num_artificial_parms_for (const_tree fn) 1182 { 1183 int count = 0; 1184 1185 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)) 1186 count++; 1187 else 1188 return 0; 1189 1190 if (DECL_HAS_IN_CHARGE_PARM_P (fn)) 1191 count++; 1192 if (DECL_HAS_VTT_PARM_P (fn)) 1193 count++; 1194 return count; 1195 } 1196 1197 1198 #include "gt-cp-method.h" 1199