1/* Definitions for C++ name lookup routines. 2 Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net> 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GCC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to 19the Free Software Foundation, 51 Franklin Street, Fifth Floor, 20Boston, MA 02110-1301, USA. */ 21 22#include "config.h" 23#include "system.h" 24#include "coretypes.h" 25#include "tm.h" 26#include "flags.h" 27#include "tree.h" 28#include "cp-tree.h" 29#include "name-lookup.h" 30#include "timevar.h" 31#include "toplev.h" 32#include "diagnostic.h" 33#include "debug.h" 34#include "c-pragma.h" 35 36/* The bindings for a particular name in a particular scope. */ 37 38struct scope_binding { 39 tree value; 40 tree type; 41}; 42#define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE } 43 44static cxx_scope *innermost_nonclass_level (void); 45static cxx_binding *binding_for_name (cxx_scope *, tree); 46static tree lookup_name_innermost_nonclass_level (tree); 47static tree push_overloaded_decl (tree, int, bool); 48static bool lookup_using_namespace (tree, struct scope_binding *, tree, 49 tree, int); 50static bool qualified_lookup_using_namespace (tree, tree, 51 struct scope_binding *, int); 52static tree lookup_type_current_level (tree); 53static tree push_using_directive (tree); 54 55/* The :: namespace. */ 56 57tree global_namespace; 58 59/* The name of the anonymous namespace, throughout this translation 60 unit. */ 61static GTY(()) tree anonymous_namespace_name; 62 63/* Initialise anonymous_namespace_name if necessary, and return it. */ 64 65static tree 66get_anonymous_namespace_name(void) 67{ 68 if (!anonymous_namespace_name) 69 { 70 /* The anonymous namespace has to have a unique name 71 if typeinfo objects are being compared by name. */ 72 if (! flag_weak || ! SUPPORTS_ONE_ONLY) 73 anonymous_namespace_name = get_file_function_name ("N"); 74 else 75 /* The demangler expects anonymous namespaces to be called 76 something starting with '_GLOBAL__N_'. */ 77 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1"); 78 } 79 return anonymous_namespace_name; 80} 81 82/* Compute the chain index of a binding_entry given the HASH value of its 83 name and the total COUNT of chains. COUNT is assumed to be a power 84 of 2. */ 85 86#define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1)) 87 88/* A free list of "binding_entry"s awaiting for re-use. */ 89 90static GTY((deletable)) binding_entry free_binding_entry = NULL; 91 92/* Create a binding_entry object for (NAME, TYPE). */ 93 94static inline binding_entry 95binding_entry_make (tree name, tree type) 96{ 97 binding_entry entry; 98 99 if (free_binding_entry) 100 { 101 entry = free_binding_entry; 102 free_binding_entry = entry->chain; 103 } 104 else 105 entry = GGC_NEW (struct binding_entry_s); 106 107 entry->name = name; 108 entry->type = type; 109 entry->chain = NULL; 110 111 return entry; 112} 113 114/* Put ENTRY back on the free list. */ 115#if 0 116static inline void 117binding_entry_free (binding_entry entry) 118{ 119 entry->name = NULL; 120 entry->type = NULL; 121 entry->chain = free_binding_entry; 122 free_binding_entry = entry; 123} 124#endif 125 126/* The datatype used to implement the mapping from names to types at 127 a given scope. */ 128struct binding_table_s GTY(()) 129{ 130 /* Array of chains of "binding_entry"s */ 131 binding_entry * GTY((length ("%h.chain_count"))) chain; 132 133 /* The number of chains in this table. This is the length of the 134 the member "chain" considered as an array. */ 135 size_t chain_count; 136 137 /* Number of "binding_entry"s in this table. */ 138 size_t entry_count; 139}; 140 141/* Construct TABLE with an initial CHAIN_COUNT. */ 142 143static inline void 144binding_table_construct (binding_table table, size_t chain_count) 145{ 146 table->chain_count = chain_count; 147 table->entry_count = 0; 148 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count); 149} 150 151/* Make TABLE's entries ready for reuse. */ 152#if 0 153static void 154binding_table_free (binding_table table) 155{ 156 size_t i; 157 size_t count; 158 159 if (table == NULL) 160 return; 161 162 for (i = 0, count = table->chain_count; i < count; ++i) 163 { 164 binding_entry temp = table->chain[i]; 165 while (temp != NULL) 166 { 167 binding_entry entry = temp; 168 temp = entry->chain; 169 binding_entry_free (entry); 170 } 171 table->chain[i] = NULL; 172 } 173 table->entry_count = 0; 174} 175#endif 176 177/* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */ 178 179static inline binding_table 180binding_table_new (size_t chain_count) 181{ 182 binding_table table = GGC_NEW (struct binding_table_s); 183 table->chain = NULL; 184 binding_table_construct (table, chain_count); 185 return table; 186} 187 188/* Expand TABLE to twice its current chain_count. */ 189 190static void 191binding_table_expand (binding_table table) 192{ 193 const size_t old_chain_count = table->chain_count; 194 const size_t old_entry_count = table->entry_count; 195 const size_t new_chain_count = 2 * old_chain_count; 196 binding_entry *old_chains = table->chain; 197 size_t i; 198 199 binding_table_construct (table, new_chain_count); 200 for (i = 0; i < old_chain_count; ++i) 201 { 202 binding_entry entry = old_chains[i]; 203 for (; entry != NULL; entry = old_chains[i]) 204 { 205 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name); 206 const size_t j = ENTRY_INDEX (hash, new_chain_count); 207 208 old_chains[i] = entry->chain; 209 entry->chain = table->chain[j]; 210 table->chain[j] = entry; 211 } 212 } 213 table->entry_count = old_entry_count; 214} 215 216/* Insert a binding for NAME to TYPE into TABLE. */ 217 218static void 219binding_table_insert (binding_table table, tree name, tree type) 220{ 221 const unsigned int hash = IDENTIFIER_HASH_VALUE (name); 222 const size_t i = ENTRY_INDEX (hash, table->chain_count); 223 binding_entry entry = binding_entry_make (name, type); 224 225 entry->chain = table->chain[i]; 226 table->chain[i] = entry; 227 ++table->entry_count; 228 229 if (3 * table->chain_count < 5 * table->entry_count) 230 binding_table_expand (table); 231} 232 233/* Return the binding_entry, if any, that maps NAME. */ 234 235binding_entry 236binding_table_find (binding_table table, tree name) 237{ 238 const unsigned int hash = IDENTIFIER_HASH_VALUE (name); 239 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)]; 240 241 while (entry != NULL && entry->name != name) 242 entry = entry->chain; 243 244 return entry; 245} 246 247/* Apply PROC -- with DATA -- to all entries in TABLE. */ 248 249void 250binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data) 251{ 252 const size_t chain_count = table->chain_count; 253 size_t i; 254 255 for (i = 0; i < chain_count; ++i) 256 { 257 binding_entry entry = table->chain[i]; 258 for (; entry != NULL; entry = entry->chain) 259 proc (entry, data); 260 } 261} 262 263#ifndef ENABLE_SCOPE_CHECKING 264# define ENABLE_SCOPE_CHECKING 0 265#else 266# define ENABLE_SCOPE_CHECKING 1 267#endif 268 269/* A free list of "cxx_binding"s, connected by their PREVIOUS. */ 270 271static GTY((deletable)) cxx_binding *free_bindings; 272 273/* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS 274 field to NULL. */ 275 276static inline void 277cxx_binding_init (cxx_binding *binding, tree value, tree type) 278{ 279 binding->value = value; 280 binding->type = type; 281 binding->previous = NULL; 282} 283 284/* (GC)-allocate a binding object with VALUE and TYPE member initialized. */ 285 286static cxx_binding * 287cxx_binding_make (tree value, tree type) 288{ 289 cxx_binding *binding; 290 if (free_bindings) 291 { 292 binding = free_bindings; 293 free_bindings = binding->previous; 294 } 295 else 296 binding = GGC_NEW (cxx_binding); 297 298 cxx_binding_init (binding, value, type); 299 300 return binding; 301} 302 303/* Put BINDING back on the free list. */ 304 305static inline void 306cxx_binding_free (cxx_binding *binding) 307{ 308 binding->scope = NULL; 309 binding->previous = free_bindings; 310 free_bindings = binding; 311} 312 313/* Create a new binding for NAME (with the indicated VALUE and TYPE 314 bindings) in the class scope indicated by SCOPE. */ 315 316static cxx_binding * 317new_class_binding (tree name, tree value, tree type, cxx_scope *scope) 318{ 319 cp_class_binding *cb; 320 cxx_binding *binding; 321 322 if (VEC_length (cp_class_binding, scope->class_shadowed)) 323 { 324 cp_class_binding *old_base; 325 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0); 326 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1)) 327 { 328 /* Fixup the current bindings, as they might have moved. */ 329 size_t i; 330 331 for (i = 0; 332 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb); 333 i++) 334 { 335 cxx_binding **b; 336 b = &IDENTIFIER_BINDING (cb->identifier); 337 while (*b != &old_base[i].base) 338 b = &((*b)->previous); 339 *b = &cb->base; 340 } 341 } 342 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL); 343 } 344 else 345 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL); 346 347 cb->identifier = name; 348 binding = &cb->base; 349 binding->scope = scope; 350 cxx_binding_init (binding, value, type); 351 return binding; 352} 353 354/* Make DECL the innermost binding for ID. The LEVEL is the binding 355 level at which this declaration is being bound. */ 356 357static void 358push_binding (tree id, tree decl, cxx_scope* level) 359{ 360 cxx_binding *binding; 361 362 if (level != class_binding_level) 363 { 364 binding = cxx_binding_make (decl, NULL_TREE); 365 binding->scope = level; 366 /* APPLE LOCAL blocks 6040305 (ch) */ 367 binding->declared_in_block = cur_block != 0; 368 } 369 else 370 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level); 371 372 /* Now, fill in the binding information. */ 373 binding->previous = IDENTIFIER_BINDING (id); 374 INHERITED_VALUE_BINDING_P (binding) = 0; 375 LOCAL_BINDING_P (binding) = (level != class_binding_level); 376 377 /* And put it on the front of the list of bindings for ID. */ 378 IDENTIFIER_BINDING (id) = binding; 379} 380 381/* Remove the binding for DECL which should be the innermost binding 382 for ID. */ 383 384void 385pop_binding (tree id, tree decl) 386{ 387 cxx_binding *binding; 388 389 if (id == NULL_TREE) 390 /* It's easiest to write the loops that call this function without 391 checking whether or not the entities involved have names. We 392 get here for such an entity. */ 393 return; 394 395 /* Get the innermost binding for ID. */ 396 binding = IDENTIFIER_BINDING (id); 397 398 /* The name should be bound. */ 399 gcc_assert (binding != NULL); 400 401 /* The DECL will be either the ordinary binding or the type 402 binding for this identifier. Remove that binding. */ 403 if (binding->value == decl) 404 binding->value = NULL_TREE; 405 else 406 { 407 gcc_assert (binding->type == decl); 408 binding->type = NULL_TREE; 409 } 410 411 if (!binding->value && !binding->type) 412 { 413 /* We're completely done with the innermost binding for this 414 identifier. Unhook it from the list of bindings. */ 415 IDENTIFIER_BINDING (id) = binding->previous; 416 417 /* Add it to the free list. */ 418 cxx_binding_free (binding); 419 } 420} 421 422/* BINDING records an existing declaration for a name in the current scope. 423 But, DECL is another declaration for that same identifier in the 424 same scope. This is the `struct stat' hack whereby a non-typedef 425 class name or enum-name can be bound at the same level as some other 426 kind of entity. 427 3.3.7/1 428 429 A class name (9.1) or enumeration name (7.2) can be hidden by the 430 name of an object, function, or enumerator declared in the same scope. 431 If a class or enumeration name and an object, function, or enumerator 432 are declared in the same scope (in any order) with the same name, the 433 class or enumeration name is hidden wherever the object, function, or 434 enumerator name is visible. 435 436 It's the responsibility of the caller to check that 437 inserting this name is valid here. Returns nonzero if the new binding 438 was successful. */ 439 440static bool 441supplement_binding (cxx_binding *binding, tree decl) 442{ 443 tree bval = binding->value; 444 bool ok = true; 445 446 timevar_push (TV_NAME_LOOKUP); 447 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl)) 448 /* The new name is the type name. */ 449 binding->type = decl; 450 else if (/* BVAL is null when push_class_level_binding moves an 451 inherited type-binding out of the way to make room for a 452 new value binding. */ 453 !bval 454 /* BVAL is error_mark_node when DECL's name has been used 455 in a non-class scope prior declaration. In that case, 456 we should have already issued a diagnostic; for graceful 457 error recovery purpose, pretend this was the intended 458 declaration for that name. */ 459 || bval == error_mark_node 460 /* If BVAL is anticipated but has not yet been declared, 461 pretend it is not there at all. */ 462 || (TREE_CODE (bval) == FUNCTION_DECL 463 && DECL_ANTICIPATED (bval) 464 && !DECL_HIDDEN_FRIEND_P (bval))) 465 binding->value = decl; 466 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)) 467 { 468 /* The old binding was a type name. It was placed in 469 VALUE field because it was thought, at the point it was 470 declared, to be the only entity with such a name. Move the 471 type name into the type slot; it is now hidden by the new 472 binding. */ 473 binding->type = bval; 474 binding->value = decl; 475 binding->value_is_inherited = false; 476 } 477 else if (TREE_CODE (bval) == TYPE_DECL 478 && TREE_CODE (decl) == TYPE_DECL 479 && DECL_NAME (decl) == DECL_NAME (bval) 480 && binding->scope->kind != sk_class 481 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval)) 482 /* If either type involves template parameters, we must 483 wait until instantiation. */ 484 || uses_template_parms (TREE_TYPE (decl)) 485 || uses_template_parms (TREE_TYPE (bval)))) 486 /* We have two typedef-names, both naming the same type to have 487 the same name. In general, this is OK because of: 488 489 [dcl.typedef] 490 491 In a given scope, a typedef specifier can be used to redefine 492 the name of any type declared in that scope to refer to the 493 type to which it already refers. 494 495 However, in class scopes, this rule does not apply due to the 496 stricter language in [class.mem] prohibiting redeclarations of 497 members. */ 498 ok = false; 499 /* There can be two block-scope declarations of the same variable, 500 so long as they are `extern' declarations. However, there cannot 501 be two declarations of the same static data member: 502 503 [class.mem] 504 505 A member shall not be declared twice in the 506 member-specification. */ 507 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL 508 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval) 509 && !DECL_CLASS_SCOPE_P (decl)) 510 { 511 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false); 512 ok = false; 513 } 514 else if (TREE_CODE (decl) == NAMESPACE_DECL 515 && TREE_CODE (bval) == NAMESPACE_DECL 516 && DECL_NAMESPACE_ALIAS (decl) 517 && DECL_NAMESPACE_ALIAS (bval) 518 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl)) 519 /* [namespace.alias] 520 521 In a declarative region, a namespace-alias-definition can be 522 used to redefine a namespace-alias declared in that declarative 523 region to refer only to the namespace to which it already 524 refers. */ 525 ok = false; 526 else 527 { 528 error ("declaration of %q#D", decl); 529 error ("conflicts with previous declaration %q+#D", bval); 530 ok = false; 531 } 532 533 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok); 534} 535 536/* Add DECL to the list of things declared in B. */ 537 538static void 539add_decl_to_level (tree decl, cxx_scope *b) 540{ 541 if (TREE_CODE (decl) == NAMESPACE_DECL 542 && !DECL_NAMESPACE_ALIAS (decl)) 543 { 544 TREE_CHAIN (decl) = b->namespaces; 545 b->namespaces = decl; 546 } 547 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)) 548 { 549 TREE_CHAIN (decl) = b->vtables; 550 b->vtables = decl; 551 } 552 else 553 { 554 /* We build up the list in reverse order, and reverse it later if 555 necessary. */ 556 TREE_CHAIN (decl) = b->names; 557 b->names = decl; 558 b->names_size++; 559 560 /* If appropriate, add decl to separate list of statics. We 561 include extern variables because they might turn out to be 562 static later. It's OK for this list to contain a few false 563 positives. */ 564 if (b->kind == sk_namespace) 565 if ((TREE_CODE (decl) == VAR_DECL 566 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))) 567 || (TREE_CODE (decl) == FUNCTION_DECL 568 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl)))) 569 VEC_safe_push (tree, gc, b->static_decls, decl); 570 } 571} 572 573/* Record a decl-node X as belonging to the current lexical scope. 574 Check for errors (such as an incompatible declaration for the same 575 name already seen in the same scope). IS_FRIEND is true if X is 576 declared as a friend. 577 578 Returns either X or an old decl for the same name. 579 If an old decl is returned, it may have been smashed 580 to agree with what X says. */ 581 582tree 583pushdecl_maybe_friend (tree x, bool is_friend) 584{ 585 tree t; 586 tree name; 587 int need_new_binding; 588 589 timevar_push (TV_NAME_LOOKUP); 590 591 if (x == error_mark_node) 592 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 593 594 need_new_binding = 1; 595 596 if (DECL_TEMPLATE_PARM_P (x)) 597 /* Template parameters have no context; they are not X::T even 598 when declared within a class or namespace. */ 599 ; 600 else 601 { 602 if (current_function_decl && x != current_function_decl 603 /* A local declaration for a function doesn't constitute 604 nesting. */ 605 && TREE_CODE (x) != FUNCTION_DECL 606 /* A local declaration for an `extern' variable is in the 607 scope of the current namespace, not the current 608 function. */ 609 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x)) 610 && !DECL_CONTEXT (x)) 611 DECL_CONTEXT (x) = current_function_decl; 612 613 /* If this is the declaration for a namespace-scope function, 614 but the declaration itself is in a local scope, mark the 615 declaration. */ 616 if (TREE_CODE (x) == FUNCTION_DECL 617 && DECL_NAMESPACE_SCOPE_P (x) 618 && current_function_decl 619 && x != current_function_decl) 620 DECL_LOCAL_FUNCTION_P (x) = 1; 621 } 622 623 name = DECL_NAME (x); 624 if (name) 625 { 626 int different_binding_level = 0; 627 628 if (TREE_CODE (name) == TEMPLATE_ID_EXPR) 629 name = TREE_OPERAND (name, 0); 630 631 /* In case this decl was explicitly namespace-qualified, look it 632 up in its namespace context. */ 633 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ()) 634 t = namespace_binding (name, DECL_CONTEXT (x)); 635 else 636 t = lookup_name_innermost_nonclass_level (name); 637 638 /* [basic.link] If there is a visible declaration of an entity 639 with linkage having the same name and type, ignoring entities 640 declared outside the innermost enclosing namespace scope, the 641 block scope declaration declares that same entity and 642 receives the linkage of the previous declaration. */ 643 if (! t && current_function_decl && x != current_function_decl 644 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL) 645 && DECL_EXTERNAL (x)) 646 { 647 /* Look in block scope. */ 648 t = innermost_non_namespace_value (name); 649 /* Or in the innermost namespace. */ 650 if (! t) 651 t = namespace_binding (name, DECL_CONTEXT (x)); 652 /* Does it have linkage? Note that if this isn't a DECL, it's an 653 OVERLOAD, which is OK. */ 654 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t))) 655 t = NULL_TREE; 656 if (t) 657 different_binding_level = 1; 658 } 659 660 /* If we are declaring a function, and the result of name-lookup 661 was an OVERLOAD, look for an overloaded instance that is 662 actually the same as the function we are declaring. (If 663 there is one, we have to merge our declaration with the 664 previous declaration.) */ 665 if (t && TREE_CODE (t) == OVERLOAD) 666 { 667 tree match; 668 669 if (TREE_CODE (x) == FUNCTION_DECL) 670 for (match = t; match; match = OVL_NEXT (match)) 671 { 672 if (decls_match (OVL_CURRENT (match), x)) 673 break; 674 } 675 else 676 /* Just choose one. */ 677 match = t; 678 679 if (match) 680 t = OVL_CURRENT (match); 681 else 682 t = NULL_TREE; 683 } 684 685 if (t && t != error_mark_node) 686 { 687 if (different_binding_level) 688 { 689 if (decls_match (x, t)) 690 /* The standard only says that the local extern 691 inherits linkage from the previous decl; in 692 particular, default args are not shared. Add 693 the decl into a hash table to make sure only 694 the previous decl in this case is seen by the 695 middle end. */ 696 { 697 struct cxx_int_tree_map *h; 698 void **loc; 699 700 TREE_PUBLIC (x) = TREE_PUBLIC (t); 701 702 if (cp_function_chain->extern_decl_map == NULL) 703 cp_function_chain->extern_decl_map 704 = htab_create_ggc (20, cxx_int_tree_map_hash, 705 cxx_int_tree_map_eq, NULL); 706 707 h = GGC_NEW (struct cxx_int_tree_map); 708 h->uid = DECL_UID (x); 709 h->to = t; 710 loc = htab_find_slot_with_hash 711 (cp_function_chain->extern_decl_map, h, 712 h->uid, INSERT); 713 *(struct cxx_int_tree_map **) loc = h; 714 } 715 } 716 else if (TREE_CODE (t) == PARM_DECL) 717 { 718 gcc_assert (DECL_CONTEXT (t)); 719 720 /* Check for duplicate params. */ 721 if (duplicate_decls (x, t, is_friend)) 722 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); 723 } 724 else if ((DECL_EXTERN_C_FUNCTION_P (x) 725 || DECL_FUNCTION_TEMPLATE_P (x)) 726 && is_overloaded_fn (t)) 727 /* Don't do anything just yet. */; 728 else if (t == wchar_decl_node) 729 { 730 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x)) 731 pedwarn ("redeclaration of %<wchar_t%> as %qT", 732 TREE_TYPE (x)); 733 734 /* Throw away the redeclaration. */ 735 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); 736 } 737 else 738 { 739 tree olddecl = duplicate_decls (x, t, is_friend); 740 741 /* If the redeclaration failed, we can stop at this 742 point. */ 743 if (olddecl == error_mark_node) 744 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 745 746 if (olddecl) 747 { 748 if (TREE_CODE (t) == TYPE_DECL) 749 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t)); 750 751 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); 752 } 753 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL) 754 { 755 /* A redeclaration of main, but not a duplicate of the 756 previous one. 757 758 [basic.start.main] 759 760 This function shall not be overloaded. */ 761 error ("invalid redeclaration of %q+D", t); 762 error ("as %qD", x); 763 /* We don't try to push this declaration since that 764 causes a crash. */ 765 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x); 766 } 767 } 768 } 769 770 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x)) 771 check_default_args (x); 772 773 check_template_shadow (x); 774 775 /* If this is a function conjured up by the backend, massage it 776 so it looks friendly. */ 777 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x)) 778 { 779 retrofit_lang_decl (x); 780 SET_DECL_LANGUAGE (x, lang_c); 781 } 782 783 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x)) 784 { 785 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend); 786 if (t != x) 787 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); 788 if (!namespace_bindings_p ()) 789 /* We do not need to create a binding for this name; 790 push_overloaded_decl will have already done so if 791 necessary. */ 792 need_new_binding = 0; 793 } 794 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x)) 795 { 796 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend); 797 if (t == x) 798 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t))); 799 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); 800 } 801 802 /* If declaring a type as a typedef, copy the type (unless we're 803 at line 0), and install this TYPE_DECL as the new type's typedef 804 name. See the extensive comment in ../c-decl.c (pushdecl). */ 805 if (TREE_CODE (x) == TYPE_DECL) 806 { 807 tree type = TREE_TYPE (x); 808 if (DECL_IS_BUILTIN (x)) 809 { 810 if (TYPE_NAME (type) == 0) 811 TYPE_NAME (type) = x; 812 } 813 else if (type != error_mark_node && TYPE_NAME (type) != x 814 /* We don't want to copy the type when all we're 815 doing is making a TYPE_DECL for the purposes of 816 inlining. */ 817 && (!TYPE_NAME (type) 818 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))) 819 { 820 DECL_ORIGINAL_TYPE (x) = type; 821 type = build_variant_type_copy (type); 822 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x)); 823 TYPE_NAME (type) = x; 824 TREE_TYPE (x) = type; 825 } 826 827 if (type != error_mark_node 828 && TYPE_NAME (type) 829 && TYPE_IDENTIFIER (type)) 830 set_identifier_type_value (DECL_NAME (x), x); 831 } 832 833 /* Multiple external decls of the same identifier ought to match. 834 835 We get warnings about inline functions where they are defined. 836 We get warnings about other functions from push_overloaded_decl. 837 838 Avoid duplicate warnings where they are used. */ 839 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL) 840 { 841 tree decl; 842 843 decl = IDENTIFIER_NAMESPACE_VALUE (name); 844 if (decl && TREE_CODE (decl) == OVERLOAD) 845 decl = OVL_FUNCTION (decl); 846 847 if (decl && decl != error_mark_node 848 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl)) 849 /* If different sort of thing, we already gave an error. */ 850 && TREE_CODE (decl) == TREE_CODE (x) 851 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl))) 852 { 853 pedwarn ("type mismatch with previous external decl of %q#D", x); 854 pedwarn ("previous external decl of %q+#D", decl); 855 } 856 } 857 858 if (TREE_CODE (x) == FUNCTION_DECL 859 && is_friend 860 && !flag_friend_injection) 861 { 862 /* This is a new declaration of a friend function, so hide 863 it from ordinary function lookup. */ 864 DECL_ANTICIPATED (x) = 1; 865 DECL_HIDDEN_FRIEND_P (x) = 1; 866 } 867 868 /* This name is new in its binding level. 869 Install the new declaration and return it. */ 870 if (namespace_bindings_p ()) 871 { 872 /* Install a global value. */ 873 874 /* If the first global decl has external linkage, 875 warn if we later see static one. */ 876 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x)) 877 TREE_PUBLIC (name) = 1; 878 879 /* Bind the name for the entity. */ 880 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x) 881 && t != NULL_TREE) 882 && (TREE_CODE (x) == TYPE_DECL 883 || TREE_CODE (x) == VAR_DECL 884 || TREE_CODE (x) == NAMESPACE_DECL 885 || TREE_CODE (x) == CONST_DECL 886 || TREE_CODE (x) == TEMPLATE_DECL)) 887 SET_IDENTIFIER_NAMESPACE_VALUE (name, x); 888 889 /* If new decl is `static' and an `extern' was seen previously, 890 warn about it. */ 891 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t)) 892 warn_extern_redeclared_static (x, t); 893 } 894 else 895 { 896 /* Here to install a non-global value. */ 897 tree oldlocal = innermost_non_namespace_value (name); 898 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name); 899 900 if (need_new_binding) 901 { 902 push_local_binding (name, x, 0); 903 /* Because push_local_binding will hook X on to the 904 current_binding_level's name list, we don't want to 905 do that again below. */ 906 need_new_binding = 0; 907 } 908 909 /* If this is a TYPE_DECL, push it into the type value slot. */ 910 if (TREE_CODE (x) == TYPE_DECL) 911 set_identifier_type_value (name, x); 912 913 /* Clear out any TYPE_DECL shadowed by a namespace so that 914 we won't think this is a type. The C struct hack doesn't 915 go through namespaces. */ 916 if (TREE_CODE (x) == NAMESPACE_DECL) 917 set_identifier_type_value (name, NULL_TREE); 918 919 if (oldlocal) 920 { 921 tree d = oldlocal; 922 923 while (oldlocal 924 && TREE_CODE (oldlocal) == VAR_DECL 925 && DECL_DEAD_FOR_LOCAL (oldlocal)) 926 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal); 927 928 if (oldlocal == NULL_TREE) 929 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d)); 930 } 931 932 /* If this is an extern function declaration, see if we 933 have a global definition or declaration for the function. */ 934 if (oldlocal == NULL_TREE 935 && DECL_EXTERNAL (x) 936 && oldglobal != NULL_TREE 937 && TREE_CODE (x) == FUNCTION_DECL 938 && TREE_CODE (oldglobal) == FUNCTION_DECL) 939 { 940 /* We have one. Their types must agree. */ 941 if (decls_match (x, oldglobal)) 942 /* OK */; 943 else 944 { 945 warning (0, "extern declaration of %q#D doesn't match", x); 946 warning (0, "global declaration %q+#D", oldglobal); 947 } 948 } 949 /* If we have a local external declaration, 950 and no file-scope declaration has yet been seen, 951 then if we later have a file-scope decl it must not be static. */ 952 if (oldlocal == NULL_TREE 953 && oldglobal == NULL_TREE 954 && DECL_EXTERNAL (x) 955 && TREE_PUBLIC (x)) 956 TREE_PUBLIC (name) = 1; 957 958 /* Warn if shadowing an argument at the top level of the body. */ 959 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x) 960 /* Inline decls shadow nothing. */ 961 && !DECL_FROM_INLINE (x) 962 && TREE_CODE (oldlocal) == PARM_DECL 963 /* Don't check the `this' parameter. */ 964 && !DECL_ARTIFICIAL (oldlocal)) 965 { 966 bool err = false; 967 968 /* Don't complain if it's from an enclosing function. */ 969 if (DECL_CONTEXT (oldlocal) == current_function_decl 970 && TREE_CODE (x) != PARM_DECL) 971 { 972 /* Go to where the parms should be and see if we find 973 them there. */ 974 struct cp_binding_level *b = current_binding_level->level_chain; 975 976 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl)) 977 /* Skip the ctor/dtor cleanup level. */ 978 b = b->level_chain; 979 980 /* ARM $8.3 */ 981 if (b->kind == sk_function_parms) 982 { 983 error ("declaration of %q#D shadows a parameter", x); 984 err = true; 985 } 986 } 987 988 if (warn_shadow && !err) 989 { 990 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x); 991 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal); 992 } 993 } 994 995 /* Maybe warn if shadowing something else. */ 996 else if (warn_shadow && !DECL_EXTERNAL (x) 997 /* No shadow warnings for internally generated vars. */ 998 && ! DECL_ARTIFICIAL (x) 999 /* No shadow warnings for vars made for inlining. */ 1000 && ! DECL_FROM_INLINE (x)) 1001 { 1002 tree member; 1003 1004 if (current_class_ptr) 1005 member = lookup_member (current_class_type, 1006 name, 1007 /*protect=*/0, 1008 /*want_type=*/false); 1009 else 1010 member = NULL_TREE; 1011 1012 if (member && !TREE_STATIC (member)) 1013 { 1014 /* Location of previous decl is not useful in this case. */ 1015 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'", 1016 x); 1017 } 1018 else if (oldlocal != NULL_TREE 1019 && TREE_CODE (oldlocal) == VAR_DECL) 1020 { 1021 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x); 1022 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal); 1023 } 1024 else if (oldglobal != NULL_TREE 1025 && TREE_CODE (oldglobal) == VAR_DECL) 1026 /* XXX shadow warnings in outer-more namespaces */ 1027 { 1028 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration", 1029 x); 1030 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal); 1031 } 1032 } 1033 } 1034 1035 if (TREE_CODE (x) == VAR_DECL) 1036 maybe_register_incomplete_var (x); 1037 } 1038 1039 if (need_new_binding) 1040 add_decl_to_level (x, 1041 DECL_NAMESPACE_SCOPE_P (x) 1042 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x)) 1043 : current_binding_level); 1044 1045 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x); 1046} 1047 1048/* Record a decl-node X as belonging to the current lexical scope. */ 1049 1050tree 1051pushdecl (tree x) 1052{ 1053 return pushdecl_maybe_friend (x, false); 1054} 1055 1056/* Enter DECL into the symbol table, if that's appropriate. Returns 1057 DECL, or a modified version thereof. */ 1058 1059tree 1060maybe_push_decl (tree decl) 1061{ 1062 tree type = TREE_TYPE (decl); 1063 1064 /* Add this decl to the current binding level, but not if it comes 1065 from another scope, e.g. a static member variable. TEM may equal 1066 DECL or it may be a previous decl of the same name. */ 1067 if (decl == error_mark_node 1068 || (TREE_CODE (decl) != PARM_DECL 1069 && DECL_CONTEXT (decl) != NULL_TREE 1070 /* Definitions of namespace members outside their namespace are 1071 possible. */ 1072 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL) 1073 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ()) 1074 || TREE_CODE (type) == UNKNOWN_TYPE 1075 /* The declaration of a template specialization does not affect 1076 the functions available for overload resolution, so we do not 1077 call pushdecl. */ 1078 || (TREE_CODE (decl) == FUNCTION_DECL 1079 && DECL_TEMPLATE_SPECIALIZATION (decl))) 1080 return decl; 1081 else 1082 return pushdecl (decl); 1083} 1084 1085/* Bind DECL to ID in the current_binding_level, assumed to be a local 1086 binding level. If PUSH_USING is set in FLAGS, we know that DECL 1087 doesn't really belong to this binding level, that it got here 1088 through a using-declaration. */ 1089 1090void 1091push_local_binding (tree id, tree decl, int flags) 1092{ 1093 struct cp_binding_level *b; 1094 1095 /* Skip over any local classes. This makes sense if we call 1096 push_local_binding with a friend decl of a local class. */ 1097 b = innermost_nonclass_level (); 1098 1099 if (lookup_name_innermost_nonclass_level (id)) 1100 { 1101 /* Supplement the existing binding. */ 1102 if (!supplement_binding (IDENTIFIER_BINDING (id), decl)) 1103 /* It didn't work. Something else must be bound at this 1104 level. Do not add DECL to the list of things to pop 1105 later. */ 1106 return; 1107 } 1108 else 1109 /* Create a new binding. */ 1110 push_binding (id, decl, b); 1111 1112 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING)) 1113 /* We must put the OVERLOAD into a TREE_LIST since the 1114 TREE_CHAIN of an OVERLOAD is already used. Similarly for 1115 decls that got here through a using-declaration. */ 1116 decl = build_tree_list (NULL_TREE, decl); 1117 1118 /* And put DECL on the list of things declared by the current 1119 binding level. */ 1120 add_decl_to_level (decl, b); 1121} 1122 1123/* Check to see whether or not DECL is a variable that would have been 1124 in scope under the ARM, but is not in scope under the ANSI/ISO 1125 standard. If so, issue an error message. If name lookup would 1126 work in both cases, but return a different result, this function 1127 returns the result of ANSI/ISO lookup. Otherwise, it returns 1128 DECL. */ 1129 1130tree 1131check_for_out_of_scope_variable (tree decl) 1132{ 1133 tree shadowed; 1134 1135 /* We only care about out of scope variables. */ 1136 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl))) 1137 return decl; 1138 1139 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl) 1140 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ; 1141 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL 1142 && DECL_DEAD_FOR_LOCAL (shadowed)) 1143 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed) 1144 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE; 1145 if (!shadowed) 1146 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl)); 1147 if (shadowed) 1148 { 1149 if (!DECL_ERROR_REPORTED (decl)) 1150 { 1151 warning (0, "name lookup of %qD changed", DECL_NAME (decl)); 1152 warning (0, " matches this %q+D under ISO standard rules", 1153 shadowed); 1154 warning (0, " matches this %q+D under old rules", decl); 1155 DECL_ERROR_REPORTED (decl) = 1; 1156 } 1157 return shadowed; 1158 } 1159 1160 /* If we have already complained about this declaration, there's no 1161 need to do it again. */ 1162 if (DECL_ERROR_REPORTED (decl)) 1163 return decl; 1164 1165 DECL_ERROR_REPORTED (decl) = 1; 1166 1167 if (TREE_TYPE (decl) == error_mark_node) 1168 return decl; 1169 1170 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) 1171 { 1172 error ("name lookup of %qD changed for new ISO %<for%> scoping", 1173 DECL_NAME (decl)); 1174 error (" cannot use obsolete binding at %q+D because " 1175 "it has a destructor", decl); 1176 return error_mark_node; 1177 } 1178 else 1179 { 1180 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping", 1181 DECL_NAME (decl)); 1182 pedwarn (" using obsolete binding at %q+D", decl); 1183 } 1184 1185 return decl; 1186} 1187 1188/* true means unconditionally make a BLOCK for the next level pushed. */ 1189 1190static bool keep_next_level_flag; 1191 1192static int binding_depth = 0; 1193static int is_class_level = 0; 1194 1195static void 1196indent (int depth) 1197{ 1198 int i; 1199 1200 for (i = 0; i < depth * 2; i++) 1201 putc (' ', stderr); 1202} 1203 1204/* Return a string describing the kind of SCOPE we have. */ 1205static const char * 1206cxx_scope_descriptor (cxx_scope *scope) 1207{ 1208 /* The order of this table must match the "scope_kind" 1209 enumerators. */ 1210 static const char* scope_kind_names[] = { 1211 "block-scope", 1212 "cleanup-scope", 1213 "try-scope", 1214 "catch-scope", 1215 "for-scope", 1216 "function-parameter-scope", 1217 "class-scope", 1218 "namespace-scope", 1219 "template-parameter-scope", 1220 "template-explicit-spec-scope" 1221 }; 1222 const scope_kind kind = scope->explicit_spec_p 1223 ? sk_template_spec : scope->kind; 1224 1225 return scope_kind_names[kind]; 1226} 1227 1228/* Output a debugging information about SCOPE when performing 1229 ACTION at LINE. */ 1230static void 1231cxx_scope_debug (cxx_scope *scope, int line, const char *action) 1232{ 1233 const char *desc = cxx_scope_descriptor (scope); 1234 if (scope->this_entity) 1235 verbatim ("%s %s(%E) %p %d\n", action, desc, 1236 scope->this_entity, (void *) scope, line); 1237 else 1238 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line); 1239} 1240 1241/* Return the estimated initial size of the hashtable of a NAMESPACE 1242 scope. */ 1243 1244static inline size_t 1245namespace_scope_ht_size (tree ns) 1246{ 1247 tree name = DECL_NAME (ns); 1248 1249 return name == std_identifier 1250 ? NAMESPACE_STD_HT_SIZE 1251 : (name == global_scope_name 1252 ? GLOBAL_SCOPE_HT_SIZE 1253 : NAMESPACE_ORDINARY_HT_SIZE); 1254} 1255 1256/* A chain of binding_level structures awaiting reuse. */ 1257 1258static GTY((deletable)) struct cp_binding_level *free_binding_level; 1259 1260/* Insert SCOPE as the innermost binding level. */ 1261 1262void 1263push_binding_level (struct cp_binding_level *scope) 1264{ 1265 /* Add it to the front of currently active scopes stack. */ 1266 scope->level_chain = current_binding_level; 1267 current_binding_level = scope; 1268 keep_next_level_flag = false; 1269 1270 if (ENABLE_SCOPE_CHECKING) 1271 { 1272 scope->binding_depth = binding_depth; 1273 indent (binding_depth); 1274 cxx_scope_debug (scope, input_line, "push"); 1275 is_class_level = 0; 1276 binding_depth++; 1277 } 1278} 1279 1280/* Create a new KIND scope and make it the top of the active scopes stack. 1281 ENTITY is the scope of the associated C++ entity (namespace, class, 1282 function); it is NULL otherwise. */ 1283 1284cxx_scope * 1285begin_scope (scope_kind kind, tree entity) 1286{ 1287 cxx_scope *scope; 1288 1289 /* Reuse or create a struct for this binding level. */ 1290 if (!ENABLE_SCOPE_CHECKING && free_binding_level) 1291 { 1292 scope = free_binding_level; 1293 free_binding_level = scope->level_chain; 1294 } 1295 else 1296 scope = GGC_NEW (cxx_scope); 1297 memset (scope, 0, sizeof (cxx_scope)); 1298 1299 scope->this_entity = entity; 1300 scope->more_cleanups_ok = true; 1301 switch (kind) 1302 { 1303 case sk_cleanup: 1304 scope->keep = true; 1305 break; 1306 1307 case sk_template_spec: 1308 scope->explicit_spec_p = true; 1309 kind = sk_template_parms; 1310 /* Fall through. */ 1311 case sk_template_parms: 1312 case sk_block: 1313 case sk_try: 1314 case sk_catch: 1315 case sk_for: 1316 case sk_class: 1317 case sk_function_parms: 1318 case sk_omp: 1319 scope->keep = keep_next_level_flag; 1320 break; 1321 1322 case sk_namespace: 1323 NAMESPACE_LEVEL (entity) = scope; 1324 scope->static_decls = 1325 VEC_alloc (tree, gc, 1326 DECL_NAME (entity) == std_identifier 1327 || DECL_NAME (entity) == global_scope_name 1328 ? 200 : 10); 1329 break; 1330 1331 default: 1332 /* Should not happen. */ 1333 gcc_unreachable (); 1334 break; 1335 } 1336 scope->kind = kind; 1337 1338 push_binding_level (scope); 1339 1340 return scope; 1341} 1342 1343/* We're about to leave current scope. Pop the top of the stack of 1344 currently active scopes. Return the enclosing scope, now active. */ 1345 1346cxx_scope * 1347leave_scope (void) 1348{ 1349 cxx_scope *scope = current_binding_level; 1350 1351 if (scope->kind == sk_namespace && class_binding_level) 1352 current_binding_level = class_binding_level; 1353 1354 /* We cannot leave a scope, if there are none left. */ 1355 if (NAMESPACE_LEVEL (global_namespace)) 1356 gcc_assert (!global_scope_p (scope)); 1357 1358 if (ENABLE_SCOPE_CHECKING) 1359 { 1360 indent (--binding_depth); 1361 cxx_scope_debug (scope, input_line, "leave"); 1362 if (is_class_level != (scope == class_binding_level)) 1363 { 1364 indent (binding_depth); 1365 verbatim ("XXX is_class_level != (current_scope == class_scope)\n"); 1366 } 1367 is_class_level = 0; 1368 } 1369 1370#ifdef HANDLE_PRAGMA_VISIBILITY 1371 if (scope->has_visibility) 1372 pop_visibility (); 1373#endif 1374 1375 /* Move one nesting level up. */ 1376 current_binding_level = scope->level_chain; 1377 1378 /* Namespace-scopes are left most probably temporarily, not 1379 completely; they can be reopened later, e.g. in namespace-extension 1380 or any name binding activity that requires us to resume a 1381 namespace. For classes, we cache some binding levels. For other 1382 scopes, we just make the structure available for reuse. */ 1383 if (scope->kind != sk_namespace 1384 && scope->kind != sk_class) 1385 { 1386 scope->level_chain = free_binding_level; 1387 gcc_assert (!ENABLE_SCOPE_CHECKING 1388 || scope->binding_depth == binding_depth); 1389 free_binding_level = scope; 1390 } 1391 1392 /* Find the innermost enclosing class scope, and reset 1393 CLASS_BINDING_LEVEL appropriately. */ 1394 if (scope->kind == sk_class) 1395 { 1396 class_binding_level = NULL; 1397 for (scope = current_binding_level; scope; scope = scope->level_chain) 1398 if (scope->kind == sk_class) 1399 { 1400 class_binding_level = scope; 1401 break; 1402 } 1403 } 1404 1405 return current_binding_level; 1406} 1407 1408static void 1409resume_scope (struct cp_binding_level* b) 1410{ 1411 /* Resuming binding levels is meant only for namespaces, 1412 and those cannot nest into classes. */ 1413 gcc_assert (!class_binding_level); 1414 /* Also, resuming a non-directly nested namespace is a no-no. */ 1415 gcc_assert (b->level_chain == current_binding_level); 1416 current_binding_level = b; 1417 if (ENABLE_SCOPE_CHECKING) 1418 { 1419 b->binding_depth = binding_depth; 1420 indent (binding_depth); 1421 cxx_scope_debug (b, input_line, "resume"); 1422 is_class_level = 0; 1423 binding_depth++; 1424 } 1425} 1426 1427/* Return the innermost binding level that is not for a class scope. */ 1428 1429static cxx_scope * 1430innermost_nonclass_level (void) 1431{ 1432 cxx_scope *b; 1433 1434 b = current_binding_level; 1435 while (b->kind == sk_class) 1436 b = b->level_chain; 1437 1438 return b; 1439} 1440 1441/* We're defining an object of type TYPE. If it needs a cleanup, but 1442 we're not allowed to add any more objects with cleanups to the current 1443 scope, create a new binding level. */ 1444 1445void 1446maybe_push_cleanup_level (tree type) 1447{ 1448 if (type != error_mark_node 1449 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) 1450 && current_binding_level->more_cleanups_ok == 0) 1451 { 1452 begin_scope (sk_cleanup, NULL); 1453 current_binding_level->statement_list = push_stmt_list (); 1454 } 1455} 1456 1457/* Nonzero if we are currently in the global binding level. */ 1458 1459int 1460global_bindings_p (void) 1461{ 1462 return global_scope_p (current_binding_level); 1463} 1464 1465/* True if we are currently in a toplevel binding level. This 1466 means either the global binding level or a namespace in a toplevel 1467 binding level. Since there are no non-toplevel namespace levels, 1468 this really means any namespace or template parameter level. We 1469 also include a class whose context is toplevel. */ 1470 1471bool 1472toplevel_bindings_p (void) 1473{ 1474 struct cp_binding_level *b = innermost_nonclass_level (); 1475 1476 return b->kind == sk_namespace || b->kind == sk_template_parms; 1477} 1478 1479/* True if this is a namespace scope, or if we are defining a class 1480 which is itself at namespace scope, or whose enclosing class is 1481 such a class, etc. */ 1482 1483bool 1484namespace_bindings_p (void) 1485{ 1486 struct cp_binding_level *b = innermost_nonclass_level (); 1487 1488 return b->kind == sk_namespace; 1489} 1490 1491/* True if the current level needs to have a BLOCK made. */ 1492 1493bool 1494kept_level_p (void) 1495{ 1496 return (current_binding_level->blocks != NULL_TREE 1497 || current_binding_level->keep 1498 || current_binding_level->kind == sk_cleanup 1499 || current_binding_level->names != NULL_TREE); 1500} 1501 1502/* Returns the kind of the innermost scope. */ 1503 1504scope_kind 1505innermost_scope_kind (void) 1506{ 1507 return current_binding_level->kind; 1508} 1509 1510/* Returns true if this scope was created to store template parameters. */ 1511 1512bool 1513template_parm_scope_p (void) 1514{ 1515 return innermost_scope_kind () == sk_template_parms; 1516} 1517 1518/* If KEEP is true, make a BLOCK node for the next binding level, 1519 unconditionally. Otherwise, use the normal logic to decide whether 1520 or not to create a BLOCK. */ 1521 1522void 1523keep_next_level (bool keep) 1524{ 1525 keep_next_level_flag = keep; 1526} 1527 1528/* Return the list of declarations of the current level. 1529 Note that this list is in reverse order unless/until 1530 you nreverse it; and when you do nreverse it, you must 1531 store the result back using `storedecls' or you will lose. */ 1532 1533tree 1534getdecls (void) 1535{ 1536 return current_binding_level->names; 1537} 1538 1539/* For debugging. */ 1540static int no_print_functions = 0; 1541static int no_print_builtins = 0; 1542 1543static void 1544print_binding_level (struct cp_binding_level* lvl) 1545{ 1546 tree t; 1547 int i = 0, len; 1548 fprintf (stderr, " blocks=%p", (void *) lvl->blocks); 1549 if (lvl->more_cleanups_ok) 1550 fprintf (stderr, " more-cleanups-ok"); 1551 if (lvl->have_cleanups) 1552 fprintf (stderr, " have-cleanups"); 1553 fprintf (stderr, "\n"); 1554 if (lvl->names) 1555 { 1556 fprintf (stderr, " names:\t"); 1557 /* We can probably fit 3 names to a line? */ 1558 for (t = lvl->names; t; t = TREE_CHAIN (t)) 1559 { 1560 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL)) 1561 continue; 1562 if (no_print_builtins 1563 && (TREE_CODE (t) == TYPE_DECL) 1564 && DECL_IS_BUILTIN (t)) 1565 continue; 1566 1567 /* Function decls tend to have longer names. */ 1568 if (TREE_CODE (t) == FUNCTION_DECL) 1569 len = 3; 1570 else 1571 len = 2; 1572 i += len; 1573 if (i > 6) 1574 { 1575 fprintf (stderr, "\n\t"); 1576 i = len; 1577 } 1578 print_node_brief (stderr, "", t, 0); 1579 if (t == error_mark_node) 1580 break; 1581 } 1582 if (i) 1583 fprintf (stderr, "\n"); 1584 } 1585 if (VEC_length (cp_class_binding, lvl->class_shadowed)) 1586 { 1587 size_t i; 1588 cp_class_binding *b; 1589 fprintf (stderr, " class-shadowed:"); 1590 for (i = 0; 1591 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b); 1592 ++i) 1593 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier)); 1594 fprintf (stderr, "\n"); 1595 } 1596 if (lvl->type_shadowed) 1597 { 1598 fprintf (stderr, " type-shadowed:"); 1599 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t)) 1600 { 1601 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t))); 1602 } 1603 fprintf (stderr, "\n"); 1604 } 1605} 1606 1607void 1608print_other_binding_stack (struct cp_binding_level *stack) 1609{ 1610 struct cp_binding_level *level; 1611 for (level = stack; !global_scope_p (level); level = level->level_chain) 1612 { 1613 fprintf (stderr, "binding level %p\n", (void *) level); 1614 print_binding_level (level); 1615 } 1616} 1617 1618void 1619print_binding_stack (void) 1620{ 1621 struct cp_binding_level *b; 1622 fprintf (stderr, "current_binding_level=%p\n" 1623 "class_binding_level=%p\n" 1624 "NAMESPACE_LEVEL (global_namespace)=%p\n", 1625 (void *) current_binding_level, (void *) class_binding_level, 1626 (void *) NAMESPACE_LEVEL (global_namespace)); 1627 if (class_binding_level) 1628 { 1629 for (b = class_binding_level; b; b = b->level_chain) 1630 if (b == current_binding_level) 1631 break; 1632 if (b) 1633 b = class_binding_level; 1634 else 1635 b = current_binding_level; 1636 } 1637 else 1638 b = current_binding_level; 1639 print_other_binding_stack (b); 1640 fprintf (stderr, "global:\n"); 1641 print_binding_level (NAMESPACE_LEVEL (global_namespace)); 1642} 1643 1644/* Return the type associated with id. */ 1645 1646tree 1647identifier_type_value (tree id) 1648{ 1649 timevar_push (TV_NAME_LOOKUP); 1650 /* There is no type with that name, anywhere. */ 1651 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE) 1652 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE); 1653 /* This is not the type marker, but the real thing. */ 1654 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node) 1655 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id)); 1656 /* Have to search for it. It must be on the global level, now. 1657 Ask lookup_name not to return non-types. */ 1658 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN); 1659 if (id) 1660 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id)); 1661 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE); 1662} 1663 1664/* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since 1665 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */ 1666 1667tree 1668identifier_global_value (tree t) 1669{ 1670 return IDENTIFIER_GLOBAL_VALUE (t); 1671} 1672 1673/* Push a definition of struct, union or enum tag named ID. into 1674 binding_level B. DECL is a TYPE_DECL for the type. We assume that 1675 the tag ID is not already defined. */ 1676 1677static void 1678set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b) 1679{ 1680 tree type; 1681 1682 if (b->kind != sk_namespace) 1683 { 1684 /* Shadow the marker, not the real thing, so that the marker 1685 gets restored later. */ 1686 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id); 1687 b->type_shadowed 1688 = tree_cons (id, old_type_value, b->type_shadowed); 1689 type = decl ? TREE_TYPE (decl) : NULL_TREE; 1690 TREE_TYPE (b->type_shadowed) = type; 1691 } 1692 else 1693 { 1694 cxx_binding *binding = 1695 binding_for_name (NAMESPACE_LEVEL (current_namespace), id); 1696 gcc_assert (decl); 1697 if (binding->value) 1698 supplement_binding (binding, decl); 1699 else 1700 binding->value = decl; 1701 1702 /* Store marker instead of real type. */ 1703 type = global_type_node; 1704 } 1705 SET_IDENTIFIER_TYPE_VALUE (id, type); 1706} 1707 1708/* As set_identifier_type_value_with_scope, but using 1709 current_binding_level. */ 1710 1711void 1712set_identifier_type_value (tree id, tree decl) 1713{ 1714 set_identifier_type_value_with_scope (id, decl, current_binding_level); 1715} 1716 1717/* Return the name for the constructor (or destructor) for the 1718 specified class TYPE. When given a template, this routine doesn't 1719 lose the specialization. */ 1720 1721static inline tree 1722constructor_name_full (tree type) 1723{ 1724 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type)); 1725} 1726 1727/* Return the name for the constructor (or destructor) for the 1728 specified class. When given a template, return the plain 1729 unspecialized name. */ 1730 1731tree 1732constructor_name (tree type) 1733{ 1734 tree name; 1735 name = constructor_name_full (type); 1736 if (IDENTIFIER_TEMPLATE (name)) 1737 name = IDENTIFIER_TEMPLATE (name); 1738 return name; 1739} 1740 1741/* Returns TRUE if NAME is the name for the constructor for TYPE. */ 1742 1743bool 1744constructor_name_p (tree name, tree type) 1745{ 1746 tree ctor_name; 1747 1748 if (!name) 1749 return false; 1750 1751 if (TREE_CODE (name) != IDENTIFIER_NODE) 1752 return false; 1753 1754 ctor_name = constructor_name_full (type); 1755 if (name == ctor_name) 1756 return true; 1757 if (IDENTIFIER_TEMPLATE (ctor_name) 1758 && name == IDENTIFIER_TEMPLATE (ctor_name)) 1759 return true; 1760 return false; 1761} 1762 1763/* Counter used to create anonymous type names. */ 1764 1765static GTY(()) int anon_cnt; 1766 1767/* Return an IDENTIFIER which can be used as a name for 1768 anonymous structs and unions. */ 1769 1770tree 1771make_anon_name (void) 1772{ 1773 char buf[32]; 1774 1775 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++); 1776 return get_identifier (buf); 1777} 1778 1779/* Return (from the stack of) the BINDING, if any, established at SCOPE. */ 1780 1781static inline cxx_binding * 1782find_binding (cxx_scope *scope, cxx_binding *binding) 1783{ 1784 timevar_push (TV_NAME_LOOKUP); 1785 1786 for (; binding != NULL; binding = binding->previous) 1787 if (binding->scope == scope) 1788 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding); 1789 1790 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0); 1791} 1792 1793/* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */ 1794 1795static inline cxx_binding * 1796cxx_scope_find_binding_for_name (cxx_scope *scope, tree name) 1797{ 1798 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name); 1799 if (b) 1800 { 1801 /* Fold-in case where NAME is used only once. */ 1802 if (scope == b->scope && b->previous == NULL) 1803 return b; 1804 return find_binding (scope, b); 1805 } 1806 return NULL; 1807} 1808 1809/* Always returns a binding for name in scope. If no binding is 1810 found, make a new one. */ 1811 1812static cxx_binding * 1813binding_for_name (cxx_scope *scope, tree name) 1814{ 1815 cxx_binding *result; 1816 1817 result = cxx_scope_find_binding_for_name (scope, name); 1818 if (result) 1819 return result; 1820 /* Not found, make a new one. */ 1821 result = cxx_binding_make (NULL, NULL); 1822 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name); 1823 result->scope = scope; 1824 result->is_local = false; 1825 result->value_is_inherited = false; 1826 /* APPLE LOCAL blocks 6040305 (ch) */ 1827 result->declared_in_block = 0; 1828 IDENTIFIER_NAMESPACE_BINDINGS (name) = result; 1829 return result; 1830} 1831 1832/* Insert another USING_DECL into the current binding level, returning 1833 this declaration. If this is a redeclaration, do nothing, and 1834 return NULL_TREE if this not in namespace scope (in namespace 1835 scope, a using decl might extend any previous bindings). */ 1836 1837static tree 1838push_using_decl (tree scope, tree name) 1839{ 1840 tree decl; 1841 1842 timevar_push (TV_NAME_LOOKUP); 1843 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL); 1844 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); 1845 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl)) 1846 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name) 1847 break; 1848 if (decl) 1849 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, 1850 namespace_bindings_p () ? decl : NULL_TREE); 1851 decl = build_lang_decl (USING_DECL, name, NULL_TREE); 1852 USING_DECL_SCOPE (decl) = scope; 1853 TREE_CHAIN (decl) = current_binding_level->usings; 1854 current_binding_level->usings = decl; 1855 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); 1856} 1857 1858/* Same as pushdecl, but define X in binding-level LEVEL. We rely on the 1859 caller to set DECL_CONTEXT properly. */ 1860 1861tree 1862pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend) 1863{ 1864 struct cp_binding_level *b; 1865 tree function_decl = current_function_decl; 1866 1867 timevar_push (TV_NAME_LOOKUP); 1868 current_function_decl = NULL_TREE; 1869 if (level->kind == sk_class) 1870 { 1871 b = class_binding_level; 1872 class_binding_level = level; 1873 pushdecl_class_level (x); 1874 class_binding_level = b; 1875 } 1876 else 1877 { 1878 b = current_binding_level; 1879 current_binding_level = level; 1880 x = pushdecl_maybe_friend (x, is_friend); 1881 current_binding_level = b; 1882 } 1883 current_function_decl = function_decl; 1884 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x); 1885} 1886 1887/* DECL is a FUNCTION_DECL for a non-member function, which may have 1888 other definitions already in place. We get around this by making 1889 the value of the identifier point to a list of all the things that 1890 want to be referenced by that name. It is then up to the users of 1891 that name to decide what to do with that list. 1892 1893 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its 1894 DECL_TEMPLATE_RESULT. It is dealt with the same way. 1895 1896 FLAGS is a bitwise-or of the following values: 1897 PUSH_LOCAL: Bind DECL in the current scope, rather than at 1898 namespace scope. 1899 PUSH_USING: DECL is being pushed as the result of a using 1900 declaration. 1901 1902 IS_FRIEND is true if this is a friend declaration. 1903 1904 The value returned may be a previous declaration if we guessed wrong 1905 about what language DECL should belong to (C or C++). Otherwise, 1906 it's always DECL (and never something that's not a _DECL). */ 1907 1908static tree 1909push_overloaded_decl (tree decl, int flags, bool is_friend) 1910{ 1911 tree name = DECL_NAME (decl); 1912 tree old; 1913 tree new_binding; 1914 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL)); 1915 1916 timevar_push (TV_NAME_LOOKUP); 1917 if (doing_global) 1918 old = namespace_binding (name, DECL_CONTEXT (decl)); 1919 else 1920 old = lookup_name_innermost_nonclass_level (name); 1921 1922 if (old) 1923 { 1924 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old)) 1925 { 1926 tree t = TREE_TYPE (old); 1927 if (IS_AGGR_TYPE (t) && warn_shadow 1928 && (! DECL_IN_SYSTEM_HEADER (decl) 1929 || ! DECL_IN_SYSTEM_HEADER (old))) 1930 warning (0, "%q#D hides constructor for %q#T", decl, t); 1931 old = NULL_TREE; 1932 } 1933 else if (is_overloaded_fn (old)) 1934 { 1935 tree tmp; 1936 1937 for (tmp = old; tmp; tmp = OVL_NEXT (tmp)) 1938 { 1939 tree fn = OVL_CURRENT (tmp); 1940 tree dup; 1941 1942 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp) 1943 && !(flags & PUSH_USING) 1944 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)), 1945 TYPE_ARG_TYPES (TREE_TYPE (decl))) 1946 && ! decls_match (fn, decl)) 1947 error ("%q#D conflicts with previous using declaration %q#D", 1948 decl, fn); 1949 1950 dup = duplicate_decls (decl, fn, is_friend); 1951 /* If DECL was a redeclaration of FN -- even an invalid 1952 one -- pass that information along to our caller. */ 1953 if (dup == fn || dup == error_mark_node) 1954 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup); 1955 } 1956 1957 /* We don't overload implicit built-ins. duplicate_decls() 1958 may fail to merge the decls if the new decl is e.g. a 1959 template function. */ 1960 if (TREE_CODE (old) == FUNCTION_DECL 1961 && DECL_ANTICIPATED (old) 1962 && !DECL_HIDDEN_FRIEND_P (old)) 1963 old = NULL; 1964 } 1965 else if (old == error_mark_node) 1966 /* Ignore the undefined symbol marker. */ 1967 old = NULL_TREE; 1968 else 1969 { 1970 error ("previous non-function declaration %q+#D", old); 1971 error ("conflicts with function declaration %q#D", decl); 1972 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); 1973 } 1974 } 1975 1976 if (old || TREE_CODE (decl) == TEMPLATE_DECL 1977 /* If it's a using declaration, we always need to build an OVERLOAD, 1978 because it's the only way to remember that the declaration comes 1979 from 'using', and have the lookup behave correctly. */ 1980 || (flags & PUSH_USING)) 1981 { 1982 if (old && TREE_CODE (old) != OVERLOAD) 1983 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE)); 1984 else 1985 new_binding = ovl_cons (decl, old); 1986 if (flags & PUSH_USING) 1987 OVL_USED (new_binding) = 1; 1988 } 1989 else 1990 /* NAME is not ambiguous. */ 1991 new_binding = decl; 1992 1993 if (doing_global) 1994 set_namespace_binding (name, current_namespace, new_binding); 1995 else 1996 { 1997 /* We only create an OVERLOAD if there was a previous binding at 1998 this level, or if decl is a template. In the former case, we 1999 need to remove the old binding and replace it with the new 2000 binding. We must also run through the NAMES on the binding 2001 level where the name was bound to update the chain. */ 2002 2003 if (TREE_CODE (new_binding) == OVERLOAD && old) 2004 { 2005 tree *d; 2006 2007 for (d = &IDENTIFIER_BINDING (name)->scope->names; 2008 *d; 2009 d = &TREE_CHAIN (*d)) 2010 if (*d == old 2011 || (TREE_CODE (*d) == TREE_LIST 2012 && TREE_VALUE (*d) == old)) 2013 { 2014 if (TREE_CODE (*d) == TREE_LIST) 2015 /* Just replace the old binding with the new. */ 2016 TREE_VALUE (*d) = new_binding; 2017 else 2018 /* Build a TREE_LIST to wrap the OVERLOAD. */ 2019 *d = tree_cons (NULL_TREE, new_binding, 2020 TREE_CHAIN (*d)); 2021 2022 /* And update the cxx_binding node. */ 2023 IDENTIFIER_BINDING (name)->value = new_binding; 2024 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); 2025 } 2026 2027 /* We should always find a previous binding in this case. */ 2028 gcc_unreachable (); 2029 } 2030 2031 /* Install the new binding. */ 2032 push_local_binding (name, new_binding, flags); 2033 } 2034 2035 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); 2036} 2037 2038/* Check a non-member using-declaration. Return the name and scope 2039 being used, and the USING_DECL, or NULL_TREE on failure. */ 2040 2041static tree 2042validate_nonmember_using_decl (tree decl, tree scope, tree name) 2043{ 2044 /* [namespace.udecl] 2045 A using-declaration for a class member shall be a 2046 member-declaration. */ 2047 if (TYPE_P (scope)) 2048 { 2049 error ("%qT is not a namespace", scope); 2050 return NULL_TREE; 2051 } 2052 else if (scope == error_mark_node) 2053 return NULL_TREE; 2054 2055 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR) 2056 { 2057 /* 7.3.3/5 2058 A using-declaration shall not name a template-id. */ 2059 error ("a using-declaration cannot specify a template-id. " 2060 "Try %<using %D%>", name); 2061 return NULL_TREE; 2062 } 2063 2064 if (TREE_CODE (decl) == NAMESPACE_DECL) 2065 { 2066 error ("namespace %qD not allowed in using-declaration", decl); 2067 return NULL_TREE; 2068 } 2069 2070 if (TREE_CODE (decl) == SCOPE_REF) 2071 { 2072 /* It's a nested name with template parameter dependent scope. 2073 This can only be using-declaration for class member. */ 2074 error ("%qT is not a namespace", TREE_OPERAND (decl, 0)); 2075 return NULL_TREE; 2076 } 2077 2078 if (is_overloaded_fn (decl)) 2079 decl = get_first_fn (decl); 2080 2081 gcc_assert (DECL_P (decl)); 2082 2083 /* Make a USING_DECL. */ 2084 return push_using_decl (scope, name); 2085} 2086 2087/* Process local and global using-declarations. */ 2088 2089static void 2090do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype, 2091 tree *newval, tree *newtype) 2092{ 2093 struct scope_binding decls = EMPTY_SCOPE_BINDING; 2094 2095 *newval = *newtype = NULL_TREE; 2096 if (!qualified_lookup_using_namespace (name, scope, &decls, 0)) 2097 /* Lookup error */ 2098 return; 2099 2100 if (!decls.value && !decls.type) 2101 { 2102 error ("%qD not declared", name); 2103 return; 2104 } 2105 2106 /* LLVM LOCAL begin mainline */ 2107 /* Shift the old and new bindings around so we're comparing class and 2108 enumeration names to each other. */ 2109 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval)) 2110 { 2111 oldtype = oldval; 2112 oldval = NULL_TREE; 2113 } 2114 2115 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value)) 2116 { 2117 decls.type = decls.value; 2118 decls.value = NULL_TREE; 2119 } 2120 /* LLVM LOCAL end mainline */ 2121 2122 /* It is impossible to overload a built-in function; any explicit 2123 declaration eliminates the built-in declaration. So, if OLDVAL 2124 is a built-in, then we can just pretend it isn't there. */ 2125 if (oldval 2126 && TREE_CODE (oldval) == FUNCTION_DECL 2127 && DECL_ANTICIPATED (oldval) 2128 && !DECL_HIDDEN_FRIEND_P (oldval)) 2129 oldval = NULL_TREE; 2130 2131 /* LLVM LOCAL begin mainline */ 2132 if (decls.value) 2133 { 2134 /* Check for using functions. */ 2135 if (is_overloaded_fn (decls.value)) 2136 { 2137 tree tmp, tmp1; 2138 2139 if (oldval && !is_overloaded_fn (oldval)) 2140 { 2141 error ("%qD is already declared in this scope", name); 2142 oldval = NULL_TREE; 2143 } 2144 2145 *newval = oldval; 2146 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp)) 2147 { 2148 tree new_fn = OVL_CURRENT (tmp); 2149 2150 /* [namespace.udecl] 2151 2152 If a function declaration in namespace scope or block 2153 scope has the same name and the same parameter types as a 2154 function introduced by a using declaration the program is 2155 ill-formed. */ 2156 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1)) 2157 { 2158 tree old_fn = OVL_CURRENT (tmp1); 2159 2160 if (new_fn == old_fn) 2161 /* The function already exists in the current namespace. */ 2162 break; 2163 else if (OVL_USED (tmp1)) 2164 continue; /* this is a using decl */ 2165 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)), 2166 TYPE_ARG_TYPES (TREE_TYPE (old_fn)))) 2167 { 2168 gcc_assert (!DECL_ANTICIPATED (old_fn) 2169 || DECL_HIDDEN_FRIEND_P (old_fn)); 2170 2171 /* There was already a non-using declaration in 2172 this scope with the same parameter types. If both 2173 are the same extern "C" functions, that's ok. */ 2174 if (decls_match (new_fn, old_fn)) 2175 break; 2176 else 2177 { 2178 error ("%qD is already declared in this scope", name); 2179 break; 2180 } 2181 } 2182 } 2183 2184 /* If we broke out of the loop, there's no reason to add 2185 this function to the using declarations for this 2186 scope. */ 2187 if (tmp1) 2188 continue; 2189 2190 /* If we are adding to an existing OVERLOAD, then we no 2191 longer know the type of the set of functions. */ 2192 if (*newval && TREE_CODE (*newval) == OVERLOAD) 2193 TREE_TYPE (*newval) = unknown_type_node; 2194 /* Add this new function to the set. */ 2195 *newval = build_overload (OVL_CURRENT (tmp), *newval); 2196 /* If there is only one function, then we use its type. (A 2197 using-declaration naming a single function can be used in 2198 contexts where overload resolution cannot be 2199 performed.) */ 2200 if (TREE_CODE (*newval) != OVERLOAD) 2201 { 2202 *newval = ovl_cons (*newval, NULL_TREE); 2203 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp)); 2204 } 2205 OVL_USED (*newval) = 1; 2206 } 2207 } 2208 else 2209 { 2210 *newval = decls.value; 2211 if (oldval && !decls_match (*newval, oldval)) 2212 error ("%qD is already declared in this scope", name); 2213 } 2214 } 2215 else 2216 *newval = oldval; 2217 2218 if (decls.type && TREE_CODE (decls.type) == TREE_LIST) 2219 { 2220 error ("reference to %qD is ambiguous", name); 2221 print_candidates (decls.type); 2222 } 2223 else 2224 { 2225 *newtype = decls.type; 2226 if (oldtype && *newtype && !decls_match (oldtype, *newtype)) 2227 error ("%qD is already declared in this scope", name); 2228 } 2229 2230 /* If *newval is empty, shift any class or enumeration name down. */ 2231 if (!*newval) 2232 { 2233 *newval = *newtype; 2234 *newtype = NULL_TREE; 2235 } 2236 /* LLVM LOCAL end mainline */ 2237} 2238 2239/* Process a using-declaration at function scope. */ 2240 2241void 2242do_local_using_decl (tree decl, tree scope, tree name) 2243{ 2244 tree oldval, oldtype, newval, newtype; 2245 tree orig_decl = decl; 2246 2247 decl = validate_nonmember_using_decl (decl, scope, name); 2248 if (decl == NULL_TREE) 2249 return; 2250 2251 if (building_stmt_tree () 2252 && at_function_scope_p ()) 2253 add_decl_expr (decl); 2254 2255 oldval = lookup_name_innermost_nonclass_level (name); 2256 oldtype = lookup_type_current_level (name); 2257 2258 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype); 2259 2260 if (newval) 2261 { 2262 if (is_overloaded_fn (newval)) 2263 { 2264 tree fn, term; 2265 2266 /* We only need to push declarations for those functions 2267 that were not already bound in the current level. 2268 The old value might be NULL_TREE, it might be a single 2269 function, or an OVERLOAD. */ 2270 if (oldval && TREE_CODE (oldval) == OVERLOAD) 2271 term = OVL_FUNCTION (oldval); 2272 else 2273 term = oldval; 2274 for (fn = newval; fn && OVL_CURRENT (fn) != term; 2275 fn = OVL_NEXT (fn)) 2276 push_overloaded_decl (OVL_CURRENT (fn), 2277 PUSH_LOCAL | PUSH_USING, 2278 false); 2279 } 2280 else 2281 push_local_binding (name, newval, PUSH_USING); 2282 } 2283 if (newtype) 2284 { 2285 push_local_binding (name, newtype, PUSH_USING); 2286 set_identifier_type_value (name, newtype); 2287 } 2288 2289 /* Emit debug info. */ 2290 if (!processing_template_decl) 2291 cp_emit_debug_info_for_using (orig_decl, current_scope()); 2292} 2293 2294/* Returns true if ROOT (a namespace, class, or function) encloses 2295 CHILD. CHILD may be either a class type or a namespace. */ 2296 2297bool 2298is_ancestor (tree root, tree child) 2299{ 2300 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL 2301 || TREE_CODE (root) == FUNCTION_DECL 2302 || CLASS_TYPE_P (root))); 2303 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL 2304 || CLASS_TYPE_P (child))); 2305 2306 /* The global namespace encloses everything. */ 2307 if (root == global_namespace) 2308 return true; 2309 2310 while (true) 2311 { 2312 /* If we've run out of scopes, stop. */ 2313 if (!child) 2314 return false; 2315 /* If we've reached the ROOT, it encloses CHILD. */ 2316 if (root == child) 2317 return true; 2318 /* Go out one level. */ 2319 if (TYPE_P (child)) 2320 child = TYPE_NAME (child); 2321 child = DECL_CONTEXT (child); 2322 } 2323} 2324 2325/* Enter the class or namespace scope indicated by T suitable for name 2326 lookup. T can be arbitrary scope, not necessary nested inside the 2327 current scope. Returns a non-null scope to pop iff pop_scope 2328 should be called later to exit this scope. */ 2329 2330tree 2331push_scope (tree t) 2332{ 2333 if (TREE_CODE (t) == NAMESPACE_DECL) 2334 push_decl_namespace (t); 2335 else if (CLASS_TYPE_P (t)) 2336 { 2337 if (!at_class_scope_p () 2338 || !same_type_p (current_class_type, t)) 2339 push_nested_class (t); 2340 else 2341 /* T is the same as the current scope. There is therefore no 2342 need to re-enter the scope. Since we are not actually 2343 pushing a new scope, our caller should not call 2344 pop_scope. */ 2345 t = NULL_TREE; 2346 } 2347 2348 return t; 2349} 2350 2351/* Leave scope pushed by push_scope. */ 2352 2353void 2354pop_scope (tree t) 2355{ 2356 if (TREE_CODE (t) == NAMESPACE_DECL) 2357 pop_decl_namespace (); 2358 else if CLASS_TYPE_P (t) 2359 pop_nested_class (); 2360} 2361 2362/* Subroutine of push_inner_scope. */ 2363 2364static void 2365push_inner_scope_r (tree outer, tree inner) 2366{ 2367 tree prev; 2368 2369 if (outer == inner 2370 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner))) 2371 return; 2372 2373 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner)); 2374 if (outer != prev) 2375 push_inner_scope_r (outer, prev); 2376 if (TREE_CODE (inner) == NAMESPACE_DECL) 2377 { 2378 struct cp_binding_level *save_template_parm = 0; 2379 /* Temporary take out template parameter scopes. They are saved 2380 in reversed order in save_template_parm. */ 2381 while (current_binding_level->kind == sk_template_parms) 2382 { 2383 struct cp_binding_level *b = current_binding_level; 2384 current_binding_level = b->level_chain; 2385 b->level_chain = save_template_parm; 2386 save_template_parm = b; 2387 } 2388 2389 resume_scope (NAMESPACE_LEVEL (inner)); 2390 current_namespace = inner; 2391 2392 /* Restore template parameter scopes. */ 2393 while (save_template_parm) 2394 { 2395 struct cp_binding_level *b = save_template_parm; 2396 save_template_parm = b->level_chain; 2397 b->level_chain = current_binding_level; 2398 current_binding_level = b; 2399 } 2400 } 2401 else 2402 pushclass (inner); 2403} 2404 2405/* Enter the scope INNER from current scope. INNER must be a scope 2406 nested inside current scope. This works with both name lookup and 2407 pushing name into scope. In case a template parameter scope is present, 2408 namespace is pushed under the template parameter scope according to 2409 name lookup rule in 14.6.1/6. 2410 2411 Return the former current scope suitable for pop_inner_scope. */ 2412 2413tree 2414push_inner_scope (tree inner) 2415{ 2416 tree outer = current_scope (); 2417 if (!outer) 2418 outer = current_namespace; 2419 2420 push_inner_scope_r (outer, inner); 2421 return outer; 2422} 2423 2424/* Exit the current scope INNER back to scope OUTER. */ 2425 2426void 2427pop_inner_scope (tree outer, tree inner) 2428{ 2429 if (outer == inner 2430 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner))) 2431 return; 2432 2433 while (outer != inner) 2434 { 2435 if (TREE_CODE (inner) == NAMESPACE_DECL) 2436 { 2437 struct cp_binding_level *save_template_parm = 0; 2438 /* Temporary take out template parameter scopes. They are saved 2439 in reversed order in save_template_parm. */ 2440 while (current_binding_level->kind == sk_template_parms) 2441 { 2442 struct cp_binding_level *b = current_binding_level; 2443 current_binding_level = b->level_chain; 2444 b->level_chain = save_template_parm; 2445 save_template_parm = b; 2446 } 2447 2448 pop_namespace (); 2449 2450 /* Restore template parameter scopes. */ 2451 while (save_template_parm) 2452 { 2453 struct cp_binding_level *b = save_template_parm; 2454 save_template_parm = b->level_chain; 2455 b->level_chain = current_binding_level; 2456 current_binding_level = b; 2457 } 2458 } 2459 else 2460 popclass (); 2461 2462 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner)); 2463 } 2464} 2465 2466/* Do a pushlevel for class declarations. */ 2467 2468void 2469pushlevel_class (void) 2470{ 2471 if (ENABLE_SCOPE_CHECKING) 2472 is_class_level = 1; 2473 2474 class_binding_level = begin_scope (sk_class, current_class_type); 2475} 2476 2477/* ...and a poplevel for class declarations. */ 2478 2479void 2480poplevel_class (void) 2481{ 2482 struct cp_binding_level *level = class_binding_level; 2483 cp_class_binding *cb; 2484 size_t i; 2485 tree shadowed; 2486 2487 timevar_push (TV_NAME_LOOKUP); 2488 gcc_assert (level != 0); 2489 2490 /* If we're leaving a toplevel class, cache its binding level. */ 2491 if (current_class_depth == 1) 2492 previous_class_level = level; 2493 for (shadowed = level->type_shadowed; 2494 shadowed; 2495 shadowed = TREE_CHAIN (shadowed)) 2496 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed)); 2497 2498 /* Remove the bindings for all of the class-level declarations. */ 2499 if (level->class_shadowed) 2500 { 2501 for (i = 0; 2502 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb); 2503 ++i) 2504 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous; 2505 ggc_free (level->class_shadowed); 2506 level->class_shadowed = NULL; 2507 } 2508 2509 /* Now, pop out of the binding level which we created up in the 2510 `pushlevel_class' routine. */ 2511 if (ENABLE_SCOPE_CHECKING) 2512 is_class_level = 1; 2513 2514 leave_scope (); 2515 timevar_pop (TV_NAME_LOOKUP); 2516} 2517 2518/* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as 2519 appropriate. DECL is the value to which a name has just been 2520 bound. CLASS_TYPE is the class in which the lookup occurred. */ 2521 2522static void 2523set_inherited_value_binding_p (cxx_binding *binding, tree decl, 2524 tree class_type) 2525{ 2526 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST) 2527 { 2528 tree context; 2529 2530 if (TREE_CODE (decl) == OVERLOAD) 2531 context = CP_DECL_CONTEXT (OVL_CURRENT (decl)); 2532 else 2533 { 2534 gcc_assert (DECL_P (decl)); 2535 context = context_for_name_lookup (decl); 2536 } 2537 2538 if (is_properly_derived_from (class_type, context)) 2539 INHERITED_VALUE_BINDING_P (binding) = 1; 2540 else 2541 INHERITED_VALUE_BINDING_P (binding) = 0; 2542 } 2543 else if (binding->value == decl) 2544 /* We only encounter a TREE_LIST when there is an ambiguity in the 2545 base classes. Such an ambiguity can be overridden by a 2546 definition in this class. */ 2547 INHERITED_VALUE_BINDING_P (binding) = 1; 2548 else 2549 INHERITED_VALUE_BINDING_P (binding) = 0; 2550} 2551 2552/* Make the declaration of X appear in CLASS scope. */ 2553 2554bool 2555pushdecl_class_level (tree x) 2556{ 2557 tree name; 2558 bool is_valid = true; 2559 2560 timevar_push (TV_NAME_LOOKUP); 2561 /* Get the name of X. */ 2562 if (TREE_CODE (x) == OVERLOAD) 2563 name = DECL_NAME (get_first_fn (x)); 2564 else 2565 name = DECL_NAME (x); 2566 2567 if (name) 2568 { 2569 is_valid = push_class_level_binding (name, x); 2570 if (TREE_CODE (x) == TYPE_DECL) 2571 set_identifier_type_value (name, x); 2572 } 2573 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x))) 2574 { 2575 /* If X is an anonymous aggregate, all of its members are 2576 treated as if they were members of the class containing the 2577 aggregate, for naming purposes. */ 2578 tree f; 2579 2580 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f)) 2581 { 2582 location_t save_location = input_location; 2583 input_location = DECL_SOURCE_LOCATION (f); 2584 if (!pushdecl_class_level (f)) 2585 is_valid = false; 2586 input_location = save_location; 2587 } 2588 } 2589 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid); 2590} 2591 2592/* Return the BINDING (if any) for NAME in SCOPE, which is a class 2593 scope. If the value returned is non-NULL, and the PREVIOUS field 2594 is not set, callers must set the PREVIOUS field explicitly. */ 2595 2596static cxx_binding * 2597get_class_binding (tree name, cxx_scope *scope) 2598{ 2599 tree class_type; 2600 tree type_binding; 2601 tree value_binding; 2602 cxx_binding *binding; 2603 2604 class_type = scope->this_entity; 2605 2606 /* Get the type binding. */ 2607 type_binding = lookup_member (class_type, name, 2608 /*protect=*/2, /*want_type=*/true); 2609 /* Get the value binding. */ 2610 value_binding = lookup_member (class_type, name, 2611 /*protect=*/2, /*want_type=*/false); 2612 2613 if (value_binding 2614 && (TREE_CODE (value_binding) == TYPE_DECL 2615 || DECL_CLASS_TEMPLATE_P (value_binding) 2616 || (TREE_CODE (value_binding) == TREE_LIST 2617 && TREE_TYPE (value_binding) == error_mark_node 2618 && (TREE_CODE (TREE_VALUE (value_binding)) 2619 == TYPE_DECL)))) 2620 /* We found a type binding, even when looking for a non-type 2621 binding. This means that we already processed this binding 2622 above. */ 2623 ; 2624 else if (value_binding) 2625 { 2626 if (TREE_CODE (value_binding) == TREE_LIST 2627 && TREE_TYPE (value_binding) == error_mark_node) 2628 /* NAME is ambiguous. */ 2629 ; 2630 else if (BASELINK_P (value_binding)) 2631 /* NAME is some overloaded functions. */ 2632 value_binding = BASELINK_FUNCTIONS (value_binding); 2633 } 2634 2635 /* If we found either a type binding or a value binding, create a 2636 new binding object. */ 2637 if (type_binding || value_binding) 2638 { 2639 binding = new_class_binding (name, 2640 value_binding, 2641 type_binding, 2642 scope); 2643 /* This is a class-scope binding, not a block-scope binding. */ 2644 LOCAL_BINDING_P (binding) = 0; 2645 set_inherited_value_binding_p (binding, value_binding, class_type); 2646 } 2647 else 2648 binding = NULL; 2649 2650 return binding; 2651} 2652 2653/* Make the declaration(s) of X appear in CLASS scope under the name 2654 NAME. Returns true if the binding is valid. */ 2655 2656bool 2657push_class_level_binding (tree name, tree x) 2658{ 2659 cxx_binding *binding; 2660 tree decl = x; 2661 bool ok; 2662 2663 timevar_push (TV_NAME_LOOKUP); 2664 /* The class_binding_level will be NULL if x is a template 2665 parameter name in a member template. */ 2666 if (!class_binding_level) 2667 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true); 2668 2669 if (name == error_mark_node) 2670 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false); 2671 2672 /* Check for invalid member names. */ 2673 gcc_assert (TYPE_BEING_DEFINED (current_class_type)); 2674 /* We could have been passed a tree list if this is an ambiguous 2675 declaration. If so, pull the declaration out because 2676 check_template_shadow will not handle a TREE_LIST. */ 2677 if (TREE_CODE (decl) == TREE_LIST 2678 && TREE_TYPE (decl) == error_mark_node) 2679 decl = TREE_VALUE (decl); 2680 2681 check_template_shadow (decl); 2682 2683 /* [class.mem] 2684 2685 If T is the name of a class, then each of the following shall 2686 have a name different from T: 2687 2688 -- every static data member of class T; 2689 2690 -- every member of class T that is itself a type; 2691 2692 -- every enumerator of every member of class T that is an 2693 enumerated type; 2694 2695 -- every member of every anonymous union that is a member of 2696 class T. 2697 2698 (Non-static data members were also forbidden to have the same 2699 name as T until TC1.) */ 2700 if ((TREE_CODE (x) == VAR_DECL 2701 || TREE_CODE (x) == CONST_DECL 2702 || (TREE_CODE (x) == TYPE_DECL 2703 && !DECL_SELF_REFERENCE_P (x)) 2704 /* A data member of an anonymous union. */ 2705 || (TREE_CODE (x) == FIELD_DECL 2706 && DECL_CONTEXT (x) != current_class_type)) 2707 && DECL_NAME (x) == constructor_name (current_class_type)) 2708 { 2709 tree scope = context_for_name_lookup (x); 2710 if (TYPE_P (scope) && same_type_p (scope, current_class_type)) 2711 { 2712 error ("%qD has the same name as the class in which it is " 2713 "declared", 2714 x); 2715 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false); 2716 } 2717 } 2718 2719 /* Get the current binding for NAME in this class, if any. */ 2720 binding = IDENTIFIER_BINDING (name); 2721 if (!binding || binding->scope != class_binding_level) 2722 { 2723 binding = get_class_binding (name, class_binding_level); 2724 /* If a new binding was created, put it at the front of the 2725 IDENTIFIER_BINDING list. */ 2726 if (binding) 2727 { 2728 binding->previous = IDENTIFIER_BINDING (name); 2729 IDENTIFIER_BINDING (name) = binding; 2730 } 2731 } 2732 2733 /* If there is already a binding, then we may need to update the 2734 current value. */ 2735 if (binding && binding->value) 2736 { 2737 tree bval = binding->value; 2738 tree old_decl = NULL_TREE; 2739 2740 if (INHERITED_VALUE_BINDING_P (binding)) 2741 { 2742 /* If the old binding was from a base class, and was for a 2743 tag name, slide it over to make room for the new binding. 2744 The old binding is still visible if explicitly qualified 2745 with a class-key. */ 2746 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval) 2747 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))) 2748 { 2749 old_decl = binding->type; 2750 binding->type = bval; 2751 binding->value = NULL_TREE; 2752 INHERITED_VALUE_BINDING_P (binding) = 0; 2753 } 2754 else 2755 { 2756 old_decl = bval; 2757 /* Any inherited type declaration is hidden by the type 2758 declaration in the derived class. */ 2759 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)) 2760 binding->type = NULL_TREE; 2761 } 2762 } 2763 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval)) 2764 old_decl = bval; 2765 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL) 2766 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true); 2767 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval)) 2768 old_decl = bval; 2769 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x)) 2770 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true); 2771 2772 if (old_decl && binding->scope == class_binding_level) 2773 { 2774 binding->value = x; 2775 /* It is always safe to clear INHERITED_VALUE_BINDING_P 2776 here. This function is only used to register bindings 2777 from with the class definition itself. */ 2778 INHERITED_VALUE_BINDING_P (binding) = 0; 2779 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true); 2780 } 2781 } 2782 2783 /* Note that we declared this value so that we can issue an error if 2784 this is an invalid redeclaration of a name already used for some 2785 other purpose. */ 2786 note_name_declared_in_class (name, decl); 2787 2788 /* If we didn't replace an existing binding, put the binding on the 2789 stack of bindings for the identifier, and update the shadowed 2790 list. */ 2791 if (binding && binding->scope == class_binding_level) 2792 /* Supplement the existing binding. */ 2793 ok = supplement_binding (binding, decl); 2794 else 2795 { 2796 /* Create a new binding. */ 2797 push_binding (name, decl, class_binding_level); 2798 ok = true; 2799 } 2800 2801 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok); 2802} 2803 2804/* Process "using SCOPE::NAME" in a class scope. Return the 2805 USING_DECL created. */ 2806 2807tree 2808do_class_using_decl (tree scope, tree name) 2809{ 2810 /* The USING_DECL returned by this function. */ 2811 tree value; 2812 /* The declaration (or declarations) name by this using 2813 declaration. NULL if we are in a template and cannot figure out 2814 what has been named. */ 2815 tree decl; 2816 /* True if SCOPE is a dependent type. */ 2817 bool scope_dependent_p; 2818 /* True if SCOPE::NAME is dependent. */ 2819 bool name_dependent_p; 2820 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */ 2821 bool bases_dependent_p; 2822 tree binfo; 2823 tree base_binfo; 2824 int i; 2825 2826 if (name == error_mark_node) 2827 return NULL_TREE; 2828 2829 if (!scope || !TYPE_P (scope)) 2830 { 2831 error ("using-declaration for non-member at class scope"); 2832 return NULL_TREE; 2833 } 2834 2835 /* Make sure the name is not invalid */ 2836 if (TREE_CODE (name) == BIT_NOT_EXPR) 2837 { 2838 error ("%<%T::%D%> names destructor", scope, name); 2839 return NULL_TREE; 2840 } 2841 if (constructor_name_p (name, scope)) 2842 { 2843 error ("%<%T::%D%> names constructor", scope, name); 2844 return NULL_TREE; 2845 } 2846 if (constructor_name_p (name, current_class_type)) 2847 { 2848 error ("%<%T::%D%> names constructor in %qT", 2849 scope, name, current_class_type); 2850 return NULL_TREE; 2851 } 2852 2853 scope_dependent_p = dependent_type_p (scope); 2854 name_dependent_p = (scope_dependent_p 2855 || (IDENTIFIER_TYPENAME_P (name) 2856 && dependent_type_p (TREE_TYPE (name)))); 2857 2858 bases_dependent_p = false; 2859 if (processing_template_decl) 2860 for (binfo = TYPE_BINFO (current_class_type), i = 0; 2861 BINFO_BASE_ITERATE (binfo, i, base_binfo); 2862 i++) 2863 if (dependent_type_p (TREE_TYPE (base_binfo))) 2864 { 2865 bases_dependent_p = true; 2866 break; 2867 } 2868 2869 decl = NULL_TREE; 2870 2871 /* From [namespace.udecl]: 2872 2873 A using-declaration used as a member-declaration shall refer to a 2874 member of a base class of the class being defined. 2875 2876 In general, we cannot check this constraint in a template because 2877 we do not know the entire set of base classes of the current 2878 class type. However, if all of the base classes are 2879 non-dependent, then we can avoid delaying the check until 2880 instantiation. */ 2881 if (!scope_dependent_p) 2882 { 2883 base_kind b_kind; 2884 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind); 2885 if (b_kind < bk_proper_base) 2886 { 2887 if (!bases_dependent_p) 2888 { 2889 error_not_base_type (scope, current_class_type); 2890 return NULL_TREE; 2891 } 2892 } 2893 else if (!name_dependent_p) 2894 { 2895 decl = lookup_member (binfo, name, 0, false); 2896 if (!decl) 2897 { 2898 error ("no members matching %<%T::%D%> in %q#T", scope, name, 2899 scope); 2900 return NULL_TREE; 2901 } 2902 /* The binfo from which the functions came does not matter. */ 2903 if (BASELINK_P (decl)) 2904 decl = BASELINK_FUNCTIONS (decl); 2905 } 2906 } 2907 2908 value = build_lang_decl (USING_DECL, name, NULL_TREE); 2909 USING_DECL_DECLS (value) = decl; 2910 USING_DECL_SCOPE (value) = scope; 2911 DECL_DEPENDENT_P (value) = !decl; 2912 2913 return value; 2914} 2915 2916 2917/* Return the binding value for name in scope. */ 2918 2919tree 2920namespace_binding (tree name, tree scope) 2921{ 2922 cxx_binding *binding; 2923 2924 if (scope == NULL) 2925 scope = global_namespace; 2926 else 2927 /* Unnecessary for the global namespace because it can't be an alias. */ 2928 scope = ORIGINAL_NAMESPACE (scope); 2929 2930 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name); 2931 2932 return binding ? binding->value : NULL_TREE; 2933} 2934 2935/* Set the binding value for name in scope. */ 2936 2937void 2938set_namespace_binding (tree name, tree scope, tree val) 2939{ 2940 cxx_binding *b; 2941 2942 timevar_push (TV_NAME_LOOKUP); 2943 if (scope == NULL_TREE) 2944 scope = global_namespace; 2945 b = binding_for_name (NAMESPACE_LEVEL (scope), name); 2946 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node) 2947 b->value = val; 2948 else 2949 supplement_binding (b, val); 2950 timevar_pop (TV_NAME_LOOKUP); 2951} 2952 2953/* Set the context of a declaration to scope. Complain if we are not 2954 outside scope. */ 2955 2956void 2957set_decl_namespace (tree decl, tree scope, bool friendp) 2958{ 2959 tree old, fn; 2960 2961 /* Get rid of namespace aliases. */ 2962 scope = ORIGINAL_NAMESPACE (scope); 2963 2964 /* It is ok for friends to be qualified in parallel space. */ 2965 if (!friendp && !is_ancestor (current_namespace, scope)) 2966 error ("declaration of %qD not in a namespace surrounding %qD", 2967 decl, scope); 2968 DECL_CONTEXT (decl) = FROB_CONTEXT (scope); 2969 2970 /* Writing "int N::i" to declare a variable within "N" is invalid. */ 2971 if (scope == current_namespace) 2972 { 2973 if (at_namespace_scope_p ()) 2974 error ("explicit qualification in declaration of %qD", 2975 decl); 2976 return; 2977 } 2978 2979 /* See whether this has been declared in the namespace. */ 2980 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true); 2981 if (old == error_mark_node) 2982 /* No old declaration at all. */ 2983 goto complain; 2984 if (!is_overloaded_fn (decl)) 2985 /* Don't compare non-function decls with decls_match here, since 2986 it can't check for the correct constness at this 2987 point. pushdecl will find those errors later. */ 2988 return; 2989 /* Since decl is a function, old should contain a function decl. */ 2990 if (!is_overloaded_fn (old)) 2991 goto complain; 2992 fn = OVL_CURRENT (old); 2993 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn))) 2994 goto complain; 2995 /* A template can be explicitly specialized in any namespace. */ 2996 if (processing_explicit_instantiation) 2997 return; 2998 if (processing_template_decl || processing_specialization) 2999 /* We have not yet called push_template_decl to turn a 3000 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't 3001 match. But, we'll check later, when we construct the 3002 template. */ 3003 return; 3004 /* Instantiations or specializations of templates may be declared as 3005 friends in any namespace. */ 3006 if (friendp && DECL_USE_TEMPLATE (decl)) 3007 return; 3008 if (is_overloaded_fn (old)) 3009 { 3010 for (; old; old = OVL_NEXT (old)) 3011 if (decls_match (decl, OVL_CURRENT (old))) 3012 return; 3013 } 3014 else if (decls_match (decl, old)) 3015 return; 3016 complain: 3017 error ("%qD should have been declared inside %qD", decl, scope); 3018} 3019 3020/* Return the namespace where the current declaration is declared. */ 3021 3022static tree 3023current_decl_namespace (void) 3024{ 3025 tree result; 3026 /* If we have been pushed into a different namespace, use it. */ 3027 if (decl_namespace_list) 3028 return TREE_PURPOSE (decl_namespace_list); 3029 3030 if (current_class_type) 3031 result = decl_namespace_context (current_class_type); 3032 else if (current_function_decl) 3033 result = decl_namespace_context (current_function_decl); 3034 else 3035 result = current_namespace; 3036 return result; 3037} 3038 3039/* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we 3040 select a name that is unique to this compilation unit. */ 3041 3042void 3043push_namespace (tree name) 3044{ 3045 push_namespace_with_attribs (name, NULL_TREE); 3046} 3047 3048/* Same, but specify attributes to apply to the namespace. The attributes 3049 only apply to the current namespace-body, not to any later extensions. */ 3050 3051void 3052push_namespace_with_attribs (tree name, tree attributes) 3053{ 3054 tree d = NULL_TREE; 3055 int need_new = 1; 3056 int implicit_use = 0; 3057 bool anon = !name; 3058 3059 timevar_push (TV_NAME_LOOKUP); 3060 3061 /* We should not get here if the global_namespace is not yet constructed 3062 nor if NAME designates the global namespace: The global scope is 3063 constructed elsewhere. */ 3064 gcc_assert (global_namespace != NULL && name != global_scope_name); 3065 3066 if (anon) 3067 { 3068 name = get_anonymous_namespace_name(); 3069 d = IDENTIFIER_NAMESPACE_VALUE (name); 3070 if (d) 3071 /* Reopening anonymous namespace. */ 3072 need_new = 0; 3073 implicit_use = 1; 3074 } 3075 else 3076 { 3077 /* Check whether this is an extended namespace definition. */ 3078 d = IDENTIFIER_NAMESPACE_VALUE (name); 3079 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL) 3080 { 3081 need_new = 0; 3082 if (DECL_NAMESPACE_ALIAS (d)) 3083 { 3084 error ("namespace alias %qD not allowed here, assuming %qD", 3085 d, DECL_NAMESPACE_ALIAS (d)); 3086 d = DECL_NAMESPACE_ALIAS (d); 3087 } 3088 } 3089 } 3090 3091 if (need_new) 3092 { 3093 /* Make a new namespace, binding the name to it. */ 3094 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node); 3095 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace); 3096 /* The name of this namespace is not visible to other translation 3097 units if it is an anonymous namespace or member thereof. */ 3098 if (anon || decl_anon_ns_mem_p (current_namespace)) 3099 TREE_PUBLIC (d) = 0; 3100 else 3101 TREE_PUBLIC (d) = 1; 3102 pushdecl (d); 3103 if (anon) 3104 { 3105 /* Clear DECL_NAME for the benefit of debugging back ends. */ 3106 SET_DECL_ASSEMBLER_NAME (d, name); 3107 DECL_NAME (d) = NULL_TREE; 3108 } 3109 begin_scope (sk_namespace, d); 3110 } 3111 else 3112 resume_scope (NAMESPACE_LEVEL (d)); 3113 3114 if (implicit_use) 3115 do_using_directive (d); 3116 /* Enter the name space. */ 3117 current_namespace = d; 3118 3119#ifdef HANDLE_PRAGMA_VISIBILITY 3120 /* Clear has_visibility in case a previous namespace-definition had a 3121 visibility attribute and this one doesn't. */ 3122 current_binding_level->has_visibility = 0; 3123 for (d = attributes; d; d = TREE_CHAIN (d)) 3124 { 3125 tree name = TREE_PURPOSE (d); 3126 tree args = TREE_VALUE (d); 3127 tree x; 3128 3129 if (! is_attribute_p ("visibility", name)) 3130 { 3131 warning (OPT_Wattributes, "%qs attribute directive ignored", 3132 IDENTIFIER_POINTER (name)); 3133 continue; 3134 } 3135 3136 x = args ? TREE_VALUE (args) : NULL_TREE; 3137 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args)) 3138 { 3139 warning (OPT_Wattributes, "%qs attribute requires a single NTBS argument", 3140 IDENTIFIER_POINTER (name)); 3141 continue; 3142 } 3143 3144 current_binding_level->has_visibility = 1; 3145 push_visibility (TREE_STRING_POINTER (x)); 3146 goto found; 3147 } 3148 found: 3149#endif 3150 3151 timevar_pop (TV_NAME_LOOKUP); 3152} 3153 3154/* Pop from the scope of the current namespace. */ 3155 3156void 3157pop_namespace (void) 3158{ 3159 gcc_assert (current_namespace != global_namespace); 3160 current_namespace = CP_DECL_CONTEXT (current_namespace); 3161 /* The binding level is not popped, as it might be re-opened later. */ 3162 leave_scope (); 3163} 3164 3165/* Push into the scope of the namespace NS, even if it is deeply 3166 nested within another namespace. */ 3167 3168void 3169push_nested_namespace (tree ns) 3170{ 3171 if (ns == global_namespace) 3172 push_to_top_level (); 3173 else 3174 { 3175 push_nested_namespace (CP_DECL_CONTEXT (ns)); 3176 push_namespace (DECL_NAME (ns)); 3177 } 3178} 3179 3180/* Pop back from the scope of the namespace NS, which was previously 3181 entered with push_nested_namespace. */ 3182 3183void 3184pop_nested_namespace (tree ns) 3185{ 3186 timevar_push (TV_NAME_LOOKUP); 3187 while (ns != global_namespace) 3188 { 3189 pop_namespace (); 3190 ns = CP_DECL_CONTEXT (ns); 3191 } 3192 3193 pop_from_top_level (); 3194 timevar_pop (TV_NAME_LOOKUP); 3195} 3196 3197/* Temporarily set the namespace for the current declaration. */ 3198 3199void 3200push_decl_namespace (tree decl) 3201{ 3202 if (TREE_CODE (decl) != NAMESPACE_DECL) 3203 decl = decl_namespace_context (decl); 3204 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl), 3205 NULL_TREE, decl_namespace_list); 3206} 3207 3208/* [namespace.memdef]/2 */ 3209 3210void 3211pop_decl_namespace (void) 3212{ 3213 decl_namespace_list = TREE_CHAIN (decl_namespace_list); 3214} 3215 3216/* Return the namespace that is the common ancestor 3217 of two given namespaces. */ 3218 3219static tree 3220namespace_ancestor (tree ns1, tree ns2) 3221{ 3222 timevar_push (TV_NAME_LOOKUP); 3223 if (is_ancestor (ns1, ns2)) 3224 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1); 3225 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, 3226 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2)); 3227} 3228 3229/* Process a namespace-alias declaration. */ 3230 3231void 3232do_namespace_alias (tree alias, tree namespace) 3233{ 3234 if (namespace == error_mark_node) 3235 return; 3236 3237 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL); 3238 3239 namespace = ORIGINAL_NAMESPACE (namespace); 3240 3241 /* Build the alias. */ 3242 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node); 3243 DECL_NAMESPACE_ALIAS (alias) = namespace; 3244 DECL_EXTERNAL (alias) = 1; 3245 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ()); 3246 pushdecl (alias); 3247 3248 /* Emit debug info for namespace alias. */ 3249 (*debug_hooks->global_decl) (alias); 3250} 3251 3252/* Like pushdecl, only it places X in the current namespace, 3253 if appropriate. */ 3254 3255tree 3256pushdecl_namespace_level (tree x, bool is_friend) 3257{ 3258 struct cp_binding_level *b = current_binding_level; 3259 tree t; 3260 3261 timevar_push (TV_NAME_LOOKUP); 3262 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend); 3263 3264 /* Now, the type_shadowed stack may screw us. Munge it so it does 3265 what we want. */ 3266 if (TREE_CODE (t) == TYPE_DECL) 3267 { 3268 tree name = DECL_NAME (t); 3269 tree newval; 3270 tree *ptr = (tree *)0; 3271 for (; !global_scope_p (b); b = b->level_chain) 3272 { 3273 tree shadowed = b->type_shadowed; 3274 for (; shadowed; shadowed = TREE_CHAIN (shadowed)) 3275 if (TREE_PURPOSE (shadowed) == name) 3276 { 3277 ptr = &TREE_VALUE (shadowed); 3278 /* Can't break out of the loop here because sometimes 3279 a binding level will have duplicate bindings for 3280 PT names. It's gross, but I haven't time to fix it. */ 3281 } 3282 } 3283 newval = TREE_TYPE (t); 3284 if (ptr == (tree *)0) 3285 { 3286 /* @@ This shouldn't be needed. My test case "zstring.cc" trips 3287 up here if this is changed to an assertion. --KR */ 3288 SET_IDENTIFIER_TYPE_VALUE (name, t); 3289 } 3290 else 3291 { 3292 *ptr = newval; 3293 } 3294 } 3295 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); 3296} 3297 3298/* Insert USED into the using list of USER. Set INDIRECT_flag if this 3299 directive is not directly from the source. Also find the common 3300 ancestor and let our users know about the new namespace */ 3301static void 3302add_using_namespace (tree user, tree used, bool indirect) 3303{ 3304 tree t; 3305 timevar_push (TV_NAME_LOOKUP); 3306 /* Using oneself is a no-op. */ 3307 if (user == used) 3308 { 3309 timevar_pop (TV_NAME_LOOKUP); 3310 return; 3311 } 3312 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL); 3313 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL); 3314 /* Check if we already have this. */ 3315 t = purpose_member (used, DECL_NAMESPACE_USING (user)); 3316 if (t != NULL_TREE) 3317 { 3318 if (!indirect) 3319 /* Promote to direct usage. */ 3320 TREE_INDIRECT_USING (t) = 0; 3321 timevar_pop (TV_NAME_LOOKUP); 3322 return; 3323 } 3324 3325 /* Add used to the user's using list. */ 3326 DECL_NAMESPACE_USING (user) 3327 = tree_cons (used, namespace_ancestor (user, used), 3328 DECL_NAMESPACE_USING (user)); 3329 3330 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect; 3331 3332 /* Add user to the used's users list. */ 3333 DECL_NAMESPACE_USERS (used) 3334 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used)); 3335 3336 /* Recursively add all namespaces used. */ 3337 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t)) 3338 /* indirect usage */ 3339 add_using_namespace (user, TREE_PURPOSE (t), 1); 3340 3341 /* Tell everyone using us about the new used namespaces. */ 3342 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t)) 3343 add_using_namespace (TREE_PURPOSE (t), used, 1); 3344 timevar_pop (TV_NAME_LOOKUP); 3345} 3346 3347/* Process a using-declaration not appearing in class or local scope. */ 3348 3349void 3350do_toplevel_using_decl (tree decl, tree scope, tree name) 3351{ 3352 tree oldval, oldtype, newval, newtype; 3353 tree orig_decl = decl; 3354 cxx_binding *binding; 3355 3356 decl = validate_nonmember_using_decl (decl, scope, name); 3357 if (decl == NULL_TREE) 3358 return; 3359 3360 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name); 3361 3362 oldval = binding->value; 3363 oldtype = binding->type; 3364 3365 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype); 3366 3367 /* Emit debug info. */ 3368 if (!processing_template_decl) 3369 cp_emit_debug_info_for_using (orig_decl, current_namespace); 3370 3371 /* Copy declarations found. */ 3372 if (newval) 3373 binding->value = newval; 3374 if (newtype) 3375 binding->type = newtype; 3376} 3377 3378/* Process a using-directive. */ 3379 3380void 3381do_using_directive (tree namespace) 3382{ 3383 tree context = NULL_TREE; 3384 3385 if (namespace == error_mark_node) 3386 return; 3387 3388 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL); 3389 3390 if (building_stmt_tree ()) 3391 add_stmt (build_stmt (USING_STMT, namespace)); 3392 namespace = ORIGINAL_NAMESPACE (namespace); 3393 3394 if (!toplevel_bindings_p ()) 3395 { 3396 push_using_directive (namespace); 3397 context = current_scope (); 3398 } 3399 else 3400 { 3401 /* direct usage */ 3402 add_using_namespace (current_namespace, namespace, 0); 3403 if (current_namespace != global_namespace) 3404 context = current_namespace; 3405 } 3406 3407 /* Emit debugging info. */ 3408 if (!processing_template_decl) 3409 (*debug_hooks->imported_module_or_decl) (namespace, context); 3410} 3411 3412/* Deal with a using-directive seen by the parser. Currently we only 3413 handle attributes here, since they cannot appear inside a template. */ 3414 3415void 3416parse_using_directive (tree namespace, tree attribs) 3417{ 3418 tree a; 3419 3420 do_using_directive (namespace); 3421 3422 for (a = attribs; a; a = TREE_CHAIN (a)) 3423 { 3424 tree name = TREE_PURPOSE (a); 3425 if (is_attribute_p ("strong", name)) 3426 { 3427 if (!toplevel_bindings_p ()) 3428 error ("strong using only meaningful at namespace scope"); 3429 else if (namespace != error_mark_node) 3430 { 3431 if (!is_ancestor (current_namespace, namespace)) 3432 error ("current namespace %qD does not enclose strongly used namespace %qD", 3433 current_namespace, namespace); 3434 DECL_NAMESPACE_ASSOCIATIONS (namespace) 3435 = tree_cons (current_namespace, 0, 3436 DECL_NAMESPACE_ASSOCIATIONS (namespace)); 3437 } 3438 } 3439 else 3440 warning (OPT_Wattributes, "%qD attribute directive ignored", name); 3441 } 3442} 3443 3444/* Like pushdecl, only it places X in the global scope if appropriate. 3445 Calls cp_finish_decl to register the variable, initializing it with 3446 *INIT, if INIT is non-NULL. */ 3447 3448static tree 3449pushdecl_top_level_1 (tree x, tree *init, bool is_friend) 3450{ 3451 timevar_push (TV_NAME_LOOKUP); 3452 push_to_top_level (); 3453 x = pushdecl_namespace_level (x, is_friend); 3454 if (init) 3455 finish_decl (x, *init, NULL_TREE); 3456 pop_from_top_level (); 3457 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x); 3458} 3459 3460/* Like pushdecl, only it places X in the global scope if appropriate. */ 3461 3462tree 3463pushdecl_top_level (tree x) 3464{ 3465 return pushdecl_top_level_1 (x, NULL, false); 3466} 3467 3468/* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */ 3469 3470tree 3471pushdecl_top_level_maybe_friend (tree x, bool is_friend) 3472{ 3473 return pushdecl_top_level_1 (x, NULL, is_friend); 3474} 3475 3476/* Like pushdecl, only it places X in the global scope if 3477 appropriate. Calls cp_finish_decl to register the variable, 3478 initializing it with INIT. */ 3479 3480tree 3481pushdecl_top_level_and_finish (tree x, tree init) 3482{ 3483 return pushdecl_top_level_1 (x, &init, false); 3484} 3485 3486/* Combines two sets of overloaded functions into an OVERLOAD chain, removing 3487 duplicates. The first list becomes the tail of the result. 3488 3489 The algorithm is O(n^2). We could get this down to O(n log n) by 3490 doing a sort on the addresses of the functions, if that becomes 3491 necessary. */ 3492 3493static tree 3494merge_functions (tree s1, tree s2) 3495{ 3496 for (; s2; s2 = OVL_NEXT (s2)) 3497 { 3498 tree fn2 = OVL_CURRENT (s2); 3499 tree fns1; 3500 3501 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1)) 3502 { 3503 tree fn1 = OVL_CURRENT (fns1); 3504 3505 /* If the function from S2 is already in S1, there is no 3506 need to add it again. For `extern "C"' functions, we 3507 might have two FUNCTION_DECLs for the same function, in 3508 different namespaces; again, we only need one of them. */ 3509 if (fn1 == fn2 3510 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2) 3511 && DECL_NAME (fn1) == DECL_NAME (fn2))) 3512 break; 3513 } 3514 3515 /* If we exhausted all of the functions in S1, FN2 is new. */ 3516 if (!fns1) 3517 s1 = build_overload (fn2, s1); 3518 } 3519 return s1; 3520} 3521 3522/* This should return an error not all definitions define functions. 3523 It is not an error if we find two functions with exactly the 3524 same signature, only if these are selected in overload resolution. 3525 old is the current set of bindings, new the freshly-found binding. 3526 XXX Do we want to give *all* candidates in case of ambiguity? 3527 XXX In what way should I treat extern declarations? 3528 XXX I don't want to repeat the entire duplicate_decls here */ 3529 3530/* LLVM LOCAL begin mainline */ 3531static void 3532ambiguous_decl (struct scope_binding *old, cxx_binding *new, int flags) 3533{ 3534 tree val, type; 3535 gcc_assert (old != NULL); 3536 3537 /* Copy the type. */ 3538 type = new->type; 3539 if (LOOKUP_NAMESPACES_ONLY (flags) 3540 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN))) 3541 type = NULL_TREE; 3542 3543 /* Copy the value. */ 3544 val = new->value; 3545 if (val) 3546 { 3547 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN)) 3548 val = NULL_TREE; 3549 else 3550 switch (TREE_CODE (val)) 3551 { 3552 case TEMPLATE_DECL: 3553 /* If we expect types or namespaces, and not templates, 3554 or this is not a template class. */ 3555 if ((LOOKUP_QUALIFIERS_ONLY (flags) 3556 && !DECL_CLASS_TEMPLATE_P (val))) 3557 val = NULL_TREE; 3558 break; 3559 case TYPE_DECL: 3560 if (LOOKUP_NAMESPACES_ONLY (flags) 3561 || (type && (flags & LOOKUP_PREFER_TYPES))) 3562 val = NULL_TREE; 3563 break; 3564 case NAMESPACE_DECL: 3565 if (LOOKUP_TYPES_ONLY (flags)) 3566 val = NULL_TREE; 3567 break; 3568 case FUNCTION_DECL: 3569 /* Ignore built-in functions that are still anticipated. */ 3570 if (LOOKUP_QUALIFIERS_ONLY (flags)) 3571 val = NULL_TREE; 3572 break; 3573 default: 3574 if (LOOKUP_QUALIFIERS_ONLY (flags)) 3575 val = NULL_TREE; 3576 } 3577 } 3578 3579 /* If val is hidden, shift down any class or enumeration name. */ 3580 if (!val) 3581 { 3582 val = type; 3583 type = NULL_TREE; 3584 } 3585 3586/* LLVM LOCAL end mainline */ 3587 if (!old->value) 3588 old->value = val; 3589 else if (val && val != old->value) 3590 { 3591 if (is_overloaded_fn (old->value) && is_overloaded_fn (val)) 3592 old->value = merge_functions (old->value, val); 3593 else 3594 { 3595 old->value = tree_cons (NULL_TREE, old->value, 3596 build_tree_list (NULL_TREE, val)); 3597 TREE_TYPE (old->value) = error_mark_node; 3598 } 3599 } 3600 3601 /* LLVM LOCAL begin mainline */ 3602 if (!old->type) 3603 old->type = type; 3604 else if (type && old->type != type) 3605 { 3606 old->type = tree_cons (NULL_TREE, old->type, 3607 build_tree_list (NULL_TREE, type)); 3608 TREE_TYPE (old->type) = error_mark_node; 3609 } 3610 /* LLVM LOCAL end mainline */ 3611} 3612 3613/* Return the declarations that are members of the namespace NS. */ 3614 3615tree 3616cp_namespace_decls (tree ns) 3617{ 3618 return NAMESPACE_LEVEL (ns)->names; 3619} 3620 3621/* Combine prefer_type and namespaces_only into flags. */ 3622 3623static int 3624lookup_flags (int prefer_type, int namespaces_only) 3625{ 3626 if (namespaces_only) 3627 return LOOKUP_PREFER_NAMESPACES; 3628 if (prefer_type > 1) 3629 return LOOKUP_PREFER_TYPES; 3630 if (prefer_type > 0) 3631 return LOOKUP_PREFER_BOTH; 3632 return 0; 3633} 3634 3635/* Given a lookup that returned VAL, use FLAGS to decide if we want to 3636 ignore it or not. Subroutine of lookup_name_real and 3637 lookup_type_scope. */ 3638 3639static bool 3640qualify_lookup (tree val, int flags) 3641{ 3642 if (val == NULL_TREE) 3643 return false; 3644 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL) 3645 return true; 3646 if ((flags & LOOKUP_PREFER_TYPES) 3647 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL)) 3648 return true; 3649 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES)) 3650 return false; 3651 return true; 3652} 3653 3654/* Given a lookup that returned VAL, decide if we want to ignore it or 3655 not based on DECL_ANTICIPATED. */ 3656 3657bool 3658hidden_name_p (tree val) 3659{ 3660 if (DECL_P (val) 3661 && DECL_LANG_SPECIFIC (val) 3662 && DECL_ANTICIPATED (val)) 3663 return true; 3664 return false; 3665} 3666 3667/* Remove any hidden friend functions from a possibly overloaded set 3668 of functions. */ 3669 3670tree 3671remove_hidden_names (tree fns) 3672{ 3673 if (!fns) 3674 return fns; 3675 3676 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns)) 3677 fns = NULL_TREE; 3678 else if (TREE_CODE (fns) == OVERLOAD) 3679 { 3680 tree o; 3681 3682 for (o = fns; o; o = OVL_NEXT (o)) 3683 if (hidden_name_p (OVL_CURRENT (o))) 3684 break; 3685 if (o) 3686 { 3687 tree n = NULL_TREE; 3688 3689 for (o = fns; o; o = OVL_NEXT (o)) 3690 if (!hidden_name_p (OVL_CURRENT (o))) 3691 n = build_overload (OVL_CURRENT (o), n); 3692 fns = n; 3693 } 3694 } 3695 3696 return fns; 3697} 3698 3699/* Unscoped lookup of a global: iterate over current namespaces, 3700 considering using-directives. */ 3701 3702static tree 3703unqualified_namespace_lookup (tree name, int flags) 3704{ 3705 tree initial = current_decl_namespace (); 3706 tree scope = initial; 3707 tree siter; 3708 struct cp_binding_level *level; 3709 tree val = NULL_TREE; 3710 3711 timevar_push (TV_NAME_LOOKUP); 3712 3713 for (; !val; scope = CP_DECL_CONTEXT (scope)) 3714 { 3715 struct scope_binding binding = EMPTY_SCOPE_BINDING; 3716 cxx_binding *b = 3717 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name); 3718 3719 if (b) 3720 /* LLVM LOCAL mainline */ 3721 ambiguous_decl (&binding, b, flags); 3722 3723 /* Add all _DECLs seen through local using-directives. */ 3724 for (level = current_binding_level; 3725 level->kind != sk_namespace; 3726 level = level->level_chain) 3727 if (!lookup_using_namespace (name, &binding, level->using_directives, 3728 scope, flags)) 3729 /* Give up because of error. */ 3730 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 3731 3732 /* Add all _DECLs seen through global using-directives. */ 3733 /* XXX local and global using lists should work equally. */ 3734 siter = initial; 3735 while (1) 3736 { 3737 if (!lookup_using_namespace (name, &binding, 3738 DECL_NAMESPACE_USING (siter), 3739 scope, flags)) 3740 /* Give up because of error. */ 3741 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 3742 if (siter == scope) break; 3743 siter = CP_DECL_CONTEXT (siter); 3744 } 3745 3746 val = binding.value; 3747 if (scope == global_namespace) 3748 break; 3749 } 3750 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val); 3751} 3752 3753/* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL 3754 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type 3755 bindings. 3756 3757 Returns a DECL (or OVERLOAD, or BASELINK) representing the 3758 declaration found. If no suitable declaration can be found, 3759 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is 3760 neither a class-type nor a namespace a diagnostic is issued. */ 3761 3762tree 3763lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain) 3764{ 3765 int flags = 0; 3766 tree t = NULL_TREE; 3767 3768 if (TREE_CODE (scope) == NAMESPACE_DECL) 3769 { 3770 struct scope_binding binding = EMPTY_SCOPE_BINDING; 3771 3772 flags |= LOOKUP_COMPLAIN; 3773 if (is_type_p) 3774 flags |= LOOKUP_PREFER_TYPES; 3775 if (qualified_lookup_using_namespace (name, scope, &binding, flags)) 3776 t = binding.value; 3777 } 3778 else if (is_aggr_type (scope, complain)) 3779 t = lookup_member (scope, name, 2, is_type_p); 3780 3781 if (!t) 3782 return error_mark_node; 3783 return t; 3784} 3785 3786/* Subroutine of unqualified_namespace_lookup: 3787 Add the bindings of NAME in used namespaces to VAL. 3788 We are currently looking for names in namespace SCOPE, so we 3789 look through USINGS for using-directives of namespaces 3790 which have SCOPE as a common ancestor with the current scope. 3791 Returns false on errors. */ 3792 3793static bool 3794lookup_using_namespace (tree name, struct scope_binding *val, 3795 tree usings, tree scope, int flags) 3796{ 3797 tree iter; 3798 timevar_push (TV_NAME_LOOKUP); 3799 /* Iterate over all used namespaces in current, searching for using 3800 directives of scope. */ 3801 for (iter = usings; iter; iter = TREE_CHAIN (iter)) 3802 if (TREE_VALUE (iter) == scope) 3803 { 3804 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter)); 3805 cxx_binding *val1 = 3806 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name); 3807 /* Resolve ambiguities. */ 3808 if (val1) 3809 /* LLVM LOCAL mainline */ 3810 ambiguous_decl (val, val1, flags); 3811 } 3812 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node); 3813} 3814 3815/* [namespace.qual] 3816 Accepts the NAME to lookup and its qualifying SCOPE. 3817 Returns the name/type pair found into the cxx_binding *RESULT, 3818 or false on error. */ 3819 3820static bool 3821qualified_lookup_using_namespace (tree name, tree scope, 3822 struct scope_binding *result, int flags) 3823{ 3824 /* Maintain a list of namespaces visited... */ 3825 tree seen = NULL_TREE; 3826 /* ... and a list of namespace yet to see. */ 3827 tree todo = NULL_TREE; 3828 tree todo_maybe = NULL_TREE; 3829 tree usings; 3830 timevar_push (TV_NAME_LOOKUP); 3831 /* Look through namespace aliases. */ 3832 scope = ORIGINAL_NAMESPACE (scope); 3833 while (scope && result->value != error_mark_node) 3834 { 3835 cxx_binding *binding = 3836 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name); 3837 seen = tree_cons (scope, NULL_TREE, seen); 3838 if (binding) 3839 /* LLVM LOCAL mainline */ 3840 ambiguous_decl (result, binding, flags); 3841 3842 /* Consider strong using directives always, and non-strong ones 3843 if we haven't found a binding yet. ??? Shouldn't we consider 3844 non-strong ones if the initial RESULT is non-NULL, but the 3845 binding in the given namespace is? */ 3846 for (usings = DECL_NAMESPACE_USING (scope); usings; 3847 usings = TREE_CHAIN (usings)) 3848 /* If this was a real directive, and we have not seen it. */ 3849 if (!TREE_INDIRECT_USING (usings)) 3850 { 3851 /* Try to avoid queuing the same namespace more than once, 3852 the exception being when a namespace was already 3853 enqueued for todo_maybe and then a strong using is 3854 found for it. We could try to remove it from 3855 todo_maybe, but it's probably not worth the effort. */ 3856 if (is_associated_namespace (scope, TREE_PURPOSE (usings)) 3857 && !purpose_member (TREE_PURPOSE (usings), seen) 3858 && !purpose_member (TREE_PURPOSE (usings), todo)) 3859 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo); 3860 else if ((!result->value && !result->type) 3861 && !purpose_member (TREE_PURPOSE (usings), seen) 3862 && !purpose_member (TREE_PURPOSE (usings), todo) 3863 && !purpose_member (TREE_PURPOSE (usings), todo_maybe)) 3864 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE, 3865 todo_maybe); 3866 } 3867 if (todo) 3868 { 3869 scope = TREE_PURPOSE (todo); 3870 todo = TREE_CHAIN (todo); 3871 } 3872 else if (todo_maybe 3873 && (!result->value && !result->type)) 3874 { 3875 scope = TREE_PURPOSE (todo_maybe); 3876 todo = TREE_CHAIN (todo_maybe); 3877 todo_maybe = NULL_TREE; 3878 } 3879 else 3880 scope = NULL_TREE; /* If there never was a todo list. */ 3881 } 3882 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node); 3883} 3884 3885/* Return the innermost non-namespace binding for NAME from a scope 3886 containing BINDING, or, if BINDING is NULL, the current scope. If 3887 CLASS_P is false, then class bindings are ignored. */ 3888 3889cxx_binding * 3890outer_binding (tree name, 3891 cxx_binding *binding, 3892 bool class_p) 3893{ 3894 cxx_binding *outer; 3895 cxx_scope *scope; 3896 cxx_scope *outer_scope; 3897 3898 if (binding) 3899 { 3900 scope = binding->scope->level_chain; 3901 outer = binding->previous; 3902 } 3903 else 3904 { 3905 scope = current_binding_level; 3906 outer = IDENTIFIER_BINDING (name); 3907 } 3908 outer_scope = outer ? outer->scope : NULL; 3909 3910 /* Because we create class bindings lazily, we might be missing a 3911 class binding for NAME. If there are any class binding levels 3912 between the LAST_BINDING_LEVEL and the scope in which OUTER was 3913 declared, we must lookup NAME in those class scopes. */ 3914 if (class_p) 3915 while (scope && scope != outer_scope && scope->kind != sk_namespace) 3916 { 3917 if (scope->kind == sk_class) 3918 { 3919 cxx_binding *class_binding; 3920 3921 class_binding = get_class_binding (name, scope); 3922 if (class_binding) 3923 { 3924 /* Thread this new class-scope binding onto the 3925 IDENTIFIER_BINDING list so that future lookups 3926 find it quickly. */ 3927 class_binding->previous = outer; 3928 if (binding) 3929 binding->previous = class_binding; 3930 else 3931 IDENTIFIER_BINDING (name) = class_binding; 3932 return class_binding; 3933 } 3934 } 3935 scope = scope->level_chain; 3936 } 3937 3938 return outer; 3939} 3940 3941/* Return the innermost block-scope or class-scope value binding for 3942 NAME, or NULL_TREE if there is no such binding. */ 3943 3944tree 3945innermost_non_namespace_value (tree name) 3946{ 3947 cxx_binding *binding; 3948 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true); 3949 return binding ? binding->value : NULL_TREE; 3950} 3951 3952/* Look up NAME in the current binding level and its superiors in the 3953 namespace of variables, functions and typedefs. Return a ..._DECL 3954 node of some kind representing its definition if there is only one 3955 such declaration, or return a TREE_LIST with all the overloaded 3956 definitions if there are many, or return 0 if it is undefined. 3957 Hidden name, either friend declaration or built-in function, are 3958 not ignored. 3959 3960 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces. 3961 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces). 3962 Otherwise we prefer non-TYPE_DECLs. 3963 3964 If NONCLASS is nonzero, bindings in class scopes are ignored. If 3965 BLOCK_P is false, bindings in block scopes are ignored. */ 3966 3967tree 3968lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p, 3969 int namespaces_only, int flags) 3970{ 3971 cxx_binding *iter; 3972 tree val = NULL_TREE; 3973 3974 timevar_push (TV_NAME_LOOKUP); 3975 /* Conversion operators are handled specially because ordinary 3976 unqualified name lookup will not find template conversion 3977 operators. */ 3978 if (IDENTIFIER_TYPENAME_P (name)) 3979 { 3980 struct cp_binding_level *level; 3981 3982 for (level = current_binding_level; 3983 level && level->kind != sk_namespace; 3984 level = level->level_chain) 3985 { 3986 tree class_type; 3987 tree operators; 3988 3989 /* A conversion operator can only be declared in a class 3990 scope. */ 3991 if (level->kind != sk_class) 3992 continue; 3993 3994 /* Lookup the conversion operator in the class. */ 3995 class_type = level->this_entity; 3996 operators = lookup_fnfields (class_type, name, /*protect=*/0); 3997 if (operators) 3998 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators); 3999 } 4000 4001 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE); 4002 } 4003 4004 flags |= lookup_flags (prefer_type, namespaces_only); 4005 4006 /* First, look in non-namespace scopes. */ 4007 4008 if (current_class_type == NULL_TREE) 4009 nonclass = 1; 4010 4011 if (block_p || !nonclass) 4012 for (iter = outer_binding (name, NULL, !nonclass); 4013 iter; 4014 iter = outer_binding (name, iter, !nonclass)) 4015 { 4016 tree binding; 4017 4018 /* Skip entities we don't want. */ 4019 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass) 4020 continue; 4021 4022 /* If this is the kind of thing we're looking for, we're done. */ 4023 if (qualify_lookup (iter->value, flags)) 4024 binding = iter->value; 4025 else if ((flags & LOOKUP_PREFER_TYPES) 4026 && qualify_lookup (iter->type, flags)) 4027 binding = iter->type; 4028 else 4029 binding = NULL_TREE; 4030 4031 if (binding) 4032 { 4033 if (hidden_name_p (binding)) 4034 { 4035 /* A non namespace-scope binding can only be hidden if 4036 we are in a local class, due to friend declarations. 4037 In particular, consider: 4038 4039 void f() { 4040 struct A { 4041 friend struct B; 4042 void g() { B* b; } // error: B is hidden 4043 } 4044 struct B {}; 4045 } 4046 4047 The standard says that "B" is a local class in "f" 4048 (but not nested within "A") -- but that name lookup 4049 for "B" does not find this declaration until it is 4050 declared directly with "f". 4051 4052 In particular: 4053 4054 [class.friend] 4055 4056 If a friend declaration appears in a local class and 4057 the name specified is an unqualified name, a prior 4058 declaration is looked up without considering scopes 4059 that are outside the innermost enclosing non-class 4060 scope. For a friend class declaration, if there is no 4061 prior declaration, the class that is specified 4062 belongs to the innermost enclosing non-class scope, 4063 but if it is subsequently referenced, its name is not 4064 found by name lookup until a matching declaration is 4065 provided in the innermost enclosing nonclass scope. 4066 */ 4067 gcc_assert (current_class_type && 4068 LOCAL_CLASS_P (current_class_type)); 4069 4070 /* This binding comes from a friend declaration in the local 4071 class. The standard (11.4.8) states that the lookup can 4072 only succeed if there is a non-hidden declaration in the 4073 current scope, which is not the case here. */ 4074 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE); 4075 } 4076 val = binding; 4077 break; 4078 } 4079 } 4080 4081 /* Now lookup in namespace scopes. */ 4082 if (!val) 4083 val = unqualified_namespace_lookup (name, flags); 4084 4085 /* If we have a single function from a using decl, pull it out. */ 4086 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val)) 4087 val = OVL_FUNCTION (val); 4088 4089 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val); 4090} 4091 4092tree 4093lookup_name_nonclass (tree name) 4094{ 4095 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN); 4096} 4097 4098tree 4099lookup_function_nonclass (tree name, tree args, bool block_p) 4100{ 4101 return 4102 lookup_arg_dependent (name, 4103 lookup_name_real (name, 0, 1, block_p, 0, 4104 LOOKUP_COMPLAIN), 4105 args); 4106} 4107 4108tree 4109lookup_name (tree name) 4110{ 4111 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN); 4112} 4113 4114tree 4115lookup_name_prefer_type (tree name, int prefer_type) 4116{ 4117 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true, 4118 0, LOOKUP_COMPLAIN); 4119} 4120 4121/* Look up NAME for type used in elaborated name specifier in 4122 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or 4123 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the 4124 name, more scopes are checked if cleanup or template parameter 4125 scope is encountered. 4126 4127 Unlike lookup_name_real, we make sure that NAME is actually 4128 declared in the desired scope, not from inheritance, nor using 4129 directive. For using declaration, there is DR138 still waiting 4130 to be resolved. Hidden name coming from an earlier friend 4131 declaration is also returned. 4132 4133 A TYPE_DECL best matching the NAME is returned. Catching error 4134 and issuing diagnostics are caller's responsibility. */ 4135 4136tree 4137lookup_type_scope (tree name, tag_scope scope) 4138{ 4139 cxx_binding *iter = NULL; 4140 tree val = NULL_TREE; 4141 4142 timevar_push (TV_NAME_LOOKUP); 4143 4144 /* Look in non-namespace scope first. */ 4145 if (current_binding_level->kind != sk_namespace) 4146 iter = outer_binding (name, NULL, /*class_p=*/ true); 4147 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true)) 4148 { 4149 /* Check if this is the kind of thing we're looking for. 4150 If SCOPE is TS_CURRENT, also make sure it doesn't come from 4151 base class. For ITER->VALUE, we can simply use 4152 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use 4153 our own check. 4154 4155 We check ITER->TYPE before ITER->VALUE in order to handle 4156 typedef struct C {} C; 4157 correctly. */ 4158 4159 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES) 4160 && (scope != ts_current 4161 || LOCAL_BINDING_P (iter) 4162 || DECL_CONTEXT (iter->type) == iter->scope->this_entity)) 4163 val = iter->type; 4164 else if ((scope != ts_current 4165 || !INHERITED_VALUE_BINDING_P (iter)) 4166 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES)) 4167 val = iter->value; 4168 4169 if (val) 4170 break; 4171 } 4172 4173 /* Look in namespace scope. */ 4174 if (!val) 4175 { 4176 iter = cxx_scope_find_binding_for_name 4177 (NAMESPACE_LEVEL (current_decl_namespace ()), name); 4178 4179 if (iter) 4180 { 4181 /* If this is the kind of thing we're looking for, we're done. */ 4182 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)) 4183 val = iter->type; 4184 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES)) 4185 val = iter->value; 4186 } 4187 4188 } 4189 4190 /* Type found, check if it is in the allowed scopes, ignoring cleanup 4191 and template parameter scopes. */ 4192 if (val) 4193 { 4194 struct cp_binding_level *b = current_binding_level; 4195 while (b) 4196 { 4197 if (iter->scope == b) 4198 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val); 4199 4200 if (b->kind == sk_cleanup || b->kind == sk_template_parms) 4201 b = b->level_chain; 4202 else if (b->kind == sk_class 4203 && scope == ts_within_enclosing_non_class) 4204 b = b->level_chain; 4205 else 4206 break; 4207 } 4208 } 4209 4210 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE); 4211} 4212 4213/* Similar to `lookup_name' but look only in the innermost non-class 4214 binding level. */ 4215 4216static tree 4217lookup_name_innermost_nonclass_level (tree name) 4218{ 4219 struct cp_binding_level *b; 4220 tree t = NULL_TREE; 4221 4222 timevar_push (TV_NAME_LOOKUP); 4223 b = innermost_nonclass_level (); 4224 4225 if (b->kind == sk_namespace) 4226 { 4227 t = IDENTIFIER_NAMESPACE_VALUE (name); 4228 4229 /* extern "C" function() */ 4230 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST) 4231 t = TREE_VALUE (t); 4232 } 4233 else if (IDENTIFIER_BINDING (name) 4234 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name))) 4235 { 4236 cxx_binding *binding; 4237 binding = IDENTIFIER_BINDING (name); 4238 while (1) 4239 { 4240 if (binding->scope == b 4241 && !(TREE_CODE (binding->value) == VAR_DECL 4242 && DECL_DEAD_FOR_LOCAL (binding->value))) 4243 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value); 4244 4245 if (b->kind == sk_cleanup) 4246 b = b->level_chain; 4247 else 4248 break; 4249 } 4250 } 4251 4252 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); 4253} 4254 4255/* Like lookup_name_innermost_nonclass_level, but for types. */ 4256 4257static tree 4258lookup_type_current_level (tree name) 4259{ 4260 tree t = NULL_TREE; 4261 4262 timevar_push (TV_NAME_LOOKUP); 4263 gcc_assert (current_binding_level->kind != sk_namespace); 4264 4265 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE 4266 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node) 4267 { 4268 struct cp_binding_level *b = current_binding_level; 4269 while (1) 4270 { 4271 if (purpose_member (name, b->type_shadowed)) 4272 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, 4273 REAL_IDENTIFIER_TYPE_VALUE (name)); 4274 if (b->kind == sk_cleanup) 4275 b = b->level_chain; 4276 else 4277 break; 4278 } 4279 } 4280 4281 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); 4282} 4283 4284/* [basic.lookup.koenig] */ 4285/* A nonzero return value in the functions below indicates an error. */ 4286 4287struct arg_lookup 4288{ 4289 tree name; 4290 tree args; 4291 tree namespaces; 4292 tree classes; 4293 tree functions; 4294}; 4295 4296static bool arg_assoc (struct arg_lookup*, tree); 4297static bool arg_assoc_args (struct arg_lookup*, tree); 4298static bool arg_assoc_type (struct arg_lookup*, tree); 4299static bool add_function (struct arg_lookup *, tree); 4300static bool arg_assoc_namespace (struct arg_lookup *, tree); 4301static bool arg_assoc_class (struct arg_lookup *, tree); 4302static bool arg_assoc_template_arg (struct arg_lookup*, tree); 4303 4304/* Add a function to the lookup structure. 4305 Returns true on error. */ 4306 4307static bool 4308add_function (struct arg_lookup *k, tree fn) 4309{ 4310 /* We used to check here to see if the function was already in the list, 4311 but that's O(n^2), which is just too expensive for function lookup. 4312 Now we deal with the occasional duplicate in joust. In doing this, we 4313 assume that the number of duplicates will be small compared to the 4314 total number of functions being compared, which should usually be the 4315 case. */ 4316 4317 /* We must find only functions, or exactly one non-function. */ 4318 if (!k->functions) 4319 k->functions = fn; 4320 else if (fn == k->functions) 4321 ; 4322 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn)) 4323 k->functions = build_overload (fn, k->functions); 4324 else 4325 { 4326 tree f1 = OVL_CURRENT (k->functions); 4327 tree f2 = fn; 4328 if (is_overloaded_fn (f1)) 4329 { 4330 fn = f1; f1 = f2; f2 = fn; 4331 } 4332 error ("%q+D is not a function,", f1); 4333 error (" conflict with %q+D", f2); 4334 error (" in call to %qD", k->name); 4335 return true; 4336 } 4337 4338 return false; 4339} 4340 4341/* Returns true iff CURRENT has declared itself to be an associated 4342 namespace of SCOPE via a strong using-directive (or transitive chain 4343 thereof). Both are namespaces. */ 4344 4345bool 4346is_associated_namespace (tree current, tree scope) 4347{ 4348 tree seen = NULL_TREE; 4349 tree todo = NULL_TREE; 4350 tree t; 4351 while (1) 4352 { 4353 if (scope == current) 4354 return true; 4355 seen = tree_cons (scope, NULL_TREE, seen); 4356 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t)) 4357 if (!purpose_member (TREE_PURPOSE (t), seen)) 4358 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo); 4359 if (todo) 4360 { 4361 scope = TREE_PURPOSE (todo); 4362 todo = TREE_CHAIN (todo); 4363 } 4364 else 4365 return false; 4366 } 4367} 4368 4369/* Return whether FN is a friend of an associated class of ARG. */ 4370 4371static bool 4372friend_of_associated_class_p (tree arg, tree fn) 4373{ 4374 tree type; 4375 4376 if (TYPE_P (arg)) 4377 type = arg; 4378 else if (type_unknown_p (arg)) 4379 return false; 4380 else 4381 type = TREE_TYPE (arg); 4382 4383 /* If TYPE is a class, the class itself and all base classes are 4384 associated classes. */ 4385 if (CLASS_TYPE_P (type)) 4386 { 4387 if (is_friend (type, fn)) 4388 return true; 4389 4390 if (TYPE_BINFO (type)) 4391 { 4392 tree binfo, base_binfo; 4393 int i; 4394 4395 for (binfo = TYPE_BINFO (type), i = 0; 4396 BINFO_BASE_ITERATE (binfo, i, base_binfo); 4397 i++) 4398 if (is_friend (BINFO_TYPE (base_binfo), fn)) 4399 return true; 4400 } 4401 } 4402 4403 /* If TYPE is a class member, the class of which it is a member is 4404 an associated class. */ 4405 if ((CLASS_TYPE_P (type) 4406 || TREE_CODE (type) == UNION_TYPE 4407 || TREE_CODE (type) == ENUMERAL_TYPE) 4408 && TYPE_CONTEXT (type) 4409 && CLASS_TYPE_P (TYPE_CONTEXT (type)) 4410 && is_friend (TYPE_CONTEXT (type), fn)) 4411 return true; 4412 4413 return false; 4414} 4415 4416/* Add functions of a namespace to the lookup structure. 4417 Returns true on error. */ 4418 4419static bool 4420arg_assoc_namespace (struct arg_lookup *k, tree scope) 4421{ 4422 tree value; 4423 4424 if (purpose_member (scope, k->namespaces)) 4425 return 0; 4426 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces); 4427 4428 /* Check out our super-users. */ 4429 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value; 4430 value = TREE_CHAIN (value)) 4431 if (arg_assoc_namespace (k, TREE_PURPOSE (value))) 4432 return true; 4433 4434 value = namespace_binding (k->name, scope); 4435 if (!value) 4436 return false; 4437 4438 for (; value; value = OVL_NEXT (value)) 4439 { 4440 /* We don't want to find arbitrary hidden functions via argument 4441 dependent lookup. We only want to find friends of associated 4442 classes. */ 4443 if (hidden_name_p (OVL_CURRENT (value))) 4444 { 4445 tree args; 4446 4447 for (args = k->args; args; args = TREE_CHAIN (args)) 4448 if (friend_of_associated_class_p (TREE_VALUE (args), 4449 OVL_CURRENT (value))) 4450 break; 4451 if (!args) 4452 continue; 4453 } 4454 4455 if (add_function (k, OVL_CURRENT (value))) 4456 return true; 4457 } 4458 4459 return false; 4460} 4461 4462/* Adds everything associated with a template argument to the lookup 4463 structure. Returns true on error. */ 4464 4465static bool 4466arg_assoc_template_arg (struct arg_lookup *k, tree arg) 4467{ 4468 /* [basic.lookup.koenig] 4469 4470 If T is a template-id, its associated namespaces and classes are 4471 ... the namespaces and classes associated with the types of the 4472 template arguments provided for template type parameters 4473 (excluding template template parameters); the namespaces in which 4474 any template template arguments are defined; and the classes in 4475 which any member templates used as template template arguments 4476 are defined. [Note: non-type template arguments do not 4477 contribute to the set of associated namespaces. ] */ 4478 4479 /* Consider first template template arguments. */ 4480 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM 4481 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE) 4482 return false; 4483 else if (TREE_CODE (arg) == TEMPLATE_DECL) 4484 { 4485 tree ctx = CP_DECL_CONTEXT (arg); 4486 4487 /* It's not a member template. */ 4488 if (TREE_CODE (ctx) == NAMESPACE_DECL) 4489 return arg_assoc_namespace (k, ctx); 4490 /* Otherwise, it must be member template. */ 4491 else 4492 return arg_assoc_class (k, ctx); 4493 } 4494 /* It's not a template template argument, but it is a type template 4495 argument. */ 4496 else if (TYPE_P (arg)) 4497 return arg_assoc_type (k, arg); 4498 /* It's a non-type template argument. */ 4499 else 4500 return false; 4501} 4502 4503/* Adds everything associated with class to the lookup structure. 4504 Returns true on error. */ 4505 4506static bool 4507arg_assoc_class (struct arg_lookup *k, tree type) 4508{ 4509 tree list, friends, context; 4510 int i; 4511 4512 /* Backend build structures, such as __builtin_va_list, aren't 4513 affected by all this. */ 4514 if (!CLASS_TYPE_P (type)) 4515 return false; 4516 4517 if (purpose_member (type, k->classes)) 4518 return false; 4519 k->classes = tree_cons (type, NULL_TREE, k->classes); 4520 4521 context = decl_namespace_context (type); 4522 if (arg_assoc_namespace (k, context)) 4523 return true; 4524 4525 if (TYPE_BINFO (type)) 4526 { 4527 /* Process baseclasses. */ 4528 tree binfo, base_binfo; 4529 4530 for (binfo = TYPE_BINFO (type), i = 0; 4531 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 4532 if (arg_assoc_class (k, BINFO_TYPE (base_binfo))) 4533 return true; 4534 } 4535 4536 /* Process friends. */ 4537 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list; 4538 list = TREE_CHAIN (list)) 4539 if (k->name == FRIEND_NAME (list)) 4540 for (friends = FRIEND_DECLS (list); friends; 4541 friends = TREE_CHAIN (friends)) 4542 { 4543 tree fn = TREE_VALUE (friends); 4544 4545 /* Only interested in global functions with potentially hidden 4546 (i.e. unqualified) declarations. */ 4547 if (CP_DECL_CONTEXT (fn) != context) 4548 continue; 4549 /* Template specializations are never found by name lookup. 4550 (Templates themselves can be found, but not template 4551 specializations.) */ 4552 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn)) 4553 continue; 4554 if (add_function (k, fn)) 4555 return true; 4556 } 4557 4558 /* Process template arguments. */ 4559 if (CLASSTYPE_TEMPLATE_INFO (type) 4560 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))) 4561 { 4562 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)); 4563 for (i = 0; i < TREE_VEC_LENGTH (list); ++i) 4564 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i)); 4565 } 4566 4567 return false; 4568} 4569 4570/* Adds everything associated with a given type. 4571 Returns 1 on error. */ 4572 4573static bool 4574arg_assoc_type (struct arg_lookup *k, tree type) 4575{ 4576 /* As we do not get the type of non-type dependent expressions 4577 right, we can end up with such things without a type. */ 4578 if (!type) 4579 return false; 4580 4581 if (TYPE_PTRMEM_P (type)) 4582 { 4583 /* Pointer to member: associate class type and value type. */ 4584 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type))) 4585 return true; 4586 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type)); 4587 } 4588 else switch (TREE_CODE (type)) 4589 { 4590 case ERROR_MARK: 4591 return false; 4592 case VOID_TYPE: 4593 case INTEGER_TYPE: 4594 case REAL_TYPE: 4595 case COMPLEX_TYPE: 4596 case VECTOR_TYPE: 4597 case BOOLEAN_TYPE: 4598 return false; 4599 case RECORD_TYPE: 4600 if (TYPE_PTRMEMFUNC_P (type)) 4601 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type)); 4602 return arg_assoc_class (k, type); 4603 case POINTER_TYPE: 4604 /* APPLE LOCAL blocks 6040305 */ 4605 case BLOCK_POINTER_TYPE: 4606 case REFERENCE_TYPE: 4607 case ARRAY_TYPE: 4608 return arg_assoc_type (k, TREE_TYPE (type)); 4609 case UNION_TYPE: 4610 case ENUMERAL_TYPE: 4611 return arg_assoc_namespace (k, decl_namespace_context (type)); 4612 case METHOD_TYPE: 4613 /* The basetype is referenced in the first arg type, so just 4614 fall through. */ 4615 case FUNCTION_TYPE: 4616 /* Associate the parameter types. */ 4617 if (arg_assoc_args (k, TYPE_ARG_TYPES (type))) 4618 return true; 4619 /* Associate the return type. */ 4620 return arg_assoc_type (k, TREE_TYPE (type)); 4621 case TEMPLATE_TYPE_PARM: 4622 case BOUND_TEMPLATE_TEMPLATE_PARM: 4623 return false; 4624 case TYPENAME_TYPE: 4625 return false; 4626 case LANG_TYPE: 4627 gcc_assert (type == unknown_type_node); 4628 return false; 4629 default: 4630 gcc_unreachable (); 4631 } 4632 return false; 4633} 4634 4635/* Adds everything associated with arguments. Returns true on error. */ 4636 4637static bool 4638arg_assoc_args (struct arg_lookup *k, tree args) 4639{ 4640 for (; args; args = TREE_CHAIN (args)) 4641 if (arg_assoc (k, TREE_VALUE (args))) 4642 return true; 4643 return false; 4644} 4645 4646/* Adds everything associated with a given tree_node. Returns 1 on error. */ 4647 4648static bool 4649arg_assoc (struct arg_lookup *k, tree n) 4650{ 4651 if (n == error_mark_node) 4652 return false; 4653 4654 if (TYPE_P (n)) 4655 return arg_assoc_type (k, n); 4656 4657 if (! type_unknown_p (n)) 4658 return arg_assoc_type (k, TREE_TYPE (n)); 4659 4660 if (TREE_CODE (n) == ADDR_EXPR) 4661 n = TREE_OPERAND (n, 0); 4662 if (TREE_CODE (n) == COMPONENT_REF) 4663 n = TREE_OPERAND (n, 1); 4664 if (TREE_CODE (n) == OFFSET_REF) 4665 n = TREE_OPERAND (n, 1); 4666 while (TREE_CODE (n) == TREE_LIST) 4667 n = TREE_VALUE (n); 4668 if (TREE_CODE (n) == BASELINK) 4669 n = BASELINK_FUNCTIONS (n); 4670 4671 if (TREE_CODE (n) == FUNCTION_DECL) 4672 return arg_assoc_type (k, TREE_TYPE (n)); 4673 if (TREE_CODE (n) == TEMPLATE_ID_EXPR) 4674 { 4675 /* [basic.lookup.koenig] 4676 4677 If T is a template-id, its associated namespaces and classes 4678 are the namespace in which the template is defined; for 4679 member templates, the member template's class... */ 4680 tree template = TREE_OPERAND (n, 0); 4681 tree args = TREE_OPERAND (n, 1); 4682 tree ctx; 4683 int ix; 4684 4685 if (TREE_CODE (template) == COMPONENT_REF) 4686 template = TREE_OPERAND (template, 1); 4687 4688 /* First, the template. There may actually be more than one if 4689 this is an overloaded function template. But, in that case, 4690 we only need the first; all the functions will be in the same 4691 namespace. */ 4692 template = OVL_CURRENT (template); 4693 4694 ctx = CP_DECL_CONTEXT (template); 4695 4696 if (TREE_CODE (ctx) == NAMESPACE_DECL) 4697 { 4698 if (arg_assoc_namespace (k, ctx) == 1) 4699 return true; 4700 } 4701 /* It must be a member template. */ 4702 else if (arg_assoc_class (k, ctx) == 1) 4703 return true; 4704 4705 /* Now the arguments. */ 4706 if (args) 4707 for (ix = TREE_VEC_LENGTH (args); ix--;) 4708 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1) 4709 return true; 4710 } 4711 else if (TREE_CODE (n) == OVERLOAD) 4712 { 4713 for (; n; n = OVL_CHAIN (n)) 4714 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n)))) 4715 return true; 4716 } 4717 4718 return false; 4719} 4720 4721/* Performs Koenig lookup depending on arguments, where fns 4722 are the functions found in normal lookup. */ 4723 4724tree 4725lookup_arg_dependent (tree name, tree fns, tree args) 4726{ 4727 struct arg_lookup k; 4728 4729 timevar_push (TV_NAME_LOOKUP); 4730 4731 /* Remove any hidden friend functions from the list of functions 4732 found so far. They will be added back by arg_assoc_class as 4733 appropriate. */ 4734 fns = remove_hidden_names (fns); 4735 4736 k.name = name; 4737 k.args = args; 4738 k.functions = fns; 4739 k.classes = NULL_TREE; 4740 4741 /* We previously performed an optimization here by setting 4742 NAMESPACES to the current namespace when it was safe. However, DR 4743 164 says that namespaces that were already searched in the first 4744 stage of template processing are searched again (potentially 4745 picking up later definitions) in the second stage. */ 4746 k.namespaces = NULL_TREE; 4747 4748 arg_assoc_args (&k, args); 4749 4750 fns = k.functions; 4751 4752 if (fns 4753 && TREE_CODE (fns) != VAR_DECL 4754 && !is_overloaded_fn (fns)) 4755 { 4756 error ("argument dependent lookup finds %q+D", fns); 4757 error (" in call to %qD", name); 4758 fns = error_mark_node; 4759 } 4760 4761 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns); 4762} 4763 4764/* Add namespace to using_directives. Return NULL_TREE if nothing was 4765 changed (i.e. there was already a directive), or the fresh 4766 TREE_LIST otherwise. */ 4767 4768static tree 4769push_using_directive (tree used) 4770{ 4771 tree ud = current_binding_level->using_directives; 4772 tree iter, ancestor; 4773 4774 timevar_push (TV_NAME_LOOKUP); 4775 /* Check if we already have this. */ 4776 if (purpose_member (used, ud) != NULL_TREE) 4777 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE); 4778 4779 ancestor = namespace_ancestor (current_decl_namespace (), used); 4780 ud = current_binding_level->using_directives; 4781 ud = tree_cons (used, ancestor, ud); 4782 current_binding_level->using_directives = ud; 4783 4784 /* Recursively add all namespaces used. */ 4785 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter)) 4786 push_using_directive (TREE_PURPOSE (iter)); 4787 4788 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud); 4789} 4790 4791/* The type TYPE is being declared. If it is a class template, or a 4792 specialization of a class template, do any processing required and 4793 perform error-checking. If IS_FRIEND is nonzero, this TYPE is 4794 being declared a friend. B is the binding level at which this TYPE 4795 should be bound. 4796 4797 Returns the TYPE_DECL for TYPE, which may have been altered by this 4798 processing. */ 4799 4800static tree 4801maybe_process_template_type_declaration (tree type, int is_friend, 4802 cxx_scope *b) 4803{ 4804 tree decl = TYPE_NAME (type); 4805 4806 if (processing_template_parmlist) 4807 /* You can't declare a new template type in a template parameter 4808 list. But, you can declare a non-template type: 4809 4810 template <class A*> struct S; 4811 4812 is a forward-declaration of `A'. */ 4813 ; 4814 else if (b->kind == sk_namespace 4815 && current_binding_level->kind != sk_namespace) 4816 /* If this new type is being injected into a containing scope, 4817 then it's not a template type. */ 4818 ; 4819 else 4820 { 4821 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE); 4822 4823 if (processing_template_decl) 4824 { 4825 /* This may change after the call to 4826 push_template_decl_real, but we want the original value. */ 4827 tree name = DECL_NAME (decl); 4828 4829 decl = push_template_decl_real (decl, is_friend); 4830 /* If the current binding level is the binding level for the 4831 template parameters (see the comment in 4832 begin_template_parm_list) and the enclosing level is a class 4833 scope, and we're not looking at a friend, push the 4834 declaration of the member class into the class scope. In the 4835 friend case, push_template_decl will already have put the 4836 friend into global scope, if appropriate. */ 4837 if (TREE_CODE (type) != ENUMERAL_TYPE 4838 && !is_friend && b->kind == sk_template_parms 4839 && b->level_chain->kind == sk_class) 4840 { 4841 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type)); 4842 4843 if (!COMPLETE_TYPE_P (current_class_type)) 4844 { 4845 maybe_add_class_template_decl_list (current_class_type, 4846 type, /*friend_p=*/0); 4847 /* Put this UTD in the table of UTDs for the class. */ 4848 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL) 4849 CLASSTYPE_NESTED_UTDS (current_class_type) = 4850 binding_table_new (SCOPE_DEFAULT_HT_SIZE); 4851 4852 binding_table_insert 4853 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type); 4854 } 4855 } 4856 } 4857 } 4858 4859 return decl; 4860} 4861 4862/* Push a tag name NAME for struct/class/union/enum type TYPE. In case 4863 that the NAME is a class template, the tag is processed but not pushed. 4864 4865 The pushed scope depend on the SCOPE parameter: 4866 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup 4867 scope. 4868 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and 4869 non-template-parameter scope. This case is needed for forward 4870 declarations. 4871 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to 4872 TS_GLOBAL case except that names within template-parameter scopes 4873 are not pushed at all. 4874 4875 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */ 4876 4877tree 4878pushtag (tree name, tree type, tag_scope scope) 4879{ 4880 struct cp_binding_level *b; 4881 tree decl; 4882 4883 timevar_push (TV_NAME_LOOKUP); 4884 b = current_binding_level; 4885 while (/* Cleanup scopes are not scopes from the point of view of 4886 the language. */ 4887 b->kind == sk_cleanup 4888 /* Neither are the scopes used to hold template parameters 4889 for an explicit specialization. For an ordinary template 4890 declaration, these scopes are not scopes from the point of 4891 view of the language. */ 4892 || (b->kind == sk_template_parms 4893 && (b->explicit_spec_p || scope == ts_global)) 4894 || (b->kind == sk_class 4895 && (scope != ts_current 4896 /* We may be defining a new type in the initializer 4897 of a static member variable. We allow this when 4898 not pedantic, and it is particularly useful for 4899 type punning via an anonymous union. */ 4900 || COMPLETE_TYPE_P (b->this_entity)))) 4901 b = b->level_chain; 4902 4903 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); 4904 4905 /* Do C++ gratuitous typedefing. */ 4906 if (IDENTIFIER_TYPE_VALUE (name) != type) 4907 { 4908 tree tdef; 4909 int in_class = 0; 4910 tree context = TYPE_CONTEXT (type); 4911 4912 if (! context) 4913 { 4914 tree cs = current_scope (); 4915 4916 if (scope == ts_current) 4917 context = cs; 4918 else if (cs != NULL_TREE && TYPE_P (cs)) 4919 /* When declaring a friend class of a local class, we want 4920 to inject the newly named class into the scope 4921 containing the local class, not the namespace 4922 scope. */ 4923 context = decl_function_context (get_type_decl (cs)); 4924 } 4925 if (!context) 4926 context = current_namespace; 4927 4928 if (b->kind == sk_class 4929 || (b->kind == sk_template_parms 4930 && b->level_chain->kind == sk_class)) 4931 in_class = 1; 4932 4933 if (current_lang_name == lang_name_java) 4934 TYPE_FOR_JAVA (type) = 1; 4935 4936 tdef = create_implicit_typedef (name, type); 4937 DECL_CONTEXT (tdef) = FROB_CONTEXT (context); 4938 if (scope == ts_within_enclosing_non_class) 4939 { 4940 /* This is a friend. Make this TYPE_DECL node hidden from 4941 ordinary name lookup. Its corresponding TEMPLATE_DECL 4942 will be marked in push_template_decl_real. */ 4943 retrofit_lang_decl (tdef); 4944 DECL_ANTICIPATED (tdef) = 1; 4945 DECL_FRIEND_P (tdef) = 1; 4946 } 4947 4948 decl = maybe_process_template_type_declaration 4949 (type, scope == ts_within_enclosing_non_class, b); 4950 if (decl == error_mark_node) 4951 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); 4952 4953 if (! in_class) 4954 set_identifier_type_value_with_scope (name, tdef, b); 4955 4956 if (b->kind == sk_class) 4957 { 4958 if (!PROCESSING_REAL_TEMPLATE_DECL_P ()) 4959 /* Put this TYPE_DECL on the TYPE_FIELDS list for the 4960 class. But if it's a member template class, we want 4961 the TEMPLATE_DECL, not the TYPE_DECL, so this is done 4962 later. */ 4963 finish_member_declaration (decl); 4964 else 4965 pushdecl_class_level (decl); 4966 } 4967 else if (b->kind != sk_template_parms) 4968 { 4969 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false); 4970 if (decl == error_mark_node) 4971 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl); 4972 } 4973 4974 TYPE_CONTEXT (type) = DECL_CONTEXT (decl); 4975 4976 /* If this is a local class, keep track of it. We need this 4977 information for name-mangling, and so that it is possible to 4978 find all function definitions in a translation unit in a 4979 convenient way. (It's otherwise tricky to find a member 4980 function definition it's only pointed to from within a local 4981 class.) */ 4982 if (TYPE_CONTEXT (type) 4983 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL) 4984 VEC_safe_push (tree, gc, local_classes, type); 4985 } 4986 if (b->kind == sk_class 4987 && !COMPLETE_TYPE_P (current_class_type)) 4988 { 4989 maybe_add_class_template_decl_list (current_class_type, 4990 type, /*friend_p=*/0); 4991 4992 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL) 4993 CLASSTYPE_NESTED_UTDS (current_class_type) 4994 = binding_table_new (SCOPE_DEFAULT_HT_SIZE); 4995 4996 binding_table_insert 4997 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type); 4998 } 4999 5000 decl = TYPE_NAME (type); 5001 gcc_assert (TREE_CODE (decl) == TYPE_DECL); 5002 TYPE_STUB_DECL (type) = decl; 5003 5004 /* Set type visibility now if this is a forward declaration. */ 5005 TREE_PUBLIC (decl) = 1; 5006 determine_visibility (decl); 5007 5008 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type); 5009} 5010 5011/* Subroutines for reverting temporarily to top-level for instantiation 5012 of templates and such. We actually need to clear out the class- and 5013 local-value slots of all identifiers, so that only the global values 5014 are at all visible. Simply setting current_binding_level to the global 5015 scope isn't enough, because more binding levels may be pushed. */ 5016struct saved_scope *scope_chain; 5017 5018/* If ID has not already been marked, add an appropriate binding to 5019 *OLD_BINDINGS. */ 5020 5021static void 5022store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings) 5023{ 5024 cxx_saved_binding *saved; 5025 5026 if (!id || !IDENTIFIER_BINDING (id)) 5027 return; 5028 5029 if (IDENTIFIER_MARKED (id)) 5030 return; 5031 5032 IDENTIFIER_MARKED (id) = 1; 5033 5034 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL); 5035 saved->identifier = id; 5036 saved->binding = IDENTIFIER_BINDING (id); 5037 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id); 5038 IDENTIFIER_BINDING (id) = NULL; 5039} 5040 5041static void 5042store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings) 5043{ 5044 tree t; 5045 5046 timevar_push (TV_NAME_LOOKUP); 5047 for (t = names; t; t = TREE_CHAIN (t)) 5048 { 5049 tree id; 5050 5051 if (TREE_CODE (t) == TREE_LIST) 5052 id = TREE_PURPOSE (t); 5053 else 5054 id = DECL_NAME (t); 5055 5056 store_binding (id, old_bindings); 5057 } 5058 timevar_pop (TV_NAME_LOOKUP); 5059} 5060 5061/* Like store_bindings, but NAMES is a vector of cp_class_binding 5062 objects, rather than a TREE_LIST. */ 5063 5064static void 5065store_class_bindings (VEC(cp_class_binding,gc) *names, 5066 VEC(cxx_saved_binding,gc) **old_bindings) 5067{ 5068 size_t i; 5069 cp_class_binding *cb; 5070 5071 timevar_push (TV_NAME_LOOKUP); 5072 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i) 5073 store_binding (cb->identifier, old_bindings); 5074 timevar_pop (TV_NAME_LOOKUP); 5075} 5076 5077void 5078push_to_top_level (void) 5079{ 5080 struct saved_scope *s; 5081 struct cp_binding_level *b; 5082 cxx_saved_binding *sb; 5083 size_t i; 5084 int need_pop; 5085 5086 timevar_push (TV_NAME_LOOKUP); 5087 s = GGC_CNEW (struct saved_scope); 5088 5089 b = scope_chain ? current_binding_level : 0; 5090 5091 /* If we're in the middle of some function, save our state. */ 5092 if (cfun) 5093 { 5094 need_pop = 1; 5095 push_function_context_to (NULL_TREE); 5096 } 5097 else 5098 need_pop = 0; 5099 5100 if (scope_chain && previous_class_level) 5101 store_class_bindings (previous_class_level->class_shadowed, 5102 &s->old_bindings); 5103 5104 /* Have to include the global scope, because class-scope decls 5105 aren't listed anywhere useful. */ 5106 for (; b; b = b->level_chain) 5107 { 5108 tree t; 5109 5110 /* Template IDs are inserted into the global level. If they were 5111 inserted into namespace level, finish_file wouldn't find them 5112 when doing pending instantiations. Therefore, don't stop at 5113 namespace level, but continue until :: . */ 5114 if (global_scope_p (b)) 5115 break; 5116 5117 store_bindings (b->names, &s->old_bindings); 5118 /* We also need to check class_shadowed to save class-level type 5119 bindings, since pushclass doesn't fill in b->names. */ 5120 if (b->kind == sk_class) 5121 store_class_bindings (b->class_shadowed, &s->old_bindings); 5122 5123 /* Unwind type-value slots back to top level. */ 5124 for (t = b->type_shadowed; t; t = TREE_CHAIN (t)) 5125 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t)); 5126 } 5127 5128 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i) 5129 IDENTIFIER_MARKED (sb->identifier) = 0; 5130 5131 s->prev = scope_chain; 5132 s->bindings = b; 5133 s->need_pop_function_context = need_pop; 5134 s->function_decl = current_function_decl; 5135 s->skip_evaluation = skip_evaluation; 5136 5137 scope_chain = s; 5138 current_function_decl = NULL_TREE; 5139 current_lang_base = VEC_alloc (tree, gc, 10); 5140 current_lang_name = lang_name_cplusplus; 5141 current_namespace = global_namespace; 5142 push_class_stack (); 5143 skip_evaluation = 0; 5144 timevar_pop (TV_NAME_LOOKUP); 5145} 5146 5147void 5148pop_from_top_level (void) 5149{ 5150 struct saved_scope *s = scope_chain; 5151 cxx_saved_binding *saved; 5152 size_t i; 5153 5154 timevar_push (TV_NAME_LOOKUP); 5155 /* Clear out class-level bindings cache. */ 5156 if (previous_class_level) 5157 invalidate_class_lookup_cache (); 5158 pop_class_stack (); 5159 5160 current_lang_base = 0; 5161 5162 scope_chain = s->prev; 5163 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i) 5164 { 5165 tree id = saved->identifier; 5166 5167 IDENTIFIER_BINDING (id) = saved->binding; 5168 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value); 5169 } 5170 5171 /* If we were in the middle of compiling a function, restore our 5172 state. */ 5173 if (s->need_pop_function_context) 5174 pop_function_context_from (NULL_TREE); 5175 current_function_decl = s->function_decl; 5176 skip_evaluation = s->skip_evaluation; 5177 timevar_pop (TV_NAME_LOOKUP); 5178} 5179 5180/* Pop off extraneous binding levels left over due to syntax errors. 5181 5182 We don't pop past namespaces, as they might be valid. */ 5183 5184void 5185pop_everything (void) 5186{ 5187 if (ENABLE_SCOPE_CHECKING) 5188 verbatim ("XXX entering pop_everything ()\n"); 5189 while (!toplevel_bindings_p ()) 5190 { 5191 if (current_binding_level->kind == sk_class) 5192 pop_nested_class (); 5193 else 5194 poplevel (0, 0, 0); 5195 } 5196 if (ENABLE_SCOPE_CHECKING) 5197 verbatim ("XXX leaving pop_everything ()\n"); 5198} 5199 5200/* Emit debugging information for using declarations and directives. 5201 If input tree is overloaded fn then emit debug info for all 5202 candidates. */ 5203 5204void 5205cp_emit_debug_info_for_using (tree t, tree context) 5206{ 5207 /* Don't try to emit any debug information if we have errors. */ 5208 if (sorrycount || errorcount) 5209 return; 5210 5211 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration 5212 of a builtin function. */ 5213 if (TREE_CODE (t) == FUNCTION_DECL 5214 && DECL_EXTERNAL (t) 5215 && DECL_BUILT_IN (t)) 5216 return; 5217 5218 /* Do not supply context to imported_module_or_decl, if 5219 it is a global namespace. */ 5220 if (context == global_namespace) 5221 context = NULL_TREE; 5222 5223 if (BASELINK_P (t)) 5224 t = BASELINK_FUNCTIONS (t); 5225 5226 /* FIXME: Handle TEMPLATE_DECLs. */ 5227 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t)) 5228 if (TREE_CODE (t) != TEMPLATE_DECL) 5229 (*debug_hooks->imported_module_or_decl) (t, context); 5230} 5231 5232#include "gt-cp-name-lookup.h" 5233