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