method.c revision 96263
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 Free Software Foundation, Inc. 5 Contributed by Michael Tiemann (tiemann@cygnus.com) 6 7This file is part of GNU CC. 8 9GNU CC 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 14GNU CC 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 GNU CC; see the file COPYING. If not, write to 21the Free Software Foundation, 59 Temple Place - Suite 330, 22Boston, MA 02111-1307, USA. */ 23 24 25/* Handle method declarations. */ 26#include "config.h" 27#include "system.h" 28#include "tree.h" 29#include "cp-tree.h" 30#include "obstack.h" 31#include "rtl.h" 32#include "expr.h" 33#include "output.h" 34#include "flags.h" 35#include "toplev.h" 36#include "ggc.h" 37#include "tm_p.h" 38 39/* Various flags to control the mangling process. */ 40 41enum mangling_flags 42{ 43 /* No flags. */ 44 mf_none = 0, 45 /* The thing we are presently mangling is part of a template type, 46 rather than a fully instantiated type. Therefore, we may see 47 complex expressions where we would normally expect to see a 48 simple integer constant. */ 49 mf_maybe_uninstantiated = 1, 50 /* When mangling a numeric value, use the form `_XX_' (instead of 51 just `XX') if the value has more than one digit. */ 52 mf_use_underscores_around_value = 2, 53}; 54 55typedef enum mangling_flags mangling_flags; 56 57#define obstack_chunk_alloc xmalloc 58#define obstack_chunk_free free 59 60static void do_build_assign_ref PARAMS ((tree)); 61static void do_build_copy_constructor PARAMS ((tree)); 62static tree synthesize_exception_spec PARAMS ((tree, tree (*) (tree, void *), void *)); 63static tree locate_dtor PARAMS ((tree, void *)); 64static tree locate_ctor PARAMS ((tree, void *)); 65static tree locate_copy PARAMS ((tree, void *)); 66 67/* Called once to initialize method.c. */ 68 69void 70init_method () 71{ 72 init_mangle (); 73} 74 75 76/* Set the mangled name (DECL_ASSEMBLER_NAME) for DECL. */ 77 78void 79set_mangled_name_for_decl (decl) 80 tree decl; 81{ 82 if (processing_template_decl) 83 /* There's no need to mangle the name of a template function. */ 84 return; 85 86 mangle_decl (decl); 87} 88 89 90/* Given a tree_code CODE, and some arguments (at least one), 91 attempt to use an overloaded operator on the arguments. 92 93 For unary operators, only the first argument need be checked. 94 For binary operators, both arguments may need to be checked. 95 96 Member functions can convert class references to class pointers, 97 for one-level deep indirection. More than that is not supported. 98 Operators [](), ()(), and ->() must be member functions. 99 100 We call function call building calls with LOOKUP_COMPLAIN if they 101 are our only hope. This is true when we see a vanilla operator 102 applied to something of aggregate type. If this fails, we are free 103 to return `error_mark_node', because we will have reported the 104 error. 105 106 Operators NEW and DELETE overload in funny ways: operator new takes 107 a single `size' parameter, and operator delete takes a pointer to the 108 storage being deleted. When overloading these operators, success is 109 assumed. If there is a failure, report an error message and return 110 `error_mark_node'. */ 111 112/* NOSTRICT */ 113tree 114build_opfncall (code, flags, xarg1, xarg2, arg3) 115 enum tree_code code; 116 int flags; 117 tree xarg1, xarg2, arg3; 118{ 119 return build_new_op (code, flags, xarg1, xarg2, arg3); 120} 121 122/* This function takes an identifier, ID, and attempts to figure out what 123 it means. There are a number of possible scenarios, presented in increasing 124 order of hair: 125 126 1) not in a class's scope 127 2) in class's scope, member name of the class's method 128 3) in class's scope, but not a member name of the class 129 4) in class's scope, member name of a class's variable 130 131 NAME is $1 from the bison rule. It is an IDENTIFIER_NODE. 132 VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1) 133 134 As a last ditch, try to look up the name as a label and return that 135 address. 136 137 Values which are declared as being of REFERENCE_TYPE are 138 automatically dereferenced here (as a hack to make the 139 compiler faster). */ 140 141tree 142hack_identifier (value, name) 143 tree value, name; 144{ 145 tree type; 146 147 if (value == error_mark_node) 148 return error_mark_node; 149 150 type = TREE_TYPE (value); 151 if (TREE_CODE (value) == FIELD_DECL) 152 { 153 if (current_class_ptr == NULL_TREE) 154 { 155 if (current_function_decl 156 && DECL_STATIC_FUNCTION_P (current_function_decl)) 157 error ("invalid use of member `%D' in static member function", 158 value); 159 else 160 /* We can get here when processing a bad default 161 argument, like: 162 struct S { int a; void f(int i = a); } */ 163 error ("invalid use of member `%D'", value); 164 165 return error_mark_node; 166 } 167 TREE_USED (current_class_ptr) = 1; 168 169 /* Mark so that if we are in a constructor, and then find that 170 this field was initialized by a base initializer, 171 we can emit an error message. */ 172 TREE_USED (value) = 1; 173 value = build_component_ref (current_class_ref, name, NULL_TREE, 1); 174 } 175 else if ((TREE_CODE (value) == FUNCTION_DECL 176 && DECL_FUNCTION_MEMBER_P (value)) 177 || (TREE_CODE (value) == OVERLOAD 178 && DECL_FUNCTION_MEMBER_P (OVL_CURRENT (value)))) 179 { 180 tree decl; 181 182 if (TREE_CODE (value) == OVERLOAD) 183 value = OVL_CURRENT (value); 184 185 decl = maybe_dummy_object (DECL_CONTEXT (value), 0); 186 value = build_component_ref (decl, name, NULL_TREE, 1); 187 } 188 else if (really_overloaded_fn (value)) 189 ; 190 else if (TREE_CODE (value) == OVERLOAD) 191 /* not really overloaded function */ 192 mark_used (OVL_FUNCTION (value)); 193 else if (TREE_CODE (value) == TREE_LIST) 194 { 195 /* Ambiguous reference to base members, possibly other cases?. */ 196 tree t = value; 197 while (t && TREE_CODE (t) == TREE_LIST) 198 { 199 mark_used (TREE_VALUE (t)); 200 t = TREE_CHAIN (t); 201 } 202 } 203 else if (TREE_CODE (value) == NAMESPACE_DECL) 204 { 205 error ("use of namespace `%D' as expression", value); 206 return error_mark_node; 207 } 208 else if (DECL_CLASS_TEMPLATE_P (value)) 209 { 210 error ("use of class template `%T' as expression", value); 211 return error_mark_node; 212 } 213 else 214 mark_used (value); 215 216 if (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == PARM_DECL 217 || TREE_CODE (value) == RESULT_DECL) 218 { 219 tree context = decl_function_context (value); 220 if (context != NULL_TREE && context != current_function_decl 221 && ! TREE_STATIC (value)) 222 { 223 error ("use of %s from containing function", 224 (TREE_CODE (value) == VAR_DECL 225 ? "`auto' variable" : "parameter")); 226 cp_error_at (" `%#D' declared here", value); 227 value = error_mark_node; 228 } 229 } 230 231 if (DECL_P (value) && DECL_NONLOCAL (value)) 232 { 233 if (DECL_CLASS_SCOPE_P (value) 234 && DECL_CONTEXT (value) != current_class_type) 235 { 236 tree path; 237 path = currently_open_derived_class (DECL_CONTEXT (value)); 238 enforce_access (path, value); 239 } 240 } 241 else if (TREE_CODE (value) == TREE_LIST 242 && TREE_TYPE (value) == error_mark_node) 243 { 244 error ("\ 245request for member `%D' is ambiguous in multiple inheritance lattice", 246 name); 247 print_candidates (value); 248 return error_mark_node; 249 } 250 251 if (! processing_template_decl) 252 value = convert_from_reference (value); 253 return value; 254} 255 256 257/* Return a thunk to FUNCTION. For a virtual thunk, DELTA is the 258 offset to this used to locate the vptr, and VCALL_INDEX is used to 259 look up the eventual subobject location. For a non-virtual thunk, 260 DELTA is the offset to this and VCALL_INDEX is NULL. */ 261 262tree 263make_thunk (function, delta, vcall_index) 264 tree function; 265 tree delta; 266 tree vcall_index; 267{ 268 tree thunk_id; 269 tree thunk; 270 tree func_decl; 271 tree vcall_offset; 272 HOST_WIDE_INT d; 273 274 /* Scale the VCALL_INDEX to be in terms of bytes. */ 275 if (vcall_index) 276 vcall_offset 277 = size_binop (MULT_EXPR, 278 vcall_index, 279 convert (ssizetype, 280 TYPE_SIZE_UNIT (vtable_entry_type))); 281 else 282 vcall_offset = NULL_TREE; 283 284 d = tree_low_cst (delta, 0); 285 286 if (TREE_CODE (function) != ADDR_EXPR) 287 abort (); 288 func_decl = TREE_OPERAND (function, 0); 289 if (TREE_CODE (func_decl) != FUNCTION_DECL) 290 abort (); 291 292 thunk_id = mangle_thunk (TREE_OPERAND (function, 0), 293 delta, vcall_offset); 294 thunk = IDENTIFIER_GLOBAL_VALUE (thunk_id); 295 if (thunk && !DECL_THUNK_P (thunk)) 296 { 297 error ("implementation-reserved name `%D' used", thunk_id); 298 thunk = NULL_TREE; 299 SET_IDENTIFIER_GLOBAL_VALUE (thunk_id, thunk); 300 } 301 if (thunk == NULL_TREE) 302 { 303 thunk = build_decl (FUNCTION_DECL, thunk_id, TREE_TYPE (func_decl)); 304 DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (func_decl); 305 copy_lang_decl (func_decl); 306 SET_DECL_ASSEMBLER_NAME (thunk, thunk_id); 307 DECL_CONTEXT (thunk) = DECL_CONTEXT (func_decl); 308 TREE_READONLY (thunk) = TREE_READONLY (func_decl); 309 TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (func_decl); 310 TREE_PUBLIC (thunk) = TREE_PUBLIC (func_decl); 311 if (flag_weak) 312 comdat_linkage (thunk); 313 SET_DECL_THUNK_P (thunk); 314 DECL_INITIAL (thunk) = function; 315 THUNK_DELTA (thunk) = d; 316 THUNK_VCALL_OFFSET (thunk) = vcall_offset; 317 /* The thunk itself is not a constructor or destructor, even if 318 the thing it is thunking to is. */ 319 DECL_INTERFACE_KNOWN (thunk) = 1; 320 DECL_NOT_REALLY_EXTERN (thunk) = 1; 321 DECL_SAVED_FUNCTION_DATA (thunk) = NULL; 322 DECL_DESTRUCTOR_P (thunk) = 0; 323 DECL_CONSTRUCTOR_P (thunk) = 0; 324 /* And neither is it a clone. */ 325 DECL_CLONED_FUNCTION (thunk) = NULL_TREE; 326 DECL_EXTERNAL (thunk) = 1; 327 DECL_ARTIFICIAL (thunk) = 1; 328 /* Even if this thunk is a member of a local class, we don't 329 need a static chain. */ 330 DECL_NO_STATIC_CHAIN (thunk) = 1; 331 /* The THUNK is not a pending inline, even if the FUNC_DECL is. */ 332 DECL_PENDING_INLINE_P (thunk) = 0; 333 /* Nor has it been deferred. */ 334 DECL_DEFERRED_FN (thunk) = 0; 335 /* So that finish_file can write out any thunks that need to be: */ 336 pushdecl_top_level (thunk); 337 SET_IDENTIFIER_GLOBAL_VALUE (thunk_id, thunk); 338 } 339 return thunk; 340} 341 342/* Emit the definition of a C++ multiple inheritance vtable thunk. If 343 EMIT_P is non-zero, the thunk is emitted immediately. */ 344 345void 346use_thunk (thunk_fndecl, emit_p) 347 tree thunk_fndecl; 348 int emit_p; 349{ 350 tree fnaddr; 351 tree function; 352 tree vcall_offset; 353 HOST_WIDE_INT delta; 354 355 if (TREE_ASM_WRITTEN (thunk_fndecl)) 356 return; 357 358 fnaddr = DECL_INITIAL (thunk_fndecl); 359 if (TREE_CODE (DECL_INITIAL (thunk_fndecl)) != ADDR_EXPR) 360 /* We already turned this thunk into an ordinary function. 361 There's no need to process this thunk again. */ 362 return; 363 364 /* Thunks are always addressable; they only appear in vtables. */ 365 TREE_ADDRESSABLE (thunk_fndecl) = 1; 366 367 /* Figure out what function is being thunked to. It's referenced in 368 this translation unit. */ 369 function = TREE_OPERAND (fnaddr, 0); 370 TREE_ADDRESSABLE (function) = 1; 371 mark_used (function); 372 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (function)) = 1; 373 if (!emit_p) 374 return; 375 376 delta = THUNK_DELTA (thunk_fndecl); 377 vcall_offset = THUNK_VCALL_OFFSET (thunk_fndecl); 378 379 /* And, if we need to emit the thunk, it's used. */ 380 mark_used (thunk_fndecl); 381 /* This thunk is actually defined. */ 382 DECL_EXTERNAL (thunk_fndecl) = 0; 383 /* The linkage of the function may have changed. FIXME in linkage 384 rewrite. */ 385 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function); 386 387 if (flag_syntax_only) 388 { 389 TREE_ASM_WRITTEN (thunk_fndecl) = 1; 390 return; 391 } 392 393 push_to_top_level (); 394 395 /* The back-end expects DECL_INITIAL to contain a BLOCK, so we 396 create one. */ 397 DECL_INITIAL (thunk_fndecl) = make_node (BLOCK); 398 BLOCK_VARS (DECL_INITIAL (thunk_fndecl)) 399 = DECL_ARGUMENTS (thunk_fndecl); 400 401#ifdef ASM_OUTPUT_MI_THUNK 402 if (!vcall_offset) 403 { 404 const char *fnname; 405 current_function_decl = thunk_fndecl; 406 DECL_RESULT (thunk_fndecl) 407 = build_decl (RESULT_DECL, 0, integer_type_node); 408 fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0); 409 init_function_start (thunk_fndecl, input_filename, lineno); 410 current_function_is_thunk = 1; 411 assemble_start_function (thunk_fndecl, fnname); 412 ASM_OUTPUT_MI_THUNK (asm_out_file, thunk_fndecl, delta, function); 413 assemble_end_function (thunk_fndecl, fnname); 414 current_function_decl = 0; 415 cfun = 0; 416 TREE_ASM_WRITTEN (thunk_fndecl) = 1; 417 } 418 else 419#endif /* ASM_OUTPUT_MI_THUNK */ 420 { 421 /* If we don't have the necessary macro for efficient thunks, generate 422 a thunk function that just makes a call to the real function. 423 Unfortunately, this doesn't work for varargs. */ 424 425 tree a, t; 426 427 if (varargs_function_p (function)) 428 error ("generic thunk code fails for method `%#D' which uses `...'", 429 function); 430 431 /* Set up clone argument trees for the thunk. */ 432 t = NULL_TREE; 433 for (a = DECL_ARGUMENTS (function); a; a = TREE_CHAIN (a)) 434 { 435 tree x = copy_node (a); 436 TREE_CHAIN (x) = t; 437 DECL_CONTEXT (x) = thunk_fndecl; 438 t = x; 439 } 440 a = nreverse (t); 441 DECL_ARGUMENTS (thunk_fndecl) = a; 442 DECL_RESULT (thunk_fndecl) = NULL_TREE; 443 444 start_function (NULL_TREE, thunk_fndecl, NULL_TREE, SF_PRE_PARSED); 445 /* We don't bother with a body block for thunks. */ 446 447 /* Adjust the this pointer by the constant. */ 448 t = ssize_int (delta); 449 t = fold (build (PLUS_EXPR, TREE_TYPE (a), a, t)); 450 451 /* If there's a vcall offset, look up that value in the vtable and 452 adjust the `this' pointer again. */ 453 if (vcall_offset && !integer_zerop (vcall_offset)) 454 { 455 tree orig_this; 456 457 t = save_expr (t); 458 orig_this = t; 459 /* The vptr is always at offset zero in the object. */ 460 t = build1 (NOP_EXPR, 461 build_pointer_type (build_pointer_type 462 (vtable_entry_type)), 463 t); 464 /* Form the vtable address. */ 465 t = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (t)), t); 466 /* Find the entry with the vcall offset. */ 467 t = build (PLUS_EXPR, TREE_TYPE (t), t, vcall_offset); 468 /* Calculate the offset itself. */ 469 t = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (t)), t); 470 /* Adjust the `this' pointer. */ 471 t = fold (build (PLUS_EXPR, 472 TREE_TYPE (orig_this), 473 orig_this, 474 t)); 475 } 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 (function, t); 483 if (VOID_TYPE_P (TREE_TYPE (t))) 484 finish_expr_stmt (t); 485 else 486 finish_return_stmt (t); 487 488 /* Since we want to emit the thunk, we explicitly mark its name as 489 referenced. */ 490 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (thunk_fndecl)) = 1; 491 492 /* But we don't want debugging information about it. */ 493 DECL_IGNORED_P (thunk_fndecl) = 1; 494 495 expand_body (finish_function (0)); 496 } 497 498 pop_from_top_level (); 499} 500 501/* Code for synthesizing methods which have default semantics defined. */ 502 503/* Generate code for default X(X&) constructor. */ 504 505static void 506do_build_copy_constructor (fndecl) 507 tree fndecl; 508{ 509 tree parm = FUNCTION_FIRST_USER_PARM (fndecl); 510 tree t; 511 512 parm = convert_from_reference (parm); 513 514 if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type) 515 && is_empty_class (current_class_type)) 516 /* Don't copy the padding byte; it might not have been allocated 517 if *this is a base subobject. */; 518 else if (TYPE_HAS_TRIVIAL_INIT_REF (current_class_type)) 519 { 520 t = build (INIT_EXPR, void_type_node, current_class_ref, parm); 521 finish_expr_stmt (t); 522 } 523 else 524 { 525 tree fields = TYPE_FIELDS (current_class_type); 526 int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type); 527 tree binfos = TYPE_BINFO_BASETYPES (current_class_type); 528 tree member_init_list = NULL_TREE; 529 tree base_init_list = NULL_TREE; 530 int cvquals = cp_type_quals (TREE_TYPE (parm)); 531 int i; 532 533 /* Initialize all the base-classes with the parameter converted 534 to their type so that we get their copy constructor and not 535 another constructor that takes current_class_type. We must 536 deal with the binfo's directly as a direct base might be 537 inaccessible due to ambiguity. */ 538 for (t = CLASSTYPE_VBASECLASSES (current_class_type); t; 539 t = TREE_CHAIN (t)) 540 { 541 tree binfo = TREE_VALUE (t); 542 543 base_init_list = tree_cons (binfo, 544 build_base_path (PLUS_EXPR, parm, 545 binfo, 1), 546 base_init_list); 547 } 548 549 for (i = 0; i < n_bases; ++i) 550 { 551 tree binfo = TREE_VEC_ELT (binfos, i); 552 if (TREE_VIA_VIRTUAL (binfo)) 553 continue; 554 555 base_init_list = tree_cons (binfo, 556 build_base_path (PLUS_EXPR, parm, 557 binfo, 1), 558 base_init_list); 559 } 560 561 for (; fields; fields = TREE_CHAIN (fields)) 562 { 563 tree init; 564 tree field = fields; 565 tree expr_type; 566 567 if (TREE_CODE (field) != FIELD_DECL) 568 continue; 569 570 init = parm; 571 if (DECL_NAME (field)) 572 { 573 if (VFIELD_NAME_P (DECL_NAME (field))) 574 continue; 575 576 /* True for duplicate members. */ 577 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field) 578 continue; 579 } 580 else if ((t = TREE_TYPE (field)) != NULL_TREE 581 && ANON_AGGR_TYPE_P (t) 582 && TYPE_FIELDS (t) != NULL_TREE) 583 /* Just use the field; anonymous types can't have 584 nontrivial copy ctors or assignment ops. */; 585 else 586 continue; 587 588 /* Compute the type of "init->field". If the copy-constructor 589 parameter is, for example, "const S&", and the type of 590 the field is "T", then the type will usually be "const 591 T". (There are no cv-qualified variants of reference 592 types.) */ 593 expr_type = TREE_TYPE (field); 594 if (TREE_CODE (expr_type) != REFERENCE_TYPE) 595 expr_type = cp_build_qualified_type (expr_type, cvquals); 596 init = build (COMPONENT_REF, expr_type, init, field); 597 init = build_tree_list (NULL_TREE, init); 598 599 member_init_list 600 = tree_cons (field, init, member_init_list); 601 } 602 member_init_list = nreverse (member_init_list); 603 base_init_list = nreverse (base_init_list); 604 emit_base_init (member_init_list, base_init_list); 605 } 606} 607 608static void 609do_build_assign_ref (fndecl) 610 tree fndecl; 611{ 612 tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl)); 613 tree compound_stmt; 614 615 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0); 616 parm = convert_from_reference (parm); 617 618 if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type) 619 && is_empty_class (current_class_type)) 620 /* Don't copy the padding byte; it might not have been allocated 621 if *this is a base subobject. */; 622 else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (current_class_type)) 623 { 624 tree t = build (MODIFY_EXPR, void_type_node, current_class_ref, parm); 625 finish_expr_stmt (t); 626 } 627 else 628 { 629 tree fields = TYPE_FIELDS (current_class_type); 630 int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type); 631 tree binfos = TYPE_BINFO_BASETYPES (current_class_type); 632 int cvquals = cp_type_quals (TREE_TYPE (parm)); 633 int i; 634 635 for (i = 0; i < n_bases; ++i) 636 { 637 /* We must deal with the binfo's directly as a direct base 638 might be inaccessible due to ambiguity. */ 639 tree binfo = TREE_VEC_ELT (binfos, i); 640 tree src = build_base_path (PLUS_EXPR, parm, binfo, 1); 641 tree dst = build_base_path (PLUS_EXPR, current_class_ref, binfo, 1); 642 643 tree expr = build_method_call (dst, 644 ansi_assopname (NOP_EXPR), 645 build_tree_list (NULL_TREE, src), 646 binfo, 647 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL); 648 finish_expr_stmt (expr); 649 } 650 for (; fields; fields = TREE_CHAIN (fields)) 651 { 652 tree comp, init, t; 653 tree field = fields; 654 655 if (TREE_CODE (field) != FIELD_DECL) 656 continue; 657 658 if (CP_TYPE_CONST_P (TREE_TYPE (field))) 659 { 660 error ("non-static const member `%#D', can't use default assignment operator", field); 661 continue; 662 } 663 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE) 664 { 665 error ("non-static reference member `%#D', can't use default assignment operator", field); 666 continue; 667 } 668 669 comp = current_class_ref; 670 init = parm; 671 672 if (DECL_NAME (field)) 673 { 674 if (VFIELD_NAME_P (DECL_NAME (field))) 675 continue; 676 677 /* True for duplicate members. */ 678 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (field)) != field) 679 continue; 680 } 681 else if ((t = TREE_TYPE (field)) != NULL_TREE 682 && ANON_AGGR_TYPE_P (t) 683 && TYPE_FIELDS (t) != NULL_TREE) 684 /* Just use the field; anonymous types can't have 685 nontrivial copy ctors or assignment ops. */; 686 else 687 continue; 688 689 comp = build (COMPONENT_REF, TREE_TYPE (field), comp, field); 690 init = build (COMPONENT_REF, 691 build_qualified_type (TREE_TYPE (field), cvquals), 692 init, field); 693 694 if (DECL_NAME (field)) 695 finish_expr_stmt (build_modify_expr (comp, NOP_EXPR, init)); 696 else 697 finish_expr_stmt (build (MODIFY_EXPR, TREE_TYPE (comp), comp, 698 init)); 699 } 700 } 701 finish_return_stmt (current_class_ref); 702 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt); 703} 704 705void 706synthesize_method (fndecl) 707 tree fndecl; 708{ 709 int nested = (current_function_decl != NULL_TREE); 710 tree context = decl_function_context (fndecl); 711 int need_body = 1; 712 tree stmt; 713 714 if (at_eof) 715 import_export_decl (fndecl); 716 717 /* If we've been asked to synthesize a clone, just synthesize the 718 cloned function instead. Doing so will automatically fill in the 719 body for the clone. */ 720 if (DECL_CLONED_FUNCTION_P (fndecl)) 721 { 722 synthesize_method (DECL_CLONED_FUNCTION (fndecl)); 723 return; 724 } 725 726 if (! context) 727 push_to_top_level (); 728 else if (nested) 729 push_function_context_to (context); 730 731 /* Put the function definition at the position where it is needed, 732 rather than within the body of the class. That way, an error 733 during the generation of the implicit body points at the place 734 where the attempt to generate the function occurs, giving the 735 user a hint as to why we are attempting to generate the 736 function. */ 737 DECL_SOURCE_LINE (fndecl) = lineno; 738 DECL_SOURCE_FILE (fndecl) = input_filename; 739 740 interface_unknown = 1; 741 start_function (NULL_TREE, fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED); 742 clear_last_expr (); 743 stmt = begin_function_body (); 744 745 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR) 746 { 747 do_build_assign_ref (fndecl); 748 need_body = 0; 749 } 750 else if (DECL_CONSTRUCTOR_P (fndecl)) 751 { 752 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl); 753 if (arg_chain != void_list_node) 754 do_build_copy_constructor (fndecl); 755 else if (TYPE_NEEDS_CONSTRUCTING (current_class_type)) 756 finish_mem_initializers (NULL_TREE); 757 } 758 759 /* If we haven't yet generated the body of the function, just 760 generate an empty compound statement. */ 761 if (need_body) 762 { 763 tree compound_stmt; 764 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0); 765 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt); 766 } 767 768 finish_function_body (stmt); 769 expand_body (finish_function (0)); 770 771 extract_interface_info (); 772 if (! context) 773 pop_from_top_level (); 774 else if (nested) 775 pop_function_context_from (context); 776} 777 778/* Use EXTRACTOR to locate the relevant function called for each base & 779 class field of TYPE. CLIENT allows additional information to be passed 780 to EXTRACTOR. Generates the union of all exceptions generated by those 781 functions. Note that we haven't updated TYPE_FIELDS and such of any 782 variants yet, so we need to look at the main one. */ 783 784static tree 785synthesize_exception_spec (type, extractor, client) 786 tree type; 787 tree (*extractor) (tree, void *); 788 void *client; 789{ 790 tree raises = empty_except_spec; 791 tree fields = TYPE_FIELDS (type); 792 int i, n_bases = CLASSTYPE_N_BASECLASSES (type); 793 tree binfos = TYPE_BINFO_BASETYPES (type); 794 795 for (i = 0; i != n_bases; i++) 796 { 797 tree base = BINFO_TYPE (TREE_VEC_ELT (binfos, i)); 798 tree fn = (*extractor) (base, client); 799 if (fn) 800 { 801 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)); 802 803 raises = merge_exception_specifiers (raises, fn_raises); 804 } 805 } 806 for (; fields; fields = TREE_CHAIN (fields)) 807 { 808 tree type = TREE_TYPE (fields); 809 tree fn; 810 811 if (TREE_CODE (fields) != FIELD_DECL) 812 continue; 813 while (TREE_CODE (type) == ARRAY_TYPE) 814 type = TREE_TYPE (type); 815 if (TREE_CODE (type) != RECORD_TYPE) 816 continue; 817 818 fn = (*extractor) (type, client); 819 if (fn) 820 { 821 tree fn_raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)); 822 823 raises = merge_exception_specifiers (raises, fn_raises); 824 } 825 } 826 return raises; 827} 828 829/* Locate the dtor of TYPE. */ 830 831static tree 832locate_dtor (type, client) 833 tree type; 834 void *client ATTRIBUTE_UNUSED; 835{ 836 tree fns; 837 838 if (!TYPE_HAS_DESTRUCTOR (type)) 839 return NULL_TREE; 840 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 841 CLASSTYPE_DESTRUCTOR_SLOT); 842 return fns; 843} 844 845/* Locate the default ctor of TYPE. */ 846 847static tree 848locate_ctor (type, client) 849 tree type; 850 void *client ATTRIBUTE_UNUSED; 851{ 852 tree fns; 853 854 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) 855 return NULL_TREE; 856 857 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 858 CLASSTYPE_CONSTRUCTOR_SLOT); 859 for (; fns; fns = OVL_NEXT (fns)) 860 { 861 tree fn = OVL_CURRENT (fns); 862 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn)); 863 864 if (sufficient_parms_p (TREE_CHAIN (parms))) 865 return fn; 866 } 867 return NULL_TREE; 868} 869 870struct copy_data 871{ 872 tree name; 873 int quals; 874}; 875 876/* Locate the copy ctor or copy assignment of TYPE. CLIENT_ 877 points to a COPY_DATA holding the name (NULL for the ctor) 878 and desired qualifiers of the source operand. */ 879 880static tree 881locate_copy (type, client_) 882 tree type; 883 void *client_; 884{ 885 struct copy_data *client = (struct copy_data *)client_; 886 tree fns; 887 int ix = -1; 888 tree best = NULL_TREE; 889 int excess_p = 0; 890 891 if (client->name) 892 { 893 if (TYPE_HAS_ASSIGN_REF (type)) 894 ix = lookup_fnfields_1 (type, client->name); 895 } 896 else if (TYPE_HAS_INIT_REF (type)) 897 ix = CLASSTYPE_CONSTRUCTOR_SLOT; 898 if (ix < 0) 899 return NULL_TREE; 900 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), ix); 901 902 for (; fns; fns = OVL_NEXT (fns)) 903 { 904 tree fn = OVL_CURRENT (fns); 905 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn)); 906 tree src_type; 907 int excess; 908 int quals; 909 910 parms = TREE_CHAIN (parms); 911 if (!parms) 912 continue; 913 src_type = TREE_VALUE (parms); 914 if (TREE_CODE (src_type) == REFERENCE_TYPE) 915 src_type = TREE_TYPE (src_type); 916 if (!same_type_ignoring_top_level_qualifiers_p (src_type, type)) 917 continue; 918 if (!sufficient_parms_p (TREE_CHAIN (parms))) 919 continue; 920 quals = cp_type_quals (src_type); 921 if (client->quals & ~quals) 922 continue; 923 excess = quals & ~client->quals; 924 if (!best || (excess_p && !excess)) 925 { 926 best = fn; 927 excess_p = excess; 928 } 929 else 930 /* Ambiguous */ 931 return NULL_TREE; 932 } 933 return best; 934} 935 936/* Implicitly declare the special function indicated by KIND, as a 937 member of TYPE. For copy constructors and assignment operators, 938 CONST_P indicates whether these functions should take a const 939 reference argument or a non-const reference. */ 940 941tree 942implicitly_declare_fn (kind, type, const_p) 943 special_function_kind kind; 944 tree type; 945 int const_p; 946{ 947 tree declspecs = NULL_TREE; 948 tree fn, args = NULL_TREE; 949 tree raises = empty_except_spec; 950 int retref = 0; 951 int has_parm = 0; 952 tree name = constructor_name (TYPE_IDENTIFIER (type)); 953 954 switch (kind) 955 { 956 case sfk_destructor: 957 /* Destructor. */ 958 name = build_nt (BIT_NOT_EXPR, name); 959 args = void_list_node; 960 raises = synthesize_exception_spec (type, &locate_dtor, 0); 961 break; 962 963 case sfk_constructor: 964 /* Default constructor. */ 965 args = void_list_node; 966 raises = synthesize_exception_spec (type, &locate_ctor, 0); 967 break; 968 969 case sfk_copy_constructor: 970 case sfk_assignment_operator: 971 { 972 struct copy_data data; 973 tree argtype = type; 974 975 has_parm = 1; 976 data.name = NULL; 977 data.quals = 0; 978 if (kind == sfk_assignment_operator) 979 { 980 retref = 1; 981 declspecs = build_tree_list (NULL_TREE, type); 982 983 name = ansi_assopname (NOP_EXPR); 984 data.name = name; 985 } 986 if (const_p) 987 { 988 data.quals = TYPE_QUAL_CONST; 989 argtype = build_qualified_type (argtype, TYPE_QUAL_CONST); 990 } 991 992 argtype = build_reference_type (argtype); 993 args = build_tree_list (hash_tree_chain (argtype, NULL_TREE), 994 get_identifier ("_ctor_arg")); 995 args = tree_cons (NULL_TREE, args, void_list_node); 996 997 raises = synthesize_exception_spec (type, &locate_copy, &data); 998 break; 999 } 1000 default: 1001 abort (); 1002 } 1003 1004 TREE_PARMLIST (args) = 1; 1005 1006 { 1007 tree declarator = make_call_declarator (name, args, NULL_TREE, raises); 1008 1009 if (retref) 1010 declarator = build_nt (ADDR_EXPR, declarator); 1011 1012 fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE); 1013 if (has_parm) 1014 TREE_USED (FUNCTION_FIRST_USER_PARM (fn)) = 1; 1015 } 1016 1017 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 20000408); 1018 1019 DECL_ARTIFICIAL (fn) = 1; 1020 DECL_NOT_REALLY_EXTERN (fn) = 1; 1021 DECL_DECLARED_INLINE_P (fn) = 1; 1022 DECL_INLINE (fn) = 1; 1023 defer_fn (fn); 1024 1025 return fn; 1026} 1027 1028/* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST 1029 as there are artificial parms in FN. */ 1030 1031tree 1032skip_artificial_parms_for (fn, list) 1033 tree fn, list; 1034{ 1035 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)) 1036 list = TREE_CHAIN (list); 1037 else 1038 return list; 1039 1040 if (DECL_HAS_IN_CHARGE_PARM_P (fn)) 1041 list = TREE_CHAIN (list); 1042 if (DECL_HAS_VTT_PARM_P (fn)) 1043 list = TREE_CHAIN (list); 1044 return list; 1045} 1046