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