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 7 This file is part of GCC. 8 9 GCC is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2, or (at your option) 12 any later version. 13 14 GCC is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with GCC; see the file COPYING. If not, write to 21 the Free Software Foundation, 51 Franklin Street, Fifth Floor, 22 Boston, 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 44 enum 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 58 typedef enum mangling_flags mangling_flags; 59 60 static tree thunk_adjust (tree, bool, HOST_WIDE_INT, tree); 61 static void do_build_assign_ref (tree); 62 static void do_build_copy_constructor (tree); 63 static tree synthesize_exception_spec (tree, tree (*) (tree, void *), void *); 64 static tree locate_dtor (tree, void *); 65 static tree locate_ctor (tree, void *); 66 static tree locate_copy (tree, void *); 67 static tree make_alias_for_thunk (tree); 68 69 /* Called once to initialize method.c. */ 70 71 void 72 init_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 86 tree 87 make_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 177 void 178 finish_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 220 static tree 221 thunk_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 259 static GTY (()) int thunk_labelno; 260 261 /* Create a static alias to function. */ 262 263 tree 264 make_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 298 static tree 299 make_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 319 void 320 use_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 /* The back-end expects DECL_INITIAL to contain a BLOCK, so we 411 create one. */ 412 DECL_INITIAL (thunk_fndecl) = make_node (BLOCK); 413 414 /* Set up cloned argument trees for the thunk. */ 415 t = NULL_TREE; 416 for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a)) 417 { 418 tree x = copy_node (a); 419 TREE_CHAIN (x) = t; 420 DECL_CONTEXT (x) = thunk_fndecl; 421 SET_DECL_RTL (x, NULL_RTX); 422 DECL_HAS_VALUE_EXPR_P (x) = 0; 423 t = x; 424 } 425 a = nreverse (t); 426 DECL_ARGUMENTS (thunk_fndecl) = a; 427 BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) = a; 428 429 if (this_adjusting 430 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset, 431 virtual_value, alias)) 432 { 433 const char *fnname; 434 current_function_decl = thunk_fndecl; 435 DECL_RESULT (thunk_fndecl) 436 = build_decl (RESULT_DECL, 0, integer_type_node); 437 fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0); 438 init_function_start (thunk_fndecl); 439 current_function_is_thunk = 1; 440 assemble_start_function (thunk_fndecl, fnname); 441 442 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl, 443 fixed_offset, virtual_value, alias); 444 445 assemble_end_function (thunk_fndecl, fnname); 446 init_insn_lengths (); 447 current_function_decl = 0; 448 cfun = 0; 449 TREE_ASM_WRITTEN (thunk_fndecl) = 1; 450 } 451 else 452 { 453 /* If this is a covariant thunk, or we don't have the necessary 454 code for efficient thunks, generate a thunk function that 455 just makes a call to the real function. Unfortunately, this 456 doesn't work for varargs. */ 457 458 if (varargs_function_p (function)) 459 error ("generic thunk code fails for method %q#D which uses %<...%>", 460 function); 461 462 DECL_RESULT (thunk_fndecl) = NULL_TREE; 463 464 start_preparsed_function (thunk_fndecl, NULL_TREE, SF_PRE_PARSED); 465 /* We don't bother with a body block for thunks. */ 466 467 /* There's no need to check accessibility inside the thunk body. */ 468 push_deferring_access_checks (dk_no_check); 469 470 t = a; 471 if (this_adjusting) 472 t = thunk_adjust (t, /*this_adjusting=*/1, 473 fixed_offset, virtual_offset); 474 475 /* Build up the call to the real function. */ 476 t = tree_cons (NULL_TREE, t, NULL_TREE); 477 for (a = TREE_CHAIN (a); a; a = TREE_CHAIN (a)) 478 t = tree_cons (NULL_TREE, a, t); 479 t = nreverse (t); 480 t = build_call (alias, t); 481 CALL_FROM_THUNK_P (t) = 1; 482 483 if (VOID_TYPE_P (TREE_TYPE (t))) 484 finish_expr_stmt (t); 485 else 486 { 487 if (!this_adjusting) 488 { 489 tree cond = NULL_TREE; 490 491 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE) 492 { 493 /* If the return type is a pointer, we need to 494 protect against NULL. We know there will be an 495 adjustment, because that's why we're emitting a 496 thunk. */ 497 t = save_expr (t); 498 cond = cp_convert (boolean_type_node, t); 499 } 500 501 t = thunk_adjust (t, /*this_adjusting=*/0, 502 fixed_offset, virtual_offset); 503 if (cond) 504 t = build3 (COND_EXPR, TREE_TYPE (t), cond, t, 505 cp_convert (TREE_TYPE (t), integer_zero_node)); 506 } 507 if (IS_AGGR_TYPE (TREE_TYPE (t))) 508 t = build_cplus_new (TREE_TYPE (t), t); 509 finish_return_stmt (t); 510 } 511 512 /* Since we want to emit the thunk, we explicitly mark its name as 513 referenced. */ 514 mark_decl_referenced (thunk_fndecl); 515 516 /* But we don't want debugging information about it. */ 517 DECL_IGNORED_P (thunk_fndecl) = 1; 518 519 /* Re-enable access control. */ 520 pop_deferring_access_checks (); 521 522 thunk_fndecl = finish_function (0); 523 tree_lowering_passes (thunk_fndecl); 524 expand_body (thunk_fndecl); 525 } 526 527 pop_from_top_level (); 528 } 529 530 /* Code for synthesizing methods which have default semantics defined. */ 531 532 /* Generate code for default X(X&) constructor. */ 533 534 static void 535 do_build_copy_constructor (tree fndecl) 536 { 537 tree parm = FUNCTION_FIRST_USER_PARM (fndecl); 538 539 parm = convert_from_reference (parm); 540 541 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type) 542 && is_empty_class (current_class_type)) 543 /* Don't copy the padding byte; it might not have been allocated 544 if *this is a base subobject. */; 545 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)) 546 { 547 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm); 548 finish_expr_stmt (t); 549 } 550 else 551 { 552 tree fields = TYPE_FIELDS (current_class_type); 553 tree member_init_list = NULL_TREE; 554 int cvquals = cp_type_quals (TREE_TYPE (parm)); 555 int i; 556 tree binfo, base_binfo; 557 VEC(tree,gc) *vbases; 558 559 /* Initialize all the base-classes with the parameter converted 560 to their type so that we get their copy constructor and not 561 another constructor that takes current_class_type. We must 562 deal with the binfo's directly as a direct base might be 563 inaccessible due to ambiguity. */ 564 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0; 565 VEC_iterate (tree, vbases, i, binfo); i++) 566 { 567 member_init_list 568 = tree_cons (binfo, 569 build_tree_list (NULL_TREE, 570 build_base_path (PLUS_EXPR, parm, 571 binfo, 1)), 572 member_init_list); 573 } 574 575 for (binfo = TYPE_BINFO (current_class_type), i = 0; 576 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 577 { 578 if (BINFO_VIRTUAL_P (base_binfo)) 579 continue; 580 581 member_init_list 582 = tree_cons (base_binfo, 583 build_tree_list (NULL_TREE, 584 build_base_path (PLUS_EXPR, parm, 585 base_binfo, 1)), 586 member_init_list); 587 } 588 589 for (; fields; fields = TREE_CHAIN (fields)) 590 { 591 tree init = parm; 592 tree field = fields; 593 tree expr_type; 594 595 if (TREE_CODE (field) != FIELD_DECL) 596 continue; 597 598 expr_type = TREE_TYPE (field); 599 if (DECL_NAME (field)) 600 { 601 if (VFIELD_NAME_P (DECL_NAME (field))) 602 continue; 603 } 604 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type)) 605 /* Just use the field; anonymous types can't have 606 nontrivial copy ctors or assignment ops. */; 607 else 608 continue; 609 610 /* Compute the type of "init->field". If the copy-constructor 611 parameter is, for example, "const S&", and the type of 612 the field is "T", then the type will usually be "const 613 T". (There are no cv-qualified variants of reference 614 types.) */ 615 if (TREE_CODE (expr_type) != REFERENCE_TYPE) 616 { 617 int quals = cvquals; 618 619 if (DECL_MUTABLE_P (field)) 620 quals &= ~TYPE_QUAL_CONST; 621 expr_type = cp_build_qualified_type (expr_type, quals); 622 } 623 624 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE); 625 init = build_tree_list (NULL_TREE, init); 626 627 member_init_list = tree_cons (field, init, member_init_list); 628 } 629 finish_mem_initializers (member_init_list); 630 } 631 } 632 633 static void 634 do_build_assign_ref (tree fndecl) 635 { 636 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl)); 637 tree compound_stmt; 638 639 compound_stmt = begin_compound_stmt (0); 640 parm = convert_from_reference (parm); 641 642 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type) 643 && is_empty_class (current_class_type)) 644 /* Don't copy the padding byte; it might not have been allocated 645 if *this is a base subobject. */; 646 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)) 647 { 648 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm); 649 finish_expr_stmt (t); 650 } 651 else 652 { 653 tree fields; 654 int cvquals = cp_type_quals (TREE_TYPE (parm)); 655 int i; 656 tree binfo, base_binfo; 657 658 /* Assign to each of the direct base classes. */ 659 for (binfo = TYPE_BINFO (current_class_type), i = 0; 660 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 661 { 662 tree converted_parm; 663 664 /* We must convert PARM directly to the base class 665 explicitly since the base class may be ambiguous. */ 666 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1); 667 /* Call the base class assignment operator. */ 668 finish_expr_stmt 669 (build_special_member_call (current_class_ref, 670 ansi_assopname (NOP_EXPR), 671 build_tree_list (NULL_TREE, 672 converted_parm), 673 base_binfo, 674 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL)); 675 } 676 677 /* Assign to each of the non-static data members. */ 678 for (fields = TYPE_FIELDS (current_class_type); 679 fields; 680 fields = TREE_CHAIN (fields)) 681 { 682 tree comp = current_class_ref; 683 tree init = parm; 684 tree field = fields; 685 tree expr_type; 686 int quals; 687 688 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field)) 689 continue; 690 691 expr_type = TREE_TYPE (field); 692 693 if (CP_TYPE_CONST_P (expr_type)) 694 { 695 error ("non-static const member %q#D, can't use default " 696 "assignment operator", field); 697 continue; 698 } 699 else if (TREE_CODE (expr_type) == REFERENCE_TYPE) 700 { 701 error ("non-static reference member %q#D, can't use " 702 "default assignment operator", field); 703 continue; 704 } 705 706 if (DECL_NAME (field)) 707 { 708 if (VFIELD_NAME_P (DECL_NAME (field))) 709 continue; 710 } 711 else if (ANON_AGGR_TYPE_P (expr_type) 712 && TYPE_FIELDS (expr_type) != NULL_TREE) 713 /* Just use the field; anonymous types can't have 714 nontrivial copy ctors or assignment ops. */; 715 else 716 continue; 717 718 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE); 719 720 /* Compute the type of init->field */ 721 quals = cvquals; 722 if (DECL_MUTABLE_P (field)) 723 quals &= ~TYPE_QUAL_CONST; 724 expr_type = cp_build_qualified_type (expr_type, quals); 725 726 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE); 727 728 if (DECL_NAME (field)) 729 init = build_modify_expr (comp, NOP_EXPR, init); 730 else 731 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init); 732 finish_expr_stmt (init); 733 } 734 } 735 finish_return_stmt (current_class_ref); 736 finish_compound_stmt (compound_stmt); 737 } 738 739 /* Synthesize FNDECL, a non-static member function. */ 740 741 void 742 synthesize_method (tree fndecl) 743 { 744 bool nested = (current_function_decl != NULL_TREE); 745 tree context = decl_function_context (fndecl); 746 bool need_body = true; 747 tree stmt; 748 location_t save_input_location = input_location; 749 int error_count = errorcount; 750 int warning_count = warningcount; 751 752 /* Reset the source location, we might have been previously 753 deferred, and thus have saved where we were first needed. */ 754 DECL_SOURCE_LOCATION (fndecl) 755 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl))); 756 757 /* If we've been asked to synthesize a clone, just synthesize the 758 cloned function instead. Doing so will automatically fill in the 759 body for the clone. */ 760 if (DECL_CLONED_FUNCTION_P (fndecl)) 761 fndecl = DECL_CLONED_FUNCTION (fndecl); 762 763 /* We may be in the middle of deferred access check. Disable 764 it now. */ 765 push_deferring_access_checks (dk_no_deferred); 766 767 if (! context) 768 push_to_top_level (); 769 else if (nested) 770 push_function_context_to (context); 771 772 input_location = DECL_SOURCE_LOCATION (fndecl); 773 774 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED); 775 stmt = begin_function_body (); 776 777 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR) 778 { 779 do_build_assign_ref (fndecl); 780 need_body = false; 781 } 782 else if (DECL_CONSTRUCTOR_P (fndecl)) 783 { 784 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl); 785 if (arg_chain != void_list_node) 786 do_build_copy_constructor (fndecl); 787 else 788 finish_mem_initializers (NULL_TREE); 789 } 790 791 /* If we haven't yet generated the body of the function, just 792 generate an empty compound statement. */ 793 if (need_body) 794 { 795 tree compound_stmt; 796 compound_stmt = begin_compound_stmt (BCS_FN_BODY); 797 finish_compound_stmt (compound_stmt); 798 } 799 800 finish_function_body (stmt); 801 expand_or_defer_fn (finish_function (0)); 802 803 input_location = save_input_location; 804 805 if (! context) 806 pop_from_top_level (); 807 else if (nested) 808 pop_function_context_from (context); 809 810 pop_deferring_access_checks (); 811 812 if (error_count != errorcount || warning_count != warningcount) 813 inform ("%Hsynthesized method %qD first required here ", 814 &input_location, fndecl); 815 } 816 817 /* Use EXTRACTOR to locate the relevant function called for each base & 818 class field of TYPE. CLIENT allows additional information to be passed 819 to EXTRACTOR. Generates the union of all exceptions generated by those 820 functions. Note that we haven't updated TYPE_FIELDS and such of any 821 variants yet, so we need to look at the main one. */ 822 823 static tree 824 synthesize_exception_spec (tree type, tree (*extractor) (tree, void*), 825 void *client) 826 { 827 tree raises = empty_except_spec; 828 tree fields = TYPE_FIELDS (type); 829 tree binfo, base_binfo; 830 int i; 831 832 for (binfo = TYPE_BINFO (type), i = 0; 833 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 834 { 835 tree fn = (*extractor) (BINFO_TYPE (base_binfo), client); 836 if (fn) 837 { 838 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)); 839 840 raises = merge_exception_specifiers (raises, fn_raises); 841 } 842 } 843 for (; fields; fields = TREE_CHAIN (fields)) 844 { 845 tree type = TREE_TYPE (fields); 846 tree fn; 847 848 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields)) 849 continue; 850 while (TREE_CODE (type) == ARRAY_TYPE) 851 type = TREE_TYPE (type); 852 if (!CLASS_TYPE_P (type)) 853 continue; 854 855 fn = (*extractor) (type, client); 856 if (fn) 857 { 858 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)); 859 860 raises = merge_exception_specifiers (raises, fn_raises); 861 } 862 } 863 return raises; 864 } 865 866 /* Locate the dtor of TYPE. */ 867 868 static tree 869 locate_dtor (tree type, void *client ATTRIBUTE_UNUSED) 870 { 871 return CLASSTYPE_DESTRUCTORS (type); 872 } 873 874 /* Locate the default ctor of TYPE. */ 875 876 static tree 877 locate_ctor (tree type, void *client ATTRIBUTE_UNUSED) 878 { 879 tree fns; 880 881 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) 882 return NULL_TREE; 883 884 /* Call lookup_fnfields_1 to create the constructor declarations, if 885 necessary. */ 886 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type)) 887 return lazily_declare_fn (sfk_constructor, type); 888 889 for (fns = CLASSTYPE_CONSTRUCTORS (type); fns; fns = OVL_NEXT (fns)) 890 { 891 tree fn = OVL_CURRENT (fns); 892 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn)); 893 894 parms = skip_artificial_parms_for (fn, parms); 895 896 if (sufficient_parms_p (parms)) 897 return fn; 898 } 899 gcc_unreachable (); 900 } 901 902 struct copy_data 903 { 904 tree name; 905 int quals; 906 }; 907 908 /* Locate the copy ctor or copy assignment of TYPE. CLIENT_ 909 points to a COPY_DATA holding the name (NULL for the ctor) 910 and desired qualifiers of the source operand. */ 911 912 static tree 913 locate_copy (tree type, void *client_) 914 { 915 struct copy_data *client = (struct copy_data *)client_; 916 tree fns; 917 tree best = NULL_TREE; 918 bool excess_p = false; 919 920 if (client->name) 921 { 922 int ix; 923 ix = lookup_fnfields_1 (type, client->name); 924 if (ix < 0) 925 return NULL_TREE; 926 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix); 927 } 928 else if (TYPE_HAS_INIT_REF (type)) 929 { 930 /* If construction of the copy constructor was postponed, create 931 it now. */ 932 if (CLASSTYPE_LAZY_COPY_CTOR (type)) 933 lazily_declare_fn (sfk_copy_constructor, type); 934 fns = CLASSTYPE_CONSTRUCTORS (type); 935 } 936 else 937 return NULL_TREE; 938 for (; fns; fns = OVL_NEXT (fns)) 939 { 940 tree fn = OVL_CURRENT (fns); 941 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn)); 942 tree src_type; 943 int excess; 944 int quals; 945 946 parms = skip_artificial_parms_for (fn, parms); 947 if (!parms) 948 continue; 949 src_type = non_reference (TREE_VALUE (parms)); 950 951 if (src_type == error_mark_node) 952 return NULL_TREE; 953 954 if (!same_type_ignoring_top_level_qualifiers_p (src_type, type)) 955 continue; 956 if (!sufficient_parms_p (TREE_CHAIN (parms))) 957 continue; 958 quals = cp_type_quals (src_type); 959 if (client->quals & ~quals) 960 continue; 961 excess = quals & ~client->quals; 962 if (!best || (excess_p && !excess)) 963 { 964 best = fn; 965 excess_p = excess; 966 } 967 else 968 /* Ambiguous */ 969 return NULL_TREE; 970 } 971 return best; 972 } 973 974 /* Implicitly declare the special function indicated by KIND, as a 975 member of TYPE. For copy constructors and assignment operators, 976 CONST_P indicates whether these functions should take a const 977 reference argument or a non-const reference. Returns the 978 FUNCTION_DECL for the implicitly declared function. */ 979 980 static tree 981 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p) 982 { 983 tree fn; 984 tree parameter_types = void_list_node; 985 tree return_type; 986 tree fn_type; 987 tree raises = empty_except_spec; 988 tree rhs_parm_type = NULL_TREE; 989 tree this_parm; 990 tree name; 991 HOST_WIDE_INT saved_processing_template_decl; 992 993 /* Because we create declarations for implicitly declared functions 994 lazily, we may be creating the declaration for a member of TYPE 995 while in some completely different context. However, TYPE will 996 never be a dependent class (because we never want to do lookups 997 for implicitly defined functions in a dependent class). 998 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here 999 because we only create clones for constructors and destructors 1000 when not in a template. */ 1001 gcc_assert (!dependent_type_p (type)); 1002 saved_processing_template_decl = processing_template_decl; 1003 processing_template_decl = 0; 1004 1005 type = TYPE_MAIN_VARIANT (type); 1006 1007 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type)) 1008 { 1009 if (kind == sfk_destructor) 1010 /* See comment in check_special_function_return_type. */ 1011 return_type = build_pointer_type (void_type_node); 1012 else 1013 return_type = build_pointer_type (type); 1014 } 1015 else 1016 return_type = void_type_node; 1017 1018 switch (kind) 1019 { 1020 case sfk_destructor: 1021 /* Destructor. */ 1022 name = constructor_name (type); 1023 raises = synthesize_exception_spec (type, &locate_dtor, 0); 1024 break; 1025 1026 case sfk_constructor: 1027 /* Default constructor. */ 1028 name = constructor_name (type); 1029 raises = synthesize_exception_spec (type, &locate_ctor, 0); 1030 break; 1031 1032 case sfk_copy_constructor: 1033 case sfk_assignment_operator: 1034 { 1035 struct copy_data data; 1036 1037 data.name = NULL; 1038 data.quals = 0; 1039 if (kind == sfk_assignment_operator) 1040 { 1041 return_type = build_reference_type (type); 1042 name = ansi_assopname (NOP_EXPR); 1043 data.name = name; 1044 } 1045 else 1046 name = constructor_name (type); 1047 1048 if (const_p) 1049 { 1050 data.quals = TYPE_QUAL_CONST; 1051 rhs_parm_type = build_qualified_type (type, TYPE_QUAL_CONST); 1052 } 1053 else 1054 rhs_parm_type = type; 1055 rhs_parm_type = build_reference_type (rhs_parm_type); 1056 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types); 1057 raises = synthesize_exception_spec (type, &locate_copy, &data); 1058 break; 1059 } 1060 default: 1061 gcc_unreachable (); 1062 } 1063 1064 /* Create the function. */ 1065 fn_type = build_method_type_directly (type, return_type, parameter_types); 1066 if (raises) 1067 fn_type = build_exception_variant (fn_type, raises); 1068 fn = build_lang_decl (FUNCTION_DECL, name, fn_type); 1069 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type)); 1070 if (kind == sfk_constructor || kind == sfk_copy_constructor) 1071 DECL_CONSTRUCTOR_P (fn) = 1; 1072 else if (kind == sfk_destructor) 1073 DECL_DESTRUCTOR_P (fn) = 1; 1074 else 1075 { 1076 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1; 1077 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR); 1078 } 1079 /* Create the explicit arguments. */ 1080 if (rhs_parm_type) 1081 { 1082 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we 1083 want its type to be included in the mangled function 1084 name. */ 1085 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type); 1086 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1; 1087 } 1088 /* Add the "this" parameter. */ 1089 this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED); 1090 TREE_CHAIN (this_parm) = DECL_ARGUMENTS (fn); 1091 DECL_ARGUMENTS (fn) = this_parm; 1092 1093 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL); 1094 set_linkage_according_to_type (type, fn); 1095 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof); 1096 DECL_IN_AGGR_P (fn) = 1; 1097 DECL_ARTIFICIAL (fn) = 1; 1098 DECL_NOT_REALLY_EXTERN (fn) = 1; 1099 DECL_DECLARED_INLINE_P (fn) = 1; 1100 DECL_INLINE (fn) = 1; 1101 gcc_assert (!TREE_USED (fn)); 1102 1103 /* Restore PROCESSING_TEMPLATE_DECL. */ 1104 processing_template_decl = saved_processing_template_decl; 1105 1106 return fn; 1107 } 1108 1109 /* Add an implicit declaration to TYPE for the kind of function 1110 indicated by SFK. Return the FUNCTION_DECL for the new implicit 1111 declaration. */ 1112 1113 tree 1114 lazily_declare_fn (special_function_kind sfk, tree type) 1115 { 1116 tree fn; 1117 bool const_p; 1118 1119 /* Figure out whether or not the argument has a const reference 1120 type. */ 1121 if (sfk == sfk_copy_constructor) 1122 const_p = TYPE_HAS_CONST_INIT_REF (type); 1123 else if (sfk == sfk_assignment_operator) 1124 const_p = TYPE_HAS_CONST_ASSIGN_REF (type); 1125 else 1126 /* In this case, CONST_P will be ignored. */ 1127 const_p = false; 1128 /* Declare the function. */ 1129 fn = implicitly_declare_fn (sfk, type, const_p); 1130 /* A destructor may be virtual. */ 1131 if (sfk == sfk_destructor) 1132 check_for_override (fn, type); 1133 /* Add it to CLASSTYPE_METHOD_VEC. */ 1134 add_method (type, fn, NULL_TREE); 1135 /* Add it to TYPE_METHODS. */ 1136 if (sfk == sfk_destructor 1137 && DECL_VIRTUAL_P (fn) 1138 && abi_version_at_least (2)) 1139 /* The ABI requires that a virtual destructor go at the end of the 1140 vtable. */ 1141 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn); 1142 else 1143 { 1144 /* G++ 3.2 put the implicit destructor at the *beginning* of the 1145 TYPE_METHODS list, which cause the destructor to be emitted 1146 in an incorrect location in the vtable. */ 1147 if (warn_abi && DECL_VIRTUAL_P (fn)) 1148 warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant" 1149 "and may change in a future version of GCC due to " 1150 "implicit virtual destructor", 1151 type); 1152 TREE_CHAIN (fn) = TYPE_METHODS (type); 1153 TYPE_METHODS (type) = fn; 1154 } 1155 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0); 1156 if (sfk == sfk_assignment_operator) 1157 CLASSTYPE_LAZY_ASSIGNMENT_OP (type) = 0; 1158 else 1159 { 1160 /* Remember that the function has been created. */ 1161 if (sfk == sfk_constructor) 1162 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0; 1163 else if (sfk == sfk_copy_constructor) 1164 CLASSTYPE_LAZY_COPY_CTOR (type) = 0; 1165 else if (sfk == sfk_destructor) 1166 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0; 1167 /* Create appropriate clones. */ 1168 clone_function_decl (fn, /*update_method_vec=*/true); 1169 } 1170 1171 return fn; 1172 } 1173 1174 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST 1175 as there are artificial parms in FN. */ 1176 1177 tree 1178 skip_artificial_parms_for (tree fn, tree list) 1179 { 1180 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)) 1181 list = TREE_CHAIN (list); 1182 else 1183 return list; 1184 1185 if (DECL_HAS_IN_CHARGE_PARM_P (fn)) 1186 list = TREE_CHAIN (list); 1187 if (DECL_HAS_VTT_PARM_P (fn)) 1188 list = TREE_CHAIN (list); 1189 return list; 1190 } 1191 1192 #include "gt-cp-method.h" 1193