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