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