1/* Process declarations and variables for C++ compiler. 2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 4 Contributed by Michael Tiemann (tiemann@cygnus.com) 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2, or (at your option) 11any later version. 12 13GCC is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING. If not, write to 20the Free Software Foundation, 51 Franklin Street, Fifth Floor, 21Boston, MA 02110-1301, USA. */ 22 23 24/* Process declarations and symbol lookup for C++ front end. 25 Also constructs types; the standard scalar types at initialization, 26 and structure, union, array and enum types when they are declared. */ 27 28/* ??? not all decl nodes are given the most useful possible 29 line numbers. For example, the CONST_DECLs for enum values. */ 30 31#include "config.h" 32#include "system.h" 33#include "coretypes.h" 34#include "tm.h" 35#include "tree.h" 36#include "rtl.h" 37#include "expr.h" 38#include "flags.h" 39#include "cp-tree.h" 40#include "tree-inline.h" 41#include "decl.h" 42#include "output.h" 43#include "except.h" 44#include "toplev.h" 45#include "hashtab.h" 46#include "tm_p.h" 47#include "target.h" 48#include "c-common.h" 49#include "c-pragma.h" 50#include "diagnostic.h" 51#include "debug.h" 52#include "timevar.h" 53#include "tree-flow.h" 54 55/* APPLE LOCAL blocks 6040305 (ce) */ 56tree grokparms (cp_parameter_declarator *, tree *); 57static const char *redeclaration_error_message (tree, tree); 58 59static int decl_jump_unsafe (tree); 60static void require_complete_types_for_parms (tree); 61static int ambi_op_p (enum tree_code); 62static int unary_op_p (enum tree_code); 63static void push_local_name (tree); 64static tree grok_reference_init (tree, tree, tree, tree *); 65static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *, 66 int, int, tree); 67static void record_unknown_type (tree, const char *); 68static tree builtin_function_1 (const char *, tree, tree, 69 enum built_in_function code, 70 enum built_in_class cl, const char *, 71 tree); 72static tree build_library_fn_1 (tree, enum tree_code, tree); 73static int member_function_or_else (tree, tree, enum overload_flags); 74static void bad_specifiers (tree, const char *, int, int, int, int, 75 int); 76static void check_for_uninitialized_const_var (tree); 77static hashval_t typename_hash (const void *); 78static int typename_compare (const void *, const void *); 79static tree local_variable_p_walkfn (tree *, int *, void *); 80static tree record_builtin_java_type (const char *, int); 81static const char *tag_name (enum tag_types); 82static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool); 83static int walk_namespaces_r (tree, walk_namespaces_fn, void *); 84static void maybe_deduce_size_from_array_init (tree, tree); 85static void layout_var_decl (tree); 86static void maybe_commonize_var (tree); 87static tree check_initializer (tree, tree, int, tree *); 88static void make_rtl_for_nonlocal_decl (tree, tree, const char *); 89static void save_function_data (tree); 90static void check_function_type (tree, tree); 91static void finish_constructor_body (void); 92static void begin_destructor_body (void); 93static void finish_destructor_body (void); 94static tree create_array_type_for_decl (tree, tree, tree); 95static tree get_atexit_node (void); 96static tree get_dso_handle_node (void); 97static tree start_cleanup_fn (void); 98static void end_cleanup_fn (void); 99static tree cp_make_fname_decl (tree, int); 100static void initialize_predefined_identifiers (void); 101static tree check_special_function_return_type 102 (special_function_kind, tree, tree); 103static tree push_cp_library_fn (enum tree_code, tree); 104static tree build_cp_library_fn (tree, enum tree_code, tree); 105static void store_parm_decls (tree); 106static void initialize_local_var (tree, tree); 107static void expand_static_init (tree, tree); 108static tree next_initializable_field (tree); 109 110/* The following symbols are subsumed in the cp_global_trees array, and 111 listed here individually for documentation purposes. 112 113 C++ extensions 114 tree wchar_decl_node; 115 116 tree vtable_entry_type; 117 tree delta_type_node; 118 tree __t_desc_type_node; 119 120 tree class_type_node; 121 tree unknown_type_node; 122 123 Array type `vtable_entry_type[]' 124 125 tree vtbl_type_node; 126 tree vtbl_ptr_type_node; 127 128 Namespaces, 129 130 tree std_node; 131 tree abi_node; 132 133 A FUNCTION_DECL which can call `abort'. Not necessarily the 134 one that the user will declare, but sufficient to be called 135 by routines that want to abort the program. 136 137 tree abort_fndecl; 138 139 The FUNCTION_DECL for the default `::operator delete'. 140 141 tree global_delete_fndecl; 142 143 Used by RTTI 144 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type; 145 tree tinfo_var_id; */ 146 147tree cp_global_trees[CPTI_MAX]; 148 149/* Indicates that there is a type value in some namespace, although 150 that is not necessarily in scope at the moment. */ 151 152tree global_type_node; 153 154/* The node that holds the "name" of the global scope. */ 155tree global_scope_name; 156 157#define local_names cp_function_chain->x_local_names 158 159/* A list of objects which have constructors or destructors 160 which reside in the global scope. The decl is stored in 161 the TREE_VALUE slot and the initializer is stored 162 in the TREE_PURPOSE slot. */ 163tree static_aggregates; 164 165/* -- end of C++ */ 166 167/* A node for the integer constants 2, and 3. */ 168 169tree integer_two_node, integer_three_node; 170 171/* Used only for jumps to as-yet undefined labels, since jumps to 172 defined labels can have their validity checked immediately. */ 173 174struct named_label_use_entry GTY(()) 175{ 176 struct named_label_use_entry *next; 177 /* The binding level to which this entry is *currently* attached. 178 This is initially the binding level in which the goto appeared, 179 but is modified as scopes are closed. */ 180 struct cp_binding_level *binding_level; 181 /* The head of the names list that was current when the goto appeared, 182 or the inner scope popped. These are the decls that will *not* be 183 skipped when jumping to the label. */ 184 tree names_in_scope; 185 /* The location of the goto, for error reporting. */ 186 location_t o_goto_locus; 187 /* True if an OpenMP structured block scope has been closed since 188 the goto appeared. This means that the branch from the label will 189 illegally exit an OpenMP scope. */ 190 bool in_omp_scope; 191}; 192 193/* A list of all LABEL_DECLs in the function that have names. Here so 194 we can clear out their names' definitions at the end of the 195 function, and so we can check the validity of jumps to these labels. */ 196 197struct named_label_entry GTY(()) 198{ 199 /* The decl itself. */ 200 tree label_decl; 201 202 /* The binding level to which the label is *currently* attached. 203 This is initially set to the binding level in which the label 204 is defined, but is modified as scopes are closed. */ 205 struct cp_binding_level *binding_level; 206 /* The head of the names list that was current when the label was 207 defined, or the inner scope popped. These are the decls that will 208 be skipped when jumping to the label. */ 209 tree names_in_scope; 210 /* A tree list of all decls from all binding levels that would be 211 crossed by a backward branch to the label. */ 212 tree bad_decls; 213 214 /* A list of uses of the label, before the label is defined. */ 215 struct named_label_use_entry *uses; 216 217 /* The following bits are set after the label is defined, and are 218 updated as scopes are popped. They indicate that a backward jump 219 to the label will illegally enter a scope of the given flavor. */ 220 bool in_try_scope; 221 bool in_catch_scope; 222 bool in_omp_scope; 223}; 224 225#define named_labels cp_function_chain->x_named_labels 226 227/* The number of function bodies which we are currently processing. 228 (Zero if we are at namespace scope, one inside the body of a 229 function, two inside the body of a function in a local class, etc.) */ 230int function_depth; 231 232/* States indicating how grokdeclarator() should handle declspecs marked 233 with __attribute__((deprecated)). An object declared as 234 __attribute__((deprecated)) suppresses warnings of uses of other 235 deprecated items. */ 236/* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */ 237/* An object declared as __attribute__((unavailable)) suppresses 238 any reports of being declared with unavailable or deprecated 239 items. */ 240/* APPLE LOCAL end "unavailable" attribute (radar 2809697) */ 241 242enum deprecated_states { 243 DEPRECATED_NORMAL, 244 DEPRECATED_SUPPRESS 245 /* APPLE LOCAL "unavailable" attribute (radar 2809697) */ 246 , DEPRECATED_UNAVAILABLE_SUPPRESS 247}; 248 249static enum deprecated_states deprecated_state = DEPRECATED_NORMAL; 250 251 252/* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or 253 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the 254 time the VAR_DECL was declared, the type was incomplete. */ 255 256static GTY(()) tree incomplete_vars; 257 258/* Returns the kind of template specialization we are currently 259 processing, given that it's declaration contained N_CLASS_SCOPES 260 explicit scope qualifications. */ 261 262tmpl_spec_kind 263current_tmpl_spec_kind (int n_class_scopes) 264{ 265 int n_template_parm_scopes = 0; 266 int seen_specialization_p = 0; 267 int innermost_specialization_p = 0; 268 struct cp_binding_level *b; 269 270 /* Scan through the template parameter scopes. */ 271 for (b = current_binding_level; 272 b->kind == sk_template_parms; 273 b = b->level_chain) 274 { 275 /* If we see a specialization scope inside a parameter scope, 276 then something is wrong. That corresponds to a declaration 277 like: 278 279 template <class T> template <> ... 280 281 which is always invalid since [temp.expl.spec] forbids the 282 specialization of a class member template if the enclosing 283 class templates are not explicitly specialized as well. */ 284 if (b->explicit_spec_p) 285 { 286 if (n_template_parm_scopes == 0) 287 innermost_specialization_p = 1; 288 else 289 seen_specialization_p = 1; 290 } 291 else if (seen_specialization_p == 1) 292 return tsk_invalid_member_spec; 293 294 ++n_template_parm_scopes; 295 } 296 297 /* Handle explicit instantiations. */ 298 if (processing_explicit_instantiation) 299 { 300 if (n_template_parm_scopes != 0) 301 /* We've seen a template parameter list during an explicit 302 instantiation. For example: 303 304 template <class T> template void f(int); 305 306 This is erroneous. */ 307 return tsk_invalid_expl_inst; 308 else 309 return tsk_expl_inst; 310 } 311 312 if (n_template_parm_scopes < n_class_scopes) 313 /* We've not seen enough template headers to match all the 314 specialized classes present. For example: 315 316 template <class T> void R<T>::S<T>::f(int); 317 318 This is invalid; there needs to be one set of template 319 parameters for each class. */ 320 return tsk_insufficient_parms; 321 else if (n_template_parm_scopes == n_class_scopes) 322 /* We're processing a non-template declaration (even though it may 323 be a member of a template class.) For example: 324 325 template <class T> void S<T>::f(int); 326 327 The `class T' maches the `S<T>', leaving no template headers 328 corresponding to the `f'. */ 329 return tsk_none; 330 else if (n_template_parm_scopes > n_class_scopes + 1) 331 /* We've got too many template headers. For example: 332 333 template <> template <class T> void f (T); 334 335 There need to be more enclosing classes. */ 336 return tsk_excessive_parms; 337 else 338 /* This must be a template. It's of the form: 339 340 template <class T> template <class U> void S<T>::f(U); 341 342 This is a specialization if the innermost level was a 343 specialization; otherwise it's just a definition of the 344 template. */ 345 return innermost_specialization_p ? tsk_expl_spec : tsk_template; 346} 347 348/* Exit the current scope. */ 349 350void 351finish_scope (void) 352{ 353 poplevel (0, 0, 0); 354} 355 356/* When a label goes out of scope, check to see if that label was used 357 in a valid manner, and issue any appropriate warnings or errors. */ 358 359static void 360pop_label (tree label, tree old_value) 361{ 362 if (!processing_template_decl) 363 { 364 if (DECL_INITIAL (label) == NULL_TREE) 365 { 366 location_t location; 367 368 error ("label %q+D used but not defined", label); 369#ifdef USE_MAPPED_LOCATION 370 location = input_location; /* FIXME want (input_filename, (line)0) */ 371#else 372 location.file = input_filename; 373 location.line = 0; 374#endif 375 /* Avoid crashing later. */ 376 define_label (location, DECL_NAME (label)); 377 } 378 else if (!TREE_USED (label)) 379 warning (OPT_Wunused_label, "label %q+D defined but not used", label); 380 } 381 382 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value); 383} 384 385/* At the end of a function, all labels declared within the function 386 go out of scope. BLOCK is the top-level block for the 387 function. */ 388 389static int 390pop_labels_1 (void **slot, void *data) 391{ 392 struct named_label_entry *ent = (struct named_label_entry *) *slot; 393 tree block = (tree) data; 394 395 pop_label (ent->label_decl, NULL_TREE); 396 397 /* Put the labels into the "variables" of the top-level block, 398 so debugger can see them. */ 399 TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block); 400 BLOCK_VARS (block) = ent->label_decl; 401 402 htab_clear_slot (named_labels, slot); 403 404 return 1; 405} 406 407static void 408pop_labels (tree block) 409{ 410 if (named_labels) 411 { 412 htab_traverse (named_labels, pop_labels_1, block); 413 named_labels = NULL; 414 } 415} 416 417/* At the end of a block with local labels, restore the outer definition. */ 418 419static void 420pop_local_label (tree label, tree old_value) 421{ 422 struct named_label_entry dummy; 423 void **slot; 424 425 pop_label (label, old_value); 426 427 dummy.label_decl = label; 428 slot = htab_find_slot (named_labels, &dummy, NO_INSERT); 429 htab_clear_slot (named_labels, slot); 430} 431 432/* The following two routines are used to interface to Objective-C++. 433 The binding level is purposely treated as an opaque type. */ 434 435void * 436objc_get_current_scope (void) 437{ 438 return current_binding_level; 439} 440 441/* The following routine is used by the NeXT-style SJLJ exceptions; 442 variables get marked 'volatile' so as to not be clobbered by 443 _setjmp()/_longjmp() calls. All variables in the current scope, 444 as well as parent scopes up to (but not including) ENCLOSING_BLK 445 shall be thusly marked. */ 446 447void 448objc_mark_locals_volatile (void *enclosing_blk) 449{ 450 struct cp_binding_level *scope; 451 452 for (scope = current_binding_level; 453 scope && scope != enclosing_blk; 454 scope = scope->level_chain) 455 { 456 tree decl; 457 458 for (decl = scope->names; decl; decl = TREE_CHAIN (decl)) 459 objc_volatilize_decl (decl); 460 461 /* Do not climb up past the current function. */ 462 if (scope->kind == sk_function_parms) 463 break; 464 } 465} 466 467/* Update data for defined and undefined labels when leaving a scope. */ 468 469static int 470poplevel_named_label_1 (void **slot, void *data) 471{ 472 struct named_label_entry *ent = (struct named_label_entry *) *slot; 473 struct cp_binding_level *bl = (struct cp_binding_level *) data; 474 struct cp_binding_level *obl = bl->level_chain; 475 476 if (ent->binding_level == bl) 477 { 478 tree decl; 479 480 for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl)) 481 if (decl_jump_unsafe (decl)) 482 ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls); 483 484 ent->binding_level = obl; 485 ent->names_in_scope = obl->names; 486 switch (bl->kind) 487 { 488 case sk_try: 489 ent->in_try_scope = true; 490 break; 491 case sk_catch: 492 ent->in_catch_scope = true; 493 break; 494 case sk_omp: 495 ent->in_omp_scope = true; 496 break; 497 default: 498 break; 499 } 500 } 501 else if (ent->uses) 502 { 503 struct named_label_use_entry *use; 504 505 for (use = ent->uses; use ; use = use->next) 506 if (use->binding_level == bl) 507 { 508 use->binding_level = obl; 509 use->names_in_scope = obl->names; 510 if (bl->kind == sk_omp) 511 use->in_omp_scope = true; 512 } 513 } 514 515 return 1; 516} 517 518/* Exit a binding level. 519 Pop the level off, and restore the state of the identifier-decl mappings 520 that were in effect when this level was entered. 521 522 If KEEP == 1, this level had explicit declarations, so 523 and create a "block" (a BLOCK node) for the level 524 to record its declarations and subblocks for symbol table output. 525 526 If FUNCTIONBODY is nonzero, this level is the body of a function, 527 so create a block as if KEEP were set and also clear out all 528 label names. 529 530 If REVERSE is nonzero, reverse the order of decls before putting 531 them into the BLOCK. */ 532 533tree 534poplevel (int keep, int reverse, int functionbody) 535{ 536 tree link; 537 /* The chain of decls was accumulated in reverse order. 538 Put it into forward order, just for cleanliness. */ 539 tree decls; 540 int tmp = functionbody; 541 int real_functionbody; 542 tree subblocks; 543 tree block; 544 tree decl; 545 int leaving_for_scope; 546 scope_kind kind; 547 548 timevar_push (TV_NAME_LOOKUP); 549 restart: 550 551 block = NULL_TREE; 552 553 gcc_assert (current_binding_level->kind != sk_class); 554 555 real_functionbody = (current_binding_level->kind == sk_cleanup 556 ? ((functionbody = 0), tmp) : functionbody); 557 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0; 558 559 gcc_assert (!VEC_length(cp_class_binding, 560 current_binding_level->class_shadowed)); 561 562 /* We used to use KEEP == 2 to indicate that the new block should go 563 at the beginning of the list of blocks at this binding level, 564 rather than the end. This hack is no longer used. */ 565 gcc_assert (keep == 0 || keep == 1); 566 567 if (current_binding_level->keep) 568 keep = 1; 569 570 /* Any uses of undefined labels, and any defined labels, now operate 571 under constraints of next binding contour. */ 572 if (cfun && !functionbody && named_labels) 573 htab_traverse (named_labels, poplevel_named_label_1, 574 current_binding_level); 575 576 /* Get the decls in the order they were written. 577 Usually current_binding_level->names is in reverse order. 578 But parameter decls were previously put in forward order. */ 579 580 if (reverse) 581 current_binding_level->names 582 = decls = nreverse (current_binding_level->names); 583 else 584 decls = current_binding_level->names; 585 586 /* If there were any declarations or structure tags in that level, 587 or if this level is a function body, 588 create a BLOCK to record them for the life of this function. */ 589 block = NULL_TREE; 590 if (keep == 1 || functionbody) 591 block = make_node (BLOCK); 592 if (block != NULL_TREE) 593 { 594 BLOCK_VARS (block) = decls; 595 BLOCK_SUBBLOCKS (block) = subblocks; 596 } 597 598 /* In each subblock, record that this is its superior. */ 599 if (keep >= 0) 600 for (link = subblocks; link; link = TREE_CHAIN (link)) 601 BLOCK_SUPERCONTEXT (link) = block; 602 603 /* We still support the old for-scope rules, whereby the variables 604 in a for-init statement were in scope after the for-statement 605 ended. We only use the new rules if flag_new_for_scope is 606 nonzero. */ 607 leaving_for_scope 608 = current_binding_level->kind == sk_for && flag_new_for_scope == 1; 609 610 /* Before we remove the declarations first check for unused variables. */ 611 if (warn_unused_variable 612 && !processing_template_decl) 613 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl)) 614 if (TREE_CODE (decl) == VAR_DECL 615 && ! TREE_USED (decl) 616 && ! DECL_IN_SYSTEM_HEADER (decl) 617 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl)) 618 warning (OPT_Wunused_variable, "unused variable %q+D", decl); 619 620 /* Remove declarations for all the DECLs in this level. */ 621 for (link = decls; link; link = TREE_CHAIN (link)) 622 { 623 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL 624 && DECL_NAME (link)) 625 { 626 tree name = DECL_NAME (link); 627 cxx_binding *ob; 628 tree ns_binding; 629 630 ob = outer_binding (name, 631 IDENTIFIER_BINDING (name), 632 /*class_p=*/true); 633 if (!ob) 634 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name); 635 else 636 ns_binding = NULL_TREE; 637 638 if (ob && ob->scope == current_binding_level->level_chain) 639 /* We have something like: 640 641 int i; 642 for (int i; ;); 643 644 and we are leaving the `for' scope. There's no reason to 645 keep the binding of the inner `i' in this case. */ 646 pop_binding (name, link); 647 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL)) 648 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL)) 649 /* Here, we have something like: 650 651 typedef int I; 652 653 void f () { 654 for (int I; ;); 655 } 656 657 We must pop the for-scope binding so we know what's a 658 type and what isn't. */ 659 pop_binding (name, link); 660 else 661 { 662 /* Mark this VAR_DECL as dead so that we can tell we left it 663 there only for backward compatibility. */ 664 DECL_DEAD_FOR_LOCAL (link) = 1; 665 666 /* Keep track of what should have happened when we 667 popped the binding. */ 668 if (ob && ob->value) 669 { 670 SET_DECL_SHADOWED_FOR_VAR (link, ob->value); 671 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1; 672 } 673 674 /* Add it to the list of dead variables in the next 675 outermost binding to that we can remove these when we 676 leave that binding. */ 677 current_binding_level->level_chain->dead_vars_from_for 678 = tree_cons (NULL_TREE, link, 679 current_binding_level->level_chain-> 680 dead_vars_from_for); 681 682 /* Although we don't pop the cxx_binding, we do clear 683 its SCOPE since the scope is going away now. */ 684 IDENTIFIER_BINDING (name)->scope 685 = current_binding_level->level_chain; 686 } 687 } 688 else 689 { 690 tree name; 691 692 /* Remove the binding. */ 693 decl = link; 694 695 if (TREE_CODE (decl) == TREE_LIST) 696 decl = TREE_VALUE (decl); 697 name = decl; 698 699 if (TREE_CODE (name) == OVERLOAD) 700 name = OVL_FUNCTION (name); 701 702 gcc_assert (DECL_P (name)); 703 pop_binding (DECL_NAME (name), decl); 704 } 705 } 706 707 /* Remove declarations for any `for' variables from inner scopes 708 that we kept around. */ 709 for (link = current_binding_level->dead_vars_from_for; 710 link; link = TREE_CHAIN (link)) 711 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link)); 712 713 /* Restore the IDENTIFIER_TYPE_VALUEs. */ 714 for (link = current_binding_level->type_shadowed; 715 link; link = TREE_CHAIN (link)) 716 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link)); 717 718 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */ 719 for (link = current_binding_level->shadowed_labels; 720 link; 721 link = TREE_CHAIN (link)) 722 pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link)); 723 724 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs 725 list if a `using' declaration put them there. The debugging 726 back-ends won't understand OVERLOAD, so we remove them here. 727 Because the BLOCK_VARS are (temporarily) shared with 728 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have 729 popped all the bindings. */ 730 if (block) 731 { 732 tree* d; 733 734 for (d = &BLOCK_VARS (block); *d; ) 735 { 736 if (TREE_CODE (*d) == TREE_LIST) 737 *d = TREE_CHAIN (*d); 738 else 739 d = &TREE_CHAIN (*d); 740 } 741 } 742 743 /* If the level being exited is the top level of a function, 744 check over all the labels. */ 745 if (functionbody) 746 { 747 /* Since this is the top level block of a function, the vars are 748 the function's parameters. Don't leave them in the BLOCK 749 because they are found in the FUNCTION_DECL instead. */ 750 BLOCK_VARS (block) = 0; 751 pop_labels (block); 752 } 753 754 kind = current_binding_level->kind; 755 if (kind == sk_cleanup) 756 { 757 tree stmt; 758 759 /* If this is a temporary binding created for a cleanup, then we'll 760 have pushed a statement list level. Pop that, create a new 761 BIND_EXPR for the block, and insert it into the stream. */ 762 stmt = pop_stmt_list (current_binding_level->statement_list); 763 stmt = c_build_bind_expr (block, stmt); 764 add_stmt (stmt); 765 } 766 767 leave_scope (); 768 if (functionbody) 769 { 770 /* The current function is being defined, so its DECL_INITIAL 771 should be error_mark_node. */ 772 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node); 773 DECL_INITIAL (current_function_decl) = block; 774 } 775 else if (block) 776 current_binding_level->blocks 777 = chainon (current_binding_level->blocks, block); 778 779 /* If we did not make a block for the level just exited, 780 any blocks made for inner levels 781 (since they cannot be recorded as subblocks in that level) 782 must be carried forward so they will later become subblocks 783 of something else. */ 784 else if (subblocks) 785 current_binding_level->blocks 786 = chainon (current_binding_level->blocks, subblocks); 787 788 /* Each and every BLOCK node created here in `poplevel' is important 789 (e.g. for proper debugging information) so if we created one 790 earlier, mark it as "used". */ 791 if (block) 792 TREE_USED (block) = 1; 793 794 /* All temporary bindings created for cleanups are popped silently. */ 795 if (kind == sk_cleanup) 796 goto restart; 797 798 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block); 799} 800 801/* Insert BLOCK at the end of the list of subblocks of the 802 current binding level. This is used when a BIND_EXPR is expanded, 803 to handle the BLOCK node inside the BIND_EXPR. */ 804 805void 806insert_block (tree block) 807{ 808 TREE_USED (block) = 1; 809 current_binding_level->blocks 810 = chainon (current_binding_level->blocks, block); 811} 812 813/* Walk all the namespaces contained NAMESPACE, including NAMESPACE 814 itself, calling F for each. The DATA is passed to F as well. */ 815 816static int 817walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data) 818{ 819 int result = 0; 820 tree current = NAMESPACE_LEVEL (namespace)->namespaces; 821 822 result |= (*f) (namespace, data); 823 824 for (; current; current = TREE_CHAIN (current)) 825 result |= walk_namespaces_r (current, f, data); 826 827 return result; 828} 829 830/* Walk all the namespaces, calling F for each. The DATA is passed to 831 F as well. */ 832 833int 834walk_namespaces (walk_namespaces_fn f, void* data) 835{ 836 return walk_namespaces_r (global_namespace, f, data); 837} 838 839/* Call wrapup_globals_declarations for the globals in NAMESPACE. If 840 DATA is non-NULL, this is the last time we will call 841 wrapup_global_declarations for this NAMESPACE. */ 842 843int 844wrapup_globals_for_namespace (tree namespace, void* data) 845{ 846 struct cp_binding_level *level = NAMESPACE_LEVEL (namespace); 847 VEC(tree,gc) *statics = level->static_decls; 848 tree *vec = VEC_address (tree, statics); 849 int len = VEC_length (tree, statics); 850 int last_time = (data != 0); 851 852 if (last_time) 853 { 854 check_global_declarations (vec, len); 855 emit_debug_global_declarations (vec, len); 856 return 0; 857 } 858 859 /* Write out any globals that need to be output. */ 860 return wrapup_global_declarations (vec, len); 861} 862 863 864/* In C++, you don't have to write `struct S' to refer to `S'; you 865 can just use `S'. We accomplish this by creating a TYPE_DECL as 866 if the user had written `typedef struct S S'. Create and return 867 the TYPE_DECL for TYPE. */ 868 869tree 870create_implicit_typedef (tree name, tree type) 871{ 872 tree decl; 873 874 decl = build_decl (TYPE_DECL, name, type); 875 DECL_ARTIFICIAL (decl) = 1; 876 /* There are other implicit type declarations, like the one *within* 877 a class that allows you to write `S::S'. We must distinguish 878 amongst these. */ 879 SET_DECL_IMPLICIT_TYPEDEF_P (decl); 880 TYPE_NAME (type) = decl; 881 882 return decl; 883} 884 885/* Remember a local name for name-mangling purposes. */ 886 887static void 888push_local_name (tree decl) 889{ 890 size_t i, nelts; 891 tree t, name; 892 893 timevar_push (TV_NAME_LOOKUP); 894 895 name = DECL_NAME (decl); 896 897 nelts = VEC_length (tree, local_names); 898 for (i = 0; i < nelts; i++) 899 { 900 t = VEC_index (tree, local_names, i); 901 if (DECL_NAME (t) == name) 902 { 903 if (!DECL_LANG_SPECIFIC (decl)) 904 retrofit_lang_decl (decl); 905 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1; 906 if (DECL_LANG_SPECIFIC (t)) 907 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1; 908 else 909 DECL_DISCRIMINATOR (decl) = 1; 910 911 VEC_replace (tree, local_names, i, decl); 912 timevar_pop (TV_NAME_LOOKUP); 913 return; 914 } 915 } 916 917 VEC_safe_push (tree, gc, local_names, decl); 918 timevar_pop (TV_NAME_LOOKUP); 919} 920 921/* Subroutine of duplicate_decls: return truthvalue of whether 922 or not types of these decls match. 923 924 For C++, we must compare the parameter list so that `int' can match 925 `int&' in a parameter position, but `int&' is not confused with 926 `const int&'. */ 927 928int 929decls_match (tree newdecl, tree olddecl) 930{ 931 int types_match; 932 933 if (newdecl == olddecl) 934 return 1; 935 936 if (TREE_CODE (newdecl) != TREE_CODE (olddecl)) 937 /* If the two DECLs are not even the same kind of thing, we're not 938 interested in their types. */ 939 return 0; 940 941 if (TREE_CODE (newdecl) == FUNCTION_DECL) 942 { 943 tree f1 = TREE_TYPE (newdecl); 944 tree f2 = TREE_TYPE (olddecl); 945 tree p1 = TYPE_ARG_TYPES (f1); 946 tree p2 = TYPE_ARG_TYPES (f2); 947 948 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl) 949 && ! (DECL_EXTERN_C_P (newdecl) 950 && DECL_EXTERN_C_P (olddecl))) 951 return 0; 952 953 if (TREE_CODE (f1) != TREE_CODE (f2)) 954 return 0; 955 956 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2))) 957 { 958 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl) 959 && (DECL_BUILT_IN (olddecl) 960#ifndef NO_IMPLICIT_EXTERN_C 961 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl)) 962 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl)) 963#endif 964 )) 965 { 966 types_match = self_promoting_args_p (p1); 967 if (p1 == void_list_node) 968 TREE_TYPE (newdecl) = TREE_TYPE (olddecl); 969 } 970#ifndef NO_IMPLICIT_EXTERN_C 971 else if (p1 == NULL_TREE 972 && (DECL_EXTERN_C_P (olddecl) 973 && DECL_IN_SYSTEM_HEADER (olddecl) 974 && !DECL_CLASS_SCOPE_P (olddecl)) 975 && (DECL_EXTERN_C_P (newdecl) 976 && DECL_IN_SYSTEM_HEADER (newdecl) 977 && !DECL_CLASS_SCOPE_P (newdecl))) 978 { 979 types_match = self_promoting_args_p (p2); 980 TREE_TYPE (newdecl) = TREE_TYPE (olddecl); 981 } 982#endif 983 else 984 types_match = compparms (p1, p2); 985 } 986 else 987 types_match = 0; 988 } 989 else if (TREE_CODE (newdecl) == TEMPLATE_DECL) 990 { 991 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) 992 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))) 993 return 0; 994 995 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl), 996 DECL_TEMPLATE_PARMS (olddecl))) 997 return 0; 998 999 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) 1000 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)), 1001 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))); 1002 else 1003 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl), 1004 DECL_TEMPLATE_RESULT (newdecl)); 1005 } 1006 else 1007 { 1008 /* Need to check scope for variable declaration (VAR_DECL). 1009 For typedef (TYPE_DECL), scope is ignored. */ 1010 if (TREE_CODE (newdecl) == VAR_DECL 1011 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl) 1012 /* [dcl.link] 1013 Two declarations for an object with C language linkage 1014 with the same name (ignoring the namespace that qualify 1015 it) that appear in different namespace scopes refer to 1016 the same object. */ 1017 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl))) 1018 return 0; 1019 1020 if (TREE_TYPE (newdecl) == error_mark_node) 1021 types_match = TREE_TYPE (olddecl) == error_mark_node; 1022 else if (TREE_TYPE (olddecl) == NULL_TREE) 1023 types_match = TREE_TYPE (newdecl) == NULL_TREE; 1024 else if (TREE_TYPE (newdecl) == NULL_TREE) 1025 types_match = 0; 1026 else 1027 types_match = comptypes (TREE_TYPE (newdecl), 1028 TREE_TYPE (olddecl), 1029 COMPARE_REDECLARATION); 1030 } 1031 1032 return types_match; 1033} 1034 1035/* If NEWDECL is `static' and an `extern' was seen previously, 1036 warn about it. OLDDECL is the previous declaration. 1037 1038 Note that this does not apply to the C++ case of declaring 1039 a variable `extern const' and then later `const'. 1040 1041 Don't complain about built-in functions, since they are beyond 1042 the user's control. */ 1043 1044void 1045warn_extern_redeclared_static (tree newdecl, tree olddecl) 1046{ 1047 tree name; 1048 1049 if (TREE_CODE (newdecl) == TYPE_DECL 1050 || TREE_CODE (newdecl) == TEMPLATE_DECL 1051 || TREE_CODE (newdecl) == CONST_DECL 1052 || TREE_CODE (newdecl) == NAMESPACE_DECL) 1053 return; 1054 1055 /* Don't get confused by static member functions; that's a different 1056 use of `static'. */ 1057 if (TREE_CODE (newdecl) == FUNCTION_DECL 1058 && DECL_STATIC_FUNCTION_P (newdecl)) 1059 return; 1060 1061 /* If the old declaration was `static', or the new one isn't, then 1062 then everything is OK. */ 1063 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl)) 1064 return; 1065 1066 /* It's OK to declare a builtin function as `static'. */ 1067 if (TREE_CODE (olddecl) == FUNCTION_DECL 1068 && DECL_ARTIFICIAL (olddecl)) 1069 return; 1070 1071 name = DECL_ASSEMBLER_NAME (newdecl); 1072 pedwarn ("%qD was declared %<extern%> and later %<static%>", newdecl); 1073 pedwarn ("previous declaration of %q+D", olddecl); 1074} 1075 1076/* NEW_DECL is a redeclaration of OLD_DECL; both are functions or 1077 function templates. If their exception specifications do not 1078 match, issue an a diagnostic. */ 1079 1080static void 1081check_redeclaration_exception_specification (tree new_decl, 1082 tree old_decl) 1083{ 1084 tree new_type; 1085 tree old_type; 1086 tree new_exceptions; 1087 tree old_exceptions; 1088 1089 new_type = TREE_TYPE (new_decl); 1090 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type); 1091 old_type = TREE_TYPE (old_decl); 1092 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type); 1093 1094 /* [except.spec] 1095 1096 If any declaration of a function has an exception-specification, 1097 all declarations, including the definition and an explicit 1098 specialization, of that function shall have an 1099 exception-specification with the same set of type-ids. */ 1100 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl)) 1101 && ! DECL_IS_BUILTIN (old_decl) 1102 && flag_exceptions 1103 && !comp_except_specs (new_exceptions, old_exceptions, 1104 /*exact=*/true)) 1105 { 1106 error ("declaration of %qF throws different exceptions", new_decl); 1107 error ("from previous declaration %q+F", old_decl); 1108 } 1109} 1110 1111/* If NEWDECL is a redeclaration of OLDDECL, merge the declarations. 1112 If the redeclaration is invalid, a diagnostic is issued, and the 1113 error_mark_node is returned. Otherwise, OLDDECL is returned. 1114 1115 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is 1116 returned. 1117 1118 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */ 1119 1120tree 1121duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend) 1122{ 1123 unsigned olddecl_uid = DECL_UID (olddecl); 1124 int olddecl_friend = 0, types_match = 0, hidden_friend = 0; 1125 int new_defines_function = 0; 1126 tree new_template; 1127 1128 if (newdecl == olddecl) 1129 return olddecl; 1130 1131 types_match = decls_match (newdecl, olddecl); 1132 1133 /* If either the type of the new decl or the type of the old decl is an 1134 error_mark_node, then that implies that we have already issued an 1135 error (earlier) for some bogus type specification, and in that case, 1136 it is rather pointless to harass the user with yet more error message 1137 about the same declaration, so just pretend the types match here. */ 1138 if (TREE_TYPE (newdecl) == error_mark_node 1139 || TREE_TYPE (olddecl) == error_mark_node) 1140 return error_mark_node; 1141 1142 if (DECL_P (olddecl) 1143 && TREE_CODE (newdecl) == FUNCTION_DECL 1144 && TREE_CODE (olddecl) == FUNCTION_DECL 1145 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl))) 1146 { 1147 if (DECL_DECLARED_INLINE_P (newdecl) 1148 && DECL_UNINLINABLE (newdecl) 1149 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl))) 1150 /* Already warned elsewhere. */; 1151 else if (DECL_DECLARED_INLINE_P (olddecl) 1152 && DECL_UNINLINABLE (olddecl) 1153 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl))) 1154 /* Already warned. */; 1155 else if (DECL_DECLARED_INLINE_P (newdecl) 1156 && DECL_UNINLINABLE (olddecl) 1157 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl))) 1158 { 1159 warning (OPT_Wattributes, "function %q+D redeclared as inline", 1160 newdecl); 1161 warning (OPT_Wattributes, "previous declaration of %q+D " 1162 "with attribute noinline", olddecl); 1163 } 1164 else if (DECL_DECLARED_INLINE_P (olddecl) 1165 && DECL_UNINLINABLE (newdecl) 1166 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl))) 1167 { 1168 warning (OPT_Wattributes, "function %q+D redeclared with " 1169 "attribute noinline", newdecl); 1170 warning (OPT_Wattributes, "previous declaration of %q+D was inline", 1171 olddecl); 1172 } 1173 } 1174 1175 /* Check for redeclaration and other discrepancies. */ 1176 if (TREE_CODE (olddecl) == FUNCTION_DECL 1177 && DECL_ARTIFICIAL (olddecl)) 1178 { 1179 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl)); 1180 if (TREE_CODE (newdecl) != FUNCTION_DECL) 1181 { 1182 /* Avoid warnings redeclaring built-ins which have not been 1183 explicitly declared. */ 1184 if (DECL_ANTICIPATED (olddecl)) 1185 return NULL_TREE; 1186 1187 /* If you declare a built-in or predefined function name as static, 1188 the old definition is overridden, but optionally warn this was a 1189 bad choice of name. */ 1190 if (! TREE_PUBLIC (newdecl)) 1191 { 1192 warning (OPT_Wshadow, "shadowing %s function %q#D", 1193 DECL_BUILT_IN (olddecl) ? "built-in" : "library", 1194 olddecl); 1195 /* Discard the old built-in function. */ 1196 return NULL_TREE; 1197 } 1198 /* If the built-in is not ansi, then programs can override 1199 it even globally without an error. */ 1200 else if (! DECL_BUILT_IN (olddecl)) 1201 warning (0, "library function %q#D redeclared as non-function %q#D", 1202 olddecl, newdecl); 1203 else 1204 { 1205 error ("declaration of %q#D", newdecl); 1206 error ("conflicts with built-in declaration %q#D", 1207 olddecl); 1208 } 1209 return NULL_TREE; 1210 } 1211 else if (!types_match) 1212 { 1213 /* Avoid warnings redeclaring built-ins which have not been 1214 explicitly declared. */ 1215 if (DECL_ANTICIPATED (olddecl)) 1216 { 1217 /* Deal with fileptr_type_node. FILE type is not known 1218 at the time we create the builtins. */ 1219 tree t1, t2; 1220 1221 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)), 1222 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl)); 1223 t1 || t2; 1224 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)) 1225 if (!t1 || !t2) 1226 break; 1227 else if (TREE_VALUE (t2) == fileptr_type_node) 1228 { 1229 tree t = TREE_VALUE (t1); 1230 1231 if (TREE_CODE (t) == POINTER_TYPE 1232 && TYPE_NAME (TREE_TYPE (t)) 1233 && DECL_NAME (TYPE_NAME (TREE_TYPE (t))) 1234 == get_identifier ("FILE") 1235 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2))) 1236 { 1237 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl)); 1238 1239 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) 1240 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)); 1241 types_match = decls_match (newdecl, olddecl); 1242 if (types_match) 1243 return duplicate_decls (newdecl, olddecl, 1244 newdecl_is_friend); 1245 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs; 1246 } 1247 } 1248 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2))) 1249 break; 1250 } 1251 else if ((DECL_EXTERN_C_P (newdecl) 1252 && DECL_EXTERN_C_P (olddecl)) 1253 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)), 1254 TYPE_ARG_TYPES (TREE_TYPE (olddecl)))) 1255 { 1256 /* A near match; override the builtin. */ 1257 1258 if (TREE_PUBLIC (newdecl)) 1259 { 1260 warning (0, "new declaration %q#D", newdecl); 1261 warning (0, "ambiguates built-in declaration %q#D", 1262 olddecl); 1263 } 1264 else 1265 warning (OPT_Wshadow, "shadowing %s function %q#D", 1266 DECL_BUILT_IN (olddecl) ? "built-in" : "library", 1267 olddecl); 1268 } 1269 else 1270 /* Discard the old built-in function. */ 1271 return NULL_TREE; 1272 1273 /* Replace the old RTL to avoid problems with inlining. */ 1274 COPY_DECL_RTL (newdecl, olddecl); 1275 } 1276 /* Even if the types match, prefer the new declarations type for 1277 built-ins which have not been explicitly declared, for 1278 exception lists, etc... */ 1279 else if (DECL_ANTICIPATED (olddecl)) 1280 { 1281 tree type = TREE_TYPE (newdecl); 1282 tree attribs = (*targetm.merge_type_attributes) 1283 (TREE_TYPE (olddecl), type); 1284 1285 type = cp_build_type_attribute_variant (type, attribs); 1286 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type; 1287 } 1288 1289 /* Whether or not the builtin can throw exceptions has no 1290 bearing on this declarator. */ 1291 TREE_NOTHROW (olddecl) = 0; 1292 1293 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl)) 1294 { 1295 /* If a builtin function is redeclared as `static', merge 1296 the declarations, but make the original one static. */ 1297 DECL_THIS_STATIC (olddecl) = 1; 1298 TREE_PUBLIC (olddecl) = 0; 1299 1300 /* Make the old declaration consistent with the new one so 1301 that all remnants of the builtin-ness of this function 1302 will be banished. */ 1303 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl)); 1304 COPY_DECL_RTL (newdecl, olddecl); 1305 } 1306 } 1307 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl)) 1308 { 1309 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl) 1310 && TREE_CODE (newdecl) != TYPE_DECL 1311 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL 1312 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)) 1313 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl) 1314 && TREE_CODE (olddecl) != TYPE_DECL 1315 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL 1316 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) 1317 == TYPE_DECL)))) 1318 { 1319 /* We do nothing special here, because C++ does such nasty 1320 things with TYPE_DECLs. Instead, just let the TYPE_DECL 1321 get shadowed, and know that if we need to find a TYPE_DECL 1322 for a given name, we can look in the IDENTIFIER_TYPE_VALUE 1323 slot of the identifier. */ 1324 return NULL_TREE; 1325 } 1326 1327 if ((TREE_CODE (newdecl) == FUNCTION_DECL 1328 && DECL_FUNCTION_TEMPLATE_P (olddecl)) 1329 || (TREE_CODE (olddecl) == FUNCTION_DECL 1330 && DECL_FUNCTION_TEMPLATE_P (newdecl))) 1331 return NULL_TREE; 1332 1333 error ("%q#D redeclared as different kind of symbol", newdecl); 1334 if (TREE_CODE (olddecl) == TREE_LIST) 1335 olddecl = TREE_VALUE (olddecl); 1336 error ("previous declaration of %q+#D", olddecl); 1337 1338 return error_mark_node; 1339 } 1340 else if (!types_match) 1341 { 1342 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)) 1343 /* These are certainly not duplicate declarations; they're 1344 from different scopes. */ 1345 return NULL_TREE; 1346 1347 if (TREE_CODE (newdecl) == TEMPLATE_DECL) 1348 { 1349 /* The name of a class template may not be declared to refer to 1350 any other template, class, function, object, namespace, value, 1351 or type in the same scope. */ 1352 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL 1353 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) 1354 { 1355 error ("declaration of template %q#D", newdecl); 1356 error ("conflicts with previous declaration %q+#D", olddecl); 1357 } 1358 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL 1359 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL 1360 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))), 1361 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)))) 1362 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl), 1363 DECL_TEMPLATE_PARMS (olddecl)) 1364 /* Template functions can be disambiguated by 1365 return type. */ 1366 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)), 1367 TREE_TYPE (TREE_TYPE (olddecl)))) 1368 { 1369 error ("new declaration %q#D", newdecl); 1370 error ("ambiguates old declaration %q+#D", olddecl); 1371 } 1372 return NULL_TREE; 1373 } 1374 if (TREE_CODE (newdecl) == FUNCTION_DECL) 1375 { 1376 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl)) 1377 { 1378 error ("declaration of C function %q#D conflicts with", 1379 newdecl); 1380 error ("previous declaration %q+#D here", olddecl); 1381 } 1382 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)), 1383 TYPE_ARG_TYPES (TREE_TYPE (olddecl)))) 1384 { 1385 error ("new declaration %q#D", newdecl); 1386 error ("ambiguates old declaration %q+#D", olddecl); 1387 return error_mark_node; 1388 } 1389 else 1390 return NULL_TREE; 1391 } 1392 else 1393 { 1394 error ("conflicting declaration %q#D", newdecl); 1395 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl); 1396 return error_mark_node; 1397 } 1398 } 1399 else if (TREE_CODE (newdecl) == FUNCTION_DECL 1400 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl) 1401 && (!DECL_TEMPLATE_INFO (newdecl) 1402 || (DECL_TI_TEMPLATE (newdecl) 1403 != DECL_TI_TEMPLATE (olddecl)))) 1404 || (DECL_TEMPLATE_SPECIALIZATION (newdecl) 1405 && (!DECL_TEMPLATE_INFO (olddecl) 1406 || (DECL_TI_TEMPLATE (olddecl) 1407 != DECL_TI_TEMPLATE (newdecl)))))) 1408 /* It's OK to have a template specialization and a non-template 1409 with the same type, or to have specializations of two 1410 different templates with the same type. Note that if one is a 1411 specialization, and the other is an instantiation of the same 1412 template, that we do not exit at this point. That situation 1413 can occur if we instantiate a template class, and then 1414 specialize one of its methods. This situation is valid, but 1415 the declarations must be merged in the usual way. */ 1416 return NULL_TREE; 1417 else if (TREE_CODE (newdecl) == FUNCTION_DECL 1418 && ((DECL_TEMPLATE_INSTANTIATION (olddecl) 1419 && !DECL_USE_TEMPLATE (newdecl)) 1420 || (DECL_TEMPLATE_INSTANTIATION (newdecl) 1421 && !DECL_USE_TEMPLATE (olddecl)))) 1422 /* One of the declarations is a template instantiation, and the 1423 other is not a template at all. That's OK. */ 1424 return NULL_TREE; 1425 else if (TREE_CODE (newdecl) == NAMESPACE_DECL) 1426 { 1427 /* In [namespace.alias] we have: 1428 1429 In a declarative region, a namespace-alias-definition can be 1430 used to redefine a namespace-alias declared in that declarative 1431 region to refer only to the namespace to which it already 1432 refers. 1433 1434 Therefore, if we encounter a second alias directive for the same 1435 alias, we can just ignore the second directive. */ 1436 if (DECL_NAMESPACE_ALIAS (newdecl) 1437 && (DECL_NAMESPACE_ALIAS (newdecl) 1438 == DECL_NAMESPACE_ALIAS (olddecl))) 1439 return olddecl; 1440 /* [namespace.alias] 1441 1442 A namespace-name or namespace-alias shall not be declared as 1443 the name of any other entity in the same declarative region. 1444 A namespace-name defined at global scope shall not be 1445 declared as the name of any other entity in any global scope 1446 of the program. */ 1447 error ("declaration of namespace %qD conflicts with", newdecl); 1448 error ("previous declaration of namespace %q+D here", olddecl); 1449 return error_mark_node; 1450 } 1451 else 1452 { 1453 const char *errmsg = redeclaration_error_message (newdecl, olddecl); 1454 if (errmsg) 1455 { 1456 error (errmsg, newdecl); 1457 if (DECL_NAME (olddecl) != NULL_TREE) 1458 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ()) 1459 ? "%q+#D previously defined here" 1460 : "%q+#D previously declared here", olddecl); 1461 return error_mark_node; 1462 } 1463 else if (TREE_CODE (olddecl) == FUNCTION_DECL 1464 && DECL_INITIAL (olddecl) != NULL_TREE 1465 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE 1466 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE) 1467 { 1468 /* Prototype decl follows defn w/o prototype. */ 1469 warning (0, "prototype for %q+#D", newdecl); 1470 warning (0, "%Jfollows non-prototype definition here", olddecl); 1471 } 1472 else if ((TREE_CODE (olddecl) == FUNCTION_DECL 1473 || TREE_CODE (olddecl) == VAR_DECL) 1474 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl)) 1475 { 1476 /* [dcl.link] 1477 If two declarations of the same function or object 1478 specify different linkage-specifications ..., the program 1479 is ill-formed.... Except for functions with C++ linkage, 1480 a function declaration without a linkage specification 1481 shall not precede the first linkage specification for 1482 that function. A function can be declared without a 1483 linkage specification after an explicit linkage 1484 specification has been seen; the linkage explicitly 1485 specified in the earlier declaration is not affected by 1486 such a function declaration. 1487 1488 DR 563 raises the question why the restrictions on 1489 functions should not also apply to objects. Older 1490 versions of G++ silently ignore the linkage-specification 1491 for this example: 1492 1493 namespace N { 1494 extern int i; 1495 extern "C" int i; 1496 } 1497 1498 which is clearly wrong. Therefore, we now treat objects 1499 like functions. */ 1500 if (current_lang_depth () == 0) 1501 { 1502 /* There is no explicit linkage-specification, so we use 1503 the linkage from the previous declaration. */ 1504 if (!DECL_LANG_SPECIFIC (newdecl)) 1505 retrofit_lang_decl (newdecl); 1506 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl)); 1507 } 1508 else 1509 { 1510 error ("previous declaration of %q+#D with %qL linkage", 1511 olddecl, DECL_LANGUAGE (olddecl)); 1512 error ("conflicts with new declaration with %qL linkage", 1513 DECL_LANGUAGE (newdecl)); 1514 } 1515 } 1516 1517 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl)) 1518 ; 1519 else if (TREE_CODE (olddecl) == FUNCTION_DECL) 1520 { 1521 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl)); 1522 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)); 1523 int i = 1; 1524 1525 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE) 1526 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2); 1527 1528 for (; t1 && t1 != void_list_node; 1529 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++) 1530 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2)) 1531 { 1532 if (1 == simple_cst_equal (TREE_PURPOSE (t1), 1533 TREE_PURPOSE (t2))) 1534 { 1535 pedwarn ("default argument given for parameter %d of %q#D", 1536 i, newdecl); 1537 pedwarn ("after previous specification in %q+#D", olddecl); 1538 } 1539 else 1540 { 1541 error ("default argument given for parameter %d of %q#D", 1542 i, newdecl); 1543 error ("after previous specification in %q+#D", 1544 olddecl); 1545 } 1546 } 1547 1548 if (DECL_DECLARED_INLINE_P (newdecl) 1549 && ! DECL_DECLARED_INLINE_P (olddecl) 1550 && TREE_ADDRESSABLE (olddecl) && warn_inline) 1551 { 1552 warning (0, "%q#D was used before it was declared inline", newdecl); 1553 warning (0, "%Jprevious non-inline declaration here", olddecl); 1554 } 1555 } 1556 } 1557 1558 /* Do not merge an implicit typedef with an explicit one. In: 1559 1560 class A; 1561 ... 1562 typedef class A A __attribute__ ((foo)); 1563 1564 the attribute should apply only to the typedef. */ 1565 if (TREE_CODE (olddecl) == TYPE_DECL 1566 && (DECL_IMPLICIT_TYPEDEF_P (olddecl) 1567 || DECL_IMPLICIT_TYPEDEF_P (newdecl))) 1568 return NULL_TREE; 1569 1570 /* If new decl is `static' and an `extern' was seen previously, 1571 warn about it. */ 1572 warn_extern_redeclared_static (newdecl, olddecl); 1573 1574 /* We have committed to returning 1 at this point. */ 1575 if (TREE_CODE (newdecl) == FUNCTION_DECL) 1576 { 1577 /* Now that functions must hold information normally held 1578 by field decls, there is extra work to do so that 1579 declaration information does not get destroyed during 1580 definition. */ 1581 if (DECL_VINDEX (olddecl)) 1582 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl); 1583 if (DECL_CONTEXT (olddecl)) 1584 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl); 1585 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl); 1586 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl); 1587 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl); 1588 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl); 1589 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl); 1590 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl); 1591 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK) 1592 SET_OVERLOADED_OPERATOR_CODE 1593 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl)); 1594 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE; 1595 1596 /* Optionally warn about more than one declaration for the same 1597 name, but don't warn about a function declaration followed by a 1598 definition. */ 1599 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl) 1600 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE) 1601 /* Don't warn about extern decl followed by definition. */ 1602 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)) 1603 /* Don't warn about friends, let add_friend take care of it. */ 1604 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl))) 1605 { 1606 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl); 1607 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl); 1608 } 1609 } 1610 1611 /* Deal with C++: must preserve virtual function table size. */ 1612 if (TREE_CODE (olddecl) == TYPE_DECL) 1613 { 1614 tree newtype = TREE_TYPE (newdecl); 1615 tree oldtype = TREE_TYPE (olddecl); 1616 1617 if (newtype != error_mark_node && oldtype != error_mark_node 1618 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype)) 1619 CLASSTYPE_FRIEND_CLASSES (newtype) 1620 = CLASSTYPE_FRIEND_CLASSES (oldtype); 1621 1622 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl); 1623 } 1624 1625 /* Copy all the DECL_... slots specified in the new decl 1626 except for any that we copy here from the old type. */ 1627 DECL_ATTRIBUTES (newdecl) 1628 = (*targetm.merge_decl_attributes) (olddecl, newdecl); 1629 1630 if (TREE_CODE (newdecl) == TEMPLATE_DECL) 1631 { 1632 tree old_result; 1633 tree new_result; 1634 old_result = DECL_TEMPLATE_RESULT (olddecl); 1635 new_result = DECL_TEMPLATE_RESULT (newdecl); 1636 TREE_TYPE (olddecl) = TREE_TYPE (old_result); 1637 DECL_TEMPLATE_SPECIALIZATIONS (olddecl) 1638 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl), 1639 DECL_TEMPLATE_SPECIALIZATIONS (newdecl)); 1640 1641 if (DECL_FUNCTION_TEMPLATE_P (newdecl)) 1642 { 1643 DECL_INLINE (old_result) 1644 |= DECL_INLINE (new_result); 1645 DECL_DECLARED_INLINE_P (old_result) 1646 |= DECL_DECLARED_INLINE_P (new_result); 1647 check_redeclaration_exception_specification (newdecl, olddecl); 1648 } 1649 1650 /* If the new declaration is a definition, update the file and 1651 line information on the declaration, and also make 1652 the old declaration the same definition. */ 1653 if (DECL_INITIAL (old_result) == NULL_TREE 1654 && DECL_INITIAL (new_result) != NULL_TREE) 1655 { 1656 DECL_SOURCE_LOCATION (olddecl) 1657 = DECL_SOURCE_LOCATION (old_result) 1658 = DECL_SOURCE_LOCATION (newdecl); 1659 DECL_INITIAL (old_result) = DECL_INITIAL (new_result); 1660 if (DECL_FUNCTION_TEMPLATE_P (newdecl)) 1661 DECL_ARGUMENTS (old_result) 1662 = DECL_ARGUMENTS (new_result); 1663 } 1664 1665 return olddecl; 1666 } 1667 1668 if (types_match) 1669 { 1670 /* Automatically handles default parameters. */ 1671 tree oldtype = TREE_TYPE (olddecl); 1672 tree newtype; 1673 1674 /* Merge the data types specified in the two decls. */ 1675 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl)); 1676 1677 /* If merge_types produces a non-typedef type, just use the old type. */ 1678 if (TREE_CODE (newdecl) == TYPE_DECL 1679 && newtype == DECL_ORIGINAL_TYPE (newdecl)) 1680 newtype = oldtype; 1681 1682 if (TREE_CODE (newdecl) == VAR_DECL) 1683 { 1684 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl); 1685 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl); 1686 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl) 1687 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl); 1688 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl) 1689 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl); 1690 1691 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */ 1692 if (DECL_LANG_SPECIFIC (olddecl) 1693 && CP_DECL_THREADPRIVATE_P (olddecl)) 1694 { 1695 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */ 1696 if (!DECL_LANG_SPECIFIC (newdecl)) 1697 retrofit_lang_decl (newdecl); 1698 1699 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl); 1700 CP_DECL_THREADPRIVATE_P (newdecl) = 1; 1701 } 1702 } 1703 1704 /* Do this after calling `merge_types' so that default 1705 parameters don't confuse us. */ 1706 else if (TREE_CODE (newdecl) == FUNCTION_DECL) 1707 check_redeclaration_exception_specification (newdecl, olddecl); 1708 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype; 1709 1710 if (TREE_CODE (newdecl) == FUNCTION_DECL) 1711 check_default_args (newdecl); 1712 1713 /* Lay the type out, unless already done. */ 1714 if (! same_type_p (newtype, oldtype) 1715 && TREE_TYPE (newdecl) != error_mark_node 1716 && !(processing_template_decl && uses_template_parms (newdecl))) 1717 layout_type (TREE_TYPE (newdecl)); 1718 1719 if ((TREE_CODE (newdecl) == VAR_DECL 1720 || TREE_CODE (newdecl) == PARM_DECL 1721 || TREE_CODE (newdecl) == RESULT_DECL 1722 || TREE_CODE (newdecl) == FIELD_DECL 1723 || TREE_CODE (newdecl) == TYPE_DECL) 1724 && !(processing_template_decl && uses_template_parms (newdecl))) 1725 layout_decl (newdecl, 0); 1726 1727 /* Merge the type qualifiers. */ 1728 if (TREE_READONLY (newdecl)) 1729 TREE_READONLY (olddecl) = 1; 1730 if (TREE_THIS_VOLATILE (newdecl)) 1731 TREE_THIS_VOLATILE (olddecl) = 1; 1732 if (TREE_NOTHROW (newdecl)) 1733 TREE_NOTHROW (olddecl) = 1; 1734 1735 /* Merge deprecatedness. */ 1736 if (TREE_DEPRECATED (newdecl)) 1737 TREE_DEPRECATED (olddecl) = 1; 1738 1739 /* Merge the initialization information. */ 1740 if (DECL_INITIAL (newdecl) == NULL_TREE 1741 && DECL_INITIAL (olddecl) != NULL_TREE) 1742 { 1743 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl); 1744 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl); 1745 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl) 1746 && DECL_LANG_SPECIFIC (newdecl) 1747 && DECL_LANG_SPECIFIC (olddecl)) 1748 { 1749 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl); 1750 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl); 1751 } 1752 } 1753 1754 /* Merge the section attribute. 1755 We want to issue an error if the sections conflict but that must be 1756 done later in decl_attributes since we are called before attributes 1757 are assigned. */ 1758 if (DECL_SECTION_NAME (newdecl) == NULL_TREE) 1759 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl); 1760 1761 if (TREE_CODE (newdecl) == FUNCTION_DECL) 1762 { 1763 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl) 1764 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl); 1765 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl); 1766 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl); 1767 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl); 1768 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl); 1769 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl); 1770 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl); 1771 /* Keep the old RTL. */ 1772 COPY_DECL_RTL (olddecl, newdecl); 1773 } 1774 else if (TREE_CODE (newdecl) == VAR_DECL 1775 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl))) 1776 { 1777 /* Keep the old RTL. We cannot keep the old RTL if the old 1778 declaration was for an incomplete object and the new 1779 declaration is not since many attributes of the RTL will 1780 change. */ 1781 COPY_DECL_RTL (olddecl, newdecl); 1782 } 1783 } 1784 /* If cannot merge, then use the new type and qualifiers, 1785 and don't preserve the old rtl. */ 1786 else 1787 { 1788 /* Clean out any memory we had of the old declaration. */ 1789 tree oldstatic = value_member (olddecl, static_aggregates); 1790 if (oldstatic) 1791 TREE_VALUE (oldstatic) = error_mark_node; 1792 1793 TREE_TYPE (olddecl) = TREE_TYPE (newdecl); 1794 TREE_READONLY (olddecl) = TREE_READONLY (newdecl); 1795 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl); 1796 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl); 1797 } 1798 1799 /* Merge the storage class information. */ 1800 merge_weak (newdecl, olddecl); 1801 1802 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl); 1803 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl); 1804 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl); 1805 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl); 1806 if (! DECL_EXTERNAL (olddecl)) 1807 DECL_EXTERNAL (newdecl) = 0; 1808 1809 new_template = NULL_TREE; 1810 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl)) 1811 { 1812 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl); 1813 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl); 1814 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl); 1815 DECL_TEMPLATE_INSTANTIATED (newdecl) 1816 |= DECL_TEMPLATE_INSTANTIATED (olddecl); 1817 1818 /* If the OLDDECL is an instantiation and/or specialization, 1819 then the NEWDECL must be too. But, it may not yet be marked 1820 as such if the caller has created NEWDECL, but has not yet 1821 figured out that it is a redeclaration. */ 1822 if (!DECL_USE_TEMPLATE (newdecl)) 1823 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl); 1824 1825 /* Don't really know how much of the language-specific 1826 values we should copy from old to new. */ 1827 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl); 1828 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 = 1829 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2; 1830 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl); 1831 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl); 1832 if (DECL_TEMPLATE_INFO (newdecl)) 1833 new_template = DECL_TI_TEMPLATE (newdecl); 1834 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl); 1835 DECL_INITIALIZED_IN_CLASS_P (newdecl) 1836 |= DECL_INITIALIZED_IN_CLASS_P (olddecl); 1837 olddecl_friend = DECL_FRIEND_P (olddecl); 1838 hidden_friend = (DECL_ANTICIPATED (olddecl) 1839 && DECL_HIDDEN_FRIEND_P (olddecl) 1840 && newdecl_is_friend); 1841 1842 /* Only functions have DECL_BEFRIENDING_CLASSES. */ 1843 if (TREE_CODE (newdecl) == FUNCTION_DECL 1844 || DECL_FUNCTION_TEMPLATE_P (newdecl)) 1845 { 1846 DECL_BEFRIENDING_CLASSES (newdecl) 1847 = chainon (DECL_BEFRIENDING_CLASSES (newdecl), 1848 DECL_BEFRIENDING_CLASSES (olddecl)); 1849 /* DECL_THUNKS is only valid for virtual functions, 1850 otherwise it is a DECL_FRIEND_CONTEXT. */ 1851 if (DECL_VIRTUAL_P (newdecl)) 1852 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl); 1853 } 1854 } 1855 1856 if (TREE_CODE (newdecl) == FUNCTION_DECL) 1857 { 1858 if (DECL_TEMPLATE_INSTANTIATION (olddecl) 1859 && !DECL_TEMPLATE_INSTANTIATION (newdecl)) 1860 { 1861 /* If newdecl is not a specialization, then it is not a 1862 template-related function at all. And that means that we 1863 should have exited above, returning 0. */ 1864 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl)); 1865 1866 if (TREE_USED (olddecl)) 1867 /* From [temp.expl.spec]: 1868 1869 If a template, a member template or the member of a class 1870 template is explicitly specialized then that 1871 specialization shall be declared before the first use of 1872 that specialization that would cause an implicit 1873 instantiation to take place, in every translation unit in 1874 which such a use occurs. */ 1875 error ("explicit specialization of %qD after first use", 1876 olddecl); 1877 1878 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl); 1879 1880 /* Don't propagate visibility from the template to the 1881 specialization here. We'll do that in determine_visibility if 1882 appropriate. */ 1883 DECL_VISIBILITY_SPECIFIED (olddecl) = 0; 1884 1885 /* [temp.expl.spec/14] We don't inline explicit specialization 1886 just because the primary template says so. */ 1887 } 1888 else 1889 { 1890 if (DECL_PENDING_INLINE_INFO (newdecl) == 0) 1891 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl); 1892 1893 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl); 1894 1895 /* If either decl says `inline', this fn is inline, unless 1896 its definition was passed already. */ 1897 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE) 1898 DECL_INLINE (olddecl) = 1; 1899 DECL_INLINE (newdecl) = DECL_INLINE (olddecl); 1900 1901 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl) 1902 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)); 1903 } 1904 1905 /* Preserve abstractness on cloned [cd]tors. */ 1906 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl); 1907 1908 if (! types_match) 1909 { 1910 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl)); 1911 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl); 1912 COPY_DECL_RTL (newdecl, olddecl); 1913 } 1914 if (! types_match || new_defines_function) 1915 { 1916 /* These need to be copied so that the names are available. 1917 Note that if the types do match, we'll preserve inline 1918 info and other bits, but if not, we won't. */ 1919 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl); 1920 DECL_RESULT (olddecl) = DECL_RESULT (newdecl); 1921 } 1922 if (new_defines_function) 1923 /* If defining a function declared with other language 1924 linkage, use the previously declared language linkage. */ 1925 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl)); 1926 else if (types_match) 1927 { 1928 /* If redeclaring a builtin function, and not a definition, 1929 it stays built in. */ 1930 if (DECL_BUILT_IN (olddecl)) 1931 { 1932 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl); 1933 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl); 1934 /* If we're keeping the built-in definition, keep the rtl, 1935 regardless of declaration matches. */ 1936 COPY_DECL_RTL (olddecl, newdecl); 1937 } 1938 1939 DECL_RESULT (newdecl) = DECL_RESULT (olddecl); 1940 /* Don't clear out the arguments if we're redefining a function. */ 1941 if (DECL_ARGUMENTS (olddecl)) 1942 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl); 1943 } 1944 } 1945 else if (TREE_CODE (newdecl) == NAMESPACE_DECL) 1946 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl); 1947 1948 /* Now preserve various other info from the definition. */ 1949 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl); 1950 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl); 1951 DECL_COMMON (newdecl) = DECL_COMMON (olddecl); 1952 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl); 1953 1954 /* Warn about conflicting visibility specifications. */ 1955 if (DECL_VISIBILITY_SPECIFIED (olddecl) 1956 && DECL_VISIBILITY_SPECIFIED (newdecl) 1957 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl)) 1958 { 1959 warning (OPT_Wattributes, "%q+D: visibility attribute ignored " 1960 "because it", newdecl); 1961 warning (OPT_Wattributes, "%Jconflicts with previous " 1962 "declaration here", olddecl); 1963 } 1964 /* Choose the declaration which specified visibility. */ 1965 if (DECL_VISIBILITY_SPECIFIED (olddecl)) 1966 { 1967 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl); 1968 DECL_VISIBILITY_SPECIFIED (newdecl) = 1; 1969 } 1970 /* Init priority used to be merged from newdecl to olddecl by the memcpy, 1971 so keep this behavior. */ 1972 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl)) 1973 { 1974 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl)); 1975 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1; 1976 } 1977 1978 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced 1979 with that from NEWDECL below. */ 1980 if (DECL_LANG_SPECIFIC (olddecl)) 1981 { 1982 gcc_assert (DECL_LANG_SPECIFIC (olddecl) 1983 != DECL_LANG_SPECIFIC (newdecl)); 1984 ggc_free (DECL_LANG_SPECIFIC (olddecl)); 1985 } 1986 1987 if (TREE_CODE (newdecl) == FUNCTION_DECL) 1988 { 1989 int function_size; 1990 1991 function_size = sizeof (struct tree_decl_common); 1992 1993 memcpy ((char *) olddecl + sizeof (struct tree_common), 1994 (char *) newdecl + sizeof (struct tree_common), 1995 function_size - sizeof (struct tree_common)); 1996 1997 memcpy ((char *) olddecl + sizeof (struct tree_decl_common), 1998 (char *) newdecl + sizeof (struct tree_decl_common), 1999 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common)); 2000 if (new_template) 2001 /* If newdecl is a template instantiation, it is possible that 2002 the following sequence of events has occurred: 2003 2004 o A friend function was declared in a class template. The 2005 class template was instantiated. 2006 2007 o The instantiation of the friend declaration was 2008 recorded on the instantiation list, and is newdecl. 2009 2010 o Later, however, instantiate_class_template called pushdecl 2011 on the newdecl to perform name injection. But, pushdecl in 2012 turn called duplicate_decls when it discovered that another 2013 declaration of a global function with the same name already 2014 existed. 2015 2016 o Here, in duplicate_decls, we decided to clobber newdecl. 2017 2018 If we're going to do that, we'd better make sure that 2019 olddecl, and not newdecl, is on the list of 2020 instantiations so that if we try to do the instantiation 2021 again we won't get the clobbered declaration. */ 2022 reregister_specialization (newdecl, 2023 new_template, 2024 olddecl); 2025 } 2026 else 2027 { 2028 size_t size = tree_code_size (TREE_CODE (olddecl)); 2029 memcpy ((char *) olddecl + sizeof (struct tree_common), 2030 (char *) newdecl + sizeof (struct tree_common), 2031 sizeof (struct tree_decl_common) - sizeof (struct tree_common)); 2032 switch (TREE_CODE (olddecl)) 2033 { 2034 case LABEL_DECL: 2035 case VAR_DECL: 2036 case RESULT_DECL: 2037 case PARM_DECL: 2038 case FIELD_DECL: 2039 case TYPE_DECL: 2040 case CONST_DECL: 2041 { 2042 memcpy ((char *) olddecl + sizeof (struct tree_decl_common), 2043 (char *) newdecl + sizeof (struct tree_decl_common), 2044 size - sizeof (struct tree_decl_common) 2045 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *)); 2046 } 2047 break; 2048 default: 2049 memcpy ((char *) olddecl + sizeof (struct tree_decl_common), 2050 (char *) newdecl + sizeof (struct tree_decl_common), 2051 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common) 2052 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *)); 2053 break; 2054 } 2055 } 2056 DECL_UID (olddecl) = olddecl_uid; 2057 if (olddecl_friend) 2058 DECL_FRIEND_P (olddecl) = 1; 2059 if (hidden_friend) 2060 { 2061 DECL_ANTICIPATED (olddecl) = 1; 2062 DECL_HIDDEN_FRIEND_P (olddecl) = 1; 2063 } 2064 2065 /* NEWDECL contains the merged attribute lists. 2066 Update OLDDECL to be the same. */ 2067 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl); 2068 2069 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl 2070 so that encode_section_info has a chance to look at the new decl 2071 flags and attributes. */ 2072 if (DECL_RTL_SET_P (olddecl) 2073 && (TREE_CODE (olddecl) == FUNCTION_DECL 2074 || (TREE_CODE (olddecl) == VAR_DECL 2075 && TREE_STATIC (olddecl)))) 2076 make_decl_rtl (olddecl); 2077 2078 /* The NEWDECL will no longer be needed. Because every out-of-class 2079 declaration of a member results in a call to duplicate_decls, 2080 freeing these nodes represents in a significant savings. */ 2081 ggc_free (newdecl); 2082 2083 return olddecl; 2084} 2085 2086/* Return zero if the declaration NEWDECL is valid 2087 when the declaration OLDDECL (assumed to be for the same name) 2088 has already been seen. 2089 Otherwise return an error message format string with a %s 2090 where the identifier should go. */ 2091 2092static const char * 2093redeclaration_error_message (tree newdecl, tree olddecl) 2094{ 2095 if (TREE_CODE (newdecl) == TYPE_DECL) 2096 { 2097 /* Because C++ can put things into name space for free, 2098 constructs like "typedef struct foo { ... } foo" 2099 would look like an erroneous redeclaration. */ 2100 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl))) 2101 return NULL; 2102 else 2103 return "redefinition of %q#D"; 2104 } 2105 else if (TREE_CODE (newdecl) == FUNCTION_DECL) 2106 { 2107 /* If this is a pure function, its olddecl will actually be 2108 the original initialization to `0' (which we force to call 2109 abort()). Don't complain about redefinition in this case. */ 2110 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl) 2111 && DECL_INITIAL (olddecl) == NULL_TREE) 2112 return NULL; 2113 2114 /* If both functions come from different namespaces, this is not 2115 a redeclaration - this is a conflict with a used function. */ 2116 if (DECL_NAMESPACE_SCOPE_P (olddecl) 2117 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl) 2118 && ! decls_match (olddecl, newdecl)) 2119 return "%qD conflicts with used function"; 2120 2121 /* We'll complain about linkage mismatches in 2122 warn_extern_redeclared_static. */ 2123 2124 /* Defining the same name twice is no good. */ 2125 if (DECL_INITIAL (olddecl) != NULL_TREE 2126 && DECL_INITIAL (newdecl) != NULL_TREE) 2127 { 2128 if (DECL_NAME (olddecl) == NULL_TREE) 2129 return "%q#D not declared in class"; 2130 else 2131 return "redefinition of %q#D"; 2132 } 2133 return NULL; 2134 } 2135 else if (TREE_CODE (newdecl) == TEMPLATE_DECL) 2136 { 2137 tree nt, ot; 2138 2139 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) 2140 { 2141 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl)) 2142 && COMPLETE_TYPE_P (TREE_TYPE (olddecl))) 2143 return "redefinition of %q#D"; 2144 return NULL; 2145 } 2146 2147 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL 2148 || (DECL_TEMPLATE_RESULT (newdecl) 2149 == DECL_TEMPLATE_RESULT (olddecl))) 2150 return NULL; 2151 2152 nt = DECL_TEMPLATE_RESULT (newdecl); 2153 if (DECL_TEMPLATE_INFO (nt)) 2154 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt)); 2155 ot = DECL_TEMPLATE_RESULT (olddecl); 2156 if (DECL_TEMPLATE_INFO (ot)) 2157 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot)); 2158 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)) 2159 return "redefinition of %q#D"; 2160 2161 return NULL; 2162 } 2163 else if (TREE_CODE (newdecl) == VAR_DECL 2164 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl) 2165 && (! DECL_LANG_SPECIFIC (olddecl) 2166 || ! CP_DECL_THREADPRIVATE_P (olddecl) 2167 || DECL_THREAD_LOCAL_P (newdecl))) 2168 { 2169 /* Only variables can be thread-local, and all declarations must 2170 agree on this property. */ 2171 if (DECL_THREAD_LOCAL_P (newdecl)) 2172 return "thread-local declaration of %q#D follows " 2173 "non-thread-local declaration"; 2174 else 2175 return "non-thread-local declaration of %q#D follows " 2176 "thread-local declaration"; 2177 } 2178 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl)) 2179 { 2180 /* The objects have been declared at namespace scope. If either 2181 is a member of an anonymous union, then this is an invalid 2182 redeclaration. For example: 2183 2184 int i; 2185 union { int i; }; 2186 2187 is invalid. */ 2188 if (DECL_ANON_UNION_VAR_P (newdecl) 2189 || DECL_ANON_UNION_VAR_P (olddecl)) 2190 return "redeclaration of %q#D"; 2191 /* If at least one declaration is a reference, there is no 2192 conflict. For example: 2193 2194 int i = 3; 2195 extern int i; 2196 2197 is valid. */ 2198 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl)) 2199 return NULL; 2200 /* Reject two definitions. */ 2201 return "redefinition of %q#D"; 2202 } 2203 else 2204 { 2205 /* Objects declared with block scope: */ 2206 /* Reject two definitions, and reject a definition 2207 together with an external reference. */ 2208 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))) 2209 return "redeclaration of %q#D"; 2210 return NULL; 2211 } 2212} 2213 2214/* Hash and equality functions for the named_label table. */ 2215 2216static hashval_t 2217named_label_entry_hash (const void *data) 2218{ 2219 const struct named_label_entry *ent = (const struct named_label_entry *) data; 2220 return DECL_UID (ent->label_decl); 2221} 2222 2223static int 2224named_label_entry_eq (const void *a, const void *b) 2225{ 2226 const struct named_label_entry *ent_a = (const struct named_label_entry *) a; 2227 const struct named_label_entry *ent_b = (const struct named_label_entry *) b; 2228 return ent_a->label_decl == ent_b->label_decl; 2229} 2230 2231/* Create a new label, named ID. */ 2232 2233static tree 2234make_label_decl (tree id, int local_p) 2235{ 2236 struct named_label_entry *ent; 2237 void **slot; 2238 tree decl; 2239 2240 decl = build_decl (LABEL_DECL, id, void_type_node); 2241 2242 DECL_CONTEXT (decl) = current_function_decl; 2243 DECL_MODE (decl) = VOIDmode; 2244 C_DECLARED_LABEL_FLAG (decl) = local_p; 2245 2246 /* Say where one reference is to the label, for the sake of the 2247 error if it is not defined. */ 2248 DECL_SOURCE_LOCATION (decl) = input_location; 2249 2250 /* Record the fact that this identifier is bound to this label. */ 2251 SET_IDENTIFIER_LABEL_VALUE (id, decl); 2252 2253 /* Create the label htab for the function on demand. */ 2254 if (!named_labels) 2255 named_labels = htab_create_ggc (13, named_label_entry_hash, 2256 named_label_entry_eq, NULL); 2257 2258 /* Record this label on the list of labels used in this function. 2259 We do this before calling make_label_decl so that we get the 2260 IDENTIFIER_LABEL_VALUE before the new label is declared. */ 2261 ent = GGC_CNEW (struct named_label_entry); 2262 ent->label_decl = decl; 2263 2264 slot = htab_find_slot (named_labels, ent, INSERT); 2265 gcc_assert (*slot == NULL); 2266 *slot = ent; 2267 2268 return decl; 2269} 2270 2271/* Look for a label named ID in the current function. If one cannot 2272 be found, create one. (We keep track of used, but undefined, 2273 labels, and complain about them at the end of a function.) */ 2274 2275tree 2276lookup_label (tree id) 2277{ 2278 tree decl; 2279 2280 timevar_push (TV_NAME_LOOKUP); 2281 /* You can't use labels at global scope. */ 2282 if (current_function_decl == NULL_TREE) 2283 { 2284 error ("label %qE referenced outside of any function", id); 2285 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE); 2286 } 2287 2288 /* See if we've already got this label. */ 2289 decl = IDENTIFIER_LABEL_VALUE (id); 2290 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl) 2291 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); 2292 2293 decl = make_label_decl (id, /*local_p=*/0); 2294 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); 2295} 2296 2297/* Declare a local label named ID. */ 2298 2299tree 2300declare_local_label (tree id) 2301{ 2302 tree decl, shadow; 2303 2304 /* Add a new entry to the SHADOWED_LABELS list so that when we leave 2305 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */ 2306 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE, 2307 current_binding_level->shadowed_labels); 2308 current_binding_level->shadowed_labels = shadow; 2309 2310 decl = make_label_decl (id, /*local_p=*/1); 2311 TREE_VALUE (shadow) = decl; 2312 2313 return decl; 2314} 2315 2316/* Returns nonzero if it is ill-formed to jump past the declaration of 2317 DECL. Returns 2 if it's also a real problem. */ 2318 2319static int 2320decl_jump_unsafe (tree decl) 2321{ 2322 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl) 2323 || TREE_TYPE (decl) == error_mark_node) 2324 return 0; 2325 2326 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)) 2327 || DECL_NONTRIVIALLY_INITIALIZED_P (decl)) 2328 return 2; 2329 2330 if (pod_type_p (TREE_TYPE (decl))) 2331 return 0; 2332 2333 /* The POD stuff is just pedantry; why should it matter if the class 2334 contains a field of pointer to member type? */ 2335 return 1; 2336} 2337 2338/* A subroutine of check_previous_goto_1 to identify a branch to the user. */ 2339 2340static void 2341identify_goto (tree decl, const location_t *locus) 2342{ 2343 if (decl) 2344 pedwarn ("jump to label %qD", decl); 2345 else 2346 pedwarn ("jump to case label"); 2347 if (locus) 2348 pedwarn ("%H from here", locus); 2349} 2350 2351/* Check that a single previously seen jump to a newly defined label 2352 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for 2353 the jump context; NAMES are the names in scope in LEVEL at the jump 2354 context; LOCUS is the source position of the jump or 0. Returns 2355 true if all is well. */ 2356 2357static bool 2358check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names, 2359 bool exited_omp, const location_t *locus) 2360{ 2361 struct cp_binding_level *b; 2362 bool identified = false, saw_eh = false, saw_omp = false; 2363 2364 if (exited_omp) 2365 { 2366 identify_goto (decl, locus); 2367 error (" exits OpenMP structured block"); 2368 identified = saw_omp = true; 2369 } 2370 2371 for (b = current_binding_level; b ; b = b->level_chain) 2372 { 2373 tree new_decls, old_decls = (b == level ? names : NULL_TREE); 2374 2375 for (new_decls = b->names; new_decls != old_decls; 2376 new_decls = TREE_CHAIN (new_decls)) 2377 { 2378 int problem = decl_jump_unsafe (new_decls); 2379 if (! problem) 2380 continue; 2381 2382 if (!identified) 2383 { 2384 identify_goto (decl, locus); 2385 identified = true; 2386 } 2387 if (problem > 1) 2388 error (" crosses initialization of %q+#D", new_decls); 2389 else 2390 pedwarn (" enters scope of non-POD %q+#D", new_decls); 2391 } 2392 2393 if (b == level) 2394 break; 2395 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh) 2396 { 2397 if (!identified) 2398 { 2399 identify_goto (decl, locus); 2400 identified = true; 2401 } 2402 if (b->kind == sk_try) 2403 error (" enters try block"); 2404 else 2405 error (" enters catch block"); 2406 saw_eh = true; 2407 } 2408 if (b->kind == sk_omp && !saw_omp) 2409 { 2410 if (!identified) 2411 { 2412 identify_goto (decl, locus); 2413 identified = true; 2414 } 2415 error (" enters OpenMP structured block"); 2416 saw_omp = true; 2417 } 2418 } 2419 2420 return !identified; 2421} 2422 2423static void 2424check_previous_goto (tree decl, struct named_label_use_entry *use) 2425{ 2426 check_previous_goto_1 (decl, use->binding_level, 2427 use->names_in_scope, use->in_omp_scope, 2428 &use->o_goto_locus); 2429} 2430 2431static bool 2432check_switch_goto (struct cp_binding_level* level) 2433{ 2434 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL); 2435} 2436 2437/* Check that a new jump to a label DECL is OK. Called by 2438 finish_goto_stmt. */ 2439 2440void 2441check_goto (tree decl) 2442{ 2443 struct named_label_entry *ent, dummy; 2444 bool saw_catch = false, identified = false; 2445 tree bad; 2446 2447 /* We can't know where a computed goto is jumping. 2448 So we assume that it's OK. */ 2449 if (TREE_CODE (decl) != LABEL_DECL) 2450 return; 2451 2452 /* We didn't record any information about this label when we created it, 2453 and there's not much point since it's trivial to analyze as a return. */ 2454 if (decl == cdtor_label) 2455 return; 2456 2457 dummy.label_decl = decl; 2458 ent = (struct named_label_entry *) htab_find (named_labels, &dummy); 2459 gcc_assert (ent != NULL); 2460 2461 /* If the label hasn't been defined yet, defer checking. */ 2462 if (! DECL_INITIAL (decl)) 2463 { 2464 struct named_label_use_entry *new_use; 2465 2466 /* Don't bother creating another use if the last goto had the 2467 same data, and will therefore create the same set of errors. */ 2468 if (ent->uses 2469 && ent->uses->names_in_scope == current_binding_level->names) 2470 return; 2471 2472 new_use = GGC_NEW (struct named_label_use_entry); 2473 new_use->binding_level = current_binding_level; 2474 new_use->names_in_scope = current_binding_level->names; 2475 new_use->o_goto_locus = input_location; 2476 new_use->in_omp_scope = false; 2477 2478 new_use->next = ent->uses; 2479 ent->uses = new_use; 2480 return; 2481 } 2482 2483 if (ent->in_try_scope || ent->in_catch_scope 2484 || ent->in_omp_scope || ent->bad_decls) 2485 { 2486 pedwarn ("jump to label %q+D", decl); 2487 pedwarn (" from here"); 2488 identified = true; 2489 } 2490 2491 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad)) 2492 { 2493 tree b = TREE_VALUE (bad); 2494 int u = decl_jump_unsafe (b); 2495 2496 if (u > 1 && DECL_ARTIFICIAL (b)) 2497 { 2498 /* Can't skip init of __exception_info. */ 2499 error ("%J enters catch block", b); 2500 saw_catch = true; 2501 } 2502 else if (u > 1) 2503 error (" skips initialization of %q+#D", b); 2504 else 2505 pedwarn (" enters scope of non-POD %q+#D", b); 2506 } 2507 2508 if (ent->in_try_scope) 2509 error (" enters try block"); 2510 else if (ent->in_catch_scope && !saw_catch) 2511 error (" enters catch block"); 2512 2513 if (ent->in_omp_scope) 2514 error (" enters OpenMP structured block"); 2515 else if (flag_openmp) 2516 { 2517 struct cp_binding_level *b; 2518 for (b = current_binding_level; b ; b = b->level_chain) 2519 { 2520 if (b == ent->binding_level) 2521 break; 2522 if (b->kind == sk_omp) 2523 { 2524 if (!identified) 2525 { 2526 pedwarn ("jump to label %q+D", decl); 2527 pedwarn (" from here"); 2528 identified = true; 2529 } 2530 error (" exits OpenMP structured block"); 2531 break; 2532 } 2533 } 2534 } 2535} 2536 2537/* Check that a return is ok wrt OpenMP structured blocks. 2538 Called by finish_return_stmt. Returns true if all is well. */ 2539 2540bool 2541check_omp_return (void) 2542{ 2543 struct cp_binding_level *b; 2544 for (b = current_binding_level; b ; b = b->level_chain) 2545 if (b->kind == sk_omp) 2546 { 2547 error ("invalid exit from OpenMP structured block"); 2548 return false; 2549 } 2550 return true; 2551} 2552 2553/* Define a label, specifying the location in the source file. 2554 Return the LABEL_DECL node for the label. */ 2555 2556tree 2557define_label (location_t location, tree name) 2558{ 2559 struct named_label_entry *ent, dummy; 2560 struct cp_binding_level *p; 2561 tree decl; 2562 2563 timevar_push (TV_NAME_LOOKUP); 2564 2565 decl = lookup_label (name); 2566 2567 dummy.label_decl = decl; 2568 ent = (struct named_label_entry *) htab_find (named_labels, &dummy); 2569 gcc_assert (ent != NULL); 2570 2571 /* After labels, make any new cleanups in the function go into their 2572 own new (temporary) binding contour. */ 2573 for (p = current_binding_level; 2574 p->kind != sk_function_parms; 2575 p = p->level_chain) 2576 p->more_cleanups_ok = 0; 2577 2578 if (name == get_identifier ("wchar_t")) 2579 pedwarn ("label named wchar_t"); 2580 2581 if (DECL_INITIAL (decl) != NULL_TREE) 2582 { 2583 error ("duplicate label %qD", decl); 2584 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 2585 } 2586 else 2587 { 2588 struct named_label_use_entry *use; 2589 2590 /* Mark label as having been defined. */ 2591 DECL_INITIAL (decl) = error_mark_node; 2592 /* Say where in the source. */ 2593 DECL_SOURCE_LOCATION (decl) = location; 2594 2595 ent->binding_level = current_binding_level; 2596 ent->names_in_scope = current_binding_level->names; 2597 2598 for (use = ent->uses; use ; use = use->next) 2599 check_previous_goto (decl, use); 2600 ent->uses = NULL; 2601 } 2602 2603 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); 2604} 2605 2606struct cp_switch 2607{ 2608 struct cp_binding_level *level; 2609 struct cp_switch *next; 2610 /* The SWITCH_STMT being built. */ 2611 tree switch_stmt; 2612 /* A splay-tree mapping the low element of a case range to the high 2613 element, or NULL_TREE if there is no high element. Used to 2614 determine whether or not a new case label duplicates an old case 2615 label. We need a tree, rather than simply a hash table, because 2616 of the GNU case range extension. */ 2617 splay_tree cases; 2618}; 2619 2620/* A stack of the currently active switch statements. The innermost 2621 switch statement is on the top of the stack. There is no need to 2622 mark the stack for garbage collection because it is only active 2623 during the processing of the body of a function, and we never 2624 collect at that point. */ 2625 2626static struct cp_switch *switch_stack; 2627 2628/* Called right after a switch-statement condition is parsed. 2629 SWITCH_STMT is the switch statement being parsed. */ 2630 2631void 2632push_switch (tree switch_stmt) 2633{ 2634 struct cp_switch *p = XNEW (struct cp_switch); 2635 p->level = current_binding_level; 2636 p->next = switch_stack; 2637 p->switch_stmt = switch_stmt; 2638 p->cases = splay_tree_new (case_compare, NULL, NULL); 2639 switch_stack = p; 2640} 2641 2642void 2643pop_switch (void) 2644{ 2645 struct cp_switch *cs = switch_stack; 2646 location_t switch_location; 2647 2648 /* Emit warnings as needed. */ 2649 if (EXPR_HAS_LOCATION (cs->switch_stmt)) 2650 switch_location = EXPR_LOCATION (cs->switch_stmt); 2651 else 2652 switch_location = input_location; 2653 if (!processing_template_decl) 2654 c_do_switch_warnings (cs->cases, switch_location, 2655 SWITCH_STMT_TYPE (cs->switch_stmt), 2656 SWITCH_STMT_COND (cs->switch_stmt)); 2657 2658 splay_tree_delete (cs->cases); 2659 switch_stack = switch_stack->next; 2660 free (cs); 2661} 2662 2663/* Note that we've seen a definition of a case label, and complain if this 2664 is a bad place for one. */ 2665 2666tree 2667finish_case_label (tree low_value, tree high_value) 2668{ 2669 tree cond, r; 2670 struct cp_binding_level *p; 2671 2672 if (processing_template_decl) 2673 { 2674 tree label; 2675 2676 /* For templates, just add the case label; we'll do semantic 2677 analysis at instantiation-time. */ 2678 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); 2679 return add_stmt (build_case_label (low_value, high_value, label)); 2680 } 2681 2682 /* Find the condition on which this switch statement depends. */ 2683 cond = SWITCH_STMT_COND (switch_stack->switch_stmt); 2684 if (cond && TREE_CODE (cond) == TREE_LIST) 2685 cond = TREE_VALUE (cond); 2686 2687 if (!check_switch_goto (switch_stack->level)) 2688 return error_mark_node; 2689 2690 r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond), 2691 low_value, high_value); 2692 2693 /* After labels, make any new cleanups in the function go into their 2694 own new (temporary) binding contour. */ 2695 for (p = current_binding_level; 2696 p->kind != sk_function_parms; 2697 p = p->level_chain) 2698 p->more_cleanups_ok = 0; 2699 2700 return r; 2701} 2702 2703/* Hash a TYPENAME_TYPE. K is really of type `tree'. */ 2704 2705static hashval_t 2706typename_hash (const void* k) 2707{ 2708 hashval_t hash; 2709 tree t = (tree) k; 2710 2711 hash = (htab_hash_pointer (TYPE_CONTEXT (t)) 2712 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t)))); 2713 2714 return hash; 2715} 2716 2717typedef struct typename_info { 2718 tree scope; 2719 tree name; 2720 tree template_id; 2721 bool enum_p; 2722 bool class_p; 2723} typename_info; 2724 2725/* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */ 2726 2727static int 2728typename_compare (const void * k1, const void * k2) 2729{ 2730 tree t1; 2731 const typename_info *t2; 2732 2733 t1 = (tree) k1; 2734 t2 = (const typename_info *) k2; 2735 2736 return (DECL_NAME (TYPE_NAME (t1)) == t2->name 2737 && TYPE_CONTEXT (t1) == t2->scope 2738 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id 2739 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p 2740 && TYPENAME_IS_CLASS_P (t1) == t2->class_p); 2741} 2742 2743/* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is 2744 the type of `T', NAME is the IDENTIFIER_NODE for `t'. 2745 2746 Returns the new TYPENAME_TYPE. */ 2747 2748static GTY ((param_is (union tree_node))) htab_t typename_htab; 2749 2750static tree 2751build_typename_type (tree context, tree name, tree fullname, 2752 enum tag_types tag_type) 2753{ 2754 tree t; 2755 tree d; 2756 typename_info ti; 2757 void **e; 2758 hashval_t hash; 2759 2760 if (typename_htab == NULL) 2761 typename_htab = htab_create_ggc (61, &typename_hash, 2762 &typename_compare, NULL); 2763 2764 ti.scope = FROB_CONTEXT (context); 2765 ti.name = name; 2766 ti.template_id = fullname; 2767 ti.enum_p = tag_type == enum_type; 2768 ti.class_p = (tag_type == class_type 2769 || tag_type == record_type 2770 || tag_type == union_type); 2771 hash = (htab_hash_pointer (ti.scope) 2772 ^ htab_hash_pointer (ti.name)); 2773 2774 /* See if we already have this type. */ 2775 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT); 2776 if (*e) 2777 t = (tree) *e; 2778 else 2779 { 2780 /* Build the TYPENAME_TYPE. */ 2781 t = make_aggr_type (TYPENAME_TYPE); 2782 TYPE_CONTEXT (t) = ti.scope; 2783 TYPENAME_TYPE_FULLNAME (t) = ti.template_id; 2784 TYPENAME_IS_ENUM_P (t) = ti.enum_p; 2785 TYPENAME_IS_CLASS_P (t) = ti.class_p; 2786 2787 /* Build the corresponding TYPE_DECL. */ 2788 d = build_decl (TYPE_DECL, name, t); 2789 TYPE_NAME (TREE_TYPE (d)) = d; 2790 TYPE_STUB_DECL (TREE_TYPE (d)) = d; 2791 DECL_CONTEXT (d) = FROB_CONTEXT (context); 2792 DECL_ARTIFICIAL (d) = 1; 2793 2794 /* Store it in the hash table. */ 2795 *e = t; 2796 } 2797 2798 return t; 2799} 2800 2801/* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag 2802 provided to name the type. Returns an appropriate type, unless an 2803 error occurs, in which case error_mark_node is returned. If we 2804 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we 2805 return that, rather than the _TYPE it corresponds to, in other 2806 cases we look through the type decl. If TF_ERROR is set, complain 2807 about errors, otherwise be quiet. */ 2808 2809tree 2810make_typename_type (tree context, tree name, enum tag_types tag_type, 2811 tsubst_flags_t complain) 2812{ 2813 tree fullname; 2814 tree t; 2815 bool want_template; 2816 2817 if (name == error_mark_node 2818 || context == NULL_TREE 2819 || context == error_mark_node) 2820 return error_mark_node; 2821 2822 if (TYPE_P (name)) 2823 { 2824 if (!(TYPE_LANG_SPECIFIC (name) 2825 && (CLASSTYPE_IS_TEMPLATE (name) 2826 || CLASSTYPE_USE_TEMPLATE (name)))) 2827 name = TYPE_IDENTIFIER (name); 2828 else 2829 /* Create a TEMPLATE_ID_EXPR for the type. */ 2830 name = build_nt (TEMPLATE_ID_EXPR, 2831 CLASSTYPE_TI_TEMPLATE (name), 2832 CLASSTYPE_TI_ARGS (name)); 2833 } 2834 else if (TREE_CODE (name) == TYPE_DECL) 2835 name = DECL_NAME (name); 2836 2837 fullname = name; 2838 2839 if (TREE_CODE (name) == TEMPLATE_ID_EXPR) 2840 { 2841 name = TREE_OPERAND (name, 0); 2842 if (TREE_CODE (name) == TEMPLATE_DECL) 2843 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name); 2844 else if (TREE_CODE (name) == OVERLOAD) 2845 { 2846 error ("%qD is not a type", name); 2847 return error_mark_node; 2848 } 2849 } 2850 if (TREE_CODE (name) == TEMPLATE_DECL) 2851 { 2852 error ("%qD used without template parameters", name); 2853 return error_mark_node; 2854 } 2855 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); 2856 gcc_assert (TYPE_P (context)); 2857 2858 /* When the CONTEXT is a dependent type, NAME could refer to a 2859 dependent base class of CONTEXT. So we cannot peek inside it, 2860 even if CONTEXT is a currently open scope. */ 2861 if (dependent_type_p (context)) 2862 return build_typename_type (context, name, fullname, tag_type); 2863 2864 if (!IS_AGGR_TYPE (context)) 2865 { 2866 if (complain & tf_error) 2867 error ("%q#T is not a class", context); 2868 return error_mark_node; 2869 } 2870 2871 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR; 2872 2873 /* We should only set WANT_TYPE when we're a nested typename type. 2874 Then we can give better diagnostics if we find a non-type. */ 2875 t = lookup_field (context, name, 0, /*want_type=*/true); 2876 if (!t) 2877 { 2878 if (complain & tf_error) 2879 error (want_template ? "no class template named %q#T in %q#T" 2880 : "no type named %q#T in %q#T", name, context); 2881 return error_mark_node; 2882 } 2883 2884 if (want_template && !DECL_CLASS_TEMPLATE_P (t)) 2885 { 2886 if (complain & tf_error) 2887 error ("%<typename %T::%D%> names %q#T, which is not a class template", 2888 context, name, t); 2889 return error_mark_node; 2890 } 2891 if (!want_template && TREE_CODE (t) != TYPE_DECL) 2892 { 2893 if (complain & tf_error) 2894 error ("%<typename %T::%D%> names %q#T, which is not a type", 2895 context, name, t); 2896 return error_mark_node; 2897 } 2898 2899 if (complain & tf_error) 2900 perform_or_defer_access_check (TYPE_BINFO (context), t, t); 2901 2902 if (want_template) 2903 return lookup_template_class (t, TREE_OPERAND (fullname, 1), 2904 NULL_TREE, context, 2905 /*entering_scope=*/0, 2906 tf_warning_or_error | tf_user); 2907 2908 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl)) 2909 t = TREE_TYPE (t); 2910 2911 return t; 2912} 2913 2914/* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name 2915 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs, 2916 in which case error_mark_node is returned. 2917 2918 If PARM_LIST is non-NULL, also make sure that the template parameter 2919 list of TEMPLATE_DECL matches. 2920 2921 If COMPLAIN zero, don't complain about any errors that occur. */ 2922 2923tree 2924make_unbound_class_template (tree context, tree name, tree parm_list, 2925 tsubst_flags_t complain) 2926{ 2927 tree t; 2928 tree d; 2929 2930 if (TYPE_P (name)) 2931 name = TYPE_IDENTIFIER (name); 2932 else if (DECL_P (name)) 2933 name = DECL_NAME (name); 2934 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); 2935 2936 if (!dependent_type_p (context) 2937 || currently_open_class (context)) 2938 { 2939 tree tmpl = NULL_TREE; 2940 2941 if (IS_AGGR_TYPE (context)) 2942 tmpl = lookup_field (context, name, 0, false); 2943 2944 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl)) 2945 { 2946 if (complain & tf_error) 2947 error ("no class template named %q#T in %q#T", name, context); 2948 return error_mark_node; 2949 } 2950 2951 if (parm_list 2952 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list)) 2953 { 2954 if (complain & tf_error) 2955 { 2956 error ("template parameters do not match template"); 2957 error ("%q+D declared here", tmpl); 2958 } 2959 return error_mark_node; 2960 } 2961 2962 if (complain & tf_error) 2963 perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl); 2964 2965 return tmpl; 2966 } 2967 2968 /* Build the UNBOUND_CLASS_TEMPLATE. */ 2969 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE); 2970 TYPE_CONTEXT (t) = FROB_CONTEXT (context); 2971 TREE_TYPE (t) = NULL_TREE; 2972 2973 /* Build the corresponding TEMPLATE_DECL. */ 2974 d = build_decl (TEMPLATE_DECL, name, t); 2975 TYPE_NAME (TREE_TYPE (d)) = d; 2976 TYPE_STUB_DECL (TREE_TYPE (d)) = d; 2977 DECL_CONTEXT (d) = FROB_CONTEXT (context); 2978 DECL_ARTIFICIAL (d) = 1; 2979 DECL_TEMPLATE_PARMS (d) = parm_list; 2980 2981 return t; 2982} 2983 2984 2985 2986/* Push the declarations of builtin types into the namespace. 2987 RID_INDEX is the index of the builtin type in the array 2988 RID_POINTERS. NAME is the name used when looking up the builtin 2989 type. TYPE is the _TYPE node for the builtin type. */ 2990 2991void 2992record_builtin_type (enum rid rid_index, 2993 const char* name, 2994 tree type) 2995{ 2996 tree rname = NULL_TREE, tname = NULL_TREE; 2997 tree tdecl = NULL_TREE; 2998 2999 if ((int) rid_index < (int) RID_MAX) 3000 rname = ridpointers[(int) rid_index]; 3001 if (name) 3002 tname = get_identifier (name); 3003 3004 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be 3005 eliminated. Built-in types should not be looked up name; their 3006 names are keywords that the parser can recognize. However, there 3007 is code in c-common.c that uses identifier_global_value to look 3008 up built-in types by name. */ 3009 if (tname) 3010 { 3011 tdecl = build_decl (TYPE_DECL, tname, type); 3012 DECL_ARTIFICIAL (tdecl) = 1; 3013 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl); 3014 } 3015 if (rname) 3016 { 3017 if (!tdecl) 3018 { 3019 tdecl = build_decl (TYPE_DECL, rname, type); 3020 DECL_ARTIFICIAL (tdecl) = 1; 3021 } 3022 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl); 3023 } 3024 3025 if (!TYPE_NAME (type)) 3026 TYPE_NAME (type) = tdecl; 3027 3028 if (tdecl) 3029 debug_hooks->type_decl (tdecl, 0); 3030} 3031 3032/* Record one of the standard Java types. 3033 * Declare it as having the given NAME. 3034 * If SIZE > 0, it is the size of one of the integral types; 3035 * otherwise it is the negative of the size of one of the other types. */ 3036 3037static tree 3038record_builtin_java_type (const char* name, int size) 3039{ 3040 tree type, decl; 3041 if (size > 0) 3042 type = make_signed_type (size); 3043 else if (size > -32) 3044 { /* "__java_char" or ""__java_boolean". */ 3045 type = make_unsigned_type (-size); 3046 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/ 3047 } 3048 else 3049 { /* "__java_float" or ""__java_double". */ 3050 type = make_node (REAL_TYPE); 3051 TYPE_PRECISION (type) = - size; 3052 layout_type (type); 3053 } 3054 record_builtin_type (RID_MAX, name, type); 3055 decl = TYPE_NAME (type); 3056 3057 /* Suppress generate debug symbol entries for these types, 3058 since for normal C++ they are just clutter. 3059 However, push_lang_context undoes this if extern "Java" is seen. */ 3060 DECL_IGNORED_P (decl) = 1; 3061 3062 TYPE_FOR_JAVA (type) = 1; 3063 return type; 3064} 3065 3066/* Push a type into the namespace so that the back-ends ignore it. */ 3067 3068static void 3069record_unknown_type (tree type, const char* name) 3070{ 3071 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type)); 3072 /* Make sure the "unknown type" typedecl gets ignored for debug info. */ 3073 DECL_IGNORED_P (decl) = 1; 3074 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1; 3075 TYPE_SIZE (type) = TYPE_SIZE (void_type_node); 3076 TYPE_ALIGN (type) = 1; 3077 TYPE_USER_ALIGN (type) = 0; 3078 TYPE_MODE (type) = TYPE_MODE (void_type_node); 3079} 3080 3081/* A string for which we should create an IDENTIFIER_NODE at 3082 startup. */ 3083 3084typedef struct predefined_identifier 3085{ 3086 /* The name of the identifier. */ 3087 const char *const name; 3088 /* The place where the IDENTIFIER_NODE should be stored. */ 3089 tree *const node; 3090 /* Nonzero if this is the name of a constructor or destructor. */ 3091 const int ctor_or_dtor_p; 3092} predefined_identifier; 3093 3094/* Create all the predefined identifiers. */ 3095 3096static void 3097initialize_predefined_identifiers (void) 3098{ 3099 const predefined_identifier *pid; 3100 3101 /* A table of identifiers to create at startup. */ 3102 static const predefined_identifier predefined_identifiers[] = { 3103 { "C++", &lang_name_cplusplus, 0 }, 3104 { "C", &lang_name_c, 0 }, 3105 { "Java", &lang_name_java, 0 }, 3106 /* Some of these names have a trailing space so that it is 3107 impossible for them to conflict with names written by users. */ 3108 { "__ct ", &ctor_identifier, 1 }, 3109 { "__base_ctor ", &base_ctor_identifier, 1 }, 3110 { "__comp_ctor ", &complete_ctor_identifier, 1 }, 3111 { "__dt ", &dtor_identifier, 1 }, 3112 { "__comp_dtor ", &complete_dtor_identifier, 1 }, 3113 { "__base_dtor ", &base_dtor_identifier, 1 }, 3114 { "__deleting_dtor ", &deleting_dtor_identifier, 1 }, 3115 { IN_CHARGE_NAME, &in_charge_identifier, 0 }, 3116 { "nelts", &nelts_identifier, 0 }, 3117 { THIS_NAME, &this_identifier, 0 }, 3118 { VTABLE_DELTA_NAME, &delta_identifier, 0 }, 3119 { VTABLE_PFN_NAME, &pfn_identifier, 0 }, 3120 { "_vptr", &vptr_identifier, 0 }, 3121 { "__vtt_parm", &vtt_parm_identifier, 0 }, 3122 { "::", &global_scope_name, 0 }, 3123 { "std", &std_identifier, 0 }, 3124 { NULL, NULL, 0 } 3125 }; 3126 3127 for (pid = predefined_identifiers; pid->name; ++pid) 3128 { 3129 *pid->node = get_identifier (pid->name); 3130 if (pid->ctor_or_dtor_p) 3131 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1; 3132 } 3133} 3134 3135/* Create the predefined scalar types of C, 3136 and some nodes representing standard constants (0, 1, (void *)0). 3137 Initialize the global binding level. 3138 Make definitions for built-in primitive functions. */ 3139 3140void 3141cxx_init_decl_processing (void) 3142{ 3143 tree void_ftype; 3144 tree void_ftype_ptr; 3145 3146 build_common_tree_nodes (flag_signed_char, false); 3147 3148 /* Create all the identifiers we need. */ 3149 initialize_predefined_identifiers (); 3150 3151 /* Create the global variables. */ 3152 push_to_top_level (); 3153 3154 current_function_decl = NULL_TREE; 3155 current_binding_level = NULL; 3156 /* Enter the global namespace. */ 3157 gcc_assert (global_namespace == NULL_TREE); 3158 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name, 3159 void_type_node); 3160 TREE_PUBLIC (global_namespace) = 1; 3161 begin_scope (sk_namespace, global_namespace); 3162 3163 current_lang_name = NULL_TREE; 3164 3165 /* Adjust various flags based on command-line settings. */ 3166 if (!flag_permissive) 3167 flag_pedantic_errors = 1; 3168 if (!flag_no_inline) 3169 { 3170 flag_inline_trees = 1; 3171 flag_no_inline = 1; 3172 } 3173 if (flag_inline_functions) 3174 flag_inline_trees = 2; 3175 3176 if (flag_visibility_ms_compat) 3177 default_visibility = VISIBILITY_HIDDEN; 3178 3179 /* Initially, C. */ 3180 current_lang_name = lang_name_c; 3181 3182 /* Create the `std' namespace. */ 3183 push_namespace (std_identifier); 3184 std_node = current_namespace; 3185 pop_namespace (); 3186 3187 c_common_nodes_and_builtins (); 3188 3189 java_byte_type_node = record_builtin_java_type ("__java_byte", 8); 3190 java_short_type_node = record_builtin_java_type ("__java_short", 16); 3191 java_int_type_node = record_builtin_java_type ("__java_int", 32); 3192 java_long_type_node = record_builtin_java_type ("__java_long", 64); 3193 java_float_type_node = record_builtin_java_type ("__java_float", -32); 3194 java_double_type_node = record_builtin_java_type ("__java_double", -64); 3195 java_char_type_node = record_builtin_java_type ("__java_char", -16); 3196 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1); 3197 3198 integer_two_node = build_int_cst (NULL_TREE, 2); 3199 integer_three_node = build_int_cst (NULL_TREE, 3); 3200 3201 record_builtin_type (RID_BOOL, "bool", boolean_type_node); 3202 truthvalue_type_node = boolean_type_node; 3203 truthvalue_false_node = boolean_false_node; 3204 truthvalue_true_node = boolean_true_node; 3205 3206 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE); 3207 3208#if 0 3209 record_builtin_type (RID_MAX, NULL, string_type_node); 3210#endif 3211 3212 delta_type_node = ptrdiff_type_node; 3213 vtable_index_type = ptrdiff_type_node; 3214 3215 vtt_parm_type = build_pointer_type (const_ptr_type_node); 3216 void_ftype = build_function_type (void_type_node, void_list_node); 3217 void_ftype_ptr = build_function_type (void_type_node, 3218 tree_cons (NULL_TREE, 3219 ptr_type_node, 3220 void_list_node)); 3221 void_ftype_ptr 3222 = build_exception_variant (void_ftype_ptr, empty_except_spec); 3223 3224 /* C++ extensions */ 3225 3226 unknown_type_node = make_node (UNKNOWN_TYPE); 3227 record_unknown_type (unknown_type_node, "unknown type"); 3228 3229 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */ 3230 TREE_TYPE (unknown_type_node) = unknown_type_node; 3231 3232 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same 3233 result. */ 3234 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node; 3235 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node; 3236 3237 { 3238 /* Make sure we get a unique function type, so we can give 3239 its pointer type a name. (This wins for gdb.) */ 3240 tree vfunc_type = make_node (FUNCTION_TYPE); 3241 TREE_TYPE (vfunc_type) = integer_type_node; 3242 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE; 3243 layout_type (vfunc_type); 3244 3245 vtable_entry_type = build_pointer_type (vfunc_type); 3246 } 3247 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type); 3248 3249 vtbl_type_node 3250 = build_cplus_array_type (vtable_entry_type, NULL_TREE); 3251 layout_type (vtbl_type_node); 3252 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST); 3253 record_builtin_type (RID_MAX, NULL, vtbl_type_node); 3254 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type); 3255 layout_type (vtbl_ptr_type_node); 3256 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node); 3257 3258 push_namespace (get_identifier ("__cxxabiv1")); 3259 abi_node = current_namespace; 3260 pop_namespace (); 3261 3262 global_type_node = make_node (LANG_TYPE); 3263 record_unknown_type (global_type_node, "global type"); 3264 3265 /* Now, C++. */ 3266 current_lang_name = lang_name_cplusplus; 3267 3268 { 3269 tree bad_alloc_id; 3270 tree bad_alloc_type_node; 3271 tree bad_alloc_decl; 3272 tree newtype, deltype; 3273 tree ptr_ftype_sizetype; 3274 3275 push_namespace (std_identifier); 3276 bad_alloc_id = get_identifier ("bad_alloc"); 3277 bad_alloc_type_node = make_aggr_type (RECORD_TYPE); 3278 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace; 3279 bad_alloc_decl 3280 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node); 3281 DECL_CONTEXT (bad_alloc_decl) = current_namespace; 3282 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl; 3283 pop_namespace (); 3284 3285 ptr_ftype_sizetype 3286 = build_function_type (ptr_type_node, 3287 tree_cons (NULL_TREE, 3288 size_type_node, 3289 void_list_node)); 3290 newtype = build_exception_variant 3291 (ptr_ftype_sizetype, add_exception_specifier 3292 (NULL_TREE, bad_alloc_type_node, -1)); 3293 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec); 3294 push_cp_library_fn (NEW_EXPR, newtype); 3295 push_cp_library_fn (VEC_NEW_EXPR, newtype); 3296 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype); 3297 push_cp_library_fn (VEC_DELETE_EXPR, deltype); 3298 } 3299 3300 abort_fndecl 3301 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype); 3302 3303 /* Perform other language dependent initializations. */ 3304 init_class_processing (); 3305 init_rtti_processing (); 3306 3307 if (flag_exceptions) 3308 init_exception_processing (); 3309 3310 if (! supports_one_only ()) 3311 flag_weak = 0; 3312 3313 make_fname_decl = cp_make_fname_decl; 3314 start_fname_decls (); 3315 3316 /* Show we use EH for cleanups. */ 3317 if (flag_exceptions) 3318 using_eh_for_cleanups (); 3319} 3320 3321/* Generate an initializer for a function naming variable from 3322 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is 3323 filled in with the type of the init. */ 3324 3325tree 3326cp_fname_init (const char* name, tree *type_p) 3327{ 3328 tree domain = NULL_TREE; 3329 tree type; 3330 tree init = NULL_TREE; 3331 size_t length = 0; 3332 3333 if (name) 3334 { 3335 length = strlen (name); 3336 domain = build_index_type (size_int (length)); 3337 init = build_string (length + 1, name); 3338 } 3339 3340 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST); 3341 type = build_cplus_array_type (type, domain); 3342 3343 *type_p = type; 3344 3345 if (init) 3346 TREE_TYPE (init) = type; 3347 else 3348 init = error_mark_node; 3349 3350 return init; 3351} 3352 3353/* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the 3354 decl, NAME is the initialization string and TYPE_DEP indicates whether 3355 NAME depended on the type of the function. We make use of that to detect 3356 __PRETTY_FUNCTION__ inside a template fn. This is being done 3357 lazily at the point of first use, so we mustn't push the decl now. */ 3358 3359static tree 3360cp_make_fname_decl (tree id, int type_dep) 3361{ 3362 const char *const name = (type_dep && processing_template_decl 3363 ? NULL : fname_as_string (type_dep)); 3364 tree type; 3365 tree init = cp_fname_init (name, &type); 3366 tree decl = build_decl (VAR_DECL, id, type); 3367 3368 if (name) 3369 free ((char *) name); 3370 3371 /* As we're using pushdecl_with_scope, we must set the context. */ 3372 DECL_CONTEXT (decl) = current_function_decl; 3373 DECL_PRETTY_FUNCTION_P (decl) = type_dep; 3374 3375 TREE_STATIC (decl) = 1; 3376 TREE_READONLY (decl) = 1; 3377 DECL_ARTIFICIAL (decl) = 1; 3378 3379 TREE_USED (decl) = 1; 3380 3381 if (current_function_decl) 3382 { 3383 struct cp_binding_level *b = current_binding_level; 3384 while (b->level_chain->kind != sk_function_parms) 3385 b = b->level_chain; 3386 pushdecl_with_scope (decl, b, /*is_friend=*/false); 3387 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE, 3388 LOOKUP_ONLYCONVERTING); 3389 } 3390 else 3391 pushdecl_top_level_and_finish (decl, init); 3392 3393 return decl; 3394} 3395 3396/* Make a definition for a builtin function named NAME in the current 3397 namespace, whose data type is TYPE and whose context is CONTEXT. 3398 TYPE should be a function type with argument types. 3399 3400 CLASS and CODE tell later passes how to compile calls to this function. 3401 See tree.h for possible values. 3402 3403 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME, 3404 the name to be called if we can't opencode the function. 3405 If ATTRS is nonzero, use that for the function's attribute 3406 list. */ 3407 3408static tree 3409builtin_function_1 (const char* name, 3410 tree type, 3411 tree context, 3412 enum built_in_function code, 3413 enum built_in_class class, 3414 const char* libname, 3415 tree attrs) 3416{ 3417 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type); 3418 DECL_BUILT_IN_CLASS (decl) = class; 3419 DECL_FUNCTION_CODE (decl) = code; 3420 DECL_CONTEXT (decl) = context; 3421 3422 pushdecl (decl); 3423 3424 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME, 3425 we cannot change DECL_ASSEMBLER_NAME until we have installed this 3426 function in the namespace. */ 3427 if (libname) 3428 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname)); 3429 3430 /* A function in the user's namespace should have an explicit 3431 declaration before it is used. Mark the built-in function as 3432 anticipated but not actually declared. */ 3433 if (name[0] != '_' || name[1] != '_') 3434 DECL_ANTICIPATED (decl) = 1; 3435 3436 /* Possibly apply some default attributes to this built-in function. */ 3437 if (attrs) 3438 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN); 3439 else 3440 decl_attributes (&decl, NULL_TREE, 0); 3441 3442 return decl; 3443} 3444 3445/* Entry point for the benefit of c_common_nodes_and_builtins. 3446 3447 Make a definition for a builtin function named NAME and whose data type 3448 is TYPE. TYPE should be a function type with argument types. This 3449 function places the anticipated declaration in the global namespace 3450 and additionally in the std namespace if appropriate. 3451 3452 CLASS and CODE tell later passes how to compile calls to this function. 3453 See tree.h for possible values. 3454 3455 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME, 3456 the name to be called if we can't opencode the function. 3457 3458 If ATTRS is nonzero, use that for the function's attribute 3459 list. */ 3460 3461tree 3462builtin_function (const char* name, 3463 tree type, 3464 int code, 3465 enum built_in_class cl, 3466 const char* libname, 3467 tree attrs) 3468{ 3469 /* All builtins that don't begin with an '_' should additionally 3470 go in the 'std' namespace. */ 3471 if (name[0] != '_') 3472 { 3473 push_namespace (std_identifier); 3474 builtin_function_1 (name, type, std_node, code, cl, libname, attrs); 3475 pop_namespace (); 3476 } 3477 3478 return builtin_function_1 (name, type, NULL_TREE, code, 3479 cl, libname, attrs); 3480} 3481 3482/* Generate a FUNCTION_DECL with the typical flags for a runtime library 3483 function. Not called directly. */ 3484 3485static tree 3486build_library_fn_1 (tree name, enum tree_code operator_code, tree type) 3487{ 3488 tree fn = build_lang_decl (FUNCTION_DECL, name, type); 3489 DECL_EXTERNAL (fn) = 1; 3490 TREE_PUBLIC (fn) = 1; 3491 DECL_ARTIFICIAL (fn) = 1; 3492 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code); 3493 SET_DECL_LANGUAGE (fn, lang_c); 3494 /* Runtime library routines are, by definition, available in an 3495 external shared object. */ 3496 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT; 3497 DECL_VISIBILITY_SPECIFIED (fn) = 1; 3498 return fn; 3499} 3500 3501/* Returns the _DECL for a library function with C linkage. 3502 We assume that such functions never throw; if this is incorrect, 3503 callers should unset TREE_NOTHROW. */ 3504 3505tree 3506build_library_fn (tree name, tree type) 3507{ 3508 tree fn = build_library_fn_1 (name, ERROR_MARK, type); 3509 TREE_NOTHROW (fn) = 1; 3510 return fn; 3511} 3512 3513/* Returns the _DECL for a library function with C++ linkage. */ 3514 3515static tree 3516build_cp_library_fn (tree name, enum tree_code operator_code, tree type) 3517{ 3518 tree fn = build_library_fn_1 (name, operator_code, type); 3519 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type); 3520 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace); 3521 SET_DECL_LANGUAGE (fn, lang_cplusplus); 3522 return fn; 3523} 3524 3525/* Like build_library_fn, but takes a C string instead of an 3526 IDENTIFIER_NODE. */ 3527 3528tree 3529build_library_fn_ptr (const char* name, tree type) 3530{ 3531 return build_library_fn (get_identifier (name), type); 3532} 3533 3534/* Like build_cp_library_fn, but takes a C string instead of an 3535 IDENTIFIER_NODE. */ 3536 3537tree 3538build_cp_library_fn_ptr (const char* name, tree type) 3539{ 3540 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type); 3541} 3542 3543/* Like build_library_fn, but also pushes the function so that we will 3544 be able to find it via IDENTIFIER_GLOBAL_VALUE. */ 3545 3546tree 3547push_library_fn (tree name, tree type) 3548{ 3549 tree fn = build_library_fn (name, type); 3550 pushdecl_top_level (fn); 3551 return fn; 3552} 3553 3554/* Like build_cp_library_fn, but also pushes the function so that it 3555 will be found by normal lookup. */ 3556 3557static tree 3558push_cp_library_fn (enum tree_code operator_code, tree type) 3559{ 3560 tree fn = build_cp_library_fn (ansi_opname (operator_code), 3561 operator_code, 3562 type); 3563 pushdecl (fn); 3564 return fn; 3565} 3566 3567/* Like push_library_fn, but takes a TREE_LIST of parm types rather than 3568 a FUNCTION_TYPE. */ 3569 3570tree 3571push_void_library_fn (tree name, tree parmtypes) 3572{ 3573 tree type = build_function_type (void_type_node, parmtypes); 3574 return push_library_fn (name, type); 3575} 3576 3577/* Like push_library_fn, but also note that this function throws 3578 and does not return. Used for __throw_foo and the like. */ 3579 3580tree 3581push_throw_library_fn (tree name, tree type) 3582{ 3583 tree fn = push_library_fn (name, type); 3584 TREE_THIS_VOLATILE (fn) = 1; 3585 TREE_NOTHROW (fn) = 0; 3586 return fn; 3587} 3588 3589/* When we call finish_struct for an anonymous union, we create 3590 default copy constructors and such. But, an anonymous union 3591 shouldn't have such things; this function undoes the damage to the 3592 anonymous union type T. 3593 3594 (The reason that we create the synthesized methods is that we don't 3595 distinguish `union { int i; }' from `typedef union { int i; } U'. 3596 The first is an anonymous union; the second is just an ordinary 3597 union type.) */ 3598 3599void 3600fixup_anonymous_aggr (tree t) 3601{ 3602 tree *q; 3603 3604 /* Wipe out memory of synthesized methods. */ 3605 TYPE_HAS_CONSTRUCTOR (t) = 0; 3606 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0; 3607 TYPE_HAS_INIT_REF (t) = 0; 3608 TYPE_HAS_CONST_INIT_REF (t) = 0; 3609 TYPE_HAS_ASSIGN_REF (t) = 0; 3610 TYPE_HAS_CONST_ASSIGN_REF (t) = 0; 3611 3612 /* Splice the implicitly generated functions out of the TYPE_METHODS 3613 list. */ 3614 q = &TYPE_METHODS (t); 3615 while (*q) 3616 { 3617 if (DECL_ARTIFICIAL (*q)) 3618 *q = TREE_CHAIN (*q); 3619 else 3620 q = &TREE_CHAIN (*q); 3621 } 3622 3623 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */ 3624 if (TYPE_METHODS (t)) 3625 error ("%Jan anonymous union cannot have function members", 3626 TYPE_MAIN_DECL (t)); 3627 3628 /* Anonymous aggregates cannot have fields with ctors, dtors or complex 3629 assignment operators (because they cannot have these methods themselves). 3630 For anonymous unions this is already checked because they are not allowed 3631 in any union, otherwise we have to check it. */ 3632 if (TREE_CODE (t) != UNION_TYPE) 3633 { 3634 tree field, type; 3635 3636 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field)) 3637 if (TREE_CODE (field) == FIELD_DECL) 3638 { 3639 type = TREE_TYPE (field); 3640 if (CLASS_TYPE_P (type)) 3641 { 3642 if (TYPE_NEEDS_CONSTRUCTING (type)) 3643 error ("member %q+#D with constructor not allowed " 3644 "in anonymous aggregate", field); 3645 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) 3646 error ("member %q+#D with destructor not allowed " 3647 "in anonymous aggregate", field); 3648 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type)) 3649 error ("member %q+#D with copy assignment operator " 3650 "not allowed in anonymous aggregate", field); 3651 } 3652 } 3653 } 3654} 3655 3656/* Make sure that a declaration with no declarator is well-formed, i.e. 3657 just declares a tagged type or anonymous union. 3658 3659 Returns the type declared; or NULL_TREE if none. */ 3660 3661tree 3662check_tag_decl (cp_decl_specifier_seq *declspecs) 3663{ 3664 int saw_friend = declspecs->specs[(int)ds_friend] != 0; 3665 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0; 3666 /* If a class, struct, or enum type is declared by the DECLSPECS 3667 (i.e, if a class-specifier, enum-specifier, or non-typename 3668 elaborated-type-specifier appears in the DECLSPECS), 3669 DECLARED_TYPE is set to the corresponding type. */ 3670 tree declared_type = NULL_TREE; 3671 bool error_p = false; 3672 3673 if (declspecs->multiple_types_p) 3674 error ("multiple types in one declaration"); 3675 else if (declspecs->redefined_builtin_type) 3676 { 3677 if (!in_system_header) 3678 pedwarn ("redeclaration of C++ built-in type %qT", 3679 declspecs->redefined_builtin_type); 3680 return NULL_TREE; 3681 } 3682 3683 if (declspecs->type 3684 && TYPE_P (declspecs->type) 3685 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE 3686 && IS_AGGR_TYPE (declspecs->type)) 3687 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE)) 3688 declared_type = declspecs->type; 3689 else if (declspecs->type == error_mark_node) 3690 error_p = true; 3691 if (declared_type == NULL_TREE && ! saw_friend && !error_p) 3692 pedwarn ("declaration does not declare anything"); 3693 /* Check for an anonymous union. */ 3694 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type)) 3695 && TYPE_ANONYMOUS_P (declared_type)) 3696 { 3697 /* 7/3 In a simple-declaration, the optional init-declarator-list 3698 can be omitted only when declaring a class (clause 9) or 3699 enumeration (7.2), that is, when the decl-specifier-seq contains 3700 either a class-specifier, an elaborated-type-specifier with 3701 a class-key (9.1), or an enum-specifier. In these cases and 3702 whenever a class-specifier or enum-specifier is present in the 3703 decl-specifier-seq, the identifiers in these specifiers are among 3704 the names being declared by the declaration (as class-name, 3705 enum-names, or enumerators, depending on the syntax). In such 3706 cases, and except for the declaration of an unnamed bit-field (9.6), 3707 the decl-specifier-seq shall introduce one or more names into the 3708 program, or shall redeclare a name introduced by a previous 3709 declaration. [Example: 3710 enum { }; // ill-formed 3711 typedef class { }; // ill-formed 3712 --end example] */ 3713 if (saw_typedef) 3714 { 3715 error ("missing type-name in typedef-declaration"); 3716 return NULL_TREE; 3717 } 3718 /* Anonymous unions are objects, so they can have specifiers. */; 3719 SET_ANON_AGGR_TYPE_P (declared_type); 3720 3721 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic 3722 && !in_system_header) 3723 pedwarn ("ISO C++ prohibits anonymous structs"); 3724 } 3725 3726 else 3727 { 3728 if (declspecs->specs[(int)ds_inline] 3729 || declspecs->specs[(int)ds_virtual]) 3730 error ("%qs can only be specified for functions", 3731 declspecs->specs[(int)ds_inline] 3732 ? "inline" : "virtual"); 3733 else if (saw_friend 3734 && (!current_class_type 3735 || current_scope () != current_class_type)) 3736 error ("%<friend%> can only be specified inside a class"); 3737 else if (declspecs->specs[(int)ds_explicit]) 3738 error ("%<explicit%> can only be specified for constructors"); 3739 else if (declspecs->storage_class) 3740 error ("a storage class can only be specified for objects " 3741 "and functions"); 3742 else if (declspecs->specs[(int)ds_const] 3743 || declspecs->specs[(int)ds_volatile] 3744 || declspecs->specs[(int)ds_restrict] 3745 || declspecs->specs[(int)ds_thread]) 3746 error ("qualifiers can only be specified for objects " 3747 "and functions"); 3748 } 3749 3750 return declared_type; 3751} 3752 3753/* Called when a declaration is seen that contains no names to declare. 3754 If its type is a reference to a structure, union or enum inherited 3755 from a containing scope, shadow that tag name for the current scope 3756 with a forward reference. 3757 If its type defines a new named structure or union 3758 or defines an enum, it is valid but we need not do anything here. 3759 Otherwise, it is an error. 3760 3761 C++: may have to grok the declspecs to learn about static, 3762 complain for anonymous unions. 3763 3764 Returns the TYPE declared -- or NULL_TREE if none. */ 3765 3766tree 3767shadow_tag (cp_decl_specifier_seq *declspecs) 3768{ 3769 tree t = check_tag_decl (declspecs); 3770 3771 if (!t) 3772 return NULL_TREE; 3773 3774 if (declspecs->attributes) 3775 { 3776 warning (0, "attribute ignored in declaration of %q+#T", t); 3777 warning (0, "attribute for %q+#T must follow the %qs keyword", 3778 t, class_key_or_enum_as_string (t)); 3779 3780 } 3781 3782 if (maybe_process_partial_specialization (t) == error_mark_node) 3783 return NULL_TREE; 3784 3785 /* This is where the variables in an anonymous union are 3786 declared. An anonymous union declaration looks like: 3787 union { ... } ; 3788 because there is no declarator after the union, the parser 3789 sends that declaration here. */ 3790 if (ANON_AGGR_TYPE_P (t)) 3791 { 3792 fixup_anonymous_aggr (t); 3793 3794 if (TYPE_FIELDS (t)) 3795 { 3796 tree decl = grokdeclarator (/*declarator=*/NULL, 3797 declspecs, NORMAL, 0, NULL); 3798 finish_anon_union (decl); 3799 } 3800 } 3801 3802 return t; 3803} 3804 3805/* APPLE LOCAL begin blocks 6339747 */ 3806/* Decode a block literal type, such as "int **", returning a ...FUNCTION_DECL node. */ 3807 3808tree 3809grokblockdecl (cp_decl_specifier_seq *type_specifiers, 3810 const cp_declarator *declarator) 3811{ 3812 tree decl; 3813 tree attrs = type_specifiers->attributes; 3814 3815 type_specifiers->attributes = NULL_TREE; 3816 3817 decl = grokdeclarator (declarator, type_specifiers, BLOCKDEF, 0, &attrs); 3818 if (attrs) 3819 cplus_decl_attributes (&decl, attrs, 0); 3820 return decl; 3821} 3822/* APPLE LOCAL end blocks 6339747 */ 3823 3824/* Decode a "typename", such as "int **", returning a ..._TYPE node. */ 3825 3826tree 3827groktypename (cp_decl_specifier_seq *type_specifiers, 3828 const cp_declarator *declarator) 3829{ 3830 tree attrs; 3831 tree type; 3832 attrs = type_specifiers->attributes; 3833 type_specifiers->attributes = NULL_TREE; 3834 type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs); 3835 if (attrs) 3836 cplus_decl_attributes (&type, attrs, 0); 3837 return type; 3838} 3839 3840/* Decode a declarator in an ordinary declaration or data definition. 3841 This is called as soon as the type information and variable name 3842 have been parsed, before parsing the initializer if any. 3843 Here we create the ..._DECL node, fill in its type, 3844 and put it on the list of decls for the current context. 3845 The ..._DECL node is returned as the value. 3846 3847 Exception: for arrays where the length is not specified, 3848 the type is left null, to be filled in by `cp_finish_decl'. 3849 3850 Function definitions do not come here; they go to start_function 3851 instead. However, external and forward declarations of functions 3852 do go through here. Structure field declarations are done by 3853 grokfield and not through here. */ 3854 3855tree 3856start_decl (const cp_declarator *declarator, 3857 cp_decl_specifier_seq *declspecs, 3858 int initialized, 3859 tree attributes, 3860 tree prefix_attributes, 3861 tree *pushed_scope_p) 3862{ 3863 tree decl; 3864 tree type, tem; 3865 tree context; 3866 /* APPLE LOCAL "unavailable" attribute (radar 2809697) */ 3867 tree a; 3868 bool was_public; 3869 3870 *pushed_scope_p = NULL_TREE; 3871 3872 /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */ 3873 /* An object declared as __attribute__((unavailable)) suppresses 3874 any reports of being declared with unavailable or deprecated 3875 items. An object declared as __attribute__((deprecated)) 3876 suppresses warnings of uses of other deprecated items. */ 3877#ifdef A_LESS_INEFFICENT_WAY /* which I really don't want to do! */ 3878 if (lookup_attribute ("deprecated", attributes)) 3879 deprecated_state = DEPRECATED_SUPPRESS; 3880 else if (lookup_attribute ("unavailable", attributes)) 3881 deprecated_state = DEPRECATED_UNAVAILABLE_SUPPRESS; 3882#else /* a more efficient way doing what lookup_attribute would do */ 3883 for (a = attributes; a; a = TREE_CHAIN (a)) 3884 { 3885 tree name = TREE_PURPOSE (a); 3886 if (TREE_CODE (name) == IDENTIFIER_NODE) 3887 if (is_attribute_p ("deprecated", name)) 3888 { 3889 deprecated_state = DEPRECATED_SUPPRESS; 3890 break; 3891 } 3892 if (is_attribute_p ("unavailable", name)) 3893 { 3894 deprecated_state = DEPRECATED_UNAVAILABLE_SUPPRESS; 3895 break; 3896 } 3897 } 3898#endif 3899 /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */ 3900 3901 attributes = chainon (attributes, prefix_attributes); 3902 3903 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized, 3904 &attributes); 3905 3906 deprecated_state = DEPRECATED_NORMAL; 3907 3908 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE 3909 || decl == error_mark_node) 3910 return error_mark_node; 3911 3912 type = TREE_TYPE (decl); 3913 3914 context = DECL_CONTEXT (decl); 3915 3916 if (context) 3917 { 3918 *pushed_scope_p = push_scope (context); 3919 3920 /* We are only interested in class contexts, later. */ 3921 if (TREE_CODE (context) == NAMESPACE_DECL) 3922 context = NULL_TREE; 3923 } 3924 3925 if (initialized) 3926 /* Is it valid for this decl to have an initializer at all? 3927 If not, set INITIALIZED to zero, which will indirectly 3928 tell `cp_finish_decl' to ignore the initializer once it is parsed. */ 3929 switch (TREE_CODE (decl)) 3930 { 3931 case TYPE_DECL: 3932 error ("typedef %qD is initialized (use __typeof__ instead)", decl); 3933 return error_mark_node; 3934 3935 case FUNCTION_DECL: 3936 error ("function %q#D is initialized like a variable", decl); 3937 return error_mark_node; 3938 3939 default: 3940 break; 3941 } 3942 3943 if (initialized) 3944 { 3945 if (! toplevel_bindings_p () 3946 && DECL_EXTERNAL (decl)) 3947 warning (0, "declaration of %q#D has %<extern%> and is initialized", 3948 decl); 3949 DECL_EXTERNAL (decl) = 0; 3950 if (toplevel_bindings_p ()) 3951 TREE_STATIC (decl) = 1; 3952 } 3953 3954 /* Set attributes here so if duplicate decl, will have proper attributes. */ 3955 cplus_decl_attributes (&decl, attributes, 0); 3956 3957 /* Dllimported symbols cannot be defined. Static data members (which 3958 can be initialized in-class and dllimported) go through grokfield, 3959 not here, so we don't need to exclude those decls when checking for 3960 a definition. */ 3961 if (initialized && DECL_DLLIMPORT_P (decl)) 3962 { 3963 error ("definition of %q#D is marked %<dllimport%>", decl); 3964 DECL_DLLIMPORT_P (decl) = 0; 3965 } 3966 3967 /* If #pragma weak was used, mark the decl weak now. */ 3968 maybe_apply_pragma_weak (decl); 3969 3970 if (TREE_CODE (decl) == FUNCTION_DECL 3971 && DECL_DECLARED_INLINE_P (decl) 3972 && DECL_UNINLINABLE (decl) 3973 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl))) 3974 warning (0, "inline function %q+D given attribute noinline", decl); 3975 3976 if (context && COMPLETE_TYPE_P (complete_type (context))) 3977 { 3978 if (TREE_CODE (decl) == VAR_DECL) 3979 { 3980 tree field = lookup_field (context, DECL_NAME (decl), 0, false); 3981 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL) 3982 error ("%q#D is not a static member of %q#T", decl, context); 3983 else 3984 { 3985 if (DECL_CONTEXT (field) != context) 3986 { 3987 if (!same_type_p (DECL_CONTEXT (field), context)) 3988 pedwarn ("ISO C++ does not permit %<%T::%D%> " 3989 "to be defined as %<%T::%D%>", 3990 DECL_CONTEXT (field), DECL_NAME (decl), 3991 context, DECL_NAME (decl)); 3992 DECL_CONTEXT (decl) = DECL_CONTEXT (field); 3993 } 3994 if (processing_specialization 3995 && template_class_depth (context) == 0 3996 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context)) 3997 error ("template header not allowed in member definition " 3998 "of explicitly specialized class"); 3999 /* Static data member are tricky; an in-class initialization 4000 still doesn't provide a definition, so the in-class 4001 declaration will have DECL_EXTERNAL set, but will have an 4002 initialization. Thus, duplicate_decls won't warn 4003 about this situation, and so we check here. */ 4004 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field)) 4005 error ("duplicate initialization of %qD", decl); 4006 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false)) 4007 decl = field; 4008 } 4009 } 4010 else 4011 { 4012 tree field = check_classfn (context, decl, 4013 (processing_template_decl 4014 > template_class_depth (context)) 4015 ? current_template_parms 4016 : NULL_TREE); 4017 if (field && duplicate_decls (decl, field, 4018 /*newdecl_is_friend=*/false)) 4019 decl = field; 4020 } 4021 4022 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */ 4023 DECL_IN_AGGR_P (decl) = 0; 4024 /* Do not mark DECL as an explicit specialization if it was not 4025 already marked as an instantiation; a declaration should 4026 never be marked as a specialization unless we know what 4027 template is being specialized. */ 4028 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl)) 4029 { 4030 SET_DECL_TEMPLATE_SPECIALIZATION (decl); 4031 4032 /* [temp.expl.spec] An explicit specialization of a static data 4033 member of a template is a definition if the declaration 4034 includes an initializer; otherwise, it is a declaration. 4035 4036 We check for processing_specialization so this only applies 4037 to the new specialization syntax. */ 4038 if (!initialized && processing_specialization) 4039 DECL_EXTERNAL (decl) = 1; 4040 } 4041 4042 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl)) 4043 pedwarn ("declaration of %q#D outside of class is not definition", 4044 decl); 4045 } 4046 4047 was_public = TREE_PUBLIC (decl); 4048 4049 /* Enter this declaration into the symbol table. */ 4050 tem = maybe_push_decl (decl); 4051 4052 if (processing_template_decl) 4053 tem = push_template_decl (tem); 4054 if (tem == error_mark_node) 4055 return error_mark_node; 4056 4057 /* Tell the back-end to use or not use .common as appropriate. If we say 4058 -fconserve-space, we want this to save .data space, at the expense of 4059 wrong semantics. If we say -fno-conserve-space, we want this to 4060 produce errors about redefs; to do this we force variables into the 4061 data segment. */ 4062 if (flag_conserve_space 4063 && TREE_CODE (tem) == VAR_DECL 4064 && TREE_PUBLIC (tem) 4065 && !DECL_THREAD_LOCAL_P (tem) 4066 && !have_global_bss_p ()) 4067 DECL_COMMON (tem) = 1; 4068 4069 if (TREE_CODE (tem) == VAR_DECL 4070 && DECL_NAMESPACE_SCOPE_P (tem) && !TREE_PUBLIC (tem) && !was_public 4071 && !DECL_THIS_STATIC (tem) && !DECL_ARTIFICIAL (tem)) 4072 { 4073 /* This is a const variable with implicit 'static'. Set 4074 DECL_THIS_STATIC so we can tell it from variables that are 4075 !TREE_PUBLIC because of the anonymous namespace. */ 4076 gcc_assert (cp_type_readonly (TREE_TYPE (tem))); 4077 DECL_THIS_STATIC (tem) = 1; 4078 } 4079 4080 if (!processing_template_decl && TREE_CODE (tem) == VAR_DECL) 4081 start_decl_1 (tem, initialized); 4082 4083 return tem; 4084} 4085 4086void 4087start_decl_1 (tree decl, bool initialized) 4088{ 4089 tree type; 4090 4091 gcc_assert (!processing_template_decl); 4092 4093 if (error_operand_p (decl)) 4094 return; 4095 4096 gcc_assert (TREE_CODE (decl) == VAR_DECL); 4097 type = TREE_TYPE (decl); 4098 4099 if (initialized) 4100 /* Is it valid for this decl to have an initializer at all? 4101 If not, set INITIALIZED to zero, which will indirectly 4102 tell `cp_finish_decl' to ignore the initializer once it is parsed. */ 4103 { 4104 /* Don't allow initializations for incomplete types except for 4105 arrays which might be completed by the initialization. */ 4106 if (COMPLETE_TYPE_P (complete_type (type))) 4107 ; /* A complete type is ok. */ 4108 else if (TREE_CODE (type) != ARRAY_TYPE) 4109 { 4110 error ("variable %q#D has initializer but incomplete type", decl); 4111 initialized = 0; 4112 type = TREE_TYPE (decl) = error_mark_node; 4113 } 4114 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type)))) 4115 { 4116 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)) 4117 error ("elements of array %q#D have incomplete type", decl); 4118 /* else we already gave an error in start_decl. */ 4119 initialized = 0; 4120 } 4121 } 4122 else if (IS_AGGR_TYPE (type) 4123 && ! DECL_EXTERNAL (decl)) 4124 { 4125 if (!COMPLETE_TYPE_P (complete_type (type))) 4126 { 4127 error ("aggregate %q#D has incomplete type and cannot be defined", 4128 decl); 4129 /* Change the type so that assemble_variable will give 4130 DECL an rtl we can live with: (mem (const_int 0)). */ 4131 type = TREE_TYPE (decl) = error_mark_node; 4132 } 4133 else 4134 { 4135 /* If any base type in the hierarchy of TYPE needs a constructor, 4136 then we set initialized to 1. This way any nodes which are 4137 created for the purposes of initializing this aggregate 4138 will live as long as it does. This is necessary for global 4139 aggregates which do not have their initializers processed until 4140 the end of the file. */ 4141 initialized = TYPE_NEEDS_CONSTRUCTING (type); 4142 } 4143 } 4144 4145 /* Create a new scope to hold this declaration if necessary. 4146 Whether or not a new scope is necessary cannot be determined 4147 until after the type has been completed; if the type is a 4148 specialization of a class template it is not until after 4149 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR 4150 will be set correctly. */ 4151 maybe_push_cleanup_level (type); 4152} 4153 4154/* Handle initialization of references. DECL, TYPE, and INIT have the 4155 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry, 4156 but will be set to a new CLEANUP_STMT if a temporary is created 4157 that must be destroyed subsequently. 4158 4159 Returns an initializer expression to use to initialize DECL, or 4160 NULL if the initialization can be performed statically. 4161 4162 Quotes on semantics can be found in ARM 8.4.3. */ 4163 4164static tree 4165grok_reference_init (tree decl, tree type, tree init, tree *cleanup) 4166{ 4167 tree tmp; 4168 4169 if (init == NULL_TREE) 4170 { 4171 if ((DECL_LANG_SPECIFIC (decl) == 0 4172 || DECL_IN_AGGR_P (decl) == 0) 4173 && ! DECL_THIS_EXTERN (decl)) 4174 error ("%qD declared as reference but not initialized", decl); 4175 return NULL_TREE; 4176 } 4177 4178 if (TREE_CODE (init) == CONSTRUCTOR) 4179 { 4180 error ("ISO C++ forbids use of initializer list to " 4181 "initialize reference %qD", decl); 4182 return NULL_TREE; 4183 } 4184 4185 if (TREE_CODE (init) == TREE_LIST) 4186 init = build_x_compound_expr_from_list (init, "initializer"); 4187 4188 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE 4189 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE) 4190 /* Note: default conversion is only called in very special cases. */ 4191 init = decay_conversion (init); 4192 4193 /* Convert INIT to the reference type TYPE. This may involve the 4194 creation of a temporary, whose lifetime must be the same as that 4195 of the reference. If so, a DECL_EXPR for the temporary will be 4196 added just after the DECL_EXPR for DECL. That's why we don't set 4197 DECL_INITIAL for local references (instead assigning to them 4198 explicitly); we need to allow the temporary to be initialized 4199 first. */ 4200 tmp = initialize_reference (type, init, decl, cleanup); 4201 4202 if (tmp == error_mark_node) 4203 return NULL_TREE; 4204 else if (tmp == NULL_TREE) 4205 { 4206 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init)); 4207 return NULL_TREE; 4208 } 4209 4210 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp)) 4211 return tmp; 4212 4213 DECL_INITIAL (decl) = tmp; 4214 4215 return NULL_TREE; 4216} 4217 4218/* Designated initializers in arrays are not supported in GNU C++. 4219 The parser cannot detect this error since it does not know whether 4220 a given brace-enclosed initializer is for a class type or for an 4221 array. This function checks that CE does not use a designated 4222 initializer. If it does, an error is issued. Returns true if CE 4223 is valid, i.e., does not have a designated initializer. */ 4224 4225static bool 4226check_array_designated_initializer (const constructor_elt *ce) 4227{ 4228 /* Designated initializers for array elements arenot supported. */ 4229 if (ce->index) 4230 { 4231 /* The parser only allows identifiers as designated 4232 intializers. */ 4233 gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE); 4234 error ("name %qD used in a GNU-style designated " 4235 "initializer for an array", ce->index); 4236 return false; 4237 } 4238 4239 return true; 4240} 4241 4242/* When parsing `int a[] = {1, 2};' we don't know the size of the 4243 array until we finish parsing the initializer. If that's the 4244 situation we're in, update DECL accordingly. */ 4245 4246static void 4247maybe_deduce_size_from_array_init (tree decl, tree init) 4248{ 4249 tree type = TREE_TYPE (decl); 4250 4251 if (TREE_CODE (type) == ARRAY_TYPE 4252 && TYPE_DOMAIN (type) == NULL_TREE 4253 && TREE_CODE (decl) != TYPE_DECL) 4254 { 4255 /* do_default is really a C-ism to deal with tentative definitions. 4256 But let's leave it here to ease the eventual merge. */ 4257 int do_default = !DECL_EXTERNAL (decl); 4258 tree initializer = init ? init : DECL_INITIAL (decl); 4259 int failure = 0; 4260 4261 /* Check that there are no designated initializers in INIT, as 4262 those are not supported in GNU C++, and as the middle-end 4263 will crash if presented with a non-numeric designated 4264 initializer. */ 4265 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR) 4266 { 4267 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer); 4268 constructor_elt *ce; 4269 HOST_WIDE_INT i; 4270 for (i = 0; 4271 VEC_iterate (constructor_elt, v, i, ce); 4272 ++i) 4273 if (!check_array_designated_initializer (ce)) 4274 failure = 1; 4275 } 4276 4277 if (!failure) 4278 { 4279 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer, 4280 do_default); 4281 if (failure == 1) 4282 { 4283 error ("initializer fails to determine size of %qD", decl); 4284 TREE_TYPE (decl) = error_mark_node; 4285 } 4286 else if (failure == 2) 4287 { 4288 if (do_default) 4289 { 4290 error ("array size missing in %qD", decl); 4291 TREE_TYPE (decl) = error_mark_node; 4292 } 4293 /* If a `static' var's size isn't known, make it extern as 4294 well as static, so it does not get allocated. If it's not 4295 `static', then don't mark it extern; finish_incomplete_decl 4296 will give it a default size and it will get allocated. */ 4297 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl)) 4298 DECL_EXTERNAL (decl) = 1; 4299 } 4300 else if (failure == 3) 4301 { 4302 error ("zero-size array %qD", decl); 4303 TREE_TYPE (decl) = error_mark_node; 4304 } 4305 } 4306 4307 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl); 4308 4309 layout_decl (decl, 0); 4310 } 4311} 4312 4313/* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue 4314 any appropriate error messages regarding the layout. */ 4315 4316static void 4317layout_var_decl (tree decl) 4318{ 4319 tree type; 4320 4321 type = TREE_TYPE (decl); 4322 if (type == error_mark_node) 4323 return; 4324 4325 /* If we haven't already layed out this declaration, do so now. 4326 Note that we must not call complete type for an external object 4327 because it's type might involve templates that we are not 4328 supposed to instantiate yet. (And it's perfectly valid to say 4329 `extern X x' for some incomplete type `X'.) */ 4330 if (!DECL_EXTERNAL (decl)) 4331 complete_type (type); 4332 if (!DECL_SIZE (decl) 4333 && TREE_TYPE (decl) != error_mark_node 4334 && (COMPLETE_TYPE_P (type) 4335 || (TREE_CODE (type) == ARRAY_TYPE 4336 && !TYPE_DOMAIN (type) 4337 && COMPLETE_TYPE_P (TREE_TYPE (type))))) 4338 layout_decl (decl, 0); 4339 4340 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE) 4341 { 4342 /* An automatic variable with an incomplete type: that is an error. 4343 Don't talk about array types here, since we took care of that 4344 message in grokdeclarator. */ 4345 error ("storage size of %qD isn't known", decl); 4346 TREE_TYPE (decl) = error_mark_node; 4347 } 4348#if 0 4349 /* Keep this code around in case we later want to control debug info 4350 based on whether a type is "used". (jason 1999-11-11) */ 4351 4352 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype)) 4353 /* Let debugger know it should output info for this type. */ 4354 note_debug_info_needed (ttype); 4355 4356 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl)) 4357 note_debug_info_needed (DECL_CONTEXT (decl)); 4358#endif 4359 4360 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl)) 4361 && DECL_SIZE (decl) != NULL_TREE 4362 && ! TREE_CONSTANT (DECL_SIZE (decl))) 4363 { 4364 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST) 4365 constant_expression_warning (DECL_SIZE (decl)); 4366 else 4367 error ("storage size of %qD isn't constant", decl); 4368 } 4369} 4370 4371/* If a local static variable is declared in an inline function, or if 4372 we have a weak definition, we must endeavor to create only one 4373 instance of the variable at link-time. */ 4374 4375static void 4376maybe_commonize_var (tree decl) 4377{ 4378 /* Static data in a function with comdat linkage also has comdat 4379 linkage. */ 4380 if (TREE_STATIC (decl) 4381 /* Don't mess with __FUNCTION__. */ 4382 && ! DECL_ARTIFICIAL (decl) 4383 && DECL_FUNCTION_SCOPE_P (decl) 4384 /* Unfortunately, import_export_decl has not always been called 4385 before the function is processed, so we cannot simply check 4386 DECL_COMDAT. */ 4387 && (DECL_COMDAT (DECL_CONTEXT (decl)) 4388 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl)) 4389 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl))) 4390 && TREE_PUBLIC (DECL_CONTEXT (decl))))) 4391 { 4392 if (flag_weak) 4393 { 4394 /* With weak symbols, we simply make the variable COMDAT; 4395 that will cause copies in multiple translations units to 4396 be merged. */ 4397 comdat_linkage (decl); 4398 } 4399 else 4400 { 4401 if (DECL_INITIAL (decl) == NULL_TREE 4402 || DECL_INITIAL (decl) == error_mark_node) 4403 { 4404 /* Without weak symbols, we can use COMMON to merge 4405 uninitialized variables. */ 4406 TREE_PUBLIC (decl) = 1; 4407 DECL_COMMON (decl) = 1; 4408 } 4409 else 4410 { 4411 /* While for initialized variables, we must use internal 4412 linkage -- which means that multiple copies will not 4413 be merged. */ 4414 TREE_PUBLIC (decl) = 0; 4415 DECL_COMMON (decl) = 0; 4416 warning (0, "sorry: semantics of inline function static " 4417 "data %q+#D are wrong (you'll wind up " 4418 "with multiple copies)", decl); 4419 warning (0, "%J you can work around this by removing " 4420 "the initializer", 4421 decl); 4422 } 4423 } 4424 } 4425 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl)) 4426 /* Set it up again; we might have set DECL_INITIAL since the last 4427 time. */ 4428 comdat_linkage (decl); 4429} 4430 4431/* Issue an error message if DECL is an uninitialized const variable. */ 4432 4433static void 4434check_for_uninitialized_const_var (tree decl) 4435{ 4436 tree type = TREE_TYPE (decl); 4437 4438 /* ``Unless explicitly declared extern, a const object does not have 4439 external linkage and must be initialized. ($8.4; $12.1)'' ARM 4440 7.1.6 */ 4441 if (TREE_CODE (decl) == VAR_DECL 4442 && TREE_CODE (type) != REFERENCE_TYPE 4443 && CP_TYPE_CONST_P (type) 4444 && !TYPE_NEEDS_CONSTRUCTING (type) 4445 && !DECL_INITIAL (decl)) 4446 error ("uninitialized const %qD", decl); 4447} 4448 4449 4450/* Structure holding the current initializer being processed by reshape_init. 4451 CUR is a pointer to the current element being processed, END is a pointer 4452 after the last element present in the initializer. */ 4453typedef struct reshape_iterator_t 4454{ 4455 constructor_elt *cur; 4456 constructor_elt *end; 4457} reshape_iter; 4458 4459static tree reshape_init_r (tree, reshape_iter *, bool); 4460 4461/* FIELD is a FIELD_DECL or NULL. In the former case, the value 4462 returned is the next FIELD_DECL (possibly FIELD itself) that can be 4463 initialized. If there are no more such fields, the return value 4464 will be NULL. */ 4465 4466static tree 4467next_initializable_field (tree field) 4468{ 4469 while (field 4470 && (TREE_CODE (field) != FIELD_DECL 4471 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field)) 4472 || DECL_ARTIFICIAL (field))) 4473 field = TREE_CHAIN (field); 4474 4475 return field; 4476} 4477 4478/* Subroutine of reshape_init_array and reshape_init_vector, which does 4479 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an 4480 INTEGER_CST representing the size of the array minus one (the maximum index), 4481 or NULL_TREE if the array was declared without specifying the size. D is 4482 the iterator within the constructor. */ 4483 4484static tree 4485reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d) 4486{ 4487 tree new_init; 4488 bool sized_array_p = (max_index != NULL_TREE); 4489 unsigned HOST_WIDE_INT max_index_cst = 0; 4490 unsigned HOST_WIDE_INT index; 4491 4492 /* The initializer for an array is always a CONSTRUCTOR. */ 4493 new_init = build_constructor (NULL_TREE, NULL); 4494 4495 if (sized_array_p) 4496 { 4497 /* Minus 1 is used for zero sized arrays. */ 4498 if (integer_all_onesp (max_index)) 4499 return new_init; 4500 4501 if (host_integerp (max_index, 1)) 4502 max_index_cst = tree_low_cst (max_index, 1); 4503 /* sizetype is sign extended, not zero extended. */ 4504 else 4505 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index), 4506 1); 4507 } 4508 4509 /* Loop until there are no more initializers. */ 4510 for (index = 0; 4511 d->cur != d->end && (!sized_array_p || index <= max_index_cst); 4512 ++index) 4513 { 4514 tree elt_init; 4515 4516 check_array_designated_initializer (d->cur); 4517 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false); 4518 if (elt_init == error_mark_node) 4519 return error_mark_node; 4520 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init); 4521 } 4522 4523 return new_init; 4524} 4525 4526/* Subroutine of reshape_init_r, processes the initializers for arrays. 4527 Parameters are the same of reshape_init_r. */ 4528 4529static tree 4530reshape_init_array (tree type, reshape_iter *d) 4531{ 4532 tree max_index = NULL_TREE; 4533 4534 gcc_assert (TREE_CODE (type) == ARRAY_TYPE); 4535 4536 if (TYPE_DOMAIN (type)) 4537 max_index = array_type_nelts (type); 4538 4539 return reshape_init_array_1 (TREE_TYPE (type), max_index, d); 4540} 4541 4542/* Subroutine of reshape_init_r, processes the initializers for vectors. 4543 Parameters are the same of reshape_init_r. */ 4544 4545static tree 4546reshape_init_vector (tree type, reshape_iter *d) 4547{ 4548 tree max_index = NULL_TREE; 4549 tree rtype; 4550 4551 gcc_assert (TREE_CODE (type) == VECTOR_TYPE); 4552 4553 if (COMPOUND_LITERAL_P (d->cur->value)) 4554 { 4555 tree value = d->cur->value; 4556 if (!same_type_p (TREE_TYPE (value), type)) 4557 { 4558 error ("invalid type %qT as initializer for a vector of type %qT", 4559 TREE_TYPE (d->cur->value), type); 4560 value = error_mark_node; 4561 } 4562 ++d->cur; 4563 return value; 4564 } 4565 4566 /* For a vector, the representation type is a struct 4567 containing a single member which is an array of the 4568 appropriate size. */ 4569 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type); 4570 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype)))) 4571 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype))); 4572 4573 return reshape_init_array_1 (TREE_TYPE (type), max_index, d); 4574} 4575 4576/* Subroutine of reshape_init_r, processes the initializers for classes 4577 or union. Parameters are the same of reshape_init_r. */ 4578 4579static tree 4580reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p) 4581{ 4582 tree field; 4583 tree new_init; 4584 4585 gcc_assert (CLASS_TYPE_P (type)); 4586 4587 /* The initializer for a class is always a CONSTRUCTOR. */ 4588 new_init = build_constructor (NULL_TREE, NULL); 4589 field = next_initializable_field (TYPE_FIELDS (type)); 4590 4591 if (!field) 4592 { 4593 /* [dcl.init.aggr] 4594 4595 An initializer for an aggregate member that is an 4596 empty class shall have the form of an empty 4597 initializer-list {}. */ 4598 if (!first_initializer_p) 4599 { 4600 error ("initializer for %qT must be brace-enclosed", type); 4601 return error_mark_node; 4602 } 4603 return new_init; 4604 } 4605 4606 /* Loop through the initializable fields, gathering initializers. */ 4607 while (d->cur != d->end) 4608 { 4609 tree field_init; 4610 4611 /* Handle designated initializers, as an extension. */ 4612 if (d->cur->index) 4613 { 4614 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false); 4615 4616 if (!field || TREE_CODE (field) != FIELD_DECL) 4617 { 4618 error ("%qT has no non-static data member named %qD", type, 4619 d->cur->index); 4620 return error_mark_node; 4621 } 4622 } 4623 4624 /* If we processed all the member of the class, we are done. */ 4625 if (!field) 4626 break; 4627 4628 field_init = reshape_init_r (TREE_TYPE (field), d, 4629 /*first_initializer_p=*/false); 4630 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init); 4631 4632 /* [dcl.init.aggr] 4633 4634 When a union is initialized with a brace-enclosed 4635 initializer, the braces shall only contain an 4636 initializer for the first member of the union. */ 4637 if (TREE_CODE (type) == UNION_TYPE) 4638 break; 4639 4640 field = next_initializable_field (TREE_CHAIN (field)); 4641 } 4642 4643 return new_init; 4644} 4645 4646/* Subroutine of reshape_init, which processes a single initializer (part of 4647 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the 4648 iterator within the CONSTRUCTOR which points to the initializer to process. 4649 FIRST_INITIALIZER_P is true if this is the first initializer of the 4650 CONSTRUCTOR node. */ 4651 4652static tree 4653reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p) 4654{ 4655 tree init = d->cur->value; 4656 4657 /* A non-aggregate type is always initialized with a single 4658 initializer. */ 4659 if (!CP_AGGREGATE_TYPE_P (type)) 4660 { 4661 /* It is invalid to initialize a non-aggregate type with a 4662 brace-enclosed initializer. 4663 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because 4664 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is 4665 a CONSTRUCTOR (with a record type). */ 4666 if (TREE_CODE (init) == CONSTRUCTOR 4667 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */ 4668 { 4669 error ("braces around scalar initializer for type %qT", type); 4670 init = error_mark_node; 4671 } 4672 4673 d->cur++; 4674 return init; 4675 } 4676 4677 /* [dcl.init.aggr] 4678 4679 All implicit type conversions (clause _conv_) are considered when 4680 initializing the aggregate member with an initializer from an 4681 initializer-list. If the initializer can initialize a member, 4682 the member is initialized. Otherwise, if the member is itself a 4683 non-empty subaggregate, brace elision is assumed and the 4684 initializer is considered for the initialization of the first 4685 member of the subaggregate. */ 4686 if (TREE_CODE (init) != CONSTRUCTOR 4687 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL)) 4688 { 4689 d->cur++; 4690 return init; 4691 } 4692 4693 /* [dcl.init.string] 4694 4695 A char array (whether plain char, signed char, or unsigned char) 4696 can be initialized by a string-literal (optionally enclosed in 4697 braces); a wchar_t array can be initialized by a wide 4698 string-literal (optionally enclosed in braces). */ 4699 if (TREE_CODE (type) == ARRAY_TYPE 4700 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))) 4701 { 4702 tree str_init = init; 4703 4704 /* Strip one level of braces if and only if they enclose a single 4705 element (as allowed by [dcl.init.string]). */ 4706 if (!first_initializer_p 4707 && TREE_CODE (str_init) == CONSTRUCTOR 4708 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1) 4709 { 4710 str_init = VEC_index (constructor_elt, 4711 CONSTRUCTOR_ELTS (str_init), 0)->value; 4712 } 4713 4714 /* If it's a string literal, then it's the initializer for the array 4715 as a whole. Otherwise, continue with normal initialization for 4716 array types (one value per array element). */ 4717 if (TREE_CODE (str_init) == STRING_CST) 4718 { 4719 d->cur++; 4720 return str_init; 4721 } 4722 } 4723 4724 /* The following cases are about aggregates. If we are not within a full 4725 initializer already, and there is not a CONSTRUCTOR, it means that there 4726 is a missing set of braces (that is, we are processing the case for 4727 which reshape_init exists). */ 4728 if (!first_initializer_p) 4729 { 4730 if (TREE_CODE (init) == CONSTRUCTOR) 4731 { 4732 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init))) 4733 /* There is no need to reshape pointer-to-member function 4734 initializers, as they are always constructed correctly 4735 by the front end. */ 4736 ; 4737 else if (COMPOUND_LITERAL_P (init)) 4738 /* For a nested compound literal, there is no need to reshape since 4739 brace elision is not allowed. Even if we decided to allow it, 4740 we should add a call to reshape_init in finish_compound_literal, 4741 before calling digest_init, so changing this code would still 4742 not be necessary. */ 4743 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init)); 4744 else 4745 { 4746 ++d->cur; 4747 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init)); 4748 return reshape_init (type, init); 4749 } 4750 } 4751 4752 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT", 4753 type); 4754 } 4755 4756 /* Dispatch to specialized routines. */ 4757 if (CLASS_TYPE_P (type)) 4758 return reshape_init_class (type, d, first_initializer_p); 4759 else if (TREE_CODE (type) == ARRAY_TYPE) 4760 return reshape_init_array (type, d); 4761 else if (TREE_CODE (type) == VECTOR_TYPE) 4762 return reshape_init_vector (type, d); 4763 else 4764 gcc_unreachable(); 4765} 4766 4767/* Undo the brace-elision allowed by [dcl.init.aggr] in a 4768 brace-enclosed aggregate initializer. 4769 4770 INIT is the CONSTRUCTOR containing the list of initializers describing 4771 a brace-enclosed initializer for an entity of the indicated aggregate TYPE. 4772 It may not presently match the shape of the TYPE; for example: 4773 4774 struct S { int a; int b; }; 4775 struct S a[] = { 1, 2, 3, 4 }; 4776 4777 Here INIT will hold a VEC of four elements, rather than a 4778 VEC of two elements, each itself a VEC of two elements. This 4779 routine transforms INIT from the former form into the latter. The 4780 revised CONSTRUCTOR node is returned. */ 4781 4782tree 4783reshape_init (tree type, tree init) 4784{ 4785 VEC(constructor_elt, gc) *v; 4786 reshape_iter d; 4787 tree new_init; 4788 4789 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init)); 4790 4791 v = CONSTRUCTOR_ELTS (init); 4792 4793 /* An empty constructor does not need reshaping, and it is always a valid 4794 initializer. */ 4795 if (VEC_empty (constructor_elt, v)) 4796 return init; 4797 4798 /* Recurse on this CONSTRUCTOR. */ 4799 d.cur = VEC_index (constructor_elt, v, 0); 4800 d.end = d.cur + VEC_length (constructor_elt, v); 4801 4802 new_init = reshape_init_r (type, &d, true); 4803 if (new_init == error_mark_node) 4804 return error_mark_node; 4805 4806 /* Make sure all the element of the constructor were used. Otherwise, 4807 issue an error about exceeding initializers. */ 4808 if (d.cur != d.end) 4809 error ("too many initializers for %qT", type); 4810 4811 return new_init; 4812} 4813 4814/* Verify INIT (the initializer for DECL), and record the 4815 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for 4816 grok_reference_init. 4817 4818 If the return value is non-NULL, it is an expression that must be 4819 evaluated dynamically to initialize DECL. */ 4820 4821static tree 4822check_initializer (tree decl, tree init, int flags, tree *cleanup) 4823{ 4824 tree type = TREE_TYPE (decl); 4825 tree init_code = NULL; 4826 4827 /* Things that are going to be initialized need to have complete 4828 type. */ 4829 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl)); 4830 4831 if (type == error_mark_node) 4832 /* We will have already complained. */ 4833 return NULL_TREE; 4834 4835 if (TREE_CODE (type) == ARRAY_TYPE) 4836 { 4837 tree element_type = TREE_TYPE (type); 4838 4839 /* The array type itself need not be complete, because the 4840 initializer may tell us how many elements are in the array. 4841 But, the elements of the array must be complete. */ 4842 if (!COMPLETE_TYPE_P (complete_type (element_type))) 4843 { 4844 error ("elements of array %q#D have incomplete type", decl); 4845 return NULL_TREE; 4846 } 4847 /* It is not valid to initialize an a VLA. */ 4848 if (init 4849 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type))) 4850 || !TREE_CONSTANT (TYPE_SIZE (element_type)))) 4851 { 4852 error ("variable-sized object %qD may not be initialized", decl); 4853 return NULL_TREE; 4854 } 4855 } 4856 else if (!COMPLETE_TYPE_P (type)) 4857 { 4858 error ("%qD has incomplete type", decl); 4859 TREE_TYPE (decl) = error_mark_node; 4860 return NULL_TREE; 4861 } 4862 else 4863 /* There is no way to make a variable-sized class type in GNU C++. */ 4864 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type))); 4865 4866 if (!CP_AGGREGATE_TYPE_P (type) 4867 && init && BRACE_ENCLOSED_INITIALIZER_P (init) 4868 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)) != 1) 4869 { 4870 error ("scalar object %qD requires one element in initializer", decl); 4871 TREE_TYPE (decl) = error_mark_node; 4872 return NULL_TREE; 4873 } 4874 4875 if (TREE_CODE (decl) == CONST_DECL) 4876 { 4877 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE); 4878 4879 DECL_INITIAL (decl) = init; 4880 4881 gcc_assert (init != NULL_TREE); 4882 init = NULL_TREE; 4883 } 4884 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE) 4885 init = grok_reference_init (decl, type, init, cleanup); 4886 else if (init) 4887 { 4888 /* Do not reshape constructors of vectors (they don't need to be 4889 reshaped. */ 4890 if (TREE_CODE (init) == CONSTRUCTOR 4891 && !COMPOUND_LITERAL_P (init) 4892 && !TREE_TYPE (init)) /* ptrmemfunc */ 4893 { 4894 init = reshape_init (type, init); 4895 4896 if ((*targetm.vector_opaque_p) (type)) 4897 { 4898 error ("opaque vector types cannot be initialized"); 4899 init = error_mark_node; 4900 } 4901 } 4902 4903 /* If DECL has an array type without a specific bound, deduce the 4904 array size from the initializer. */ 4905 maybe_deduce_size_from_array_init (decl, init); 4906 type = TREE_TYPE (decl); 4907 if (type == error_mark_node) 4908 return NULL_TREE; 4909 4910 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type)) 4911 { 4912 if (TREE_CODE (type) == ARRAY_TYPE) 4913 goto initialize_aggr; 4914 else if (TREE_CODE (init) == CONSTRUCTOR) 4915 { 4916 if (TYPE_NON_AGGREGATE_CLASS (type)) 4917 { 4918 error ("%qD must be initialized by constructor, " 4919 "not by %<{...}%>", 4920 decl); 4921 init = error_mark_node; 4922 } 4923 else 4924 goto dont_use_constructor; 4925 } 4926 else 4927 { 4928 int saved_stmts_are_full_exprs_p; 4929 4930 initialize_aggr: 4931 saved_stmts_are_full_exprs_p = 0; 4932 if (building_stmt_tree ()) 4933 { 4934 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p (); 4935 current_stmt_tree ()->stmts_are_full_exprs_p = 1; 4936 } 4937 init = build_aggr_init (decl, init, flags); 4938 if (building_stmt_tree ()) 4939 current_stmt_tree ()->stmts_are_full_exprs_p = 4940 saved_stmts_are_full_exprs_p; 4941 return init; 4942 } 4943 } 4944 else 4945 { 4946 dont_use_constructor: 4947 if (TREE_CODE (init) != TREE_VEC) 4948 { 4949 init_code = store_init_value (decl, init); 4950 if (pedantic && TREE_CODE (type) == ARRAY_TYPE 4951 && DECL_INITIAL (decl) 4952 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST 4953 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl))) 4954 warning (0, "array %qD initialized by parenthesized string literal %qE", 4955 decl, DECL_INITIAL (decl)); 4956 init = NULL; 4957 } 4958 } 4959 } 4960 else if (DECL_EXTERNAL (decl)) 4961 ; 4962 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type)) 4963 goto initialize_aggr; 4964 else if (IS_AGGR_TYPE (type)) 4965 { 4966 tree core_type = strip_array_types (type); 4967 4968 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)) 4969 error ("structure %qD with uninitialized const members", decl); 4970 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)) 4971 error ("structure %qD with uninitialized reference members", decl); 4972 4973 check_for_uninitialized_const_var (decl); 4974 } 4975 else 4976 check_for_uninitialized_const_var (decl); 4977 4978 if (init && init != error_mark_node) 4979 init_code = build2 (INIT_EXPR, type, decl, init); 4980 4981 return init_code; 4982} 4983 4984/* If DECL is not a local variable, give it RTL. */ 4985 4986static void 4987make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec) 4988{ 4989 int toplev = toplevel_bindings_p (); 4990 int defer_p; 4991 const char *filename; 4992 4993 /* Set the DECL_ASSEMBLER_NAME for the object. */ 4994 if (asmspec) 4995 { 4996 /* The `register' keyword, when used together with an 4997 asm-specification, indicates that the variable should be 4998 placed in a particular register. */ 4999 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)) 5000 { 5001 set_user_assembler_name (decl, asmspec); 5002 DECL_HARD_REGISTER (decl) = 1; 5003 } 5004 else 5005 { 5006 if (TREE_CODE (decl) == FUNCTION_DECL 5007 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL) 5008 set_builtin_user_assembler_name (decl, asmspec); 5009 set_user_assembler_name (decl, asmspec); 5010 } 5011 } 5012 5013 /* Handle non-variables up front. */ 5014 if (TREE_CODE (decl) != VAR_DECL) 5015 { 5016 rest_of_decl_compilation (decl, toplev, at_eof); 5017 return; 5018 } 5019 5020 /* If we see a class member here, it should be a static data 5021 member. */ 5022 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl)) 5023 { 5024 gcc_assert (TREE_STATIC (decl)); 5025 /* APPLE LOCAL begin templated static data 6298605 */ 5026 /* An in-class declaration of a static data member should be 5027 external if the decl is accessible from outside this 5028 translation unit (eg something not in an anonymous 5029 namespace); it is only a declaration, and not a 5030 definition. */ 5031 if (init == NULL_TREE && TREE_PUBLIC (decl)) 5032 gcc_assert (DECL_EXTERNAL (decl)); 5033 /* APPLE LOCAL end templated static data 6298605 */ 5034 } 5035 5036 /* We don't create any RTL for local variables. */ 5037 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl)) 5038 return; 5039 5040 /* We defer emission of local statics until the corresponding 5041 DECL_EXPR is expanded. */ 5042 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl); 5043 5044 /* We try to defer namespace-scope static constants so that they are 5045 not emitted into the object file unnecessarily. */ 5046 filename = input_filename; 5047 if (!DECL_VIRTUAL_P (decl) 5048 && TREE_READONLY (decl) 5049 && DECL_INITIAL (decl) != NULL_TREE 5050 && DECL_INITIAL (decl) != error_mark_node 5051 && filename != NULL 5052 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)) 5053 && toplev 5054 && !TREE_PUBLIC (decl)) 5055 { 5056 /* Fool with the linkage of static consts according to #pragma 5057 interface. */ 5058 struct c_fileinfo *finfo = get_fileinfo (filename); 5059 if (!finfo->interface_unknown && !TREE_PUBLIC (decl)) 5060 { 5061 TREE_PUBLIC (decl) = 1; 5062 DECL_EXTERNAL (decl) = finfo->interface_only; 5063 } 5064 5065 defer_p = 1; 5066 } 5067 /* Likewise for template instantiations. */ 5068 else if (DECL_LANG_SPECIFIC (decl) 5069 && DECL_IMPLICIT_INSTANTIATION (decl)) 5070 defer_p = 1; 5071 5072 /* If we're not deferring, go ahead and assemble the variable. */ 5073 if (!defer_p) 5074 rest_of_decl_compilation (decl, toplev, at_eof); 5075} 5076 5077/* Generate code to initialize DECL (a local variable). */ 5078 5079static void 5080initialize_local_var (tree decl, tree init) 5081{ 5082 tree type = TREE_TYPE (decl); 5083 tree cleanup; 5084 5085 gcc_assert (TREE_CODE (decl) == VAR_DECL 5086 || TREE_CODE (decl) == RESULT_DECL); 5087 gcc_assert (!TREE_STATIC (decl)); 5088 5089 if (DECL_SIZE (decl) == NULL_TREE) 5090 { 5091 /* If we used it already as memory, it must stay in memory. */ 5092 DECL_INITIAL (decl) = NULL_TREE; 5093 TREE_ADDRESSABLE (decl) = TREE_USED (decl); 5094 } 5095 5096 if (DECL_SIZE (decl) && type != error_mark_node) 5097 { 5098 int already_used; 5099 5100 /* Compute and store the initial value. */ 5101 already_used = TREE_USED (decl) || TREE_USED (type); 5102 5103 /* Perform the initialization. */ 5104 if (init) 5105 { 5106 int saved_stmts_are_full_exprs_p; 5107 5108 gcc_assert (building_stmt_tree ()); 5109 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p (); 5110 current_stmt_tree ()->stmts_are_full_exprs_p = 1; 5111 finish_expr_stmt (init); 5112 current_stmt_tree ()->stmts_are_full_exprs_p = 5113 saved_stmts_are_full_exprs_p; 5114 } 5115 5116 /* Set this to 0 so we can tell whether an aggregate which was 5117 initialized was ever used. Don't do this if it has a 5118 destructor, so we don't complain about the 'resource 5119 allocation is initialization' idiom. Now set 5120 attribute((unused)) on types so decls of that type will be 5121 marked used. (see TREE_USED, above.) */ 5122 if (TYPE_NEEDS_CONSTRUCTING (type) 5123 && ! already_used 5124 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type) 5125 && DECL_NAME (decl)) 5126 TREE_USED (decl) = 0; 5127 else if (already_used) 5128 TREE_USED (decl) = 1; 5129 } 5130 5131 /* Generate a cleanup, if necessary. */ 5132 cleanup = cxx_maybe_build_cleanup (decl); 5133 if (DECL_SIZE (decl) && cleanup) 5134 finish_decl_cleanup (decl, cleanup); 5135} 5136 5137/* DECL is a VAR_DECL for a compiler-generated variable with static 5138 storage duration (like a virtual table) whose initializer is a 5139 compile-time constant. INIT must be either a TREE_LIST of values, 5140 or a CONSTRUCTOR. Initialize the variable and provide it to the 5141 back end. */ 5142 5143void 5144initialize_artificial_var (tree decl, tree init) 5145{ 5146 gcc_assert (DECL_ARTIFICIAL (decl)); 5147 if (TREE_CODE (init) == TREE_LIST) 5148 init = build_constructor_from_list (NULL_TREE, init); 5149 gcc_assert (TREE_CODE (init) == CONSTRUCTOR); 5150 DECL_INITIAL (decl) = init; 5151 DECL_INITIALIZED_P (decl) = 1; 5152 determine_visibility (decl); 5153 layout_var_decl (decl); 5154 maybe_commonize_var (decl); 5155 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL); 5156} 5157 5158/* INIT is the initializer for a variable, as represented by the 5159 parser. Returns true iff INIT is value-dependent. */ 5160 5161static bool 5162value_dependent_init_p (tree init) 5163{ 5164 if (TREE_CODE (init) == TREE_LIST) 5165 /* A parenthesized initializer, e.g.: int i (3, 2); ? */ 5166 return any_value_dependent_elements_p (init); 5167 else if (TREE_CODE (init) == CONSTRUCTOR) 5168 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */ 5169 { 5170 VEC(constructor_elt, gc) *elts; 5171 size_t nelts; 5172 size_t i; 5173 5174 elts = CONSTRUCTOR_ELTS (init); 5175 nelts = VEC_length (constructor_elt, elts); 5176 for (i = 0; i < nelts; ++i) 5177 if (value_dependent_init_p (VEC_index (constructor_elt, 5178 elts, i)->value)) 5179 return true; 5180 } 5181 else 5182 /* It must be a simple expression, e.g., int i = 3; */ 5183 return value_dependent_expression_p (init); 5184 5185 return false; 5186} 5187 5188/* APPLE LOCAL begin blocks 6040305 (cr) */ 5189#define BLOCK_ALIGN_MAX 18 5190static tree block_byref_id_object_copy[BLOCK_BYREF_CURRENT_MAX*(BLOCK_ALIGN_MAX+1)]; 5191static tree block_byref_id_object_dispose[BLOCK_BYREF_CURRENT_MAX*(BLOCK_ALIGN_MAX+1)]; 5192 5193/** 5194 This routine builds: 5195 5196 void __Block_byref_id_object_copy(struct Block_byref_id_object *dst, 5197 struct Block_byref_id_object *src) { 5198 _Block_object_assign (&_dest->object, _src->object, BLOCK_FIELD_IS_OBJECT[|BLOCK_FIELD_IS_WEAK]) // objects 5199 _Block_object_assign(&_dest->object, _src->object, BLOCK_FIELD_IS_BLOCK[|BLOCK_FIELD_IS_WEAK]) // blocks 5200 } */ 5201static void 5202synth_block_byref_id_object_copy_func (int flag, int kind) 5203{ 5204 tree stmt; 5205 tree dst_arg, src_arg; 5206 tree dst_obj, src_obj; 5207 tree call_exp; 5208 5209 gcc_assert (block_byref_id_object_copy[kind]); 5210 /* Set up: (void* _dest, void*_src) parameters. */ 5211 dst_arg = build_decl (PARM_DECL, get_identifier ("_dst"), 5212 ptr_type_node); 5213 TREE_USED (dst_arg) = 1; 5214 DECL_ARG_TYPE (dst_arg) = ptr_type_node; 5215 src_arg = build_decl (PARM_DECL, get_identifier ("_src"), 5216 ptr_type_node); 5217 TREE_USED (src_arg) = 1; 5218 DECL_ARG_TYPE (src_arg) = ptr_type_node; 5219 /* arg_info = xcalloc (1, sizeof (struct c_arg_info)); */ 5220 TREE_CHAIN (dst_arg) = src_arg; 5221 /* arg_info->parms = dst_arg; */ 5222 /* arg_info->types = tree_cons (NULL_TREE, ptr_type_node, 5223 tree_cons (NULL_TREE, 5224 ptr_type_node, 5225 NULL_TREE)); */ 5226 DECL_ARGUMENTS (block_byref_id_object_copy[kind]) = dst_arg; 5227 /* function header synthesis. */ 5228 push_function_context (); 5229 /* start_block_helper_function (block_byref_id_object_copy[kind], true); */ 5230 /* store_parm_decls_from (arg_info); */ 5231 start_preparsed_function (block_byref_id_object_copy[kind], 5232 /*attrs*/NULL_TREE, 5233 SF_PRE_PARSED); 5234 5235 /* Body of the function. */ 5236 stmt = begin_compound_stmt (BCS_FN_BODY); 5237 /* Build dst->object */ 5238 dst_obj = build_indirect_object_id_exp (dst_arg); 5239 5240 5241 /* src_obj is: _src->object. */ 5242 src_obj = build_indirect_object_id_exp (src_arg); 5243 /* APPLE LOCAL begin radar 6180456 */ 5244 /* _Block_object_assign (&_dest->object, _src->object, BLOCK_FIELD_IS_OBJECT) or: 5245 _Block_object_assign (&_dest->object, _src->object, BLOCK_FIELD_IS_BLOCK) */ 5246 /* APPLE LOCAL begin radar 6573923 */ 5247 /* Also add the new flag when calling _Block_object_dispose 5248 from byref dispose helper. */ 5249 flag |= BLOCK_BYREF_CALLER; 5250 /* APPLE LOCAL end radar 6573923 */ 5251 call_exp = build_block_object_assign_call_exp (build_fold_addr_expr (dst_obj), src_obj, flag); 5252 add_stmt (call_exp); 5253 /* APPLE LOCAL end radar 6180456 */ 5254 5255 finish_compound_stmt (stmt); 5256 /* APPLE LOCAL radar 6169580 */ 5257 finish_function (4); 5258 pop_function_context (); 5259} 5260 5261/** 5262 This routine builds: 5263 5264 void __Block_byref_id_object_dispose(struct Block_byref_id_object *_src) { 5265 _Block_object_dispose(_src->object, BLOCK_FIELD_IS_OBJECT[|BLOCK_FIELD_IS_WEAK]) // objects 5266 _Block_object_dispose(_src->object, BLOCK_FIELD_IS_BLOCK[|BLOCK_FIELD_IS_WEAK]) // blocks 5267 } */ 5268static void synth_block_byref_id_object_dispose_func (int flag, int kind) 5269{ 5270 tree stmt; 5271 tree src_arg, src_obj, rel_exp; 5272 5273 gcc_assert (block_byref_id_object_dispose[kind]); 5274 /* Set up: (void *_src) parameter. */ 5275 src_arg = build_decl (PARM_DECL, get_identifier ("_src"), 5276 ptr_type_node); 5277 TREE_USED (src_arg) = 1; 5278 DECL_ARG_TYPE (src_arg) = ptr_type_node; 5279 /* arg_info = xcalloc (1, sizeof (struct c_arg_info)); 5280 arg_info->parms = src_arg; 5281 arg_info->types = tree_cons (NULL_TREE, ptr_type_node, 5282 NULL_TREE); */ 5283 DECL_ARGUMENTS (block_byref_id_object_dispose[kind]) = src_arg; 5284 /* function header synthesis. */ 5285 push_function_context (); 5286 /* start_block_helper_function (block_byref_id_object_dispose[kind], true); */ 5287 /* store_parm_decls_from (arg_info); */ 5288 start_preparsed_function (block_byref_id_object_dispose[kind], 5289 /*attrs*/NULL_TREE, 5290 SF_PRE_PARSED); 5291 5292 /* Body of the function. */ 5293 stmt = begin_compound_stmt (BCS_FN_BODY); 5294 src_obj = build_indirect_object_id_exp (src_arg); 5295 5296 /* APPLE LOCAL begin radar 6180456 */ 5297 /* _Block_object_dispose(_src->object, BLOCK_FIELD_IS_OBJECT) or: 5298 _Block_object_dispose(_src->object, BLOCK_FIELD_IS_BLOCK) */ 5299 /* APPLE LOCAL begin radar 6573923 */ 5300 /* Also add the new flag when calling _Block_object_dispose 5301 from byref dispose helper. */ 5302 flag |= BLOCK_BYREF_CALLER; 5303 /* APPLE LOCAL end radar 6573923 */ 5304 rel_exp = build_block_object_dispose_call_exp (src_obj, flag); 5305 /* APPLE LOCAL end radar 6180456 */ 5306 add_stmt (rel_exp); 5307 5308 finish_compound_stmt (stmt); 5309 /* APPLE LOCAL radar 6169580 */ 5310 finish_function (4); 5311 pop_function_context (); 5312} 5313 5314static tree 5315block_start_struct (tree name) 5316{ 5317 tree s; 5318 /* The idea here is to mimic the actions that the C++ parser takes when 5319 constructing 'extern "C" struct NAME {'. */ 5320 push_lang_context (lang_name_c); 5321 5322 s = xref_tag (record_type, name, ts_global, 0); 5323 CLASSTYPE_DECLARED_CLASS (s) = 0; /* this is a 'struct', not a 'class'. */ 5324 xref_basetypes (s, NULL_TREE); /* no base classes here! */ 5325 5326 return begin_class_definition (s, NULL_TREE); 5327} 5328 5329static tree 5330block_finish_struct (tree t, tree fieldlist) 5331{ 5332 tree field, next_field; 5333 5334 for (field = fieldlist; field; field = next_field) 5335 { 5336 next_field = TREE_CHAIN (field); /* insert one field at a time; */ 5337 TREE_CHAIN (field) = NULL_TREE; /* otherwise, grokfield croaks. */ 5338 finish_member_declaration (field); 5339 } 5340 t = finish_struct (t, NULL); 5341 pop_lang_context (); 5342 5343 return t; 5344} 5345 5346/* new_block_byref_decl - This routine changes a 'typex x' declared variable into: 5347 5348 struct __Block_byref_x { 5349 // APPLE LOCAL radar 6244520 5350 void *__isa; // NULL for everything except __weak pointers 5351 struct Block_byref_x *__forwarding; 5352 int32_t __flags; 5353 int32_t __size; 5354 void *__ByrefKeepFuncPtr; // Only if variable is __block ObjC object 5355 void *__ByrefDestroyFuncPtr; // Only if variable is __block ObjC object 5356 typex x; 5357 } x; 5358*/ 5359 5360static tree 5361new_block_byref_decl (tree decl) 5362{ 5363 static int unique_count; 5364 /* APPLE LOCAL radar 5847976 */ 5365 int save_flag_objc_gc; 5366 tree Block_byref_type; 5367 tree fields = NULL_TREE, field; 5368 const char *prefix = "__Block_byref_"; 5369 char *string = (char*)alloca (strlen (IDENTIFIER_POINTER (DECL_NAME (decl))) + 5370 strlen (prefix) + 8 /* to hold the count */); 5371 5372 sprintf (string, "%s%d_%s", prefix, ++unique_count, 5373 IDENTIFIER_POINTER (DECL_NAME (decl))); 5374 5375 push_to_top_level (); 5376 5377 /* Block_byref_type = start_struct (RECORD_TYPE, get_identifier (string)); */ 5378 Block_byref_type = block_start_struct (get_identifier (string)); 5379 5380 /* APPLE LOCAL begin radar 6244520 */ 5381 /* void *__isa; */ 5382 field = build_decl (FIELD_DECL, get_identifier ("__isa"), ptr_type_node); 5383 fields = field; 5384 /* APPLE LOCAL end radar 6244520 */ 5385 5386 /* struct Block_byref_x *__forwarding; */ 5387 field = build_decl (FIELD_DECL, get_identifier ("__forwarding"), 5388 build_pointer_type (Block_byref_type)); 5389 /* APPLE LOCAL radar 6244520 */ 5390 chainon (fields, field); 5391 5392 /* int32_t __flags; */ 5393 field = build_decl (FIELD_DECL, get_identifier ("__flags"), 5394 unsigned_type_node); 5395 chainon (fields, field); 5396 5397 /* int32_t __size; */ 5398 field = build_decl (FIELD_DECL, get_identifier ("__size"), 5399 unsigned_type_node); 5400 chainon (fields, field); 5401 5402 if (COPYABLE_BYREF_LOCAL_NONPOD (decl)) 5403 { 5404 /* void *__ByrefKeepFuncPtr; */ 5405 field = build_decl (FIELD_DECL, get_identifier ("__ByrefKeepFuncPtr"), 5406 ptr_type_node); 5407 chainon (fields, field); 5408 5409 /* void *__ByrefDestroyFuncPtr; */ 5410 field = build_decl (FIELD_DECL, get_identifier ("__ByrefDestroyFuncPtr"), 5411 ptr_type_node); 5412 chainon (fields, field); 5413 } 5414 5415 /* typex x; */ 5416 field = build_decl (FIELD_DECL, DECL_NAME (decl), TREE_TYPE (decl)); 5417 chainon (fields, field); 5418 5419 /* APPLE LOCAL begin radar 5847976 */ 5420 /* Hack so we don't issue warning on a field_decl having __weak attribute */ 5421 save_flag_objc_gc = flag_objc_gc; 5422 flag_objc_gc = 0; 5423 /* finish_struct (Block_byref_type, field_decl_chain, NULL_TREE); */ 5424 block_finish_struct (Block_byref_type, fields); 5425 flag_objc_gc = save_flag_objc_gc; 5426 /* APPLE LOCAL end radar 5847976 */ 5427 pop_from_top_level (); 5428 5429 TREE_TYPE (decl) = Block_byref_type; 5430 /* Force layout_decl to recompute these fields. */ 5431 DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0; 5432 layout_decl (decl, 0); 5433 return decl; 5434} 5435 5436/* init_byref_decl - This routine builds the initializer for the __Block_byref_x 5437 type in the form of: 5438 { NULL, &x, 0, sizeof(struct __Block_byref_x), initializer-expr}; 5439 5440 or: 5441 { NULL, &x, 0, sizeof(struct __Block_byref_x)}; 5442 when INIT is NULL_TREE 5443 5444 For __block ObjC objects, it also adds "byref_keep" and "byref_destroy" 5445 Funtion pointers. So the most general initializers would be: 5446 5447 { NULL, &x, 0, sizeof(struct __Block_byref_x), &byref_keep, &byref_destroy, 5448 &initializer-expr}; 5449 */ 5450static tree 5451init_byref_decl (tree decl, tree init, int flag) 5452{ 5453 tree initlist; 5454 tree block_byref_type = TREE_TYPE (decl); 5455 int size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (block_byref_type)); 5456 unsigned flags = 0; 5457 tree fields; 5458 5459 if (COPYABLE_BYREF_LOCAL_NONPOD (decl)) 5460 flags = BLOCK_HAS_COPY_DISPOSE; 5461 5462 fields = TYPE_FIELDS (block_byref_type); 5463 /* APPLE LOCAL begin radar 6244520 */ 5464 initlist = tree_cons (fields, fold_convert (ptr_type_node, ((flag & BLOCK_FIELD_IS_WEAK) != 0) ? integer_one_node 5465 : integer_zero_node), 5466 0); 5467 fields = TREE_CHAIN (fields); 5468 5469 initlist = tree_cons (fields, 5470 build_unary_op (ADDR_EXPR, decl, 0), initlist); 5471 /* APPLE LOCAL end radar 6244520 */ 5472 fields = TREE_CHAIN (fields); 5473 5474 initlist = tree_cons (fields, build_int_cst (TREE_TYPE (fields), flags), 5475 initlist); 5476 fields = TREE_CHAIN (fields); 5477 initlist = tree_cons (fields, build_int_cst (TREE_TYPE (fields), size), 5478 initlist); 5479 fields = TREE_CHAIN (fields); 5480 5481 if (COPYABLE_BYREF_LOCAL_NONPOD (decl)) 5482 { 5483 char name[64]; 5484 int align = exact_log2 ((DECL_ALIGN (decl)+TYPE_ALIGN (ptr_type_node)-1) / TYPE_ALIGN (ptr_type_node)); 5485 int kind; 5486 if (align == -1 || align > BLOCK_ALIGN_MAX) { 5487 error ("invalid alignment for __block variable"); 5488 kind = 0; 5489 } else 5490 kind = align*BLOCK_BYREF_CURRENT_MAX + flag; 5491 /* Add &__Block_byref_id_object_copy, &__Block_byref_id_object_dispose 5492 initializers. */ 5493 if (!block_byref_id_object_copy[kind]) 5494 { 5495 tree func_type; 5496 push_lang_context (lang_name_c); 5497 /* Build a void __Block_byref_id_object_copy(void*, void*) type. */ 5498 func_type = 5499 build_function_type (void_type_node, 5500 tree_cons (NULL_TREE, ptr_type_node, 5501 tree_cons (NULL_TREE, ptr_type_node, 5502 void_list_node))); 5503 sprintf (name, "__Block_byref_id_object_copy%d", kind); 5504 block_byref_id_object_copy[kind] = build_helper_func_decl (get_identifier (name), 5505 func_type); 5506 DECL_CONTEXT (block_byref_id_object_copy[kind]) = current_function_decl; 5507 /* Synthesize function definition. */ 5508 synth_block_byref_id_object_copy_func (flag, kind); 5509 pop_lang_context (); 5510 } 5511 initlist = tree_cons (fields, 5512 build_fold_addr_expr (block_byref_id_object_copy[kind]), 5513 initlist); 5514 fields = TREE_CHAIN (fields); 5515 5516 if (!block_byref_id_object_dispose[kind]) 5517 { 5518 tree func_type; 5519 push_lang_context (lang_name_c); 5520 /* Synthesize void __Block_byref_id_object_dispose (void*) and 5521 build &__Block_byref_id_object_dispose. */ 5522 func_type = 5523 build_function_type (void_type_node, 5524 tree_cons (NULL_TREE, ptr_type_node, void_list_node)); 5525 sprintf (name, "__Block_byref_id_object_dispose%d", kind); 5526 block_byref_id_object_dispose[kind] = build_helper_func_decl (get_identifier (name), 5527 func_type); 5528 DECL_CONTEXT (block_byref_id_object_dispose[kind]) = current_function_decl; 5529 /* Synthesize function definition. */ 5530 synth_block_byref_id_object_dispose_func (flag, kind); 5531 pop_lang_context (); 5532 } 5533 initlist = tree_cons (fields, 5534 build_fold_addr_expr (block_byref_id_object_dispose[kind]), 5535 initlist); 5536 fields = TREE_CHAIN (fields); 5537 } 5538 5539 if (init) 5540 { 5541 init = digest_init (TREE_TYPE (fields), init); 5542 initlist = tree_cons (fields, init, initlist); 5543 } 5544 init = build_constructor_from_list (block_byref_type, nreverse (initlist)); 5545 return init; 5546} 5547/* APPLE LOCAL end blocks 6040305 (cr) */ 5548 5549/* Finish processing of a declaration; 5550 install its line number and initial value. 5551 If the length of an array type is not known before, 5552 it must be determined now, from the initial value, or it is an error. 5553 5554 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is 5555 true, then INIT is an integral constant expression. 5556 5557 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0 5558 if the (init) syntax was used. */ 5559 5560void 5561cp_finish_decl (tree decl, tree init, bool init_const_expr_p, 5562 tree asmspec_tree, int flags) 5563{ 5564 tree type; 5565 tree cleanup; 5566 const char *asmspec = NULL; 5567 int was_readonly = 0; 5568 bool var_definition_p = false; 5569 int saved_processing_template_decl; 5570 5571 if (decl == error_mark_node) 5572 return; 5573 else if (! decl) 5574 { 5575 if (init) 5576 error ("assignment (not initialization) in declaration"); 5577 return; 5578 } 5579 5580 gcc_assert (TREE_CODE (decl) != RESULT_DECL); 5581 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */ 5582 gcc_assert (TREE_CODE (decl) != PARM_DECL); 5583 5584 type = TREE_TYPE (decl); 5585 if (type == error_mark_node) 5586 return; 5587 5588 /* Assume no cleanup is required. */ 5589 cleanup = NULL_TREE; 5590 saved_processing_template_decl = processing_template_decl; 5591 5592 /* If a name was specified, get the string. */ 5593 if (global_scope_p (current_binding_level)) 5594 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree); 5595 if (asmspec_tree && asmspec_tree != error_mark_node) 5596 asmspec = TREE_STRING_POINTER (asmspec_tree); 5597 5598 if (current_class_type 5599 && CP_DECL_CONTEXT (decl) == current_class_type 5600 && TYPE_BEING_DEFINED (current_class_type) 5601 && (DECL_INITIAL (decl) || init)) 5602 DECL_INITIALIZED_IN_CLASS_P (decl) = 1; 5603 5604 if (processing_template_decl) 5605 { 5606 bool type_dependent_p; 5607 5608 /* Add this declaration to the statement-tree. */ 5609 if (at_function_scope_p ()) 5610 add_decl_expr (decl); 5611 5612 type_dependent_p = dependent_type_p (type); 5613 5614 if (init && init_const_expr_p) 5615 { 5616 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1; 5617 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl)) 5618 TREE_CONSTANT (decl) = 1; 5619 } 5620 5621 /* Generally, initializers in templates are expanded when the 5622 template is instantiated. But, if DECL is an integral 5623 constant static data member, then it can be used in future 5624 integral constant expressions, and its value must be 5625 available. */ 5626 if (!(init 5627 && DECL_CLASS_SCOPE_P (decl) 5628 && DECL_INTEGRAL_CONSTANT_VAR_P (decl) 5629 && !type_dependent_p 5630 && !value_dependent_init_p (init))) 5631 { 5632 if (init) 5633 DECL_INITIAL (decl) = init; 5634 if (TREE_CODE (decl) == VAR_DECL 5635 && !DECL_PRETTY_FUNCTION_P (decl) 5636 && !type_dependent_p) 5637 maybe_deduce_size_from_array_init (decl, init); 5638 goto finish_end; 5639 } 5640 5641 init = fold_non_dependent_expr (init); 5642 processing_template_decl = 0; 5643 } 5644 5645 /* Take care of TYPE_DECLs up front. */ 5646 if (TREE_CODE (decl) == TYPE_DECL) 5647 { 5648 if (type != error_mark_node 5649 && IS_AGGR_TYPE (type) && DECL_NAME (decl)) 5650 { 5651 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type) 5652 warning (0, "shadowing previous type declaration of %q#D", decl); 5653 set_identifier_type_value (DECL_NAME (decl), decl); 5654 } 5655 5656 /* If we have installed this as the canonical typedef for this 5657 type, and that type has not been defined yet, delay emitting 5658 the debug information for it, as we will emit it later. */ 5659 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl 5660 && !COMPLETE_TYPE_P (TREE_TYPE (decl))) 5661 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1; 5662 5663 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE, 5664 at_eof); 5665 goto finish_end; 5666 } 5667 5668 /* A reference will be modified here, as it is initialized. */ 5669 if (! DECL_EXTERNAL (decl) 5670 && TREE_READONLY (decl) 5671 && TREE_CODE (type) == REFERENCE_TYPE) 5672 { 5673 was_readonly = 1; 5674 TREE_READONLY (decl) = 0; 5675 } 5676 5677 if (TREE_CODE (decl) == VAR_DECL) 5678 { 5679 /* Only PODs can have thread-local storage. Other types may require 5680 various kinds of non-trivial initialization. */ 5681 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl))) 5682 error ("%qD cannot be thread-local because it has non-POD type %qT", 5683 decl, TREE_TYPE (decl)); 5684 /* APPLE LOCAL begin blocks 6040305 (cq) */ 5685 if (COPYABLE_BYREF_LOCAL_VAR (decl)) { 5686 if (DECL_EXTERNAL (decl) || TREE_STATIC (decl)) 5687 { 5688 error ("__block attribute on %q+D not allowed, only allowed on local variables", decl); 5689 COPYABLE_BYREF_LOCAL_VAR (decl) = 0; 5690 COPYABLE_BYREF_LOCAL_NONPOD (decl) = 0; 5691 } 5692 } 5693 /* APPLE LOCAL end blocks 6040305 (cq) */ 5694 5695 /* If this is a local variable that will need a mangled name, 5696 register it now. We must do this before processing the 5697 initializer for the variable, since the initialization might 5698 require a guard variable, and since the mangled name of the 5699 guard variable will depend on the mangled name of this 5700 variable. */ 5701 if (!processing_template_decl 5702 && DECL_FUNCTION_SCOPE_P (decl) 5703 && TREE_STATIC (decl) 5704 && !DECL_ARTIFICIAL (decl)) 5705 push_local_name (decl); 5706 /* Convert the initializer to the type of DECL, if we have not 5707 already initialized DECL. */ 5708 if (!DECL_INITIALIZED_P (decl) 5709 /* If !DECL_EXTERNAL then DECL is being defined. In the 5710 case of a static data member initialized inside the 5711 class-specifier, there can be an initializer even if DECL 5712 is *not* defined. */ 5713 && (!DECL_EXTERNAL (decl) || init)) 5714 { 5715 if (init) 5716 { 5717 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1; 5718 if (init_const_expr_p) 5719 { 5720 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1; 5721 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl)) 5722 TREE_CONSTANT (decl) = 1; 5723 } 5724 } 5725 init = check_initializer (decl, init, flags, &cleanup); 5726 /* Thread-local storage cannot be dynamically initialized. */ 5727 if (DECL_THREAD_LOCAL_P (decl) && init) 5728 { 5729 error ("%qD is thread-local and so cannot be dynamically " 5730 "initialized", decl); 5731 init = NULL_TREE; 5732 } 5733 5734 /* Check that the initializer for a static data member was a 5735 constant. Although we check in the parser that the 5736 initializer is an integral constant expression, we do not 5737 simplify division-by-zero at the point at which it 5738 occurs. Therefore, in: 5739 5740 struct S { static const int i = 7 / 0; }; 5741 5742 we issue an error at this point. It would 5743 probably be better to forbid division by zero in 5744 integral constant expressions. */ 5745 if (DECL_EXTERNAL (decl) && init) 5746 { 5747 error ("%qD cannot be initialized by a non-constant expression" 5748 " when being declared", decl); 5749 DECL_INITIALIZED_IN_CLASS_P (decl) = 0; 5750 init = NULL_TREE; 5751 } 5752 5753 /* Handle: 5754 5755 [dcl.init] 5756 5757 The memory occupied by any object of static storage 5758 duration is zero-initialized at program startup before 5759 any other initialization takes place. 5760 5761 We cannot create an appropriate initializer until after 5762 the type of DECL is finalized. If DECL_INITIAL is set, 5763 then the DECL is statically initialized, and any 5764 necessary zero-initialization has already been performed. */ 5765 if (TREE_STATIC (decl) && !DECL_INITIAL (decl)) 5766 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl), 5767 /*nelts=*/NULL_TREE, 5768 /*static_storage_p=*/true); 5769 /* Remember that the initialization for this variable has 5770 taken place. */ 5771 DECL_INITIALIZED_P (decl) = 1; 5772 /* This declaration is the definition of this variable, 5773 unless we are initializing a static data member within 5774 the class specifier. */ 5775 if (!DECL_EXTERNAL (decl)) 5776 var_definition_p = true; 5777 } 5778 /* If the variable has an array type, lay out the type, even if 5779 there is no initializer. It is valid to index through the 5780 array, and we must get TYPE_ALIGN set correctly on the array 5781 type. */ 5782 else if (TREE_CODE (type) == ARRAY_TYPE) 5783 layout_type (type); 5784 } 5785 5786 /* Add this declaration to the statement-tree. This needs to happen 5787 after the call to check_initializer so that the DECL_EXPR for a 5788 reference temp is added before the DECL_EXPR for the reference itself. */ 5789 if (at_function_scope_p ()) 5790 add_decl_expr (decl); 5791 5792 /* Let the middle end know about variables and functions -- but not 5793 static data members in uninstantiated class templates. */ 5794 if (!saved_processing_template_decl 5795 && (TREE_CODE (decl) == VAR_DECL 5796 || TREE_CODE (decl) == FUNCTION_DECL)) 5797 { 5798 if (TREE_CODE (decl) == VAR_DECL) 5799 { 5800 layout_var_decl (decl); 5801 maybe_commonize_var (decl); 5802 } 5803 5804 make_rtl_for_nonlocal_decl (decl, init, asmspec); 5805 5806 /* Check for abstractness of the type. Notice that there is no 5807 need to strip array types here since the check for those types 5808 is already done within create_array_type_for_decl. */ 5809 if (TREE_CODE (type) == FUNCTION_TYPE 5810 || TREE_CODE (type) == METHOD_TYPE) 5811 abstract_virtuals_error (decl, TREE_TYPE (type)); 5812 else 5813 abstract_virtuals_error (decl, type); 5814 5815 /* This needs to happen after the linkage is set. */ 5816 determine_visibility (decl); 5817 5818 if (TREE_CODE (decl) == FUNCTION_DECL 5819 || TREE_TYPE (decl) == error_mark_node) 5820 /* No initialization required. */ 5821 ; 5822 else if (DECL_EXTERNAL (decl) 5823 && ! (DECL_LANG_SPECIFIC (decl) 5824 && DECL_NOT_REALLY_EXTERN (decl))) 5825 { 5826 if (init) 5827 DECL_INITIAL (decl) = init; 5828 } 5829 else 5830 { 5831 /* A variable definition. */ 5832 if (DECL_FUNCTION_SCOPE_P (decl)) 5833 { 5834 /* Initialize the local variable. */ 5835 if (processing_template_decl) 5836 DECL_INITIAL (decl) = init; 5837 else if (!TREE_STATIC (decl)) 5838 initialize_local_var (decl, init); 5839 } 5840 5841 /* If a variable is defined, and then a subsequent 5842 definition with external linkage is encountered, we will 5843 get here twice for the same variable. We want to avoid 5844 calling expand_static_init more than once. For variables 5845 that are not static data members, we can call 5846 expand_static_init only when we actually process the 5847 initializer. It is not legal to redeclare a static data 5848 member, so this issue does not arise in that case. */ 5849 if (var_definition_p && TREE_STATIC (decl)) 5850 { 5851 /* If a TREE_READONLY variable needs initialization 5852 at runtime, it is no longer readonly and we need to 5853 avoid MEM_READONLY_P being set on RTL created for it. */ 5854 if (init) 5855 { 5856 if (TREE_READONLY (decl)) 5857 TREE_READONLY (decl) = 0; 5858 was_readonly = 0; 5859 } 5860 expand_static_init (decl, init); 5861 } 5862 } 5863 } 5864 5865 /* If a CLEANUP_STMT was created to destroy a temporary bound to a 5866 reference, insert it in the statement-tree now. */ 5867 if (cleanup) 5868 push_cleanup (decl, cleanup, false); 5869 5870 finish_end: 5871 processing_template_decl = saved_processing_template_decl; 5872 5873 if (was_readonly) 5874 TREE_READONLY (decl) = 1; 5875 5876 /* If this was marked 'used', be sure it will be output. */ 5877 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl))) 5878 mark_decl_referenced (decl); 5879} 5880 5881/* This is here for a midend callback from c-common.c. */ 5882 5883void 5884finish_decl (tree decl, tree init, tree asmspec_tree) 5885{ 5886 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0); 5887} 5888 5889/* Returns a declaration for a VAR_DECL as if: 5890 5891 extern "C" TYPE NAME; 5892 5893 had been seen. Used to create compiler-generated global 5894 variables. */ 5895 5896static tree 5897declare_global_var (tree name, tree type) 5898{ 5899 tree decl; 5900 5901 push_to_top_level (); 5902 decl = build_decl (VAR_DECL, name, type); 5903 TREE_PUBLIC (decl) = 1; 5904 DECL_EXTERNAL (decl) = 1; 5905 DECL_ARTIFICIAL (decl) = 1; 5906 /* If the user has explicitly declared this variable (perhaps 5907 because the code we are compiling is part of a low-level runtime 5908 library), then it is possible that our declaration will be merged 5909 with theirs by pushdecl. */ 5910 decl = pushdecl (decl); 5911 finish_decl (decl, NULL_TREE, NULL_TREE); 5912 pop_from_top_level (); 5913 5914 return decl; 5915} 5916 5917/* Returns a pointer to the `atexit' function. Note that if 5918 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new 5919 `__cxa_atexit' function specified in the IA64 C++ ABI. */ 5920 5921static tree 5922get_atexit_node (void) 5923{ 5924 tree atexit_fndecl; 5925 tree arg_types; 5926 tree fn_type; 5927 tree fn_ptr_type; 5928 const char *name; 5929 bool use_aeabi_atexit; 5930 5931 if (atexit_node) 5932 return atexit_node; 5933 5934 if (flag_use_cxa_atexit) 5935 { 5936 /* The declaration for `__cxa_atexit' is: 5937 5938 int __cxa_atexit (void (*)(void *), void *, void *) 5939 5940 We build up the argument types and then then function type 5941 itself. */ 5942 5943 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit (); 5944 /* First, build the pointer-to-function type for the first 5945 argument. */ 5946 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node); 5947 fn_type = build_function_type (void_type_node, arg_types); 5948 fn_ptr_type = build_pointer_type (fn_type); 5949 /* Then, build the rest of the argument types. */ 5950 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node); 5951 if (use_aeabi_atexit) 5952 { 5953 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types); 5954 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types); 5955 } 5956 else 5957 { 5958 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types); 5959 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types); 5960 } 5961 /* And the final __cxa_atexit type. */ 5962 fn_type = build_function_type (integer_type_node, arg_types); 5963 fn_ptr_type = build_pointer_type (fn_type); 5964 if (use_aeabi_atexit) 5965 name = "__aeabi_atexit"; 5966 else 5967 name = "__cxa_atexit"; 5968 } 5969 else 5970 { 5971 /* The declaration for `atexit' is: 5972 5973 int atexit (void (*)()); 5974 5975 We build up the argument types and then then function type 5976 itself. */ 5977 fn_type = build_function_type (void_type_node, void_list_node); 5978 fn_ptr_type = build_pointer_type (fn_type); 5979 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node); 5980 /* Build the final atexit type. */ 5981 fn_type = build_function_type (integer_type_node, arg_types); 5982 name = "atexit"; 5983 } 5984 5985 /* Now, build the function declaration. */ 5986 push_lang_context (lang_name_c); 5987 atexit_fndecl = build_library_fn_ptr (name, fn_type); 5988 mark_used (atexit_fndecl); 5989 pop_lang_context (); 5990 atexit_node = decay_conversion (atexit_fndecl); 5991 5992 return atexit_node; 5993} 5994 5995/* Returns the __dso_handle VAR_DECL. */ 5996 5997static tree 5998get_dso_handle_node (void) 5999{ 6000 if (dso_handle_node) 6001 return dso_handle_node; 6002 6003 /* Declare the variable. */ 6004 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"), 6005 ptr_type_node); 6006 6007 return dso_handle_node; 6008} 6009 6010/* Begin a new function with internal linkage whose job will be simply 6011 to destroy some particular variable. */ 6012 6013static GTY(()) int start_cleanup_cnt; 6014 6015static tree 6016start_cleanup_fn (void) 6017{ 6018 char name[32]; 6019 tree parmtypes; 6020 tree fntype; 6021 tree fndecl; 6022 6023 push_to_top_level (); 6024 6025 /* No need to mangle this. */ 6026 push_lang_context (lang_name_c); 6027 6028 /* Build the parameter-types. */ 6029 parmtypes = void_list_node; 6030 /* Functions passed to __cxa_atexit take an additional parameter. 6031 We'll just ignore it. After we implement the new calling 6032 convention for destructors, we can eliminate the use of 6033 additional cleanup functions entirely in the -fnew-abi case. */ 6034 if (flag_use_cxa_atexit) 6035 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes); 6036 /* Build the function type itself. */ 6037 fntype = build_function_type (void_type_node, parmtypes); 6038 /* Build the name of the function. */ 6039 sprintf (name, "__tcf_%d", start_cleanup_cnt++); 6040 /* Build the function declaration. */ 6041 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype); 6042 /* It's a function with internal linkage, generated by the 6043 compiler. */ 6044 TREE_PUBLIC (fndecl) = 0; 6045 DECL_ARTIFICIAL (fndecl) = 1; 6046 /* Make the function `inline' so that it is only emitted if it is 6047 actually needed. It is unlikely that it will be inlined, since 6048 it is only called via a function pointer, but we avoid unnecessary 6049 emissions this way. */ 6050 DECL_INLINE (fndecl) = 1; 6051 DECL_DECLARED_INLINE_P (fndecl) = 1; 6052 DECL_INTERFACE_KNOWN (fndecl) = 1; 6053 /* Build the parameter. */ 6054 if (flag_use_cxa_atexit) 6055 { 6056 tree parmdecl; 6057 6058 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node); 6059 DECL_CONTEXT (parmdecl) = fndecl; 6060 TREE_USED (parmdecl) = 1; 6061 DECL_ARGUMENTS (fndecl) = parmdecl; 6062 } 6063 6064 pushdecl (fndecl); 6065 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED); 6066 6067 pop_lang_context (); 6068 6069 return current_function_decl; 6070} 6071 6072/* Finish the cleanup function begun by start_cleanup_fn. */ 6073 6074static void 6075end_cleanup_fn (void) 6076{ 6077 expand_or_defer_fn (finish_function (0)); 6078 6079 pop_from_top_level (); 6080} 6081 6082/* Generate code to handle the destruction of DECL, an object with 6083 static storage duration. */ 6084 6085tree 6086register_dtor_fn (tree decl) 6087{ 6088 tree cleanup; 6089 tree compound_stmt; 6090 tree args; 6091 tree fcall; 6092 6093 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) 6094 return void_zero_node; 6095 6096 /* Call build_cleanup before we enter the anonymous function so that 6097 any access checks will be done relative to the current scope, 6098 rather than the scope of the anonymous function. */ 6099 build_cleanup (decl); 6100 6101 /* Now start the function. */ 6102 cleanup = start_cleanup_fn (); 6103 6104 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer 6105 to the original function, rather than the anonymous one. That 6106 will make the back-end think that nested functions are in use, 6107 which causes confusion. */ 6108 6109 push_deferring_access_checks (dk_no_check); 6110 fcall = build_cleanup (decl); 6111 pop_deferring_access_checks (); 6112 6113 /* Create the body of the anonymous function. */ 6114 compound_stmt = begin_compound_stmt (BCS_FN_BODY); 6115 finish_expr_stmt (fcall); 6116 finish_compound_stmt (compound_stmt); 6117 end_cleanup_fn (); 6118 6119 /* Call atexit with the cleanup function. */ 6120 cxx_mark_addressable (cleanup); 6121 mark_used (cleanup); 6122 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0); 6123 if (flag_use_cxa_atexit) 6124 { 6125 args = tree_cons (NULL_TREE, 6126 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0), 6127 NULL_TREE); 6128 if (targetm.cxx.use_aeabi_atexit ()) 6129 { 6130 args = tree_cons (NULL_TREE, cleanup, args); 6131 args = tree_cons (NULL_TREE, null_pointer_node, args); 6132 } 6133 else 6134 { 6135 args = tree_cons (NULL_TREE, null_pointer_node, args); 6136 args = tree_cons (NULL_TREE, cleanup, args); 6137 } 6138 } 6139 else 6140 args = tree_cons (NULL_TREE, cleanup, NULL_TREE); 6141 return build_function_call (get_atexit_node (), args); 6142} 6143 6144/* DECL is a VAR_DECL with static storage duration. INIT, if present, 6145 is its initializer. Generate code to handle the construction 6146 and destruction of DECL. */ 6147 6148static void 6149expand_static_init (tree decl, tree init) 6150{ 6151 gcc_assert (TREE_CODE (decl) == VAR_DECL); 6152 gcc_assert (TREE_STATIC (decl)); 6153 6154 /* Some variables require no initialization. */ 6155 if (!init 6156 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)) 6157 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) 6158 return; 6159 6160 /* APPLE LOCAL begin radar 5733674 */ 6161 if (c_dialect_objc () && flag_objc_gc && init && TREE_CODE (init) == INIT_EXPR) 6162 { 6163 tree result = objc_generate_write_barrier (TREE_OPERAND (init, 0), 6164 INIT_EXPR, TREE_OPERAND (init, 1)); 6165 if (result) 6166 init = result; 6167 } 6168 /* APPLE LOCAL end radar 5733674 */ 6169 6170 if (DECL_FUNCTION_SCOPE_P (decl)) 6171 { 6172 /* Emit code to perform this initialization but once. */ 6173 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE; 6174 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE; 6175 tree guard, guard_addr, guard_addr_list; 6176 tree acquire_fn, release_fn, abort_fn; 6177 tree flag, begin; 6178 6179 /* Emit code to perform this initialization but once. This code 6180 looks like: 6181 6182 static <type> guard; 6183 if (!guard.first_byte) { 6184 if (__cxa_guard_acquire (&guard)) { 6185 bool flag = false; 6186 try { 6187 // Do initialization. 6188 flag = true; __cxa_guard_release (&guard); 6189 // Register variable for destruction at end of program. 6190 } catch { 6191 if (!flag) __cxa_guard_abort (&guard); 6192 } 6193 } 6194 6195 Note that the `flag' variable is only set to 1 *after* the 6196 initialization is complete. This ensures that an exception, 6197 thrown during the construction, will cause the variable to 6198 reinitialized when we pass through this code again, as per: 6199 6200 [stmt.dcl] 6201 6202 If the initialization exits by throwing an exception, the 6203 initialization is not complete, so it will be tried again 6204 the next time control enters the declaration. 6205 6206 This process should be thread-safe, too; multiple threads 6207 should not be able to initialize the variable more than 6208 once. */ 6209 6210 /* Create the guard variable. */ 6211 guard = get_guard (decl); 6212 6213 /* This optimization isn't safe on targets with relaxed memory 6214 consistency. On such targets we force synchronization in 6215 __cxa_guard_acquire. */ 6216 if (!targetm.relaxed_ordering || !flag_threadsafe_statics) 6217 { 6218 /* Begin the conditional initialization. */ 6219 if_stmt = begin_if_stmt (); 6220 finish_if_stmt_cond (get_guard_cond (guard), if_stmt); 6221 then_clause = begin_compound_stmt (BCS_NO_SCOPE); 6222 } 6223 6224 if (flag_threadsafe_statics) 6225 { 6226 guard_addr = build_address (guard); 6227 guard_addr_list = build_tree_list (NULL_TREE, guard_addr); 6228 6229 acquire_fn = get_identifier ("__cxa_guard_acquire"); 6230 release_fn = get_identifier ("__cxa_guard_release"); 6231 abort_fn = get_identifier ("__cxa_guard_abort"); 6232 if (!get_global_value_if_present (acquire_fn, &acquire_fn)) 6233 { 6234 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr), 6235 void_list_node); 6236 tree vfntype = build_function_type (void_type_node, argtypes); 6237 acquire_fn = push_library_fn 6238 (acquire_fn, build_function_type (integer_type_node, argtypes)); 6239 release_fn = push_library_fn (release_fn, vfntype); 6240 abort_fn = push_library_fn (abort_fn, vfntype); 6241 } 6242 else 6243 { 6244 release_fn = identifier_global_value (release_fn); 6245 abort_fn = identifier_global_value (abort_fn); 6246 } 6247 6248 inner_if_stmt = begin_if_stmt (); 6249 finish_if_stmt_cond (build_call (acquire_fn, guard_addr_list), 6250 inner_if_stmt); 6251 6252 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE); 6253 begin = get_target_expr (boolean_false_node); 6254 flag = TARGET_EXPR_SLOT (begin); 6255 6256 TARGET_EXPR_CLEANUP (begin) 6257 = build3 (COND_EXPR, void_type_node, flag, 6258 void_zero_node, 6259 build_call (abort_fn, guard_addr_list)); 6260 CLEANUP_EH_ONLY (begin) = 1; 6261 6262 /* Do the initialization itself. */ 6263 init = add_stmt_to_compound (begin, init); 6264 init = add_stmt_to_compound 6265 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node)); 6266 init = add_stmt_to_compound 6267 (init, build_call (release_fn, guard_addr_list)); 6268 } 6269 else 6270 init = add_stmt_to_compound (init, set_guard (guard)); 6271 6272 /* Use atexit to register a function for destroying this static 6273 variable. */ 6274 init = add_stmt_to_compound (init, register_dtor_fn (decl)); 6275 6276 finish_expr_stmt (init); 6277 6278 if (flag_threadsafe_statics) 6279 { 6280 finish_compound_stmt (inner_then_clause); 6281 finish_then_clause (inner_if_stmt); 6282 finish_if_stmt (inner_if_stmt); 6283 } 6284 6285 if (!targetm.relaxed_ordering || !flag_threadsafe_statics) 6286 { 6287 finish_compound_stmt (then_clause); 6288 finish_then_clause (if_stmt); 6289 finish_if_stmt (if_stmt); 6290 } 6291 } 6292 else 6293 static_aggregates = tree_cons (init, decl, static_aggregates); 6294} 6295 6296 6297/* Make TYPE a complete type based on INITIAL_VALUE. 6298 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered, 6299 2 if there was no information (in which case assume 0 if DO_DEFAULT), 6300 3 if the initializer list is empty (in pedantic mode). */ 6301 6302int 6303cp_complete_array_type (tree *ptype, tree initial_value, bool do_default) 6304{ 6305 int failure; 6306 tree type, elt_type; 6307 6308 if (initial_value) 6309 { 6310 /* An array of character type can be initialized from a 6311 brace-enclosed string constant. 6312 6313 FIXME: this code is duplicated from reshape_init. Probably 6314 we should just call reshape_init here? */ 6315 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype))) 6316 && TREE_CODE (initial_value) == CONSTRUCTOR 6317 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value))) 6318 { 6319 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value); 6320 tree value = VEC_index (constructor_elt, v, 0)->value; 6321 6322 if (TREE_CODE (value) == STRING_CST 6323 && VEC_length (constructor_elt, v) == 1) 6324 initial_value = value; 6325 } 6326 } 6327 6328 failure = complete_array_type (ptype, initial_value, do_default); 6329 6330 /* We can create the array before the element type is complete, which 6331 means that we didn't have these two bits set in the original type 6332 either. In completing the type, we are expected to propagate these 6333 bits. See also complete_type which does the same thing for arrays 6334 of fixed size. */ 6335 type = *ptype; 6336 if (TYPE_DOMAIN (type)) 6337 { 6338 elt_type = TREE_TYPE (type); 6339 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type); 6340 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) 6341 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type); 6342 } 6343 6344 return failure; 6345} 6346 6347/* Return zero if something is declared to be a member of type 6348 CTYPE when in the context of CUR_TYPE. STRING is the error 6349 message to print in that case. Otherwise, quietly return 1. */ 6350 6351static int 6352member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags) 6353{ 6354 if (ctype && ctype != cur_type) 6355 { 6356 if (flags == DTOR_FLAG) 6357 error ("destructor for alien class %qT cannot be a member", ctype); 6358 else 6359 error ("constructor for alien class %qT cannot be a member", ctype); 6360 return 0; 6361 } 6362 return 1; 6363} 6364 6365/* Subroutine of `grokdeclarator'. */ 6366 6367/* Generate errors possibly applicable for a given set of specifiers. 6368 This is for ARM $7.1.2. */ 6369 6370static void 6371bad_specifiers (tree object, 6372 const char* type, 6373 int virtualp, 6374 int quals, 6375 int inlinep, 6376 int friendp, 6377 int raises) 6378{ 6379 if (virtualp) 6380 error ("%qD declared as a %<virtual%> %s", object, type); 6381 if (inlinep) 6382 error ("%qD declared as an %<inline%> %s", object, type); 6383 if (quals) 6384 error ("%<const%> and %<volatile%> function specifiers on " 6385 "%qD invalid in %s declaration", 6386 object, type); 6387 if (friendp) 6388 error ("%q+D declared as a friend", object); 6389 if (raises 6390 && (TREE_CODE (object) == TYPE_DECL 6391 || (!TYPE_PTRFN_P (TREE_TYPE (object)) 6392 && !TYPE_REFFN_P (TREE_TYPE (object)) 6393 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object))))) 6394 error ("%q+D declared with an exception specification", object); 6395} 6396 6397/* DECL is a member function or static data member and is presently 6398 being defined. Check that the definition is taking place in a 6399 valid namespace. */ 6400 6401static void 6402check_class_member_definition_namespace (tree decl) 6403{ 6404 /* These checks only apply to member functions and static data 6405 members. */ 6406 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL 6407 || TREE_CODE (decl) == VAR_DECL); 6408 /* We check for problems with specializations in pt.c in 6409 check_specialization_namespace, where we can issue better 6410 diagnostics. */ 6411 if (processing_specialization) 6412 return; 6413 /* There are no restrictions on the placement of 6414 explicit instantiations. */ 6415 if (processing_explicit_instantiation) 6416 return; 6417 /* [class.mfct] 6418 6419 A member function definition that appears outside of the 6420 class definition shall appear in a namespace scope enclosing 6421 the class definition. 6422 6423 [class.static.data] 6424 6425 The definition for a static data member shall appear in a 6426 namespace scope enclosing the member's class definition. */ 6427 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl))) 6428 pedwarn ("definition of %qD is not in namespace enclosing %qT", 6429 decl, DECL_CONTEXT (decl)); 6430} 6431 6432/* Build a PARM_DECL for the "this" parameter. TYPE is the 6433 METHOD_TYPE for a non-static member function; QUALS are the 6434 cv-qualifiers that apply to the function. */ 6435 6436tree 6437build_this_parm (tree type, cp_cv_quals quals) 6438{ 6439 tree this_type; 6440 tree qual_type; 6441 tree parm; 6442 cp_cv_quals this_quals; 6443 6444 this_type = TREE_VALUE (TYPE_ARG_TYPES (type)); 6445 /* The `this' parameter is implicitly `const'; it cannot be 6446 assigned to. */ 6447 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST; 6448 qual_type = cp_build_qualified_type (this_type, this_quals); 6449 parm = build_artificial_parm (this_identifier, qual_type); 6450 cp_apply_type_quals_to_decl (this_quals, parm); 6451 return parm; 6452} 6453 6454/* CTYPE is class type, or null if non-class. 6455 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE 6456 or METHOD_TYPE. 6457 DECLARATOR is the function's name. 6458 PARMS is a chain of PARM_DECLs for the function. 6459 VIRTUALP is truthvalue of whether the function is virtual or not. 6460 FLAGS are to be passed through to `grokclassfn'. 6461 QUALS are qualifiers indicating whether the function is `const' 6462 or `volatile'. 6463 RAISES is a list of exceptions that this function can raise. 6464 CHECK is 1 if we must find this method in CTYPE, 0 if we should 6465 not look, and -1 if we should not call `grokclassfn' at all. 6466 6467 SFK is the kind of special function (if any) for the new function. 6468 6469 Returns `NULL_TREE' if something goes wrong, after issuing 6470 applicable error messages. */ 6471 6472static tree 6473grokfndecl (tree ctype, 6474 tree type, 6475 tree declarator, 6476 tree parms, 6477 tree orig_declarator, 6478 int virtualp, 6479 enum overload_flags flags, 6480 cp_cv_quals quals, 6481 tree raises, 6482 int check, 6483 int friendp, 6484 int publicp, 6485 int inlinep, 6486 special_function_kind sfk, 6487 bool funcdef_flag, 6488 int template_count, 6489 tree in_namespace, 6490 tree* attrlist) 6491{ 6492 tree decl; 6493 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE; 6494 tree t; 6495 6496 if (raises) 6497 type = build_exception_variant (type, raises); 6498 6499 decl = build_lang_decl (FUNCTION_DECL, declarator, type); 6500 if (TREE_CODE (type) == METHOD_TYPE) 6501 { 6502 tree parm; 6503 parm = build_this_parm (type, quals); 6504 TREE_CHAIN (parm) = parms; 6505 parms = parm; 6506 } 6507 DECL_ARGUMENTS (decl) = parms; 6508 /* Propagate volatile out from type to decl. */ 6509 if (TYPE_VOLATILE (type)) 6510 TREE_THIS_VOLATILE (decl) = 1; 6511 6512 /* If pointers to member functions use the least significant bit to 6513 indicate whether a function is virtual, ensure a pointer 6514 to this function will have that bit clear. */ 6515 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn 6516 && TREE_CODE (type) == METHOD_TYPE 6517 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT) 6518 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT; 6519 6520 if (friendp 6521 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR) 6522 { 6523 if (funcdef_flag) 6524 error 6525 ("defining explicit specialization %qD in friend declaration", 6526 orig_declarator); 6527 else 6528 { 6529 tree fns = TREE_OPERAND (orig_declarator, 0); 6530 tree args = TREE_OPERAND (orig_declarator, 1); 6531 6532 if (PROCESSING_REAL_TEMPLATE_DECL_P ()) 6533 { 6534 /* Something like `template <class T> friend void f<T>()'. */ 6535 error ("invalid use of template-id %qD in declaration " 6536 "of primary template", 6537 orig_declarator); 6538 return NULL_TREE; 6539 } 6540 6541 6542 /* A friend declaration of the form friend void f<>(). Record 6543 the information in the TEMPLATE_ID_EXPR. */ 6544 SET_DECL_IMPLICIT_INSTANTIATION (decl); 6545 6546 if (TREE_CODE (fns) == COMPONENT_REF) 6547 { 6548 /* Due to bison parser ickiness, we will have already looked 6549 up an operator_name or PFUNCNAME within the current class 6550 (see template_id in parse.y). If the current class contains 6551 such a name, we'll get a COMPONENT_REF here. Undo that. */ 6552 6553 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0)) 6554 == current_class_type); 6555 fns = TREE_OPERAND (fns, 1); 6556 } 6557 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE 6558 || TREE_CODE (fns) == OVERLOAD); 6559 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE); 6560 6561 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t)) 6562 if (TREE_PURPOSE (t) 6563 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG) 6564 { 6565 error ("default arguments are not allowed in declaration " 6566 "of friend template specialization %qD", 6567 decl); 6568 return NULL_TREE; 6569 } 6570 6571 if (inlinep) 6572 { 6573 error ("%<inline%> is not allowed in declaration of friend " 6574 "template specialization %qD", 6575 decl); 6576 return NULL_TREE; 6577 } 6578 } 6579 } 6580 6581 /* If this decl has namespace scope, set that up. */ 6582 if (in_namespace) 6583 set_decl_namespace (decl, in_namespace, friendp); 6584 else if (!ctype) 6585 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); 6586 6587 /* `main' and builtins have implicit 'C' linkage. */ 6588 if ((MAIN_NAME_P (declarator) 6589 || (IDENTIFIER_LENGTH (declarator) > 10 6590 && IDENTIFIER_POINTER (declarator)[0] == '_' 6591 && IDENTIFIER_POINTER (declarator)[1] == '_' 6592 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0)) 6593 && current_lang_name == lang_name_cplusplus 6594 && ctype == NULL_TREE 6595 /* NULL_TREE means global namespace. */ 6596 && DECL_CONTEXT (decl) == NULL_TREE) 6597 SET_DECL_LANGUAGE (decl, lang_c); 6598 6599 /* Should probably propagate const out from type to decl I bet (mrs). */ 6600 if (staticp) 6601 { 6602 DECL_STATIC_FUNCTION_P (decl) = 1; 6603 DECL_CONTEXT (decl) = ctype; 6604 } 6605 6606 if (ctype) 6607 { 6608 DECL_CONTEXT (decl) = ctype; 6609 if (funcdef_flag) 6610 check_class_member_definition_namespace (decl); 6611 } 6612 6613 if (ctype == NULL_TREE && DECL_MAIN_P (decl)) 6614 { 6615 if (processing_template_decl) 6616 error ("cannot declare %<::main%> to be a template"); 6617 if (inlinep) 6618 error ("cannot declare %<::main%> to be inline"); 6619 if (!publicp) 6620 error ("cannot declare %<::main%> to be static"); 6621 inlinep = 0; 6622 publicp = 1; 6623 } 6624 6625 /* Members of anonymous types and local classes have no linkage; make 6626 them internal. If a typedef is made later, this will be changed. */ 6627 if (ctype && (TYPE_ANONYMOUS_P (ctype) 6628 || decl_function_context (TYPE_MAIN_DECL (ctype)))) 6629 publicp = 0; 6630 6631 if (publicp) 6632 { 6633 /* [basic.link]: A name with no linkage (notably, the name of a class 6634 or enumeration declared in a local scope) shall not be used to 6635 declare an entity with linkage. 6636 6637 Only check this for public decls for now. See core 319, 389. */ 6638 t = no_linkage_check (TREE_TYPE (decl), 6639 /*relaxed_p=*/false); 6640 if (t) 6641 { 6642 if (TYPE_ANONYMOUS_P (t)) 6643 { 6644 if (DECL_EXTERN_C_P (decl)) 6645 /* Allow this; it's pretty common in C. */; 6646 else 6647 { 6648 pedwarn ("non-local function %q#D uses anonymous type", 6649 decl); 6650 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t))) 6651 pedwarn ("%q+#D does not refer to the unqualified " 6652 "type, so it is not used for linkage", 6653 TYPE_NAME (t)); 6654 } 6655 } 6656 else 6657 pedwarn ("non-local function %q#D uses local type %qT", decl, t); 6658 } 6659 } 6660 6661 TREE_PUBLIC (decl) = publicp; 6662 if (! publicp) 6663 { 6664 DECL_INTERFACE_KNOWN (decl) = 1; 6665 DECL_NOT_REALLY_EXTERN (decl) = 1; 6666 } 6667 6668 /* If the declaration was declared inline, mark it as such. */ 6669 if (inlinep) 6670 DECL_DECLARED_INLINE_P (decl) = 1; 6671 /* We inline functions that are explicitly declared inline, or, when 6672 the user explicitly asks us to, all functions. */ 6673 if (DECL_DECLARED_INLINE_P (decl) 6674 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag)) 6675 DECL_INLINE (decl) = 1; 6676 6677 DECL_EXTERNAL (decl) = 1; 6678 if (quals && TREE_CODE (type) == FUNCTION_TYPE) 6679 { 6680 error ("%smember function %qD cannot have cv-qualifier", 6681 (ctype ? "static " : "non-"), decl); 6682 quals = TYPE_UNQUALIFIED; 6683 } 6684 6685 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)) 6686 && !grok_op_properties (decl, /*complain=*/true)) 6687 return NULL_TREE; 6688 6689 if (ctype && decl_function_context (decl)) 6690 DECL_NO_STATIC_CHAIN (decl) = 1; 6691 6692 if (funcdef_flag) 6693 /* Make the init_value nonzero so pushdecl knows this is not 6694 tentative. error_mark_node is replaced later with the BLOCK. */ 6695 DECL_INITIAL (decl) = error_mark_node; 6696 6697 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl)) 6698 TREE_NOTHROW (decl) = 1; 6699 6700 /* Caller will do the rest of this. */ 6701 if (check < 0) 6702 return decl; 6703 6704 if (ctype != NULL_TREE) 6705 { 6706 if (sfk == sfk_constructor) 6707 DECL_CONSTRUCTOR_P (decl) = 1; 6708 6709 grokclassfn (ctype, decl, flags); 6710 } 6711 6712 decl = check_explicit_specialization (orig_declarator, decl, 6713 template_count, 6714 2 * funcdef_flag + 6715 4 * (friendp != 0)); 6716 if (decl == error_mark_node) 6717 return NULL_TREE; 6718 6719 if (attrlist) 6720 { 6721 cplus_decl_attributes (&decl, *attrlist, 0); 6722 *attrlist = NULL_TREE; 6723 } 6724 6725 /* Check main's type after attributes have been applied. */ 6726 if (ctype == NULL_TREE && DECL_MAIN_P (decl) 6727 && !same_type_p (TREE_TYPE (TREE_TYPE (decl)), 6728 integer_type_node)) 6729 { 6730 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl)); 6731 tree newtype; 6732 error ("%<::main%> must return %<int%>"); 6733 newtype = build_function_type (integer_type_node, oldtypeargs); 6734 TREE_TYPE (decl) = newtype; 6735 } 6736 6737 if (ctype != NULL_TREE 6738 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl)) 6739 && check) 6740 { 6741 tree old_decl; 6742 6743 old_decl = check_classfn (ctype, decl, 6744 (processing_template_decl 6745 > template_class_depth (ctype)) 6746 ? current_template_parms 6747 : NULL_TREE); 6748 if (old_decl) 6749 { 6750 tree ok; 6751 tree pushed_scope; 6752 6753 if (TREE_CODE (old_decl) == TEMPLATE_DECL) 6754 /* Because grokfndecl is always supposed to return a 6755 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT 6756 here. We depend on our callers to figure out that its 6757 really a template that's being returned. */ 6758 old_decl = DECL_TEMPLATE_RESULT (old_decl); 6759 6760 if (DECL_STATIC_FUNCTION_P (old_decl) 6761 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE) 6762 /* Remove the `this' parm added by grokclassfn. 6763 XXX Isn't this done in start_function, too? */ 6764 revert_static_member_fn (decl); 6765 if (DECL_ARTIFICIAL (old_decl)) 6766 error ("definition of implicitly-declared %qD", old_decl); 6767 6768 /* Since we've smashed OLD_DECL to its 6769 DECL_TEMPLATE_RESULT, we must do the same to DECL. */ 6770 if (TREE_CODE (decl) == TEMPLATE_DECL) 6771 decl = DECL_TEMPLATE_RESULT (decl); 6772 6773 /* Attempt to merge the declarations. This can fail, in 6774 the case of some invalid specialization declarations. */ 6775 pushed_scope = push_scope (ctype); 6776 ok = duplicate_decls (decl, old_decl, friendp); 6777 if (pushed_scope) 6778 pop_scope (pushed_scope); 6779 if (!ok) 6780 { 6781 error ("no %q#D member function declared in class %qT", 6782 decl, ctype); 6783 return NULL_TREE; 6784 } 6785 return old_decl; 6786 } 6787 } 6788 6789 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl)) 6790 return NULL_TREE; 6791 6792 if (ctype == NULL_TREE || check) 6793 return decl; 6794 6795 if (virtualp) 6796 DECL_VIRTUAL_P (decl) = 1; 6797 6798 return decl; 6799} 6800 6801/* DECL is a VAR_DECL for a static data member. Set flags to reflect 6802 the linkage that DECL will receive in the object file. */ 6803 6804static void 6805set_linkage_for_static_data_member (tree decl) 6806{ 6807 /* A static data member always has static storage duration and 6808 external linkage. Note that static data members are forbidden in 6809 local classes -- the only situation in which a class has 6810 non-external linkage. */ 6811 TREE_PUBLIC (decl) = 1; 6812 TREE_STATIC (decl) = 1; 6813 /* For non-template classes, static data members are always put 6814 out in exactly those files where they are defined, just as 6815 with ordinary namespace-scope variables. */ 6816 if (!processing_template_decl) 6817 DECL_INTERFACE_KNOWN (decl) = 1; 6818} 6819 6820/* Create a VAR_DECL named NAME with the indicated TYPE. 6821 6822 If SCOPE is non-NULL, it is the class type or namespace containing 6823 the variable. If SCOPE is NULL, the variable should is created in 6824 the innermost enclosings scope. */ 6825 6826static tree 6827grokvardecl (tree type, 6828 tree name, 6829 const cp_decl_specifier_seq *declspecs, 6830 int initialized, 6831 int constp, 6832 tree scope) 6833{ 6834 tree decl; 6835 tree explicit_scope; 6836 6837 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE); 6838 6839 /* Compute the scope in which to place the variable, but remember 6840 whether or not that scope was explicitly specified by the user. */ 6841 explicit_scope = scope; 6842 if (!scope) 6843 { 6844 /* An explicit "extern" specifier indicates a namespace-scope 6845 variable. */ 6846 if (declspecs->storage_class == sc_extern) 6847 scope = current_namespace; 6848 else if (!at_function_scope_p ()) 6849 scope = current_scope (); 6850 } 6851 6852 if (scope 6853 && (/* If the variable is a namespace-scope variable declared in a 6854 template, we need DECL_LANG_SPECIFIC. */ 6855 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl) 6856 /* Similarly for namespace-scope variables with language linkage 6857 other than C++. */ 6858 || (TREE_CODE (scope) == NAMESPACE_DECL 6859 && current_lang_name != lang_name_cplusplus) 6860 /* Similarly for static data members. */ 6861 || TYPE_P (scope))) 6862 decl = build_lang_decl (VAR_DECL, name, type); 6863 else 6864 decl = build_decl (VAR_DECL, name, type); 6865 6866 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL) 6867 set_decl_namespace (decl, explicit_scope, 0); 6868 else 6869 DECL_CONTEXT (decl) = FROB_CONTEXT (scope); 6870 6871 if (declspecs->storage_class == sc_extern) 6872 { 6873 DECL_THIS_EXTERN (decl) = 1; 6874 DECL_EXTERNAL (decl) = !initialized; 6875 } 6876 6877 if (DECL_CLASS_SCOPE_P (decl)) 6878 { 6879 set_linkage_for_static_data_member (decl); 6880 /* This function is only called with out-of-class definitions. */ 6881 DECL_EXTERNAL (decl) = 0; 6882 check_class_member_definition_namespace (decl); 6883 } 6884 /* At top level, either `static' or no s.c. makes a definition 6885 (perhaps tentative), and absence of `static' makes it public. */ 6886 else if (toplevel_bindings_p ()) 6887 { 6888 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static 6889 && (DECL_THIS_EXTERN (decl) || ! constp)); 6890 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl); 6891 } 6892 /* Not at top level, only `static' makes a static definition. */ 6893 else 6894 { 6895 TREE_STATIC (decl) = declspecs->storage_class == sc_static; 6896 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl); 6897 } 6898 6899 if (declspecs->specs[(int)ds_thread]) 6900 { 6901 if (targetm.have_tls) 6902 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl); 6903 else 6904 /* A mere warning is sure to result in improper semantics 6905 at runtime. Don't bother to allow this to compile. */ 6906 error ("thread-local storage not supported for this target"); 6907 } 6908 6909 if (TREE_PUBLIC (decl)) 6910 { 6911 /* [basic.link]: A name with no linkage (notably, the name of a class 6912 or enumeration declared in a local scope) shall not be used to 6913 declare an entity with linkage. 6914 6915 Only check this for public decls for now. */ 6916 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false); 6917 if (t) 6918 { 6919 if (TYPE_ANONYMOUS_P (t)) 6920 { 6921 if (DECL_EXTERN_C_P (decl)) 6922 /* Allow this; it's pretty common in C. */ 6923 ; 6924 else 6925 { 6926 /* DRs 132, 319 and 389 seem to indicate types with 6927 no linkage can only be used to declare extern "C" 6928 entities. Since it's not always an error in the 6929 ISO C++ 90 Standard, we only issue a warning. */ 6930 warning (0, "non-local variable %q#D uses anonymous type", 6931 decl); 6932 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t))) 6933 warning (0, "%q+#D does not refer to the unqualified " 6934 "type, so it is not used for linkage", 6935 TYPE_NAME (t)); 6936 } 6937 } 6938 else 6939 warning (0, "non-local variable %q#D uses local type %qT", decl, t); 6940 } 6941 } 6942 else 6943 DECL_INTERFACE_KNOWN (decl) = 1; 6944 6945 return decl; 6946} 6947 6948/* Create and return a canonical pointer to member function type, for 6949 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */ 6950 6951tree 6952build_ptrmemfunc_type (tree type) 6953{ 6954 tree field, fields; 6955 tree t; 6956 tree unqualified_variant = NULL_TREE; 6957 6958 if (type == error_mark_node) 6959 return type; 6960 6961 /* If a canonical type already exists for this type, use it. We use 6962 this method instead of type_hash_canon, because it only does a 6963 simple equality check on the list of field members. */ 6964 6965 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type))) 6966 return t; 6967 6968 /* Make sure that we always have the unqualified pointer-to-member 6969 type first. */ 6970 if (cp_type_quals (type) != TYPE_UNQUALIFIED) 6971 unqualified_variant 6972 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type)); 6973 6974 t = make_aggr_type (RECORD_TYPE); 6975 xref_basetypes (t, NULL_TREE); 6976 6977 /* Let the front-end know this is a pointer to member function... */ 6978 TYPE_PTRMEMFUNC_FLAG (t) = 1; 6979 /* ... and not really an aggregate. */ 6980 SET_IS_AGGR_TYPE (t, 0); 6981 6982 field = build_decl (FIELD_DECL, pfn_identifier, type); 6983 fields = field; 6984 6985 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node); 6986 TREE_CHAIN (field) = fields; 6987 fields = field; 6988 6989 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node); 6990 6991 /* Zap out the name so that the back-end will give us the debugging 6992 information for this anonymous RECORD_TYPE. */ 6993 TYPE_NAME (t) = NULL_TREE; 6994 6995 /* If this is not the unqualified form of this pointer-to-member 6996 type, set the TYPE_MAIN_VARIANT for this type to be the 6997 unqualified type. Since they are actually RECORD_TYPEs that are 6998 not variants of each other, we must do this manually. */ 6999 if (cp_type_quals (type) != TYPE_UNQUALIFIED) 7000 { 7001 t = build_qualified_type (t, cp_type_quals (type)); 7002 TYPE_MAIN_VARIANT (t) = unqualified_variant; 7003 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant); 7004 TYPE_NEXT_VARIANT (unqualified_variant) = t; 7005 } 7006 7007 /* Cache this pointer-to-member type so that we can find it again 7008 later. */ 7009 TYPE_SET_PTRMEMFUNC_TYPE (type, t); 7010 7011 return t; 7012} 7013 7014/* Create and return a pointer to data member type. */ 7015 7016tree 7017build_ptrmem_type (tree class_type, tree member_type) 7018{ 7019 if (TREE_CODE (member_type) == METHOD_TYPE) 7020 { 7021 tree arg_types; 7022 7023 arg_types = TYPE_ARG_TYPES (member_type); 7024 class_type = (cp_build_qualified_type 7025 (class_type, 7026 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types))))); 7027 member_type 7028 = build_method_type_directly (class_type, 7029 TREE_TYPE (member_type), 7030 TREE_CHAIN (arg_types)); 7031 return build_ptrmemfunc_type (build_pointer_type (member_type)); 7032 } 7033 else 7034 { 7035 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE); 7036 return build_offset_type (class_type, member_type); 7037 } 7038} 7039 7040/* DECL is a VAR_DECL defined in-class, whose TYPE is also given. 7041 Check to see that the definition is valid. Issue appropriate error 7042 messages. Return 1 if the definition is particularly bad, or 0 7043 otherwise. */ 7044 7045int 7046check_static_variable_definition (tree decl, tree type) 7047{ 7048 /* Motion 10 at San Diego: If a static const integral data member is 7049 initialized with an integral constant expression, the initializer 7050 may appear either in the declaration (within the class), or in 7051 the definition, but not both. If it appears in the class, the 7052 member is a member constant. The file-scope definition is always 7053 required. */ 7054 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE) 7055 { 7056 error ("invalid in-class initialization of static data member " 7057 "of non-integral type %qT", 7058 type); 7059 /* If we just return the declaration, crashes will sometimes 7060 occur. We therefore return void_type_node, as if this were a 7061 friend declaration, to cause callers to completely ignore 7062 this declaration. */ 7063 return 1; 7064 } 7065 else if (!CP_TYPE_CONST_P (type)) 7066 error ("ISO C++ forbids in-class initialization of non-const " 7067 "static member %qD", 7068 decl); 7069 else if (pedantic && !INTEGRAL_TYPE_P (type)) 7070 pedwarn ("ISO C++ forbids initialization of member constant " 7071 "%qD of non-integral type %qT", decl, type); 7072 7073 return 0; 7074} 7075 7076/* Given the SIZE (i.e., number of elements) in an array, compute an 7077 appropriate index type for the array. If non-NULL, NAME is the 7078 name of the thing being declared. */ 7079 7080tree 7081compute_array_index_type (tree name, tree size) 7082{ 7083 tree type; 7084 tree itype; 7085 7086 if (error_operand_p (size)) 7087 return error_mark_node; 7088 7089 type = TREE_TYPE (size); 7090 /* The array bound must be an integer type. */ 7091 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type)) 7092 { 7093 if (name) 7094 error ("size of array %qD has non-integral type %qT", name, type); 7095 else 7096 error ("size of array has non-integral type %qT", type); 7097 size = integer_one_node; 7098 type = TREE_TYPE (size); 7099 } 7100 7101 if (abi_version_at_least (2) 7102 /* We should only handle value dependent expressions specially. */ 7103 ? value_dependent_expression_p (size) 7104 /* But for abi-1, we handled all instances in templates. This 7105 effects the manglings produced. */ 7106 : processing_template_decl) 7107 return build_index_type (build_min (MINUS_EXPR, sizetype, 7108 size, integer_one_node)); 7109 7110 /* The size might be the result of a cast. */ 7111 STRIP_TYPE_NOPS (size); 7112 7113 /* It might be a const variable or enumeration constant. */ 7114 size = integral_constant_value (size); 7115 7116 /* Normally, the array-bound will be a constant. */ 7117 if (TREE_CODE (size) == INTEGER_CST) 7118 { 7119 /* Check to see if the array bound overflowed. Make that an 7120 error, no matter how generous we're being. */ 7121 int old_flag_pedantic_errors = flag_pedantic_errors; 7122 int old_pedantic = pedantic; 7123 pedantic = flag_pedantic_errors = 1; 7124 constant_expression_warning (size); 7125 pedantic = old_pedantic; 7126 flag_pedantic_errors = old_flag_pedantic_errors; 7127 7128 /* An array must have a positive number of elements. */ 7129 if (INT_CST_LT (size, integer_zero_node)) 7130 { 7131 if (name) 7132 error ("size of array %qD is negative", name); 7133 else 7134 error ("size of array is negative"); 7135 size = integer_one_node; 7136 } 7137 /* As an extension we allow zero-sized arrays. We always allow 7138 them in system headers because glibc uses them. */ 7139 else if (integer_zerop (size) && pedantic && !in_system_header) 7140 { 7141 if (name) 7142 pedwarn ("ISO C++ forbids zero-size array %qD", name); 7143 else 7144 pedwarn ("ISO C++ forbids zero-size array"); 7145 } 7146 } 7147 else if (TREE_CONSTANT (size)) 7148 { 7149 /* `(int) &fn' is not a valid array bound. */ 7150 if (name) 7151 error ("size of array %qD is not an integral constant-expression", 7152 name); 7153 else 7154 error ("size of array is not an integral constant-expression"); 7155 size = integer_one_node; 7156 } 7157 else if (pedantic && warn_vla != 0) 7158 { 7159 if (name) 7160 pedwarn ("ISO C++ forbids variable length array %qD", name); 7161 else 7162 pedwarn ("ISO C++ forbids variable length array"); 7163 } 7164 else if (warn_vla > 0) 7165 { 7166 if (name) 7167 warning (OPT_Wvla, 7168 "variable length array %qD is used", name); 7169 else 7170 warning (OPT_Wvla, 7171 "variable length array is used"); 7172 } 7173 7174 if (processing_template_decl && !TREE_CONSTANT (size)) 7175 /* A variable sized array. */ 7176 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node); 7177 else 7178 { 7179 HOST_WIDE_INT saved_processing_template_decl; 7180 7181 /* Compute the index of the largest element in the array. It is 7182 one less than the number of elements in the array. We save 7183 and restore PROCESSING_TEMPLATE_DECL so that computations in 7184 cp_build_binary_op will be appropriately folded. */ 7185 saved_processing_template_decl = processing_template_decl; 7186 processing_template_decl = 0; 7187 itype = cp_build_binary_op (MINUS_EXPR, 7188 cp_convert (ssizetype, size), 7189 cp_convert (ssizetype, integer_one_node)); 7190 itype = fold (itype); 7191 processing_template_decl = saved_processing_template_decl; 7192 7193 if (!TREE_CONSTANT (itype)) 7194 /* A variable sized array. */ 7195 itype = variable_size (itype); 7196 /* Make sure that there was no overflow when creating to a signed 7197 index type. (For example, on a 32-bit machine, an array with 7198 size 2^32 - 1 is too big.) */ 7199 else if (TREE_CODE (itype) == INTEGER_CST 7200 && TREE_OVERFLOW (itype)) 7201 { 7202 error ("overflow in array dimension"); 7203 TREE_OVERFLOW (itype) = 0; 7204 } 7205 } 7206 7207 /* Create and return the appropriate index type. */ 7208 return build_index_type (itype); 7209} 7210 7211/* Returns the scope (if any) in which the entity declared by 7212 DECLARATOR will be located. If the entity was declared with an 7213 unqualified name, NULL_TREE is returned. */ 7214 7215tree 7216get_scope_of_declarator (const cp_declarator *declarator) 7217{ 7218 while (declarator && declarator->kind != cdk_id) 7219 declarator = declarator->declarator; 7220 7221 /* If the declarator-id is a SCOPE_REF, the scope in which the 7222 declaration occurs is the first operand. */ 7223 if (declarator 7224 && declarator->u.id.qualifying_scope) 7225 return declarator->u.id.qualifying_scope; 7226 7227 /* Otherwise, the declarator is not a qualified name; the entity will 7228 be declared in the current scope. */ 7229 return NULL_TREE; 7230} 7231 7232/* Returns an ARRAY_TYPE for an array with SIZE elements of the 7233 indicated TYPE. If non-NULL, NAME is the NAME of the declaration 7234 with this type. */ 7235 7236static tree 7237create_array_type_for_decl (tree name, tree type, tree size) 7238{ 7239 tree itype = NULL_TREE; 7240 const char* error_msg; 7241 7242 /* If things have already gone awry, bail now. */ 7243 if (type == error_mark_node || size == error_mark_node) 7244 return error_mark_node; 7245 7246 /* Assume that everything will go OK. */ 7247 error_msg = NULL; 7248 7249 /* There are some types which cannot be array elements. */ 7250 switch (TREE_CODE (type)) 7251 { 7252 case VOID_TYPE: 7253 error_msg = "array of void"; 7254 break; 7255 7256 case FUNCTION_TYPE: 7257 error_msg = "array of functions"; 7258 break; 7259 7260 case REFERENCE_TYPE: 7261 error_msg = "array of references"; 7262 break; 7263 7264 case METHOD_TYPE: 7265 error_msg = "array of function members"; 7266 break; 7267 7268 default: 7269 break; 7270 } 7271 7272 /* If something went wrong, issue an error-message and return. */ 7273 if (error_msg) 7274 { 7275 if (name) 7276 error ("declaration of %qD as %s", name, error_msg); 7277 else 7278 error ("creating %s", error_msg); 7279 7280 return error_mark_node; 7281 } 7282 7283 /* [dcl.array] 7284 7285 The constant expressions that specify the bounds of the arrays 7286 can be omitted only for the first member of the sequence. */ 7287 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)) 7288 { 7289 if (name) 7290 error ("declaration of %qD as multidimensional array must " 7291 "have bounds for all dimensions except the first", 7292 name); 7293 else 7294 error ("multidimensional array must have bounds for all " 7295 "dimensions except the first"); 7296 7297 return error_mark_node; 7298 } 7299 7300 /* Figure out the index type for the array. */ 7301 if (size) 7302 itype = compute_array_index_type (name, size); 7303 7304 /* [dcl.array] 7305 T is called the array element type; this type shall not be [...] an 7306 abstract class type. */ 7307 abstract_virtuals_error (name, type); 7308 7309 return build_cplus_array_type (type, itype); 7310} 7311 7312/* Check that it's OK to declare a function with the indicated TYPE. 7313 SFK indicates the kind of special function (if any) that this 7314 function is. OPTYPE is the type given in a conversion operator 7315 declaration, or the class type for a constructor/destructor. 7316 Returns the actual return type of the function; that 7317 may be different than TYPE if an error occurs, or for certain 7318 special functions. */ 7319 7320static tree 7321check_special_function_return_type (special_function_kind sfk, 7322 tree type, 7323 tree optype) 7324{ 7325 switch (sfk) 7326 { 7327 case sfk_constructor: 7328 if (type) 7329 error ("return type specification for constructor invalid"); 7330 7331 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype)) 7332 type = build_pointer_type (optype); 7333 else 7334 type = void_type_node; 7335 break; 7336 7337 case sfk_destructor: 7338 if (type) 7339 error ("return type specification for destructor invalid"); 7340 /* We can't use the proper return type here because we run into 7341 problems with ambiguous bases and covariant returns. 7342 Java classes are left unchanged because (void *) isn't a valid 7343 Java type, and we don't want to change the Java ABI. */ 7344 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype)) 7345 type = build_pointer_type (void_type_node); 7346 else 7347 type = void_type_node; 7348 break; 7349 7350 case sfk_conversion: 7351 if (type && !same_type_p (type, optype)) 7352 error ("operator %qT declared to return %qT", optype, type); 7353 else if (type) 7354 pedwarn ("return type specified for %<operator %T%>", optype); 7355 type = optype; 7356 break; 7357 7358 default: 7359 gcc_unreachable (); 7360 } 7361 7362 return type; 7363} 7364 7365/* A variable or data member (whose unqualified name is IDENTIFIER) 7366 has been declared with the indicated TYPE. If the TYPE is not 7367 acceptable, issue an error message and return a type to use for 7368 error-recovery purposes. */ 7369 7370tree 7371check_var_type (tree identifier, tree type) 7372{ 7373 if (VOID_TYPE_P (type)) 7374 { 7375 if (!identifier) 7376 error ("unnamed variable or field declared void"); 7377 else if (TREE_CODE (identifier) == IDENTIFIER_NODE) 7378 { 7379 gcc_assert (!IDENTIFIER_OPNAME_P (identifier)); 7380 error ("variable or field %qE declared void", identifier); 7381 } 7382 else 7383 error ("variable or field declared void"); 7384 type = error_mark_node; 7385 } 7386 7387 return type; 7388} 7389 7390/* Given declspecs and a declarator (abstract or otherwise), determine 7391 the name and type of the object declared and construct a DECL node 7392 for it. 7393 7394 DECLSPECS is a chain of tree_list nodes whose value fields 7395 are the storage classes and type specifiers. 7396 7397 DECL_CONTEXT says which syntactic context this declaration is in: 7398 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL. 7399 FUNCDEF for a function definition. Like NORMAL but a few different 7400 error messages in each case. Return value may be zero meaning 7401 this definition is too screwy to try to parse. 7402 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to 7403 handle member functions (which have FIELD context). 7404 Return value may be zero meaning this definition is too screwy to 7405 try to parse. 7406 PARM for a parameter declaration (either within a function prototype 7407 or before a function body). Make a PARM_DECL, or return void_type_node. 7408 CATCHPARM for a parameter declaration before a catch clause. 7409 TYPENAME if for a typename (in a cast or sizeof). 7410 Don't make a DECL node; just return the ..._TYPE node. 7411 FIELD for a struct or union field; make a FIELD_DECL. 7412 BITFIELD for a field with specified width. 7413 INITIALIZED is 1 if the decl has an initializer. 7414 7415 ATTRLIST is a pointer to the list of attributes, which may be NULL 7416 if there are none; *ATTRLIST may be modified if attributes from inside 7417 the declarator should be applied to the declaration. 7418 7419 When this function is called, scoping variables (such as 7420 CURRENT_CLASS_TYPE) should reflect the scope in which the 7421 declaration occurs, not the scope in which the new declaration will 7422 be placed. For example, on: 7423 7424 void S::f() { ... } 7425 7426 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE 7427 should not be `S'. 7428 7429 Returns a DECL (if a declarator is present), a TYPE (if there is no 7430 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an 7431 error occurs. */ 7432 7433tree 7434grokdeclarator (const cp_declarator *declarator, 7435 const cp_decl_specifier_seq *declspecs, 7436 enum decl_context decl_context, 7437 int initialized, 7438 tree* attrlist) 7439{ 7440 tree type = NULL_TREE; 7441 int longlong = 0; 7442 int virtualp, explicitp, friendp, inlinep, staticp; 7443 int explicit_int = 0; 7444 int explicit_char = 0; 7445 int defaulted_int = 0; 7446 tree dependent_name = NULL_TREE; 7447 7448 tree typedef_decl = NULL_TREE; 7449 const char *name = NULL; 7450 tree typedef_type = NULL_TREE; 7451 /* True if this declarator is a function definition. */ 7452 bool funcdef_flag = false; 7453 cp_declarator_kind innermost_code = cdk_error; 7454 int bitfield = 0; 7455#if 0 7456 /* See the code below that used this. */ 7457 tree decl_attr = NULL_TREE; 7458#endif 7459 7460 /* Keep track of what sort of function is being processed 7461 so that we can warn about default return values, or explicit 7462 return values which do not match prescribed defaults. */ 7463 special_function_kind sfk = sfk_none; 7464 7465 tree dname = NULL_TREE; 7466 tree ctor_return_type = NULL_TREE; 7467 enum overload_flags flags = NO_SPECIAL; 7468 /* cv-qualifiers that apply to the declarator, for a declaration of 7469 a member function. */ 7470 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED; 7471 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */ 7472 int type_quals; 7473 tree raises = NULL_TREE; 7474 int template_count = 0; 7475 tree returned_attrs = NULL_TREE; 7476 tree parms = NULL_TREE; 7477 const cp_declarator *id_declarator; 7478 /* The unqualified name of the declarator; either an 7479 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */ 7480 tree unqualified_id; 7481 /* The class type, if any, in which this entity is located, 7482 or NULL_TREE if none. Note that this value may be different from 7483 the current class type; for example if an attempt is made to declare 7484 "A::f" inside "B", this value will be "A". */ 7485 tree ctype = current_class_type; 7486 /* The NAMESPACE_DECL for the namespace in which this entity is 7487 located. If an unqualified name is used to declare the entity, 7488 this value will be NULL_TREE, even if the entity is located at 7489 namespace scope. */ 7490 tree in_namespace = NULL_TREE; 7491 cp_storage_class storage_class; 7492 bool unsigned_p, signed_p, short_p, long_p, thread_p; 7493 bool type_was_error_mark_node = false; 7494 7495 signed_p = declspecs->specs[(int)ds_signed]; 7496 unsigned_p = declspecs->specs[(int)ds_unsigned]; 7497 short_p = declspecs->specs[(int)ds_short]; 7498 long_p = declspecs->specs[(int)ds_long]; 7499 longlong = declspecs->specs[(int)ds_long] >= 2; 7500 thread_p = declspecs->specs[(int)ds_thread]; 7501 7502 if (decl_context == FUNCDEF) 7503 funcdef_flag = true, decl_context = NORMAL; 7504 else if (decl_context == MEMFUNCDEF) 7505 funcdef_flag = true, decl_context = FIELD; 7506 else if (decl_context == BITFIELD) 7507 bitfield = 1, decl_context = FIELD; 7508 7509 /* Look inside a declarator for the name being declared 7510 and get it as a string, for an error message. */ 7511 for (id_declarator = declarator; 7512 id_declarator; 7513 id_declarator = id_declarator->declarator) 7514 { 7515 if (id_declarator->kind != cdk_id) 7516 innermost_code = id_declarator->kind; 7517 7518 switch (id_declarator->kind) 7519 { 7520 case cdk_function: 7521 if (id_declarator->declarator 7522 && id_declarator->declarator->kind == cdk_id) 7523 { 7524 sfk = id_declarator->declarator->u.id.sfk; 7525 if (sfk == sfk_destructor) 7526 flags = DTOR_FLAG; 7527 } 7528 break; 7529 7530 case cdk_id: 7531 { 7532 tree qualifying_scope = id_declarator->u.id.qualifying_scope; 7533 tree decl = id_declarator->u.id.unqualified_name; 7534 if (!decl) 7535 break; 7536 if (qualifying_scope) 7537 { 7538 if (at_function_scope_p ()) 7539 { 7540 /* [dcl.meaning] 7541 7542 A declarator-id shall not be qualified except 7543 for ... 7544 7545 None of the cases are permitted in block 7546 scope. */ 7547 if (qualifying_scope == global_namespace) 7548 error ("invalid use of qualified-name %<::%D%>", 7549 decl); 7550 else if (TYPE_P (qualifying_scope)) 7551 error ("invalid use of qualified-name %<%T::%D%>", 7552 qualifying_scope, decl); 7553 else 7554 error ("invalid use of qualified-name %<%D::%D%>", 7555 qualifying_scope, decl); 7556 return error_mark_node; 7557 } 7558 else if (TYPE_P (qualifying_scope)) 7559 { 7560 ctype = qualifying_scope; 7561 if (innermost_code != cdk_function 7562 && current_class_type 7563 && !UNIQUELY_DERIVED_FROM_P (ctype, 7564 current_class_type)) 7565 { 7566 error ("type %qT is not derived from type %qT", 7567 ctype, current_class_type); 7568 return error_mark_node; 7569 } 7570 } 7571 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL) 7572 in_namespace = qualifying_scope; 7573 } 7574 switch (TREE_CODE (decl)) 7575 { 7576 case BIT_NOT_EXPR: 7577 { 7578 tree type; 7579 7580 if (innermost_code != cdk_function) 7581 { 7582 error ("declaration of %qD as non-function", decl); 7583 return error_mark_node; 7584 } 7585 else if (!qualifying_scope 7586 && !(current_class_type && at_class_scope_p ())) 7587 { 7588 error ("declaration of %qD as non-member", decl); 7589 return error_mark_node; 7590 } 7591 7592 type = TREE_OPERAND (decl, 0); 7593 name = IDENTIFIER_POINTER (constructor_name (type)); 7594 dname = decl; 7595 } 7596 break; 7597 7598 case TEMPLATE_ID_EXPR: 7599 { 7600 tree fns = TREE_OPERAND (decl, 0); 7601 7602 dname = fns; 7603 if (TREE_CODE (dname) != IDENTIFIER_NODE) 7604 { 7605 gcc_assert (is_overloaded_fn (dname)); 7606 dname = DECL_NAME (get_first_fn (dname)); 7607 } 7608 } 7609 /* Fall through. */ 7610 7611 case IDENTIFIER_NODE: 7612 if (TREE_CODE (decl) == IDENTIFIER_NODE) 7613 dname = decl; 7614 7615 if (C_IS_RESERVED_WORD (dname)) 7616 { 7617 error ("declarator-id missing; using reserved word %qD", 7618 dname); 7619 name = IDENTIFIER_POINTER (dname); 7620 } 7621 else if (!IDENTIFIER_TYPENAME_P (dname)) 7622 name = IDENTIFIER_POINTER (dname); 7623 else 7624 { 7625 gcc_assert (flags == NO_SPECIAL); 7626 flags = TYPENAME_FLAG; 7627 ctor_return_type = TREE_TYPE (dname); 7628 sfk = sfk_conversion; 7629 if (is_typename_at_global_scope (dname)) 7630 name = IDENTIFIER_POINTER (dname); 7631 else 7632 name = "<invalid operator>"; 7633 } 7634 break; 7635 7636 default: 7637 gcc_unreachable (); 7638 } 7639 break; 7640 7641 case cdk_array: 7642 case cdk_pointer: 7643 case cdk_reference: 7644 case cdk_ptrmem: 7645 /* APPLE LOCAL blocks 6040305 */ 7646 case cdk_block_pointer: 7647 break; 7648 7649 case cdk_error: 7650 return error_mark_node; 7651 7652 default: 7653 gcc_unreachable (); 7654 } 7655 } 7656 if (id_declarator->kind == cdk_id) 7657 break; 7658 } 7659 7660 /* [dcl.fct.edf] 7661 7662 The declarator in a function-definition shall have the form 7663 D1 ( parameter-declaration-clause) ... */ 7664 if (funcdef_flag && innermost_code != cdk_function) 7665 { 7666 error ("function definition does not declare parameters"); 7667 return error_mark_node; 7668 } 7669 7670 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG) 7671 && innermost_code != cdk_function 7672 && ! (ctype && !declspecs->any_specifiers_p)) 7673 { 7674 error ("declaration of %qD as non-function", dname); 7675 return error_mark_node; 7676 } 7677 7678 /* Anything declared one level down from the top level 7679 must be one of the parameters of a function 7680 (because the body is at least two levels down). */ 7681 7682 /* This heuristic cannot be applied to C++ nodes! Fixed, however, 7683 by not allowing C++ class definitions to specify their parameters 7684 with xdecls (must be spec.d in the parmlist). 7685 7686 Since we now wait to push a class scope until we are sure that 7687 we are in a legitimate method context, we must set oldcname 7688 explicitly (since current_class_name is not yet alive). 7689 7690 We also want to avoid calling this a PARM if it is in a namespace. */ 7691 7692 if (decl_context == NORMAL && !toplevel_bindings_p ()) 7693 { 7694 struct cp_binding_level *b = current_binding_level; 7695 current_binding_level = b->level_chain; 7696 if (current_binding_level != 0 && toplevel_bindings_p ()) 7697 decl_context = PARM; 7698 current_binding_level = b; 7699 } 7700 7701 if (name == NULL) 7702 name = decl_context == PARM ? "parameter" : "type name"; 7703 7704 /* If there were multiple types specified in the decl-specifier-seq, 7705 issue an error message. */ 7706 if (declspecs->multiple_types_p) 7707 { 7708 error ("two or more data types in declaration of %qs", name); 7709 return error_mark_node; 7710 } 7711 7712 /* Extract the basic type from the decl-specifier-seq. */ 7713 type = declspecs->type; 7714 if (type == error_mark_node) 7715 { 7716 type = NULL_TREE; 7717 type_was_error_mark_node = true; 7718 } 7719 7720 /* APPLE LOCAL begin unavailable attribute (radar 2809697) --bowdidge */ 7721 /* If the entire declaration is itself tagged as unavailable then 7722 suppress reports of unavailable/deprecated items. If the 7723 entire declaration is tagged as only deprecated we still 7724 report unavailable uses. */ 7725 if (type && TREE_DEPRECATED (type) && TREE_UNAVAILABLE (type)) 7726 { 7727 if (deprecated_state != DEPRECATED_UNAVAILABLE_SUPPRESS) 7728 warn_deprecated_use (type); 7729 } 7730 else 7731 /* APPLE LOCAL end unavailable attribute (radar 2809697) --bowdidge */ 7732 /* If the entire declaration is itself tagged as deprecated then 7733 suppress reports of deprecated items. */ 7734 if (type && TREE_DEPRECATED (type) 7735 && deprecated_state != DEPRECATED_SUPPRESS) 7736 warn_deprecated_use (type); 7737 if (type && TREE_CODE (type) == TYPE_DECL) 7738 { 7739 typedef_decl = type; 7740 type = TREE_TYPE (typedef_decl); 7741 } 7742 /* No type at all: default to `int', and set DEFAULTED_INT 7743 because it was not a user-defined typedef. */ 7744 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p)) 7745 { 7746 /* These imply 'int'. */ 7747 type = integer_type_node; 7748 defaulted_int = 1; 7749 } 7750 /* Gather flags. */ 7751 explicit_int = declspecs->explicit_int_p; 7752 explicit_char = declspecs->explicit_char_p; 7753 7754#if 0 7755 /* See the code below that used this. */ 7756 if (typedef_decl) 7757 decl_attr = DECL_ATTRIBUTES (typedef_decl); 7758#endif 7759 typedef_type = type; 7760 7761 7762 if (sfk != sfk_conversion) 7763 ctor_return_type = ctype; 7764 7765 if (sfk != sfk_none) 7766 type = check_special_function_return_type (sfk, type, 7767 ctor_return_type); 7768 else if (type == NULL_TREE) 7769 { 7770 int is_main; 7771 7772 explicit_int = -1; 7773 7774 /* We handle `main' specially here, because 'main () { }' is so 7775 common. With no options, it is allowed. With -Wreturn-type, 7776 it is a warning. It is only an error with -pedantic-errors. */ 7777 is_main = (funcdef_flag 7778 && dname && MAIN_NAME_P (dname) 7779 && ctype == NULL_TREE 7780 && in_namespace == NULL_TREE 7781 && current_namespace == global_namespace); 7782 7783 if (type_was_error_mark_node) 7784 /* We've already issued an error, don't complain more. */; 7785 else if (in_system_header || flag_ms_extensions) 7786 /* Allow it, sigh. */; 7787 else if (pedantic || ! is_main) 7788 pedwarn ("ISO C++ forbids declaration of %qs with no type", name); 7789 else if (warn_return_type) 7790 warning (0, "ISO C++ forbids declaration of %qs with no type", name); 7791 7792 type = integer_type_node; 7793 } 7794 7795 ctype = NULL_TREE; 7796 7797 /* Now process the modifiers that were specified 7798 and check for invalid combinations. */ 7799 7800 /* Long double is a special combination. */ 7801 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node) 7802 { 7803 long_p = false; 7804 type = build_qualified_type (long_double_type_node, 7805 cp_type_quals (type)); 7806 } 7807 7808 /* Check all other uses of type modifiers. */ 7809 7810 if (unsigned_p || signed_p || long_p || short_p) 7811 { 7812 int ok = 0; 7813 7814 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE) 7815 error ("%<signed%> or %<unsigned%> invalid for %qs", name); 7816 else if (signed_p && unsigned_p) 7817 error ("%<signed%> and %<unsigned%> specified together for %qs", name); 7818 else if (longlong && TREE_CODE (type) != INTEGER_TYPE) 7819 error ("%<long long%> invalid for %qs", name); 7820 else if (long_p && TREE_CODE (type) == REAL_TYPE) 7821 error ("%<long%> invalid for %qs", name); 7822 else if (short_p && TREE_CODE (type) == REAL_TYPE) 7823 error ("%<short%> invalid for %qs", name); 7824 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE) 7825 error ("%<long%> or %<short%> invalid for %qs", name); 7826 else if ((long_p || short_p) && explicit_char) 7827 error ("%<long%> or %<short%> specified with char for %qs", name); 7828 else if (long_p && short_p) 7829 error ("%<long%> and %<short%> specified together for %qs", name); 7830 else 7831 { 7832 ok = 1; 7833 if (!explicit_int && !defaulted_int && !explicit_char && pedantic) 7834 { 7835 pedwarn ("long, short, signed or unsigned used invalidly for %qs", 7836 name); 7837 if (flag_pedantic_errors) 7838 ok = 0; 7839 } 7840 } 7841 7842 /* Discard the type modifiers if they are invalid. */ 7843 if (! ok) 7844 { 7845 unsigned_p = false; 7846 signed_p = false; 7847 long_p = false; 7848 short_p = false; 7849 longlong = 0; 7850 } 7851 } 7852 7853 /* Decide whether an integer type is signed or not. 7854 Optionally treat bitfields as signed by default. */ 7855 if (unsigned_p 7856 /* [class.bit] 7857 7858 It is implementation-defined whether a plain (neither 7859 explicitly signed or unsigned) char, short, int, or long 7860 bit-field is signed or unsigned. 7861 7862 Naturally, we extend this to long long as well. Note that 7863 this does not include wchar_t. */ 7864 || (bitfield && !flag_signed_bitfields 7865 && !signed_p 7866 /* A typedef for plain `int' without `signed' can be 7867 controlled just like plain `int', but a typedef for 7868 `signed int' cannot be so controlled. */ 7869 && !(typedef_decl 7870 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)) 7871 && TREE_CODE (type) == INTEGER_TYPE 7872 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node))) 7873 { 7874 if (longlong) 7875 type = long_long_unsigned_type_node; 7876 else if (long_p) 7877 type = long_unsigned_type_node; 7878 else if (short_p) 7879 type = short_unsigned_type_node; 7880 else if (type == char_type_node) 7881 type = unsigned_char_type_node; 7882 else if (typedef_decl) 7883 type = c_common_unsigned_type (type); 7884 else 7885 type = unsigned_type_node; 7886 } 7887 else if (signed_p && type == char_type_node) 7888 type = signed_char_type_node; 7889 else if (longlong) 7890 type = long_long_integer_type_node; 7891 else if (long_p) 7892 type = long_integer_type_node; 7893 else if (short_p) 7894 type = short_integer_type_node; 7895 7896 if (declspecs->specs[(int)ds_complex]) 7897 { 7898 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE) 7899 error ("complex invalid for %qs", name); 7900 /* If we just have "complex", it is equivalent to 7901 "complex double", but if any modifiers at all are specified it is 7902 the complex form of TYPE. E.g, "complex short" is 7903 "complex short int". */ 7904 7905 else if (defaulted_int && ! longlong 7906 && ! (long_p || short_p || signed_p || unsigned_p)) 7907 type = complex_double_type_node; 7908 else if (type == integer_type_node) 7909 type = complex_integer_type_node; 7910 else if (type == float_type_node) 7911 type = complex_float_type_node; 7912 else if (type == double_type_node) 7913 type = complex_double_type_node; 7914 else if (type == long_double_type_node) 7915 type = complex_long_double_type_node; 7916 else 7917 type = build_complex_type (type); 7918 } 7919 7920 type_quals = TYPE_UNQUALIFIED; 7921 if (declspecs->specs[(int)ds_const]) 7922 type_quals |= TYPE_QUAL_CONST; 7923 if (declspecs->specs[(int)ds_volatile]) 7924 type_quals |= TYPE_QUAL_VOLATILE; 7925 if (declspecs->specs[(int)ds_restrict]) 7926 type_quals |= TYPE_QUAL_RESTRICT; 7927 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED) 7928 error ("qualifiers are not allowed on declaration of %<operator %T%>", 7929 ctor_return_type); 7930 7931 if (TREE_CODE (type) == FUNCTION_TYPE 7932 && type_quals != TYPE_UNQUALIFIED) 7933 { 7934 /* This was an error in C++98 (cv-qualifiers cannot be added to 7935 a function type), but DR 295 makes the code well-formed by 7936 dropping the extra qualifiers. */ 7937 if (pedantic) 7938 { 7939 tree bad_type = build_qualified_type (type, type_quals); 7940 pedwarn ("ignoring %qV qualifiers added to function type %qT", 7941 bad_type, type); 7942 } 7943 type_quals = TYPE_UNQUALIFIED; 7944 } 7945 type_quals |= cp_type_quals (type); 7946 type = cp_build_qualified_type_real 7947 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl) 7948 ? tf_ignore_bad_quals : 0) | tf_warning_or_error)); 7949 /* We might have ignored or rejected some of the qualifiers. */ 7950 type_quals = cp_type_quals (type); 7951 7952 staticp = 0; 7953 inlinep = !! declspecs->specs[(int)ds_inline]; 7954 virtualp = !! declspecs->specs[(int)ds_virtual]; 7955 explicitp = !! declspecs->specs[(int)ds_explicit]; 7956 7957 storage_class = declspecs->storage_class; 7958 if (storage_class == sc_static) 7959 staticp = 1 + (decl_context == FIELD); 7960 7961 if (virtualp && staticp == 2) 7962 { 7963 error ("member %qD cannot be declared both virtual and static", dname); 7964 storage_class = sc_none; 7965 staticp = 0; 7966 } 7967 friendp = !! declspecs->specs[(int)ds_friend]; 7968 7969 if (dependent_name && !friendp) 7970 { 7971 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name); 7972 return error_mark_node; 7973 } 7974 7975 /* Issue errors about use of storage classes for parameters. */ 7976 if (decl_context == PARM) 7977 { 7978 if (declspecs->specs[(int)ds_typedef]) 7979 { 7980 error ("typedef declaration invalid in parameter declaration"); 7981 return error_mark_node; 7982 } 7983 else if (storage_class == sc_static 7984 || storage_class == sc_extern 7985 || thread_p) 7986 error ("storage class specifiers invalid in parameter declarations"); 7987 } 7988 7989 /* Give error if `virtual' is used outside of class declaration. */ 7990 if (virtualp 7991 && (current_class_name == NULL_TREE || decl_context != FIELD)) 7992 { 7993 error ("virtual outside class declaration"); 7994 virtualp = 0; 7995 } 7996 7997 /* Static anonymous unions are dealt with here. */ 7998 if (staticp && decl_context == TYPENAME 7999 && declspecs->type 8000 && ANON_AGGR_TYPE_P (declspecs->type)) 8001 decl_context = FIELD; 8002 8003 /* Warn about storage classes that are invalid for certain 8004 kinds of declarations (parameters, typenames, etc.). */ 8005 if (thread_p 8006 && ((storage_class 8007 && storage_class != sc_extern 8008 && storage_class != sc_static) 8009 || declspecs->specs[(int)ds_typedef])) 8010 { 8011 error ("multiple storage classes in declaration of %qs", name); 8012 thread_p = false; 8013 } 8014 if (declspecs->conflicting_specifiers_p) 8015 { 8016 error ("conflicting specifiers in declaration of %qs", name); 8017 storage_class = sc_none; 8018 } 8019 else if (decl_context != NORMAL 8020 && ((storage_class != sc_none 8021 && storage_class != sc_mutable) 8022 || thread_p)) 8023 { 8024 if ((decl_context == PARM || decl_context == CATCHPARM) 8025 && (storage_class == sc_register 8026 || storage_class == sc_auto)) 8027 ; 8028 else if (declspecs->specs[(int)ds_typedef]) 8029 ; 8030 else if (decl_context == FIELD 8031 /* C++ allows static class elements. */ 8032 && storage_class == sc_static) 8033 /* C++ also allows inlines and signed and unsigned elements, 8034 but in those cases we don't come in here. */ 8035 ; 8036 else 8037 { 8038 if (decl_context == FIELD) 8039 error ("storage class specified for %qs", name); 8040 else 8041 { 8042 if (decl_context == PARM || decl_context == CATCHPARM) 8043 error ("storage class specified for parameter %qs", name); 8044 else 8045 error ("storage class specified for typename"); 8046 } 8047 if (storage_class == sc_register 8048 || storage_class == sc_auto 8049 || storage_class == sc_extern 8050 || thread_p) 8051 storage_class = sc_none; 8052 } 8053 } 8054 else if (storage_class == sc_extern && initialized 8055 && !funcdef_flag) 8056 { 8057 if (toplevel_bindings_p ()) 8058 { 8059 /* It's common practice (and completely valid) to have a const 8060 be initialized and declared extern. */ 8061 if (!(type_quals & TYPE_QUAL_CONST)) 8062 warning (0, "%qs initialized and declared %<extern%>", name); 8063 } 8064 else 8065 error ("%qs has both %<extern%> and initializer", name); 8066 } 8067 else if (storage_class == sc_extern && funcdef_flag 8068 && ! toplevel_bindings_p ()) 8069 error ("nested function %qs declared %<extern%>", name); 8070 else if (toplevel_bindings_p ()) 8071 { 8072 if (storage_class == sc_auto) 8073 error ("top-level declaration of %qs specifies %<auto%>", name); 8074 } 8075 else if (thread_p 8076 && storage_class != sc_extern 8077 && storage_class != sc_static) 8078 { 8079 error ("function-scope %qs implicitly auto and declared %<__thread%>", 8080 name); 8081 thread_p = false; 8082 } 8083 8084 if (storage_class && friendp) 8085 error ("storage class specifiers invalid in friend function declarations"); 8086 8087 if (!id_declarator) 8088 unqualified_id = NULL_TREE; 8089 else 8090 { 8091 unqualified_id = id_declarator->u.id.unqualified_name; 8092 switch (TREE_CODE (unqualified_id)) 8093 { 8094 case BIT_NOT_EXPR: 8095 unqualified_id 8096 = constructor_name (TREE_OPERAND (unqualified_id, 0)); 8097 break; 8098 8099 case IDENTIFIER_NODE: 8100 case TEMPLATE_ID_EXPR: 8101 break; 8102 8103 default: 8104 gcc_unreachable (); 8105 } 8106 } 8107 8108 /* Determine the type of the entity declared by recurring on the 8109 declarator. */ 8110 for (; declarator; declarator = declarator->declarator) 8111 { 8112 const cp_declarator *inner_declarator; 8113 tree attrs; 8114 8115 if (type == error_mark_node) 8116 return error_mark_node; 8117 8118 attrs = declarator->attributes; 8119 if (attrs) 8120 { 8121 int attr_flags; 8122 8123 attr_flags = 0; 8124 if (declarator == NULL || declarator->kind == cdk_id) 8125 attr_flags |= (int) ATTR_FLAG_DECL_NEXT; 8126 if (declarator->kind == cdk_function) 8127 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT; 8128 if (declarator->kind == cdk_array) 8129 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT; 8130 returned_attrs = decl_attributes (&type, 8131 chainon (returned_attrs, attrs), 8132 attr_flags); 8133 } 8134 8135 if (declarator->kind == cdk_id) 8136 break; 8137 8138 inner_declarator = declarator->declarator; 8139 8140 switch (declarator->kind) 8141 { 8142 case cdk_array: 8143 type = create_array_type_for_decl (dname, type, 8144 declarator->u.array.bounds); 8145 break; 8146 8147 case cdk_function: 8148 { 8149 tree arg_types; 8150 int funcdecl_p; 8151 8152 /* Declaring a function type. 8153 Make sure we have a valid type for the function to return. */ 8154 8155 /* We now know that the TYPE_QUALS don't apply to the 8156 decl, but to its return type. */ 8157 type_quals = TYPE_UNQUALIFIED; 8158 8159 /* Warn about some types functions can't return. */ 8160 8161 if (TREE_CODE (type) == FUNCTION_TYPE) 8162 { 8163 error ("%qs declared as function returning a function", name); 8164 type = integer_type_node; 8165 } 8166 if (TREE_CODE (type) == ARRAY_TYPE) 8167 { 8168 error ("%qs declared as function returning an array", name); 8169 type = integer_type_node; 8170 } 8171 8172 /* Pick up type qualifiers which should be applied to `this'. */ 8173 memfn_quals = declarator->u.function.qualifiers; 8174 8175 /* Pick up the exception specifications. */ 8176 raises = declarator->u.function.exception_specification; 8177 8178 /* Say it's a definition only for the CALL_EXPR 8179 closest to the identifier. */ 8180 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id; 8181 8182 if (ctype == NULL_TREE 8183 && decl_context == FIELD 8184 && funcdecl_p 8185 && (friendp == 0 || dname == current_class_name)) 8186 ctype = current_class_type; 8187 8188 if (ctype && (sfk == sfk_constructor 8189 || sfk == sfk_destructor)) 8190 { 8191 /* We are within a class's scope. If our declarator name 8192 is the same as the class name, and we are defining 8193 a function, then it is a constructor/destructor, and 8194 therefore returns a void type. */ 8195 8196 /* ISO C++ 12.4/2. A destructor may not be declared 8197 const or volatile. A destructor may not be 8198 static. 8199 8200 ISO C++ 12.1. A constructor may not be declared 8201 const or volatile. A constructor may not be 8202 virtual. A constructor may not be static. */ 8203 if (staticp == 2) 8204 error ((flags == DTOR_FLAG) 8205 ? "destructor cannot be static member function" 8206 : "constructor cannot be static member function"); 8207 if (memfn_quals) 8208 { 8209 error ((flags == DTOR_FLAG) 8210 ? "destructors may not be cv-qualified" 8211 : "constructors may not be cv-qualified"); 8212 memfn_quals = TYPE_UNQUALIFIED; 8213 } 8214 8215 if (decl_context == FIELD 8216 && !member_function_or_else (ctype, 8217 current_class_type, 8218 flags)) 8219 return error_mark_node; 8220 8221 if (flags != DTOR_FLAG) 8222 { 8223 /* It's a constructor. */ 8224 if (explicitp == 1) 8225 explicitp = 2; 8226 if (virtualp) 8227 { 8228 pedwarn ("constructors cannot be declared virtual"); 8229 virtualp = 0; 8230 } 8231 if (decl_context == FIELD 8232 && sfk != sfk_constructor) 8233 return error_mark_node; 8234 } 8235 if (decl_context == FIELD) 8236 staticp = 0; 8237 } 8238 else if (friendp) 8239 { 8240 if (initialized) 8241 error ("can't initialize friend function %qs", name); 8242 if (virtualp) 8243 { 8244 /* Cannot be both friend and virtual. */ 8245 error ("virtual functions cannot be friends"); 8246 friendp = 0; 8247 } 8248 if (decl_context == NORMAL) 8249 error ("friend declaration not in class definition"); 8250 if (current_function_decl && funcdef_flag) 8251 error ("can't define friend function %qs in a local " 8252 "class definition", 8253 name); 8254 } 8255 8256 arg_types = grokparms (declarator->u.function.parameters, 8257 &parms); 8258 8259 if (inner_declarator 8260 && inner_declarator->kind == cdk_id 8261 && inner_declarator->u.id.sfk == sfk_destructor 8262 && arg_types != void_list_node) 8263 { 8264 error ("destructors may not have parameters"); 8265 arg_types = void_list_node; 8266 parms = NULL_TREE; 8267 } 8268 8269 type = build_function_type (type, arg_types); 8270 } 8271 break; 8272 8273 case cdk_pointer: 8274 case cdk_reference: 8275 case cdk_ptrmem: 8276 /* Filter out pointers-to-references and references-to-references. 8277 We can get these if a TYPE_DECL is used. */ 8278 8279 if (TREE_CODE (type) == REFERENCE_TYPE) 8280 { 8281 error (declarator->kind == cdk_reference 8282 ? "cannot declare reference to %q#T" 8283 : "cannot declare pointer to %q#T", type); 8284 type = TREE_TYPE (type); 8285 } 8286 else if (VOID_TYPE_P (type)) 8287 { 8288 if (declarator->kind == cdk_reference) 8289 error ("cannot declare reference to %q#T", type); 8290 else if (declarator->kind == cdk_ptrmem) 8291 error ("cannot declare pointer to %q#T member", type); 8292 } 8293 8294 /* We now know that the TYPE_QUALS don't apply to the decl, 8295 but to the target of the pointer. */ 8296 type_quals = TYPE_UNQUALIFIED; 8297 8298 if (declarator->kind == cdk_ptrmem 8299 && (TREE_CODE (type) == FUNCTION_TYPE || memfn_quals)) 8300 { 8301 memfn_quals |= cp_type_quals (type); 8302 type = build_memfn_type (type, 8303 declarator->u.pointer.class_type, 8304 memfn_quals); 8305 memfn_quals = TYPE_UNQUALIFIED; 8306 } 8307 8308 if (declarator->kind == cdk_reference) 8309 { 8310 if (!VOID_TYPE_P (type)) 8311 type = build_reference_type (type); 8312 } 8313 else if (TREE_CODE (type) == METHOD_TYPE) 8314 type = build_ptrmemfunc_type (build_pointer_type (type)); 8315 else if (declarator->kind == cdk_ptrmem) 8316 { 8317 gcc_assert (TREE_CODE (declarator->u.pointer.class_type) 8318 != NAMESPACE_DECL); 8319 if (declarator->u.pointer.class_type == error_mark_node) 8320 /* We will already have complained. */ 8321 type = error_mark_node; 8322 else 8323 type = build_ptrmem_type (declarator->u.pointer.class_type, 8324 type); 8325 } 8326 else 8327 type = build_pointer_type (type); 8328 8329 /* Process a list of type modifier keywords (such as 8330 const or volatile) that were given inside the `*' or `&'. */ 8331 8332 if (declarator->u.pointer.qualifiers) 8333 { 8334 type 8335 = cp_build_qualified_type (type, 8336 declarator->u.pointer.qualifiers); 8337 type_quals = cp_type_quals (type); 8338 } 8339 ctype = NULL_TREE; 8340 break; 8341 8342 /* APPLE LOCAL begin blocks 6040305 (cj) */ 8343 case cdk_block_pointer: 8344 if (TREE_CODE (type) != FUNCTION_TYPE) 8345 { 8346 error ("block pointer to non-function type is invalid"); 8347 type = error_mark_node; 8348 } 8349 else 8350 { 8351 /* We now know that the TYPE_QUALS don't apply to the decl, 8352 but to the target of the pointer. */ 8353 type_quals = TYPE_UNQUALIFIED; 8354 8355 type = build_block_pointer_type (type); 8356 8357 if (declarator->u.pointer.qualifiers) 8358 { 8359 type 8360 = cp_build_qualified_type (type, 8361 declarator->u.pointer.qualifiers); 8362 type_quals = cp_type_quals (type); 8363 } 8364 } 8365 ctype = NULL_TREE; 8366 break; 8367 /* APPLE LOCAL end blocks 6040305 (cj) */ 8368 8369 case cdk_error: 8370 break; 8371 8372 default: 8373 gcc_unreachable (); 8374 } 8375 } 8376 8377 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR 8378 && TREE_CODE (type) != FUNCTION_TYPE 8379 && TREE_CODE (type) != METHOD_TYPE) 8380 { 8381 error ("template-id %qD used as a declarator", 8382 unqualified_id); 8383 unqualified_id = dname; 8384 } 8385 8386 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly 8387 qualified with a class-name, turn it into a METHOD_TYPE, unless 8388 we know that the function is static. We take advantage of this 8389 opportunity to do other processing that pertains to entities 8390 explicitly declared to be class members. Note that if DECLARATOR 8391 is non-NULL, we know it is a cdk_id declarator; otherwise, we 8392 would not have exited the loop above. */ 8393 if (declarator 8394 && declarator->u.id.qualifying_scope 8395 && TYPE_P (declarator->u.id.qualifying_scope)) 8396 { 8397 tree t; 8398 8399 ctype = declarator->u.id.qualifying_scope; 8400 ctype = TYPE_MAIN_VARIANT (ctype); 8401 t = ctype; 8402 while (t != NULL_TREE && CLASS_TYPE_P (t)) 8403 { 8404 /* You're supposed to have one `template <...>' for every 8405 template class, but you don't need one for a full 8406 specialization. For example: 8407 8408 template <class T> struct S{}; 8409 template <> struct S<int> { void f(); }; 8410 void S<int>::f () {} 8411 8412 is correct; there shouldn't be a `template <>' for the 8413 definition of `S<int>::f'. */ 8414 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t) 8415 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t))) 8416 /* T is an explicit (not partial) specialization. All 8417 containing classes must therefore also be explicitly 8418 specialized. */ 8419 break; 8420 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t)) 8421 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t))) 8422 template_count += 1; 8423 8424 t = TYPE_MAIN_DECL (t); 8425 t = DECL_CONTEXT (t); 8426 } 8427 8428 if (ctype == current_class_type) 8429 { 8430 if (friendp) 8431 pedwarn ("member functions are implicitly friends of their class"); 8432 else 8433 pedwarn ("extra qualification %<%T::%> on member %qs", 8434 ctype, name); 8435 } 8436 else if (/* If the qualifying type is already complete, then we 8437 can skip the following checks. */ 8438 !COMPLETE_TYPE_P (ctype) 8439 && (/* If the function is being defined, then 8440 qualifying type must certainly be complete. */ 8441 funcdef_flag 8442 /* A friend declaration of "T::f" is OK, even if 8443 "T" is a template parameter. But, if this 8444 function is not a friend, the qualifying type 8445 must be a class. */ 8446 || (!friendp && !CLASS_TYPE_P (ctype)) 8447 /* For a declaration, the type need not be 8448 complete, if either it is dependent (since there 8449 is no meaningful definition of complete in that 8450 case) or the qualifying class is currently being 8451 defined. */ 8452 || !(dependent_type_p (ctype) 8453 || currently_open_class (ctype))) 8454 /* Check that the qualifying type is complete. */ 8455 && !complete_type_or_else (ctype, NULL_TREE)) 8456 return error_mark_node; 8457 else if (TREE_CODE (type) == FUNCTION_TYPE) 8458 { 8459 tree sname = declarator->u.id.unqualified_name; 8460 8461 if (current_class_type 8462 && (!friendp || funcdef_flag)) 8463 { 8464 error (funcdef_flag 8465 ? "cannot define member function %<%T::%s%> within %<%T%>" 8466 : "cannot declare member function %<%T::%s%> within %<%T%>", 8467 ctype, name, current_class_type); 8468 return error_mark_node; 8469 } 8470 8471 if (TREE_CODE (sname) == IDENTIFIER_NODE 8472 && NEW_DELETE_OPNAME_P (sname)) 8473 /* Overloaded operator new and operator delete 8474 are always static functions. */ 8475 ; 8476 else 8477 type = build_memfn_type (type, ctype, memfn_quals); 8478 } 8479 else if (declspecs->specs[(int)ds_typedef] 8480 && current_class_type) 8481 { 8482 error ("cannot declare member %<%T::%s%> within %qT", 8483 ctype, name, current_class_type); 8484 return error_mark_node; 8485 } 8486 } 8487 8488 /* Now TYPE has the actual type. */ 8489 8490 if (returned_attrs) 8491 { 8492 if (attrlist) 8493 *attrlist = chainon (returned_attrs, *attrlist); 8494 else 8495 attrlist = &returned_attrs; 8496 } 8497 8498 /* Did array size calculations overflow? */ 8499 8500 if (TREE_CODE (type) == ARRAY_TYPE 8501 && COMPLETE_TYPE_P (type) 8502 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST 8503 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type))) 8504 { 8505 error ("size of array %qs is too large", name); 8506 /* If we proceed with the array type as it is, we'll eventually 8507 crash in tree_low_cst(). */ 8508 type = error_mark_node; 8509 } 8510 8511 if ((decl_context == FIELD || decl_context == PARM) 8512 && !processing_template_decl 8513 && variably_modified_type_p (type, NULL_TREE)) 8514 { 8515 if (decl_context == FIELD) 8516 error ("data member may not have variably modified type %qT", type); 8517 else 8518 error ("parameter may not have variably modified type %qT", type); 8519 type = error_mark_node; 8520 } 8521 8522 if (explicitp == 1 || (explicitp && friendp)) 8523 { 8524 /* [dcl.fct.spec] The explicit specifier shall only be used in 8525 declarations of constructors within a class definition. */ 8526 error ("only declarations of constructors can be %<explicit%>"); 8527 explicitp = 0; 8528 } 8529 8530 if (storage_class == sc_mutable) 8531 { 8532 if (decl_context != FIELD || friendp) 8533 { 8534 error ("non-member %qs cannot be declared %<mutable%>", name); 8535 storage_class = sc_none; 8536 } 8537 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef]) 8538 { 8539 error ("non-object member %qs cannot be declared %<mutable%>", name); 8540 storage_class = sc_none; 8541 } 8542 else if (TREE_CODE (type) == FUNCTION_TYPE 8543 || TREE_CODE (type) == METHOD_TYPE) 8544 { 8545 error ("function %qs cannot be declared %<mutable%>", name); 8546 storage_class = sc_none; 8547 } 8548 else if (staticp) 8549 { 8550 error ("static %qs cannot be declared %<mutable%>", name); 8551 storage_class = sc_none; 8552 } 8553 else if (type_quals & TYPE_QUAL_CONST) 8554 { 8555 error ("const %qs cannot be declared %<mutable%>", name); 8556 storage_class = sc_none; 8557 } 8558 } 8559 8560 /* APPLE LOCAL begin blocks 6339747 */ 8561 if (decl_context == BLOCKDEF) 8562 { 8563 tree decl; 8564 8565 if (type == error_mark_node) 8566 return error_mark_node; 8567 8568 if (TREE_CODE (type) != FUNCTION_TYPE) 8569 { 8570 tree t = make_node (FUNCTION_TYPE); 8571 8572 if (TREE_CODE (type) == ARRAY_TYPE) 8573 { 8574 error ("block declared as returning an array"); 8575 return error_mark_node; 8576 } 8577 8578 TYPE_ARG_TYPES (t) = void_list_node; 8579 TREE_TYPE (t) = type; 8580 type = t; 8581 parms = NULL_TREE; 8582 } 8583 8584 if (raises) 8585 type = build_exception_variant (type, raises); 8586 decl = build_lang_decl (FUNCTION_DECL, NULL_TREE, type); 8587 DECL_ARGUMENTS (decl) = parms; 8588 return decl; 8589 } 8590 /* APPLE LOCAL end blocks 6339747 */ 8591 8592 /* If this is declaring a typedef name, return a TYPE_DECL. */ 8593 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME) 8594 { 8595 tree decl; 8596 8597 /* Note that the grammar rejects storage classes 8598 in typenames, fields or parameters. */ 8599 if (current_lang_name == lang_name_java) 8600 TYPE_FOR_JAVA (type) = 1; 8601 8602 /* This declaration: 8603 8604 typedef void f(int) const; 8605 8606 declares a function type which is not a member of any 8607 particular class, but which is cv-qualified; for 8608 example "f S::*" declares a pointer to a const-qualified 8609 member function of S. We record the cv-qualification in the 8610 function type. */ 8611 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE) 8612 type = cp_build_qualified_type (type, memfn_quals); 8613 8614 if (decl_context == FIELD) 8615 decl = build_lang_decl (TYPE_DECL, unqualified_id, type); 8616 else 8617 decl = build_decl (TYPE_DECL, unqualified_id, type); 8618 if (id_declarator && declarator->u.id.qualifying_scope) 8619 error ("%Jtypedef name may not be a nested-name-specifier", decl); 8620 8621 if (decl_context != FIELD) 8622 { 8623 if (!current_function_decl) 8624 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); 8625 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl) 8626 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P 8627 (current_function_decl))) 8628 /* The TYPE_DECL is "abstract" because there will be 8629 clones of this constructor/destructor, and there will 8630 be copies of this TYPE_DECL generated in those 8631 clones. */ 8632 DECL_ABSTRACT (decl) = 1; 8633 } 8634 else if (constructor_name_p (unqualified_id, current_class_type)) 8635 pedwarn ("ISO C++ forbids nested type %qD with same name " 8636 "as enclosing class", 8637 unqualified_id); 8638 8639 /* If the user declares "typedef struct {...} foo" then the 8640 struct will have an anonymous name. Fill that name in now. 8641 Nothing can refer to it, so nothing needs know about the name 8642 change. */ 8643 if (type != error_mark_node 8644 && unqualified_id 8645 && TYPE_NAME (type) 8646 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 8647 && TYPE_ANONYMOUS_P (type) 8648 /* Don't do this if there are attributes. */ 8649 && (!attrlist || !*attrlist) 8650 && cp_type_quals (type) == TYPE_UNQUALIFIED) 8651 { 8652 tree oldname = TYPE_NAME (type); 8653 tree t; 8654 8655 /* Replace the anonymous name with the real name everywhere. */ 8656 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 8657 if (TYPE_NAME (t) == oldname) 8658 TYPE_NAME (t) = decl; 8659 8660 if (TYPE_LANG_SPECIFIC (type)) 8661 TYPE_WAS_ANONYMOUS (type) = 1; 8662 8663 /* If this is a typedef within a template class, the nested 8664 type is a (non-primary) template. The name for the 8665 template needs updating as well. */ 8666 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type)) 8667 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)) 8668 = TYPE_IDENTIFIER (type); 8669 8670 /* FIXME remangle member functions; member functions of a 8671 type with external linkage have external linkage. */ 8672 } 8673 8674 /* Any qualifiers on a function type typedef have already been 8675 dealt with. */ 8676 if (memfn_quals && !ctype && TREE_CODE (type) == FUNCTION_TYPE) 8677 memfn_quals = TYPE_UNQUALIFIED; 8678 8679 if (signed_p 8680 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))) 8681 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1; 8682 8683 bad_specifiers (decl, "type", virtualp, 8684 memfn_quals != TYPE_UNQUALIFIED, 8685 inlinep, friendp, raises != NULL_TREE); 8686 8687 return decl; 8688 } 8689 8690 /* Detect the case of an array type of unspecified size 8691 which came, as such, direct from a typedef name. 8692 We must copy the type, so that the array's domain can be 8693 individually set by the object's initializer. */ 8694 8695 if (type && typedef_type 8696 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type) 8697 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)) 8698 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE); 8699 8700 /* Detect where we're using a typedef of function type to declare a 8701 function. PARMS will not be set, so we must create it now. */ 8702 8703 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE) 8704 { 8705 tree decls = NULL_TREE; 8706 tree args; 8707 8708 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args)) 8709 { 8710 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args)); 8711 8712 TREE_CHAIN (decl) = decls; 8713 decls = decl; 8714 } 8715 8716 parms = nreverse (decls); 8717 8718 if (decl_context != TYPENAME) 8719 { 8720 /* A cv-qualifier-seq shall only be part of the function type 8721 for a non-static member function. [8.3.5/4 dcl.fct] */ 8722 if (cp_type_quals (type) != TYPE_UNQUALIFIED 8723 && (current_class_type == NULL_TREE || staticp) ) 8724 { 8725 error ("qualified function types cannot be used to declare %s functions", 8726 (staticp? "static member" : "free")); 8727 type = TYPE_MAIN_VARIANT (type); 8728 } 8729 8730 /* The qualifiers on the function type become the qualifiers on 8731 the non-static member function. */ 8732 memfn_quals |= cp_type_quals (type); 8733 } 8734 } 8735 8736 /* If this is a type name (such as, in a cast or sizeof), 8737 compute the type and return it now. */ 8738 8739 if (decl_context == TYPENAME) 8740 { 8741 /* Note that the grammar rejects storage classes 8742 in typenames, fields or parameters. */ 8743 if (type_quals != TYPE_UNQUALIFIED) 8744 type_quals = TYPE_UNQUALIFIED; 8745 8746 /* Special case: "friend class foo" looks like a TYPENAME context. */ 8747 if (friendp) 8748 { 8749 if (type_quals != TYPE_UNQUALIFIED) 8750 { 8751 error ("type qualifiers specified for friend class declaration"); 8752 type_quals = TYPE_UNQUALIFIED; 8753 } 8754 if (inlinep) 8755 { 8756 error ("%<inline%> specified for friend class declaration"); 8757 inlinep = 0; 8758 } 8759 8760 if (!current_aggr) 8761 { 8762 /* Don't allow friend declaration without a class-key. */ 8763 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM) 8764 pedwarn ("template parameters cannot be friends"); 8765 else if (TREE_CODE (type) == TYPENAME_TYPE) 8766 pedwarn ("friend declaration requires class-key, " 8767 "i.e. %<friend class %T::%D%>", 8768 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type)); 8769 else 8770 pedwarn ("friend declaration requires class-key, " 8771 "i.e. %<friend %#T%>", 8772 type); 8773 } 8774 8775 /* Only try to do this stuff if we didn't already give up. */ 8776 if (type != integer_type_node) 8777 { 8778 /* A friendly class? */ 8779 if (current_class_type) 8780 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type), 8781 /*complain=*/true); 8782 else 8783 error ("trying to make class %qT a friend of global scope", 8784 type); 8785 8786 type = void_type_node; 8787 } 8788 } 8789 else if (memfn_quals) 8790 { 8791 if (ctype == NULL_TREE) 8792 { 8793 if (TREE_CODE (type) != METHOD_TYPE) 8794 error ("invalid qualifiers on non-member function type"); 8795 else 8796 ctype = TYPE_METHOD_BASETYPE (type); 8797 } 8798 if (ctype) 8799 type = build_memfn_type (type, ctype, memfn_quals); 8800 } 8801 8802 return type; 8803 } 8804 else if (unqualified_id == NULL_TREE && decl_context != PARM 8805 && decl_context != CATCHPARM 8806 && TREE_CODE (type) != UNION_TYPE 8807 && ! bitfield) 8808 { 8809 error ("abstract declarator %qT used as declaration", type); 8810 return error_mark_node; 8811 } 8812 8813 /* Only functions may be declared using an operator-function-id. */ 8814 if (unqualified_id 8815 && IDENTIFIER_OPNAME_P (unqualified_id) 8816 && TREE_CODE (type) != FUNCTION_TYPE 8817 && TREE_CODE (type) != METHOD_TYPE) 8818 { 8819 error ("declaration of %qD as non-function", unqualified_id); 8820 return error_mark_node; 8821 } 8822 8823 /* We don't check parameter types here because we can emit a better 8824 error message later. */ 8825 if (decl_context != PARM) 8826 { 8827 type = check_var_type (unqualified_id, type); 8828 if (type == error_mark_node) 8829 return error_mark_node; 8830 } 8831 8832 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL 8833 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */ 8834 8835 if (decl_context == PARM || decl_context == CATCHPARM) 8836 { 8837 if (ctype || in_namespace) 8838 error ("cannot use %<::%> in parameter declaration"); 8839 8840 /* A parameter declared as an array of T is really a pointer to T. 8841 One declared as a function is really a pointer to a function. 8842 One declared as a member is really a pointer to member. */ 8843 8844 if (TREE_CODE (type) == ARRAY_TYPE) 8845 { 8846 /* Transfer const-ness of array into that of type pointed to. */ 8847 type = build_pointer_type (TREE_TYPE (type)); 8848 type_quals = TYPE_UNQUALIFIED; 8849 } 8850 else if (TREE_CODE (type) == FUNCTION_TYPE) 8851 type = build_pointer_type (type); 8852 } 8853 8854 { 8855 tree decl; 8856 8857 if (decl_context == PARM) 8858 { 8859 decl = cp_build_parm_decl (unqualified_id, type); 8860 8861 bad_specifiers (decl, "parameter", virtualp, 8862 memfn_quals != TYPE_UNQUALIFIED, 8863 inlinep, friendp, raises != NULL_TREE); 8864 } 8865 else if (decl_context == FIELD) 8866 { 8867 /* The C99 flexible array extension. */ 8868 if (!staticp && TREE_CODE (type) == ARRAY_TYPE 8869 && TYPE_DOMAIN (type) == NULL_TREE) 8870 { 8871 tree itype = compute_array_index_type (dname, integer_zero_node); 8872 type = build_cplus_array_type (TREE_TYPE (type), itype); 8873 } 8874 8875 if (type == error_mark_node) 8876 { 8877 /* Happens when declaring arrays of sizes which 8878 are error_mark_node, for example. */ 8879 decl = NULL_TREE; 8880 } 8881 else if (in_namespace && !friendp) 8882 { 8883 /* Something like struct S { int N::j; }; */ 8884 error ("invalid use of %<::%>"); 8885 return error_mark_node; 8886 } 8887 else if (TREE_CODE (type) == FUNCTION_TYPE) 8888 { 8889 int publicp = 0; 8890 tree function_context; 8891 8892 if (friendp == 0) 8893 { 8894 if (ctype == NULL_TREE) 8895 ctype = current_class_type; 8896 8897 if (ctype == NULL_TREE) 8898 { 8899 error ("can't make %qD into a method -- not in a class", 8900 unqualified_id); 8901 return error_mark_node; 8902 } 8903 8904 /* ``A union may [ ... ] not [ have ] virtual functions.'' 8905 ARM 9.5 */ 8906 if (virtualp && TREE_CODE (ctype) == UNION_TYPE) 8907 { 8908 error ("function %qD declared virtual inside a union", 8909 unqualified_id); 8910 return error_mark_node; 8911 } 8912 8913 if (NEW_DELETE_OPNAME_P (unqualified_id)) 8914 { 8915 if (virtualp) 8916 { 8917 error ("%qD cannot be declared virtual, since it " 8918 "is always static", 8919 unqualified_id); 8920 virtualp = 0; 8921 } 8922 } 8923 else if (staticp < 2) 8924 type = build_memfn_type (type, ctype, memfn_quals); 8925 } 8926 8927 /* Check that the name used for a destructor makes sense. */ 8928 if (sfk == sfk_destructor) 8929 { 8930 if (!ctype) 8931 { 8932 gcc_assert (friendp); 8933 error ("expected qualified name in friend declaration " 8934 "for destructor %qD", 8935 id_declarator->u.id.unqualified_name); 8936 return error_mark_node; 8937 } 8938 8939 if (!same_type_p (TREE_OPERAND 8940 (id_declarator->u.id.unqualified_name, 0), 8941 ctype)) 8942 { 8943 error ("declaration of %qD as member of %qT", 8944 id_declarator->u.id.unqualified_name, ctype); 8945 return error_mark_node; 8946 } 8947 } 8948 8949 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */ 8950 function_context = (ctype != NULL_TREE) ? 8951 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE; 8952 publicp = (! friendp || ! staticp) 8953 && function_context == NULL_TREE; 8954 decl = grokfndecl (ctype, type, 8955 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR 8956 ? unqualified_id : dname, 8957 parms, 8958 unqualified_id, 8959 virtualp, flags, memfn_quals, raises, 8960 friendp ? -1 : 0, friendp, publicp, inlinep, 8961 sfk, 8962 funcdef_flag, template_count, in_namespace, attrlist); 8963 if (decl == NULL_TREE) 8964 return error_mark_node; 8965#if 0 8966 /* This clobbers the attrs stored in `decl' from `attrlist'. */ 8967 /* The decl and setting of decl_attr is also turned off. */ 8968 decl = build_decl_attribute_variant (decl, decl_attr); 8969#endif 8970 8971 /* [class.conv.ctor] 8972 8973 A constructor declared without the function-specifier 8974 explicit that can be called with a single parameter 8975 specifies a conversion from the type of its first 8976 parameter to the type of its class. Such a constructor 8977 is called a converting constructor. */ 8978 if (explicitp == 2) 8979 DECL_NONCONVERTING_P (decl) = 1; 8980 else if (DECL_CONSTRUCTOR_P (decl)) 8981 { 8982 /* The constructor can be called with exactly one 8983 parameter if there is at least one parameter, and 8984 any subsequent parameters have default arguments. 8985 Ignore any compiler-added parms. */ 8986 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl); 8987 8988 if (arg_types == void_list_node 8989 || (arg_types 8990 && TREE_CHAIN (arg_types) 8991 && TREE_CHAIN (arg_types) != void_list_node 8992 && !TREE_PURPOSE (TREE_CHAIN (arg_types)))) 8993 DECL_NONCONVERTING_P (decl) = 1; 8994 } 8995 } 8996 else if (TREE_CODE (type) == METHOD_TYPE) 8997 { 8998 /* We only get here for friend declarations of 8999 members of other classes. */ 9000 /* All method decls are public, so tell grokfndecl to set 9001 TREE_PUBLIC, also. */ 9002 decl = grokfndecl (ctype, type, 9003 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR 9004 ? unqualified_id : dname, 9005 parms, 9006 unqualified_id, 9007 virtualp, flags, memfn_quals, raises, 9008 friendp ? -1 : 0, friendp, 1, 0, sfk, 9009 funcdef_flag, template_count, in_namespace, 9010 attrlist); 9011 if (decl == NULL_TREE) 9012 return error_mark_node; 9013 } 9014 else if (!staticp && !dependent_type_p (type) 9015 && !COMPLETE_TYPE_P (complete_type (type)) 9016 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0)) 9017 { 9018 if (unqualified_id) 9019 error ("field %qD has incomplete type", unqualified_id); 9020 else 9021 error ("name %qT has incomplete type", type); 9022 9023 /* If we're instantiating a template, tell them which 9024 instantiation made the field's type be incomplete. */ 9025 if (current_class_type 9026 && TYPE_NAME (current_class_type) 9027 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type)) 9028 && declspecs->type 9029 && declspecs->type == type) 9030 error (" in instantiation of template %qT", 9031 current_class_type); 9032 9033 return error_mark_node; 9034 } 9035 else 9036 { 9037 if (friendp) 9038 { 9039 error ("%qE is neither function nor member function; " 9040 "cannot be declared friend", unqualified_id); 9041 friendp = 0; 9042 } 9043 decl = NULL_TREE; 9044 } 9045 9046 if (friendp) 9047 { 9048 /* Friends are treated specially. */ 9049 if (ctype == current_class_type) 9050 ; /* We already issued a pedwarn. */ 9051 else if (decl && DECL_NAME (decl)) 9052 { 9053 if (template_class_depth (current_class_type) == 0) 9054 { 9055 decl = check_explicit_specialization 9056 (unqualified_id, decl, template_count, 9057 2 * funcdef_flag + 4); 9058 if (decl == error_mark_node) 9059 return error_mark_node; 9060 } 9061 9062 decl = do_friend (ctype, unqualified_id, decl, 9063 *attrlist, flags, 9064 funcdef_flag); 9065 return decl; 9066 } 9067 else 9068 return error_mark_node; 9069 } 9070 9071 /* Structure field. It may not be a function, except for C++. */ 9072 9073 if (decl == NULL_TREE) 9074 { 9075 if (initialized) 9076 { 9077 if (!staticp) 9078 { 9079 /* An attempt is being made to initialize a non-static 9080 member. But, from [class.mem]: 9081 9082 4 A member-declarator can contain a 9083 constant-initializer only if it declares a static 9084 member (_class.static_) of integral or enumeration 9085 type, see _class.static.data_. 9086 9087 This used to be relatively common practice, but 9088 the rest of the compiler does not correctly 9089 handle the initialization unless the member is 9090 static so we make it static below. */ 9091 pedwarn ("ISO C++ forbids initialization of member %qD", 9092 unqualified_id); 9093 pedwarn ("making %qD static", unqualified_id); 9094 staticp = 1; 9095 } 9096 9097 if (uses_template_parms (type)) 9098 /* We'll check at instantiation time. */ 9099 ; 9100 else if (check_static_variable_definition (unqualified_id, 9101 type)) 9102 /* If we just return the declaration, crashes 9103 will sometimes occur. We therefore return 9104 void_type_node, as if this was a friend 9105 declaration, to cause callers to completely 9106 ignore this declaration. */ 9107 return error_mark_node; 9108 } 9109 9110 if (staticp) 9111 { 9112 /* C++ allows static class members. All other work 9113 for this is done by grokfield. */ 9114 decl = build_lang_decl (VAR_DECL, unqualified_id, type); 9115 set_linkage_for_static_data_member (decl); 9116 /* Even if there is an in-class initialization, DECL 9117 is considered undefined until an out-of-class 9118 definition is provided. */ 9119 DECL_EXTERNAL (decl) = 1; 9120 9121 if (thread_p) 9122 { 9123 if (targetm.have_tls) 9124 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl); 9125 else 9126 /* A mere warning is sure to result in improper 9127 semantics at runtime. Don't bother to allow this to 9128 compile. */ 9129 error ("thread-local storage not supported for this target"); 9130 } 9131 } 9132 else 9133 { 9134 decl = build_decl (FIELD_DECL, unqualified_id, type); 9135 DECL_NONADDRESSABLE_P (decl) = bitfield; 9136 if (storage_class == sc_mutable) 9137 { 9138 DECL_MUTABLE_P (decl) = 1; 9139 storage_class = sc_none; 9140 } 9141 } 9142 9143 bad_specifiers (decl, "field", virtualp, 9144 memfn_quals != TYPE_UNQUALIFIED, 9145 inlinep, friendp, raises != NULL_TREE); 9146 } 9147 } 9148 else if (TREE_CODE (type) == FUNCTION_TYPE 9149 || TREE_CODE (type) == METHOD_TYPE) 9150 { 9151 tree original_name; 9152 int publicp = 0; 9153 9154 if (!unqualified_id) 9155 return error_mark_node; 9156 9157 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR) 9158 original_name = dname; 9159 else 9160 original_name = unqualified_id; 9161 9162 if (storage_class == sc_auto) 9163 error ("storage class %<auto%> invalid for function %qs", name); 9164 else if (storage_class == sc_register) 9165 error ("storage class %<register%> invalid for function %qs", name); 9166 else if (thread_p) 9167 error ("storage class %<__thread%> invalid for function %qs", name); 9168 9169 /* Function declaration not at top level. 9170 Storage classes other than `extern' are not allowed 9171 and `extern' makes no difference. */ 9172 if (! toplevel_bindings_p () 9173 && (storage_class == sc_static 9174 || declspecs->specs[(int)ds_inline]) 9175 && pedantic) 9176 { 9177 if (storage_class == sc_static) 9178 pedwarn ("%<static%> specified invalid for function %qs " 9179 "declared out of global scope", name); 9180 else 9181 pedwarn ("%<inline%> specifier invalid for function %qs " 9182 "declared out of global scope", name); 9183 } 9184 9185 if (ctype == NULL_TREE) 9186 { 9187 if (virtualp) 9188 { 9189 error ("virtual non-class function %qs", name); 9190 virtualp = 0; 9191 } 9192 } 9193 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2 9194 && !NEW_DELETE_OPNAME_P (original_name)) 9195 type = build_method_type_directly (ctype, 9196 TREE_TYPE (type), 9197 TYPE_ARG_TYPES (type)); 9198 9199 /* Record presence of `static'. */ 9200 publicp = (ctype != NULL_TREE 9201 || storage_class == sc_extern 9202 || storage_class != sc_static); 9203 9204 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id, 9205 virtualp, flags, memfn_quals, raises, 9206 1, friendp, 9207 publicp, inlinep, sfk, funcdef_flag, 9208 template_count, in_namespace, attrlist); 9209 if (decl == NULL_TREE) 9210 return error_mark_node; 9211 9212 if (staticp == 1) 9213 { 9214 int invalid_static = 0; 9215 9216 /* Don't allow a static member function in a class, and forbid 9217 declaring main to be static. */ 9218 if (TREE_CODE (type) == METHOD_TYPE) 9219 { 9220 pedwarn ("cannot declare member function %qD to have " 9221 "static linkage", decl); 9222 invalid_static = 1; 9223 } 9224 else if (current_function_decl) 9225 { 9226 /* FIXME need arm citation */ 9227 error ("cannot declare static function inside another function"); 9228 invalid_static = 1; 9229 } 9230 9231 if (invalid_static) 9232 { 9233 staticp = 0; 9234 storage_class = sc_none; 9235 } 9236 } 9237 } 9238 else 9239 { 9240 /* It's a variable. */ 9241 9242 /* An uninitialized decl with `extern' is a reference. */ 9243 decl = grokvardecl (type, unqualified_id, 9244 declspecs, 9245 initialized, 9246 (type_quals & TYPE_QUAL_CONST) != 0, 9247 ctype ? ctype : in_namespace); 9248 bad_specifiers (decl, "variable", virtualp, 9249 memfn_quals != TYPE_UNQUALIFIED, 9250 inlinep, friendp, raises != NULL_TREE); 9251 9252 if (ctype) 9253 { 9254 DECL_CONTEXT (decl) = ctype; 9255 if (staticp == 1) 9256 { 9257 pedwarn ("%<static%> may not be used when defining " 9258 "(as opposed to declaring) a static data member"); 9259 staticp = 0; 9260 storage_class = sc_none; 9261 } 9262 if (storage_class == sc_register && TREE_STATIC (decl)) 9263 { 9264 error ("static member %qD declared %<register%>", decl); 9265 storage_class = sc_none; 9266 } 9267 if (storage_class == sc_extern && pedantic) 9268 { 9269 pedwarn ("cannot explicitly declare member %q#D to have " 9270 "extern linkage", 9271 decl); 9272 storage_class = sc_none; 9273 } 9274 } 9275 } 9276 9277 /* Record `register' declaration for warnings on & 9278 and in case doing stupid register allocation. */ 9279 9280 if (storage_class == sc_register) 9281 DECL_REGISTER (decl) = 1; 9282 else if (storage_class == sc_extern) 9283 DECL_THIS_EXTERN (decl) = 1; 9284 else if (storage_class == sc_static) 9285 DECL_THIS_STATIC (decl) = 1; 9286 9287 /* Record constancy and volatility. There's no need to do this 9288 when processing a template; we'll do this for the instantiated 9289 declaration based on the type of DECL. */ 9290 if (!processing_template_decl) 9291 cp_apply_type_quals_to_decl (type_quals, decl); 9292 9293 return decl; 9294 } 9295} 9296 9297/* Subroutine of start_function. Ensure that each of the parameter 9298 types (as listed in PARMS) is complete, as is required for a 9299 function definition. */ 9300 9301static void 9302require_complete_types_for_parms (tree parms) 9303{ 9304 for (; parms; parms = TREE_CHAIN (parms)) 9305 { 9306 if (dependent_type_p (TREE_TYPE (parms))) 9307 continue; 9308 if (!VOID_TYPE_P (TREE_TYPE (parms)) 9309 && complete_type_or_else (TREE_TYPE (parms), parms)) 9310 { 9311 relayout_decl (parms); 9312 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms)); 9313 } 9314 else 9315 /* grokparms or complete_type_or_else will have already issued 9316 an error. */ 9317 TREE_TYPE (parms) = error_mark_node; 9318 } 9319} 9320 9321/* Returns nonzero if T is a local variable. */ 9322 9323int 9324local_variable_p (tree t) 9325{ 9326 if ((TREE_CODE (t) == VAR_DECL 9327 /* A VAR_DECL with a context that is a _TYPE is a static data 9328 member. */ 9329 && !TYPE_P (CP_DECL_CONTEXT (t)) 9330 /* Any other non-local variable must be at namespace scope. */ 9331 && !DECL_NAMESPACE_SCOPE_P (t)) 9332 || (TREE_CODE (t) == PARM_DECL)) 9333 return 1; 9334 9335 return 0; 9336} 9337 9338/* Returns nonzero if T is an automatic local variable or a label. 9339 (These are the declarations that need to be remapped when the code 9340 containing them is duplicated.) */ 9341 9342int 9343nonstatic_local_decl_p (tree t) 9344{ 9345 return ((local_variable_p (t) && !TREE_STATIC (t)) 9346 || TREE_CODE (t) == LABEL_DECL 9347 || TREE_CODE (t) == RESULT_DECL); 9348} 9349 9350/* Like local_variable_p, but suitable for use as a tree-walking 9351 function. */ 9352 9353static tree 9354local_variable_p_walkfn (tree *tp, int *walk_subtrees, 9355 void *data ATTRIBUTE_UNUSED) 9356{ 9357 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp)) 9358 return *tp; 9359 else if (TYPE_P (*tp)) 9360 *walk_subtrees = 0; 9361 9362 return NULL_TREE; 9363} 9364 9365 9366/* Check that ARG, which is a default-argument expression for a 9367 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if 9368 something goes wrong. DECL may also be a _TYPE node, rather than a 9369 DECL, if there is no DECL available. */ 9370 9371tree 9372check_default_argument (tree decl, tree arg) 9373{ 9374 tree var; 9375 tree decl_type; 9376 9377 if (TREE_CODE (arg) == DEFAULT_ARG) 9378 /* We get a DEFAULT_ARG when looking at an in-class declaration 9379 with a default argument. Ignore the argument for now; we'll 9380 deal with it after the class is complete. */ 9381 return arg; 9382 9383 if (TYPE_P (decl)) 9384 { 9385 decl_type = decl; 9386 decl = NULL_TREE; 9387 } 9388 else 9389 decl_type = TREE_TYPE (decl); 9390 9391 if (arg == error_mark_node 9392 || decl == error_mark_node 9393 || TREE_TYPE (arg) == error_mark_node 9394 || decl_type == error_mark_node) 9395 /* Something already went wrong. There's no need to check 9396 further. */ 9397 return error_mark_node; 9398 9399 /* [dcl.fct.default] 9400 9401 A default argument expression is implicitly converted to the 9402 parameter type. */ 9403 if (!TREE_TYPE (arg) 9404 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL)) 9405 { 9406 if (decl) 9407 error ("default argument for %q#D has type %qT", 9408 decl, TREE_TYPE (arg)); 9409 else 9410 error ("default argument for parameter of type %qT has type %qT", 9411 decl_type, TREE_TYPE (arg)); 9412 9413 return error_mark_node; 9414 } 9415 9416 /* [dcl.fct.default] 9417 9418 Local variables shall not be used in default argument 9419 expressions. 9420 9421 The keyword `this' shall not be used in a default argument of a 9422 member function. */ 9423 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn, 9424 NULL); 9425 if (var) 9426 { 9427 error ("default argument %qE uses local variable %qD", arg, var); 9428 return error_mark_node; 9429 } 9430 9431 /* All is well. */ 9432 return arg; 9433} 9434 9435/* Decode the list of parameter types for a function type. 9436 Given the list of things declared inside the parens, 9437 return a list of types. 9438 9439 If this parameter does not end with an ellipsis, we append 9440 void_list_node. 9441 9442 *PARMS is set to the chain of PARM_DECLs created. */ 9443 9444/* APPLE LOCAL blocks 6040305 (ce) */ 9445tree 9446grokparms (cp_parameter_declarator *first_parm, tree *parms) 9447{ 9448 tree result = NULL_TREE; 9449 tree decls = NULL_TREE; 9450 int ellipsis = !first_parm || first_parm->ellipsis_p; 9451 cp_parameter_declarator *parm; 9452 int any_error = 0; 9453 9454 for (parm = first_parm; parm != NULL; parm = parm->next) 9455 { 9456 tree type = NULL_TREE; 9457 tree init = parm->default_argument; 9458 tree attrs; 9459 tree decl; 9460 9461 if (parm == no_parameters) 9462 break; 9463 9464 attrs = parm->decl_specifiers.attributes; 9465 parm->decl_specifiers.attributes = NULL_TREE; 9466 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers, 9467 PARM, init != NULL_TREE, &attrs); 9468 if (! decl || TREE_TYPE (decl) == error_mark_node) 9469 continue; 9470 9471 if (attrs) 9472 cplus_decl_attributes (&decl, attrs, 0); 9473 9474 type = TREE_TYPE (decl); 9475 if (VOID_TYPE_P (type)) 9476 { 9477 if (same_type_p (type, void_type_node) 9478 && DECL_SELF_REFERENCE_P (type) 9479 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis) 9480 /* this is a parmlist of `(void)', which is ok. */ 9481 break; 9482 cxx_incomplete_type_error (decl, type); 9483 /* It's not a good idea to actually create parameters of 9484 type `void'; other parts of the compiler assume that a 9485 void type terminates the parameter list. */ 9486 type = error_mark_node; 9487 TREE_TYPE (decl) = error_mark_node; 9488 } 9489 9490 if (type != error_mark_node) 9491 { 9492 /* Top-level qualifiers on the parameters are 9493 ignored for function types. */ 9494 type = cp_build_qualified_type (type, 0); 9495 if (TREE_CODE (type) == METHOD_TYPE) 9496 { 9497 error ("parameter %qD invalidly declared method type", decl); 9498 type = build_pointer_type (type); 9499 TREE_TYPE (decl) = type; 9500 } 9501 else if (abstract_virtuals_error (decl, type)) 9502 any_error = 1; /* Seems like a good idea. */ 9503 else if (POINTER_TYPE_P (type)) 9504 { 9505 /* [dcl.fct]/6, parameter types cannot contain pointers 9506 (references) to arrays of unknown bound. */ 9507 tree t = TREE_TYPE (type); 9508 int ptr = TYPE_PTR_P (type); 9509 9510 while (1) 9511 { 9512 if (TYPE_PTR_P (t)) 9513 ptr = 1; 9514 else if (TREE_CODE (t) != ARRAY_TYPE) 9515 break; 9516 else if (!TYPE_DOMAIN (t)) 9517 break; 9518 t = TREE_TYPE (t); 9519 } 9520 if (TREE_CODE (t) == ARRAY_TYPE) 9521 error ("parameter %qD includes %s to array of unknown " 9522 "bound %qT", 9523 decl, ptr ? "pointer" : "reference", t); 9524 } 9525 9526 if (any_error) 9527 init = NULL_TREE; 9528 else if (init && !processing_template_decl) 9529 init = check_default_argument (decl, init); 9530 } 9531 9532 TREE_CHAIN (decl) = decls; 9533 decls = decl; 9534 result = tree_cons (init, type, result); 9535 } 9536 decls = nreverse (decls); 9537 result = nreverse (result); 9538 if (!ellipsis) 9539 result = chainon (result, void_list_node); 9540 *parms = decls; 9541 9542 return result; 9543} 9544 9545 9546/* D is a constructor or overloaded `operator='. 9547 9548 Let T be the class in which D is declared. Then, this function 9549 returns: 9550 9551 -1 if D's is an ill-formed constructor or copy assignment operator 9552 whose first parameter is of type `T'. 9553 0 if D is not a copy constructor or copy assignment 9554 operator. 9555 1 if D is a copy constructor or copy assignment operator whose 9556 first parameter is a reference to const qualified T. 9557 2 if D is a copy constructor or copy assignment operator whose 9558 first parameter is a reference to non-const qualified T. 9559 9560 This function can be used as a predicate. Positive values indicate 9561 a copy constructor and nonzero values indicate a copy assignment 9562 operator. */ 9563 9564int 9565copy_fn_p (tree d) 9566{ 9567 tree args; 9568 tree arg_type; 9569 int result = 1; 9570 9571 gcc_assert (DECL_FUNCTION_MEMBER_P (d)); 9572 9573 if (TREE_CODE (d) == TEMPLATE_DECL 9574 || (DECL_TEMPLATE_INFO (d) 9575 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d)))) 9576 /* Instantiations of template member functions are never copy 9577 functions. Note that member functions of templated classes are 9578 represented as template functions internally, and we must 9579 accept those as copy functions. */ 9580 return 0; 9581 9582 args = FUNCTION_FIRST_USER_PARMTYPE (d); 9583 if (!args) 9584 return 0; 9585 9586 arg_type = TREE_VALUE (args); 9587 if (arg_type == error_mark_node) 9588 return 0; 9589 9590 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d)) 9591 { 9592 /* Pass by value copy assignment operator. */ 9593 result = -1; 9594 } 9595 else if (TREE_CODE (arg_type) == REFERENCE_TYPE 9596 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d)) 9597 { 9598 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type))) 9599 result = 2; 9600 } 9601 else 9602 return 0; 9603 9604 args = TREE_CHAIN (args); 9605 9606 if (args && args != void_list_node && !TREE_PURPOSE (args)) 9607 /* There are more non-optional args. */ 9608 return 0; 9609 9610 return result; 9611} 9612 9613/* Remember any special properties of member function DECL. */ 9614 9615void grok_special_member_properties (tree decl) 9616{ 9617 tree class_type; 9618 9619 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 9620 return; 9621 9622 class_type = DECL_CONTEXT (decl); 9623 if (DECL_CONSTRUCTOR_P (decl)) 9624 { 9625 int ctor = copy_fn_p (decl); 9626 9627 TYPE_HAS_CONSTRUCTOR (class_type) = 1; 9628 9629 if (ctor > 0) 9630 { 9631 /* [class.copy] 9632 9633 A non-template constructor for class X is a copy 9634 constructor if its first parameter is of type X&, const 9635 X&, volatile X& or const volatile X&, and either there 9636 are no other parameters or else all other parameters have 9637 default arguments. */ 9638 TYPE_HAS_INIT_REF (class_type) = 1; 9639 if (ctor > 1) 9640 TYPE_HAS_CONST_INIT_REF (class_type) = 1; 9641 } 9642 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl))) 9643 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1; 9644 } 9645 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR) 9646 { 9647 /* [class.copy] 9648 9649 A non-template assignment operator for class X is a copy 9650 assignment operator if its parameter is of type X, X&, const 9651 X&, volatile X& or const volatile X&. */ 9652 9653 int assop = copy_fn_p (decl); 9654 9655 if (assop) 9656 { 9657 TYPE_HAS_ASSIGN_REF (class_type) = 1; 9658 if (assop != 1) 9659 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1; 9660 } 9661 } 9662} 9663 9664/* Check a constructor DECL has the correct form. Complains 9665 if the class has a constructor of the form X(X). */ 9666 9667int 9668grok_ctor_properties (tree ctype, tree decl) 9669{ 9670 int ctor_parm = copy_fn_p (decl); 9671 9672 if (ctor_parm < 0) 9673 { 9674 /* [class.copy] 9675 9676 A declaration of a constructor for a class X is ill-formed if 9677 its first parameter is of type (optionally cv-qualified) X 9678 and either there are no other parameters or else all other 9679 parameters have default arguments. 9680 9681 We *don't* complain about member template instantiations that 9682 have this form, though; they can occur as we try to decide 9683 what constructor to use during overload resolution. Since 9684 overload resolution will never prefer such a constructor to 9685 the non-template copy constructor (which is either explicitly 9686 or implicitly defined), there's no need to worry about their 9687 existence. Theoretically, they should never even be 9688 instantiated, but that's hard to forestall. */ 9689 error ("invalid constructor; you probably meant %<%T (const %T&)%>", 9690 ctype, ctype); 9691 return 0; 9692 } 9693 9694 return 1; 9695} 9696 9697/* An operator with this code is unary, but can also be binary. */ 9698 9699static int 9700ambi_op_p (enum tree_code code) 9701{ 9702 return (code == INDIRECT_REF 9703 || code == ADDR_EXPR 9704 || code == UNARY_PLUS_EXPR 9705 || code == NEGATE_EXPR 9706 || code == PREINCREMENT_EXPR 9707 || code == PREDECREMENT_EXPR); 9708} 9709 9710/* An operator with this name can only be unary. */ 9711 9712static int 9713unary_op_p (enum tree_code code) 9714{ 9715 return (code == TRUTH_NOT_EXPR 9716 || code == BIT_NOT_EXPR 9717 || code == COMPONENT_REF 9718 || code == TYPE_EXPR); 9719} 9720 9721/* DECL is a declaration for an overloaded operator. If COMPLAIN is true, 9722 errors are issued for invalid declarations. */ 9723 9724bool 9725grok_op_properties (tree decl, bool complain) 9726{ 9727 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl)); 9728 tree argtype; 9729 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE); 9730 tree name = DECL_NAME (decl); 9731 enum tree_code operator_code; 9732 int arity; 9733 bool ellipsis_p; 9734 tree class_type; 9735 9736 /* Count the number of arguments and check for ellipsis. */ 9737 for (argtype = argtypes, arity = 0; 9738 argtype && argtype != void_list_node; 9739 argtype = TREE_CHAIN (argtype)) 9740 ++arity; 9741 ellipsis_p = !argtype; 9742 9743 class_type = DECL_CONTEXT (decl); 9744 if (class_type && !CLASS_TYPE_P (class_type)) 9745 class_type = NULL_TREE; 9746 9747 if (DECL_CONV_FN_P (decl)) 9748 operator_code = TYPE_EXPR; 9749 else 9750 do 9751 { 9752#define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \ 9753 if (ansi_opname (CODE) == name) \ 9754 { \ 9755 operator_code = (CODE); \ 9756 break; \ 9757 } \ 9758 else if (ansi_assopname (CODE) == name) \ 9759 { \ 9760 operator_code = (CODE); \ 9761 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \ 9762 break; \ 9763 } 9764 9765#include "operators.def" 9766#undef DEF_OPERATOR 9767 9768 gcc_unreachable (); 9769 } 9770 while (0); 9771 gcc_assert (operator_code != LAST_CPLUS_TREE_CODE); 9772 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code); 9773 9774 if (class_type) 9775 switch (operator_code) 9776 { 9777 case NEW_EXPR: 9778 TYPE_HAS_NEW_OPERATOR (class_type) = 1; 9779 break; 9780 9781 case DELETE_EXPR: 9782 TYPE_GETS_DELETE (class_type) |= 1; 9783 break; 9784 9785 case VEC_NEW_EXPR: 9786 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1; 9787 break; 9788 9789 case VEC_DELETE_EXPR: 9790 TYPE_GETS_DELETE (class_type) |= 2; 9791 break; 9792 9793 default: 9794 break; 9795 } 9796 9797 /* [basic.std.dynamic.allocation]/1: 9798 9799 A program is ill-formed if an allocation function is declared 9800 in a namespace scope other than global scope or declared static 9801 in global scope. 9802 9803 The same also holds true for deallocation functions. */ 9804 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR 9805 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR) 9806 { 9807 if (DECL_NAMESPACE_SCOPE_P (decl)) 9808 { 9809 if (CP_DECL_CONTEXT (decl) != global_namespace) 9810 { 9811 error ("%qD may not be declared within a namespace", decl); 9812 return false; 9813 } 9814 else if (!TREE_PUBLIC (decl)) 9815 { 9816 error ("%qD may not be declared as static", decl); 9817 return false; 9818 } 9819 } 9820 } 9821 9822 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR) 9823 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl)); 9824 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR) 9825 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl)); 9826 else 9827 { 9828 /* An operator function must either be a non-static member function 9829 or have at least one parameter of a class, a reference to a class, 9830 an enumeration, or a reference to an enumeration. 13.4.0.6 */ 9831 if (! methodp || DECL_STATIC_FUNCTION_P (decl)) 9832 { 9833 if (operator_code == TYPE_EXPR 9834 || operator_code == CALL_EXPR 9835 || operator_code == COMPONENT_REF 9836 || operator_code == ARRAY_REF 9837 || operator_code == NOP_EXPR) 9838 { 9839 error ("%qD must be a nonstatic member function", decl); 9840 return false; 9841 } 9842 else 9843 { 9844 tree p; 9845 9846 if (DECL_STATIC_FUNCTION_P (decl)) 9847 { 9848 error ("%qD must be either a non-static member " 9849 "function or a non-member function", decl); 9850 return false; 9851 } 9852 9853 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p)) 9854 { 9855 tree arg = non_reference (TREE_VALUE (p)); 9856 if (arg == error_mark_node) 9857 return false; 9858 9859 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used 9860 because these checks are performed even on 9861 template functions. */ 9862 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE) 9863 break; 9864 } 9865 9866 if (!p || p == void_list_node) 9867 { 9868 if (complain) 9869 error ("%qD must have an argument of class or " 9870 "enumerated type", decl); 9871 return false; 9872 } 9873 } 9874 } 9875 9876 /* There are no restrictions on the arguments to an overloaded 9877 "operator ()". */ 9878 if (operator_code == CALL_EXPR) 9879 return true; 9880 9881 /* Warn about conversion operators that will never be used. */ 9882 if (IDENTIFIER_TYPENAME_P (name) 9883 && ! DECL_TEMPLATE_INFO (decl) 9884 && warn_conversion 9885 /* Warn only declaring the function; there is no need to 9886 warn again about out-of-class definitions. */ 9887 && class_type == current_class_type) 9888 { 9889 tree t = TREE_TYPE (name); 9890 int ref = (TREE_CODE (t) == REFERENCE_TYPE); 9891 const char *what = 0; 9892 9893 if (ref) 9894 t = TYPE_MAIN_VARIANT (TREE_TYPE (t)); 9895 9896 if (TREE_CODE (t) == VOID_TYPE) 9897 what = "void"; 9898 else if (class_type) 9899 { 9900 if (t == class_type) 9901 what = "the same type"; 9902 /* Don't force t to be complete here. */ 9903 else if (IS_AGGR_TYPE (t) 9904 && COMPLETE_TYPE_P (t) 9905 && DERIVED_FROM_P (t, class_type)) 9906 what = "a base class"; 9907 } 9908 9909 if (what) 9910 warning (OPT_Wconversion, "conversion to %s%s will never use a type " 9911 "conversion operator", 9912 ref ? "a reference to " : "", what); 9913 } 9914 9915 if (operator_code == COND_EXPR) 9916 { 9917 /* 13.4.0.3 */ 9918 error ("ISO C++ prohibits overloading operator ?:"); 9919 return false; 9920 } 9921 else if (ellipsis_p) 9922 { 9923 error ("%qD must not have variable number of arguments", decl); 9924 return false; 9925 } 9926 else if (ambi_op_p (operator_code)) 9927 { 9928 if (arity == 1) 9929 /* We pick the one-argument operator codes by default, so 9930 we don't have to change anything. */ 9931 ; 9932 else if (arity == 2) 9933 { 9934 /* If we thought this was a unary operator, we now know 9935 it to be a binary operator. */ 9936 switch (operator_code) 9937 { 9938 case INDIRECT_REF: 9939 operator_code = MULT_EXPR; 9940 break; 9941 9942 case ADDR_EXPR: 9943 operator_code = BIT_AND_EXPR; 9944 break; 9945 9946 case UNARY_PLUS_EXPR: 9947 operator_code = PLUS_EXPR; 9948 break; 9949 9950 case NEGATE_EXPR: 9951 operator_code = MINUS_EXPR; 9952 break; 9953 9954 case PREINCREMENT_EXPR: 9955 operator_code = POSTINCREMENT_EXPR; 9956 break; 9957 9958 case PREDECREMENT_EXPR: 9959 operator_code = POSTDECREMENT_EXPR; 9960 break; 9961 9962 default: 9963 gcc_unreachable (); 9964 } 9965 9966 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code); 9967 9968 if ((operator_code == POSTINCREMENT_EXPR 9969 || operator_code == POSTDECREMENT_EXPR) 9970 && ! processing_template_decl 9971 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node)) 9972 { 9973 if (methodp) 9974 error ("postfix %qD must take %<int%> as its argument", 9975 decl); 9976 else 9977 error ("postfix %qD must take %<int%> as its second " 9978 "argument", decl); 9979 return false; 9980 } 9981 } 9982 else 9983 { 9984 if (methodp) 9985 error ("%qD must take either zero or one argument", decl); 9986 else 9987 error ("%qD must take either one or two arguments", decl); 9988 return false; 9989 } 9990 9991 /* More Effective C++ rule 6. */ 9992 if (warn_ecpp 9993 && (operator_code == POSTINCREMENT_EXPR 9994 || operator_code == POSTDECREMENT_EXPR 9995 || operator_code == PREINCREMENT_EXPR 9996 || operator_code == PREDECREMENT_EXPR)) 9997 { 9998 tree arg = TREE_VALUE (argtypes); 9999 tree ret = TREE_TYPE (TREE_TYPE (decl)); 10000 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE) 10001 arg = TREE_TYPE (arg); 10002 arg = TYPE_MAIN_VARIANT (arg); 10003 if (operator_code == PREINCREMENT_EXPR 10004 || operator_code == PREDECREMENT_EXPR) 10005 { 10006 if (TREE_CODE (ret) != REFERENCE_TYPE 10007 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)), 10008 arg)) 10009 warning (OPT_Weffc__, "prefix %qD should return %qT", decl, 10010 build_reference_type (arg)); 10011 } 10012 else 10013 { 10014 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg)) 10015 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg); 10016 } 10017 } 10018 } 10019 else if (unary_op_p (operator_code)) 10020 { 10021 if (arity != 1) 10022 { 10023 if (methodp) 10024 error ("%qD must take %<void%>", decl); 10025 else 10026 error ("%qD must take exactly one argument", decl); 10027 return false; 10028 } 10029 } 10030 else /* if (binary_op_p (operator_code)) */ 10031 { 10032 if (arity != 2) 10033 { 10034 if (methodp) 10035 error ("%qD must take exactly one argument", decl); 10036 else 10037 error ("%qD must take exactly two arguments", decl); 10038 return false; 10039 } 10040 10041 /* More Effective C++ rule 7. */ 10042 if (warn_ecpp 10043 && (operator_code == TRUTH_ANDIF_EXPR 10044 || operator_code == TRUTH_ORIF_EXPR 10045 || operator_code == COMPOUND_EXPR)) 10046 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments", 10047 decl); 10048 } 10049 10050 /* Effective C++ rule 23. */ 10051 if (warn_ecpp 10052 && arity == 2 10053 && !DECL_ASSIGNMENT_OPERATOR_P (decl) 10054 && (operator_code == PLUS_EXPR 10055 || operator_code == MINUS_EXPR 10056 || operator_code == TRUNC_DIV_EXPR 10057 || operator_code == MULT_EXPR 10058 || operator_code == TRUNC_MOD_EXPR) 10059 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE) 10060 warning (OPT_Weffc__, "%qD should return by value", decl); 10061 10062 /* [over.oper]/8 */ 10063 for (; argtypes && argtypes != void_list_node; 10064 argtypes = TREE_CHAIN (argtypes)) 10065 if (TREE_PURPOSE (argtypes)) 10066 { 10067 TREE_PURPOSE (argtypes) = NULL_TREE; 10068 if (operator_code == POSTINCREMENT_EXPR 10069 || operator_code == POSTDECREMENT_EXPR) 10070 { 10071 if (pedantic) 10072 pedwarn ("%qD cannot have default arguments", decl); 10073 } 10074 else 10075 { 10076 error ("%qD cannot have default arguments", decl); 10077 return false; 10078 } 10079 } 10080 } 10081 return true; 10082} 10083 10084/* Return a string giving the keyword associate with CODE. */ 10085 10086static const char * 10087tag_name (enum tag_types code) 10088{ 10089 switch (code) 10090 { 10091 case record_type: 10092 return "struct"; 10093 case class_type: 10094 return "class"; 10095 case union_type: 10096 return "union"; 10097 case enum_type: 10098 return "enum"; 10099 case typename_type: 10100 return "typename"; 10101 default: 10102 gcc_unreachable (); 10103 } 10104} 10105 10106/* Name lookup in an elaborated-type-specifier (after the keyword 10107 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the 10108 elaborated-type-specifier is invalid, issue a diagnostic and return 10109 error_mark_node; otherwise, return the *_TYPE to which it referred. 10110 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */ 10111 10112tree 10113check_elaborated_type_specifier (enum tag_types tag_code, 10114 tree decl, 10115 bool allow_template_p) 10116{ 10117 tree type; 10118 10119 /* In the case of: 10120 10121 struct S { struct S *p; }; 10122 10123 name lookup will find the TYPE_DECL for the implicit "S::S" 10124 typedef. Adjust for that here. */ 10125 if (DECL_SELF_REFERENCE_P (decl)) 10126 decl = TYPE_NAME (TREE_TYPE (decl)); 10127 10128 type = TREE_TYPE (decl); 10129 10130 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P 10131 is false for this case as well. */ 10132 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM) 10133 { 10134 error ("using template type parameter %qT after %qs", 10135 type, tag_name (tag_code)); 10136 return error_mark_node; 10137 } 10138 /* [dcl.type.elab] 10139 10140 If the identifier resolves to a typedef-name or a template 10141 type-parameter, the elaborated-type-specifier is ill-formed. 10142 10143 In other words, the only legitimate declaration to use in the 10144 elaborated type specifier is the implicit typedef created when 10145 the type is declared. */ 10146 else if (!DECL_IMPLICIT_TYPEDEF_P (decl) 10147 && tag_code != typename_type) 10148 { 10149 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code)); 10150 error ("%q+D has a previous declaration here", decl); 10151 return error_mark_node; 10152 } 10153 else if (TREE_CODE (type) != RECORD_TYPE 10154 && TREE_CODE (type) != UNION_TYPE 10155 && tag_code != enum_type 10156 && tag_code != typename_type) 10157 { 10158 error ("%qT referred to as %qs", type, tag_name (tag_code)); 10159 error ("%q+T has a previous declaration here", type); 10160 return error_mark_node; 10161 } 10162 else if (TREE_CODE (type) != ENUMERAL_TYPE 10163 && tag_code == enum_type) 10164 { 10165 error ("%qT referred to as enum", type); 10166 error ("%q+T has a previous declaration here", type); 10167 return error_mark_node; 10168 } 10169 else if (!allow_template_p 10170 && TREE_CODE (type) == RECORD_TYPE 10171 && CLASSTYPE_IS_TEMPLATE (type)) 10172 { 10173 /* If a class template appears as elaborated type specifier 10174 without a template header such as: 10175 10176 template <class T> class C {}; 10177 void f(class C); // No template header here 10178 10179 then the required template argument is missing. */ 10180 error ("template argument required for %<%s %T%>", 10181 tag_name (tag_code), 10182 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))); 10183 return error_mark_node; 10184 } 10185 10186 return type; 10187} 10188 10189/* Lookup NAME in elaborate type specifier in scope according to 10190 SCOPE and issue diagnostics if necessary. 10191 Return *_TYPE node upon success, NULL_TREE when the NAME is not 10192 found, and ERROR_MARK_NODE for type error. */ 10193 10194static tree 10195lookup_and_check_tag (enum tag_types tag_code, tree name, 10196 tag_scope scope, bool template_header_p) 10197{ 10198 tree t; 10199 tree decl; 10200 if (scope == ts_global) 10201 { 10202 /* First try ordinary name lookup, ignoring hidden class name 10203 injected via friend declaration. */ 10204 decl = lookup_name_prefer_type (name, 2); 10205 /* If that fails, the name will be placed in the smallest 10206 non-class, non-function-prototype scope according to 3.3.1/5. 10207 We may already have a hidden name declared as friend in this 10208 scope. So lookup again but not ignoring hidden names. 10209 If we find one, that name will be made visible rather than 10210 creating a new tag. */ 10211 if (!decl) 10212 decl = lookup_type_scope (name, ts_within_enclosing_non_class); 10213 } 10214 else 10215 decl = lookup_type_scope (name, scope); 10216 10217 if (decl && DECL_CLASS_TEMPLATE_P (decl)) 10218 decl = DECL_TEMPLATE_RESULT (decl); 10219 10220 if (decl && TREE_CODE (decl) == TYPE_DECL) 10221 { 10222 /* Look for invalid nested type: 10223 class C { 10224 class C {}; 10225 }; */ 10226 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl)) 10227 { 10228 error ("%qD has the same name as the class in which it is " 10229 "declared", 10230 decl); 10231 return error_mark_node; 10232 } 10233 10234 /* Two cases we need to consider when deciding if a class 10235 template is allowed as an elaborated type specifier: 10236 1. It is a self reference to its own class. 10237 2. It comes with a template header. 10238 10239 For example: 10240 10241 template <class T> class C { 10242 class C *c1; // DECL_SELF_REFERENCE_P is true 10243 class D; 10244 }; 10245 template <class U> class C; // template_header_p is true 10246 template <class T> class C<T>::D { 10247 class C *c2; // DECL_SELF_REFERENCE_P is true 10248 }; */ 10249 10250 t = check_elaborated_type_specifier (tag_code, 10251 decl, 10252 template_header_p 10253 | DECL_SELF_REFERENCE_P (decl)); 10254 return t; 10255 } 10256 else if (decl && TREE_CODE (decl) == TREE_LIST) 10257 { 10258 error ("reference to %qD is ambiguous", name); 10259 print_candidates (decl); 10260 return error_mark_node; 10261 } 10262 else 10263 return NULL_TREE; 10264} 10265 10266/* Get the struct, enum or union (TAG_CODE says which) with tag NAME. 10267 Define the tag as a forward-reference if it is not defined. 10268 10269 If a declaration is given, process it here, and report an error if 10270 multiple declarations are not identical. 10271 10272 SCOPE is TS_CURRENT when this is also a definition. Only look in 10273 the current frame for the name (since C++ allows new names in any 10274 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend 10275 declaration. Only look beginning from the current scope outward up 10276 till the nearest non-class scope. Otherwise it is TS_GLOBAL. 10277 10278 TEMPLATE_HEADER_P is true when this declaration is preceded by 10279 a set of template parameters. */ 10280 10281tree 10282xref_tag (enum tag_types tag_code, tree name, 10283 tag_scope scope, bool template_header_p) 10284{ 10285 enum tree_code code; 10286 tree t; 10287 tree context = NULL_TREE; 10288 10289 timevar_push (TV_NAME_LOOKUP); 10290 10291 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); 10292 10293 switch (tag_code) 10294 { 10295 case record_type: 10296 case class_type: 10297 code = RECORD_TYPE; 10298 break; 10299 case union_type: 10300 code = UNION_TYPE; 10301 break; 10302 case enum_type: 10303 code = ENUMERAL_TYPE; 10304 break; 10305 default: 10306 gcc_unreachable (); 10307 } 10308 10309 /* In case of anonymous name, xref_tag is only called to 10310 make type node and push name. Name lookup is not required. */ 10311 if (ANON_AGGRNAME_P (name)) 10312 t = NULL_TREE; 10313 else 10314 t = lookup_and_check_tag (tag_code, name, 10315 scope, template_header_p); 10316 10317 if (t == error_mark_node) 10318 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 10319 10320 if (scope != ts_current && t && current_class_type 10321 && template_class_depth (current_class_type) 10322 && template_header_p) 10323 { 10324 /* Since SCOPE is not TS_CURRENT, we are not looking at a 10325 definition of this tag. Since, in addition, we are currently 10326 processing a (member) template declaration of a template 10327 class, we must be very careful; consider: 10328 10329 template <class X> 10330 struct S1 10331 10332 template <class U> 10333 struct S2 10334 { template <class V> 10335 friend struct S1; }; 10336 10337 Here, the S2::S1 declaration should not be confused with the 10338 outer declaration. In particular, the inner version should 10339 have a template parameter of level 2, not level 1. This 10340 would be particularly important if the member declaration 10341 were instead: 10342 10343 template <class V = U> friend struct S1; 10344 10345 say, when we should tsubst into `U' when instantiating 10346 S2. On the other hand, when presented with: 10347 10348 template <class T> 10349 struct S1 { 10350 template <class U> 10351 struct S2 {}; 10352 template <class U> 10353 friend struct S2; 10354 }; 10355 10356 we must find the inner binding eventually. We 10357 accomplish this by making sure that the new type we 10358 create to represent this declaration has the right 10359 TYPE_CONTEXT. */ 10360 context = TYPE_CONTEXT (t); 10361 t = NULL_TREE; 10362 } 10363 10364 if (! t) 10365 { 10366 /* If no such tag is yet defined, create a forward-reference node 10367 and record it as the "definition". 10368 When a real declaration of this type is found, 10369 the forward-reference will be altered into a real type. */ 10370 if (code == ENUMERAL_TYPE) 10371 { 10372 error ("use of enum %q#D without previous declaration", name); 10373 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 10374 } 10375 else 10376 { 10377 t = make_aggr_type (code); 10378 TYPE_CONTEXT (t) = context; 10379 t = pushtag (name, t, scope); 10380 } 10381 } 10382 else 10383 { 10384 if (template_header_p && IS_AGGR_TYPE (t)) 10385 { 10386 if (!redeclare_class_template (t, current_template_parms)) 10387 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 10388 } 10389 else if (!processing_template_decl 10390 && CLASS_TYPE_P (t) 10391 && CLASSTYPE_IS_TEMPLATE (t)) 10392 { 10393 error ("redeclaration of %qT as a non-template", t); 10394 error ("previous declaration %q+D", t); 10395 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 10396 } 10397 10398 /* Make injected friend class visible. */ 10399 if (scope != ts_within_enclosing_non_class 10400 && hidden_name_p (TYPE_NAME (t))) 10401 { 10402 DECL_ANTICIPATED (TYPE_NAME (t)) = 0; 10403 DECL_FRIEND_P (TYPE_NAME (t)) = 0; 10404 10405 if (TYPE_TEMPLATE_INFO (t)) 10406 { 10407 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0; 10408 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0; 10409 } 10410 } 10411 } 10412 10413 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); 10414} 10415 10416tree 10417xref_tag_from_type (tree old, tree id, tag_scope scope) 10418{ 10419 enum tag_types tag_kind; 10420 10421 if (TREE_CODE (old) == RECORD_TYPE) 10422 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type); 10423 else 10424 tag_kind = union_type; 10425 10426 if (id == NULL_TREE) 10427 id = TYPE_IDENTIFIER (old); 10428 10429 return xref_tag (tag_kind, id, scope, false); 10430} 10431 10432/* Create the binfo hierarchy for REF with (possibly NULL) base list 10433 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an 10434 access_* node, and the TREE_VALUE is the type of the base-class. 10435 Non-NULL TREE_TYPE indicates virtual inheritance. 10436 10437 Returns true if the binfo heirarchy was successfully created, 10438 false if an error was detected. */ 10439 10440bool 10441xref_basetypes (tree ref, tree base_list) 10442{ 10443 tree *basep; 10444 tree binfo, base_binfo; 10445 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */ 10446 unsigned max_bases = 0; /* Maximum direct bases. */ 10447 int i; 10448 tree default_access; 10449 tree igo_prev; /* Track Inheritance Graph Order. */ 10450 10451 if (ref == error_mark_node) 10452 return false; 10453 10454 /* The base of a derived class is private by default, all others are 10455 public. */ 10456 default_access = (TREE_CODE (ref) == RECORD_TYPE 10457 && CLASSTYPE_DECLARED_CLASS (ref) 10458 ? access_private_node : access_public_node); 10459 10460 /* First, make sure that any templates in base-classes are 10461 instantiated. This ensures that if we call ourselves recursively 10462 we do not get confused about which classes are marked and which 10463 are not. */ 10464 basep = &base_list; 10465 while (*basep) 10466 { 10467 tree basetype = TREE_VALUE (*basep); 10468 10469 if (!(processing_template_decl && uses_template_parms (basetype)) 10470 && !complete_type_or_else (basetype, NULL)) 10471 /* An incomplete type. Remove it from the list. */ 10472 *basep = TREE_CHAIN (*basep); 10473 else 10474 { 10475 max_bases++; 10476 if (TREE_TYPE (*basep)) 10477 max_vbases++; 10478 if (CLASS_TYPE_P (basetype)) 10479 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype)); 10480 basep = &TREE_CHAIN (*basep); 10481 } 10482 } 10483 10484 TYPE_MARKED_P (ref) = 1; 10485 10486 /* The binfo slot should be empty, unless this is an (ill-formed) 10487 redefinition. */ 10488 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref)); 10489 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref); 10490 10491 binfo = make_tree_binfo (max_bases); 10492 10493 TYPE_BINFO (ref) = binfo; 10494 BINFO_OFFSET (binfo) = size_zero_node; 10495 BINFO_TYPE (binfo) = ref; 10496 10497 if (max_bases) 10498 { 10499 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases); 10500 /* An aggregate cannot have baseclasses. */ 10501 CLASSTYPE_NON_AGGREGATE (ref) = 1; 10502 10503 if (TREE_CODE (ref) == UNION_TYPE) 10504 { 10505 error ("derived union %qT invalid", ref); 10506 return false; 10507 } 10508 } 10509 10510 if (max_bases > 1) 10511 { 10512 if (TYPE_FOR_JAVA (ref)) 10513 { 10514 error ("Java class %qT cannot have multiple bases", ref); 10515 return false; 10516 } 10517 } 10518 10519 if (max_vbases) 10520 { 10521 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases); 10522 10523 if (TYPE_FOR_JAVA (ref)) 10524 { 10525 error ("Java class %qT cannot have virtual bases", ref); 10526 return false; 10527 } 10528 } 10529 10530 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list)) 10531 { 10532 tree access = TREE_PURPOSE (base_list); 10533 int via_virtual = TREE_TYPE (base_list) != NULL_TREE; 10534 tree basetype = TREE_VALUE (base_list); 10535 10536 if (access == access_default_node) 10537 access = default_access; 10538 10539 if (TREE_CODE (basetype) == TYPE_DECL) 10540 basetype = TREE_TYPE (basetype); 10541 if (TREE_CODE (basetype) != RECORD_TYPE 10542 && TREE_CODE (basetype) != TYPENAME_TYPE 10543 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM 10544 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM) 10545 { 10546 error ("base type %qT fails to be a struct or class type", 10547 basetype); 10548 return false; 10549 } 10550 10551 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0)) 10552 TYPE_FOR_JAVA (ref) = 1; 10553 10554 base_binfo = NULL_TREE; 10555 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype)) 10556 { 10557 base_binfo = TYPE_BINFO (basetype); 10558 /* The original basetype could have been a typedef'd type. */ 10559 basetype = BINFO_TYPE (base_binfo); 10560 10561 /* Inherit flags from the base. */ 10562 TYPE_HAS_NEW_OPERATOR (ref) 10563 |= TYPE_HAS_NEW_OPERATOR (basetype); 10564 TYPE_HAS_ARRAY_NEW_OPERATOR (ref) 10565 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype); 10566 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype); 10567 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype); 10568 CLASSTYPE_DIAMOND_SHAPED_P (ref) 10569 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype); 10570 CLASSTYPE_REPEATED_BASE_P (ref) 10571 |= CLASSTYPE_REPEATED_BASE_P (basetype); 10572 } 10573 10574 /* We must do this test after we've seen through a typedef 10575 type. */ 10576 if (TYPE_MARKED_P (basetype)) 10577 { 10578 if (basetype == ref) 10579 error ("recursive type %qT undefined", basetype); 10580 else 10581 error ("duplicate base type %qT invalid", basetype); 10582 return false; 10583 } 10584 TYPE_MARKED_P (basetype) = 1; 10585 10586 base_binfo = copy_binfo (base_binfo, basetype, ref, 10587 &igo_prev, via_virtual); 10588 if (!BINFO_INHERITANCE_CHAIN (base_binfo)) 10589 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo; 10590 10591 BINFO_BASE_APPEND (binfo, base_binfo); 10592 BINFO_BASE_ACCESS_APPEND (binfo, access); 10593 } 10594 10595 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1)) 10596 /* If we have space in the vbase vector, we must have shared at 10597 least one of them, and are therefore diamond shaped. */ 10598 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1; 10599 10600 /* Unmark all the types. */ 10601 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 10602 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0; 10603 TYPE_MARKED_P (ref) = 0; 10604 10605 /* Now see if we have a repeated base type. */ 10606 if (!CLASSTYPE_REPEATED_BASE_P (ref)) 10607 { 10608 for (base_binfo = binfo; base_binfo; 10609 base_binfo = TREE_CHAIN (base_binfo)) 10610 { 10611 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo))) 10612 { 10613 CLASSTYPE_REPEATED_BASE_P (ref) = 1; 10614 break; 10615 } 10616 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1; 10617 } 10618 for (base_binfo = binfo; base_binfo; 10619 base_binfo = TREE_CHAIN (base_binfo)) 10620 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo))) 10621 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0; 10622 else 10623 break; 10624 } 10625 10626 return true; 10627} 10628 10629 10630/* Begin compiling the definition of an enumeration type. 10631 NAME is its name. 10632 Returns the type object, as yet incomplete. 10633 Also records info about it so that build_enumerator 10634 may be used to declare the individual values as they are read. */ 10635 10636tree 10637start_enum (tree name) 10638{ 10639 tree enumtype; 10640 10641 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); 10642 10643 /* If this is the real definition for a previous forward reference, 10644 fill in the contents in the same object that used to be the 10645 forward reference. */ 10646 10647 enumtype = lookup_and_check_tag (enum_type, name, 10648 /*tag_scope=*/ts_current, 10649 /*template_header_p=*/false); 10650 10651 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE) 10652 { 10653 error ("multiple definition of %q#T", enumtype); 10654 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype)); 10655 /* Clear out TYPE_VALUES, and start again. */ 10656 TYPE_VALUES (enumtype) = NULL_TREE; 10657 } 10658 else 10659 { 10660 /* In case of error, make a dummy enum to allow parsing to 10661 continue. */ 10662 if (enumtype == error_mark_node) 10663 name = make_anon_name (); 10664 10665 enumtype = make_node (ENUMERAL_TYPE); 10666 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current); 10667 } 10668 10669 return enumtype; 10670} 10671 10672/* After processing and defining all the values of an enumeration type, 10673 install their decls in the enumeration type and finish it off. 10674 ENUMTYPE is the type object and VALUES a list of name-value pairs. */ 10675 10676void 10677finish_enum (tree enumtype) 10678{ 10679 tree values; 10680 tree decl; 10681 tree value; 10682 tree minnode; 10683 tree maxnode; 10684 tree t; 10685 bool unsignedp; 10686 bool use_short_enum; 10687 int lowprec; 10688 int highprec; 10689 int precision; 10690 integer_type_kind itk; 10691 tree underlying_type = NULL_TREE; 10692 10693 /* We built up the VALUES in reverse order. */ 10694 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype)); 10695 10696 /* For an enum defined in a template, just set the type of the values; 10697 all further processing is postponed until the template is 10698 instantiated. We need to set the type so that tsubst of a CONST_DECL 10699 works. */ 10700 if (processing_template_decl) 10701 { 10702 for (values = TYPE_VALUES (enumtype); 10703 values; 10704 values = TREE_CHAIN (values)) 10705 TREE_TYPE (TREE_VALUE (values)) = enumtype; 10706 if (at_function_scope_p ()) 10707 add_stmt (build_min (TAG_DEFN, enumtype)); 10708 return; 10709 } 10710 10711 /* Determine the minimum and maximum values of the enumerators. */ 10712 if (TYPE_VALUES (enumtype)) 10713 { 10714 minnode = maxnode = NULL_TREE; 10715 10716 for (values = TYPE_VALUES (enumtype); 10717 values; 10718 values = TREE_CHAIN (values)) 10719 { 10720 decl = TREE_VALUE (values); 10721 10722 /* [dcl.enum]: Following the closing brace of an enum-specifier, 10723 each enumerator has the type of its enumeration. Prior to the 10724 closing brace, the type of each enumerator is the type of its 10725 initializing value. */ 10726 TREE_TYPE (decl) = enumtype; 10727 10728 /* Update the minimum and maximum values, if appropriate. */ 10729 value = DECL_INITIAL (decl); 10730 if (value == error_mark_node) 10731 value = integer_zero_node; 10732 /* Figure out what the minimum and maximum values of the 10733 enumerators are. */ 10734 if (!minnode) 10735 minnode = maxnode = value; 10736 else if (tree_int_cst_lt (maxnode, value)) 10737 maxnode = value; 10738 else if (tree_int_cst_lt (value, minnode)) 10739 minnode = value; 10740 } 10741 } 10742 else 10743 /* [dcl.enum] 10744 10745 If the enumerator-list is empty, the underlying type is as if 10746 the enumeration had a single enumerator with value 0. */ 10747 minnode = maxnode = integer_zero_node; 10748 10749 /* Compute the number of bits require to represent all values of the 10750 enumeration. We must do this before the type of MINNODE and 10751 MAXNODE are transformed, since min_precision relies on the 10752 TREE_TYPE of the value it is passed. */ 10753 unsignedp = tree_int_cst_sgn (minnode) >= 0; 10754 lowprec = min_precision (minnode, unsignedp); 10755 highprec = min_precision (maxnode, unsignedp); 10756 precision = MAX (lowprec, highprec); 10757 10758 /* Determine the underlying type of the enumeration. 10759 10760 [dcl.enum] 10761 10762 The underlying type of an enumeration is an integral type that 10763 can represent all the enumerator values defined in the 10764 enumeration. It is implementation-defined which integral type is 10765 used as the underlying type for an enumeration except that the 10766 underlying type shall not be larger than int unless the value of 10767 an enumerator cannot fit in an int or unsigned int. 10768 10769 We use "int" or an "unsigned int" as the underlying type, even if 10770 a smaller integral type would work, unless the user has 10771 explicitly requested that we use the smallest possible type. The 10772 user can request that for all enumerations with a command line 10773 flag, or for just one enumeration with an attribute. */ 10774 10775 use_short_enum = flag_short_enums 10776 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype)); 10777 10778 for (itk = (use_short_enum ? itk_char : itk_int); 10779 itk != itk_none; 10780 itk++) 10781 { 10782 underlying_type = integer_types[itk]; 10783 if (TYPE_PRECISION (underlying_type) >= precision 10784 && TYPE_UNSIGNED (underlying_type) == unsignedp) 10785 break; 10786 } 10787 if (itk == itk_none) 10788 { 10789 /* DR 377 10790 10791 IF no integral type can represent all the enumerator values, the 10792 enumeration is ill-formed. */ 10793 error ("no integral type can represent all of the enumerator values " 10794 "for %qT", enumtype); 10795 precision = TYPE_PRECISION (long_long_integer_type_node); 10796 underlying_type = integer_types[itk_unsigned_long_long]; 10797 } 10798 10799 /* Compute the minium and maximum values for the type. 10800 10801 [dcl.enum] 10802 10803 For an enumeration where emin is the smallest enumerator and emax 10804 is the largest, the values of the enumeration are the values of the 10805 underlying type in the range bmin to bmax, where bmin and bmax are, 10806 respectively, the smallest and largest values of the smallest bit- 10807 field that can store emin and emax. */ 10808 10809 /* The middle-end currently assumes that types with TYPE_PRECISION 10810 narrower than their underlying type are suitably zero or sign 10811 extended to fill their mode. g++ doesn't make these guarantees. 10812 Until the middle-end can represent such paradoxical types, we 10813 set the TYPE_PRECISION to the width of the underlying type. */ 10814 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type); 10815 10816 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp); 10817 10818 /* [dcl.enum] 10819 10820 The value of sizeof() applied to an enumeration type, an object 10821 of an enumeration type, or an enumerator, is the value of sizeof() 10822 applied to the underlying type. */ 10823 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type); 10824 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type); 10825 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type); 10826 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type); 10827 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type); 10828 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type); 10829 10830 /* Convert each of the enumerators to the type of the underlying 10831 type of the enumeration. */ 10832 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values)) 10833 { 10834 location_t saved_location; 10835 10836 decl = TREE_VALUE (values); 10837 saved_location = input_location; 10838 input_location = DECL_SOURCE_LOCATION (decl); 10839 value = perform_implicit_conversion (underlying_type, 10840 DECL_INITIAL (decl)); 10841 input_location = saved_location; 10842 10843 /* Do not clobber shared ints. */ 10844 value = copy_node (value); 10845 10846 TREE_TYPE (value) = enumtype; 10847 DECL_INITIAL (decl) = value; 10848 TREE_VALUE (values) = value; 10849 } 10850 10851 /* Fix up all variant types of this enum type. */ 10852 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t)) 10853 { 10854 TYPE_VALUES (t) = TYPE_VALUES (enumtype); 10855 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype); 10856 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype); 10857 TYPE_SIZE (t) = TYPE_SIZE (enumtype); 10858 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype); 10859 TYPE_MODE (t) = TYPE_MODE (enumtype); 10860 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype); 10861 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype); 10862 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype); 10863 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype); 10864 } 10865 10866 /* Finish debugging output for this type. */ 10867 rest_of_type_compilation (enumtype, namespace_bindings_p ()); 10868} 10869 10870/* Build and install a CONST_DECL for an enumeration constant of the 10871 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided. 10872 Assignment of sequential values by default is handled here. */ 10873 10874void 10875build_enumerator (tree name, tree value, tree enumtype) 10876{ 10877 tree decl; 10878 tree context; 10879 tree type; 10880 10881 /* If the VALUE was erroneous, pretend it wasn't there; that will 10882 result in the enum being assigned the next value in sequence. */ 10883 if (value == error_mark_node) 10884 value = NULL_TREE; 10885 10886 /* Remove no-op casts from the value. */ 10887 if (value) 10888 STRIP_TYPE_NOPS (value); 10889 10890 if (! processing_template_decl) 10891 { 10892 /* Validate and default VALUE. */ 10893 if (value != NULL_TREE) 10894 { 10895 value = integral_constant_value (value); 10896 10897 if (TREE_CODE (value) == INTEGER_CST) 10898 { 10899 value = perform_integral_promotions (value); 10900 constant_expression_warning (value); 10901 } 10902 else 10903 { 10904 error ("enumerator value for %qD not integer constant", name); 10905 value = NULL_TREE; 10906 } 10907 } 10908 10909 /* Default based on previous value. */ 10910 if (value == NULL_TREE) 10911 { 10912 if (TYPE_VALUES (enumtype)) 10913 { 10914 HOST_WIDE_INT hi; 10915 unsigned HOST_WIDE_INT lo; 10916 tree prev_value; 10917 bool overflowed; 10918 10919 /* The next value is the previous value plus one. We can 10920 safely assume that the previous value is an INTEGER_CST. 10921 add_double doesn't know the type of the target expression, 10922 so we must check with int_fits_type_p as well. */ 10923 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype))); 10924 overflowed = add_double (TREE_INT_CST_LOW (prev_value), 10925 TREE_INT_CST_HIGH (prev_value), 10926 1, 0, &lo, &hi); 10927 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi); 10928 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value)); 10929 10930 if (overflowed) 10931 { 10932 error ("overflow in enumeration values at %qD", name); 10933 value = error_mark_node; 10934 } 10935 } 10936 else 10937 value = integer_zero_node; 10938 } 10939 10940 /* Remove no-op casts from the value. */ 10941 STRIP_TYPE_NOPS (value); 10942 } 10943 10944 /* C++ associates enums with global, function, or class declarations. */ 10945 context = current_scope (); 10946 10947 /* Build the actual enumeration constant. Note that the enumeration 10948 constants have the type of their initializers until the 10949 enumeration is complete: 10950 10951 [ dcl.enum ] 10952 10953 Following the closing brace of an enum-specifier, each enumer- 10954 ator has the type of its enumeration. Prior to the closing 10955 brace, the type of each enumerator is the type of its 10956 initializing value. 10957 10958 In finish_enum we will reset the type. Of course, if we're 10959 processing a template, there may be no value. */ 10960 type = value ? TREE_TYPE (value) : NULL_TREE; 10961 10962 if (context && context == current_class_type) 10963 /* This enum declaration is local to the class. We need the full 10964 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */ 10965 decl = build_lang_decl (CONST_DECL, name, type); 10966 else 10967 /* It's a global enum, or it's local to a function. (Note local to 10968 a function could mean local to a class method. */ 10969 decl = build_decl (CONST_DECL, name, type); 10970 10971 DECL_CONTEXT (decl) = FROB_CONTEXT (context); 10972 TREE_CONSTANT (decl) = 1; 10973 TREE_INVARIANT (decl) = 1; 10974 TREE_READONLY (decl) = 1; 10975 DECL_INITIAL (decl) = value; 10976 10977 if (context && context == current_class_type) 10978 /* In something like `struct S { enum E { i = 7 }; };' we put `i' 10979 on the TYPE_FIELDS list for `S'. (That's so that you can say 10980 things like `S::i' later.) */ 10981 finish_member_declaration (decl); 10982 else 10983 pushdecl (decl); 10984 10985 /* Add this enumeration constant to the list for this type. */ 10986 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype)); 10987} 10988 10989 10990/* We're defining DECL. Make sure that it's type is OK. */ 10991 10992static void 10993check_function_type (tree decl, tree current_function_parms) 10994{ 10995 tree fntype = TREE_TYPE (decl); 10996 tree return_type = complete_type (TREE_TYPE (fntype)); 10997 10998 /* In a function definition, arg types must be complete. */ 10999 require_complete_types_for_parms (current_function_parms); 11000 11001 if (dependent_type_p (return_type)) 11002 return; 11003 if (!COMPLETE_OR_VOID_TYPE_P (return_type)) 11004 { 11005 tree args = TYPE_ARG_TYPES (fntype); 11006 11007 error ("return type %q#T is incomplete", return_type); 11008 11009 /* Make it return void instead. */ 11010 if (TREE_CODE (fntype) == METHOD_TYPE) 11011 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)), 11012 void_type_node, 11013 TREE_CHAIN (args)); 11014 else 11015 fntype = build_function_type (void_type_node, args); 11016 TREE_TYPE (decl) 11017 = build_exception_variant (fntype, 11018 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl))); 11019 } 11020 else 11021 abstract_virtuals_error (decl, TREE_TYPE (fntype)); 11022} 11023 11024/* Create the FUNCTION_DECL for a function definition. 11025 DECLSPECS and DECLARATOR are the parts of the declaration; 11026 they describe the function's name and the type it returns, 11027 but twisted together in a fashion that parallels the syntax of C. 11028 11029 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the 11030 DECLARATOR is really the DECL for the function we are about to 11031 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE 11032 indicating that the function is an inline defined in-class. 11033 11034 This function creates a binding context for the function body 11035 as well as setting up the FUNCTION_DECL in current_function_decl. 11036 11037 For C++, we must first check whether that datum makes any sense. 11038 For example, "class A local_a(1,2);" means that variable local_a 11039 is an aggregate of type A, which should have a constructor 11040 applied to it with the argument list [1, 2]. 11041 11042 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node, 11043 or may be a BLOCK if the function has been defined previously 11044 in this translation unit. On exit, DECL_INITIAL (decl1) will be 11045 error_mark_node if the function has never been defined, or 11046 a BLOCK if the function has been defined somewhere. */ 11047 11048void 11049start_preparsed_function (tree decl1, tree attrs, int flags) 11050{ 11051 tree ctype = NULL_TREE; 11052 tree fntype; 11053 tree restype; 11054 int doing_friend = 0; 11055 struct cp_binding_level *bl; 11056 tree current_function_parms; 11057 struct c_fileinfo *finfo 11058 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1))); 11059 bool honor_interface; 11060 11061 /* Sanity check. */ 11062 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE); 11063 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE); 11064 11065 fntype = TREE_TYPE (decl1); 11066 if (TREE_CODE (fntype) == METHOD_TYPE) 11067 ctype = TYPE_METHOD_BASETYPE (fntype); 11068 11069 /* ISO C++ 11.4/5. A friend function defined in a class is in 11070 the (lexical) scope of the class in which it is defined. */ 11071 if (!ctype && DECL_FRIEND_P (decl1)) 11072 { 11073 ctype = DECL_FRIEND_CONTEXT (decl1); 11074 11075 /* CTYPE could be null here if we're dealing with a template; 11076 for example, `inline friend float foo()' inside a template 11077 will have no CTYPE set. */ 11078 if (ctype && TREE_CODE (ctype) != RECORD_TYPE) 11079 ctype = NULL_TREE; 11080 else 11081 doing_friend = 1; 11082 } 11083 11084 if (DECL_DECLARED_INLINE_P (decl1) 11085 && lookup_attribute ("noinline", attrs)) 11086 warning (0, "inline function %q+D given attribute noinline", decl1); 11087 11088 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1)) 11089 /* This is a constructor, we must ensure that any default args 11090 introduced by this definition are propagated to the clones 11091 now. The clones are used directly in overload resolution. */ 11092 adjust_clone_args (decl1); 11093 11094 /* Sometimes we don't notice that a function is a static member, and 11095 build a METHOD_TYPE for it. Fix that up now. */ 11096 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1) 11097 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE) 11098 { 11099 revert_static_member_fn (decl1); 11100 ctype = NULL_TREE; 11101 } 11102 11103 /* Set up current_class_type, and enter the scope of the class, if 11104 appropriate. */ 11105 if (ctype) 11106 push_nested_class (ctype); 11107 else if (DECL_STATIC_FUNCTION_P (decl1)) 11108 push_nested_class (DECL_CONTEXT (decl1)); 11109 11110 /* Now that we have entered the scope of the class, we must restore 11111 the bindings for any template parameters surrounding DECL1, if it 11112 is an inline member template. (Order is important; consider the 11113 case where a template parameter has the same name as a field of 11114 the class.) It is not until after this point that 11115 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */ 11116 if (flags & SF_INCLASS_INLINE) 11117 maybe_begin_member_template_processing (decl1); 11118 11119 /* Effective C++ rule 15. */ 11120 if (warn_ecpp 11121 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR 11122 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE) 11123 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>"); 11124 11125 /* Make the init_value nonzero so pushdecl knows this is not tentative. 11126 error_mark_node is replaced below (in poplevel) with the BLOCK. */ 11127 if (!DECL_INITIAL (decl1)) 11128 DECL_INITIAL (decl1) = error_mark_node; 11129 11130 /* This function exists in static storage. 11131 (This does not mean `static' in the C sense!) */ 11132 TREE_STATIC (decl1) = 1; 11133 11134 /* We must call push_template_decl after current_class_type is set 11135 up. (If we are processing inline definitions after exiting a 11136 class scope, current_class_type will be NULL_TREE until set above 11137 by push_nested_class.) */ 11138 if (processing_template_decl) 11139 { 11140 /* FIXME: Handle error_mark_node more gracefully. */ 11141 tree newdecl1 = push_template_decl (decl1); 11142 if (newdecl1 != error_mark_node) 11143 decl1 = newdecl1; 11144 } 11145 11146 /* We are now in the scope of the function being defined. */ 11147 current_function_decl = decl1; 11148 11149 /* Save the parm names or decls from this function's declarator 11150 where store_parm_decls will find them. */ 11151 current_function_parms = DECL_ARGUMENTS (decl1); 11152 11153 /* Make sure the parameter and return types are reasonable. When 11154 you declare a function, these types can be incomplete, but they 11155 must be complete when you define the function. */ 11156 check_function_type (decl1, current_function_parms); 11157 11158 /* Build the return declaration for the function. */ 11159 restype = TREE_TYPE (fntype); 11160 /* Promote the value to int before returning it. */ 11161 if (c_promoting_integer_type_p (restype)) 11162 restype = type_promotes_to (restype); 11163 if (DECL_RESULT (decl1) == NULL_TREE) 11164 { 11165 tree resdecl; 11166 11167 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype)); 11168 DECL_ARTIFICIAL (resdecl) = 1; 11169 DECL_IGNORED_P (resdecl) = 1; 11170 DECL_RESULT (decl1) = resdecl; 11171 11172 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl); 11173 } 11174 11175 /* Let the user know we're compiling this function. */ 11176 announce_function (decl1); 11177 11178 /* Record the decl so that the function name is defined. 11179 If we already have a decl for this name, and it is a FUNCTION_DECL, 11180 use the old decl. */ 11181 if (!processing_template_decl && !(flags & SF_PRE_PARSED)) 11182 { 11183 /* A specialization is not used to guide overload resolution. */ 11184 if (!DECL_FUNCTION_MEMBER_P (decl1) 11185 && !(DECL_USE_TEMPLATE (decl1) && 11186 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1)))) 11187 { 11188 tree olddecl = pushdecl (decl1); 11189 11190 if (olddecl == error_mark_node) 11191 /* If something went wrong when registering the declaration, 11192 use DECL1; we have to have a FUNCTION_DECL to use when 11193 parsing the body of the function. */ 11194 ; 11195 else 11196 /* Otherwise, OLDDECL is either a previous declaration of 11197 the same function or DECL1 itself. */ 11198 decl1 = olddecl; 11199 } 11200 else 11201 { 11202 /* We need to set the DECL_CONTEXT. */ 11203 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1)) 11204 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1)); 11205 } 11206 fntype = TREE_TYPE (decl1); 11207 11208 /* If #pragma weak applies, mark the decl appropriately now. 11209 The pragma only applies to global functions. Because 11210 determining whether or not the #pragma applies involves 11211 computing the mangled name for the declaration, we cannot 11212 apply the pragma until after we have merged this declaration 11213 with any previous declarations; if the original declaration 11214 has a linkage specification, that specification applies to 11215 the definition as well, and may affect the mangled name. */ 11216 if (!DECL_CONTEXT (decl1)) 11217 maybe_apply_pragma_weak (decl1); 11218 } 11219 11220 /* Reset this in case the call to pushdecl changed it. */ 11221 current_function_decl = decl1; 11222 11223 gcc_assert (DECL_INITIAL (decl1)); 11224 11225 /* This function may already have been parsed, in which case just 11226 return; our caller will skip over the body without parsing. */ 11227 if (DECL_INITIAL (decl1) != error_mark_node) 11228 return; 11229 11230 /* Initialize RTL machinery. We cannot do this until 11231 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this 11232 even when processing a template; this is how we get 11233 CFUN set up, and our per-function variables initialized. 11234 FIXME factor out the non-RTL stuff. */ 11235 bl = current_binding_level; 11236 allocate_struct_function (decl1); 11237 current_binding_level = bl; 11238 11239 /* Even though we're inside a function body, we still don't want to 11240 call expand_expr to calculate the size of a variable-sized array. 11241 We haven't necessarily assigned RTL to all variables yet, so it's 11242 not safe to try to expand expressions involving them. */ 11243 cfun->x_dont_save_pending_sizes_p = 1; 11244 11245 /* Start the statement-tree, start the tree now. */ 11246 DECL_SAVED_TREE (decl1) = push_stmt_list (); 11247 11248 /* If we are (erroneously) defining a function that we have already 11249 defined before, wipe out what we knew before. */ 11250 if (!DECL_PENDING_INLINE_P (decl1)) 11251 DECL_SAVED_FUNCTION_DATA (decl1) = NULL; 11252 11253 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1)) 11254 { 11255 /* We know that this was set up by `grokclassfn'. We do not 11256 wait until `store_parm_decls', since evil parse errors may 11257 never get us to that point. Here we keep the consistency 11258 between `current_class_type' and `current_class_ptr'. */ 11259 tree t = DECL_ARGUMENTS (decl1); 11260 11261 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL); 11262 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE); 11263 11264 cp_function_chain->x_current_class_ref 11265 = build_indirect_ref (t, NULL); 11266 cp_function_chain->x_current_class_ptr = t; 11267 11268 /* Constructors and destructors need to know whether they're "in 11269 charge" of initializing virtual base classes. */ 11270 t = TREE_CHAIN (t); 11271 if (DECL_HAS_IN_CHARGE_PARM_P (decl1)) 11272 { 11273 current_in_charge_parm = t; 11274 t = TREE_CHAIN (t); 11275 } 11276 if (DECL_HAS_VTT_PARM_P (decl1)) 11277 { 11278 gcc_assert (DECL_NAME (t) == vtt_parm_identifier); 11279 current_vtt_parm = t; 11280 } 11281 } 11282 11283 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1) 11284 /* Implicitly-defined methods (like the 11285 destructor for a class in which no destructor 11286 is explicitly declared) must not be defined 11287 until their definition is needed. So, we 11288 ignore interface specifications for 11289 compiler-generated functions. */ 11290 && !DECL_ARTIFICIAL (decl1)); 11291 11292 if (DECL_INTERFACE_KNOWN (decl1)) 11293 { 11294 tree ctx = decl_function_context (decl1); 11295 11296 if (DECL_NOT_REALLY_EXTERN (decl1)) 11297 DECL_EXTERNAL (decl1) = 0; 11298 11299 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx) 11300 && TREE_PUBLIC (ctx)) 11301 /* This is a function in a local class in an extern inline 11302 function. */ 11303 comdat_linkage (decl1); 11304 } 11305 /* If this function belongs to an interface, it is public. 11306 If it belongs to someone else's interface, it is also external. 11307 This only affects inlines and template instantiations. */ 11308 else if (!finfo->interface_unknown && honor_interface) 11309 { 11310 if (DECL_DECLARED_INLINE_P (decl1) 11311 || DECL_TEMPLATE_INSTANTIATION (decl1) 11312 || processing_template_decl) 11313 { 11314 DECL_EXTERNAL (decl1) 11315 = (finfo->interface_only 11316 || (DECL_DECLARED_INLINE_P (decl1) 11317 && ! flag_implement_inlines 11318 && !DECL_VINDEX (decl1))); 11319 11320 /* For WIN32 we also want to put these in linkonce sections. */ 11321 maybe_make_one_only (decl1); 11322 } 11323 else 11324 DECL_EXTERNAL (decl1) = 0; 11325 DECL_INTERFACE_KNOWN (decl1) = 1; 11326 /* If this function is in an interface implemented in this file, 11327 make sure that the backend knows to emit this function 11328 here. */ 11329 if (!DECL_EXTERNAL (decl1)) 11330 mark_needed (decl1); 11331 } 11332 else if (finfo->interface_unknown && finfo->interface_only 11333 && honor_interface) 11334 { 11335 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma 11336 interface, we will have both finfo->interface_unknown and 11337 finfo->interface_only set. In that case, we don't want to 11338 use the normal heuristics because someone will supply a 11339 #pragma implementation elsewhere, and deducing it here would 11340 produce a conflict. */ 11341 comdat_linkage (decl1); 11342 DECL_EXTERNAL (decl1) = 0; 11343 DECL_INTERFACE_KNOWN (decl1) = 1; 11344 DECL_DEFER_OUTPUT (decl1) = 1; 11345 } 11346 else 11347 { 11348 /* This is a definition, not a reference. 11349 So clear DECL_EXTERNAL. */ 11350 DECL_EXTERNAL (decl1) = 0; 11351 11352 if ((DECL_DECLARED_INLINE_P (decl1) 11353 || DECL_TEMPLATE_INSTANTIATION (decl1)) 11354 && ! DECL_INTERFACE_KNOWN (decl1) 11355 /* Don't try to defer nested functions for now. */ 11356 && ! decl_function_context (decl1)) 11357 DECL_DEFER_OUTPUT (decl1) = 1; 11358 else 11359 DECL_INTERFACE_KNOWN (decl1) = 1; 11360 } 11361 11362 /* Determine the ELF visibility attribute for the function. We must not 11363 do this before calling "pushdecl", as we must allow "duplicate_decls" 11364 to merge any attributes appropriately. We also need to wait until 11365 linkage is set. */ 11366 if (!DECL_CLONED_FUNCTION_P (decl1)) 11367 determine_visibility (decl1); 11368 11369 begin_scope (sk_function_parms, decl1); 11370 11371 ++function_depth; 11372 11373 if (DECL_DESTRUCTOR_P (decl1) 11374 || (DECL_CONSTRUCTOR_P (decl1) 11375 && targetm.cxx.cdtor_returns_this ())) 11376 { 11377 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); 11378 DECL_CONTEXT (cdtor_label) = current_function_decl; 11379 } 11380 11381 start_fname_decls (); 11382 11383 store_parm_decls (current_function_parms); 11384} 11385 11386 11387/* APPLE LOCAL begin warn missing prototype 6261539 */ 11388static bool 11389fn_previously_found (tree decl, tree olddecl) 11390{ 11391 int types_match; 11392 11393 if (olddecl == 0) 11394 return false; 11395 11396 if (TREE_CODE (olddecl) == OVERLOAD) 11397 { 11398 if (OVL_CHAIN (olddecl) == NULL_TREE) 11399 olddecl = OVL_CURRENT (olddecl); 11400 else 11401 { 11402 tree match; 11403 for (match = olddecl; match; match = OVL_NEXT (match)) 11404 { 11405 if (fn_previously_found (decl, OVL_CURRENT (match))) 11406 return true; 11407 } 11408 return false; 11409 } 11410 } 11411 11412 /* Don't warn about previously erroneous things that have the same 11413 name. */ 11414 if (TREE_TYPE (olddecl) == error_mark_node) 11415 return true; 11416 11417 /* Internally defined things still need a prototype to escape the 11418 warning. */ 11419 if (DECL_ARTIFICIAL (olddecl)) 11420 return false; 11421 11422 if (TREE_CODE (olddecl) != FUNCTION_DECL) 11423 return false; 11424 11425 /* These will match or error, don't also spew prototype warnings. */ 11426 if (DECL_EXTERN_C_P (olddecl) 11427 && DECL_EXTERN_C_P (decl)) 11428 return true; 11429 11430 /* These will match or error, don't also spew prototype warnings. */ 11431 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (decl)), 11432 TYPE_ARG_TYPES (TREE_TYPE (olddecl)))) 11433 return true; 11434 11435 types_match = decls_match (decl, olddecl); 11436 11437 if (types_match) 11438 return true; 11439 11440 return false; 11441} 11442 11443inline static void 11444check_missing_prototype (tree decl) 11445{ 11446 if (warn_missing_prototypes 11447 && namespace_bindings_p () 11448 && TREE_PUBLIC (decl) 11449 && !DECL_MAIN_P (decl) 11450 && DECL_NON_THUNK_FUNCTION_P (decl) 11451 && ! DECL_FUNCTION_MEMBER_P (decl) 11452 && DECL_NAMESPACE_SCOPE_P (decl) 11453 && ! decl_anon_ns_mem_p (decl) 11454 && ! DECL_DECLARED_INLINE_P (decl)) 11455 { 11456 tree olddecl = namespace_binding (DECL_NAME (decl), DECL_CONTEXT (decl)); 11457 if (!fn_previously_found (decl, olddecl)) 11458 warning (OPT_Wmissing_prototypes, "no previous prototype for %q+D", decl); 11459 } 11460} 11461/* APPLE LOCAL end warn missing prototype 6261539 */ 11462 11463/* Like start_preparsed_function, except that instead of a 11464 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR. 11465 11466 Returns 1 on success. If the DECLARATOR is not suitable for a function 11467 (it defines a datum instead), we return 0, which tells 11468 yyparse to report a parse error. */ 11469 11470int 11471start_function (cp_decl_specifier_seq *declspecs, 11472 const cp_declarator *declarator, 11473 tree attrs) 11474{ 11475 tree decl1; 11476 11477 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs); 11478 /* If the declarator is not suitable for a function definition, 11479 cause a syntax error. */ 11480 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) 11481 return 0; 11482 11483 if (DECL_MAIN_P (decl1)) 11484 /* main must return int. grokfndecl should have corrected it 11485 (and issued a diagnostic) if the user got it wrong. */ 11486 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)), 11487 integer_type_node)); 11488 11489 /* APPLE LOCAL begin warn missing prototype 6261539 */ 11490 check_missing_prototype (decl1); 11491 /* APPLE LOCAL end warn missing prototype 6261539 */ 11492 11493 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT); 11494 11495 return 1; 11496} 11497 11498/* Returns true iff an EH_SPEC_BLOCK should be created in the body of 11499 FN. */ 11500 11501static bool 11502use_eh_spec_block (tree fn) 11503{ 11504 return (flag_exceptions && flag_enforce_eh_specs 11505 && !processing_template_decl 11506 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)) 11507 /* We insert the EH_SPEC_BLOCK only in the original 11508 function; then, it is copied automatically to the 11509 clones. */ 11510 && !DECL_CLONED_FUNCTION_P (fn) 11511 /* Implicitly-generated constructors and destructors have 11512 exception specifications. However, those specifications 11513 are the union of the possible exceptions specified by the 11514 constructors/destructors for bases and members, so no 11515 unallowed exception will ever reach this function. By 11516 not creating the EH_SPEC_BLOCK we save a little memory, 11517 and we avoid spurious warnings about unreachable 11518 code. */ 11519 && !DECL_ARTIFICIAL (fn)); 11520} 11521 11522/* Store the parameter declarations into the current function declaration. 11523 This is called after parsing the parameter declarations, before 11524 digesting the body of the function. 11525 11526 Also install to binding contour return value identifier, if any. */ 11527 11528static void 11529store_parm_decls (tree current_function_parms) 11530{ 11531 tree fndecl = current_function_decl; 11532 tree parm; 11533 11534 /* This is a chain of any other decls that came in among the parm 11535 declarations. If a parm is declared with enum {foo, bar} x; 11536 then CONST_DECLs for foo and bar are put here. */ 11537 tree nonparms = NULL_TREE; 11538 11539 if (current_function_parms) 11540 { 11541 /* This case is when the function was defined with an ANSI prototype. 11542 The parms already have decls, so we need not do anything here 11543 except record them as in effect 11544 and complain if any redundant old-style parm decls were written. */ 11545 11546 tree specparms = current_function_parms; 11547 tree next; 11548 11549 /* Must clear this because it might contain TYPE_DECLs declared 11550 at class level. */ 11551 current_binding_level->names = NULL; 11552 11553 /* If we're doing semantic analysis, then we'll call pushdecl 11554 for each of these. We must do them in reverse order so that 11555 they end in the correct forward order. */ 11556 specparms = nreverse (specparms); 11557 11558 for (parm = specparms; parm; parm = next) 11559 { 11560 next = TREE_CHAIN (parm); 11561 if (TREE_CODE (parm) == PARM_DECL) 11562 { 11563 if (DECL_NAME (parm) == NULL_TREE 11564 || TREE_CODE (parm) != VOID_TYPE) 11565 pushdecl (parm); 11566 else 11567 error ("parameter %qD declared void", parm); 11568 } 11569 else 11570 { 11571 /* If we find an enum constant or a type tag, 11572 put it aside for the moment. */ 11573 TREE_CHAIN (parm) = NULL_TREE; 11574 nonparms = chainon (nonparms, parm); 11575 } 11576 } 11577 11578 /* Get the decls in their original chain order and record in the 11579 function. This is all and only the PARM_DECLs that were 11580 pushed into scope by the loop above. */ 11581 DECL_ARGUMENTS (fndecl) = getdecls (); 11582 } 11583 else 11584 DECL_ARGUMENTS (fndecl) = NULL_TREE; 11585 11586 /* Now store the final chain of decls for the arguments 11587 as the decl-chain of the current lexical scope. 11588 Put the enumerators in as well, at the front so that 11589 DECL_ARGUMENTS is not modified. */ 11590 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl)); 11591 11592 if (use_eh_spec_block (current_function_decl)) 11593 current_eh_spec_block = begin_eh_spec_block (); 11594} 11595 11596 11597/* We have finished doing semantic analysis on DECL, but have not yet 11598 generated RTL for its body. Save away our current state, so that 11599 when we want to generate RTL later we know what to do. */ 11600 11601static void 11602save_function_data (tree decl) 11603{ 11604 struct language_function *f; 11605 11606 /* Save the language-specific per-function data so that we can 11607 get it back when we really expand this function. */ 11608 gcc_assert (!DECL_PENDING_INLINE_P (decl)); 11609 11610 /* Make a copy. */ 11611 f = GGC_NEW (struct language_function); 11612 memcpy (f, cp_function_chain, sizeof (struct language_function)); 11613 DECL_SAVED_FUNCTION_DATA (decl) = f; 11614 11615 /* Clear out the bits we don't need. */ 11616 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE; 11617 f->bindings = NULL; 11618 f->x_local_names = NULL; 11619} 11620 11621 11622/* Set the return value of the constructor (if present). */ 11623 11624static void 11625finish_constructor_body (void) 11626{ 11627 tree val; 11628 tree exprstmt; 11629 11630 if (targetm.cxx.cdtor_returns_this ()) 11631 { 11632 /* Any return from a constructor will end up here. */ 11633 add_stmt (build_stmt (LABEL_EXPR, cdtor_label)); 11634 11635 val = DECL_ARGUMENTS (current_function_decl); 11636 val = build2 (MODIFY_EXPR, TREE_TYPE (val), 11637 DECL_RESULT (current_function_decl), val); 11638 /* Return the address of the object. */ 11639 exprstmt = build_stmt (RETURN_EXPR, val); 11640 add_stmt (exprstmt); 11641 } 11642} 11643 11644/* Do all the processing for the beginning of a destructor; set up the 11645 vtable pointers and cleanups for bases and members. */ 11646 11647static void 11648begin_destructor_body (void) 11649{ 11650 tree compound_stmt; 11651 11652 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already 11653 issued an error message. We still want to try to process the 11654 body of the function, but initialize_vtbl_ptrs will crash if 11655 TYPE_BINFO is NULL. */ 11656 if (COMPLETE_TYPE_P (current_class_type)) 11657 { 11658 compound_stmt = begin_compound_stmt (0); 11659 /* Make all virtual function table pointers in non-virtual base 11660 classes point to CURRENT_CLASS_TYPE's virtual function 11661 tables. */ 11662 initialize_vtbl_ptrs (current_class_ptr); 11663 finish_compound_stmt (compound_stmt); 11664 11665 /* And insert cleanups for our bases and members so that they 11666 will be properly destroyed if we throw. */ 11667 push_base_cleanups (); 11668 } 11669} 11670 11671/* At the end of every destructor we generate code to delete the object if 11672 necessary. Do that now. */ 11673 11674static void 11675finish_destructor_body (void) 11676{ 11677 tree exprstmt; 11678 11679 /* Any return from a destructor will end up here; that way all base 11680 and member cleanups will be run when the function returns. */ 11681 add_stmt (build_stmt (LABEL_EXPR, cdtor_label)); 11682 11683 /* In a virtual destructor, we must call delete. */ 11684 if (DECL_VIRTUAL_P (current_function_decl)) 11685 { 11686 tree if_stmt; 11687 tree virtual_size = cxx_sizeof (current_class_type); 11688 11689 /* [class.dtor] 11690 11691 At the point of definition of a virtual destructor (including 11692 an implicit definition), non-placement operator delete shall 11693 be looked up in the scope of the destructor's class and if 11694 found shall be accessible and unambiguous. */ 11695 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr, 11696 virtual_size, 11697 /*global_p=*/false, 11698 /*placement=*/NULL_TREE, 11699 /*alloc_fn=*/NULL_TREE); 11700 11701 if_stmt = begin_if_stmt (); 11702 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node, 11703 current_in_charge_parm, 11704 integer_one_node), 11705 if_stmt); 11706 finish_expr_stmt (exprstmt); 11707 finish_then_clause (if_stmt); 11708 finish_if_stmt (if_stmt); 11709 } 11710 11711 if (targetm.cxx.cdtor_returns_this ()) 11712 { 11713 tree val; 11714 11715 val = DECL_ARGUMENTS (current_function_decl); 11716 val = build2 (MODIFY_EXPR, TREE_TYPE (val), 11717 DECL_RESULT (current_function_decl), val); 11718 /* Return the address of the object. */ 11719 exprstmt = build_stmt (RETURN_EXPR, val); 11720 add_stmt (exprstmt); 11721 } 11722} 11723 11724/* Do the necessary processing for the beginning of a function body, which 11725 in this case includes member-initializers, but not the catch clauses of 11726 a function-try-block. Currently, this means opening a binding level 11727 for the member-initializers (in a ctor) and member cleanups (in a dtor). */ 11728 11729tree 11730begin_function_body (void) 11731{ 11732 tree stmt; 11733 11734 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl)) 11735 return NULL_TREE; 11736 11737 if (processing_template_decl) 11738 /* Do nothing now. */; 11739 else 11740 /* Always keep the BLOCK node associated with the outermost pair of 11741 curly braces of a function. These are needed for correct 11742 operation of dwarfout.c. */ 11743 keep_next_level (true); 11744 11745 stmt = begin_compound_stmt (BCS_FN_BODY); 11746 11747 if (processing_template_decl) 11748 /* Do nothing now. */; 11749 else if (DECL_DESTRUCTOR_P (current_function_decl)) 11750 begin_destructor_body (); 11751 11752 return stmt; 11753} 11754 11755/* Do the processing for the end of a function body. Currently, this means 11756 closing out the cleanups for fully-constructed bases and members, and in 11757 the case of the destructor, deleting the object if desired. Again, this 11758 is only meaningful for [cd]tors, since they are the only functions where 11759 there is a significant distinction between the main body and any 11760 function catch clauses. Handling, say, main() return semantics here 11761 would be wrong, as flowing off the end of a function catch clause for 11762 main() would also need to return 0. */ 11763 11764void 11765finish_function_body (tree compstmt) 11766{ 11767 if (compstmt == NULL_TREE) 11768 return; 11769 11770 /* Close the block. */ 11771 finish_compound_stmt (compstmt); 11772 11773 if (processing_template_decl) 11774 /* Do nothing now. */; 11775 else if (DECL_CONSTRUCTOR_P (current_function_decl)) 11776 finish_constructor_body (); 11777 else if (DECL_DESTRUCTOR_P (current_function_decl)) 11778 finish_destructor_body (); 11779} 11780 11781/* Given a function, returns the BLOCK corresponding to the outermost level 11782 of curly braces, skipping the artificial block created for constructor 11783 initializers. */ 11784 11785static tree 11786outer_curly_brace_block (tree fndecl) 11787{ 11788 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl)); 11789 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl)) 11790 /* Skip the artificial function body block. */ 11791 block = BLOCK_SUBBLOCKS (block); 11792 return block; 11793} 11794 11795/* Finish up a function declaration and compile that function 11796 all the way to assembler language output. The free the storage 11797 for the function definition. 11798 11799 FLAGS is a bitwise or of the following values: 11800 2 - INCLASS_INLINE 11801 We just finished processing the body of an in-class inline 11802 function definition. (This processing will have taken place 11803 after the class definition is complete.) */ 11804 11805tree 11806finish_function (int flags) 11807{ 11808 tree fndecl = current_function_decl; 11809 tree fntype, ctype = NULL_TREE; 11810 int inclass_inline = (flags & 2) != 0; 11811 /* APPLE LOCAL radar 6169580 */ 11812 int in_blocks_helper_function = (flags & 4) != 0; 11813 int nested; 11814 11815 /* When we get some parse errors, we can end up without a 11816 current_function_decl, so cope. */ 11817 if (fndecl == NULL_TREE) 11818 return error_mark_node; 11819 11820 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl) 11821 && DECL_VIRTUAL_P (fndecl) 11822 && !processing_template_decl) 11823 { 11824 tree fnclass = DECL_CONTEXT (fndecl); 11825 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass)) 11826 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes); 11827 } 11828 11829 nested = function_depth > 1; 11830 fntype = TREE_TYPE (fndecl); 11831 11832 /* TREE_READONLY (fndecl) = 1; 11833 This caused &foo to be of type ptr-to-const-function 11834 which then got a warning when stored in a ptr-to-function variable. */ 11835 11836 gcc_assert (building_stmt_tree ()); 11837 /* The current function is being defined, so its DECL_INITIAL should 11838 be set, and unless there's a multiple definition, it should be 11839 error_mark_node. */ 11840 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node); 11841 11842 /* For a cloned function, we've already got all the code we need; 11843 there's no need to add any extra bits. */ 11844 if (!DECL_CLONED_FUNCTION_P (fndecl)) 11845 { 11846 if (DECL_MAIN_P (current_function_decl)) 11847 { 11848 tree stmt; 11849 11850 /* Make it so that `main' always returns 0 by default (or 11851 1 for VMS). */ 11852#if VMS_TARGET 11853 stmt = finish_return_stmt (integer_one_node); 11854#else 11855 stmt = finish_return_stmt (integer_zero_node); 11856#endif 11857 /* Hack. We don't want the middle-end to warn that this 11858 return is unreachable, so put the statement on the 11859 special line 0. */ 11860#ifdef USE_MAPPED_LOCATION 11861 SET_EXPR_LOCATION (stmt, UNKNOWN_LOCATION); 11862#else 11863 annotate_with_file_line (stmt, input_filename, 0); 11864#endif 11865 } 11866 11867 if (use_eh_spec_block (current_function_decl)) 11868 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS 11869 (TREE_TYPE (current_function_decl)), 11870 current_eh_spec_block); 11871 } 11872 11873 /* If we're saving up tree structure, tie off the function now. */ 11874 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl)); 11875 11876 finish_fname_decls (); 11877 11878 /* If this function can't throw any exceptions, remember that. */ 11879 if (!processing_template_decl 11880 && !cp_function_chain->can_throw 11881 && !flag_non_call_exceptions 11882 && !DECL_REPLACEABLE_P (fndecl)) 11883 TREE_NOTHROW (fndecl) = 1; 11884 11885 /* This must come after expand_function_end because cleanups might 11886 have declarations (from inline functions) that need to go into 11887 this function's blocks. */ 11888 11889 /* If the current binding level isn't the outermost binding level 11890 for this function, either there is a bug, or we have experienced 11891 syntax errors and the statement tree is malformed. */ 11892 if (current_binding_level->kind != sk_function_parms) 11893 { 11894 /* Make sure we have already experienced errors. */ 11895 gcc_assert (errorcount); 11896 11897 /* Throw away the broken statement tree and extra binding 11898 levels. */ 11899 DECL_SAVED_TREE (fndecl) = alloc_stmt_list (); 11900 11901 while (current_binding_level->kind != sk_function_parms) 11902 { 11903 if (current_binding_level->kind == sk_class) 11904 pop_nested_class (); 11905 else 11906 poplevel (0, 0, 0); 11907 } 11908 } 11909 poplevel (1, 0, 1); 11910 11911 /* Statements should always be full-expressions at the outermost set 11912 of curly braces for a function. */ 11913 gcc_assert (stmts_are_full_exprs_p ()); 11914 11915 /* Set up the named return value optimization, if we can. Candidate 11916 variables are selected in check_return_expr. */ 11917 if (current_function_return_value) 11918 { 11919 tree r = current_function_return_value; 11920 tree outer; 11921 11922 if (r != error_mark_node 11923 /* This is only worth doing for fns that return in memory--and 11924 simpler, since we don't have to worry about promoted modes. */ 11925 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl) 11926 /* Only allow this for variables declared in the outer scope of 11927 the function so we know that their lifetime always ends with a 11928 return; see g++.dg/opt/nrv6.C. We could be more flexible if 11929 we were to do this optimization in tree-ssa. */ 11930 && (outer = outer_curly_brace_block (fndecl)) 11931 && chain_member (r, BLOCK_VARS (outer))) 11932 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl)); 11933 11934 current_function_return_value = NULL_TREE; 11935 } 11936 11937 /* Remember that we were in class scope. */ 11938 if (current_class_name) 11939 ctype = current_class_type; 11940 11941 /* Must mark the RESULT_DECL as being in this function. */ 11942 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl; 11943 11944 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point 11945 to the FUNCTION_DECL node itself. */ 11946 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl; 11947 11948 /* Save away current state, if appropriate. */ 11949 if (!processing_template_decl) 11950 save_function_data (fndecl); 11951 11952 /* Complain if there's just no return statement. */ 11953 if (warn_return_type 11954 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE 11955 && !dependent_type_p (TREE_TYPE (fntype)) 11956 && !current_function_returns_value && !current_function_returns_null 11957 /* Don't complain if we abort or throw. */ 11958 && !current_function_returns_abnormally 11959 && !DECL_NAME (DECL_RESULT (fndecl)) 11960 /* Normally, with -Wreturn-type, flow will complain. Unless we're an 11961 inline function, as we might never be compiled separately. */ 11962 && (DECL_INLINE (fndecl) || processing_template_decl) 11963 /* Structor return values (if any) are set by the compiler. */ 11964 && !DECL_CONSTRUCTOR_P (fndecl) 11965 && !DECL_DESTRUCTOR_P (fndecl)) 11966 warning (OPT_Wreturn_type, "no return statement in function returning non-void"); 11967 11968 /* Store the end of the function, so that we get good line number 11969 info for the epilogue. */ 11970 cfun->function_end_locus = input_location; 11971 11972 /* Genericize before inlining. */ 11973 if (!processing_template_decl) 11974 { 11975 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl); 11976 cp_genericize (fndecl); 11977 /* Clear out the bits we don't need. */ 11978 f->x_current_class_ptr = NULL; 11979 f->x_current_class_ref = NULL; 11980 f->x_eh_spec_block = NULL; 11981 f->x_in_charge_parm = NULL; 11982 f->x_vtt_parm = NULL; 11983 f->x_return_value = NULL; 11984 f->bindings = NULL; 11985 f->extern_decl_map = NULL; 11986 11987 /* Handle attribute((warn_unused_result)). Relies on gimple input. */ 11988 c_warn_unused_result (&DECL_SAVED_TREE (fndecl)); 11989 } 11990 /* Clear out the bits we don't need. */ 11991 local_names = NULL; 11992 11993 /* We're leaving the context of this function, so zap cfun. It's still in 11994 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */ 11995 cfun = NULL; 11996 current_function_decl = NULL; 11997 11998 /* If this is an in-class inline definition, we may have to pop the 11999 bindings for the template parameters that we added in 12000 maybe_begin_member_template_processing when start_function was 12001 called. */ 12002 if (inclass_inline) 12003 maybe_end_member_template_processing (); 12004 12005 /* Leave the scope of the class. */ 12006 /* APPLE LOCAL radar 6169580 */ 12007 if (ctype && !in_blocks_helper_function) 12008 pop_nested_class (); 12009 12010 --function_depth; 12011 12012 /* Clean up. */ 12013 if (! nested) 12014 /* Let the error reporting routines know that we're outside a 12015 function. For a nested function, this value is used in 12016 cxx_pop_function_context and then reset via pop_function_context. */ 12017 current_function_decl = NULL_TREE; 12018 12019 return fndecl; 12020} 12021 12022/* Create the FUNCTION_DECL for a function definition. 12023 DECLSPECS and DECLARATOR are the parts of the declaration; 12024 they describe the return type and the name of the function, 12025 but twisted together in a fashion that parallels the syntax of C. 12026 12027 This function creates a binding context for the function body 12028 as well as setting up the FUNCTION_DECL in current_function_decl. 12029 12030 Returns a FUNCTION_DECL on success. 12031 12032 If the DECLARATOR is not suitable for a function (it defines a datum 12033 instead), we return 0, which tells yyparse to report a parse error. 12034 12035 May return void_type_node indicating that this method is actually 12036 a friend. See grokfield for more details. 12037 12038 Came here with a `.pushlevel' . 12039 12040 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING 12041 CHANGES TO CODE IN `grokfield'. */ 12042 12043tree 12044start_method (cp_decl_specifier_seq *declspecs, 12045 const cp_declarator *declarator, tree attrlist) 12046{ 12047 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0, 12048 &attrlist); 12049 12050 if (fndecl == error_mark_node) 12051 return error_mark_node; 12052 12053 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL) 12054 { 12055 error ("invalid member function declaration"); 12056 return error_mark_node; 12057 } 12058 12059 if (attrlist) 12060 cplus_decl_attributes (&fndecl, attrlist, 0); 12061 12062 /* Pass friends other than inline friend functions back. */ 12063 if (fndecl == void_type_node) 12064 return fndecl; 12065 12066 if (DECL_IN_AGGR_P (fndecl)) 12067 { 12068 if (DECL_CONTEXT (fndecl) 12069 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL) 12070 error ("%qD is already defined in class %qT", fndecl, 12071 DECL_CONTEXT (fndecl)); 12072 return error_mark_node; 12073 } 12074 12075 check_template_shadow (fndecl); 12076 12077 DECL_DECLARED_INLINE_P (fndecl) = 1; 12078 if (flag_default_inline) 12079 DECL_INLINE (fndecl) = 1; 12080 12081 /* We process method specializations in finish_struct_1. */ 12082 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl)) 12083 { 12084 fndecl = push_template_decl (fndecl); 12085 if (fndecl == error_mark_node) 12086 return fndecl; 12087 } 12088 12089 if (! DECL_FRIEND_P (fndecl)) 12090 { 12091 if (TREE_CHAIN (fndecl)) 12092 { 12093 fndecl = copy_node (fndecl); 12094 TREE_CHAIN (fndecl) = NULL_TREE; 12095 } 12096 } 12097 12098 finish_decl (fndecl, NULL_TREE, NULL_TREE); 12099 12100 /* Make a place for the parms. */ 12101 begin_scope (sk_function_parms, fndecl); 12102 12103 DECL_IN_AGGR_P (fndecl) = 1; 12104 return fndecl; 12105} 12106 12107/* Go through the motions of finishing a function definition. 12108 We don't compile this method until after the whole class has 12109 been processed. 12110 12111 FINISH_METHOD must return something that looks as though it 12112 came from GROKFIELD (since we are defining a method, after all). 12113 12114 This is called after parsing the body of the function definition. 12115 STMTS is the chain of statements that makes up the function body. 12116 12117 DECL is the ..._DECL that `start_method' provided. */ 12118 12119tree 12120finish_method (tree decl) 12121{ 12122 tree fndecl = decl; 12123 tree old_initial; 12124 12125 tree link; 12126 12127 if (decl == void_type_node) 12128 return decl; 12129 12130 old_initial = DECL_INITIAL (fndecl); 12131 12132 /* Undo the level for the parms (from start_method). 12133 This is like poplevel, but it causes nothing to be 12134 saved. Saving information here confuses symbol-table 12135 output routines. Besides, this information will 12136 be correctly output when this method is actually 12137 compiled. */ 12138 12139 /* Clear out the meanings of the local variables of this level; 12140 also record in each decl which block it belongs to. */ 12141 12142 for (link = current_binding_level->names; link; link = TREE_CHAIN (link)) 12143 { 12144 if (DECL_NAME (link) != NULL_TREE) 12145 pop_binding (DECL_NAME (link), link); 12146 gcc_assert (TREE_CODE (link) != FUNCTION_DECL); 12147 DECL_CONTEXT (link) = NULL_TREE; 12148 } 12149 12150 poplevel (0, 0, 0); 12151 12152 DECL_INITIAL (fndecl) = old_initial; 12153 12154 /* We used to check if the context of FNDECL was different from 12155 current_class_type as another way to get inside here. This didn't work 12156 for String.cc in libg++. */ 12157 if (DECL_FRIEND_P (fndecl)) 12158 { 12159 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type), 12160 fndecl); 12161 decl = void_type_node; 12162 } 12163 12164 return decl; 12165} 12166 12167 12168/* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that 12169 we can lay it out later, when and if its type becomes complete. */ 12170 12171void 12172maybe_register_incomplete_var (tree var) 12173{ 12174 gcc_assert (TREE_CODE (var) == VAR_DECL); 12175 12176 /* Keep track of variables with incomplete types. */ 12177 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node 12178 && DECL_EXTERNAL (var)) 12179 { 12180 tree inner_type = TREE_TYPE (var); 12181 12182 while (TREE_CODE (inner_type) == ARRAY_TYPE) 12183 inner_type = TREE_TYPE (inner_type); 12184 inner_type = TYPE_MAIN_VARIANT (inner_type); 12185 12186 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type)) 12187 /* RTTI TD entries are created while defining the type_info. */ 12188 || (TYPE_LANG_SPECIFIC (inner_type) 12189 && TYPE_BEING_DEFINED (inner_type))) 12190 incomplete_vars = tree_cons (inner_type, var, incomplete_vars); 12191 } 12192} 12193 12194/* Called when a class type (given by TYPE) is defined. If there are 12195 any existing VAR_DECLs whose type hsa been completed by this 12196 declaration, update them now. */ 12197 12198void 12199complete_vars (tree type) 12200{ 12201 tree *list = &incomplete_vars; 12202 12203 gcc_assert (CLASS_TYPE_P (type)); 12204 while (*list) 12205 { 12206 if (same_type_p (type, TREE_PURPOSE (*list))) 12207 { 12208 tree var = TREE_VALUE (*list); 12209 tree type = TREE_TYPE (var); 12210 /* Complete the type of the variable. The VAR_DECL itself 12211 will be laid out in expand_expr. */ 12212 complete_type (type); 12213 cp_apply_type_quals_to_decl (cp_type_quals (type), var); 12214 /* Remove this entry from the list. */ 12215 *list = TREE_CHAIN (*list); 12216 } 12217 else 12218 list = &TREE_CHAIN (*list); 12219 } 12220 12221 /* Check for pending declarations which may have abstract type. */ 12222 complete_type_check_abstract (type); 12223} 12224 12225/* If DECL is of a type which needs a cleanup, build that cleanup 12226 here. */ 12227 12228tree 12229cxx_maybe_build_cleanup (tree decl) 12230{ 12231 tree type = TREE_TYPE (decl); 12232 12233 /* APPLE LOCAL begin omit calls to empty destructors 5559195 */ 12234 tree dtor = NULL_TREE; 12235 bool build_cleanup = false; 12236 12237 if (TREE_CODE (type) == RECORD_TYPE) 12238 dtor = CLASSTYPE_DESTRUCTORS (type); 12239 12240 if (type != error_mark_node) 12241 { 12242 if (TREE_CODE (type) == RECORD_TYPE) 12243 /* For RECORD_TYPEs, we can refer to more precise flags than 12244 TYPE_HAS_NONTRIVIAL_DESTRUCTOR. */ 12245 build_cleanup = (dtor && TREE_PRIVATE (dtor)) 12246 || CLASSTYPE_HAS_NONTRIVIAL_DESTRUCTOR_BODY (type) 12247 || CLASSTYPE_DESTRUCTOR_NONTRIVIAL_BECAUSE_OF_BASE (type); 12248 else 12249 build_cleanup = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type); 12250 } 12251 12252 if (build_cleanup) 12253 { 12254 /* APPLE LOCAL end omit calls to empty destructors 5559195 */ 12255 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR; 12256 tree rval; 12257 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE 12258 && CLASSTYPE_VBASECLASSES (type)); 12259 if (TREE_CODE (type) == ARRAY_TYPE) 12260 rval = decl; 12261 else 12262 { 12263 cxx_mark_addressable (decl); 12264 rval = build_unary_op (ADDR_EXPR, decl, 0); 12265 } 12266 12267 /* Optimize for space over speed here. */ 12268 if (!has_vbases || flag_expensive_optimizations) 12269 flags |= LOOKUP_NONVIRTUAL; 12270 12271 rval = build_delete (TREE_TYPE (rval), rval, 12272 sfk_complete_destructor, flags, 0); 12273 12274 return rval; 12275 } 12276 return NULL_TREE; 12277} 12278 12279/* When a stmt has been parsed, this function is called. */ 12280 12281void 12282finish_stmt (void) 12283{ 12284} 12285 12286/* DECL was originally constructed as a non-static member function, 12287 but turned out to be static. Update it accordingly. */ 12288 12289void 12290revert_static_member_fn (tree decl) 12291{ 12292 tree tmp; 12293 tree function = TREE_TYPE (decl); 12294 tree args = TYPE_ARG_TYPES (function); 12295 12296 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args))) 12297 != TYPE_UNQUALIFIED) 12298 error ("static member function %q#D declared with type qualifiers", decl); 12299 12300 args = TREE_CHAIN (args); 12301 tmp = build_function_type (TREE_TYPE (function), args); 12302 tmp = build_qualified_type (tmp, cp_type_quals (function)); 12303 tmp = build_exception_variant (tmp, 12304 TYPE_RAISES_EXCEPTIONS (function)); 12305 TREE_TYPE (decl) = tmp; 12306 if (DECL_ARGUMENTS (decl)) 12307 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl)); 12308 DECL_STATIC_FUNCTION_P (decl) = 1; 12309} 12310 12311/* Initialize the variables used during compilation of a C++ 12312 function. */ 12313 12314void 12315cxx_push_function_context (struct function * f) 12316{ 12317 struct language_function *p = GGC_CNEW (struct language_function); 12318 f->language = p; 12319 12320 /* Whenever we start a new function, we destroy temporaries in the 12321 usual way. */ 12322 current_stmt_tree ()->stmts_are_full_exprs_p = 1; 12323 12324 if (f->decl) 12325 { 12326 tree fn = f->decl; 12327 12328 if (DECL_SAVED_FUNCTION_DATA (fn)) 12329 { 12330 /* If we already parsed this function, and we're just expanding it 12331 now, restore saved state. */ 12332 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn); 12333 12334 /* We don't need the saved data anymore. Unless this is an inline 12335 function; we need the named return value info for 12336 declare_return_variable. */ 12337 if (! DECL_INLINE (fn)) 12338 DECL_SAVED_FUNCTION_DATA (fn) = NULL; 12339 } 12340 } 12341} 12342 12343/* Free the language-specific parts of F, now that we've finished 12344 compiling the function. */ 12345 12346void 12347cxx_pop_function_context (struct function * f) 12348{ 12349 f->language = 0; 12350} 12351 12352/* Return which tree structure is used by T, or TS_CP_GENERIC if T is 12353 one of the language-independent trees. */ 12354 12355enum cp_tree_node_structure_enum 12356cp_tree_node_structure (union lang_tree_node * t) 12357{ 12358 switch (TREE_CODE (&t->generic)) 12359 { 12360 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG; 12361 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER; 12362 case OVERLOAD: return TS_CP_OVERLOAD; 12363 case TEMPLATE_PARM_INDEX: return TS_CP_TPI; 12364 case TINST_LEVEL: return TS_CP_TINST_LEVEL; 12365 case PTRMEM_CST: return TS_CP_PTRMEM; 12366 case BASELINK: return TS_CP_BASELINK; 12367 default: return TS_CP_GENERIC; 12368 } 12369} 12370 12371/* Build the void_list_node (void_type_node having been created). */ 12372tree 12373build_void_list_node (void) 12374{ 12375 tree t = build_tree_list (NULL_TREE, void_type_node); 12376 return t; 12377} 12378 12379bool 12380cp_missing_noreturn_ok_p (tree decl) 12381{ 12382 /* A missing noreturn is ok for the `main' function. */ 12383 return DECL_MAIN_P (decl); 12384} 12385 12386/* Return the COMDAT group into which DECL should be placed. */ 12387 12388const char * 12389cxx_comdat_group (tree decl) 12390{ 12391 tree name; 12392 12393 /* Virtual tables, construction virtual tables, and virtual table 12394 tables all go in a single COMDAT group, named after the primary 12395 virtual table. */ 12396 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl)) 12397 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl))); 12398 /* For all other DECLs, the COMDAT group is the mangled name of the 12399 declaration itself. */ 12400 else 12401 { 12402 while (DECL_THUNK_P (decl)) 12403 { 12404 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk 12405 into the same section as the target function. In that case 12406 we must return target's name. */ 12407 tree target = THUNK_TARGET (decl); 12408 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target) 12409 && DECL_SECTION_NAME (target) != NULL 12410 && DECL_ONE_ONLY (target)) 12411 decl = target; 12412 else 12413 break; 12414 } 12415 name = DECL_ASSEMBLER_NAME (decl); 12416 } 12417 12418 return IDENTIFIER_POINTER (name); 12419} 12420 12421#include "gt-cp-decl.h" 12422