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